From ed4e31eb7ee210cfa833bf433bc99a0655d6a9d7 Mon Sep 17 00:00:00 2001 From: Michael Droettboom Date: Wed, 8 Jul 2026 12:34:59 -0400 Subject: [PATCH 01/25] Pin numpy in mypy to prevent error about new features (#2323) --- .pre-commit-config.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 1ac6754ae10..cd96fe925c3 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -123,7 +123,7 @@ repos: pass_filenames: false args: [--config-file=cuda_core/pyproject.toml, cuda_core/cuda/core] additional_dependencies: - - numpy + - numpy==2.4.2 - repo: https://github.com/rhysd/actionlint rev: "914e7df21a07ef503a81201c76d2b11c789d3fca" # frozen: v1.7.12 From 8b20f77aa6cd85abb8746388e30f348bb3a3894e Mon Sep 17 00:00:00 2001 From: Andy Jost Date: Wed, 8 Jul 2026 10:20:53 -0700 Subject: [PATCH 02/25] cuda.core.texture: API-style follow-up before v1.1.0 (#2292) (#2307) * cuda.core.texture: rename from_array -> from_opaque_array, element_size -> element_bytes (#2292) Addresses items 5 and 7 of the pre-v1.1.0 texture API-style review. - ResourceDescriptor.from_array -> ResourceDescriptor.from_opaque_array: the Array -> OpaqueArray rename removed "array" ambiguity, so the factory name should follow suit. - OpaqueArray.element_size -> OpaqueArray.element_bytes: the accessor returns a byte count, matching the _bytes convention already used by size_bytes and pitch_bytes. Both are renames of APIs not yet released (first ship in v1.1.0), so no deprecation shim is needed; the new names carry a versionadded:: 1.1.0 note. Call sites in the texture tests and the four texture examples are updated. * cuda.core.texture: move texture enums to cuda.core.typing as StrEnum (#2292) Addresses item 4 of the pre-v1.1.0 texture API-style review. The texture/surface enums were IntEnum subclasses backed by cydriver.CU_* values, defined in the cuda.core.texture root namespace and lacking the Type suffix. Every other cuda.core enum unified pre-1.0 lives in cuda.core.typing as a StrEnum with semantic string values and a Type suffix. Bring the texture enums in line: - ArrayFormat -> cuda.core.typing.ArrayFormatType - AddressMode -> cuda.core.typing.AddressModeType - FilterMode -> cuda.core.typing.FilterModeType - ReadMode -> cuda.core.typing.ReadModeType Internally the driver integer values are still needed, so _array and _texture carry private CU<->StrEnum bridge maps; OpaqueArray/MipmappedArray keep storing the driver int and convert on the .format boundary. Per the enum convention, plain strings are accepted anywhere an enum is expected (via _normalize_enum / _normalize_array_format), and invalid values raise ValueError. TextureDescriptor gains a __post_init__ that normalizes its filter_mode/read_mode/ mipmap_filter_mode fields at construction. Enums are dropped from the cuda.core.texture __all__ and documented under cuda.core.typing. Tests, examples, and docs are updated to the new names; the negative-path tests that previously expected a TypeError at texture creation now expect a ValueError at descriptor construction. * cuda.core.texture: accept NumPy dtypes for array format (#2292) Addresses item 3 of the pre-v1.1.0 texture API-style review. TensorMapDescriptorOptions.data_type already accepts NumPy dtype objects and keeps its enum as a fallback. Apply the same precedent to the texture format argument: OpaqueArray / MipmappedArray creation and ResourceDescriptor.from_linear / from_pitch2d now accept an ArrayFormatType, a plain str, or a NumPy dtype object (anything numpy.dtype() accepts). Each ArrayFormatType value is already spelled as a NumPy dtype name, so the eight formats map 1:1 via a new _NUMPY_DTYPE_TO_ARRAYFORMAT table. All four factories funnel through _validate_format_channels -> _normalize_array_format, so dtype support is added in one place. ml_dtypes is intentionally not imported: every current format is a standard NumPy dtype, and the ml_dtypes path only becomes relevant if/when a bfloat16 format is added. * cuda.core.texture: rename TextureDescriptor -> TextureObjectOptions (#2292) Addresses the rename portion of item 2 of the pre-v1.1.0 texture API-style review. CUDA_TEXTURE_DESC is pure creation input (it cannot be queried back from a texture object), so "descriptor" borrowed the driver naming inappropriately. TextureObjectOptions matches the XxxOptions convention used throughout cuda.core (StreamOptions, EventOptions, TensorMapDescriptorOptions, ...). Pure rename of the dataclass and all references across the implementation, stubs, __init__ __all__, docs, tests, and examples. The from_descriptor texture_descriptor= keyword is left untouched here; the whole creation entry point is replaced by Device.create_texture_object(*, resource, options) in a later commit. * cuda.core.texture: add Device.create_opaque_array / create_mipmapped_array (#2292) Addresses item 1 (array allocation) and item 2 (Options dataclasses) of the pre-v1.1.0 texture API-style review. Every other user-allocatable resource in cuda.core is created via Device.create_* (create_stream, create_event, ...) with an XxxOptions dataclass. The texture arrays used per-type classmethod factories (OpaqueArray.from_descriptor, MipmappedArray.from_descriptor) with loose kwargs instead. Move them in line: - add OpaqueArrayOptions and MipmappedArrayOptions dataclasses (validated in __post_init__, mirroring TensorMapDescriptorOptions); - add Device.create_opaque_array(options) and Device.create_mipmapped_array( options), which gate on _check_context_initialized() and delegate to private module factories that bind to the current device (same pattern as create_event / create_graph_builder); - remove the OpaqueArray.from_descriptor / MipmappedArray.from_descriptor classmethods; the private _from_handle graphics-interop path is retained. New entry points carry versionadded:: 1.1.0. Options are exported from cuda.core.texture and documented in api.rst. Tests and the texture examples are updated to Device().create_*_array((...)). * cuda.core.texture: add Device.create_texture_object / create_surface_object (#2292) Addresses item 1 (object creation) and item 6 (drop SurfaceObject.from_array sugar) of the pre-v1.1.0 texture API-style review, completing the move to the Device.create_* allocation shape. - add Device.create_texture_object(*, resource, options) and Device.create_surface_object(*, resource), gating on _check_context_initialized() and delegating to private module factories that bind to the current device (same pattern as create_opaque_array); - remove TextureObject.from_descriptor, SurfaceObject.from_descriptor, and the speculative SurfaceObject.from_array sugar (a surface is now built from an explicit ResourceDescriptor.from_opaque_array(...) like every other backing); - rename the sampling-options argument from texture_descriptor to options on the new entry point, matching the create_* + XxxOptions convention (the queryable TextureObject.texture_descriptor property is unchanged). New entry points carry versionadded:: 1.1.0. Tests, examples, and api.rst are updated; a make_surface() helper mirrors make_texture() in the fluid example. * cuda.core.texture: apply pre-commit (ruff, ruff-format, stubgen) (#2292) Mechanical pre-commit pass over the #2292 texture API series: - ruff: drop now-unused imports in the texture example/test files and remove an unused _normalize_array_format import from _texture.pyx (cython-lint); - ruff-format: reflow the rewritten call sites in the tests and examples; - stubgen-pyx: regenerate the .pyi stubs from the updated .pyx sources. * cuda.core.texture: address API-review follow-ups (#2292) Apply the review findings from the texture API-style follow-up: - Rename TextureObject.texture_descriptor -> options (and the internal _texture_desc slot -> _options) to drop the borrowed "descriptor" naming, matching the TextureObjectOptions rename. - Make options a required argument on create_opaque_array / create_mipmapped_array (shape/format/num_channels have no defaults), so omitting it raises a clear error instead of a raw dataclass TypeError. create_texture_object keeps options=None (all-default sampling state). - Add return and resource/options type annotations to the four Device.create_* texture factories via a TYPE_CHECKING texture import (mirroring the existing GraphBuilder pattern). - Clarify in the create_* docstrings that the resource is created in the current CUDA context (call set_current first), mirroring create_stream / create_event. - Add versionadded:: 1.1.0 to OpaqueArrayOptions, MipmappedArrayOptions, TextureObjectOptions, and the new options property. - Fix a stale negative-path test whose regex no longer matched the shared check_or_create_options message; rename stale from_descriptor test names to create_*; realign the gl_interop_fluid API-MAP comment table after the enum renames. - Regenerate .pyi stubs. * cuda.core.texture: fix stale address_mode entry-rejection test (#2292) The StrEnum migration (item 4 of #2292) makes a plain str acceptable anywhere an AddressModeType is expected. A bad tuple entry like "bad" is therefore a valid *type* but an invalid *value*, so _normalize_enum rejects it with a ValueError (naming the offending position address_mode[1]), not a TypeError. Update the test to assert ValueError and rename it to test_address_mode_rejects_invalid_entry. This is the second of the two CI failures on PR #2307; the first (the stale options-type message) was fixed in the previous commit. * cuda.core.texture: register new StrEnums in enum-coverage test (#2292) test_enum_coverage.py::test_all_str_enums_in_cases requires every StrEnum in cuda.core to be declared either in _CASES (bound to a cuda_binding enum) or in _UNBOUND_STR_ENUMS. The four texture enums moved into cuda.core.typing (item 4 of #2292) were not registered, failing that guard. - AddressModeType / FilterModeType are 1:1 wrappers of CUaddress_mode / CUfilter_mode, so add mapping=None _CASES entries (count-check only; the texture mapping dicts store cydriver-derived ints, not driver. members, so the isinstance-based mapping check does not apply). - ArrayFormatType exposes only the 8 NumPy-representable formats out of CUarray_format's ~67 members, so it is a curated subset rather than a 1:1 wrapper -> _UNBOUND_STR_ENUMS. - ReadModeType maps to the CU_TRSF_READ_AS_INTEGER flag bit, not a CUenum -> _UNBOUND_STR_ENUMS. This is the third local test failure; the other two (stale texture negative-path tests) were fixed in the two preceding commits. * cuda.core.texture: add versionadded markers and widen enum str annotations Address review feedback (Ralf): - Add ``.. versionadded:: 1.1.0`` to the four new texture enums in typing.py (ArrayFormatType, AddressModeType, FilterModeType, ReadModeType) and to the texture classes that lacked a class-level marker (ResourceDescriptor, TextureObject, OpaqueArray, MipmappedArray, SurfaceObject). Remove the redundant method-level markers now covered at class level. - Widen the enum-bearing TextureObjectOptions field annotations to include ``str`` (address_mode, filter_mode, read_mode, mipmap_filter_mode), matching the runtime string coercion this PR adds and existing convention elsewhere in cuda.core. Note "Plain strings are accepted" on the affected fields. - Regenerate .pyi stubs. --- cuda_core/cuda/core/_device.pyi | 113 ++++ cuda_core/cuda/core/_device.pyx | 137 +++++ cuda_core/cuda/core/texture/__init__.py | 25 +- cuda_core/cuda/core/texture/_array.pyi | 116 ++-- cuda_core/cuda/core/texture/_array.pyx | 260 +++++---- .../cuda/core/texture/_mipmapped_array.pyi | 80 +-- .../cuda/core/texture/_mipmapped_array.pyx | 176 +++--- cuda_core/cuda/core/texture/_surface.pyi | 34 +- cuda_core/cuda/core/texture/_surface.pyx | 102 ++-- cuda_core/cuda/core/texture/_texture.pxd | 2 +- cuda_core/cuda/core/texture/_texture.pyi | 116 ++-- cuda_core/cuda/core/texture/_texture.pyx | 430 ++++++++------- cuda_core/cuda/core/typing.py | 77 +++ cuda_core/docs/source/api.rst | 28 +- cuda_core/docs/source/api_private.rst | 4 + cuda_core/examples/gl_interop_fluid.py | 104 ++-- .../gl_interop_fluid_numba_cuda_mlir.py | 4 +- cuda_core/examples/gl_interop_mipmap_lod.py | 60 ++- cuda_core/examples/texture_sample.py | 39 +- cuda_core/tests/test_enum_coverage.py | 29 + cuda_core/tests/test_texture_surface.py | 508 ++++++++++-------- 21 files changed, 1515 insertions(+), 929 deletions(-) diff --git a/cuda_core/cuda/core/_device.pyi b/cuda_core/cuda/core/_device.pyi index d5fdc5d7551..14893fbd3c0 100644 --- a/cuda_core/cuda/core/_device.pyi +++ b/cuda_core/cuda/core/_device.pyi @@ -12,6 +12,10 @@ from cuda.core._memory._buffer import Buffer, MemoryResource from cuda.core._stream import IsStreamType, Stream from cuda.core._utils.cuda_utils import ComputeCapability from cuda.core.graph import GraphBuilder +from cuda.core.texture import (MipmappedArray, MipmappedArrayOptions, + OpaqueArray, OpaqueArrayOptions, + ResourceDescriptor, SurfaceObject, + TextureObject, TextureObjectOptions) class DeviceProperties: @@ -909,5 +913,114 @@ class Device: Newly created graph builder object. """ + + def create_opaque_array(self, options: OpaqueArrayOptions) -> OpaqueArray: + """Create an :obj:`~cuda.core.texture.OpaqueArray` on the current device. + + Allocates an opaque, hardware-laid-out CUDA array for texture/surface + access. The array is created in the current CUDA context, so make this + device current with :meth:`set_current` before calling (mirroring + :meth:`create_stream` / :meth:`create_event`). + + Note + ---- + Device must be initialized. + + Parameters + ---------- + options : :obj:`~cuda.core.texture.OpaqueArrayOptions` + Allocation options (shape, format, channels, surface flag). + + Returns + ------- + :obj:`~cuda.core.texture.OpaqueArray` + Newly created opaque array. + + .. versionadded:: 1.1.0 + """ + + def create_mipmapped_array(self, options: MipmappedArrayOptions) -> MipmappedArray: + """Create a :obj:`~cuda.core.texture.MipmappedArray` on the current device. + + Allocates a mipmapped CUDA array for texture/surface access across + levels. The array is created in the current CUDA context, so make this + device current with :meth:`set_current` before calling (mirroring + :meth:`create_stream` / :meth:`create_event`). + + Note + ---- + Device must be initialized. + + Parameters + ---------- + options : :obj:`~cuda.core.texture.MipmappedArrayOptions` + Allocation options (shape, format, channels, levels, surface flag). + + Returns + ------- + :obj:`~cuda.core.texture.MipmappedArray` + Newly created mipmapped array. + + .. versionadded:: 1.1.0 + """ + + def create_texture_object(self, *, resource: ResourceDescriptor, options: TextureObjectOptions | None=None) -> TextureObject: + """Create a :obj:`~cuda.core.texture.TextureObject` on the current device. + + Binds a resource (an :obj:`~cuda.core.texture.OpaqueArray` / + :obj:`~cuda.core.texture.MipmappedArray` / linear or pitch2d + :obj:`~cuda.core.Buffer`, wrapped in a + :obj:`~cuda.core.texture.ResourceDescriptor`) as a bindless texture for + kernel-side sampled reads. The object is created in the current CUDA + context, so make this device current with :meth:`set_current` before + calling (mirroring :meth:`create_stream` / :meth:`create_event`). + + Note + ---- + Device must be initialized. + + Parameters + ---------- + resource : :obj:`~cuda.core.texture.ResourceDescriptor` + The memory backing the texture. + options : :obj:`~cuda.core.texture.TextureObjectOptions` + Sampling state (address/filter/read modes, normalization, etc.). + + Returns + ------- + :obj:`~cuda.core.texture.TextureObject` + Newly created texture object. + + .. versionadded:: 1.1.0 + """ + + def create_surface_object(self, *, resource: ResourceDescriptor) -> SurfaceObject: + """Create a :obj:`~cuda.core.texture.SurfaceObject` on the current device. + + Binds an :obj:`~cuda.core.texture.OpaqueArray` (via a + :obj:`~cuda.core.texture.ResourceDescriptor`) as a bindless surface for + kernel-side typed load/store. The backing array must have been created + with ``is_surface_load_store=True``. The object is created in the + current CUDA context, so make this device current with + :meth:`set_current` before calling (mirroring :meth:`create_stream` / + :meth:`create_event`). + + Note + ---- + Device must be initialized. + + Parameters + ---------- + resource : :obj:`~cuda.core.texture.ResourceDescriptor` + Must wrap an :obj:`~cuda.core.texture.OpaqueArray` allocated with + ``is_surface_load_store=True``. + + Returns + ------- + :obj:`~cuda.core.texture.SurfaceObject` + Newly created surface object. + + .. versionadded:: 1.1.0 + """ _tls = threading.local() _lock = threading.Lock() \ No newline at end of file diff --git a/cuda_core/cuda/core/_device.pyx b/cuda_core/cuda/core/_device.pyx index 7b27884b312..ea5bb62cc1b 100644 --- a/cuda_core/cuda/core/_device.pyx +++ b/cuda_core/cuda/core/_device.pyx @@ -44,6 +44,16 @@ from typing import TYPE_CHECKING if TYPE_CHECKING: import cuda.core.system # no-cython-lint from cuda.core.graph import GraphBuilder + from cuda.core.texture import ( + MipmappedArray, + MipmappedArrayOptions, + OpaqueArray, + OpaqueArrayOptions, + ResourceDescriptor, + SurfaceObject, + TextureObject, + TextureObjectOptions, + ) # TODO: I prefer to type these as "cdef object" and avoid accessing them from within Python, # but it seems it is very convenient to expose them for testing purposes... @@ -1456,6 +1466,133 @@ class Device: self._check_context_initialized() return GraphBuilder._init(self.create_stream()) + def create_opaque_array(self, options: OpaqueArrayOptions) -> OpaqueArray: + """Create an :obj:`~cuda.core.texture.OpaqueArray` on the current device. + + Allocates an opaque, hardware-laid-out CUDA array for texture/surface + access. The array is created in the current CUDA context, so make this + device current with :meth:`set_current` before calling (mirroring + :meth:`create_stream` / :meth:`create_event`). + + Note + ---- + Device must be initialized. + + Parameters + ---------- + options : :obj:`~cuda.core.texture.OpaqueArrayOptions` + Allocation options (shape, format, channels, surface flag). + + Returns + ------- + :obj:`~cuda.core.texture.OpaqueArray` + Newly created opaque array. + + .. versionadded:: 1.1.0 + """ + from cuda.core.texture._array import _create_opaque_array + + self._check_context_initialized() + return _create_opaque_array(options) + + def create_mipmapped_array(self, options: MipmappedArrayOptions) -> MipmappedArray: + """Create a :obj:`~cuda.core.texture.MipmappedArray` on the current device. + + Allocates a mipmapped CUDA array for texture/surface access across + levels. The array is created in the current CUDA context, so make this + device current with :meth:`set_current` before calling (mirroring + :meth:`create_stream` / :meth:`create_event`). + + Note + ---- + Device must be initialized. + + Parameters + ---------- + options : :obj:`~cuda.core.texture.MipmappedArrayOptions` + Allocation options (shape, format, channels, levels, surface flag). + + Returns + ------- + :obj:`~cuda.core.texture.MipmappedArray` + Newly created mipmapped array. + + .. versionadded:: 1.1.0 + """ + from cuda.core.texture._mipmapped_array import _create_mipmapped_array + + self._check_context_initialized() + return _create_mipmapped_array(options) + + def create_texture_object( + self, *, resource: ResourceDescriptor, options: TextureObjectOptions | None = None + ) -> TextureObject: + """Create a :obj:`~cuda.core.texture.TextureObject` on the current device. + + Binds a resource (an :obj:`~cuda.core.texture.OpaqueArray` / + :obj:`~cuda.core.texture.MipmappedArray` / linear or pitch2d + :obj:`~cuda.core.Buffer`, wrapped in a + :obj:`~cuda.core.texture.ResourceDescriptor`) as a bindless texture for + kernel-side sampled reads. The object is created in the current CUDA + context, so make this device current with :meth:`set_current` before + calling (mirroring :meth:`create_stream` / :meth:`create_event`). + + Note + ---- + Device must be initialized. + + Parameters + ---------- + resource : :obj:`~cuda.core.texture.ResourceDescriptor` + The memory backing the texture. + options : :obj:`~cuda.core.texture.TextureObjectOptions` + Sampling state (address/filter/read modes, normalization, etc.). + + Returns + ------- + :obj:`~cuda.core.texture.TextureObject` + Newly created texture object. + + .. versionadded:: 1.1.0 + """ + from cuda.core.texture._texture import _create_texture_object + + self._check_context_initialized() + return _create_texture_object(resource, options) + + def create_surface_object(self, *, resource: ResourceDescriptor) -> SurfaceObject: + """Create a :obj:`~cuda.core.texture.SurfaceObject` on the current device. + + Binds an :obj:`~cuda.core.texture.OpaqueArray` (via a + :obj:`~cuda.core.texture.ResourceDescriptor`) as a bindless surface for + kernel-side typed load/store. The backing array must have been created + with ``is_surface_load_store=True``. The object is created in the + current CUDA context, so make this device current with + :meth:`set_current` before calling (mirroring :meth:`create_stream` / + :meth:`create_event`). + + Note + ---- + Device must be initialized. + + Parameters + ---------- + resource : :obj:`~cuda.core.texture.ResourceDescriptor` + Must wrap an :obj:`~cuda.core.texture.OpaqueArray` allocated with + ``is_surface_load_store=True``. + + Returns + ------- + :obj:`~cuda.core.texture.SurfaceObject` + Newly created surface object. + + .. versionadded:: 1.1.0 + """ + from cuda.core.texture._surface import _create_surface_object + + self._check_context_initialized() + return _create_surface_object(resource) + cdef inline int Device_ensure_cuda_initialized() except? -1: """Initialize CUDA driver and check version compatibility (once per process).""" diff --git a/cuda_core/cuda/core/texture/__init__.py b/cuda_core/cuda/core/texture/__init__.py index e4414ed28ad..cd3e355f324 100644 --- a/cuda_core/cuda/core/texture/__init__.py +++ b/cuda_core/cuda/core/texture/__init__.py @@ -10,30 +10,31 @@ Import these types from here, e.g.:: - from cuda.core.texture import OpaqueArray, TextureObject, TextureDescriptor + from cuda.core.texture import OpaqueArray, TextureObject, TextureObjectOptions + +The associated enumerations (:class:`~cuda.core.typing.ArrayFormatType`, +:class:`~cuda.core.typing.AddressModeType`, +:class:`~cuda.core.typing.FilterModeType`, +:class:`~cuda.core.typing.ReadModeType`) live in :mod:`cuda.core.typing` +alongside the other ``cuda.core`` enumerations. """ -from cuda.core.texture._array import ArrayFormat, OpaqueArray -from cuda.core.texture._mipmapped_array import MipmappedArray +from cuda.core.texture._array import OpaqueArray, OpaqueArrayOptions +from cuda.core.texture._mipmapped_array import MipmappedArray, MipmappedArrayOptions from cuda.core.texture._surface import SurfaceObject from cuda.core.texture._texture import ( - AddressMode, - FilterMode, - ReadMode, ResourceDescriptor, - TextureDescriptor, TextureObject, + TextureObjectOptions, ) __all__ = [ - "AddressMode", - "ArrayFormat", - "FilterMode", "MipmappedArray", + "MipmappedArrayOptions", "OpaqueArray", - "ReadMode", + "OpaqueArrayOptions", "ResourceDescriptor", "SurfaceObject", - "TextureDescriptor", "TextureObject", + "TextureObjectOptions", ] diff --git a/cuda_core/cuda/core/texture/_array.pyi b/cuda_core/cuda/core/texture/_array.pyi index 75dadb46d98..380c2fe1c10 100644 --- a/cuda_core/cuda/core/texture/_array.pyi +++ b/cuda_core/cuda/core/texture/_array.pyi @@ -2,24 +2,41 @@ from __future__ import annotations -from enum import IntEnum +from dataclasses import dataclass +import numpy from cuda.bindings import cydriver - - -class ArrayFormat(IntEnum): - """Element format for a :class:`OpaqueArray` allocation. - - Mirrors ``CUarray_format`` from the CUDA driver API. +from cuda.core.typing import ArrayFormatType + + +@dataclass +class OpaqueArrayOptions: + """Options for :meth:`cuda.core.Device.create_opaque_array`. + + Attributes + ---------- + shape : tuple of int + ``(width,)``, ``(width, height)``, or ``(width, height, depth)`` in + elements. + format : ArrayFormatType, str, or numpy.dtype + Element format. Accepts an :class:`~cuda.core.typing.ArrayFormatType`, + a plain string (e.g. ``"float32"``), or a NumPy dtype object. + num_channels : int + Channels per element. Must be 1, 2, or 4. + is_surface_load_store : bool + If True, allocate with ``CUDA_ARRAY3D_SURFACE_LDST`` so the array can be + bound as a :class:`~cuda.core.texture.SurfaceObject` for kernel-side + writes. Default False. + + .. versionadded:: 1.1.0 """ - UINT8 = cydriver.CU_AD_FORMAT_UNSIGNED_INT8 - UINT16 = cydriver.CU_AD_FORMAT_UNSIGNED_INT16 - UINT32 = cydriver.CU_AD_FORMAT_UNSIGNED_INT32 - INT8 = cydriver.CU_AD_FORMAT_SIGNED_INT8 - INT16 = cydriver.CU_AD_FORMAT_SIGNED_INT16 - INT32 = cydriver.CU_AD_FORMAT_SIGNED_INT32 - FLOAT16 = cydriver.CU_AD_FORMAT_HALF - FLOAT32 = cydriver.CU_AD_FORMAT_FLOAT + shape: tuple[int, ...] + format: object + num_channels: int + is_surface_load_store: bool = False + + def __post_init__(self): + ... class OpaqueArray: """An opaque, hardware-laid-out GPU allocation for texture/surface access. @@ -38,9 +55,11 @@ class OpaqueArray: linear :class:`Buffer` yourself (e.g. ``mr.allocate(arr.size_bytes, stream=s)``) and copy. - Construct via :meth:`from_descriptor`. Only plain 1D/2D/3D allocations are - supported in this initial version; layered/cubemap/sparse variants will - follow once their shape semantics are settled. + Construct via :meth:`cuda.core.Device.create_opaque_array`. Only plain + 1D/2D/3D allocations are supported in this initial version; layered/cubemap/ + sparse variants will follow once their shape semantics are settled. + + .. versionadded:: 1.1.0 """ def close(self): @@ -55,29 +74,6 @@ class OpaqueArray: def __init__(self, *args, **kwargs): ... - @classmethod - def from_descriptor(cls, *, shape, format, num_channels, is_surface_load_store=False): - """Allocate a new CUDA array. - - Parameters - ---------- - shape : tuple of int - ``(width,)``, ``(width, height)``, or ``(width, height, depth)`` - in elements. - format : ArrayFormat - Element format. - num_channels : int - Channels per element. Must be 1, 2, or 4. - is_surface_load_store : bool - If True, allocate with ``CUDA_ARRAY3D_SURFACE_LDST`` so the array - can be bound as a :class:`SurfaceObject` for kernel-side writes. - Default False. - - Returns - ------- - OpaqueArray - """ - @classmethod def _from_handle(cls, handle: int, owning: bool, *, device_id=None): """Wrap an externally-allocated ``CUarray``. @@ -98,14 +94,14 @@ class OpaqueArray: @property def format(self): - """The element :class:`ArrayFormat`.""" + """The element :class:`~cuda.core.typing.ArrayFormatType`.""" @property def num_channels(self): """Channels per element (1, 2, or 4).""" @property - def element_size(self): + def element_bytes(self): """Bytes per element (format size * channels).""" @property @@ -153,7 +149,7 @@ class OpaqueArray: @property def size_bytes(self): - """Total bytes of array storage (``prod(shape) * element_size``).""" + """Total bytes of array storage (``prod(shape) * element_bytes``).""" def __enter__(self): ... @@ -163,12 +159,38 @@ class OpaqueArray: def __repr__(self): ... -_FORMAT_ELEM_SIZE = {int(ArrayFormat.UINT8): 1, int(ArrayFormat.INT8): 1, int(ArrayFormat.UINT16): 2, int(ArrayFormat.INT16): 2, int(ArrayFormat.FLOAT16): 2, int(ArrayFormat.UINT32): 4, int(ArrayFormat.INT32): 4, int(ArrayFormat.FLOAT32): 4} +_ARRAYFORMAT_TO_CU = {ArrayFormatType.UINT8: int(cydriver.CU_AD_FORMAT_UNSIGNED_INT8), ArrayFormatType.UINT16: int(cydriver.CU_AD_FORMAT_UNSIGNED_INT16), ArrayFormatType.UINT32: int(cydriver.CU_AD_FORMAT_UNSIGNED_INT32), ArrayFormatType.INT8: int(cydriver.CU_AD_FORMAT_SIGNED_INT8), ArrayFormatType.INT16: int(cydriver.CU_AD_FORMAT_SIGNED_INT16), ArrayFormatType.INT32: int(cydriver.CU_AD_FORMAT_SIGNED_INT32), ArrayFormatType.FLOAT16: int(cydriver.CU_AD_FORMAT_HALF), ArrayFormatType.FLOAT32: int(cydriver.CU_AD_FORMAT_FLOAT)} +_CU_TO_ARRAYFORMAT = {cu: fmt for fmt, cu in _ARRAYFORMAT_TO_CU.items()} +_NUMPY_DTYPE_TO_ARRAYFORMAT = {numpy.dtype(fmt.value): fmt for fmt in ArrayFormatType} +_FORMAT_ELEM_SIZE = {_ARRAYFORMAT_TO_CU[ArrayFormatType.UINT8]: 1, _ARRAYFORMAT_TO_CU[ArrayFormatType.INT8]: 1, _ARRAYFORMAT_TO_CU[ArrayFormatType.UINT16]: 2, _ARRAYFORMAT_TO_CU[ArrayFormatType.INT16]: 2, _ARRAYFORMAT_TO_CU[ArrayFormatType.FLOAT16]: 2, _ARRAYFORMAT_TO_CU[ArrayFormatType.UINT32]: 4, _ARRAYFORMAT_TO_CU[ArrayFormatType.INT32]: 4, _ARRAYFORMAT_TO_CU[ArrayFormatType.FLOAT32]: 4} + +def _normalize_array_format(format): + """Coerce ``format`` to an :class:`ArrayFormatType`. + + Accepts, in order of preference: + + * an :class:`ArrayFormatType`; + * a plain ``str`` naming one of its values (e.g. ``"float32"``); + * a NumPy dtype object (or anything ``numpy.dtype()`` accepts, such as + ``numpy.float32``) whose canonical dtype maps 1:1 to one of the eight + supported formats. + + Raises :class:`ValueError` on anything else.""" def _validate_format_channels(format, num_channels): """Validate the ``(format, num_channels)`` pair shared by the array, - mipmap, and texture factories. Raises on an invalid combination.""" + mipmap, and texture factories. Returns the normalized + :class:`ArrayFormatType`. Raises on an invalid combination.""" def _validate_array_shape(shape): """Coerce ``shape`` to a tuple of ints and validate rank (1-3) and that - every extent is >= 1. Returns the normalized tuple.""" \ No newline at end of file + every extent is >= 1. Returns the normalized tuple.""" + +def _create_opaque_array(options): + """Allocate a new :class:`OpaqueArray` on the current device. + + Backs :meth:`cuda.core.Device.create_opaque_array`. ``options`` is an + :class:`OpaqueArrayOptions` (or a mapping accepted by it); it is validated + at construction, so ``shape`` is already a normalized tuple and ``format`` + an :class:`~cuda.core.typing.ArrayFormatType`. + """ \ No newline at end of file diff --git a/cuda_core/cuda/core/texture/_array.pyx b/cuda_core/cuda/core/texture/_array.pyx index 82a08b045dc..0a1cb671daf 100644 --- a/cuda_core/cuda/core/texture/_array.pyx +++ b/cuda_core/cuda/core/texture/_array.pyx @@ -25,44 +25,100 @@ from cuda.core._utils.cuda_utils cimport ( _get_current_device_id, ) -from enum import IntEnum - +import numpy + +from dataclasses import dataclass + +from cuda.core._utils.cuda_utils import check_or_create_options +from cuda.core.typing import ArrayFormatType + + +# Bridge between the public ArrayFormatType StrEnum and the driver +# CUarray_format integer values. OpaqueArray stores the driver int internally +# (see ._format), so all conversions funnel through these two maps. +_ARRAYFORMAT_TO_CU = { + ArrayFormatType.UINT8: int(cydriver.CU_AD_FORMAT_UNSIGNED_INT8), + ArrayFormatType.UINT16: int(cydriver.CU_AD_FORMAT_UNSIGNED_INT16), + ArrayFormatType.UINT32: int(cydriver.CU_AD_FORMAT_UNSIGNED_INT32), + ArrayFormatType.INT8: int(cydriver.CU_AD_FORMAT_SIGNED_INT8), + ArrayFormatType.INT16: int(cydriver.CU_AD_FORMAT_SIGNED_INT16), + ArrayFormatType.INT32: int(cydriver.CU_AD_FORMAT_SIGNED_INT32), + ArrayFormatType.FLOAT16: int(cydriver.CU_AD_FORMAT_HALF), + ArrayFormatType.FLOAT32: int(cydriver.CU_AD_FORMAT_FLOAT), +} +_CU_TO_ARRAYFORMAT = {cu: fmt for fmt, cu in _ARRAYFORMAT_TO_CU.items()} -class ArrayFormat(IntEnum): - """Element format for a :class:`OpaqueArray` allocation. - Mirrors ``CUarray_format`` from the CUDA driver API. - """ - UINT8 = cydriver.CU_AD_FORMAT_UNSIGNED_INT8 - UINT16 = cydriver.CU_AD_FORMAT_UNSIGNED_INT16 - UINT32 = cydriver.CU_AD_FORMAT_UNSIGNED_INT32 - INT8 = cydriver.CU_AD_FORMAT_SIGNED_INT8 - INT16 = cydriver.CU_AD_FORMAT_SIGNED_INT16 - INT32 = cydriver.CU_AD_FORMAT_SIGNED_INT32 - FLOAT16 = cydriver.CU_AD_FORMAT_HALF - FLOAT32 = cydriver.CU_AD_FORMAT_FLOAT +# Every ArrayFormatType value is spelled as a NumPy dtype name, so the eight +# formats map 1:1 to NumPy dtypes. This lets callers pass a dtype object (or +# anything numpy.dtype() accepts) instead of the enum, matching the precedent +# set by TensorMapDescriptorOptions.data_type. +_NUMPY_DTYPE_TO_ARRAYFORMAT = { + numpy.dtype(fmt.value): fmt for fmt in ArrayFormatType +} -# Bytes per element (single channel) for each format. +# Bytes per element (single channel), keyed by the driver CUarray_format int. _FORMAT_ELEM_SIZE = { - int(ArrayFormat.UINT8): 1, - int(ArrayFormat.INT8): 1, - int(ArrayFormat.UINT16): 2, - int(ArrayFormat.INT16): 2, - int(ArrayFormat.FLOAT16): 2, - int(ArrayFormat.UINT32): 4, - int(ArrayFormat.INT32): 4, - int(ArrayFormat.FLOAT32): 4, + _ARRAYFORMAT_TO_CU[ArrayFormatType.UINT8]: 1, + _ARRAYFORMAT_TO_CU[ArrayFormatType.INT8]: 1, + _ARRAYFORMAT_TO_CU[ArrayFormatType.UINT16]: 2, + _ARRAYFORMAT_TO_CU[ArrayFormatType.INT16]: 2, + _ARRAYFORMAT_TO_CU[ArrayFormatType.FLOAT16]: 2, + _ARRAYFORMAT_TO_CU[ArrayFormatType.UINT32]: 4, + _ARRAYFORMAT_TO_CU[ArrayFormatType.INT32]: 4, + _ARRAYFORMAT_TO_CU[ArrayFormatType.FLOAT32]: 4, } +def _normalize_array_format(format): + """Coerce ``format`` to an :class:`ArrayFormatType`. + + Accepts, in order of preference: + + * an :class:`ArrayFormatType`; + * a plain ``str`` naming one of its values (e.g. ``"float32"``); + * a NumPy dtype object (or anything ``numpy.dtype()`` accepts, such as + ``numpy.float32``) whose canonical dtype maps 1:1 to one of the eight + supported formats. + + Raises :class:`ValueError` on anything else.""" + if isinstance(format, ArrayFormatType): + return format + if isinstance(format, str): + try: + return ArrayFormatType(format) + except ValueError as e: + valid = ", ".join(repr(f.value) for f in ArrayFormatType) + raise ValueError( + f"format must be an ArrayFormatType or one of {{{valid}}}, got {format!r}" + ) from e + # Fall back to interpreting ``format`` as a NumPy dtype (dtype object, + # scalar type, etc.). Unknown dtypes are reported against the supported set. + try: + dt = numpy.dtype(format) + except TypeError as e: + raise ValueError( + f"format must be an ArrayFormatType, str, or NumPy dtype, got {format!r}" + ) from e + try: + return _NUMPY_DTYPE_TO_ARRAYFORMAT[dt] + except KeyError as e: + valid = ", ".join(repr(f.value) for f in ArrayFormatType) + raise ValueError( + f"NumPy dtype {dt!r} has no ArrayFormatType equivalent; " + f"supported formats: {{{valid}}}" + ) from e + + def _validate_format_channels(format, num_channels): """Validate the ``(format, num_channels)`` pair shared by the array, - mipmap, and texture factories. Raises on an invalid combination.""" - if not isinstance(format, ArrayFormat): - raise TypeError(f"format must be an ArrayFormat, got {type(format).__name__}") + mipmap, and texture factories. Returns the normalized + :class:`ArrayFormatType`. Raises on an invalid combination.""" + fmt = _normalize_array_format(format) if isinstance(num_channels, bool) or num_channels not in (1, 2, 4): raise ValueError(f"num_channels must be 1, 2, or 4, got {num_channels!r}") + return fmt def _validate_array_shape(shape): @@ -80,6 +136,38 @@ def _validate_array_shape(shape): return shape_t +@dataclass +class OpaqueArrayOptions: + """Options for :meth:`cuda.core.Device.create_opaque_array`. + + Attributes + ---------- + shape : tuple of int + ``(width,)``, ``(width, height)``, or ``(width, height, depth)`` in + elements. + format : ArrayFormatType, str, or numpy.dtype + Element format. Accepts an :class:`~cuda.core.typing.ArrayFormatType`, + a plain string (e.g. ``"float32"``), or a NumPy dtype object. + num_channels : int + Channels per element. Must be 1, 2, or 4. + is_surface_load_store : bool + If True, allocate with ``CUDA_ARRAY3D_SURFACE_LDST`` so the array can be + bound as a :class:`~cuda.core.texture.SurfaceObject` for kernel-side + writes. Default False. + + .. versionadded:: 1.1.0 + """ + + shape: tuple[int, ...] + format: object + num_channels: int + is_surface_load_store: bool = False + + def __post_init__(self): + self.format = _validate_format_channels(self.format, self.num_channels) + self.shape = _validate_array_shape(self.shape) + + cdef void _fill_array_endpoint( cydriver.CUDA_MEMCPY3D* p, OpaqueArray arr, bint is_src ) noexcept: @@ -245,71 +333,19 @@ cdef class OpaqueArray: linear :class:`Buffer` yourself (e.g. ``mr.allocate(arr.size_bytes, stream=s)``) and copy. - Construct via :meth:`from_descriptor`. Only plain 1D/2D/3D allocations are - supported in this initial version; layered/cubemap/sparse variants will - follow once their shape semantics are settled. + Construct via :meth:`cuda.core.Device.create_opaque_array`. Only plain + 1D/2D/3D allocations are supported in this initial version; layered/cubemap/ + sparse variants will follow once their shape semantics are settled. + + .. versionadded:: 1.1.0 """ def __init__(self, *args, **kwargs): raise RuntimeError( - "OpaqueArray cannot be instantiated directly. Use OpaqueArray.from_descriptor()." + "OpaqueArray cannot be instantiated directly. " + "Use Device.create_opaque_array()." ) - @classmethod - def from_descriptor(cls, *, shape, format, num_channels, is_surface_load_store=False): - """Allocate a new CUDA array. - - Parameters - ---------- - shape : tuple of int - ``(width,)``, ``(width, height)``, or ``(width, height, depth)`` - in elements. - format : ArrayFormat - Element format. - num_channels : int - Channels per element. Must be 1, 2, or 4. - is_surface_load_store : bool - If True, allocate with ``CUDA_ARRAY3D_SURFACE_LDST`` so the array - can be bound as a :class:`SurfaceObject` for kernel-side writes. - Default False. - - Returns - ------- - OpaqueArray - """ - _validate_format_channels(format, num_channels) - shape_t = _validate_array_shape(shape) - - cdef cydriver.CUarray_format c_format = format - cdef cydriver.CUDA_ARRAY3D_DESCRIPTOR desc3d - cdef int rank = len(shape_t) - cdef unsigned int flags = ( - cydriver.CUDA_ARRAY3D_SURFACE_LDST if is_surface_load_store else 0 - ) - - # cuArray3DCreate handles 1D/2D/3D uniformly (Height/Depth 0 sentinels), - # so a single descriptor + create_array_handle covers every shape. - memset(&desc3d, 0, sizeof(desc3d)) - desc3d.Width = shape_t[0] - desc3d.Height = (shape_t[1] if rank >= 2 else 0) - desc3d.Depth = (shape_t[2] if rank >= 3 else 0) - desc3d.Format = c_format - desc3d.NumChannels = num_channels - desc3d.Flags = flags - - cdef OpaqueArrayHandle h = create_array_handle(desc3d) - if not h: - HANDLE_RETURN(get_last_error()) - - cdef OpaqueArray self = cls.__new__(cls) - self._handle = h - self._shape = shape_t - self._format = c_format - self._num_channels = num_channels - self._surface_load_store = bool(is_surface_load_store) - self._device_id = _get_current_device_id() - return self - @classmethod def _from_handle(cls, intptr_t handle, bint owning, *, device_id=None): """Wrap an externally-allocated ``CUarray``. @@ -340,8 +376,8 @@ cdef class OpaqueArray: @property def format(self): - """The element :class:`ArrayFormat`.""" - return ArrayFormat(self._format) + """The element :class:`~cuda.core.typing.ArrayFormatType`.""" + return _CU_TO_ARRAYFORMAT[self._format] @property def num_channels(self): @@ -349,7 +385,7 @@ cdef class OpaqueArray: return self._num_channels @property - def element_size(self): + def element_bytes(self): """Bytes per element (format size * channels).""" return _FORMAT_ELEM_SIZE[self._format] * self._num_channels @@ -411,7 +447,7 @@ cdef class OpaqueArray: @property def size_bytes(self): - """Total bytes of array storage (``prod(shape) * element_size``).""" + """Total bytes of array storage (``prod(shape) * element_bytes``).""" cdef size_t n = 1 for s in self._shape: n *= s @@ -436,7 +472,7 @@ cdef class OpaqueArray: def __repr__(self): return ( f"OpaqueArray(shape={self._shape}, " - f"format={ArrayFormat(self._format).name}, " + f"format={_CU_TO_ARRAYFORMAT[self._format].name}, " f"num_channels={self._num_channels})" ) @@ -470,3 +506,47 @@ cdef OpaqueArray _array_from_handle(OpaqueArrayHandle h, int device_id): self._num_channels = desc.NumChannels self._surface_load_store = bool(desc.Flags & cydriver.CUDA_ARRAY3D_SURFACE_LDST) return self + + +def _create_opaque_array(options): + """Allocate a new :class:`OpaqueArray` on the current device. + + Backs :meth:`cuda.core.Device.create_opaque_array`. ``options`` is an + :class:`OpaqueArrayOptions` (or a mapping accepted by it); it is validated + at construction, so ``shape`` is already a normalized tuple and ``format`` + an :class:`~cuda.core.typing.ArrayFormatType`. + """ + cdef object opts = check_or_create_options( + OpaqueArrayOptions, options, "Opaque array options" + ) + shape_t = opts.shape + + cdef cydriver.CUarray_format c_format = _ARRAYFORMAT_TO_CU[opts.format] + cdef cydriver.CUDA_ARRAY3D_DESCRIPTOR desc3d + cdef int rank = len(shape_t) + cdef unsigned int flags = ( + cydriver.CUDA_ARRAY3D_SURFACE_LDST if opts.is_surface_load_store else 0 + ) + + # cuArray3DCreate handles 1D/2D/3D uniformly (Height/Depth 0 sentinels), + # so a single descriptor + create_array_handle covers every shape. + memset(&desc3d, 0, sizeof(desc3d)) + desc3d.Width = shape_t[0] + desc3d.Height = (shape_t[1] if rank >= 2 else 0) + desc3d.Depth = (shape_t[2] if rank >= 3 else 0) + desc3d.Format = c_format + desc3d.NumChannels = opts.num_channels + desc3d.Flags = flags + + cdef OpaqueArrayHandle h = create_array_handle(desc3d) + if not h: + HANDLE_RETURN(get_last_error()) + + cdef OpaqueArray self = OpaqueArray.__new__(OpaqueArray) + self._handle = h + self._shape = shape_t + self._format = c_format + self._num_channels = opts.num_channels + self._surface_load_store = bool(opts.is_surface_load_store) + self._device_id = _get_current_device_id() + return self diff --git a/cuda_core/cuda/core/texture/_mipmapped_array.pyi b/cuda_core/cuda/core/texture/_mipmapped_array.pyi index 0741df1781e..db4413dbaf4 100644 --- a/cuda_core/cuda/core/texture/_mipmapped_array.pyi +++ b/cuda_core/cuda/core/texture/_mipmapped_array.pyi @@ -2,6 +2,43 @@ from __future__ import annotations +from dataclasses import dataclass + + +@dataclass +class MipmappedArrayOptions: + """Options for :meth:`cuda.core.Device.create_mipmapped_array`. + + Attributes + ---------- + shape : tuple of int + ``(width,)``, ``(width, height)``, or ``(width, height, depth)`` in + elements, for the base (level 0) mip. + format : ArrayFormatType, str, or numpy.dtype + Element format. Accepts an :class:`~cuda.core.typing.ArrayFormatType`, + a plain string (e.g. ``"float32"``), or a NumPy dtype object. + num_channels : int + Channels per element. Must be 1, 2, or 4. + num_levels : int + Number of mip levels to allocate; must be >= 1. The driver caps this at + the log2 of the largest dimension; passing a larger value yields a + driver error. + is_surface_load_store : bool + If True, allocate with ``CUDA_ARRAY3D_SURFACE_LDST`` so individual + levels (obtained via :meth:`MipmappedArray.get_level`) can be bound as + a :class:`~cuda.core.texture.SurfaceObject` for kernel-side writes. + Default False. + + .. versionadded:: 1.1.0 + """ + shape: tuple[int, ...] + format: object + num_channels: int + num_levels: int + is_surface_load_store: bool = False + + def __post_init__(self): + ... class MipmappedArray: """A mipmapped CUDA array for texture/surface access across levels. @@ -13,7 +50,9 @@ class MipmappedArray: implicitly, so the :class:`OpaqueArray` instances returned by :meth:`get_level` are non-owning and hold a strong reference back to their parent. - Construct via :meth:`from_descriptor`. + Construct via :meth:`cuda.core.Device.create_mipmapped_array`. + + .. versionadded:: 1.1.0 """ def close(self): @@ -28,33 +67,6 @@ class MipmappedArray: def __init__(self, *args, **kwargs): ... - @classmethod - def from_descriptor(cls, *, shape, format, num_channels, num_levels, is_surface_load_store=False): - """Allocate a new mipmapped CUDA array. - - Parameters - ---------- - shape : tuple of int - ``(width,)``, ``(width, height)``, or ``(width, height, depth)`` - in elements, for the base (level 0) mip. - format : ArrayFormat - Element format. - num_channels : int - Channels per element. Must be 1, 2, or 4. - num_levels : int - Number of mip levels to allocate; must be >= 1. The driver caps - this at the log2 of the largest dimension; passing a larger value - yields a driver error. - is_surface_load_store : bool - If True, allocate with ``CUDA_ARRAY3D_SURFACE_LDST`` so individual - levels (obtained via :meth:`get_level`) can be bound as - :class:`SurfaceObject` for kernel-side writes. Default False. - - Returns - ------- - MipmappedArray - """ - def get_level(self, level): """Return a non-owning :class:`OpaqueArray` view of the given mip level. @@ -82,7 +94,7 @@ class MipmappedArray: @property def format(self): - """The element :class:`ArrayFormat`.""" + """The element :class:`~cuda.core.typing.ArrayFormatType`.""" @property def num_channels(self): @@ -108,4 +120,12 @@ class MipmappedArray: ... def __repr__(self): - ... \ No newline at end of file + ... + +def _create_mipmapped_array(options): + """Allocate a new :class:`MipmappedArray` on the current device. + + Backs :meth:`cuda.core.Device.create_mipmapped_array`. ``options`` is a + :class:`MipmappedArrayOptions` (or a mapping accepted by it); its fields are + validated at construction. + """ \ No newline at end of file diff --git a/cuda_core/cuda/core/texture/_mipmapped_array.pyx b/cuda_core/cuda/core/texture/_mipmapped_array.pyx index 0847203fe99..3f151f7bb9f 100644 --- a/cuda_core/cuda/core/texture/_mipmapped_array.pyx +++ b/cuda_core/cuda/core/texture/_mipmapped_array.pyx @@ -8,7 +8,12 @@ from libc.string cimport memset from cuda.bindings cimport cydriver from cuda.core.texture._array cimport _array_from_handle -from cuda.core.texture._array import ArrayFormat, _validate_array_shape, _validate_format_channels +from cuda.core.texture._array import ( + _ARRAYFORMAT_TO_CU, + _CU_TO_ARRAYFORMAT, + _validate_array_shape, + _validate_format_channels, +) from cuda.core._resource_handles cimport ( OpaqueArrayHandle, MipmappedArrayHandle, @@ -22,6 +27,51 @@ from cuda.core._utils.cuda_utils cimport ( _get_current_device_id, ) +from dataclasses import dataclass + +from cuda.core._utils.cuda_utils import check_or_create_options + + +@dataclass +class MipmappedArrayOptions: + """Options for :meth:`cuda.core.Device.create_mipmapped_array`. + + Attributes + ---------- + shape : tuple of int + ``(width,)``, ``(width, height)``, or ``(width, height, depth)`` in + elements, for the base (level 0) mip. + format : ArrayFormatType, str, or numpy.dtype + Element format. Accepts an :class:`~cuda.core.typing.ArrayFormatType`, + a plain string (e.g. ``"float32"``), or a NumPy dtype object. + num_channels : int + Channels per element. Must be 1, 2, or 4. + num_levels : int + Number of mip levels to allocate; must be >= 1. The driver caps this at + the log2 of the largest dimension; passing a larger value yields a + driver error. + is_surface_load_store : bool + If True, allocate with ``CUDA_ARRAY3D_SURFACE_LDST`` so individual + levels (obtained via :meth:`MipmappedArray.get_level`) can be bound as + a :class:`~cuda.core.texture.SurfaceObject` for kernel-side writes. + Default False. + + .. versionadded:: 1.1.0 + """ + + shape: tuple[int, ...] + format: object + num_channels: int + num_levels: int + is_surface_load_store: bool = False + + def __post_init__(self): + self.format = _validate_format_channels(self.format, self.num_channels) + self.shape = _validate_array_shape(self.shape) + self.num_levels = int(self.num_levels) + if self.num_levels < 1: + raise ValueError(f"num_levels must be >= 1, got {self.num_levels}") + cdef class MipmappedArray: """A mipmapped CUDA array for texture/surface access across levels. @@ -33,81 +83,16 @@ cdef class MipmappedArray: implicitly, so the :class:`OpaqueArray` instances returned by :meth:`get_level` are non-owning and hold a strong reference back to their parent. - Construct via :meth:`from_descriptor`. + Construct via :meth:`cuda.core.Device.create_mipmapped_array`. + + .. versionadded:: 1.1.0 """ def __init__(self, *args, **kwargs): raise RuntimeError( "MipmappedArray cannot be instantiated directly. " - "Use MipmappedArray.from_descriptor()." - ) - - @classmethod - def from_descriptor( - cls, *, shape, format, num_channels, num_levels, is_surface_load_store=False - ): - """Allocate a new mipmapped CUDA array. - - Parameters - ---------- - shape : tuple of int - ``(width,)``, ``(width, height)``, or ``(width, height, depth)`` - in elements, for the base (level 0) mip. - format : ArrayFormat - Element format. - num_channels : int - Channels per element. Must be 1, 2, or 4. - num_levels : int - Number of mip levels to allocate; must be >= 1. The driver caps - this at the log2 of the largest dimension; passing a larger value - yields a driver error. - is_surface_load_store : bool - If True, allocate with ``CUDA_ARRAY3D_SURFACE_LDST`` so individual - levels (obtained via :meth:`get_level`) can be bound as - :class:`SurfaceObject` for kernel-side writes. Default False. - - Returns - ------- - MipmappedArray - """ - _validate_format_channels(format, num_channels) - shape_t = _validate_array_shape(shape) - - levels = int(num_levels) - if levels < 1: - raise ValueError(f"num_levels must be >= 1, got {levels}") - - cdef cydriver.CUarray_format c_format = format - cdef cydriver.CUDA_ARRAY3D_DESCRIPTOR desc3d - cdef int rank = len(shape_t) - cdef unsigned int flags = ( - cydriver.CUDA_ARRAY3D_SURFACE_LDST if is_surface_load_store else 0 + "Use Device.create_mipmapped_array()." ) - cdef unsigned int c_levels = levels - - # Mipmap creation uses the 3D descriptor regardless of rank; lower-rank - # shapes use Height=0/Depth=0 sentinels, matching cuArray3DCreate. - memset(&desc3d, 0, sizeof(desc3d)) - desc3d.Width = shape_t[0] - desc3d.Height = (shape_t[1] if rank >= 2 else 0) - desc3d.Depth = (shape_t[2] if rank >= 3 else 0) - desc3d.Format = c_format - desc3d.NumChannels = num_channels - desc3d.Flags = flags - - cdef MipmappedArrayHandle h = create_mipmapped_array_handle(desc3d, c_levels) - if not h: - HANDLE_RETURN(get_last_error()) - - cdef MipmappedArray self = cls.__new__(cls) - self._handle = h - self._shape = shape_t - self._format = c_format - self._num_channels = num_channels - self._num_levels = levels - self._surface_load_store = bool(is_surface_load_store) - self._device_id = _get_current_device_id() - return self def get_level(self, level): """Return a non-owning :class:`OpaqueArray` view of the given mip level. @@ -153,8 +138,8 @@ cdef class MipmappedArray: @property def format(self): - """The element :class:`ArrayFormat`.""" - return ArrayFormat(self._format) + """The element :class:`~cuda.core.typing.ArrayFormatType`.""" + return _CU_TO_ARRAYFORMAT[self._format] @property def num_channels(self): @@ -197,7 +182,52 @@ cdef class MipmappedArray: def __repr__(self): return ( f"MipmappedArray(shape={self._shape}, " - f"format={ArrayFormat(self._format).name}, " + f"format={_CU_TO_ARRAYFORMAT[self._format].name}, " f"num_channels={self._num_channels}, " f"num_levels={self._num_levels})" ) + + +def _create_mipmapped_array(options): + """Allocate a new :class:`MipmappedArray` on the current device. + + Backs :meth:`cuda.core.Device.create_mipmapped_array`. ``options`` is a + :class:`MipmappedArrayOptions` (or a mapping accepted by it); its fields are + validated at construction. + """ + cdef object opts = check_or_create_options( + MipmappedArrayOptions, options, "Mipmapped array options" + ) + shape_t = opts.shape + + cdef cydriver.CUarray_format c_format = _ARRAYFORMAT_TO_CU[opts.format] + cdef cydriver.CUDA_ARRAY3D_DESCRIPTOR desc3d + cdef int rank = len(shape_t) + cdef unsigned int flags = ( + cydriver.CUDA_ARRAY3D_SURFACE_LDST if opts.is_surface_load_store else 0 + ) + cdef unsigned int c_levels = opts.num_levels + + # Mipmap creation uses the 3D descriptor regardless of rank; lower-rank + # shapes use Height=0/Depth=0 sentinels, matching cuArray3DCreate. + memset(&desc3d, 0, sizeof(desc3d)) + desc3d.Width = shape_t[0] + desc3d.Height = (shape_t[1] if rank >= 2 else 0) + desc3d.Depth = (shape_t[2] if rank >= 3 else 0) + desc3d.Format = c_format + desc3d.NumChannels = opts.num_channels + desc3d.Flags = flags + + cdef MipmappedArrayHandle h = create_mipmapped_array_handle(desc3d, c_levels) + if not h: + HANDLE_RETURN(get_last_error()) + + cdef MipmappedArray self = MipmappedArray.__new__(MipmappedArray) + self._handle = h + self._shape = shape_t + self._format = c_format + self._num_channels = opts.num_channels + self._num_levels = opts.num_levels + self._surface_load_store = bool(opts.is_surface_load_store) + self._device_id = _get_current_device_id() + return self diff --git a/cuda_core/cuda/core/texture/_surface.pyi b/cuda_core/cuda/core/texture/_surface.pyi index be61e1099ba..977268abd5f 100644 --- a/cuda_core/cuda/core/texture/_surface.pyi +++ b/cuda_core/cuda/core/texture/_surface.pyi @@ -14,8 +14,10 @@ class SurfaceObject: ``is_surface_load_store=True`` and is kept alive for the lifetime of this object to prevent dangling handles. - Construct via :meth:`from_array` or :meth:`from_descriptor`. Passes to + Construct via :meth:`cuda.core.Device.create_surface_object`. Passes to kernels as a 64-bit handle (via the ``handle`` property). + + .. versionadded:: 1.1.0 """ def close(self): @@ -29,25 +31,6 @@ class SurfaceObject: def __init__(self, *args, **kwargs): ... - @classmethod - def from_array(cls, array): - """Create a surface object directly from an :class:`OpaqueArray`. - - The array must have been created with ``is_surface_load_store=True``. - """ - - @classmethod - def from_descriptor(cls, *, resource): - """Create a surface object from a :class:`ResourceDescriptor`. - - Parameters - ---------- - resource : ResourceDescriptor - Must wrap an :class:`OpaqueArray` allocated with - ``is_surface_load_store=True``. Linear/pitch2d resources are not - valid surface backings. - """ - @property def handle(self): """The underlying ``CUsurfObject`` as an integer (64-bit kernel arg).""" @@ -67,4 +50,13 @@ class SurfaceObject: ... def __repr__(self): - ... \ No newline at end of file + ... + +def _create_surface_object(resource): + """Create a :class:`SurfaceObject` on the current device. + + Backs :meth:`cuda.core.Device.create_surface_object`. ``resource`` must be a + :class:`ResourceDescriptor` wrapping an :class:`OpaqueArray` allocated with + ``is_surface_load_store=True``; linear/pitch2d resources are not valid + surface backings. + """ \ No newline at end of file diff --git a/cuda_core/cuda/core/texture/_surface.pyx b/cuda_core/cuda/core/texture/_surface.pyx index 93836dfeab8..ac61fddd357 100644 --- a/cuda_core/cuda/core/texture/_surface.pyx +++ b/cuda_core/cuda/core/texture/_surface.pyx @@ -33,70 +33,18 @@ cdef class SurfaceObject: ``is_surface_load_store=True`` and is kept alive for the lifetime of this object to prevent dangling handles. - Construct via :meth:`from_array` or :meth:`from_descriptor`. Passes to + Construct via :meth:`cuda.core.Device.create_surface_object`. Passes to kernels as a 64-bit handle (via the ``handle`` property). + + .. versionadded:: 1.1.0 """ def __init__(self, *args, **kwargs): raise RuntimeError( "SurfaceObject cannot be instantiated directly. " - "Use SurfaceObject.from_array() or SurfaceObject.from_descriptor()." + "Use Device.create_surface_object()." ) - @classmethod - def from_array(cls, array): - """Create a surface object directly from an :class:`OpaqueArray`. - - The array must have been created with ``is_surface_load_store=True``. - """ - if not isinstance(array, OpaqueArray): - raise TypeError(f"array must be a OpaqueArray, got {type(array).__name__}") - return cls.from_descriptor(resource=ResourceDescriptor.from_array(array)) - - @classmethod - def from_descriptor(cls, *, resource): - """Create a surface object from a :class:`ResourceDescriptor`. - - Parameters - ---------- - resource : ResourceDescriptor - Must wrap an :class:`OpaqueArray` allocated with - ``is_surface_load_store=True``. Linear/pitch2d resources are not - valid surface backings. - """ - if not isinstance(resource, ResourceDescriptor): - raise TypeError( - f"resource must be a ResourceDescriptor, got " - f"{type(resource).__name__}" - ) - if resource.kind != "array": - raise ValueError( - f"SurfaceObject requires an array-backed ResourceDescriptor, " - f"got kind={resource.kind!r}" - ) - - cdef OpaqueArray arr = resource.source - if not arr.is_surface_load_store: - raise ValueError( - "OpaqueArray must be created with is_surface_load_store=True to be " - "bound as a SurfaceObject" - ) - - cdef cydriver.CUDA_RESOURCE_DESC res_desc - memset(&res_desc, 0, sizeof(res_desc)) - res_desc.resType = cydriver.CU_RESOURCE_TYPE_ARRAY - res_desc.res.array.hArray = as_cu(arr._handle) - - cdef SurfObjectHandle h = create_surf_object_handle(res_desc, arr._handle) - if not h: - HANDLE_RETURN(get_last_error()) - - cdef SurfaceObject self = cls.__new__(cls) - self._handle = h - self._source_ref = resource - self._device_id = _get_current_device_id() - return self - @property def handle(self): """The underlying ``CUsurfObject`` as an integer (64-bit kernel arg).""" @@ -130,3 +78,45 @@ cdef class SurfaceObject: def __repr__(self): return f"SurfaceObject(handle=0x{as_intptr(self._handle):x})" + + +def _create_surface_object(resource): + """Create a :class:`SurfaceObject` on the current device. + + Backs :meth:`cuda.core.Device.create_surface_object`. ``resource`` must be a + :class:`ResourceDescriptor` wrapping an :class:`OpaqueArray` allocated with + ``is_surface_load_store=True``; linear/pitch2d resources are not valid + surface backings. + """ + if not isinstance(resource, ResourceDescriptor): + raise TypeError( + f"resource must be a ResourceDescriptor, got " + f"{type(resource).__name__}" + ) + if resource.kind != "array": + raise ValueError( + f"SurfaceObject requires an array-backed ResourceDescriptor, " + f"got kind={resource.kind!r}" + ) + + cdef OpaqueArray arr = resource.source + if not arr.is_surface_load_store: + raise ValueError( + "OpaqueArray must be created with is_surface_load_store=True to be " + "bound as a SurfaceObject" + ) + + cdef cydriver.CUDA_RESOURCE_DESC res_desc + memset(&res_desc, 0, sizeof(res_desc)) + res_desc.resType = cydriver.CU_RESOURCE_TYPE_ARRAY + res_desc.res.array.hArray = as_cu(arr._handle) + + cdef SurfObjectHandle h = create_surf_object_handle(res_desc, arr._handle) + if not h: + HANDLE_RETURN(get_last_error()) + + cdef SurfaceObject self = SurfaceObject.__new__(SurfaceObject) + self._handle = h + self._source_ref = resource + self._device_id = _get_current_device_id() + return self diff --git a/cuda_core/cuda/core/texture/_texture.pxd b/cuda_core/cuda/core/texture/_texture.pxd index f8532a4dad5..6d0871fe848 100644 --- a/cuda_core/cuda/core/texture/_texture.pxd +++ b/cuda_core/cuda/core/texture/_texture.pxd @@ -13,7 +13,7 @@ cdef class TextureObject: # structurally by the C++ box behind this handle, not by _source_ref. TexObjectHandle _handle object _source_ref # ResourceDescriptor, retained for introspection - object _texture_desc # original TextureDescriptor for introspection + object _options # original TextureObjectOptions for introspection int _device_id cpdef close(self) diff --git a/cuda_core/cuda/core/texture/_texture.pyi b/cuda_core/cuda/core/texture/_texture.pyi index b04ca384989..7840585bb4d 100644 --- a/cuda_core/cuda/core/texture/_texture.pyi +++ b/cuda_core/cuda/core/texture/_texture.pyi @@ -3,41 +3,17 @@ from __future__ import annotations from dataclasses import dataclass -from enum import IntEnum from cuda.bindings import cydriver +from cuda.core.typing import AddressModeType, FilterModeType, ReadModeType -class AddressMode(IntEnum): - """Boundary behavior for out-of-range texture coordinates.""" - WRAP = cydriver.CU_TR_ADDRESS_MODE_WRAP - CLAMP = cydriver.CU_TR_ADDRESS_MODE_CLAMP - MIRROR = cydriver.CU_TR_ADDRESS_MODE_MIRROR - BORDER = cydriver.CU_TR_ADDRESS_MODE_BORDER - -class FilterMode(IntEnum): - """Texel sampling mode.""" - POINT = cydriver.CU_TR_FILTER_MODE_POINT - LINEAR = cydriver.CU_TR_FILTER_MODE_LINEAR - -class ReadMode(IntEnum): - """How sampled values are returned to the kernel. - - - ``ELEMENT_TYPE``: return the raw element value (integer formats stay - integer, float stays float). - - ``NORMALIZED_FLOAT``: integer formats are promoted to a normalized - ``float`` in ``[0, 1]`` (unsigned) or ``[-1, 1]`` (signed). - Float formats are unaffected. - """ - ELEMENT_TYPE = 0 - NORMALIZED_FLOAT = 1 - class ResourceDescriptor: """Describes the memory backing a :class:`TextureObject`. Construct via the ``from_*`` classmethods: - - :meth:`from_array` wraps a :class:`OpaqueArray` (works for both + - :meth:`from_opaque_array` wraps a :class:`OpaqueArray` (works for both :class:`TextureObject` and :class:`SurfaceObject`). - :meth:`from_mipmapped_array` wraps a :class:`MipmappedArray` for mipmapped sampling (texture only, not surface). @@ -49,6 +25,8 @@ class ResourceDescriptor: Linear and pitch2D resources cannot back a :class:`SurfaceObject` — those require an :class:`OpaqueArray` allocated with ``is_surface_load_store=True``. + + .. versionadded:: 1.1.0 """ __slots__ = ('_kind', '_source', '_format', '_num_channels', '_size_bytes', '_width', '_height', '_pitch_bytes') @@ -56,7 +34,7 @@ class ResourceDescriptor: ... @classmethod - def from_array(cls, array): + def from_opaque_array(cls, array): """Build a resource descriptor backed by a :class:`OpaqueArray`.""" @classmethod @@ -78,8 +56,9 @@ class ResourceDescriptor: buffer : Buffer Device-memory backing. Must remain alive for the lifetime of any :class:`TextureObject` built from this descriptor. - format : ArrayFormat - Element format. + format : ArrayFormatType, str, or numpy.dtype + Element format. Accepts an :class:`~cuda.core.typing.ArrayFormatType`, + a plain string (e.g. ``"float32"``), or a NumPy dtype object. num_channels : int Channels per element. Must be 1, 2, or 4. size_bytes : int, optional @@ -89,7 +68,7 @@ class ResourceDescriptor: Notes ----- Texture objects built from a linear resource ignore the - :class:`TextureDescriptor` addressing/filtering fields — kernels read + :class:`TextureObjectOptions` addressing/filtering fields — kernels read through a typed 1D fetch with bounds checking only. """ @@ -102,8 +81,9 @@ class ResourceDescriptor: buffer : Buffer Device-memory backing. Must remain alive for the lifetime of any :class:`TextureObject` built from this descriptor. - format : ArrayFormat - Element format. + format : ArrayFormatType, str, or numpy.dtype + Element format. Accepts an :class:`~cuda.core.typing.ArrayFormatType`, + a plain string (e.g. ``"float32"``), or a NumPy dtype object. num_channels : int Channels per element. Must be 1, 2, or 4. width : int @@ -126,7 +106,7 @@ class ResourceDescriptor: @property def format(self): - """The element :class:`ArrayFormat` (``None`` for array-backed).""" + """The element :class:`~cuda.core.typing.ArrayFormatType` (``None`` for array-backed).""" @property def num_channels(self): @@ -152,18 +132,20 @@ class ResourceDescriptor: ... @dataclass -class TextureDescriptor: +class TextureObjectOptions: """Sampling state for a :class:`TextureObject` (mirrors ``CUDA_TEXTURE_DESC``). Attributes ---------- - address_mode : tuple of AddressMode - Boundary behavior per axis. May be a single :class:`AddressMode` (applied - to all axes) or a tuple of 1-3 entries (one per dimension). - filter_mode : FilterMode - Texel sampling mode. Default ``POINT``. - read_mode : ReadMode + address_mode : AddressModeType or tuple of AddressModeType + Boundary behavior per axis. May be a single + :class:`~cuda.core.typing.AddressModeType` (applied to all axes) or a + tuple of 1-3 entries (one per dimension). Plain strings are accepted. + filter_mode : FilterModeType + Texel sampling mode. Default ``POINT``. Plain strings are accepted. + read_mode : ReadModeType How sampled integer values are returned. Default ``ELEMENT_TYPE``. + Plain strings are accepted. normalized_coords : bool If True, coordinates are in ``[0, 1]`` instead of pixel indices. srgb : bool @@ -174,29 +156,35 @@ class TextureDescriptor: If True, enable seamless cubemap edge filtering. max_anisotropy : int Maximum anisotropy; 0 disables anisotropic filtering. - mipmap_filter_mode : FilterMode - Filtering between mipmap levels. Default ``POINT``. + mipmap_filter_mode : FilterModeType + Filtering between mipmap levels. Default ``POINT``. Plain strings are + accepted. mipmap_level_bias : float min_mipmap_level_clamp : float max_mipmap_level_clamp : float border_color : tuple of float or None 4-tuple used when ``address_mode`` includes ``BORDER``; ``None`` means zero. + + .. versionadded:: 1.1.0 """ - address_mode: AddressMode | tuple[AddressMode, ...] = AddressMode.CLAMP - filter_mode: FilterMode = FilterMode.POINT - read_mode: ReadMode = ReadMode.ELEMENT_TYPE + address_mode: AddressModeType | str | tuple[AddressModeType | str, ...] = AddressModeType.CLAMP + filter_mode: FilterModeType | str = FilterModeType.POINT + read_mode: ReadModeType | str = ReadModeType.ELEMENT_TYPE normalized_coords: bool = False srgb: bool = False disable_trilinear_optimization: bool = False seamless_cubemap: bool = False max_anisotropy: int = 0 - mipmap_filter_mode: FilterMode = FilterMode.POINT + mipmap_filter_mode: FilterModeType | str = FilterModeType.POINT mipmap_level_bias: float = 0.0 min_mipmap_level_clamp: float = 0.0 max_mipmap_level_clamp: float = 0.0 border_color: tuple[float, ...] | None = None + def __post_init__(self): + ... + class TextureObject: """A bindless texture handle for kernel-side sampled reads. @@ -204,8 +192,10 @@ class TextureObject: :class:`OpaqueArray` referenced by the descriptor) is kept alive for the lifetime of this object to prevent dangling handles. - Construct via :meth:`from_descriptor`. Passes to kernels as a 64-bit - handle (via the ``handle`` property). + Construct via :meth:`cuda.core.Device.create_texture_object`. Passes to + kernels as a 64-bit handle (via the ``handle`` property). + + .. versionadded:: 1.1.0 """ def close(self): @@ -219,16 +209,6 @@ class TextureObject: def __init__(self, *args, **kwargs): ... - @classmethod - def from_descriptor(cls, *, resource, texture_descriptor): - """Create a texture object from a resource + sampling descriptor. - - Parameters - ---------- - resource : ResourceDescriptor - texture_descriptor : TextureDescriptor - """ - @property def handle(self): """The underlying ``CUtexObject`` as an integer (64-bit kernel arg).""" @@ -238,8 +218,8 @@ class TextureObject: """The :class:`ResourceDescriptor` this texture was built from.""" @property - def texture_descriptor(self): - """The :class:`TextureDescriptor` this texture was built from.""" + def options(self): + """The :class:`TextureObjectOptions` this texture was built from.""" @property def device(self): @@ -258,6 +238,20 @@ _TRSF_NORMALIZED_COORDINATES = 2 _TRSF_SRGB = 16 _TRSF_DISABLE_TRILINEAR_OPTIMIZATION = 32 _TRSF_SEAMLESS_CUBEMAP = 64 +_ADDRESSMODE_TO_CU = {AddressModeType.WRAP: int(cydriver.CU_TR_ADDRESS_MODE_WRAP), AddressModeType.CLAMP: int(cydriver.CU_TR_ADDRESS_MODE_CLAMP), AddressModeType.MIRROR: int(cydriver.CU_TR_ADDRESS_MODE_MIRROR), AddressModeType.BORDER: int(cydriver.CU_TR_ADDRESS_MODE_BORDER)} +_FILTERMODE_TO_CU = {FilterModeType.POINT: int(cydriver.CU_TR_FILTER_MODE_POINT), FilterModeType.LINEAR: int(cydriver.CU_TR_FILTER_MODE_LINEAR)} + +def _normalize_enum(name, value, enum_type): + """Coerce ``value`` to ``enum_type`` (a StrEnum), accepting a plain str.""" def _normalize_address_modes(address_mode): - """Return a 3-tuple of AddressMode values from a scalar or 1-3 tuple.""" \ No newline at end of file + """Return a 3-tuple of :class:`AddressModeType` values from a scalar or + 1-3 tuple. Individual entries may be plain strings.""" + +def _create_texture_object(resource, options): + """Create a :class:`TextureObject` on the current device. + + Backs :meth:`cuda.core.Device.create_texture_object`. ``resource`` is a + :class:`ResourceDescriptor`; ``options`` is a :class:`TextureObjectOptions` + (or a mapping accepted by it). + """ \ No newline at end of file diff --git a/cuda_core/cuda/core/texture/_texture.pyx b/cuda_core/cuda/core/texture/_texture.pyx index e88ec2d2a36..8d09c727c31 100644 --- a/cuda_core/cuda/core/texture/_texture.pyx +++ b/cuda_core/cuda/core/texture/_texture.pyx @@ -9,7 +9,12 @@ from libc.string cimport memset from cuda.bindings cimport cydriver from cuda.core.texture._array cimport OpaqueArray -from cuda.core.texture._array import ArrayFormat, _FORMAT_ELEM_SIZE, _validate_format_channels +from cuda.core.texture._array import ( + _ARRAYFORMAT_TO_CU, + _CU_TO_ARRAYFORMAT, + _FORMAT_ELEM_SIZE, + _validate_format_channels, +) from cuda.core._memory._buffer cimport Buffer from cuda.core.texture._mipmapped_array cimport MipmappedArray from cuda.core.texture._mipmapped_array import MipmappedArray as _PyMipmappedArray @@ -27,8 +32,11 @@ from cuda.core._utils.cuda_utils cimport ( _get_current_device_id, ) +from cuda.core.typing import AddressModeType, FilterModeType, ReadModeType + from dataclasses import dataclass -from enum import IntEnum + +from cuda.core._utils.cuda_utils import check_or_create_options # Driver texture-descriptor flag bits (CU_TRSF_*). @@ -39,31 +47,30 @@ _TRSF_DISABLE_TRILINEAR_OPTIMIZATION = 0x20 _TRSF_SEAMLESS_CUBEMAP = 0x40 -class AddressMode(IntEnum): - """Boundary behavior for out-of-range texture coordinates.""" - WRAP = cydriver.CU_TR_ADDRESS_MODE_WRAP - CLAMP = cydriver.CU_TR_ADDRESS_MODE_CLAMP - MIRROR = cydriver.CU_TR_ADDRESS_MODE_MIRROR - BORDER = cydriver.CU_TR_ADDRESS_MODE_BORDER - +# Bridge between the public sampling StrEnums and the driver integer values. +_ADDRESSMODE_TO_CU = { + AddressModeType.WRAP: int(cydriver.CU_TR_ADDRESS_MODE_WRAP), + AddressModeType.CLAMP: int(cydriver.CU_TR_ADDRESS_MODE_CLAMP), + AddressModeType.MIRROR: int(cydriver.CU_TR_ADDRESS_MODE_MIRROR), + AddressModeType.BORDER: int(cydriver.CU_TR_ADDRESS_MODE_BORDER), +} +_FILTERMODE_TO_CU = { + FilterModeType.POINT: int(cydriver.CU_TR_FILTER_MODE_POINT), + FilterModeType.LINEAR: int(cydriver.CU_TR_FILTER_MODE_LINEAR), +} -class FilterMode(IntEnum): - """Texel sampling mode.""" - POINT = cydriver.CU_TR_FILTER_MODE_POINT - LINEAR = cydriver.CU_TR_FILTER_MODE_LINEAR - -class ReadMode(IntEnum): - """How sampled values are returned to the kernel. - - - ``ELEMENT_TYPE``: return the raw element value (integer formats stay - integer, float stays float). - - ``NORMALIZED_FLOAT``: integer formats are promoted to a normalized - ``float`` in ``[0, 1]`` (unsigned) or ``[-1, 1]`` (signed). - Float formats are unaffected. - """ - ELEMENT_TYPE = 0 - NORMALIZED_FLOAT = 1 +def _normalize_enum(name, value, enum_type): + """Coerce ``value`` to ``enum_type`` (a StrEnum), accepting a plain str.""" + if isinstance(value, enum_type): + return value + try: + return enum_type(value) + except ValueError as e: + valid = ", ".join(repr(m.value) for m in enum_type) + raise ValueError( + f"{name} must be a {enum_type.__name__} or one of {{{valid}}}, got {value!r}" + ) from e class ResourceDescriptor: @@ -71,7 +78,7 @@ class ResourceDescriptor: Construct via the ``from_*`` classmethods: - - :meth:`from_array` wraps a :class:`OpaqueArray` (works for both + - :meth:`from_opaque_array` wraps a :class:`OpaqueArray` (works for both :class:`TextureObject` and :class:`SurfaceObject`). - :meth:`from_mipmapped_array` wraps a :class:`MipmappedArray` for mipmapped sampling (texture only, not surface). @@ -83,6 +90,8 @@ class ResourceDescriptor: Linear and pitch2D resources cannot back a :class:`SurfaceObject` — those require an :class:`OpaqueArray` allocated with ``is_surface_load_store=True``. + + .. versionadded:: 1.1.0 """ __slots__ = ( @@ -99,7 +108,7 @@ class ResourceDescriptor: ) @classmethod - def from_array(cls, array): + def from_opaque_array(cls, array): """Build a resource descriptor backed by a :class:`OpaqueArray`.""" if not isinstance(array, OpaqueArray): raise TypeError(f"array must be a OpaqueArray, got {type(array).__name__}") @@ -148,8 +157,9 @@ class ResourceDescriptor: buffer : Buffer Device-memory backing. Must remain alive for the lifetime of any :class:`TextureObject` built from this descriptor. - format : ArrayFormat - Element format. + format : ArrayFormatType, str, or numpy.dtype + Element format. Accepts an :class:`~cuda.core.typing.ArrayFormatType`, + a plain string (e.g. ``"float32"``), or a NumPy dtype object. num_channels : int Channels per element. Must be 1, 2, or 4. size_bytes : int, optional @@ -159,15 +169,16 @@ class ResourceDescriptor: Notes ----- Texture objects built from a linear resource ignore the - :class:`TextureDescriptor` addressing/filtering fields — kernels read + :class:`TextureObjectOptions` addressing/filtering fields — kernels read through a typed 1D fetch with bounds checking only. """ if not isinstance(buffer, Buffer): raise TypeError(f"buffer must be a Buffer, got {type(buffer).__name__}") - _validate_format_channels(format, num_channels) + fmt = _validate_format_channels(format, num_channels) + cu_format = _ARRAYFORMAT_TO_CU[fmt] buf_size = int(buffer.size) - elem = _FORMAT_ELEM_SIZE[int(format)] * int(num_channels) + elem = _FORMAT_ELEM_SIZE[cu_format] * int(num_channels) if size_bytes is None: size = buf_size else: @@ -183,13 +194,13 @@ class ResourceDescriptor: if size % elem != 0: raise ValueError( f"size_bytes ({size}) must be a multiple of element size " - f"({elem} bytes for {format.name} x {num_channels})" + f"({elem} bytes for {fmt.name} x {num_channels})" ) self = cls.__new__(cls) self._kind = "linear" self._source = buffer - self._format = int(format) + self._format = cu_format self._num_channels = int(num_channels) self._size_bytes = size self._width = None @@ -208,8 +219,9 @@ class ResourceDescriptor: buffer : Buffer Device-memory backing. Must remain alive for the lifetime of any :class:`TextureObject` built from this descriptor. - format : ArrayFormat - Element format. + format : ArrayFormatType, str, or numpy.dtype + Element format. Accepts an :class:`~cuda.core.typing.ArrayFormatType`, + a plain string (e.g. ``"float32"``), or a NumPy dtype object. num_channels : int Channels per element. Must be 1, 2, or 4. width : int @@ -223,7 +235,8 @@ class ResourceDescriptor: """ if not isinstance(buffer, Buffer): raise TypeError(f"buffer must be a Buffer, got {type(buffer).__name__}") - _validate_format_channels(format, num_channels) + fmt = _validate_format_channels(format, num_channels) + cu_format = _ARRAYFORMAT_TO_CU[fmt] w = int(width) h = int(height) @@ -232,11 +245,11 @@ class ResourceDescriptor: raise ValueError(f"width must be >= 1, got {w}") if h < 1: raise ValueError(f"height must be >= 1, got {h}") - elem = _FORMAT_ELEM_SIZE[int(format)] * int(num_channels) + elem = _FORMAT_ELEM_SIZE[cu_format] * int(num_channels) min_pitch = w * elem if p < min_pitch: raise ValueError( - f"pitch_bytes ({p}) must be >= width * element_size ({min_pitch})" + f"pitch_bytes ({p}) must be >= width * element_bytes ({min_pitch})" ) if p * h > int(buffer.size): raise ValueError( @@ -246,7 +259,7 @@ class ResourceDescriptor: self = cls.__new__(cls) self._kind = "pitch2d" self._source = buffer - self._format = int(format) + self._format = cu_format self._num_channels = int(num_channels) self._size_bytes = None self._width = w @@ -264,8 +277,8 @@ class ResourceDescriptor: @property def format(self): - """The element :class:`ArrayFormat` (``None`` for array-backed).""" - return None if self._format is None else ArrayFormat(self._format) + """The element :class:`~cuda.core.typing.ArrayFormatType` (``None`` for array-backed).""" + return None if self._format is None else _CU_TO_ARRAYFORMAT[self._format] @property def num_channels(self): @@ -309,18 +322,20 @@ class ResourceDescriptor: @dataclass -class TextureDescriptor: +class TextureObjectOptions: """Sampling state for a :class:`TextureObject` (mirrors ``CUDA_TEXTURE_DESC``). Attributes ---------- - address_mode : tuple of AddressMode - Boundary behavior per axis. May be a single :class:`AddressMode` (applied - to all axes) or a tuple of 1-3 entries (one per dimension). - filter_mode : FilterMode - Texel sampling mode. Default ``POINT``. - read_mode : ReadMode + address_mode : AddressModeType or tuple of AddressModeType + Boundary behavior per axis. May be a single + :class:`~cuda.core.typing.AddressModeType` (applied to all axes) or a + tuple of 1-3 entries (one per dimension). Plain strings are accepted. + filter_mode : FilterModeType + Texel sampling mode. Default ``POINT``. Plain strings are accepted. + read_mode : ReadModeType How sampled integer values are returned. Default ``ELEMENT_TYPE``. + Plain strings are accepted. normalized_coords : bool If True, coordinates are in ``[0, 1]`` instead of pixel indices. srgb : bool @@ -331,50 +346,61 @@ class TextureDescriptor: If True, enable seamless cubemap edge filtering. max_anisotropy : int Maximum anisotropy; 0 disables anisotropic filtering. - mipmap_filter_mode : FilterMode - Filtering between mipmap levels. Default ``POINT``. + mipmap_filter_mode : FilterModeType + Filtering between mipmap levels. Default ``POINT``. Plain strings are + accepted. mipmap_level_bias : float min_mipmap_level_clamp : float max_mipmap_level_clamp : float border_color : tuple of float or None 4-tuple used when ``address_mode`` includes ``BORDER``; ``None`` means zero. + + .. versionadded:: 1.1.0 """ - address_mode: AddressMode | tuple[AddressMode, ...] = AddressMode.CLAMP - filter_mode: FilterMode = FilterMode.POINT - read_mode: ReadMode = ReadMode.ELEMENT_TYPE + address_mode: AddressModeType | str | tuple[AddressModeType | str, ...] = AddressModeType.CLAMP + filter_mode: FilterModeType | str = FilterModeType.POINT + read_mode: ReadModeType | str = ReadModeType.ELEMENT_TYPE normalized_coords: bool = False srgb: bool = False disable_trilinear_optimization: bool = False seamless_cubemap: bool = False max_anisotropy: int = 0 - mipmap_filter_mode: FilterMode = FilterMode.POINT + mipmap_filter_mode: FilterModeType | str = FilterModeType.POINT mipmap_level_bias: float = 0.0 min_mipmap_level_clamp: float = 0.0 max_mipmap_level_clamp: float = 0.0 border_color: tuple[float, ...] | None = None + def __post_init__(self): + self.filter_mode = _normalize_enum("filter_mode", self.filter_mode, FilterModeType) + self.read_mode = _normalize_enum("read_mode", self.read_mode, ReadModeType) + self.mipmap_filter_mode = _normalize_enum( + "mipmap_filter_mode", self.mipmap_filter_mode, FilterModeType + ) + def _normalize_address_modes(address_mode): - """Return a 3-tuple of AddressMode values from a scalar or 1-3 tuple.""" - if isinstance(address_mode, AddressMode): - return (address_mode, address_mode, address_mode) + """Return a 3-tuple of :class:`AddressModeType` values from a scalar or + 1-3 tuple. Individual entries may be plain strings.""" + if isinstance(address_mode, (AddressModeType, str)): + m = _normalize_enum("address_mode", address_mode, AddressModeType) + return (m, m, m) try: modes = tuple(address_mode) except TypeError as e: raise TypeError( - "address_mode must be an AddressMode or a tuple of AddressMode" + "address_mode must be an AddressModeType or a tuple of AddressModeType" ) from e if not 1 <= len(modes) <= 3: raise ValueError( f"address_mode tuple must have 1-3 entries, got {len(modes)}" ) - for i, m in enumerate(modes): - if not isinstance(m, AddressMode): - raise TypeError( - f"address_mode[{i}] must be an AddressMode, got {type(m).__name__}" - ) + modes = tuple( + _normalize_enum(f"address_mode[{i}]", m, AddressModeType) + for i, m in enumerate(modes) + ) # Pad to 3 entries by repeating the last one. padded = list(modes) + [modes[-1]] * (3 - len(modes)) return tuple(padded) @@ -387,155 +413,18 @@ cdef class TextureObject: :class:`OpaqueArray` referenced by the descriptor) is kept alive for the lifetime of this object to prevent dangling handles. - Construct via :meth:`from_descriptor`. Passes to kernels as a 64-bit - handle (via the ``handle`` property). + Construct via :meth:`cuda.core.Device.create_texture_object`. Passes to + kernels as a 64-bit handle (via the ``handle`` property). + + .. versionadded:: 1.1.0 """ def __init__(self, *args, **kwargs): raise RuntimeError( "TextureObject cannot be instantiated directly. " - "Use TextureObject.from_descriptor()." + "Use Device.create_texture_object()." ) - @classmethod - def from_descriptor(cls, *, resource, texture_descriptor): - """Create a texture object from a resource + sampling descriptor. - - Parameters - ---------- - resource : ResourceDescriptor - texture_descriptor : TextureDescriptor - """ - if not isinstance(resource, ResourceDescriptor): - raise TypeError( - f"resource must be a ResourceDescriptor, got " - f"{type(resource).__name__}" - ) - if not isinstance(texture_descriptor, TextureDescriptor): - raise TypeError( - f"texture_descriptor must be a TextureDescriptor, got " - f"{type(texture_descriptor).__name__}" - ) - - cdef cydriver.CUDA_RESOURCE_DESC res_desc - cdef cydriver.CUDA_TEXTURE_DESC tex_desc - memset(&res_desc, 0, sizeof(res_desc)) - memset(&tex_desc, 0, sizeof(tex_desc)) - - # --- Resource descriptor --- - cdef OpaqueArray arr - cdef MipmappedArray mip - cdef Buffer buf - cdef intptr_t devptr - if resource.kind == "array": - arr = resource.source - res_desc.resType = cydriver.CU_RESOURCE_TYPE_ARRAY - res_desc.res.array.hArray = as_cu(arr._handle) - elif resource.kind == "mipmapped_array": - mip = resource.source - res_desc.resType = cydriver.CU_RESOURCE_TYPE_MIPMAPPED_ARRAY - res_desc.res.mipmap.hMipmappedArray = as_cu(mip._handle) - elif resource.kind == "linear": - buf = resource.source - devptr = int(buf.handle) - res_desc.resType = cydriver.CU_RESOURCE_TYPE_LINEAR - res_desc.res.linear.devPtr = devptr - res_desc.res.linear.format = resource._format - res_desc.res.linear.numChannels = resource._num_channels - res_desc.res.linear.sizeInBytes = resource._size_bytes - elif resource.kind == "pitch2d": - buf = resource.source - devptr = int(buf.handle) - res_desc.resType = cydriver.CU_RESOURCE_TYPE_PITCH2D - res_desc.res.pitch2D.devPtr = devptr - res_desc.res.pitch2D.format = resource._format - res_desc.res.pitch2D.numChannels = resource._num_channels - res_desc.res.pitch2D.width = resource._width - res_desc.res.pitch2D.height = resource._height - res_desc.res.pitch2D.pitchInBytes = resource._pitch_bytes - else: - raise NotImplementedError( - f"ResourceDescriptor kind {resource.kind!r} is not yet supported" - ) - - # --- Texture descriptor --- - modes = _normalize_address_modes(texture_descriptor.address_mode) - tex_desc.addressMode[0] = modes[0] - tex_desc.addressMode[1] = modes[1] - tex_desc.addressMode[2] = modes[2] - - if not isinstance(texture_descriptor.filter_mode, FilterMode): - raise TypeError( - f"filter_mode must be a FilterMode, got " - f"{type(texture_descriptor.filter_mode).__name__}" - ) - tex_desc.filterMode = texture_descriptor.filter_mode - - if not isinstance(texture_descriptor.read_mode, ReadMode): - raise TypeError( - f"read_mode must be a ReadMode, got " - f"{type(texture_descriptor.read_mode).__name__}" - ) - - cdef unsigned int flags = 0 - # CU_TRSF_READ_AS_INTEGER suppresses normalization, so it maps to - # ReadMode.ELEMENT_TYPE. - if texture_descriptor.read_mode == ReadMode.ELEMENT_TYPE: - flags |= _TRSF_READ_AS_INTEGER - if texture_descriptor.normalized_coords: - flags |= _TRSF_NORMALIZED_COORDINATES - if texture_descriptor.srgb: - flags |= _TRSF_SRGB - if texture_descriptor.disable_trilinear_optimization: - flags |= _TRSF_DISABLE_TRILINEAR_OPTIMIZATION - if texture_descriptor.seamless_cubemap: - flags |= _TRSF_SEAMLESS_CUBEMAP - tex_desc.flags = flags - - if texture_descriptor.max_anisotropy < 0: - raise ValueError("max_anisotropy must be >= 0") - tex_desc.maxAnisotropy = texture_descriptor.max_anisotropy - - if not isinstance(texture_descriptor.mipmap_filter_mode, FilterMode): - raise TypeError( - f"mipmap_filter_mode must be a FilterMode, got " - f"{type(texture_descriptor.mipmap_filter_mode).__name__}" - ) - tex_desc.mipmapFilterMode = texture_descriptor.mipmap_filter_mode - tex_desc.mipmapLevelBias = texture_descriptor.mipmap_level_bias - tex_desc.minMipmapLevelClamp = texture_descriptor.min_mipmap_level_clamp - tex_desc.maxMipmapLevelClamp = texture_descriptor.max_mipmap_level_clamp - - cdef int i - if texture_descriptor.border_color is None: - for i in range(4): - tex_desc.borderColor[i] = 0.0 - else: - bc = tuple(texture_descriptor.border_color) - if len(bc) != 4: - raise ValueError( - f"border_color must have 4 elements, got {len(bc)}" - ) - for i in range(4): - tex_desc.borderColor[i] = bc[i] - - cdef TexObjectHandle h - if resource.kind == "array": - h = create_tex_object_handle_array(res_desc, tex_desc, arr._handle) - elif resource.kind == "mipmapped_array": - h = create_tex_object_handle_mipmap(res_desc, tex_desc, mip._handle) - else: # linear or pitch2d — both backed by a device Buffer - h = create_tex_object_handle_linear(res_desc, tex_desc, buf._h_ptr) - if not h: - HANDLE_RETURN(get_last_error()) - - cdef TextureObject self = cls.__new__(cls) - self._handle = h - self._source_ref = resource - self._texture_desc = texture_descriptor - self._device_id = _get_current_device_id() - return self - @property def handle(self): """The underlying ``CUtexObject`` as an integer (64-bit kernel arg).""" @@ -547,9 +436,9 @@ cdef class TextureObject: return self._source_ref @property - def texture_descriptor(self): - """The :class:`TextureDescriptor` this texture was built from.""" - return self._texture_desc + def options(self): + """The :class:`TextureObjectOptions` this texture was built from.""" + return self._options @property def device(self): @@ -574,3 +463,126 @@ cdef class TextureObject: def __repr__(self): return f"TextureObject(handle=0x{as_intptr(self._handle):x})" + + +def _create_texture_object(resource, options): + """Create a :class:`TextureObject` on the current device. + + Backs :meth:`cuda.core.Device.create_texture_object`. ``resource`` is a + :class:`ResourceDescriptor`; ``options`` is a :class:`TextureObjectOptions` + (or a mapping accepted by it). + """ + if not isinstance(resource, ResourceDescriptor): + raise TypeError( + f"resource must be a ResourceDescriptor, got " + f"{type(resource).__name__}" + ) + cdef object opts = check_or_create_options( + TextureObjectOptions, options, "Texture object options" + ) + + cdef cydriver.CUDA_RESOURCE_DESC res_desc + cdef cydriver.CUDA_TEXTURE_DESC tex_desc + memset(&res_desc, 0, sizeof(res_desc)) + memset(&tex_desc, 0, sizeof(tex_desc)) + + # --- Resource descriptor --- + cdef OpaqueArray arr + cdef MipmappedArray mip + cdef Buffer buf + cdef intptr_t devptr + if resource.kind == "array": + arr = resource.source + res_desc.resType = cydriver.CU_RESOURCE_TYPE_ARRAY + res_desc.res.array.hArray = as_cu(arr._handle) + elif resource.kind == "mipmapped_array": + mip = resource.source + res_desc.resType = cydriver.CU_RESOURCE_TYPE_MIPMAPPED_ARRAY + res_desc.res.mipmap.hMipmappedArray = as_cu(mip._handle) + elif resource.kind == "linear": + buf = resource.source + devptr = int(buf.handle) + res_desc.resType = cydriver.CU_RESOURCE_TYPE_LINEAR + res_desc.res.linear.devPtr = devptr + res_desc.res.linear.format = resource._format + res_desc.res.linear.numChannels = resource._num_channels + res_desc.res.linear.sizeInBytes = resource._size_bytes + elif resource.kind == "pitch2d": + buf = resource.source + devptr = int(buf.handle) + res_desc.resType = cydriver.CU_RESOURCE_TYPE_PITCH2D + res_desc.res.pitch2D.devPtr = devptr + res_desc.res.pitch2D.format = resource._format + res_desc.res.pitch2D.numChannels = resource._num_channels + res_desc.res.pitch2D.width = resource._width + res_desc.res.pitch2D.height = resource._height + res_desc.res.pitch2D.pitchInBytes = resource._pitch_bytes + else: + raise NotImplementedError( + f"ResourceDescriptor kind {resource.kind!r} is not yet supported" + ) + + # --- Texture descriptor --- + # filter_mode/read_mode/mipmap_filter_mode are normalized to their + # StrEnum types by TextureObjectOptions.__post_init__; address_mode is + # normalized (and str-coerced) here. + modes = _normalize_address_modes(opts.address_mode) + tex_desc.addressMode[0] = _ADDRESSMODE_TO_CU[modes[0]] + tex_desc.addressMode[1] = _ADDRESSMODE_TO_CU[modes[1]] + tex_desc.addressMode[2] = _ADDRESSMODE_TO_CU[modes[2]] + + tex_desc.filterMode = _FILTERMODE_TO_CU[opts.filter_mode] + + cdef unsigned int flags = 0 + # CU_TRSF_READ_AS_INTEGER suppresses normalization, so it maps to + # ReadModeType.ELEMENT_TYPE. + if opts.read_mode == ReadModeType.ELEMENT_TYPE: + flags |= _TRSF_READ_AS_INTEGER + if opts.normalized_coords: + flags |= _TRSF_NORMALIZED_COORDINATES + if opts.srgb: + flags |= _TRSF_SRGB + if opts.disable_trilinear_optimization: + flags |= _TRSF_DISABLE_TRILINEAR_OPTIMIZATION + if opts.seamless_cubemap: + flags |= _TRSF_SEAMLESS_CUBEMAP + tex_desc.flags = flags + + if opts.max_anisotropy < 0: + raise ValueError("max_anisotropy must be >= 0") + tex_desc.maxAnisotropy = opts.max_anisotropy + + tex_desc.mipmapFilterMode = _FILTERMODE_TO_CU[opts.mipmap_filter_mode] + tex_desc.mipmapLevelBias = opts.mipmap_level_bias + tex_desc.minMipmapLevelClamp = opts.min_mipmap_level_clamp + tex_desc.maxMipmapLevelClamp = opts.max_mipmap_level_clamp + + cdef int i + if opts.border_color is None: + for i in range(4): + tex_desc.borderColor[i] = 0.0 + else: + bc = tuple(opts.border_color) + if len(bc) != 4: + raise ValueError( + f"border_color must have 4 elements, got {len(bc)}" + ) + for i in range(4): + tex_desc.borderColor[i] = bc[i] + + cdef TexObjectHandle h + if resource.kind == "array": + h = create_tex_object_handle_array(res_desc, tex_desc, arr._handle) + elif resource.kind == "mipmapped_array": + h = create_tex_object_handle_mipmap(res_desc, tex_desc, mip._handle) + else: # linear or pitch2d — both backed by a device Buffer + h = create_tex_object_handle_linear(res_desc, tex_desc, buf._h_ptr) + if not h: + HANDLE_RETURN(get_last_error()) + + cdef TextureObject self = TextureObject.__new__(TextureObject) + self._handle = h + self._source_ref = resource + self._options = opts + self._device_id = _get_current_device_id() + return self diff --git a/cuda_core/cuda/core/typing.py b/cuda_core/cuda/core/typing.py index 278b516217e..2d253d8ca5e 100644 --- a/cuda_core/cuda/core/typing.py +++ b/cuda_core/cuda/core/typing.py @@ -32,9 +32,12 @@ class StrEnum(str, Enum): from cuda.core._utils.cuda_utils import driver __all__ = [ + "AddressModeType", + "ArrayFormatType", "CompilerBackendType", "DevicePointerType", "DeviceResourcesType", + "FilterModeType", "GraphConditionalType", "GraphMemoryType", "IsStreamType", @@ -42,6 +45,7 @@ class StrEnum(str, Enum): "ObjectCodeFormatType", "PCHStatusType", "ProcessStateType", + "ReadModeType", "SourceCodeType", "VirtualMemoryAccessType", "VirtualMemoryAllocationType", @@ -219,4 +223,77 @@ class VirtualMemoryAllocationType(StrEnum): MANAGED = "managed" +class ArrayFormatType(StrEnum): + """Element format for an :class:`~cuda.core.texture.OpaqueArray` allocation. + + Corresponds to ``CUarray_format`` from the CUDA driver API. Each value maps + 1:1 to a NumPy dtype; the enum is retained as an explicit escape hatch. + + * ``UINT8`` / ``UINT16`` / ``UINT32`` — unsigned integer elements. + * ``INT8`` / ``INT16`` / ``INT32`` — signed integer elements. + * ``FLOAT16`` / ``FLOAT32`` — half- and single-precision float elements. + + .. versionadded:: 1.1.0 + """ + + UINT8 = "uint8" + UINT16 = "uint16" + UINT32 = "uint32" + INT8 = "int8" + INT16 = "int16" + INT32 = "int32" + FLOAT16 = "float16" + FLOAT32 = "float32" + + +class AddressModeType(StrEnum): + """Boundary behavior for out-of-range texture coordinates. + + Corresponds to ``CUaddress_mode`` from the CUDA driver API. + + * ``WRAP`` — wrap coordinates around (tiling). + * ``CLAMP`` — clamp to the edge texel. + * ``MIRROR`` — reflect coordinates at the boundary. + * ``BORDER`` — return the configured border color. + + .. versionadded:: 1.1.0 + """ + + WRAP = "wrap" + CLAMP = "clamp" + MIRROR = "mirror" + BORDER = "border" + + +class FilterModeType(StrEnum): + """Texel sampling mode for a :class:`~cuda.core.texture.TextureObject`. + + Corresponds to ``CUfilter_mode`` from the CUDA driver API. + + * ``POINT`` — nearest-texel sampling. + * ``LINEAR`` — (bi/tri)linear interpolation. + + .. versionadded:: 1.1.0 + """ + + POINT = "point" + LINEAR = "linear" + + +class ReadModeType(StrEnum): + """How sampled values are returned to the kernel. + + * ``ELEMENT_TYPE`` — return the raw element value (integer formats stay + integer, float stays float). + * ``NORMALIZED_FLOAT`` — integer formats are promoted to a normalized + ``float`` in ``[0, 1]`` (unsigned) or ``[-1, 1]`` (signed). Float + formats are unaffected. + + .. versionadded:: 1.1.0 + """ + + ELEMENT_TYPE = "element_type" + NORMALIZED_FLOAT = "normalized_float" + + del StrEnum diff --git a/cuda_core/docs/source/api.rst b/cuda_core/docs/source/api.rst index 5008e66ab74..d0078b073d4 100644 --- a/cuda_core/docs/source/api.rst +++ b/cuda_core/docs/source/api.rst @@ -167,10 +167,13 @@ Textures and surfaces CUDA arrays back bindless texture and surface objects for kernel-side sampled reads and typed load/store. These types live in the :mod:`cuda.core.texture` namespace. :class:`OpaqueArray` is allocated through -:meth:`OpaqueArray.from_descriptor` and bound through a :class:`ResourceDescriptor` -factory; linear (1D) and row-pitched 2D :class:`Buffer` views as well as -mipmapped allocations (:class:`MipmappedArray`) are also supported as texture -backings. +:meth:`cuda.core.Device.create_opaque_array` and bound through a +:class:`ResourceDescriptor` factory; linear (1D) and row-pitched 2D +:class:`Buffer` views as well as mipmapped allocations (:class:`MipmappedArray`, +via :meth:`cuda.core.Device.create_mipmapped_array`) are also supported as +texture backings. Bindless handles are created with +:meth:`cuda.core.Device.create_texture_object` and +:meth:`cuda.core.Device.create_surface_object`. A :class:`OpaqueArray` has an opaque, hardware-defined layout with no linear device pointer, so it cannot participate in ``__cuda_array_interface__`` / @@ -193,15 +196,16 @@ DLPack zero-copy interop. Data is moved in and out only by copying — use :template: dataclass.rst - TextureDescriptor + OpaqueArrayOptions + MipmappedArrayOptions + TextureObjectOptions -.. autosummary:: - :toctree: generated/ - - ArrayFormat - AddressMode - FilterMode - ReadMode +The associated enumerations — +:class:`~cuda.core.typing.ArrayFormatType`, +:class:`~cuda.core.typing.AddressModeType`, +:class:`~cuda.core.typing.FilterModeType`, and +:class:`~cuda.core.typing.ReadModeType` — live in :mod:`cuda.core.typing` +alongside the other ``cuda.core`` enumerations. CUDA compilation toolchain diff --git a/cuda_core/docs/source/api_private.rst b/cuda_core/docs/source/api_private.rst index f8ce51d6a3a..907fc2f5bcf 100644 --- a/cuda_core/docs/source/api_private.rst +++ b/cuda_core/docs/source/api_private.rst @@ -21,15 +21,19 @@ CUDA runtime _module.KernelOccupancy _module.MaxPotentialBlockSizeOccupancyResult _module.ParamInfo + typing.AddressModeType + typing.ArrayFormatType typing.CompilerBackendType typing.DevicePointerType typing.DeviceResourcesType + typing.FilterModeType typing.GraphConditionalType typing.GraphMemoryType typing.ManagedMemoryLocationType typing.ObjectCodeFormatType typing.PCHStatusType typing.ProcessStateType + typing.ReadModeType typing.SourceCodeType typing.VirtualMemoryAccessType typing.VirtualMemoryAllocationType diff --git a/cuda_core/examples/gl_interop_fluid.py b/cuda_core/examples/gl_interop_fluid.py index e2cdb1037e2..68259d32e3b 100644 --- a/cuda_core/examples/gl_interop_fluid.py +++ b/cuda_core/examples/gl_interop_fluid.py @@ -108,15 +108,15 @@ launch, ) from cuda.core.texture import ( - AddressMode, - ArrayFormat, - FilterMode, - OpaqueArray, - ReadMode, + OpaqueArrayOptions, ResourceDescriptor, - SurfaceObject, - TextureDescriptor, - TextureObject, + TextureObjectOptions, +) +from cuda.core.typing import ( + AddressModeType, + ArrayFormatType, + FilterModeType, + ReadModeType, ) # --------------------------------------------------------------------------- @@ -398,13 +398,13 @@ def draw_fullscreen_quad(gl, shader_prog, vao_id, tex_id): # ============================ API MAP (cuda.core) =========================== # # The three helpers below are where every OpaqueArray / ResourceDescriptor / -# TextureDescriptor / TextureObject / SurfaceObject knob in this example is set. +# TextureObjectOptions / TextureObject / SurfaceObject knob in this example is set. # Each visible setting maps to a concrete piece of cuda.core / CUDA behavior: # -# OpaqueArray.from_descriptor(...) -> allocates a CUDA *array* (opaque, tiled +# Device.create_opaque_array(...) -> allocates a CUDA *array* (opaque, tiled # layout optimized for 2D texture fetches), # not linear device memory. -# ArrayFormat.FLOAT32 -> each channel is a 32-bit float texel. +# ArrayFormatType.FLOAT32 -> each channel is a 32-bit float texel. # num_channels=2 / num_channels=1 -> float2 (vx, vy) vs scalar (pressure / # divergence / dye); also fixes the # surf2Dwrite byte offset per element. @@ -414,22 +414,22 @@ def draw_fullscreen_quad(gl, shader_prog, vao_id, tex_id): # is what lets each field be sampled and # then written back in the ping-pong. # -# ResourceDescriptor.from_array(arr) -> wraps the OpaqueArray as the resource a -# TextureObject reads from. -# FilterMode.LINEAR -> free HARDWARE bilinear interpolation; +# ResourceDescriptor.from_opaque_array -> wraps the OpaqueArray as the resource a +# TextureObject reads from. +# FilterModeType.LINEAR -> free HARDWARE bilinear interpolation; # this is what makes semi-Lagrangian # advection a single tex2D fetch at a # fractional back-traced position (no # manual lerp, no neighbor gather). -# AddressMode.CLAMP -> bounded box boundary: out-of-range traces +# AddressModeType.CLAMP -> bounded box boundary: out-of-range traces # read the edge texel (ink piles up at the # walls instead of wrapping like a torus). -# ReadMode.ELEMENT_TYPE -> return the stored float value as-is (no +# ReadModeType.ELEMENT_TYPE -> return the stored float value as-is (no # integer->[0,1] normalization of texels). # normalized_coords=True -> sample in [0, 1) so CLAMP is well-defined # and texel centers are (i + 0.5) / N. # -# SurfaceObject.from_array(arr) -> binds the array for surf2Dread/surf2Dwrite. +# make_surface(arr) -> binds the array for surf2Dread/surf2Dwrite. # The x coordinate is in BYTES, so it is # x * sizeof(elem): sizeof(float2)=8 for # velocity, sizeof(float)=4 for the scalars. @@ -438,21 +438,25 @@ def draw_fullscreen_quad(gl, shader_prog, vao_id, tex_id): def make_velocity_array(): """Allocate a `float2` velocity CUDA array (channel 0 = vx, channel 1 = vy).""" - return OpaqueArray.from_descriptor( - shape=(WIDTH, HEIGHT), - format=ArrayFormat.FLOAT32, - num_channels=2, - is_surface_load_store=True, + return Device().create_opaque_array( + OpaqueArrayOptions( + shape=(WIDTH, HEIGHT), + format=ArrayFormatType.FLOAT32, + num_channels=2, + is_surface_load_store=True, + ) ) def make_scalar_array(): """Allocate a single-channel `float` CUDA array (pressure / divergence / dye).""" - return OpaqueArray.from_descriptor( - shape=(WIDTH, HEIGHT), - format=ArrayFormat.FLOAT32, - num_channels=1, - is_surface_load_store=True, + return Device().create_opaque_array( + OpaqueArrayOptions( + shape=(WIDTH, HEIGHT), + format=ArrayFormatType.FLOAT32, + num_channels=1, + is_surface_load_store=True, + ) ) @@ -464,11 +468,13 @@ def make_color_array(): surface-write machinery as the scalar fields -- only the channel count (and the surf2Dwrite byte stride, sizeof(float4) = 16) differ. """ - return OpaqueArray.from_descriptor( - shape=(WIDTH, HEIGHT), - format=ArrayFormat.FLOAT32, - num_channels=4, - is_surface_load_store=True, + return Device().create_opaque_array( + OpaqueArrayOptions( + shape=(WIDTH, HEIGHT), + format=ArrayFormatType.FLOAT32, + num_channels=4, + is_surface_load_store=True, + ) ) @@ -479,16 +485,22 @@ def make_texture(arr): needs the bilinear interpolation, and the stencil reads (divergence, Jacobi, gradient) sample exactly at texel centers so LINEAR returns the exact value. """ - res_desc = ResourceDescriptor.from_array(arr) - tex_desc = TextureDescriptor( - address_mode=AddressMode.CLAMP, - filter_mode=FilterMode.LINEAR, - read_mode=ReadMode.ELEMENT_TYPE, + res_desc = ResourceDescriptor.from_opaque_array(arr) + tex_desc = TextureObjectOptions( + address_mode=AddressModeType.CLAMP, + filter_mode=FilterModeType.LINEAR, + read_mode=ReadModeType.ELEMENT_TYPE, # Normalized coordinates keep CLAMP addressing well-defined and let us # sample at texel centers as (i + 0.5) / N. normalized_coords=True, ) - return TextureObject.from_descriptor(resource=res_desc, texture_descriptor=tex_desc) + return Device().create_texture_object(resource=res_desc, options=tex_desc) + + +def make_surface(arr): + """Bind `arr` as a SurfaceObject for raw surf2Dwrite writes.""" + res_desc = ResourceDescriptor.from_opaque_array(arr) + return Device().create_surface_object(resource=res_desc) def seed_field(stream, kernels, config, vel_surf, dye_surf, prs_surf, seed_value): @@ -552,25 +564,25 @@ def main(): # up front and keep them alive for the whole run. # API MAP: make_texture binds an array as a read-only TextureObject # (LINEAR + CLAMP + normalized; see the API MAP block above), while - # SurfaceObject.from_array binds the SAME array for raw surf2Dwrite + # make_surface binds the SAME array for raw surf2Dwrite # writes -- the read/write halves of one ping-pong buffer. vel_tex_a = make_texture(vel_a) vel_tex_b = make_texture(vel_b) - vel_surf_a = SurfaceObject.from_array(vel_a) - vel_surf_b = SurfaceObject.from_array(vel_b) + vel_surf_a = make_surface(vel_a) + vel_surf_b = make_surface(vel_b) prs_tex_a = make_texture(prs_a) prs_tex_b = make_texture(prs_b) - prs_surf_a = SurfaceObject.from_array(prs_a) - prs_surf_b = SurfaceObject.from_array(prs_b) + prs_surf_a = make_surface(prs_a) + prs_surf_b = make_surface(prs_b) div_tex = make_texture(div) - div_surf = SurfaceObject.from_array(div) + div_surf = make_surface(div) dye_tex_a = make_texture(dye_a) dye_tex_b = make_texture(dye_b) - dye_surf_a = SurfaceObject.from_array(dye_a) - dye_surf_b = SurfaceObject.from_array(dye_b) + dye_surf_a = make_surface(dye_a) + dye_surf_b = make_surface(dye_b) # --- Step 8: Seed the initial field (curl into vel_a, zero pressure/dye) --- seed_field(stream, kernels, config, vel_surf_a, dye_surf_a, prs_surf_a, seed_value=0) diff --git a/cuda_core/examples/gl_interop_fluid_numba_cuda_mlir.py b/cuda_core/examples/gl_interop_fluid_numba_cuda_mlir.py index 8500c3d54c9..791b3bd67df 100644 --- a/cuda_core/examples/gl_interop_fluid_numba_cuda_mlir.py +++ b/cuda_core/examples/gl_interop_fluid_numba_cuda_mlir.py @@ -23,7 +23,7 @@ # -------------------------------------- ----------------------------------- # OpaqueArray(num_channels=2) as texture -> cuda.device_array((H, W, 2), f32) # tex2D(tex, u, v) [HW LINEAR] -> sample_vec(arr, px, py) [manual lerp] -# AddressMode.CLAMP -> index clamp inside sample_*() +# AddressModeType.CLAMP -> index clamp inside sample_*() # surf2Dwrite(v, surf, x*8, y) -> arr[y, x, 0] = v.x; arr[y, x, 1] = v.y # TextureObject + SurfaceObject pair -> one device array; ping-pong by swap # GraphicsResource PBO (zero-copy) -> copy_to_host + glTexSubImage2D @@ -91,7 +91,7 @@ @cuda.jit(device=True, inline=True) def _clampi(i, n): - # AddressMode.CLAMP: out-of-range coordinates read the border texel. + # AddressModeType.CLAMP: out-of-range coordinates read the border texel. if i < 0: return 0 if i > n - 1: diff --git a/cuda_core/examples/gl_interop_mipmap_lod.py b/cuda_core/examples/gl_interop_mipmap_lod.py index ea82ddbd640..8c13b17c8ed 100644 --- a/cuda_core/examples/gl_interop_mipmap_lod.py +++ b/cuda_core/examples/gl_interop_mipmap_lod.py @@ -101,15 +101,15 @@ launch, ) from cuda.core.texture import ( - AddressMode, - ArrayFormat, - FilterMode, - MipmappedArray, - ReadMode, + MipmappedArrayOptions, ResourceDescriptor, - SurfaceObject, - TextureDescriptor, - TextureObject, + TextureObjectOptions, +) +from cuda.core.typing import ( + AddressModeType, + ArrayFormatType, + FilterModeType, + ReadModeType, ) # --------------------------------------------------------------------------- @@ -183,7 +183,7 @@ def build_mipmap_pyramid(mip, num_levels, stream, kernels): """ # ---- Level 0: seed the base image ------------------------------------- base_arr = mip.get_level(0) # non-owning view; do NOT use a `with` block - with SurfaceObject.from_array(base_arr) as base_surf: + with Device().create_surface_object(resource=ResourceDescriptor.from_opaque_array(base_arr)) as base_surf: block = (16, 16, 1) grid = ( (BASE_SIZE + block[0] - 1) // block[0], @@ -205,10 +205,10 @@ def build_mipmap_pyramid(mip, num_levels, stream, kernels): # Each iteration reads level (L-1) through a temporary TextureObject and # writes level L through a temporary SurfaceObject. Both close cleanly # at the end of their `with` blocks. - src_tex_desc = TextureDescriptor( - address_mode=AddressMode.CLAMP, - filter_mode=FilterMode.POINT, # explicit per-texel reads - read_mode=ReadMode.ELEMENT_TYPE, + src_tex_desc = TextureObjectOptions( + address_mode=AddressModeType.CLAMP, + filter_mode=FilterModeType.POINT, # explicit per-texel reads + read_mode=ReadModeType.ELEMENT_TYPE, normalized_coords=False, # integer pixel coordinates ) for level in range(1, num_levels): @@ -219,10 +219,10 @@ def build_mipmap_pyramid(mip, num_levels, stream, kernels): src_arr = mip.get_level(level - 1) dst_arr = mip.get_level(level) - src_res = ResourceDescriptor.from_array(src_arr) + src_res = ResourceDescriptor.from_opaque_array(src_arr) with ( - TextureObject.from_descriptor(resource=src_res, texture_descriptor=src_tex_desc) as src_tex, - SurfaceObject.from_array(dst_arr) as dst_surf, + Device().create_texture_object(resource=src_res, options=src_tex_desc) as src_tex, + Device().create_surface_object(resource=ResourceDescriptor.from_opaque_array(dst_arr)) as dst_surf, ): block = (16, 16, 1) grid = ( @@ -408,12 +408,14 @@ def main(): # --- Step 2: Allocate the mipmap pyramid and build every level --- # is_surface_load_store=True is required for kernel-side writes. num_levels = int(math.log2(BASE_SIZE)) + 1 - mip = MipmappedArray.from_descriptor( - shape=(BASE_SIZE, BASE_SIZE), - format=ArrayFormat.FLOAT32, - num_channels=4, - num_levels=num_levels, - is_surface_load_store=True, + mip = Device().create_mipmapped_array( + MipmappedArrayOptions( + shape=(BASE_SIZE, BASE_SIZE), + format=ArrayFormatType.FLOAT32, + num_channels=4, + num_levels=num_levels, + is_surface_load_store=True, + ) ) build_mipmap_pyramid(mip, num_levels, stream, kernels) @@ -423,19 +425,19 @@ def main(): # receives the user-controlled bias as a kernel argument and folds # it into the tex2DLod call (avoids rebuilding the TextureObject # whenever the user changes the bias). - display_tex_desc = TextureDescriptor( - address_mode=AddressMode.WRAP, - filter_mode=FilterMode.LINEAR, - read_mode=ReadMode.ELEMENT_TYPE, + display_tex_desc = TextureObjectOptions( + address_mode=AddressModeType.WRAP, + filter_mode=FilterModeType.LINEAR, + read_mode=ReadModeType.ELEMENT_TYPE, normalized_coords=True, - mipmap_filter_mode=FilterMode.LINEAR, # trilinear + mipmap_filter_mode=FilterModeType.LINEAR, # trilinear mipmap_level_bias=0.0, min_mipmap_level_clamp=0.0, max_mipmap_level_clamp=float(num_levels - 1), ) - display_tex = TextureObject.from_descriptor( + display_tex = Device().create_texture_object( resource=ResourceDescriptor.from_mipmapped_array(mip), - texture_descriptor=display_tex_desc, + options=display_tex_desc, ) # --- Step 4: Open a window and set up the GL/CUDA bridge --- diff --git a/cuda_core/examples/texture_sample.py b/cuda_core/examples/texture_sample.py index e69655eb479..952c77c48ca 100644 --- a/cuda_core/examples/texture_sample.py +++ b/cuda_core/examples/texture_sample.py @@ -30,14 +30,15 @@ launch, ) from cuda.core.texture import ( - AddressMode, - ArrayFormat, - FilterMode, - OpaqueArray, - ReadMode, + OpaqueArrayOptions, ResourceDescriptor, - TextureDescriptor, - TextureObject, + TextureObjectOptions, +) +from cuda.core.typing import ( + AddressModeType, + ArrayFormatType, + FilterModeType, + ReadModeType, ) # Kernel reads N (x, y) coordinates from `coords` (interleaved float pairs) and @@ -66,14 +67,16 @@ def main(): pinned_mr = LegacyPinnedMemoryResource() try: # Allocate a 2D OpaqueArray: shape=(W, H), single-channel float32. - # Note: OpaqueArray.from_descriptor takes shape=(width, height), so the host + # Note: create_opaque_array takes shape=(width, height), so the host # buffer fed into copy_from must be laid out as H rows of W elements # (row-major), i.e. host_pattern.shape == (H, W). width, height = 16, 16 - with OpaqueArray.from_descriptor( - shape=(width, height), - format=ArrayFormat.FLOAT32, - num_channels=1, + with Device().create_opaque_array( + OpaqueArrayOptions( + shape=(width, height), + format=ArrayFormatType.FLOAT32, + num_channels=1, + ) ) as arr: # Plant a known pattern: pattern[y, x] = x + 100*y. # Cast to float32 so the byte count matches the array's storage. @@ -87,14 +90,14 @@ def main(): arr.copy_from(pattern, stream=stream) # Build a linear-filtering, clamped, non-normalized texture. - res_desc = ResourceDescriptor.from_array(arr) - tex_desc = TextureDescriptor( - address_mode=AddressMode.CLAMP, - filter_mode=FilterMode.LINEAR, - read_mode=ReadMode.ELEMENT_TYPE, + res_desc = ResourceDescriptor.from_opaque_array(arr) + tex_desc = TextureObjectOptions( + address_mode=AddressModeType.CLAMP, + filter_mode=FilterModeType.LINEAR, + read_mode=ReadModeType.ELEMENT_TYPE, normalized_coords=False, ) - with TextureObject.from_descriptor(resource=res_desc, texture_descriptor=tex_desc) as tex: + with Device().create_texture_object(resource=res_desc, options=tex_desc) as tex: _run_kernel_and_verify(dev, stream, tex, pattern, width, height, pinned_mr) finally: stream.close() diff --git a/cuda_core/tests/test_enum_coverage.py b/cuda_core/tests/test_enum_coverage.py index 308614679c8..09c12bbaf52 100644 --- a/cuda_core/tests/test_enum_coverage.py +++ b/cuda_core/tests/test_enum_coverage.py @@ -98,6 +98,25 @@ }, set(), ), + # AddressModeType / FilterModeType are 1:1 wrappers of small driver enums. + # The texture mapping dicts (_ADDRESSMODE_TO_CU / _FILTERMODE_TO_CU) store + # plain ints keyed on cydriver values, not driver. members, so they + # are incompatible with the isinstance-based mapping check. Use the + # mapping=None form, which count-checks the StrEnum against the binding enum. + ( + driver.CUaddress_mode, + cuda.core.typing.AddressModeType, + None, + set(), + set(), + ), + ( + driver.CUfilter_mode, + cuda.core.typing.FilterModeType, + None, + set(), + set(), + ), ] if system.CUDA_BINDINGS_NVML_IS_COMPATIBLE: @@ -278,6 +297,16 @@ cuda.core.typing.SourceCodeType, # This enum is dynamic depending on the version of CTK installed. cuda.core.typing.VirtualMemoryAllocationType, + # ArrayFormatType wraps CUarray_format, but intentionally exposes only the + # 8 NumPy-representable formats out of the driver's ~67 members (BC1..BC7, + # UNORM_INTx, packed/planar YUV, etc. are deliberately unsupported for now). + # It is a curated subset, not a 1:1 wrapper, so a count/coverage check + # against the binding enum does not apply. + cuda.core.typing.ArrayFormatType, + # ReadModeType (ELEMENT_TYPE / NORMALIZED_FLOAT) has no backing cuda_binding + # enum: it maps to the presence/absence of the CU_TRSF_READ_AS_INTEGER + # texture-descriptor flag bit, not to a CUenum. + cuda.core.typing.ReadModeType, } diff --git a/cuda_core/tests/test_texture_surface.py b/cuda_core/tests/test_texture_surface.py index 1a6d05e65a2..bee60104be7 100644 --- a/cuda_core/tests/test_texture_surface.py +++ b/cuda_core/tests/test_texture_surface.py @@ -3,6 +3,7 @@ import gc +import numpy as np import pytest import cuda.core @@ -10,16 +11,17 @@ Device, ) from cuda.core.texture import ( - AddressMode, - ArrayFormat, - FilterMode, - MipmappedArray, + MipmappedArrayOptions, OpaqueArray, - ReadMode, + OpaqueArrayOptions, ResourceDescriptor, - SurfaceObject, - TextureDescriptor, - TextureObject, + TextureObjectOptions, +) +from cuda.core.typing import ( + AddressModeType, + ArrayFormatType, + FilterModeType, + ReadModeType, ) @@ -44,12 +46,14 @@ def test_resource_descriptor_init_disabled(): def test_array_2d_create_and_properties(init_cuda): - arr = OpaqueArray.from_descriptor(shape=(32, 16), format=ArrayFormat.FLOAT32, num_channels=1) + arr = Device().create_opaque_array( + OpaqueArrayOptions(shape=(32, 16), format=ArrayFormatType.FLOAT32, num_channels=1) + ) try: assert arr.shape == (32, 16) - assert arr.format == ArrayFormat.FLOAT32 + assert arr.format == ArrayFormatType.FLOAT32 assert arr.num_channels == 1 - assert arr.element_size == 4 + assert arr.element_bytes == 4 assert arr.size_bytes == 32 * 16 * 4 assert arr.is_surface_load_store is False assert arr.handle != 0 @@ -59,28 +63,66 @@ def test_array_2d_create_and_properties(init_cuda): def test_array_3d_with_surface_flag(init_cuda): - arr = OpaqueArray.from_descriptor( - shape=(8, 8, 4), - format=ArrayFormat.UINT8, - num_channels=4, - is_surface_load_store=True, + arr = Device().create_opaque_array( + OpaqueArrayOptions( + shape=(8, 8, 4), + format=ArrayFormatType.UINT8, + num_channels=4, + is_surface_load_store=True, + ) ) try: assert arr.shape == (8, 8, 4) assert arr.is_surface_load_store is True - assert arr.element_size == 4 + assert arr.element_bytes == 4 + finally: + arr.close() + + +@pytest.mark.agent_authored(model="claude-opus-4.8") +@pytest.mark.parametrize( + "dtype, expected", + [ + (np.float32, ArrayFormatType.FLOAT32), + (np.dtype("float16"), ArrayFormatType.FLOAT16), + (np.uint8, ArrayFormatType.UINT8), + (np.dtype("i4"), ArrayFormatType.INT32), + ], +) +def test_array_accepts_numpy_dtype_format(init_cuda, dtype, expected): + arr = Device().create_opaque_array(OpaqueArrayOptions(shape=(8, 8), format=dtype, num_channels=1)) + try: + assert arr.format == expected + finally: + arr.close() + + +@pytest.mark.agent_authored(model="claude-opus-4.8") +def test_array_accepts_str_format(init_cuda): + arr = Device().create_opaque_array(OpaqueArrayOptions(shape=(8, 8), format="float32", num_channels=1)) + try: + assert arr.format == ArrayFormatType.FLOAT32 finally: arr.close() +@pytest.mark.agent_authored(model="claude-opus-4.8") +def test_array_rejects_unsupported_dtype_format(init_cuda): + # float64 has no ArrayFormatType equivalent. + with pytest.raises(ValueError, match="no ArrayFormatType equivalent"): + Device().create_opaque_array(OpaqueArrayOptions(shape=(8,), format=np.float64, num_channels=1)) + + def test_array_rejects_bad_channels(init_cuda): with pytest.raises(ValueError, match="num_channels"): - OpaqueArray.from_descriptor(shape=(8,), format=ArrayFormat.UINT8, num_channels=3) + Device().create_opaque_array(OpaqueArrayOptions(shape=(8,), format=ArrayFormatType.UINT8, num_channels=3)) def test_array_rejects_bad_rank(init_cuda): with pytest.raises(ValueError, match="shape rank"): - OpaqueArray.from_descriptor(shape=(2, 2, 2, 2), format=ArrayFormat.UINT8, num_channels=1) + Device().create_opaque_array( + OpaqueArrayOptions(shape=(2, 2, 2, 2), format=ArrayFormatType.UINT8, num_channels=1) + ) def test_array_roundtrip_copy(init_cuda): @@ -88,7 +130,7 @@ def test_array_roundtrip_copy(init_cuda): device = Device() stream = device.create_stream() - arr = OpaqueArray.from_descriptor(shape=(16,), format=ArrayFormat.UINT32, num_channels=1) + arr = Device().create_opaque_array(OpaqueArrayOptions(shape=(16,), format=ArrayFormatType.UINT32, num_channels=1)) try: src = _array.array("I", list(range(16))) dst = _array.array("I", [0] * 16) @@ -108,7 +150,7 @@ def test_array_copy_rejects_undersized_host_buffer(init_cuda): device = Device() stream = device.create_stream() - arr = OpaqueArray.from_descriptor(shape=(16,), format=ArrayFormat.UINT32, num_channels=1) + arr = Device().create_opaque_array(OpaqueArrayOptions(shape=(16,), format=ArrayFormatType.UINT32, num_channels=1)) try: # arr is 16 * 4 = 64 bytes; pass an 8-element (32-byte) host buffer. too_small = _array.array("I", [0] * 8) @@ -124,7 +166,7 @@ def test_array_copy_rejects_undersized_host_buffer(init_cuda): def test_array_copy_rejects_undersized_device_buffer(init_cuda): device = Device() stream = device.create_stream() - arr = OpaqueArray.from_descriptor(shape=(16,), format=ArrayFormat.UINT32, num_channels=1) + arr = Device().create_opaque_array(OpaqueArrayOptions(shape=(16,), format=ArrayFormatType.UINT32, num_channels=1)) # arr is 64 bytes; allocate a 32-byte device buffer. small_buf = device.memory_resource.allocate(32, stream=device.default_stream) try: @@ -139,20 +181,22 @@ def test_array_copy_rejects_undersized_device_buffer(init_cuda): def test_texture_object_create(init_cuda): - arr = OpaqueArray.from_descriptor(shape=(32, 16), format=ArrayFormat.FLOAT32, num_channels=1) + arr = Device().create_opaque_array( + OpaqueArrayOptions(shape=(32, 16), format=ArrayFormatType.FLOAT32, num_channels=1) + ) try: - res = ResourceDescriptor.from_array(arr) - tex_desc = TextureDescriptor( - address_mode=AddressMode.CLAMP, - filter_mode=FilterMode.LINEAR, - read_mode=ReadMode.ELEMENT_TYPE, + res = ResourceDescriptor.from_opaque_array(arr) + tex_desc = TextureObjectOptions( + address_mode=AddressModeType.CLAMP, + filter_mode=FilterModeType.LINEAR, + read_mode=ReadModeType.ELEMENT_TYPE, normalized_coords=True, ) - tex = TextureObject.from_descriptor(resource=res, texture_descriptor=tex_desc) + tex = Device().create_texture_object(resource=res, options=tex_desc) try: assert tex.handle != 0 assert tex.resource is res - assert tex.texture_descriptor is tex_desc + assert tex.options is tex_desc finally: tex.close() finally: @@ -160,14 +204,16 @@ def test_texture_object_create(init_cuda): def test_surface_object_create(init_cuda): - arr = OpaqueArray.from_descriptor( - shape=(8, 8), - format=ArrayFormat.UINT8, - num_channels=4, - is_surface_load_store=True, + arr = Device().create_opaque_array( + OpaqueArrayOptions( + shape=(8, 8), + format=ArrayFormatType.UINT8, + num_channels=4, + is_surface_load_store=True, + ) ) try: - surf = SurfaceObject.from_array(arr) + surf = Device().create_surface_object(resource=ResourceDescriptor.from_opaque_array(arr)) try: assert surf.handle != 0 assert isinstance(surf.resource, ResourceDescriptor) @@ -178,10 +224,10 @@ def test_surface_object_create(init_cuda): def test_surface_requires_ldst_flag(init_cuda): - arr = OpaqueArray.from_descriptor(shape=(8, 8), format=ArrayFormat.UINT8, num_channels=4) + arr = Device().create_opaque_array(OpaqueArrayOptions(shape=(8, 8), format=ArrayFormatType.UINT8, num_channels=4)) try: with pytest.raises(ValueError, match="is_surface_load_store=True"): - SurfaceObject.from_array(arr) + Device().create_surface_object(resource=ResourceDescriptor.from_opaque_array(arr)) finally: arr.close() @@ -191,28 +237,30 @@ def test_address_mode_normalization(init_cuda): # 3-tuple; a shorter tuple should be padded by repeating the last entry. from cuda.core.texture._texture import _normalize_address_modes - assert _normalize_address_modes(AddressMode.WRAP) == ( - AddressMode.WRAP, - AddressMode.WRAP, - AddressMode.WRAP, + assert _normalize_address_modes(AddressModeType.WRAP) == ( + AddressModeType.WRAP, + AddressModeType.WRAP, + AddressModeType.WRAP, ) - assert _normalize_address_modes((AddressMode.WRAP, AddressMode.CLAMP)) == ( - AddressMode.WRAP, - AddressMode.CLAMP, - AddressMode.CLAMP, + assert _normalize_address_modes((AddressModeType.WRAP, AddressModeType.CLAMP)) == ( + AddressModeType.WRAP, + AddressModeType.CLAMP, + AddressModeType.CLAMP, ) - assert _normalize_address_modes((AddressMode.WRAP, AddressMode.CLAMP, AddressMode.MIRROR)) == ( - AddressMode.WRAP, - AddressMode.CLAMP, - AddressMode.MIRROR, + assert _normalize_address_modes((AddressModeType.WRAP, AddressModeType.CLAMP, AddressModeType.MIRROR)) == ( + AddressModeType.WRAP, + AddressModeType.CLAMP, + AddressModeType.MIRROR, ) # Smoke test: a 2-entry tuple is also accepted end-to-end. - arr = OpaqueArray.from_descriptor(shape=(8, 8, 4), format=ArrayFormat.FLOAT32, num_channels=1) + arr = Device().create_opaque_array( + OpaqueArrayOptions(shape=(8, 8, 4), format=ArrayFormatType.FLOAT32, num_channels=1) + ) try: - res = ResourceDescriptor.from_array(arr) - tex_desc = TextureDescriptor(address_mode=(AddressMode.WRAP, AddressMode.CLAMP)) - tex = TextureObject.from_descriptor(resource=res, texture_descriptor=tex_desc) + res = ResourceDescriptor.from_opaque_array(arr) + tex_desc = TextureObjectOptions(address_mode=(AddressModeType.WRAP, AddressModeType.CLAMP)) + tex = Device().create_texture_object(resource=res, options=tex_desc) try: assert tex.handle != 0 finally: @@ -233,9 +281,9 @@ def test_resource_descriptor_from_linear_defaults_size(init_cuda): device = Device() buf = _alloc_device_buffer(device, 4096) try: - res = ResourceDescriptor.from_linear(buf, format=ArrayFormat.FLOAT32, num_channels=1) + res = ResourceDescriptor.from_linear(buf, format=ArrayFormatType.FLOAT32, num_channels=1) assert res.kind == "linear" - assert res.format == ArrayFormat.FLOAT32 + assert res.format == ArrayFormatType.FLOAT32 assert res.num_channels == 1 assert res.source is buf # repr should include the kind/format hint @@ -248,7 +296,7 @@ def test_resource_descriptor_from_linear_size_override(init_cuda): device = Device() buf = _alloc_device_buffer(device, 4096) try: - res = ResourceDescriptor.from_linear(buf, format=ArrayFormat.UINT32, num_channels=1, size_bytes=2048) + res = ResourceDescriptor.from_linear(buf, format=ArrayFormatType.UINT32, num_channels=1, size_bytes=2048) assert res._size_bytes == 2048 finally: buf.close() @@ -259,7 +307,7 @@ def test_resource_descriptor_from_linear_rejects_oversize(init_cuda): buf = _alloc_device_buffer(device, 1024) try: with pytest.raises(ValueError, match="exceeds buffer.size"): - ResourceDescriptor.from_linear(buf, format=ArrayFormat.UINT8, num_channels=1, size_bytes=2048) + ResourceDescriptor.from_linear(buf, format=ArrayFormatType.UINT8, num_channels=1, size_bytes=2048) finally: buf.close() @@ -269,14 +317,14 @@ def test_resource_descriptor_from_linear_rejects_bad_channels(init_cuda): buf = _alloc_device_buffer(device, 1024) try: with pytest.raises(ValueError, match="num_channels"): - ResourceDescriptor.from_linear(buf, format=ArrayFormat.UINT8, num_channels=3) + ResourceDescriptor.from_linear(buf, format=ArrayFormatType.UINT8, num_channels=3) finally: buf.close() def test_resource_descriptor_from_linear_rejects_non_buffer(): with pytest.raises(TypeError, match="Buffer"): - ResourceDescriptor.from_linear(object(), format=ArrayFormat.UINT8, num_channels=1) + ResourceDescriptor.from_linear(object(), format=ArrayFormatType.UINT8, num_channels=1) def test_resource_descriptor_from_linear_rejects_zero_size(init_cuda): @@ -284,7 +332,7 @@ def test_resource_descriptor_from_linear_rejects_zero_size(init_cuda): buf = _alloc_device_buffer(device, 1024) try: with pytest.raises(ValueError, match="at least one element"): - ResourceDescriptor.from_linear(buf, format=ArrayFormat.UINT32, num_channels=1, size_bytes=0) + ResourceDescriptor.from_linear(buf, format=ArrayFormatType.UINT32, num_channels=1, size_bytes=0) finally: buf.close() @@ -295,7 +343,7 @@ def test_resource_descriptor_from_linear_rejects_non_multiple(init_cuda): try: # UINT32 x 1 channel = 4 bytes/element; 10 bytes is not a multiple. with pytest.raises(ValueError, match="multiple of element size"): - ResourceDescriptor.from_linear(buf, format=ArrayFormat.UINT32, num_channels=1, size_bytes=10) + ResourceDescriptor.from_linear(buf, format=ArrayFormatType.UINT32, num_channels=1, size_bytes=10) finally: buf.close() @@ -307,8 +355,8 @@ def test_texture_object_from_linear(init_cuda): # 1024 float elements buf = _alloc_device_buffer(device, 1024 * 4) try: - res = ResourceDescriptor.from_linear(buf, format=ArrayFormat.FLOAT32, num_channels=1) - tex = TextureObject.from_descriptor(resource=res, texture_descriptor=TextureDescriptor()) + res = ResourceDescriptor.from_linear(buf, format=ArrayFormatType.FLOAT32, num_channels=1) + tex = Device().create_texture_object(resource=res, options=TextureObjectOptions()) try: assert tex.handle != 0 assert tex.resource is res @@ -322,15 +370,15 @@ def test_resource_descriptor_from_pitch2d_validates_pitch(init_cuda): device = Device() buf = _alloc_device_buffer(device, 64 * 1024) try: - # element_size = 4 (UINT32 * 1 channel); width=16 -> min_pitch=64 + # element_bytes = 4 (UINT32 * 1 channel); width=16 -> min_pitch=64 with pytest.raises(ValueError, match="pitch_bytes"): ResourceDescriptor.from_pitch2d( buf, - format=ArrayFormat.UINT32, + format=ArrayFormatType.UINT32, num_channels=1, width=16, height=8, - pitch_bytes=32, # < 64 = width*element_size + pitch_bytes=32, # < 64 = width*element_bytes ) finally: buf.close() @@ -343,7 +391,7 @@ def test_resource_descriptor_from_pitch2d_validates_buffer_size(init_cuda): with pytest.raises(ValueError, match="exceeds buffer.size"): ResourceDescriptor.from_pitch2d( buf, - format=ArrayFormat.UINT8, + format=ArrayFormatType.UINT8, num_channels=4, width=64, height=128, @@ -370,7 +418,7 @@ def test_texture_object_from_pitch2d(init_cuda): try: res = ResourceDescriptor.from_pitch2d( buf, - format=ArrayFormat.UINT8, + format=ArrayFormatType.UINT8, num_channels=4, width=32, height=height, @@ -378,7 +426,7 @@ def test_texture_object_from_pitch2d(init_cuda): ) assert res.kind == "pitch2d" assert "pitch2d" in repr(res) - tex = TextureObject.from_descriptor(resource=res, texture_descriptor=TextureDescriptor()) + tex = Device().create_texture_object(resource=res, options=TextureObjectOptions()) try: assert tex.handle != 0 finally: @@ -391,20 +439,20 @@ def test_surface_rejects_linear_and_pitch2d(init_cuda): device = Device() buf = _alloc_device_buffer(device, 4096) try: - res_lin = ResourceDescriptor.from_linear(buf, format=ArrayFormat.UINT32, num_channels=1) + res_lin = ResourceDescriptor.from_linear(buf, format=ArrayFormatType.UINT32, num_channels=1) with pytest.raises(ValueError, match="array-backed"): - SurfaceObject.from_descriptor(resource=res_lin) + Device().create_surface_object(resource=res_lin) res_p2 = ResourceDescriptor.from_pitch2d( buf, - format=ArrayFormat.UINT8, + format=ArrayFormatType.UINT8, num_channels=4, width=8, height=8, pitch_bytes=64, ) with pytest.raises(ValueError, match="array-backed"): - SurfaceObject.from_descriptor(resource=res_p2) + Device().create_surface_object(resource=res_p2) finally: buf.close() @@ -417,16 +465,18 @@ def test_mipmapped_array_init_disabled(): cuda.core.texture._mipmapped_array.MipmappedArray() -def test_mipmapped_array_from_descriptor_2d(init_cuda): - mip = MipmappedArray.from_descriptor( - shape=(64, 32), - format=ArrayFormat.FLOAT32, - num_channels=1, - num_levels=4, +def test_mipmapped_array_create_2d(init_cuda): + mip = Device().create_mipmapped_array( + MipmappedArrayOptions( + shape=(64, 32), + format=ArrayFormatType.FLOAT32, + num_channels=1, + num_levels=4, + ) ) try: assert mip.shape == (64, 32) - assert mip.format == ArrayFormat.FLOAT32 + assert mip.format == ArrayFormatType.FLOAT32 assert mip.num_channels == 1 assert mip.num_levels == 4 assert mip.is_surface_load_store is False @@ -438,11 +488,13 @@ def test_mipmapped_array_from_descriptor_2d(init_cuda): def test_mipmapped_array_get_level_zero_matches_shape(init_cuda): shape = (64, 32) - mip = MipmappedArray.from_descriptor( - shape=shape, - format=ArrayFormat.UINT8, - num_channels=4, - num_levels=4, + mip = Device().create_mipmapped_array( + MipmappedArrayOptions( + shape=shape, + format=ArrayFormatType.UINT8, + num_channels=4, + num_levels=4, + ) ) try: lvl0 = mip.get_level(0) @@ -450,7 +502,7 @@ def test_mipmapped_array_get_level_zero_matches_shape(init_cuda): assert isinstance(lvl0, OpaqueArray) # Level 0 must match the base shape and rank. assert lvl0.shape == shape - assert lvl0.format == ArrayFormat.UINT8 + assert lvl0.format == ArrayFormatType.UINT8 assert lvl0.num_channels == 4 assert lvl0.handle != 0 finally: @@ -462,11 +514,13 @@ def test_mipmapped_array_get_level_zero_matches_shape(init_cuda): def test_mipmapped_array_get_level_halves_dims(init_cuda): shape = (64, 32) num_levels = 4 - mip = MipmappedArray.from_descriptor( - shape=shape, - format=ArrayFormat.UINT8, - num_channels=1, - num_levels=num_levels, + mip = Device().create_mipmapped_array( + MipmappedArrayOptions( + shape=shape, + format=ArrayFormatType.UINT8, + num_channels=1, + num_levels=num_levels, + ) ) try: for level in range(num_levels): @@ -482,11 +536,13 @@ def test_mipmapped_array_get_level_halves_dims(init_cuda): def test_mipmapped_array_get_level_out_of_range(init_cuda): - mip = MipmappedArray.from_descriptor( - shape=(16, 16), - format=ArrayFormat.UINT8, - num_channels=1, - num_levels=2, + mip = Device().create_mipmapped_array( + MipmappedArrayOptions( + shape=(16, 16), + format=ArrayFormatType.UINT8, + num_channels=1, + num_levels=2, + ) ) try: with pytest.raises(ValueError, match="num_levels"): @@ -499,20 +555,24 @@ def test_mipmapped_array_get_level_out_of_range(init_cuda): def test_mipmapped_array_rejects_zero_levels(init_cuda): with pytest.raises(ValueError, match="num_levels"): - MipmappedArray.from_descriptor( - shape=(8, 8), - format=ArrayFormat.UINT8, - num_channels=1, - num_levels=0, + Device().create_mipmapped_array( + MipmappedArrayOptions( + shape=(8, 8), + format=ArrayFormatType.UINT8, + num_channels=1, + num_levels=0, + ) ) def test_resource_descriptor_from_mipmapped_array(init_cuda): - mip = MipmappedArray.from_descriptor( - shape=(32, 16), - format=ArrayFormat.FLOAT32, - num_channels=1, - num_levels=3, + mip = Device().create_mipmapped_array( + MipmappedArrayOptions( + shape=(32, 16), + format=ArrayFormatType.FLOAT32, + num_channels=1, + num_levels=3, + ) ) try: res = ResourceDescriptor.from_mipmapped_array(mip) @@ -528,25 +588,27 @@ def test_resource_descriptor_from_mipmapped_array_rejects_non_mipmap(): def test_texture_object_from_mipmapped_array(init_cuda): - mip = MipmappedArray.from_descriptor( - shape=(32, 32), - format=ArrayFormat.FLOAT32, - num_channels=1, - num_levels=3, + mip = Device().create_mipmapped_array( + MipmappedArrayOptions( + shape=(32, 32), + format=ArrayFormatType.FLOAT32, + num_channels=1, + num_levels=3, + ) ) try: res = ResourceDescriptor.from_mipmapped_array(mip) # Use non-default mipmap params so the driver exercises that path. - tex_desc = TextureDescriptor( - address_mode=AddressMode.CLAMP, - filter_mode=FilterMode.LINEAR, + tex_desc = TextureObjectOptions( + address_mode=AddressModeType.CLAMP, + filter_mode=FilterModeType.LINEAR, normalized_coords=True, - mipmap_filter_mode=FilterMode.LINEAR, + mipmap_filter_mode=FilterModeType.LINEAR, mipmap_level_bias=0.0, min_mipmap_level_clamp=0.0, max_mipmap_level_clamp=float(mip.num_levels - 1), ) - tex = TextureObject.from_descriptor(resource=res, texture_descriptor=tex_desc) + tex = Device().create_texture_object(resource=res, options=tex_desc) try: assert tex.handle != 0 assert tex.resource is res @@ -557,17 +619,19 @@ def test_texture_object_from_mipmapped_array(init_cuda): def test_surface_rejects_mipmapped_array(init_cuda): - mip = MipmappedArray.from_descriptor( - shape=(16, 16), - format=ArrayFormat.UINT8, - num_channels=4, - num_levels=2, - is_surface_load_store=True, + mip = Device().create_mipmapped_array( + MipmappedArrayOptions( + shape=(16, 16), + format=ArrayFormatType.UINT8, + num_channels=4, + num_levels=2, + is_surface_load_store=True, + ) ) try: res = ResourceDescriptor.from_mipmapped_array(mip) with pytest.raises(ValueError, match="array-backed"): - SurfaceObject.from_descriptor(resource=res) + Device().create_surface_object(resource=res) finally: mip.close() @@ -587,11 +651,13 @@ def test_mipmapped_array_level_outlives_dropped_parent(init_cuda): device = Device() stream = device.create_stream() - mip = MipmappedArray.from_descriptor( - shape=(16, 16), - format=ArrayFormat.UINT32, - num_channels=1, - num_levels=3, + mip = Device().create_mipmapped_array( + MipmappedArrayOptions( + shape=(16, 16), + format=ArrayFormatType.UINT32, + num_channels=1, + num_levels=3, + ) ) lvl = mip.get_level(1) # (8, 8) # Drop the only Python reference to the parent and force GC. @@ -615,29 +681,33 @@ def test_texture_surface_close_is_idempotent(init_cuda): """close() drops this object's handle reference; destruction happens once via the handle deleter. A second close() (and the later __dealloc__) must be a safe no-op, and handle must read back as 0.""" - arr = OpaqueArray.from_descriptor(shape=(8, 8), format=ArrayFormat.UINT8, num_channels=1) + arr = Device().create_opaque_array(OpaqueArrayOptions(shape=(8, 8), format=ArrayFormatType.UINT8, num_channels=1)) arr.close() assert arr.handle == 0 arr.close() # second close must not raise - mip = MipmappedArray.from_descriptor(shape=(8, 8), format=ArrayFormat.UINT8, num_channels=1, num_levels=2) + mip = Device().create_mipmapped_array( + MipmappedArrayOptions(shape=(8, 8), format=ArrayFormatType.UINT8, num_channels=1, num_levels=2) + ) mip.close() assert mip.handle == 0 mip.close() - surf_arr = OpaqueArray.from_descriptor( - shape=(8, 8), format=ArrayFormat.UINT8, num_channels=4, is_surface_load_store=True + surf_arr = Device().create_opaque_array( + OpaqueArrayOptions(shape=(8, 8), format=ArrayFormatType.UINT8, num_channels=4, is_surface_load_store=True) ) - surf = SurfaceObject.from_array(surf_arr) + surf = Device().create_surface_object(resource=ResourceDescriptor.from_opaque_array(surf_arr)) surf.close() assert surf.handle == 0 surf.close() surf_arr.close() - tex_arr = OpaqueArray.from_descriptor(shape=(8, 8), format=ArrayFormat.FLOAT32, num_channels=1) - tex = TextureObject.from_descriptor( - resource=ResourceDescriptor.from_array(tex_arr), - texture_descriptor=TextureDescriptor(), + tex_arr = Device().create_opaque_array( + OpaqueArrayOptions(shape=(8, 8), format=ArrayFormatType.FLOAT32, num_channels=1) + ) + tex = Device().create_texture_object( + resource=ResourceDescriptor.from_opaque_array(tex_arr), + options=TextureObjectOptions(), ) tex.close() assert tex.handle == 0 @@ -648,23 +718,23 @@ def test_texture_surface_close_is_idempotent(init_cuda): # --- Negative-path validation tests ------------------------------------------ -def test_array_from_descriptor_rejects_bad_format(init_cuda): - with pytest.raises(TypeError, match="format must be an ArrayFormat"): - OpaqueArray.from_descriptor(shape=(8,), format=0, num_channels=1) +def test_array_create_rejects_bad_format(init_cuda): + with pytest.raises(ValueError, match="format must be an ArrayFormatType"): + Device().create_opaque_array(OpaqueArrayOptions(shape=(8,), format=0, num_channels=1)) -def test_array_from_descriptor_rejects_non_iterable_shape(init_cuda): +def test_array_create_rejects_non_iterable_shape(init_cuda): with pytest.raises(TypeError, match="shape must be a tuple"): - OpaqueArray.from_descriptor(shape=8, format=ArrayFormat.UINT8, num_channels=1) + Device().create_opaque_array(OpaqueArrayOptions(shape=8, format=ArrayFormatType.UINT8, num_channels=1)) -def test_array_from_descriptor_rejects_zero_dim(init_cuda): +def test_array_create_rejects_zero_dim(init_cuda): with pytest.raises(ValueError, match=r"shape\[1\] must be >= 1"): - OpaqueArray.from_descriptor(shape=(8, 0), format=ArrayFormat.UINT8, num_channels=1) + Device().create_opaque_array(OpaqueArrayOptions(shape=(8, 0), format=ArrayFormatType.UINT8, num_channels=1)) def test_array_copy_rejects_non_stream(init_cuda): - arr = OpaqueArray.from_descriptor(shape=(8,), format=ArrayFormat.UINT8, num_channels=1) + arr = Device().create_opaque_array(OpaqueArrayOptions(shape=(8,), format=ArrayFormatType.UINT8, num_channels=1)) try: import array as _array @@ -683,7 +753,7 @@ def test_array_copy_to_returns_dst(init_cuda): device = Device() stream = device.create_stream() - arr = OpaqueArray.from_descriptor(shape=(16,), format=ArrayFormat.UINT32, num_channels=1) + arr = Device().create_opaque_array(OpaqueArrayOptions(shape=(16,), format=ArrayFormatType.UINT32, num_channels=1)) try: dst = _array.array("I", [0] * 16) returned = arr.copy_to(dst, stream=stream) @@ -699,7 +769,7 @@ def test_array_copy_accepts_graph_builder(init_cuda): into a CUDA graph (parity with Buffer, which accepts Stream | GraphBuilder).""" device = Device() stream = device.create_stream() - arr = OpaqueArray.from_descriptor(shape=(16,), format=ArrayFormat.UINT32, num_channels=1) + arr = Device().create_opaque_array(OpaqueArrayOptions(shape=(16,), format=ArrayFormatType.UINT32, num_channels=1)) buf_in = device.memory_resource.allocate(arr.size_bytes, stream=stream) buf_out = device.memory_resource.allocate(arr.size_bytes, stream=stream) stream.sync() @@ -722,7 +792,7 @@ def test_resource_descriptor_from_pitch2d_rejects_non_buffer(): with pytest.raises(TypeError, match="buffer must be a Buffer"): ResourceDescriptor.from_pitch2d( object(), - format=ArrayFormat.UINT8, + format=ArrayFormatType.UINT8, num_channels=1, width=8, height=8, @@ -734,7 +804,7 @@ def test_resource_descriptor_from_pitch2d_rejects_bad_format(init_cuda): device = Device() buf = _alloc_device_buffer(device, 4096) try: - with pytest.raises(TypeError, match="format must be an ArrayFormat"): + with pytest.raises(ValueError, match="format must be an ArrayFormatType"): ResourceDescriptor.from_pitch2d( buf, format=0, @@ -754,7 +824,7 @@ def test_resource_descriptor_from_pitch2d_rejects_bad_channels(init_cuda): with pytest.raises(ValueError, match="num_channels"): ResourceDescriptor.from_pitch2d( buf, - format=ArrayFormat.UINT8, + format=ArrayFormatType.UINT8, num_channels=3, width=8, height=8, @@ -771,7 +841,7 @@ def test_resource_descriptor_from_pitch2d_rejects_zero_dims(init_cuda): with pytest.raises(ValueError, match="width"): ResourceDescriptor.from_pitch2d( buf, - format=ArrayFormat.UINT8, + format=ArrayFormatType.UINT8, num_channels=1, width=0, height=8, @@ -780,7 +850,7 @@ def test_resource_descriptor_from_pitch2d_rejects_zero_dims(init_cuda): with pytest.raises(ValueError, match="height"): ResourceDescriptor.from_pitch2d( buf, - format=ArrayFormat.UINT8, + format=ArrayFormatType.UINT8, num_channels=1, width=8, height=0, @@ -791,130 +861,122 @@ def test_resource_descriptor_from_pitch2d_rejects_zero_dims(init_cuda): def test_mipmapped_array_rejects_bad_format(init_cuda): - with pytest.raises(TypeError, match="format must be an ArrayFormat"): - MipmappedArray.from_descriptor(shape=(8, 8), format=0, num_channels=1, num_levels=2) + with pytest.raises(ValueError, match="format must be an ArrayFormatType"): + Device().create_mipmapped_array(MipmappedArrayOptions(shape=(8, 8), format=0, num_channels=1, num_levels=2)) def test_mipmapped_array_rejects_bad_channels(init_cuda): with pytest.raises(ValueError, match="num_channels"): - MipmappedArray.from_descriptor(shape=(8, 8), format=ArrayFormat.UINT8, num_channels=3, num_levels=2) + Device().create_mipmapped_array( + MipmappedArrayOptions(shape=(8, 8), format=ArrayFormatType.UINT8, num_channels=3, num_levels=2) + ) def test_mipmapped_array_rejects_zero_dim(init_cuda): with pytest.raises(ValueError, match=r"shape\[0\] must be >= 1"): - MipmappedArray.from_descriptor(shape=(0, 8), format=ArrayFormat.UINT8, num_channels=1, num_levels=1) + Device().create_mipmapped_array( + MipmappedArrayOptions(shape=(0, 8), format=ArrayFormatType.UINT8, num_channels=1, num_levels=1) + ) def test_texture_object_rejects_non_resource_descriptor(init_cuda): with pytest.raises(TypeError, match="resource must be a ResourceDescriptor"): - TextureObject.from_descriptor(resource=object(), texture_descriptor=TextureDescriptor()) + Device().create_texture_object(resource=object(), options=TextureObjectOptions()) -def test_texture_object_rejects_non_texture_descriptor(init_cuda): - arr = OpaqueArray.from_descriptor(shape=(8, 8), format=ArrayFormat.FLOAT32, num_channels=1) +def test_texture_object_rejects_bad_options_type(init_cuda): + arr = Device().create_opaque_array(OpaqueArrayOptions(shape=(8, 8), format=ArrayFormatType.FLOAT32, num_channels=1)) try: - res = ResourceDescriptor.from_array(arr) - with pytest.raises(TypeError, match="texture_descriptor must be a TextureDescriptor"): - TextureObject.from_descriptor(resource=res, texture_descriptor="nope") + res = ResourceDescriptor.from_opaque_array(arr) + with pytest.raises(TypeError, match="must be provided as an object of type TextureObjectOptions"): + Device().create_texture_object(resource=res, options="nope") finally: arr.close() def test_texture_object_rejects_bad_filter_mode(init_cuda): - arr = OpaqueArray.from_descriptor(shape=(8, 8), format=ArrayFormat.FLOAT32, num_channels=1) - try: - res = ResourceDescriptor.from_array(arr) - td = TextureDescriptor(filter_mode=0) # int, not FilterMode - with pytest.raises(TypeError, match="filter_mode must be a FilterMode"): - TextureObject.from_descriptor(resource=res, texture_descriptor=td) - finally: - arr.close() + # Invalid enum values are rejected at TextureObjectOptions construction. + with pytest.raises(ValueError, match="filter_mode must be a FilterModeType"): + TextureObjectOptions(filter_mode=0) # int, not FilterModeType def test_texture_object_rejects_bad_read_mode(init_cuda): - arr = OpaqueArray.from_descriptor(shape=(8, 8), format=ArrayFormat.FLOAT32, num_channels=1) - try: - res = ResourceDescriptor.from_array(arr) - td = TextureDescriptor(read_mode=0) # int, not ReadMode - with pytest.raises(TypeError, match="read_mode must be a ReadMode"): - TextureObject.from_descriptor(resource=res, texture_descriptor=td) - finally: - arr.close() + with pytest.raises(ValueError, match="read_mode must be a ReadModeType"): + TextureObjectOptions(read_mode=0) # int, not ReadModeType def test_texture_object_rejects_bad_mipmap_filter_mode(init_cuda): - arr = OpaqueArray.from_descriptor(shape=(8, 8), format=ArrayFormat.FLOAT32, num_channels=1) - try: - res = ResourceDescriptor.from_array(arr) - td = TextureDescriptor(mipmap_filter_mode=0) # int, not FilterMode - with pytest.raises(TypeError, match="mipmap_filter_mode must be a FilterMode"): - TextureObject.from_descriptor(resource=res, texture_descriptor=td) - finally: - arr.close() + with pytest.raises(ValueError, match="mipmap_filter_mode must be a FilterModeType"): + TextureObjectOptions(mipmap_filter_mode=0) # int, not FilterModeType def test_texture_object_rejects_negative_anisotropy(init_cuda): - arr = OpaqueArray.from_descriptor(shape=(8, 8), format=ArrayFormat.FLOAT32, num_channels=1) + arr = Device().create_opaque_array(OpaqueArrayOptions(shape=(8, 8), format=ArrayFormatType.FLOAT32, num_channels=1)) try: - res = ResourceDescriptor.from_array(arr) - td = TextureDescriptor(max_anisotropy=-1) + res = ResourceDescriptor.from_opaque_array(arr) + td = TextureObjectOptions(max_anisotropy=-1) with pytest.raises(ValueError, match="max_anisotropy"): - TextureObject.from_descriptor(resource=res, texture_descriptor=td) + Device().create_texture_object(resource=res, options=td) finally: arr.close() def test_texture_object_rejects_bad_border_color_length(init_cuda): - arr = OpaqueArray.from_descriptor(shape=(8, 8), format=ArrayFormat.FLOAT32, num_channels=1) + arr = Device().create_opaque_array(OpaqueArrayOptions(shape=(8, 8), format=ArrayFormatType.FLOAT32, num_channels=1)) try: - res = ResourceDescriptor.from_array(arr) - td = TextureDescriptor(border_color=(0.0, 0.0)) # length 2, not 4 + res = ResourceDescriptor.from_opaque_array(arr) + td = TextureObjectOptions(border_color=(0.0, 0.0)) # length 2, not 4 with pytest.raises(ValueError, match="border_color must have 4"): - TextureObject.from_descriptor(resource=res, texture_descriptor=td) + Device().create_texture_object(resource=res, options=td) finally: arr.close() def test_address_mode_rejects_non_addressmode_scalar(init_cuda): - arr = OpaqueArray.from_descriptor(shape=(8, 8), format=ArrayFormat.FLOAT32, num_channels=1) + arr = Device().create_opaque_array(OpaqueArrayOptions(shape=(8, 8), format=ArrayFormatType.FLOAT32, num_channels=1)) try: - res = ResourceDescriptor.from_array(arr) - td = TextureDescriptor(address_mode=42) # int, not AddressMode / iterable + res = ResourceDescriptor.from_opaque_array(arr) + td = TextureObjectOptions(address_mode=42) # int, not AddressModeType / iterable with pytest.raises(TypeError, match="address_mode"): - TextureObject.from_descriptor(resource=res, texture_descriptor=td) + Device().create_texture_object(resource=res, options=td) finally: arr.close() def test_address_mode_rejects_empty_tuple(init_cuda): - arr = OpaqueArray.from_descriptor(shape=(8, 8), format=ArrayFormat.FLOAT32, num_channels=1) + arr = Device().create_opaque_array(OpaqueArrayOptions(shape=(8, 8), format=ArrayFormatType.FLOAT32, num_channels=1)) try: - res = ResourceDescriptor.from_array(arr) - td = TextureDescriptor(address_mode=()) + res = ResourceDescriptor.from_opaque_array(arr) + td = TextureObjectOptions(address_mode=()) with pytest.raises(ValueError, match="address_mode tuple must have 1-3"): - TextureObject.from_descriptor(resource=res, texture_descriptor=td) + Device().create_texture_object(resource=res, options=td) finally: arr.close() def test_address_mode_rejects_too_long_tuple(init_cuda): - arr = OpaqueArray.from_descriptor(shape=(8, 8), format=ArrayFormat.FLOAT32, num_channels=1) + arr = Device().create_opaque_array(OpaqueArrayOptions(shape=(8, 8), format=ArrayFormatType.FLOAT32, num_channels=1)) try: - res = ResourceDescriptor.from_array(arr) - td = TextureDescriptor(address_mode=(AddressMode.WRAP, AddressMode.WRAP, AddressMode.WRAP, AddressMode.WRAP)) + res = ResourceDescriptor.from_opaque_array(arr) + td = TextureObjectOptions( + address_mode=(AddressModeType.WRAP, AddressModeType.WRAP, AddressModeType.WRAP, AddressModeType.WRAP) + ) with pytest.raises(ValueError, match="address_mode tuple must have 1-3"): - TextureObject.from_descriptor(resource=res, texture_descriptor=td) + Device().create_texture_object(resource=res, options=td) finally: arr.close() -def test_address_mode_rejects_non_addressmode_entry(init_cuda): - arr = OpaqueArray.from_descriptor(shape=(8, 8), format=ArrayFormat.FLOAT32, num_channels=1) +def test_address_mode_rejects_invalid_entry(init_cuda): + arr = Device().create_opaque_array(OpaqueArrayOptions(shape=(8, 8), format=ArrayFormatType.FLOAT32, num_channels=1)) try: - res = ResourceDescriptor.from_array(arr) - td = TextureDescriptor(address_mode=(AddressMode.WRAP, "bad", AddressMode.CLAMP)) - with pytest.raises(TypeError, match=r"address_mode\[1\]"): - TextureObject.from_descriptor(resource=res, texture_descriptor=td) + res = ResourceDescriptor.from_opaque_array(arr) + # "bad" is a valid *type* (str is accepted anywhere an AddressModeType + # is) but an invalid *value*, so it is rejected with a ValueError naming + # the offending tuple position. + td = TextureObjectOptions(address_mode=(AddressModeType.WRAP, "bad", AddressModeType.CLAMP)) + with pytest.raises(ValueError, match=r"address_mode\[1\]"): + Device().create_texture_object(resource=res, options=td) finally: arr.close() @@ -923,9 +985,9 @@ def test_texture_object_keeps_backing_array_alive(init_cuda): """Dropping the local references to the backing OpaqueArray and the ResourceDescriptor must NOT invalidate an existing TextureObject. The TextureObject holds a strong ref through its _source_ref slot.""" - arr = OpaqueArray.from_descriptor(shape=(8, 8), format=ArrayFormat.FLOAT32, num_channels=1) - res = ResourceDescriptor.from_array(arr) - tex = TextureObject.from_descriptor(resource=res, texture_descriptor=TextureDescriptor()) + arr = Device().create_opaque_array(OpaqueArrayOptions(shape=(8, 8), format=ArrayFormatType.FLOAT32, num_channels=1)) + res = ResourceDescriptor.from_opaque_array(arr) + tex = Device().create_texture_object(resource=res, options=TextureObjectOptions()) # Verify the keepalive chain via gc referents: TextureObject -> _source_ref # -> ResourceDescriptor -> _source -> OpaqueArray. We can only walk one level # at a time, so check tex's referents include the ResourceDescriptor. @@ -949,13 +1011,15 @@ def test_texture_object_keeps_backing_array_alive(init_cuda): def test_surface_object_keeps_backing_array_alive(init_cuda): - arr = OpaqueArray.from_descriptor( - shape=(8, 8), - format=ArrayFormat.UINT8, - num_channels=4, - is_surface_load_store=True, + arr = Device().create_opaque_array( + OpaqueArrayOptions( + shape=(8, 8), + format=ArrayFormatType.UINT8, + num_channels=4, + is_surface_load_store=True, + ) ) - surf = SurfaceObject.from_array(arr) + surf = Device().create_surface_object(resource=ResourceDescriptor.from_opaque_array(arr)) arr_id = id(arr) del arr gc.collect() From a901bbab093977326e03fc47c7cdce4bdfb39d98 Mon Sep 17 00:00:00 2001 From: Leo Fang Date: Wed, 8 Jul 2026 11:02:53 -0700 Subject: [PATCH 03/25] ci: switch to step-security/msvc-dev-cmd fork (Node.js 24) (#2325) The upstream ilammy/msvc-dev-cmd is unmaintained and still runs on Node.js 20, which GitHub Actions is deprecating (removal on September 16th, 2026). step-security/msvc-dev-cmd@v1.13.1 is a maintained fork upgraded to Node.js 24. coverage.yml also gains SHA pinning; it was previously tag-pinned to @v1. --- .github/workflows/build-wheel.yml | 2 +- .github/workflows/coverage.yml | 2 +- .github/workflows/test-sdist-windows.yml | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/build-wheel.yml b/.github/workflows/build-wheel.yml index 45a5b3d90ab..235cfbe813f 100644 --- a/.github/workflows/build-wheel.yml +++ b/.github/workflows/build-wheel.yml @@ -85,7 +85,7 @@ jobs: - name: Set up MSVC if: ${{ startsWith(inputs.host-platform, 'win') }} - uses: ilammy/msvc-dev-cmd@0b201ec74fa43914dc39ae48a89fd1d8cb592756 # v1 + uses: step-security/msvc-dev-cmd@22c98154b708dbd743e6f27a933cf6ceba3305c4 # v1.13.1 - name: Set up yq # GitHub made an unprofessional decision to not provide it in their Windows VMs, diff --git a/.github/workflows/coverage.yml b/.github/workflows/coverage.yml index 4b2e949e371..f1b8eb9f3a2 100644 --- a/.github/workflows/coverage.yml +++ b/.github/workflows/coverage.yml @@ -212,7 +212,7 @@ jobs: python-version: ${{ env.PY_VER }} - name: Set up MSVC - uses: ilammy/msvc-dev-cmd@v1 + uses: step-security/msvc-dev-cmd@22c98154b708dbd743e6f27a933cf6ceba3305c4 # v1.13.1 - name: Set up mini CTK uses: ./.github/actions/fetch_ctk diff --git a/.github/workflows/test-sdist-windows.yml b/.github/workflows/test-sdist-windows.yml index 78dadff508e..043bacc1cad 100644 --- a/.github/workflows/test-sdist-windows.yml +++ b/.github/workflows/test-sdist-windows.yml @@ -45,7 +45,7 @@ jobs: python-version: "3.12" - name: Set up MSVC - uses: ilammy/msvc-dev-cmd@0b201ec74fa43914dc39ae48a89fd1d8cb592756 # v1 + uses: step-security/msvc-dev-cmd@22c98154b708dbd743e6f27a933cf6ceba3305c4 # v1.13.1 - name: Install build tools run: pip install build From c2ef4ad32580dca75ef5264a2873026fbde023a4 Mon Sep 17 00:00:00 2001 From: Michael Droettboom Date: Wed, 8 Jul 2026 14:29:43 -0400 Subject: [PATCH 04/25] Remove vendored deprecated library (#2324) --- cuda_core/AGENTS.md | 101 ---------------- cuda_core/NOTICE | 29 ----- cuda_core/cuda/core/_vendored/__init__.py | 0 .../core/_vendored/deprecated/__init__.py | 6 - .../cuda/core/_vendored/deprecated/classic.py | 111 ----------------- .../cuda/core/_vendored/deprecated/params.py | 52 -------- .../cuda/core/_vendored/deprecated/sphinx.py | 113 ------------------ cuda_core/cuda/core/system/_device.pyi | 17 ++- cuda_core/cuda/core/system/_device.pyx | 14 +-- cuda_core/cuda/core/system/_nvlink.pxi | 14 ++- cuda_core/pyproject.toml | 4 - 11 files changed, 28 insertions(+), 433 deletions(-) delete mode 100644 cuda_core/cuda/core/_vendored/__init__.py delete mode 100644 cuda_core/cuda/core/_vendored/deprecated/__init__.py delete mode 100644 cuda_core/cuda/core/_vendored/deprecated/classic.py delete mode 100644 cuda_core/cuda/core/_vendored/deprecated/params.py delete mode 100644 cuda_core/cuda/core/_vendored/deprecated/sphinx.py diff --git a/cuda_core/AGENTS.md b/cuda_core/AGENTS.md index ff91284b5dd..45fc2481042 100644 --- a/cuda_core/AGENTS.md +++ b/cuda_core/AGENTS.md @@ -144,104 +144,3 @@ so that they are documented but don't appear in the main index. ### API stability Reviews should point out where existing public APIs are broken. - -### API lifecycle and deprecations - -`cuda.core` follows SemVer (see `docs/source/support.rst`): - -- **New APIs** may be added at any time (`x.Y.0`). They MUST have a - `@versionadded` decorator, unless the docstring formatting requires it to be - manually-specified. -- **Breaking removals** only happen in **major releases** (`X.0.0`). -- Per the support policy, a deprecation notice must be present for **at least - one minor release** before the API is actually removed. The deprecation notice - should use the `@deprecated` decorator, unless -- Changes should be notated in the code and also in the release notes in the - "Deprecated APIs" section. - -**Annotating a new API** — Use the `versionadded` decorator from the vendored -`cuda.core._vendored.deprecated.sphinx` module: - -```python - -from cuda.core._vendored.deprecated.sphinx import versionadded - -@versionadded(version="1.2.0") -def new_feature(...): - """Short description. - """ -``` - -Alternatively, if the vagaries of how we implement functions in Cython does not -allow this, you can add the reST `versionadded` directive directly: - -```python -def new_feature(...): - """Short description. - - .. versionadded:: 1.2.0 - """ -``` - -**Annotating a changed API** — Use the `versionchanged` decorator from the -vendored `cuda.core._vendored.deprecated.sphinx` module: - -```python - -from cuda.core._vendored.deprecated.sphinx import versionchanged - -@versionchanged(version="1.2.0", reason="The old version was broken because...") -def new_feature(...): - """Short description. - """ -``` - -Alternatively, if the vagaries of how we implement functions in Cython does not -allow this, you can add the reST `versionchanged` directive directly: - -```python -def new_feature(...): - """Short description. - - .. versionchanged:: 1.2.0 - The old version was broken because... - """ -``` - -**Deprecating an existing API** — use the `@deprecated` decorator from the -vendored `cuda.core._vendored.deprecated.sphinx` module and add a -`.. deprecated::` directive in the docstring. The decorator emits a -`DeprecationWarning` at call time; the docstring directive surfaces it in the -generated docs. - -```python -from cuda.core._vendored.deprecated.sphinx import deprecated - -@deprecated(version="1.2.0", reason="Use `new_feature` instead.")` -def old_feature(...): - """Short description. - """ -``` - -Rules to follow when deprecating: - -- The `version=` argument must be the **first** in which the - deprecation appears, not the release in which removal is planned. -- The `reason=` string must name the replacement (if one exists) so users - know what to migrate to. -- Keep the old implementation fully functional — do not change its behavior, - only add the decorator. -- The deprecated API must remain in the codebase for **at least one full minor - release cycle** before it can be removed in a subsequent major release. - -**Removing a deprecated API** — removals land in a **major release**. Before -removing, verify that the deprecation has been present since at least the -previous minor release. Remove the decorator, the implementation, and any -`__all__` entry; update `api.rst` and the release notes accordingly. - -## Vendored code - -The `cuda/core/_vendored` directory contains vendored code from third-party -sources. It should not be modified, except to update the dependency or under -exceptional circumstances, in which case any modifications should be clearly -marked. diff --git a/cuda_core/NOTICE b/cuda_core/NOTICE index bb82083df9e..c4625e23899 100644 --- a/cuda_core/NOTICE +++ b/cuda_core/NOTICE @@ -11,32 +11,3 @@ DLPack Copyright (c) 2017 by Contributors Licensed under the Apache License, Version 2.0. Source: https://github.com/dmlc/dlpack - -Deprecated -Copyright (c) 2017 Laurent LAPORTE -Licensed under the MIT License. -Source: https://github.com/tantale/deprecated - -The following license applies to the vendored Deprecated source: - -The MIT License (MIT) - -Copyright (c) 2017 Laurent LAPORTE - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. diff --git a/cuda_core/cuda/core/_vendored/__init__.py b/cuda_core/cuda/core/_vendored/__init__.py deleted file mode 100644 index e69de29bb2d..00000000000 diff --git a/cuda_core/cuda/core/_vendored/deprecated/__init__.py b/cuda_core/cuda/core/_vendored/deprecated/__init__.py deleted file mode 100644 index 20a317a94e2..00000000000 --- a/cuda_core/cuda/core/_vendored/deprecated/__init__.py +++ /dev/null @@ -1,6 +0,0 @@ -# Vendored from the Deprecated package (https://pypi.org/project/Deprecated/), -# version 1.3.1, (c) Laurent LAPORTE, MIT License. -# Modified to remove the dependency on the `wrapt` package. - -from cuda.core._vendored.deprecated.classic import deprecated -from cuda.core._vendored.deprecated.params import deprecated_params diff --git a/cuda_core/cuda/core/_vendored/deprecated/classic.py b/cuda_core/cuda/core/_vendored/deprecated/classic.py deleted file mode 100644 index 965a10d6a15..00000000000 --- a/cuda_core/cuda/core/_vendored/deprecated/classic.py +++ /dev/null @@ -1,111 +0,0 @@ -# Vendored from the Deprecated package (https://pypi.org/project/Deprecated/), -# version 1.3.1, (c) Laurent LAPORTE, MIT License. -# Modified to remove the dependency on the `wrapt` package. - -import functools -import inspect -import warnings - -# stacklevel=2 points past the wrapper to the actual call site -_routine_stacklevel = 2 -_class_stacklevel = 2 - -string_types = (bytes, str) - - -class ClassicAdapter: - """ - Classic adapter -- *for advanced usage only* - - This adapter is used to get the deprecation message according to the wrapped - object type: class, function, standard method, static method, or class method. - - This is the base class of the :class:`~deprecated.sphinx.SphinxAdapter` class - which is used to update the wrapped object docstring. - """ - - def __init__(self, reason="", version="", action=None, category=DeprecationWarning, extra_stacklevel=0): - self.reason = reason or "" - self.version = version or "" - self.action = action - self.category = category - self.extra_stacklevel = extra_stacklevel - - def get_deprecated_msg(self, wrapped, instance): - if instance is None: - if inspect.isclass(wrapped): - fmt = "Call to deprecated class {name}." - else: - fmt = "Call to deprecated function (or staticmethod) {name}." - else: - if inspect.isclass(instance): - fmt = "Call to deprecated class method {name}." - else: - fmt = "Call to deprecated method {name}." - if self.reason: - fmt += " ({reason})" - if self.version: - fmt += " -- Deprecated since version {version}." - return fmt.format(name=wrapped.__name__, reason=self.reason or "", version=self.version or "") - - def __call__(self, wrapped): - if inspect.isclass(wrapped): - old_new1 = wrapped.__new__ - - def wrapped_cls(cls, *args, **kwargs): - msg = self.get_deprecated_msg(wrapped, None) - stacklevel = _class_stacklevel + self.extra_stacklevel - if self.action: - with warnings.catch_warnings(): - warnings.simplefilter(self.action, self.category) - warnings.warn(msg, category=self.category, stacklevel=stacklevel) - else: - warnings.warn(msg, category=self.category, stacklevel=stacklevel) - if old_new1 is object.__new__: - return old_new1(cls) - return old_new1(cls, *args, **kwargs) - - wrapped.__new__ = staticmethod(wrapped_cls) - return wrapped - - elif inspect.isroutine(wrapped): - adapter = self - - @functools.wraps(wrapped) - def wrapper(*args, **kwargs): - msg = adapter.get_deprecated_msg(wrapped, None) - stacklevel = _routine_stacklevel + adapter.extra_stacklevel - if adapter.action: - with warnings.catch_warnings(): - warnings.simplefilter(adapter.action, adapter.category) - warnings.warn(msg, category=adapter.category, stacklevel=stacklevel) - else: - warnings.warn(msg, category=adapter.category, stacklevel=stacklevel) - return wrapped(*args, **kwargs) - - return wrapper - - else: - raise TypeError(repr(type(wrapped))) - - -def deprecated(*args, **kwargs): - """ - Decorator which can be used to mark functions as deprecated. - - It will result in a warning being emitted when the function is used. - """ - if args and isinstance(args[0], string_types): - kwargs["reason"] = args[0] - args = args[1:] - - if args and not callable(args[0]): - raise TypeError(repr(type(args[0]))) - - if args: - adapter_cls = kwargs.pop("adapter_cls", ClassicAdapter) - adapter = adapter_cls(**kwargs) - wrapped = args[0] - return adapter(wrapped) - - return functools.partial(deprecated, **kwargs) diff --git a/cuda_core/cuda/core/_vendored/deprecated/params.py b/cuda_core/cuda/core/_vendored/deprecated/params.py deleted file mode 100644 index 6584d86df4d..00000000000 --- a/cuda_core/cuda/core/_vendored/deprecated/params.py +++ /dev/null @@ -1,52 +0,0 @@ -# Vendored from the Deprecated package (https://pypi.org/project/Deprecated/), -# version 1.3.1, (c) Laurent LAPORTE, MIT License. -# Modified to remove the dependency on the `wrapt` package. - -import collections -import functools -import inspect -import warnings - - -class DeprecatedParams: - """ - Decorator for functions where one or more parameters are deprecated. - """ - - def __init__(self, param, reason="", category=DeprecationWarning): - self.messages = {} - self.category = category - self.populate_messages(param, reason=reason) - - def populate_messages(self, param, reason=""): - if isinstance(param, dict): - self.messages.update(param) - elif isinstance(param, str): - fmt = "'{param}' parameter is deprecated" - reason = reason or fmt.format(param=param) - self.messages[param] = reason - else: - raise TypeError(param) - - def check_params(self, signature, *args, **kwargs): - binding = signature.bind(*args, **kwargs) - bound = collections.OrderedDict(binding.arguments, **binding.kwargs) - return [param for param in bound if param in self.messages] - - def warn_messages(self, messages): - for message in messages: - warnings.warn(message, category=self.category, stacklevel=3) - - def __call__(self, f): - signature = inspect.signature(f) - - @functools.wraps(f) - def wrapper(*args, **kwargs): - invalid_params = self.check_params(signature, *args, **kwargs) - self.warn_messages([self.messages[param] for param in invalid_params]) - return f(*args, **kwargs) - - return wrapper - - -deprecated_params = DeprecatedParams diff --git a/cuda_core/cuda/core/_vendored/deprecated/sphinx.py b/cuda_core/cuda/core/_vendored/deprecated/sphinx.py deleted file mode 100644 index 557154c5474..00000000000 --- a/cuda_core/cuda/core/_vendored/deprecated/sphinx.py +++ /dev/null @@ -1,113 +0,0 @@ -# Vendored from the Deprecated package (https://pypi.org/project/Deprecated/), -# version 1.3.1, (c) Laurent LAPORTE, MIT License. -# Modified to remove the dependency on the `wrapt` package. - -import re -import textwrap - -from cuda.core._vendored.deprecated.classic import ClassicAdapter -from cuda.core._vendored.deprecated.classic import deprecated as _classic_deprecated - - -class SphinxAdapter(ClassicAdapter): - """ - Sphinx adapter -- *for advanced usage only* - - This adapter overrides :class:`~deprecated.classic.ClassicAdapter` to add - Sphinx directives ("versionadded", "versionchanged", "deprecated") to the - end of the decorated function or class docstring. - """ - - def __init__( - self, - directive, - reason="", - version="", - action=None, - category=DeprecationWarning, - extra_stacklevel=0, - line_length=70, - ): - if not version: - raise ValueError("'version' argument is required in Sphinx directives") - self.directive = directive - self.line_length = line_length - super().__init__( - reason=reason, version=version, action=action, category=category, extra_stacklevel=extra_stacklevel - ) - - def __call__(self, wrapped): - fmt = ".. {directive}:: {version}" if self.version else ".. {directive}::" - div_lines = [fmt.format(directive=self.directive, version=self.version)] - width = self.line_length - 3 if self.line_length > 3 else 2**16 - reason = textwrap.dedent(self.reason).strip() - for paragraph in reason.splitlines(): - if paragraph: - div_lines.extend( - textwrap.fill( - paragraph, - width=width, - initial_indent=" ", - subsequent_indent=" ", - ).splitlines() - ) - else: - div_lines.append("") - - docstring = wrapped.__doc__ or "" - lines = docstring.splitlines(True) or [""] - docstring = textwrap.dedent("".join(lines[1:])) if len(lines) > 1 else "" - docstring = lines[0] + docstring - if docstring: - docstring = re.sub(r"\n+$", "", docstring, flags=re.DOTALL) + "\n\n" - else: - docstring = "\n" - - docstring += "".join(f"{line}\n" for line in div_lines) - - wrapped.__doc__ = docstring - if self.directive in {"versionadded", "versionchanged"}: - return wrapped - return super().__call__(wrapped) - - def get_deprecated_msg(self, wrapped, instance): - msg = super().get_deprecated_msg(wrapped, instance) - msg = re.sub(r"(?: : [a-zA-Z]+ )? : [a-zA-Z]+ : (`[^`]*`)", r"\1", msg, flags=re.X) - return msg - - -def versionadded(reason="", version="", line_length=70): - """ - Decorator that inserts a "versionadded" Sphinx directive into the docstring. - """ - return SphinxAdapter( - "versionadded", - reason=reason, - version=version, - line_length=line_length, - ) - - -def versionchanged(reason="", version="", line_length=70): - """ - Decorator that inserts a "versionchanged" Sphinx directive into the docstring. - """ - return SphinxAdapter( - "versionchanged", - reason=reason, - version=version, - line_length=line_length, - ) - - -def deprecated(reason="", version="", line_length=70, **kwargs): - """ - Decorator that inserts a "deprecated" Sphinx directive into the docstring - and emits a :exc:`DeprecationWarning` when the decorated object is called. - """ - directive = kwargs.pop("directive", "deprecated") - adapter_cls = kwargs.pop("adapter_cls", SphinxAdapter) - kwargs["reason"] = reason - kwargs["version"] = version - kwargs["line_length"] = line_length - return _classic_deprecated(directive=directive, adapter_cls=adapter_cls, **kwargs) diff --git a/cuda_core/cuda/core/system/_device.pyi b/cuda_core/cuda/core/system/_device.pyi index 600c1fb8551..0a51e5c9928 100644 --- a/cuda_core/cuda/core/system/_device.pyi +++ b/cuda_core/cuda/core/system/_device.pyi @@ -6,8 +6,6 @@ from typing import Iterable import cuda.core from cuda.bindings import nvml -from cuda.core._vendored.deprecated.sphinx import (deprecated, versionadded, - versionchanged) from cuda.core.system.typing import (AddressingMode, AffinityScope, ClockId, ClocksEventReasons, ClockType, CoolerControl, CoolerTarget, DeviceArch, @@ -792,7 +790,6 @@ class MigInfo: class _NvlinkInfoMeta(type): @property - @deprecated(version='1.1.0', reason='Use Device.get_nvlink_count instead to get the actual number of Nvlinks available on a specific device.') def max_links(cls): """ The statically-defined maximum number of Nvlinks available. Defined in @@ -800,6 +797,10 @@ class _NvlinkInfoMeta(type): To find the actual number of Nvlinks available on a device, use :py:attr:`Device.get_nvlink_count`. + + .. version-deprecated:: 1.1.0 + This property is deprecated and will be removed in a future release. + Use :py:attr:`Device.get_nvlink_count` instead. """ class _NvlinkInfo: @@ -1736,28 +1737,32 @@ class Device: :obj:`~_device.MemoryInfo` object with memory information. """ - @versionchanged(version='1.1.0', reason='Any link number not supported by this specific device will raise a `ValueError`.') def get_nvlink(self, link: int) -> NvlinkInfo: """ Get :obj:`~NvlinkInfo` about this device. For devices with NVLink support. + + .. version-changed:: 1.1.0 + Any link number not supported by this specific device will raise a `ValueError`. """ - @versionadded(version='1.1.0') def get_nvlink_count(self) -> int: """ Get the number of NVLink links on this device. For devices with NVLink support. + + .. version-added:: 1.1.0 """ - @versionadded(version='1.1.0') def get_nvlinks(self) -> Iterable[NvlinkInfo]: """ Get :obj:`~NvlinkInfo` about all NVLink links on this device. For devices with NVLink support. + + .. version-added:: 1.1.0 """ @property diff --git a/cuda_core/cuda/core/system/_device.pyx b/cuda_core/cuda/core/system/_device.pyx index 3bd27525512..73f51cad8e3 100644 --- a/cuda_core/cuda/core/system/_device.pyx +++ b/cuda_core/cuda/core/system/_device.pyx @@ -33,7 +33,6 @@ from cuda.core.system.typing import ( ThermalController, ThermalTarget, ) -from cuda.core._vendored.deprecated.sphinx import deprecated, versionadded, versionchanged if TYPE_CHECKING: import cuda.core # no-cython-lint @@ -885,36 +884,37 @@ cdef class Device: # NVLINK # See external class definitions in _nvlink.pxi - @versionchanged( - version="1.1.0", - reason="Any link number not supported by this specific device will raise a `ValueError`." - ) def get_nvlink(self, link: int) -> NvlinkInfo: """ Get :obj:`~NvlinkInfo` about this device. For devices with NVLink support. + + .. version-changed:: 1.1.0 + Any link number not supported by this specific device will raise a `ValueError`. """ link_count = self.get_nvlink_count() if link < 0 or link >= link_count: raise ValueError(f"Link index {link} is out of range [0, {link_count})") return NvlinkInfo(self, link) - @versionadded(version="1.1.0") def get_nvlink_count(self) -> int: """ Get the number of NVLink links on this device. For devices with NVLink support. + + .. version-added:: 1.1.0 """ return self.get_field_values([FieldId.DEV_NVLINK_LINK_COUNT])[0].value - @versionadded(version="1.1.0") def get_nvlinks(self) -> Iterable[NvlinkInfo]: """ Get :obj:`~NvlinkInfo` about all NVLink links on this device. For devices with NVLink support. + + .. version-added:: 1.1.0 """ for link in range(self.get_nvlink_count()): yield self.get_nvlink(link) diff --git a/cuda_core/cuda/core/system/_nvlink.pxi b/cuda_core/cuda/core/system/_nvlink.pxi index f3d6550b97b..49ac1b75ba1 100644 --- a/cuda_core/cuda/core/system/_nvlink.pxi +++ b/cuda_core/cuda/core/system/_nvlink.pxi @@ -20,10 +20,6 @@ if _NVLINK_VERSION_6_0 is not None: class _NvlinkInfoMeta(type): @property - @deprecated( - version="1.1.0", - reason="Use Device.get_nvlink_count instead to get the actual number of Nvlinks available on a specific device." - ) def max_links(cls): """ The statically-defined maximum number of Nvlinks available. Defined in @@ -31,7 +27,17 @@ class _NvlinkInfoMeta(type): To find the actual number of Nvlinks available on a device, use :py:attr:`Device.get_nvlink_count`. + + .. version-deprecated:: 1.1.0 + This property is deprecated and will be removed in a future release. + Use :py:attr:`Device.get_nvlink_count` instead. """ + warnings.warn( + "The `max_links` property is deprecated and will be removed in a future release. " + "Use `Device.get_nvlink_count` instead.", + DeprecationWarning, + ) + # This will always return 18, even on CTK 13.3 where it should be 36. return nvml.NVLINK_MAX_LINKS diff --git a/cuda_core/pyproject.toml b/cuda_core/pyproject.toml index 3ebb2a08929..aba5b8b9fff 100644 --- a/cuda_core/pyproject.toml +++ b/cuda_core/pyproject.toml @@ -147,10 +147,6 @@ implicit_reexport = true # Ignore missing imports for now (you can tighten this later) ignore_missing_imports = true -[[tool.mypy.overrides]] -module = "cuda.core._vendored.*" -ignore_errors = true - [[tool.mypy.overrides]] # cpdef functions with Cython-native tuple return types can't carry type args # through stubgen-pyx; suppress the resulting type-arg error for this module. From 95907d906a3803080ee3835222e6ddef4538f778 Mon Sep 17 00:00:00 2001 From: Michael Wang <13521008+isVoid@users.noreply.github.com> Date: Wed, 8 Jul 2026 11:53:12 -0700 Subject: [PATCH 05/25] Fix cuda.core API currentmodule for toolchain docs (#2319) Co-authored-by: Michael Wang --- cuda_core/docs/source/api.rst | 2 ++ 1 file changed, 2 insertions(+) diff --git a/cuda_core/docs/source/api.rst b/cuda_core/docs/source/api.rst index d0078b073d4..13f17ce3588 100644 --- a/cuda_core/docs/source/api.rst +++ b/cuda_core/docs/source/api.rst @@ -211,6 +211,8 @@ alongside the other ``cuda.core`` enumerations. CUDA compilation toolchain -------------------------- +.. currentmodule:: cuda.core + .. autosummary:: :toctree: generated/ From 8eb9dc2ba180394a763d40405be4cf8865b5f8eb Mon Sep 17 00:00:00 2001 From: Andy Jost Date: Wed, 8 Jul 2026 13:18:44 -0700 Subject: [PATCH 06/25] [doc-only] docs(core): finalize 1.1.0 release notes (#2315) * docs(core): finalize 1.1.0 release notes Add a Highlights section, backfill PR/issue links on New features entries, and add Bug fixes entries for the v1.1.0 IPC import hardening (#2219, #2223, #2224), the ManagedBuffer.accessed_by torn-state fix (#2222), and graph node attachment lifetimes (#2280). Highlights (per review): the .pyi type-stub support and the new cuda.core.texture module; NVLink enumeration is covered in New features / Bug fixes rather than as a highlight. Also adds a New features entry for the cuda.core.texture module (#467, #2095, #2307). * Reorder API refs + ensure each section has currentmodule the compilation toolchain is one of the unique selling points of cuda.core, but we are burying it deeply --------- Co-authored-by: Leo Fang --- cuda_core/docs/source/api.rst | 90 ++++++++------- cuda_core/docs/source/release/1.1.0-notes.rst | 104 +++++++++++++++++- 2 files changed, 150 insertions(+), 44 deletions(-) diff --git a/cuda_core/docs/source/api.rst b/cuda_core/docs/source/api.rst index 13f17ce3588..089e68576c9 100644 --- a/cuda_core/docs/source/api.rst +++ b/cuda_core/docs/source/api.rst @@ -78,6 +78,45 @@ Memory management VirtualMemoryResourceOptions +CUDA compilation toolchain +-------------------------- + +.. currentmodule:: cuda.core + +.. autosummary:: + :toctree: generated/ + + :template: autosummary/cyclass.rst + + Program + Linker + ObjectCode + Kernel + + :template: dataclass.rst + + ProgramOptions + LinkerOptions + +Program caches +`````````````` + +``Program.compile`` accepts a ``cache=`` keyword argument that integrates +with any :class:`~cuda.core.utils.ProgramCacheResource`, so callers can +avoid recompiling identical source + options + target without writing the +:func:`~cuda.core.utils.make_program_cache_key` lookup by hand. + +.. currentmodule:: cuda.core.utils + +.. autosummary:: + :toctree: generated/ + + ProgramCacheResource + InMemoryProgramCache + FileStreamProgramCache + make_program_cache_key + + CUDA graphs ----------- @@ -89,6 +128,8 @@ CPU overhead. Graphs can be constructed in two ways: edges. Both produce an executable :class:`~graph.Graph` that can be launched on a :class:`Stream`. +.. currentmodule:: cuda.core + .. autosummary:: :toctree: generated/ @@ -138,6 +179,8 @@ Each subclass exposes attributes unique to its operation type. Graphics interoperability ------------------------- +.. currentmodule:: cuda.core + .. autosummary:: :toctree: generated/ @@ -149,6 +192,8 @@ Graphics interoperability Tensor Memory Accelerator (TMA) ------------------------------- +.. currentmodule:: cuda.core + .. autosummary:: :toctree: generated/ @@ -208,47 +253,6 @@ The associated enumerations — alongside the other ``cuda.core`` enumerations. -CUDA compilation toolchain --------------------------- - -.. currentmodule:: cuda.core - -.. autosummary:: - :toctree: generated/ - - :template: autosummary/cyclass.rst - - Program - Linker - ObjectCode - Kernel - - :template: dataclass.rst - - ProgramOptions - LinkerOptions - -Program caches -`````````````` - -``Program.compile`` accepts a ``cache=`` keyword argument that integrates -with any :class:`~cuda.core.utils.ProgramCacheResource`, so callers can -avoid recompiling identical source + options + target without writing the -:func:`~cuda.core.utils.make_program_cache_key` lookup by hand. - -.. currentmodule:: cuda.core.utils - -.. autosummary:: - :toctree: generated/ - - ProgramCacheResource - InMemoryProgramCache - FileStreamProgramCache - make_program_cache_key - -.. currentmodule:: cuda.core - - CUDA process checkpointing -------------------------- @@ -303,6 +307,8 @@ Use ``Process.restore_thread_id`` to discover that thread before calling persistence mode to be enabled or ``cuInit`` to have been called before execution. +.. currentmodule:: cuda.core + .. autosummary:: :toctree: generated/ @@ -314,6 +320,8 @@ execution. Utility functions ----------------- +.. currentmodule:: cuda.core + .. autosummary:: :toctree: generated/ diff --git a/cuda_core/docs/source/release/1.1.0-notes.rst b/cuda_core/docs/source/release/1.1.0-notes.rst index e95003ae27a..529c9df9eb7 100644 --- a/cuda_core/docs/source/release/1.1.0-notes.rst +++ b/cuda_core/docs/source/release/1.1.0-notes.rst @@ -7,6 +7,25 @@ ================================= +Highlights +---------- + +- ``cuda.core`` now ships with ``.pyi`` type stubs for all public APIs, + giving IDEs and type checkers full autocompletion and static analysis. +- New :mod:`cuda.core.texture` module for texture and surface memory: + :class:`~texture.OpaqueArray`, :class:`~texture.MipmappedArray`, + :class:`~texture.TextureObject`, and :class:`~texture.SurfaceObject`, + constructed through the corresponding ``Device.create_*`` factories. +- Richer managed-memory support: the new :class:`ManagedBuffer` exposes a + property-style advice API (:attr:`~ManagedBuffer.read_mostly`, + :attr:`~ManagedBuffer.preferred_location`, + :attr:`~ManagedBuffer.accessed_by`) with NUMA-aware host locations via the + new :class:`Host` type, plus batched range operations in + :mod:`cuda.core.utils` for prefetching and discarding many buffers at once. +- CUDA 13.3 toolkit support. + (`#2139 `__) + + New features ------------ @@ -14,6 +33,7 @@ New features expressing managed-memory locations: ``Host()`` (any host), ``Host(numa_id=N)`` (specific NUMA node), and ``Host.numa_current()`` (calling thread's NUMA node). + (`#1775 `__) - Added :class:`ManagedBuffer`, a :class:`Buffer` subclass returned by :meth:`ManagedMemoryResource.allocate` that exposes a property-style @@ -30,13 +50,16 @@ New features Use :meth:`ManagedBuffer.from_handle` to wrap an existing managed-memory pointer. + (`#1775 `__) - Added batched managed-memory range operations to :mod:`cuda.core.utils` (CUDA 13+): :func:`~utils.prefetch_batch`, :func:`~utils.discard_batch`, and :func:`~utils.discard_prefetch_batch`. Each takes a sequence of managed :class:`Buffer` instances and dispatches to the corresponding ``cuMem*BatchAsync`` driver entry point, addressing the managed-memory - portion of #1333. Single-buffer operations are exposed as instance + portion of + `#1333 `__. Single-buffer + operations are exposed as instance methods on :class:`ManagedBuffer` (:meth:`~ManagedBuffer.prefetch`, :meth:`~ManagedBuffer.discard`, :meth:`~ManagedBuffer.discard_prefetch`) and as property setters (:attr:`~ManagedBuffer.read_mostly`, @@ -48,6 +71,7 @@ New features :meth:`system.Device.get_nvlinks` for device-specific NVLink enumeration. These APIs avoid relying on the static NVML ``NVML_NVLINK_MAX_LINKS`` macro when querying the links available on a particular device. + (`#2192 `__) - Added the :attr:`graph.GraphBuilder.graph_definition` property, which exposes a captured graph as an explicit :class:`graph.GraphDefinition` @@ -55,21 +79,95 @@ New features flows that mix the capture and explicit graph-building APIs, such as inspecting or augmenting a captured graph, or populating a conditional body entirely through the explicit API. + (`#2026 `__) + +- Added the :mod:`cuda.core.texture` module for texture and surface memory: + :class:`~texture.OpaqueArray` and :class:`~texture.MipmappedArray` for + hardware-laid-out array allocations, and :class:`~texture.TextureObject` and + :class:`~texture.SurfaceObject` for bindless kernel-side sampled reads and + typed load/store. Objects are constructed from a + :class:`~texture.ResourceDescriptor` via + :meth:`Device.create_opaque_array`, :meth:`Device.create_mipmapped_array`, + :meth:`Device.create_texture_object`, and :meth:`Device.create_surface_object`. + (`#467 `__, + `#2095 `__, + `#2307 `__) - ``cuda.core`` now ships with ``.pyi`` stubs for all public APIs, enabling users' IDEs and type checkers to provide better autocompletion and static analysis. + (`#2061 `__) + +- :class:`ObjectCode` and :class:`Program` now accept path-like inputs in + addition to strings and bytes. + (`#2123 `__) + +- Exposed a :attr:`Buffer.size` accessor to Python. + (`#2068 `__, + closes `#2049 `__) -Bug fixes ---------- +Fixes and enhancements +---------------------- - On WSL, ``cuda.core.system.get_process_name`` would raise a ``UnicodeDecodeError``. It should now return the correct result. + (`#2118 `__) - Calling ``cuda.core.system.get_process_name`` before querying any device's ``compute_running_processes`` would raise a ``NvmlNotFoundError``. Now it will correctly return the process name, if it is a GPU-using process. - :meth:`system.Device.get_nvlink` now validates link numbers against the device-specific NVLink count and raises ``ValueError`` for unsupported links. + (`#2192 `__) +- Hardened the IPC buffer import path against malformed or untrusted peer + descriptors: descriptor payloads shorter than the driver struct are now + rejected before import + (`#2223 `__), an imported + buffer's size is validated against the mapped allocation extent before any + copy (`#2224 `__), and + negative allocation handles are always rejected, including under ``-O`` + (`#2219 `__). +- :attr:`ManagedBuffer.accessed_by` now validates every location before + issuing any advice, so a bulk assignment containing an invalid entry can no + longer leave the applied advice in a torn state. + (`#2222 `__) +- Graph nodes now keep their Python-owned attachments (kernel-argument + buffers, host-callback functions and user data, and memcpy/memset operands) + alive for the lifetime of the graph. Previously, keeping these objects alive + was the caller's responsibility. + (`#2280 `__) +- Hardened the graph user-object destructor against races during Python + interpreter shutdown. + (`#2074 `__) +- Free-threading correctness fixes: buffer and memory-resource threading + (`#2162 `__), critical-section + guards on shared accessors + (`#2215 `__), and an atomic + flag guarding buffer memory-attribute initialization + (`#2216 `__). +- :meth:`Program.compile` cache keys are now FIPS-safe. + (`#2087 `__) +- Memory-pool driver errors are now preserved instead of being masked by + out-of-memory handling. + (`#2084 `__) +- DLPack export now raises ``BufferError`` (the intended exception) instead of + ``RuntimeError`` when a buffer cannot be exported. + (`#2160 `__) +- Corrected the :class:`Buffer` and :class:`MemoryResource` ``__eq__`` + implementations. + (`#2067 `__, + closes `#2050 `__) +- Checkpoint restore now validates GPU UUID inputs early. + (`#2086 `__) +- Bumped the PyTorch tensor-bridge upper bound to 2.12. + (`#2099 `__) + +Documentation +------------- + +- Documented the IPC buffer pickle trust boundary: :meth:`Buffer.__reduce__` + and multi-process IPC users should review the security note before + unpickling buffer handles from untrusted sources. + (`#2225 `__) Deprecated APIs --------------- From b1c474c07f521816ea8b56d1728e5ea99a4ec58a Mon Sep 17 00:00:00 2001 From: sri-koundinyan Date: Wed, 8 Jul 2026 16:46:40 -0400 Subject: [PATCH 07/25] [doc-only] cuda_core: add "10 minutes to cuda.core" tutorial to docs (#2289) * cuda_core: add "10 minutes to cuda.core" tutorial to docs Add a beginner-friendly "10 minutes to cuda.core" guide that walks through the core workflow (select a device, compile a kernel, allocate memory, copy, launch, time with events, use multiple streams, capture a CUDA graph, and interoperate with CuPy/PyTorch), then wire it into the cuda.core docs table of contents between the installation and examples sections. Signed-off-by: Sri Koundinyan * cuda_core: address review feedback on 10 minutes to cuda.core Mainly: fix the Device()/thread-local wording for accuracy, simplify the PyTorch stream example (torch supports __cuda_stream__ natively), stop teaching Buffer as a context manager, and tidy up the CUDA graph section. Signed-off-by: Sri Koundinyan --------- Signed-off-by: Sri Koundinyan --- .../docs/source/10_minutes_to_cuda_core.rst | 437 ++++++++++++++++++ cuda_core/docs/source/index.rst | 1 + 2 files changed, 438 insertions(+) create mode 100644 cuda_core/docs/source/10_minutes_to_cuda_core.rst diff --git a/cuda_core/docs/source/10_minutes_to_cuda_core.rst b/cuda_core/docs/source/10_minutes_to_cuda_core.rst new file mode 100644 index 00000000000..b689163d995 --- /dev/null +++ b/cuda_core/docs/source/10_minutes_to_cuda_core.rst @@ -0,0 +1,437 @@ +.. SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +.. SPDX-License-Identifier: Apache-2.0 + +.. currentmodule:: cuda.core + +10 minutes to ``cuda.core`` +=========================== + +Why ``cuda.core``? +------------------ + +``cuda.core`` gives you a **Pythonic interface to the CUDA runtime**: you can +compile a CUDA C++ kernel at runtime, launch it, move memory, time it, and +capture it into a CUDA graph, all without writing a single raw CUDA driver or +runtime call. It is part of `CUDA Python +`_, providing high-level, Pythonic access +to the CUDA runtime on top of the low-level +:doc:`cuda.bindings `, so you get clean, idiomatic Python: + +- **Write GPU kernels from Python.** Compile CUDA C++ to a runnable kernel in a + few lines, with no separate build step, no ``Makefile``, and no ``nvcc`` + invocation. +- **Stay in the Python GPU ecosystem.** It shares CUDA context, streams, and + memory with `CuPy `_ and `PyTorch `_, + so you can launch your own kernels directly on their arrays, with zero copies. +- **Safe by design.** Resources are real Python objects that you release with + ``close()``, and errors raise Python exceptions instead of return codes you + have to check. + +If you have ever wanted to drop a custom CUDA kernel into a NumPy/CuPy/PyTorch +workflow without leaving Python, this is the fastest way to do it. + +Before you begin +---------------- + +This is a short, hands-on introduction to ``cuda.core``, geared mainly toward +new users. It walks from "talk to a GPU" to "compile, launch, time, and capture +a kernel" using small, runnable snippets. For the full reference, see the +:doc:`API reference `; for more complete programs, see the +:doc:`examples page `. + +.. note:: + + These snippets target CUDA 13 and need a working CUDA 13 installation plus + ``cuda.core`` and a matching ``cuda.bindings`` (13.x). The quickest way to get + both from PyPI is: + + .. code-block:: console + + $ pip install "cuda-core[cu13]" + + The :doc:`install page ` covers driver requirements, conda, CUDA 12, + and installing from source. + +Customarily, we import as follows: + +.. code-block:: python + + from cuda.core import Device, LaunchConfig, Program, ProgramOptions, launch + + +Selecting a device +------------------ + +:class:`Device` is your entry point. Creating one does **not** initialize the +GPU; calling :meth:`Device.set_current` is what sets up a `CUDA context +`_ +on the current host thread. Always call it before doing GPU work. + +.. code-block:: python + + dev = Device() # current device (device 0 if none is current); Device(1) picks a specific GPU + dev.set_current() # initialize CUDA and make this device current + + print(dev.name) # e.g. 'NVIDIA GB10' + print(dev.compute_capability) # ComputeCapability(major=12, minor=1) + print(dev.arch) # '121' (handy for building kernels below) + +:class:`Device` is a thread-local singleton: on the same thread, ``Device(0)`` +always returns the same object, so repeated calls are cheap. Rich device +attributes live under :attr:`Device.properties` (for example +``dev.properties.multiprocessor_count``). + + +Compiling a kernel +------------------ + +CUDA C++ source is compiled at runtime with :class:`Program`. You describe the +compile with :class:`ProgramOptions` (here: the C++ standard and the target +architecture, taken from ``dev.arch``), call :meth:`Program.compile` to get an +:class:`ObjectCode`, then pull out a callable :class:`Kernel` by name. + +.. code-block:: python + + code = r""" + extern "C" __global__ + void scale(float* data, float factor, size_t n) { + size_t i = threadIdx.x + blockIdx.x * blockDim.x; + if (i < n) + data[i] *= factor; + } + """ + + opts = ProgramOptions(std="c++17", arch=f"sm_{dev.arch}") + prog = Program(code, code_type="c++", options=opts) + mod = prog.compile("cubin") # "cubin" | "ptx" | "ltoir" + scale = mod.get_kernel("scale") + +We wrap the kernel in ``extern "C"`` so its name is exactly ``"scale"``, which is +the name we pass to :meth:`~ObjectCode.get_kernel`. + +When something goes wrong, ``cuda.core`` raises a regular Python exception rather +than returning an error code. A compilation failure is especially friendly: the +exception carries the compiler's log, so you can see exactly what went wrong +(other errors raise an exception with the CUDA error name and description). + +.. code-block:: python + + bad = r'extern "C" __global__ void k() { not_a_real_symbol; }' + try: + Program(bad, code_type="c++", options=opts).compile("cubin") + except Exception as e: + # the exception carries the compiler log + assert 'identifier "not_a_real_symbol" is undefined' in str(e) + + +Streams +------- + +A :class:`Stream` is an ordered queue of GPU work. Operations on the same stream +run sequentially; operations on separate streams may run concurrently. Most +``cuda.core`` operations that touch the GPU take a stream so you stay in control +of ordering. Create one from the device: + +.. code-block:: python + + stream = dev.create_stream() + +We create it first because the steps that follow, allocating, copying, and +launching, are all issued on a stream. We will pass this ``stream`` to each of +them in the next two sections. + + +Allocating memory +----------------- + +Memory comes from a :class:`MemoryResource`. Two you'll use early: + +- :meth:`Device.allocate` hands you a **device** :class:`Buffer` from the + device's default memory resource. +- :class:`PinnedMemoryResource` allocates **host** memory that is page-locked + (and host-accessible), which is convenient for staging data to and from the GPU. + +Like :meth:`Device.allocate`, :class:`PinnedMemoryResource` is stream-ordered, so +its :meth:`~PinnedMemoryResource.allocate` also takes a ``stream``. + +From here on we use `NumPy `_ for host data and to check +results, but only as a convenience: ``cuda.core`` works directly on raw memory +buffers and typed pointers, and does not depend on NumPy or any other array +library. + +.. code-block:: python + + import numpy as np + + from cuda.core import PinnedMemoryResource + + n = 1024 + nbytes = n * np.dtype(np.float32).itemsize + + pinned = PinnedMemoryResource() + host = pinned.allocate(nbytes, stream=stream) # host-accessible buffer + dbuf = dev.allocate(nbytes, stream=stream) # device buffer + + print(host.size, host.is_host_accessible) # 4096 True + print(dbuf.is_device_accessible) # True + +A :class:`Buffer` is an owning handle to an allocation. Because every +:class:`Buffer` implements ``__dlpack__``, we can get a NumPy view of the +*host* buffer with :func:`numpy.from_dlpack` (no copy, no raw pointers) and +fill it in place. (``from_dlpack`` hands back raw bytes, so we ``.view`` it as +``float32``.) + +.. code-block:: python + + host_np = np.from_dlpack(host).view(np.float32) # writable view, zero-copy + host_np[:] = np.arange(n, dtype=np.float32) + +The same trick works on the *device* side with CuPy: ``cp.from_dlpack(dbuf)`` +gives a CuPy array backed by the device buffer. + + +Copying and launching +--------------------- + +Copy host to device with :meth:`Buffer.copy_from`, run the kernel with +:func:`launch`, then copy device to host with :meth:`Buffer.copy_to`. These are +all stream-ordered and asynchronous; :meth:`Stream.sync` blocks until the queued +work finishes. + +:class:`LaunchConfig` describes the grid and block; :func:`launch` takes the +stream, the config, the kernel, and then the kernel arguments. A :class:`Buffer` +can be passed straight through as a pointer argument. Scalars, however, must +carry an explicit C type, so we use NumPy scalars (``np.float32``, +``np.uint64``) to match the kernel signature. + +.. code-block:: python + + dbuf.copy_from(host, stream=stream) # H2D + + block = 256 + grid = (n + block - 1) // block + config = LaunchConfig(grid=grid, block=block) + launch(stream, config, scale, dbuf, np.float32(3.0), np.uint64(n)) + + dbuf.copy_to(host, stream=stream) # D2H + stream.sync() # wait for all of the above + + assert np.array_equal(host_np, np.arange(n, dtype=np.float32) * 3.0) + +That is the core ``cuda.core`` workflow: **select a device, compile, allocate, +copy, launch, sync.** Everything below builds on it. + + +Timing with events +------------------ + +An :class:`Event` marks a point in a stream. Create timing-enabled events, +:meth:`record ` them around some work, synchronize, and subtract +to get the elapsed time between them in milliseconds. + +.. code-block:: python + + start = dev.create_event({"timing_enabled": True}) + end = dev.create_event({"timing_enabled": True}) + + stream.record(start) + for _ in range(100): + launch(stream, config, scale, dbuf, np.float32(1.0), np.uint64(n)) + stream.record(end) + end.sync() + + print(f"100 launches took {end - start:.4f} ms") + +Events are also how you build cross-stream dependencies without stalling the +host: :meth:`Stream.wait` makes one stream wait on an event (or another stream). + + +Working with multiple streams +----------------------------- + +A single stream is enough for ordered work, but multiple streams let independent +work proceed in parallel. The two launches below touch different buffers, so the +GPU is free to run them at the same time. When a later step *does* depend on +another stream's result, :meth:`Stream.wait` joins them: it makes one stream wait +for another's work to finish before continuing. + +.. code-block:: python + + stream_a = dev.create_stream() + stream_b = dev.create_stream() + + buf_a = dev.allocate(nbytes, stream=stream_a) + buf_b = dev.allocate(nbytes, stream=stream_b) + + host_np[:] = np.arange(n, dtype=np.float32) # known input + buf_a.copy_from(host, stream=stream_a) + buf_b.copy_from(host, stream=stream_b) + + # Independent work on each stream: free to run concurrently. + launch(stream_a, config, scale, buf_a, np.float32(2.0), np.uint64(n)) + launch(stream_b, config, scale, buf_b, np.float32(5.0), np.uint64(n)) + + # stream_b now needs stream_a's result, so it waits before reading it. + stream_b.wait(stream_a) + buf_b.copy_from(buf_a, stream=stream_b) # safe: buf_a is ready + + buf_b.copy_to(host, stream=stream_b) + stream_b.sync() + assert np.array_equal(host_np, np.arange(n, dtype=np.float32) * 2.0) + +Without the :meth:`Stream.wait`, the copy on ``stream_b`` could race ahead of the +kernel on ``stream_a``. Whether the two independent launches actually overlap is +up to the GPU scheduler, which can run them together only when each leaves the +device underutilized; using separate streams expresses that the work is +independent and lets the runtime overlap it when it can. The +:doc:`examples ` show this scaled up across multiple GPUs. + + +Capturing work in a CUDA graph +------------------------------ + +Repeating the same GPU work many times means paying the CPU cost of submitting +each operation on every repeat. A CUDA graph lets you record that work once and +then launch the whole graph repeatedly, instead of re-issuing each operation +every time. Use the stream's graph builder: begin building, issue your +operations into the *builder* instead of the stream, then complete the graph. + +.. code-block:: python + + gb = stream.create_graph_builder() + gb.begin_building() + + launch(gb, config, scale, dbuf, np.float32(1.0), np.uint64(n)) + launch(gb, config, scale, dbuf, np.float32(1.0), np.uint64(n)) + + graph = gb.end_building().complete() + + graph.upload(stream) + graph.launch(stream) # replay the whole graph in one shot + stream.sync() + +See :cuda-core-example:`cuda_graphs.py ` +for a complete capture-and-replay example with a measured speedup. + +Beyond the stream capture shown here, ``cuda.core`` also provides an explicit +graph interface (the :mod:`cuda.core.graph` module) for building, inspecting, and +modifying graphs directly, including graphs first produced by capture. The +project's `graph tests +`_ have +many usage examples. + + +Working with CuPy and PyTorch +----------------------------- + +``cuda.core`` is designed to interoperate with the rest of the Python GPU +ecosystem, so in real workflows you often skip manual host buffers entirely and +operate directly on CuPy or PyTorch arrays. + +**Current device/context.** Because :meth:`Device.set_current` sets a normal +CUDA context (the standard primary context), other CUDA-runtime libraries pick +it up automatically: if CuPy or PyTorch has already selected a device, +``Device()`` shares it, and vice versa. + +**Passing array data to a kernel.** Both CuPy and PyTorch expose their device +pointer, which you pass to :func:`launch` like any other buffer pointer. We reuse +the ``scale`` kernel and ``config`` from above, applying a factor of ``2.0`` to an +array of ones: + +.. code-block:: python + + # CuPy exposes its device pointer as .data.ptr + import cupy as cp + + a = cp.ones(n, dtype=cp.float32) + dev.sync() # CuPy fills "a" on its own stream; sync before our stream reads it + launch(stream, config, scale, a.data.ptr, np.float32(2.0), np.uint64(a.size)) + stream.sync() + assert bool((a == 2).all()) + +.. code-block:: python + + # PyTorch streams implement the __cuda_stream__ protocol natively + import torch + + t = torch.ones(n, dtype=torch.float32, device="cuda") + ts = dev.create_stream(torch.cuda.current_stream()) + launch(ts, config, scale, t.data_ptr(), np.float32(2.0), np.uint64(t.numel())) + ts.sync() + assert bool((t == 2).all()) + +The ``__cuda_stream__`` protocol is how an object advertises that it represents a +CUDA stream, so :meth:`Device.create_stream` can accept it and drive ``cuda.core`` +work on another library's stream. PyTorch implements it natively as of version +2.10. See the :doc:`interoperability guide ` for the protocol +details and how to support it in your own types. + +**Array-library-agnostic views.** To accept *any* CuPy/PyTorch/NumPy-like array +that supports DLPack or the CUDA Array Interface, decorate a function with +:func:`~cuda.core.utils.args_viewable_as_strided_memory`. The chosen arguments +become :class:`~cuda.core.utils.StridedMemoryView` objects exposing ``ptr``, +``shape``, ``dtype``, and ``is_device_accessible``: + +.. code-block:: python + + from cuda.core.utils import StridedMemoryView, args_viewable_as_strided_memory + + @args_viewable_as_strided_memory((0,)) + def scale_array(arr, work_stream, kern, factor): + view = arr.view(work_stream.handle) + assert isinstance(view, StridedMemoryView) + assert view.is_device_accessible + size = view.shape[0] + cfg = LaunchConfig(grid=(size + 255) // 256, block=256) + launch(work_stream, cfg, kern, view.ptr, np.float32(factor), np.uint64(size)) + work_stream.sync() + + # Works on a CuPy array, a PyTorch tensor, or anything else with DLPack/CAI: + buf = cp.ones(n, dtype=cp.float32) + dev.sync() + scale_array(buf, stream, scale, 2.0) + assert bool((buf == 2).all()) + +``cuda.core`` buffers also implement ``__dlpack__``, so a device :class:`Buffer` +can be handed to any DLPack importer for zero-copy exchange. + + +Cleaning up +----------- + +Buffers, streams, events, graphs, and graph builders hold CUDA resources. They +are released when garbage-collected, but you can release them explicitly with +``close()``, which the :cuda-core-examples:`cuda.core examples ` do in a +``finally`` block. + +.. code-block:: python + + graph.close() + gb.close() + dbuf.close(stream=stream) + host.close(stream=stream) + stream.close() + + +Where to go next +---------------- + +You now know the essential ``cuda.core`` workflow and how to plug it into the +Python GPU ecosystem. From here: + +- :doc:`Examples `: runnable programs for templated kernels + (``name_expressions``), multi-GPU, graphs, JIT link-time optimization, TMA, + and interop. +- :doc:`Interoperability `: the ``__cuda_stream__`` protocol, + DLPack/CAI, and ``StridedMemoryView`` in depth. +- :doc:`API reference `: every public class and function, including + :class:`Linker` (runtime linking/LTO), the memory-resource family + (:class:`DeviceMemoryResource`, :class:`ManagedMemoryResource`, + :class:`VirtualMemoryResource`, ...), and the :mod:`graph ` + node types. +- :doc:`Environment variables `: runtime knobs such as + the per-thread default stream. +- Prefer writing kernels in Python instead of CUDA C++? `Numba CUDA + `_ compiles a subset of Python into CUDA + kernels, and `numba-cuda-mlir `_ is + its next-generation evolution. diff --git a/cuda_core/docs/source/index.rst b/cuda_core/docs/source/index.rst index 7e4e2ffd4ec..bf9128b1389 100644 --- a/cuda_core/docs/source/index.rst +++ b/cuda_core/docs/source/index.rst @@ -12,6 +12,7 @@ Welcome to the documentation for ``cuda.core``. getting-started install + 10_minutes_to_cuda_core examples interoperability api From dcff8e62f84469642292635e174e3bdd400b5b8c Mon Sep 17 00:00:00 2001 From: "Ralf W. Grosse-Kunstleve" Date: Wed, 8 Jul 2026 14:37:59 -0700 Subject: [PATCH 08/25] Add content seals and validation for generated CUDA Bindings files (#2310) * Relicense CUDA Bindings and CUDA Python Signed-off-by: Keith Kraus * Address relicensing review feedback Signed-off-by: Keith Kraus * Address copyright and lockfile review feedback Signed-off-by: Keith Kraus * run_cybind_cython_gen 13.3.0 ../cuda-python * run_cybind_native 13.3.0 ../cuda-python * run_cybind_native 13.3.0 ../cuda-python * run_cybind_cython_gen 13.3.0 ../cuda-python * run_cybind_native 13.3.0 ../cuda-python * Check cybind-generated file seals in pre-commit * Revert "run_cybind_native 13.3.0 ../cuda-python" This reverts commit 0338189c4bbbcc53e122e3a110910902b15d3f4a. * Revert "run_cybind_cython_gen 13.3.0 ../cuda-python" This reverts commit b8f6a853c8f34cdacbfa426867cc64278818c279. * run_cybind_cython_gen 13.3.0 ../cuda-python * run_cybind_native 13.3.0 ../cuda-python * Revert "run_cybind_native 13.3.0 ../cuda-python" This reverts commit 94e42e89607a8ae6f12ab0e0ec458157593d180e. * Revert "run_cybind_cython_gen 13.3.0 ../cuda-python" This reverts commit cc82446318f566629e0d6c6bc422ac9c1f92d574. * run_cybind_cython_gen 13.3.0 ../cuda-python * run_cybind_native 13.3.0 ../cuda-python * Use resolved nvcc path for RDC library fixtures * Generalize generated-file seal validation * Address generated-file seal review feedback * Exclude seal checker from generated-file grep * run_cybind_cython_gen 13.3.0 ../cuda-python && run_cybind_native 13.3.0 ../cuda-python Before running cybind: rm $(git grep -l -F CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE) --------- Signed-off-by: Keith Kraus Co-authored-by: Keith Kraus --- .pre-commit-config.yaml | 7 + .../cuda/bindings/_bindings/cyruntime.pxd.in | 1 + .../cuda/bindings/_bindings/cyruntime.pyx.in | 1 + .../bindings/_bindings/cyruntime_ptds.pxd.in | 1 + .../bindings/_bindings/cyruntime_ptds.pyx.in | 1 + .../cuda/bindings/_internal/_fast_enum.py | 1 + .../cuda/bindings/_internal/cudla.pxd | 1 + .../cuda/bindings/_internal/cudla_linux.pyx | 1 + .../cuda/bindings/_internal/cufile.pxd | 1 + .../cuda/bindings/_internal/cufile_linux.pyx | 1 + .../cuda/bindings/_internal/driver.pxd | 1 + .../cuda/bindings/_internal/driver_linux.pyx | 1 + .../bindings/_internal/driver_windows.pyx | 1 + .../cuda/bindings/_internal/nvfatbin.pxd | 1 + .../bindings/_internal/nvfatbin_linux.pyx | 1 + .../bindings/_internal/nvfatbin_windows.pyx | 1 + .../cuda/bindings/_internal/nvjitlink.pxd | 1 + .../bindings/_internal/nvjitlink_linux.pyx | 1 + .../bindings/_internal/nvjitlink_windows.pyx | 1 + .../cuda/bindings/_internal/nvml.pxd | 1 + .../cuda/bindings/_internal/nvml_linux.pyx | 1 + .../cuda/bindings/_internal/nvml_windows.pyx | 1 + .../cuda/bindings/_internal/nvrtc.pxd | 1 + .../cuda/bindings/_internal/nvrtc_linux.pyx | 1 + .../cuda/bindings/_internal/nvrtc_windows.pyx | 1 + .../cuda/bindings/_internal/nvvm.pxd | 1 + .../cuda/bindings/_internal/nvvm_linux.pyx | 1 + .../cuda/bindings/_internal/nvvm_windows.pyx | 1 + cuda_bindings/cuda/bindings/cudla.pxd | 1 + cuda_bindings/cuda/bindings/cudla.pyx | 1 + cuda_bindings/cuda/bindings/cufile.pxd | 1 + cuda_bindings/cuda/bindings/cufile.pyx | 1 + cuda_bindings/cuda/bindings/cycudla.pxd | 1 + cuda_bindings/cuda/bindings/cycudla.pyx | 1 + cuda_bindings/cuda/bindings/cycufile.pxd | 1 + cuda_bindings/cuda/bindings/cycufile.pyx | 1 + cuda_bindings/cuda/bindings/cydriver.pxd | 1 + cuda_bindings/cuda/bindings/cydriver.pyx | 1 + cuda_bindings/cuda/bindings/cynvfatbin.pxd | 1 + cuda_bindings/cuda/bindings/cynvfatbin.pyx | 1 + cuda_bindings/cuda/bindings/cynvjitlink.pxd | 1 + cuda_bindings/cuda/bindings/cynvjitlink.pyx | 1 + cuda_bindings/cuda/bindings/cynvml.pxd | 1 + cuda_bindings/cuda/bindings/cynvml.pyx | 1 + cuda_bindings/cuda/bindings/cynvrtc.pxd | 1 + cuda_bindings/cuda/bindings/cynvrtc.pyx | 1 + cuda_bindings/cuda/bindings/cynvvm.pxd | 1 + cuda_bindings/cuda/bindings/cynvvm.pyx | 1 + cuda_bindings/cuda/bindings/cyruntime.pxd.in | 1 + cuda_bindings/cuda/bindings/cyruntime.pyx.in | 1 + .../cuda/bindings/cyruntime_functions.pxi.in | 1 + .../cuda/bindings/cyruntime_types.pxi.in | 1 + cuda_bindings/cuda/bindings/driver.pxd | 1 + cuda_bindings/cuda/bindings/driver.pyx | 1 + cuda_bindings/cuda/bindings/nvfatbin.pxd | 1 + cuda_bindings/cuda/bindings/nvfatbin.pyx | 1 + cuda_bindings/cuda/bindings/nvjitlink.pxd | 1 + cuda_bindings/cuda/bindings/nvjitlink.pyx | 1 + cuda_bindings/cuda/bindings/nvml.pxd | 1 + cuda_bindings/cuda/bindings/nvml.pyx | 1 + cuda_bindings/cuda/bindings/nvrtc.pxd | 1 + cuda_bindings/cuda/bindings/nvrtc.pyx | 1 + cuda_bindings/cuda/bindings/nvvm.pxd | 1 + cuda_bindings/cuda/bindings/nvvm.pyx | 1 + cuda_bindings/cuda/bindings/runtime.pxd.in | 1 + cuda_bindings/cuda/bindings/runtime.pyx.in | 1 + cuda_bindings/docs/source/module/driver.rst | 1 + cuda_bindings/docs/source/module/nvrtc.rst | 1 + cuda_bindings/docs/source/module/runtime.rst | 1 + .../test_binaries/build_test_binaries.sh | 4 +- toolshed/check_generated_file_seals.py | 153 ++++++++++++++++++ 71 files changed, 230 insertions(+), 2 deletions(-) create mode 100644 toolshed/check_generated_file_seals.py diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index cd96fe925c3..029e69da916 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -43,6 +43,13 @@ repos: exclude: '(.*pixi\.lock)|(\.git_archival\.txt)|(.*\.patch$)|(^cuda_core/cuda/core/_vendored/)' args: ["--fix"] + - id: check-generated-file-seals + name: Check generated-file seals + entry: python ./toolshed/check_generated_file_seals.py + language: python + files: ^cuda_bindings/ + types: [text] + - id: no-markdown-in-docs-source name: Prevent markdown files in docs/source directories entry: bash -c diff --git a/cuda_bindings/cuda/bindings/_bindings/cyruntime.pxd.in b/cuda_bindings/cuda/bindings/_bindings/cyruntime.pxd.in index 085c4a08334..5432ab70c8a 100644 --- a/cuda_bindings/cuda/bindings/_bindings/cyruntime.pxd.in +++ b/cuda_bindings/cuda/bindings/_bindings/cyruntime.pxd.in @@ -2,6 +2,7 @@ # SPDX-License-Identifier: Apache-2.0 # This code was automatically generated with version 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=a99a543be62e221f4b4b43249719b689c33ea030adef3dfa012b31efac555ece include "../cyruntime_types.pxi" include "../_lib/cyruntime/cyruntime.pxd" diff --git a/cuda_bindings/cuda/bindings/_bindings/cyruntime.pyx.in b/cuda_bindings/cuda/bindings/_bindings/cyruntime.pyx.in index 4c20b87d96f..58388d3dd92 100644 --- a/cuda_bindings/cuda/bindings/_bindings/cyruntime.pyx.in +++ b/cuda_bindings/cuda/bindings/_bindings/cyruntime.pyx.in @@ -2,6 +2,7 @@ # SPDX-License-Identifier: Apache-2.0 # This code was automatically generated with version 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=ccadd478eafb421b735d8fc0c44e1c03e873885646a81381f1d995bd573b5120 include "../cyruntime_functions.pxi" import os diff --git a/cuda_bindings/cuda/bindings/_bindings/cyruntime_ptds.pxd.in b/cuda_bindings/cuda/bindings/_bindings/cyruntime_ptds.pxd.in index 7f699b95b2a..d12c7be7141 100644 --- a/cuda_bindings/cuda/bindings/_bindings/cyruntime_ptds.pxd.in +++ b/cuda_bindings/cuda/bindings/_bindings/cyruntime_ptds.pxd.in @@ -2,6 +2,7 @@ # SPDX-License-Identifier: Apache-2.0 # This code was automatically generated with version 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=005e8f266f43a90c73b382df384f4143abf0e82b26d8ad69cb8aa58fbafa13ef cdef extern from "": """ #define CUDA_API_PER_THREAD_DEFAULT_STREAM diff --git a/cuda_bindings/cuda/bindings/_bindings/cyruntime_ptds.pyx.in b/cuda_bindings/cuda/bindings/_bindings/cyruntime_ptds.pyx.in index 4e0324f6ce6..c69f8a4fda2 100644 --- a/cuda_bindings/cuda/bindings/_bindings/cyruntime_ptds.pyx.in +++ b/cuda_bindings/cuda/bindings/_bindings/cyruntime_ptds.pyx.in @@ -2,6 +2,7 @@ # SPDX-License-Identifier: Apache-2.0 # This code was automatically generated with version 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=1e1b93a907c72767d54e7b740e3e3a1b7b629b111af47d22c94b587b769bab9c cdef extern from "": """ #define CUDA_API_PER_THREAD_DEFAULT_STREAM diff --git a/cuda_bindings/cuda/bindings/_internal/_fast_enum.py b/cuda_bindings/cuda/bindings/_internal/_fast_enum.py index a11477ea73b..cb3e6e900a3 100644 --- a/cuda_bindings/cuda/bindings/_internal/_fast_enum.py +++ b/cuda_bindings/cuda/bindings/_internal/_fast_enum.py @@ -4,6 +4,7 @@ # This code was automatically generated across versions from 12.0.1 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=5791f341ee9bb6573f42300fbed50cc52fc5e808c1d6bb9156e6aabb9db29b17 """ This is a replacement for the stdlib enum.IntEnum. diff --git a/cuda_bindings/cuda/bindings/_internal/cudla.pxd b/cuda_bindings/cuda/bindings/_internal/cudla.pxd index a106bd3b0d2..359cf8f486a 100644 --- a/cuda_bindings/cuda/bindings/_internal/cudla.pxd +++ b/cuda_bindings/cuda/bindings/_internal/cudla.pxd @@ -3,6 +3,7 @@ # This code was automatically generated across versions from 1.5.0 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=07f18bf6993a0d962a4e844aa9ea9a335534c669992d112dd12003b77015e5ba from ..cycudla cimport * diff --git a/cuda_bindings/cuda/bindings/_internal/cudla_linux.pyx b/cuda_bindings/cuda/bindings/_internal/cudla_linux.pyx index d14c69efaf6..93ebdfa927d 100644 --- a/cuda_bindings/cuda/bindings/_internal/cudla_linux.pyx +++ b/cuda_bindings/cuda/bindings/_internal/cudla_linux.pyx @@ -3,6 +3,7 @@ # This code was automatically generated across versions from 1.5.0 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=2b56e5f08b7806fe10648817d36d96ce420cb5a8329615fb283f71119128d090 from libc.stdint cimport intptr_t, uintptr_t import threading diff --git a/cuda_bindings/cuda/bindings/_internal/cufile.pxd b/cuda_bindings/cuda/bindings/_internal/cufile.pxd index 1942dce0612..b8fe03b779d 100644 --- a/cuda_bindings/cuda/bindings/_internal/cufile.pxd +++ b/cuda_bindings/cuda/bindings/_internal/cufile.pxd @@ -4,6 +4,7 @@ # # This code was automatically generated across versions from 12.9.1 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=b70fdd33eb00b70224c097fb28dd1031d82e8a2930356a4428c93e3bd1b52a86 from ..cycufile cimport * diff --git a/cuda_bindings/cuda/bindings/_internal/cufile_linux.pyx b/cuda_bindings/cuda/bindings/_internal/cufile_linux.pyx index 5a7f52af473..0917a2b368b 100644 --- a/cuda_bindings/cuda/bindings/_internal/cufile_linux.pyx +++ b/cuda_bindings/cuda/bindings/_internal/cufile_linux.pyx @@ -4,6 +4,7 @@ # # This code was automatically generated across versions from 12.9.1 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=b43946a1b7b010b7d9ee95ed67723e3dfc54b46a6dc68829e936ffad6ba852dc from libc.stdint cimport intptr_t, uintptr_t import threading diff --git a/cuda_bindings/cuda/bindings/_internal/driver.pxd b/cuda_bindings/cuda/bindings/_internal/driver.pxd index c10a279efc2..d0d183d034c 100644 --- a/cuda_bindings/cuda/bindings/_internal/driver.pxd +++ b/cuda_bindings/cuda/bindings/_internal/driver.pxd @@ -4,6 +4,7 @@ # # This code was automatically generated across versions from 12.9.0 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=a82b3f5dcb30b13294f6896a4d9d9f2f8d7be6b29c8f0a0c61677b1c622d4480 from ..cydriver cimport * diff --git a/cuda_bindings/cuda/bindings/_internal/driver_linux.pyx b/cuda_bindings/cuda/bindings/_internal/driver_linux.pyx index d90e6346d8d..59a0dbc0b32 100644 --- a/cuda_bindings/cuda/bindings/_internal/driver_linux.pyx +++ b/cuda_bindings/cuda/bindings/_internal/driver_linux.pyx @@ -4,6 +4,7 @@ # # This code was automatically generated across versions from 12.9.0 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=5707b0fec0518992a2e1a55400a030c3921e5443dc65094af083b8845b41b0e5 from libc.stdint cimport intptr_t, uintptr_t import os diff --git a/cuda_bindings/cuda/bindings/_internal/driver_windows.pyx b/cuda_bindings/cuda/bindings/_internal/driver_windows.pyx index aeb7aee0ac9..96c7545dd11 100644 --- a/cuda_bindings/cuda/bindings/_internal/driver_windows.pyx +++ b/cuda_bindings/cuda/bindings/_internal/driver_windows.pyx @@ -4,6 +4,7 @@ # # This code was automatically generated across versions from 12.9.0 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=51232c67845ad8bb70e4d63f8f48ed1246b27d371b929f229fa09c27b23235c8 from libc.stdint cimport intptr_t import os diff --git a/cuda_bindings/cuda/bindings/_internal/nvfatbin.pxd b/cuda_bindings/cuda/bindings/_internal/nvfatbin.pxd index c93d43badae..b712a3087b8 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvfatbin.pxd +++ b/cuda_bindings/cuda/bindings/_internal/nvfatbin.pxd @@ -4,6 +4,7 @@ # # This code was automatically generated across versions from 12.4.1 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=b52d99b7f07615d6c5ecb869a5c632e6e9cb4d0cb4f6cb1e43977d29ecd9995c from ..cynvfatbin cimport * diff --git a/cuda_bindings/cuda/bindings/_internal/nvfatbin_linux.pyx b/cuda_bindings/cuda/bindings/_internal/nvfatbin_linux.pyx index 34d84da5e7e..e30e9ee145d 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvfatbin_linux.pyx +++ b/cuda_bindings/cuda/bindings/_internal/nvfatbin_linux.pyx @@ -4,6 +4,7 @@ # # This code was automatically generated across versions from 12.4.1 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=821fd26991431cd8e528f964b5035e1deafcddf44d2971a267d9ed11d80d5199 from libc.stdint cimport intptr_t, uintptr_t import threading diff --git a/cuda_bindings/cuda/bindings/_internal/nvfatbin_windows.pyx b/cuda_bindings/cuda/bindings/_internal/nvfatbin_windows.pyx index a52733389fb..b82882cfd76 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvfatbin_windows.pyx +++ b/cuda_bindings/cuda/bindings/_internal/nvfatbin_windows.pyx @@ -4,6 +4,7 @@ # # This code was automatically generated across versions from 12.4.1 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=2052c33a9bbfdef36b362c4eedc1284ce8fa2fc905a53ac9c366218ca99f5913 from libc.stdint cimport intptr_t import threading diff --git a/cuda_bindings/cuda/bindings/_internal/nvjitlink.pxd b/cuda_bindings/cuda/bindings/_internal/nvjitlink.pxd index 29b6e6568c5..edfe717e649 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvjitlink.pxd +++ b/cuda_bindings/cuda/bindings/_internal/nvjitlink.pxd @@ -4,6 +4,7 @@ # # This code was automatically generated across versions from 12.0.1 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=fd32577c0d6b922ff30c56dc4f3dcbed2251c393098c27d972ccc8688564fa50 from ..cynvjitlink cimport * diff --git a/cuda_bindings/cuda/bindings/_internal/nvjitlink_linux.pyx b/cuda_bindings/cuda/bindings/_internal/nvjitlink_linux.pyx index 7af8d3a0176..33cea546ee4 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvjitlink_linux.pyx +++ b/cuda_bindings/cuda/bindings/_internal/nvjitlink_linux.pyx @@ -4,6 +4,7 @@ # # This code was automatically generated across versions from 12.0.1 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=f6e8c32c0afa43fe218ae5c6f43f402bb85ab1e9898ad6270872c3e546eb4913 from libc.stdint cimport intptr_t, uintptr_t import threading diff --git a/cuda_bindings/cuda/bindings/_internal/nvjitlink_windows.pyx b/cuda_bindings/cuda/bindings/_internal/nvjitlink_windows.pyx index 26537b5a059..1385f2df077 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvjitlink_windows.pyx +++ b/cuda_bindings/cuda/bindings/_internal/nvjitlink_windows.pyx @@ -4,6 +4,7 @@ # # This code was automatically generated across versions from 12.0.1 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=9043dd9e45a69e2bd6c7984832fca8cc1ccd7c66b605b384e4cff18b0c713027 from libc.stdint cimport intptr_t import threading diff --git a/cuda_bindings/cuda/bindings/_internal/nvml.pxd b/cuda_bindings/cuda/bindings/_internal/nvml.pxd index c83348fd358..eea80739f07 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvml.pxd +++ b/cuda_bindings/cuda/bindings/_internal/nvml.pxd @@ -4,6 +4,7 @@ # # This code was automatically generated across versions from 12.9.1 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=ed4c433854399c2e4f1adc3ffcfc37901e1be29c5aa50728498c87225edf92b1 from ..cynvml cimport * diff --git a/cuda_bindings/cuda/bindings/_internal/nvml_linux.pyx b/cuda_bindings/cuda/bindings/_internal/nvml_linux.pyx index 948be266843..05e7ede4929 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvml_linux.pyx +++ b/cuda_bindings/cuda/bindings/_internal/nvml_linux.pyx @@ -4,6 +4,7 @@ # # This code was automatically generated across versions from 12.9.1 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=bdb56d8618b22dfcdcb3da879bbe276c3caf7c07aae6e5aa2b76de817f4baa39 from libc.stdint cimport intptr_t, uintptr_t import threading diff --git a/cuda_bindings/cuda/bindings/_internal/nvml_windows.pyx b/cuda_bindings/cuda/bindings/_internal/nvml_windows.pyx index 02294da79c9..6de3a0e8671 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvml_windows.pyx +++ b/cuda_bindings/cuda/bindings/_internal/nvml_windows.pyx @@ -4,6 +4,7 @@ # # This code was automatically generated across versions from 12.9.1 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=56d9b790c493aea94da4c2c52e78dea025da7c698edc614c374767038d40869c from libc.stdint cimport intptr_t import os diff --git a/cuda_bindings/cuda/bindings/_internal/nvrtc.pxd b/cuda_bindings/cuda/bindings/_internal/nvrtc.pxd index dbb03f54a1e..020f113c03b 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvrtc.pxd +++ b/cuda_bindings/cuda/bindings/_internal/nvrtc.pxd @@ -4,6 +4,7 @@ # # This code was automatically generated across versions from 12.9.0 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=ff79428bd0afac112d0a9f6131f9ed097b8d0ebc4574444a0e4a41e7f6e260d0 from ..cynvrtc cimport * diff --git a/cuda_bindings/cuda/bindings/_internal/nvrtc_linux.pyx b/cuda_bindings/cuda/bindings/_internal/nvrtc_linux.pyx index 24d9d92cece..43efa40e4d8 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvrtc_linux.pyx +++ b/cuda_bindings/cuda/bindings/_internal/nvrtc_linux.pyx @@ -4,6 +4,7 @@ # # This code was automatically generated across versions from 12.9.0 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=6e54cb56384256b65cc962fbb478f7fac87523f222a141785b66881d8f554c64 from libc.stdint cimport intptr_t, uintptr_t import threading diff --git a/cuda_bindings/cuda/bindings/_internal/nvrtc_windows.pyx b/cuda_bindings/cuda/bindings/_internal/nvrtc_windows.pyx index b31d57a66ff..2aef3b145d4 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvrtc_windows.pyx +++ b/cuda_bindings/cuda/bindings/_internal/nvrtc_windows.pyx @@ -4,6 +4,7 @@ # # This code was automatically generated across versions from 12.9.0 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=7e496ceaaaf75ed29455bb670e3b3af9ab7d4ba1ea155a129088c04aab9b3c16 from libc.stdint cimport intptr_t import threading diff --git a/cuda_bindings/cuda/bindings/_internal/nvvm.pxd b/cuda_bindings/cuda/bindings/_internal/nvvm.pxd index 6c48b41efbf..e4ac3cf1258 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvvm.pxd +++ b/cuda_bindings/cuda/bindings/_internal/nvvm.pxd @@ -4,6 +4,7 @@ # # This code was automatically generated across versions from 12.0.1 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=a27b041eb470b98bf5b1a0a92ace9467c5f3921d47ee10557a4f00ff1e4ac411 from ..cynvvm cimport * diff --git a/cuda_bindings/cuda/bindings/_internal/nvvm_linux.pyx b/cuda_bindings/cuda/bindings/_internal/nvvm_linux.pyx index 40be61a91a3..d4cd73399a4 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvvm_linux.pyx +++ b/cuda_bindings/cuda/bindings/_internal/nvvm_linux.pyx @@ -4,6 +4,7 @@ # # This code was automatically generated across versions from 12.0.1 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=3c31adc68b8220439ea196a56ea63cf670aff0f85c0a67c8f554e1af4d07f456 from libc.stdint cimport intptr_t, uintptr_t import threading diff --git a/cuda_bindings/cuda/bindings/_internal/nvvm_windows.pyx b/cuda_bindings/cuda/bindings/_internal/nvvm_windows.pyx index 8d3894c39d5..25b9d1cc674 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvvm_windows.pyx +++ b/cuda_bindings/cuda/bindings/_internal/nvvm_windows.pyx @@ -4,6 +4,7 @@ # # This code was automatically generated across versions from 12.0.1 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=49ccc5908d39ebb526fee704591480550b5f780c05f14366531360e3ec2ac17a from libc.stdint cimport intptr_t import threading diff --git a/cuda_bindings/cuda/bindings/cudla.pxd b/cuda_bindings/cuda/bindings/cudla.pxd index 03190bf3e64..cb58d685a24 100644 --- a/cuda_bindings/cuda/bindings/cudla.pxd +++ b/cuda_bindings/cuda/bindings/cudla.pxd @@ -3,6 +3,7 @@ # This code was automatically generated across versions from 1.5.0 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=e64a78a1b3e010d167373d7c9635ff4637dfd1a6a38ffafb671dcde4e12aaaad from libc.stdint cimport intptr_t from .cycudla cimport * diff --git a/cuda_bindings/cuda/bindings/cudla.pyx b/cuda_bindings/cuda/bindings/cudla.pyx index 7955e71132b..ce92c2deef9 100644 --- a/cuda_bindings/cuda/bindings/cudla.pyx +++ b/cuda_bindings/cuda/bindings/cudla.pyx @@ -1,5 +1,6 @@ # SPDX-FileCopyrightText: Copyright (c) 2024-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: Apache-2.0 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=6e7ac86c22e602c08df8250f3b50c135945378aa8ae4ddb4e10174fd979c4aa5 # <<<< PREAMBLE CONTENT >>>> diff --git a/cuda_bindings/cuda/bindings/cufile.pxd b/cuda_bindings/cuda/bindings/cufile.pxd index d8f2feaad15..2bd8c7489ca 100644 --- a/cuda_bindings/cuda/bindings/cufile.pxd +++ b/cuda_bindings/cuda/bindings/cufile.pxd @@ -4,6 +4,7 @@ # # This code was automatically generated across versions from 12.9.1 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=232df43b5a8960f10286c172abc71222a3822087a1f6134e12d9341f3b53886c from libc.stdint cimport intptr_t from .cycufile cimport * diff --git a/cuda_bindings/cuda/bindings/cufile.pyx b/cuda_bindings/cuda/bindings/cufile.pyx index 0894d3754d9..b3b875d2018 100644 --- a/cuda_bindings/cuda/bindings/cufile.pyx +++ b/cuda_bindings/cuda/bindings/cufile.pyx @@ -3,6 +3,7 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.9.1 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=359f9b42f4f97b9a74570e1f7d20eb6f5faae2df194a6161f4d5a9512c3ffbe3 # <<<< PREAMBLE CONTENT >>>> diff --git a/cuda_bindings/cuda/bindings/cycudla.pxd b/cuda_bindings/cuda/bindings/cycudla.pxd index d81f58b0380..6eee248e7d5 100644 --- a/cuda_bindings/cuda/bindings/cycudla.pxd +++ b/cuda_bindings/cuda/bindings/cycudla.pxd @@ -4,6 +4,7 @@ # This code was automatically generated across versions from 1.5.0 to 13.3.0. Do not modify it directly. # This layer exposes the C header to Cython as-is. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=c4dacd5de0bc9a6ac0cc92dabed1728cc6133d0448924ea6db4f9c740ff089b6 from libc.stdint cimport int8_t, int16_t, int32_t, int64_t from libc.stdint cimport uint8_t, uint16_t, uint32_t, uint64_t from libc.stdint cimport intptr_t, uintptr_t diff --git a/cuda_bindings/cuda/bindings/cycudla.pyx b/cuda_bindings/cuda/bindings/cycudla.pyx index ef4ad78200b..42a7bd651c6 100644 --- a/cuda_bindings/cuda/bindings/cycudla.pyx +++ b/cuda_bindings/cuda/bindings/cycudla.pyx @@ -3,6 +3,7 @@ # This code was automatically generated across versions from 1.5.0 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=b134ed8cb83eb5a5c6ff30be817e64d09d421d7257761e58fbc06b131690a392 from ._internal cimport cudla as _cudla diff --git a/cuda_bindings/cuda/bindings/cycufile.pxd b/cuda_bindings/cuda/bindings/cycufile.pxd index 909870be9db..b5a0c9cb884 100644 --- a/cuda_bindings/cuda/bindings/cycufile.pxd +++ b/cuda_bindings/cuda/bindings/cycufile.pxd @@ -4,6 +4,7 @@ # # This code was automatically generated across versions from 12.9.1 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=f840820f160e36eebe6e052b5a5d3a35b55704060301ee2ab7d5cd7a7d580418 from libc.stdint cimport uint32_t, uint64_t from libc.time cimport time_t from libcpp cimport bool as cpp_bool diff --git a/cuda_bindings/cuda/bindings/cycufile.pyx b/cuda_bindings/cuda/bindings/cycufile.pyx index f5ad2d5e9f1..e457aa2c63b 100644 --- a/cuda_bindings/cuda/bindings/cycufile.pyx +++ b/cuda_bindings/cuda/bindings/cycufile.pyx @@ -4,6 +4,7 @@ # # This code was automatically generated across versions from 12.9.1 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=74f1f9c9443af66fdadbfeeb01e5c15c2d8f1b9b0b20eafa2a279583bcf7df00 from ._internal cimport cufile as _cufile import cython diff --git a/cuda_bindings/cuda/bindings/cydriver.pxd b/cuda_bindings/cuda/bindings/cydriver.pxd index f1962d0c1f0..090ac5417ef 100644 --- a/cuda_bindings/cuda/bindings/cydriver.pxd +++ b/cuda_bindings/cuda/bindings/cydriver.pxd @@ -4,6 +4,7 @@ # # This code was automatically generated across versions from 12.9.0 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=be542bd43838a355344b0cdedcf3496368dd3cf0ebdfeda22b5963f384f4d06d from libc.stdint cimport uint32_t, uint64_t diff --git a/cuda_bindings/cuda/bindings/cydriver.pyx b/cuda_bindings/cuda/bindings/cydriver.pyx index 4dbbab4449e..2ca1d97644e 100644 --- a/cuda_bindings/cuda/bindings/cydriver.pyx +++ b/cuda_bindings/cuda/bindings/cydriver.pyx @@ -4,6 +4,7 @@ # # This code was automatically generated across versions from 12.9.0 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=5b828e2ee0de9b245c71a6ba9361656ab10f7564caa7e3d9c162b2c6a07fb3df from ._internal cimport driver as _driver cdef CUresult cuGetErrorString(CUresult error, const char** pStr) except ?CUDA_ERROR_NOT_FOUND nogil: diff --git a/cuda_bindings/cuda/bindings/cynvfatbin.pxd b/cuda_bindings/cuda/bindings/cynvfatbin.pxd index d6550352a6f..ef8951fbcc3 100644 --- a/cuda_bindings/cuda/bindings/cynvfatbin.pxd +++ b/cuda_bindings/cuda/bindings/cynvfatbin.pxd @@ -4,6 +4,7 @@ # # This code was automatically generated across versions from 12.4.1 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=fede358631d711050e04c9b0f7582773ba7012844987bc47358f1378d484a136 from libc.stdint cimport intptr_t, uint32_t diff --git a/cuda_bindings/cuda/bindings/cynvfatbin.pyx b/cuda_bindings/cuda/bindings/cynvfatbin.pyx index 20e3b31d553..86bdd89f0f3 100644 --- a/cuda_bindings/cuda/bindings/cynvfatbin.pyx +++ b/cuda_bindings/cuda/bindings/cynvfatbin.pyx @@ -4,6 +4,7 @@ # # This code was automatically generated across versions from 12.4.1 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=bae30bbdaff2009b86c05de2a46bbaecad9e63327c93a10b6f2e8a2d95fd6a60 from ._internal cimport nvfatbin as _nvfatbin diff --git a/cuda_bindings/cuda/bindings/cynvjitlink.pxd b/cuda_bindings/cuda/bindings/cynvjitlink.pxd index 0098c055655..ff80a17c5ab 100644 --- a/cuda_bindings/cuda/bindings/cynvjitlink.pxd +++ b/cuda_bindings/cuda/bindings/cynvjitlink.pxd @@ -4,6 +4,7 @@ # # This code was automatically generated across versions from 12.0.1 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=58778b073e81f54fcf5c42775b45944d22b6e944fe6965b42d83898239f1e1b6 from libc.stdint cimport intptr_t, uint32_t diff --git a/cuda_bindings/cuda/bindings/cynvjitlink.pyx b/cuda_bindings/cuda/bindings/cynvjitlink.pyx index 8bdb0409a8b..cf4ee0332a0 100644 --- a/cuda_bindings/cuda/bindings/cynvjitlink.pyx +++ b/cuda_bindings/cuda/bindings/cynvjitlink.pyx @@ -4,6 +4,7 @@ # # This code was automatically generated across versions from 12.0.1 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=e507515291c3bc20b88d0b58ab5b01a1cc38c5d21bca87a4f379cc846b869ed4 from ._internal cimport nvjitlink as _nvjitlink diff --git a/cuda_bindings/cuda/bindings/cynvml.pxd b/cuda_bindings/cuda/bindings/cynvml.pxd index d48ad47c439..61ac3fa0da7 100644 --- a/cuda_bindings/cuda/bindings/cynvml.pxd +++ b/cuda_bindings/cuda/bindings/cynvml.pxd @@ -4,6 +4,7 @@ # # This code was automatically generated across versions from 12.9.1 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=5e55307c8ff89e076c29fc7c2a36bf0af7ecf3162693a4c94d7fca65454d6a9e from libc.stdint cimport int64_t diff --git a/cuda_bindings/cuda/bindings/cynvml.pyx b/cuda_bindings/cuda/bindings/cynvml.pyx index d664707eb77..612368c7736 100644 --- a/cuda_bindings/cuda/bindings/cynvml.pyx +++ b/cuda_bindings/cuda/bindings/cynvml.pyx @@ -4,6 +4,7 @@ # # This code was automatically generated across versions from 12.9.1 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=ec221879a459b2de9b3dfe54cba58613e9c08b279a95f782a450c98fd7cea532 from ._internal cimport nvml as _nvml diff --git a/cuda_bindings/cuda/bindings/cynvrtc.pxd b/cuda_bindings/cuda/bindings/cynvrtc.pxd index dd810928b63..0c0ec2f624d 100644 --- a/cuda_bindings/cuda/bindings/cynvrtc.pxd +++ b/cuda_bindings/cuda/bindings/cynvrtc.pxd @@ -4,6 +4,7 @@ # # This code was automatically generated across versions from 12.9.0 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=0da658de603326899002d26fdbea39e6f469626207e7b40435f7f24a7e5accf0 from libc.stdint cimport uint32_t, uint64_t diff --git a/cuda_bindings/cuda/bindings/cynvrtc.pyx b/cuda_bindings/cuda/bindings/cynvrtc.pyx index 180831ed437..6289a40092a 100644 --- a/cuda_bindings/cuda/bindings/cynvrtc.pyx +++ b/cuda_bindings/cuda/bindings/cynvrtc.pyx @@ -4,6 +4,7 @@ # # This code was automatically generated across versions from 12.9.0 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=9725757222bfc514253ab6a6113b4e6b1c33fab841fe2fff8ebb1012ecf7715b from ._internal cimport nvrtc as _nvrtc cdef const char* nvrtcGetErrorString(nvrtcResult result) except?NULL nogil: diff --git a/cuda_bindings/cuda/bindings/cynvvm.pxd b/cuda_bindings/cuda/bindings/cynvvm.pxd index 09a9b48bd36..f25e7e84b3b 100644 --- a/cuda_bindings/cuda/bindings/cynvvm.pxd +++ b/cuda_bindings/cuda/bindings/cynvvm.pxd @@ -10,6 +10,7 @@ ############################################################################### # enums +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=79be0fd21f7c6b6112743eb60ce9e69287a66999ecaaa063d87a52ab64982bce ctypedef enum nvvmResult "nvvmResult": NVVM_SUCCESS "NVVM_SUCCESS" = 0 NVVM_ERROR_OUT_OF_MEMORY "NVVM_ERROR_OUT_OF_MEMORY" = 1 diff --git a/cuda_bindings/cuda/bindings/cynvvm.pyx b/cuda_bindings/cuda/bindings/cynvvm.pyx index 1b4f48c1bd9..43f036a36c0 100644 --- a/cuda_bindings/cuda/bindings/cynvvm.pyx +++ b/cuda_bindings/cuda/bindings/cynvvm.pyx @@ -4,6 +4,7 @@ # # This code was automatically generated across versions from 12.0.1 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=7ea5803be62646c287bad43350e27d3254f35d25ab50b9c54f7ac5695b4c3114 from ._internal cimport nvvm as _nvvm diff --git a/cuda_bindings/cuda/bindings/cyruntime.pxd.in b/cuda_bindings/cuda/bindings/cyruntime.pxd.in index 5b3b67b60a3..952d5137f42 100644 --- a/cuda_bindings/cuda/bindings/cyruntime.pxd.in +++ b/cuda_bindings/cuda/bindings/cyruntime.pxd.in @@ -3,6 +3,7 @@ # This code was automatically generated with version 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=2d7f136277c2cc633450e22e7833a0cab63cdfc70e07719a2e46d3812cd11a2f from libc.stdint cimport uint32_t, uint64_t include "cyruntime_types.pxi" diff --git a/cuda_bindings/cuda/bindings/cyruntime.pyx.in b/cuda_bindings/cuda/bindings/cyruntime.pyx.in index 998f431fcfc..0d6e5c1b490 100644 --- a/cuda_bindings/cuda/bindings/cyruntime.pyx.in +++ b/cuda_bindings/cuda/bindings/cyruntime.pyx.in @@ -2,6 +2,7 @@ # SPDX-License-Identifier: Apache-2.0 # This code was automatically generated with version 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=8eaac6db08318ecc59f425f779f230fc18f12a64d077e6c9b3d0197725b747a4 cimport cuda.bindings._bindings.cyruntime as cyruntime cimport cython diff --git a/cuda_bindings/cuda/bindings/cyruntime_functions.pxi.in b/cuda_bindings/cuda/bindings/cyruntime_functions.pxi.in index 693ae78ec3b..69c75821056 100644 --- a/cuda_bindings/cuda/bindings/cyruntime_functions.pxi.in +++ b/cuda_bindings/cuda/bindings/cyruntime_functions.pxi.in @@ -2,6 +2,7 @@ # SPDX-License-Identifier: Apache-2.0 # This code was automatically generated with version 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=29630fb8d40658dc3ed853407f00b4618688984d4227aae877e2f32807fef519 cdef extern from "cuda_runtime_api.h": {{if 'cudaDeviceReset' in found_functions}} diff --git a/cuda_bindings/cuda/bindings/cyruntime_types.pxi.in b/cuda_bindings/cuda/bindings/cyruntime_types.pxi.in index 45cd39eb7e4..fa881e951dc 100644 --- a/cuda_bindings/cuda/bindings/cyruntime_types.pxi.in +++ b/cuda_bindings/cuda/bindings/cyruntime_types.pxi.in @@ -3,6 +3,7 @@ # This code was automatically generated with version 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=93953ce179542f5c6172446b305a7568ce2b5190b3bfba1f1c9da282c3b965f0 cdef extern from "vector_types.h": cdef struct dim3: diff --git a/cuda_bindings/cuda/bindings/driver.pxd b/cuda_bindings/cuda/bindings/driver.pxd index 1aaeefb00d6..9f4d912a3c4 100644 --- a/cuda_bindings/cuda/bindings/driver.pxd +++ b/cuda_bindings/cuda/bindings/driver.pxd @@ -2,6 +2,7 @@ # SPDX-License-Identifier: Apache-2.0 # This code was automatically generated with version 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=f4b08b7f4b26966f9f462562819700500a100748c5b34ab47de79836e6bec3f2 cimport cuda.bindings.cydriver as cydriver include "_lib/utils.pxd" diff --git a/cuda_bindings/cuda/bindings/driver.pyx b/cuda_bindings/cuda/bindings/driver.pyx index a56dde69b7e..44b7c4c567c 100644 --- a/cuda_bindings/cuda/bindings/driver.pyx +++ b/cuda_bindings/cuda/bindings/driver.pyx @@ -2,6 +2,7 @@ # SPDX-License-Identifier: Apache-2.0 # This code was automatically generated with version 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=4a70be46627269cff03a2b89504463158d6e50d738cfde91e8c3ed1bf88fd9e0 from typing import Any, Optional import cython import ctypes diff --git a/cuda_bindings/cuda/bindings/nvfatbin.pxd b/cuda_bindings/cuda/bindings/nvfatbin.pxd index 6be36a6ecd0..facc2dfeeb4 100644 --- a/cuda_bindings/cuda/bindings/nvfatbin.pxd +++ b/cuda_bindings/cuda/bindings/nvfatbin.pxd @@ -4,6 +4,7 @@ # # This code was automatically generated across versions from 12.4.1 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=c9d5a4b06ca92f766674f286b75dfc83dff952b5987eb88cdb2773bb28f1ea6a from libc.stdint cimport intptr_t, uint32_t from .cynvfatbin cimport * diff --git a/cuda_bindings/cuda/bindings/nvfatbin.pyx b/cuda_bindings/cuda/bindings/nvfatbin.pyx index 11178f79c5a..f1bdb927a5f 100644 --- a/cuda_bindings/cuda/bindings/nvfatbin.pyx +++ b/cuda_bindings/cuda/bindings/nvfatbin.pyx @@ -3,6 +3,7 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.4.1 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=d5a4eb978220598892471233ffd8b7caa8cee7b6b0c27d2d9c458f1d91979f8b # <<<< PREAMBLE CONTENT >>>> diff --git a/cuda_bindings/cuda/bindings/nvjitlink.pxd b/cuda_bindings/cuda/bindings/nvjitlink.pxd index 0958496df47..ac697049088 100644 --- a/cuda_bindings/cuda/bindings/nvjitlink.pxd +++ b/cuda_bindings/cuda/bindings/nvjitlink.pxd @@ -4,6 +4,7 @@ # # This code was automatically generated across versions from 12.0.1 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=b847666247321f33f1f6b4c5fa92d6ee5d1022389e32eceb03c7458c45ff44ed from libc.stdint cimport intptr_t, uint32_t from .cynvjitlink cimport * diff --git a/cuda_bindings/cuda/bindings/nvjitlink.pyx b/cuda_bindings/cuda/bindings/nvjitlink.pyx index 718ede05d78..89dea49e4ad 100644 --- a/cuda_bindings/cuda/bindings/nvjitlink.pyx +++ b/cuda_bindings/cuda/bindings/nvjitlink.pyx @@ -3,6 +3,7 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.0.1 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=18cc1af125a513c3867c6f2bd8e97f4b0b2d2e58565a8980223a419ae5f23b74 # <<<< PREAMBLE CONTENT >>>> diff --git a/cuda_bindings/cuda/bindings/nvml.pxd b/cuda_bindings/cuda/bindings/nvml.pxd index 85c57c8c4b4..acc9900f069 100644 --- a/cuda_bindings/cuda/bindings/nvml.pxd +++ b/cuda_bindings/cuda/bindings/nvml.pxd @@ -4,6 +4,7 @@ # # This code was automatically generated across versions from 12.9.1 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=eb901f46ca6b6930935726541c32b3ea04f7f46b6090c4c2ad9cb62386c2028b from libc.stdint cimport intptr_t from .cynvml cimport * diff --git a/cuda_bindings/cuda/bindings/nvml.pyx b/cuda_bindings/cuda/bindings/nvml.pyx index ded83bdaba6..26b63f1f6a7 100644 --- a/cuda_bindings/cuda/bindings/nvml.pyx +++ b/cuda_bindings/cuda/bindings/nvml.pyx @@ -3,6 +3,7 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.9.1 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=52642c2c289dbd93191f019468630c0c7935bf99bc15c9c7c0de3797a109e8b0 # <<<< PREAMBLE CONTENT >>>> diff --git a/cuda_bindings/cuda/bindings/nvrtc.pxd b/cuda_bindings/cuda/bindings/nvrtc.pxd index fc19329aa1c..a17faea0763 100644 --- a/cuda_bindings/cuda/bindings/nvrtc.pxd +++ b/cuda_bindings/cuda/bindings/nvrtc.pxd @@ -2,6 +2,7 @@ # SPDX-License-Identifier: Apache-2.0 # This code was automatically generated with version 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=06a058e3c626563f034714cce129fd58b33dd80c0e4a954723e92d0ae61c7c58 cimport cuda.bindings.cynvrtc as cynvrtc include "_lib/utils.pxd" diff --git a/cuda_bindings/cuda/bindings/nvrtc.pyx b/cuda_bindings/cuda/bindings/nvrtc.pyx index e4314f832cd..d963b48f791 100644 --- a/cuda_bindings/cuda/bindings/nvrtc.pyx +++ b/cuda_bindings/cuda/bindings/nvrtc.pyx @@ -2,6 +2,7 @@ # SPDX-License-Identifier: Apache-2.0 # This code was automatically generated with version 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=ac1af34ecd1468ac91074ce7f18423af19fbc7727653cdfc1cd9b6f33f6cec72 from typing import Any, Optional import cython import ctypes diff --git a/cuda_bindings/cuda/bindings/nvvm.pxd b/cuda_bindings/cuda/bindings/nvvm.pxd index 1844ea1e7a7..cb97bd48714 100644 --- a/cuda_bindings/cuda/bindings/nvvm.pxd +++ b/cuda_bindings/cuda/bindings/nvvm.pxd @@ -4,6 +4,7 @@ # # This code was automatically generated across versions from 12.0.1 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=b4e10f31d2308a47fccfc9401d4f179bf61d389c1eb1491e8f9b00bf37a14ea9 from libc.stdint cimport intptr_t from .cynvvm cimport * diff --git a/cuda_bindings/cuda/bindings/nvvm.pyx b/cuda_bindings/cuda/bindings/nvvm.pyx index 8ead1e19998..eec2fd8556a 100644 --- a/cuda_bindings/cuda/bindings/nvvm.pyx +++ b/cuda_bindings/cuda/bindings/nvvm.pyx @@ -3,6 +3,7 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.0.1 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=663773bbe4ae03ad1e170d44b06d5a924b5e4a3a0bd901c2f276976b82943bcb # <<<< PREAMBLE CONTENT >>>> diff --git a/cuda_bindings/cuda/bindings/runtime.pxd.in b/cuda_bindings/cuda/bindings/runtime.pxd.in index 4be280ac200..7881587683b 100644 --- a/cuda_bindings/cuda/bindings/runtime.pxd.in +++ b/cuda_bindings/cuda/bindings/runtime.pxd.in @@ -2,6 +2,7 @@ # SPDX-License-Identifier: Apache-2.0 # This code was automatically generated with version 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=532f673750b6344c789f7947449c1d99e3587792ba3b110e9dcc36396decbb67 cimport cuda.bindings.cyruntime as cyruntime include "_lib/utils.pxd" diff --git a/cuda_bindings/cuda/bindings/runtime.pyx.in b/cuda_bindings/cuda/bindings/runtime.pyx.in index 709dabc5ff3..a2cb9ed6b39 100644 --- a/cuda_bindings/cuda/bindings/runtime.pyx.in +++ b/cuda_bindings/cuda/bindings/runtime.pyx.in @@ -2,6 +2,7 @@ # SPDX-License-Identifier: Apache-2.0 # This code was automatically generated with version 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=6fe2ed828d10a452e3b9a6c2b27e9f606eb6aec3dae2613d0a6eae475c7744a2 from typing import Any, Optional import cython import ctypes diff --git a/cuda_bindings/docs/source/module/driver.rst b/cuda_bindings/docs/source/module/driver.rst index 4f3df8fbf38..8d9490f54a7 100644 --- a/cuda_bindings/docs/source/module/driver.rst +++ b/cuda_bindings/docs/source/module/driver.rst @@ -1,6 +1,7 @@ .. SPDX-FileCopyrightText: Copyright (c) 2021-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. .. SPDX-License-Identifier: Apache-2.0 +.. CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=15f77ea651a2deffa7f7ae710189546cff9c23ba311b693207743eaf339a0a9c ------ driver ------ diff --git a/cuda_bindings/docs/source/module/nvrtc.rst b/cuda_bindings/docs/source/module/nvrtc.rst index 0432493d47f..c879f49dc88 100644 --- a/cuda_bindings/docs/source/module/nvrtc.rst +++ b/cuda_bindings/docs/source/module/nvrtc.rst @@ -1,6 +1,7 @@ .. SPDX-FileCopyrightText: Copyright (c) 2021-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. .. SPDX-License-Identifier: Apache-2.0 +.. CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=9f44170e12fd85fa04fcd599a18d0b6474ec7920be8f28a5c097000eb3ccb0e0 ----- nvrtc ----- diff --git a/cuda_bindings/docs/source/module/runtime.rst b/cuda_bindings/docs/source/module/runtime.rst index 3e86a79e267..80b11f16644 100644 --- a/cuda_bindings/docs/source/module/runtime.rst +++ b/cuda_bindings/docs/source/module/runtime.rst @@ -1,6 +1,7 @@ .. SPDX-FileCopyrightText: Copyright (c) 2021-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. .. SPDX-License-Identifier: Apache-2.0 +.. CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=0eccd5db44f7406acb693f5dd95ad2fa17c787c11659578cf54e116eb0b06e01 ------- runtime ------- diff --git a/cuda_core/tests/test_binaries/build_test_binaries.sh b/cuda_core/tests/test_binaries/build_test_binaries.sh index 22c21585755..077dd8e90cb 100755 --- a/cuda_core/tests/test_binaries/build_test_binaries.sh +++ b/cuda_core/tests/test_binaries/build_test_binaries.sh @@ -20,9 +20,9 @@ NVCC="${NVCC:-nvcc}" -o "${SCRIPTPATH}/saxpy.o" "${SCRIPTPATH}/saxpy.cu" if [[ "${OS:-}" == "Windows_NT" ]]; then - nvcc -lib -o "${SCRIPTPATH}/saxpy.lib" "${SCRIPTPATH}/saxpy.o" + "${NVCC}" -lib -o "${SCRIPTPATH}/saxpy.lib" "${SCRIPTPATH}/saxpy.o" ls -lah "${SCRIPTPATH}/saxpy.o" "${SCRIPTPATH}/saxpy.lib" else - nvcc -lib -o "${SCRIPTPATH}/saxpy.a" "${SCRIPTPATH}/saxpy.o" + "${NVCC}" -lib -o "${SCRIPTPATH}/saxpy.a" "${SCRIPTPATH}/saxpy.o" ls -lah "${SCRIPTPATH}/saxpy.o" "${SCRIPTPATH}/saxpy.a" fi diff --git a/toolshed/check_generated_file_seals.py b/toolshed/check_generated_file_seals.py new file mode 100644 index 00000000000..1a9c45de61b --- /dev/null +++ b/toolshed/check_generated_file_seals.py @@ -0,0 +1,153 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 + +import hashlib +import os +import re +import subprocess +import sys +from pathlib import Path, PureWindowsPath + +# Intentionally assemble these markers so git grep finds only generated files, +# not the checker that validates them. +GENERATED_FILE_MARKER_FRAGMENT = "-" + "-".join(("GENERATED", "DO", "NOT", "MODIFY", "THIS", "FILE")) +GENERATED_FILE_SEAL_TOKEN = "-".join(("CYTHON", "BINDINGS")) + GENERATED_FILE_MARKER_FRAGMENT + ":" +SUPPORTED_GENERATED_FILE_SEAL_FORMATS = frozenset({1}) + +assert GENERATED_FILE_MARKER_FRAGMENT in GENERATED_FILE_SEAL_TOKEN +_TOKEN_BYTES = GENERATED_FILE_SEAL_TOKEN.encode("ascii") +_MARKER_REGEX = re.compile( + rb"^(?P#|\.\.) " + + re.escape(_TOKEN_BYTES) + + rb" format=(?P[0-9]+); content-sha256=(?P[0-9a-f]{64})\n$" +) +_COMMENT_CHARS = { + ".py": b"#", + ".pxd": b"#", + ".pxi": b"#", + ".pyx": b"#", + ".pyx.in": b"#", + ".pxd.in": b"#", + ".pxi.in": b"#", + ".rst": b"..", + ".c": b"//", + ".cpp": b"//", + ".h": b"//", +} + + +def normalize_repo_path(filepath): + return PureWindowsPath(filepath).as_posix() + + +def expected_comment_prefix(filepath): + normalized_path = normalize_repo_path(filepath) + for suffix, comment_char in _COMMENT_CHARS.items(): + if normalized_path.endswith(suffix): + return comment_char + return None + + +def load_previously_sealed_paths(): + process = subprocess.run( # noqa: S603 + [ # noqa: S607 + "git", + "grep", + "-l", + "-I", + "-F", + "-e", + GENERATED_FILE_MARKER_FRAGMENT, + "HEAD", + "--", + "cuda_bindings", + ], + capture_output=True, + text=True, + ) + if process.returncode not in (0, 1): + detail = process.stderr.strip() or f"git grep exited with status {process.returncode}" + raise RuntimeError(f"could not inspect previously sealed files: {detail}") + + head_prefix = "HEAD:" + return { + normalize_repo_path(line.removeprefix(head_prefix)) + for line in process.stdout.splitlines() + if line.startswith(head_prefix) + } + + +def validate_generated_file_seal(filepath, previously_sealed_paths): + normalized_path = normalize_repo_path(filepath) + try: + blob = Path(filepath).read_bytes() + except OSError as error: + print(f"ERROR reading {filepath!r}: {error}") + return False + + lines = blob.splitlines(keepends=True) + marker_indexes = [index for index, line in enumerate(lines) if _TOKEN_BYTES in line] + + if not marker_indexes: + if normalized_path in previously_sealed_paths: + print(f"MISSING generated-file seal in {filepath!r}") + return False + return True + + if len(marker_indexes) != 1: + print(f"INVALID generated-file seal count in {filepath!r}: found {len(marker_indexes)}, expected 1") + return False + + marker_index = marker_indexes[0] + match = _MARKER_REGEX.fullmatch(lines[marker_index]) + if match is None: + print(f"MALFORMED generated-file seal in {filepath!r}") + return False + + seal_format = int(match.group("format")) + if seal_format not in SUPPORTED_GENERATED_FILE_SEAL_FORMATS: + print(f"UNSUPPORTED generated-file seal format {seal_format} in {filepath!r}") + return False + + expected_prefix = expected_comment_prefix(filepath) + if expected_prefix is None: + print(f"UNSUPPORTED sealed generated-file extension in {filepath!r}") + return False + if match.group("prefix") != expected_prefix: + print(f"INVALID generated-file seal comment prefix in {filepath!r}") + return False + + unsealed_blob = b"".join(lines[:marker_index] + lines[marker_index + 1 :]) + computed_digest = hashlib.sha256(unsealed_blob).hexdigest().encode("ascii") + recorded_digest = match.group("digest") + if recorded_digest != computed_digest: + print(f"Manual changes detected in {filepath!r}. It is a generated file and should not be edited directly.") + print( + f"Recorded content SHA-256: {recorded_digest.decode()}\n" + f"Computed content SHA-256: {computed_digest.decode()}" + ) + return False + + return True + + +def main(args): + assert args, "filepaths expected to be passed from pre-commit" + + try: + previously_sealed_paths = load_previously_sealed_paths() + except RuntimeError as error: + print(f"ERROR: {error}") + return 2 + + returncode = 0 + for filepath in args: + if not os.path.isfile(filepath): + continue + if not validate_generated_file_seal(filepath, previously_sealed_paths): + returncode = 1 + return returncode + + +if __name__ == "__main__": + sys.exit(main(sys.argv[1:])) From 52e6eddff35fd3953882bcd67ff07b8fa2304107 Mon Sep 17 00:00:00 2001 From: "Ralf W. Grosse-Kunstleve" Date: Wed, 8 Jul 2026 16:00:49 -0700 Subject: [PATCH 09/25] Refresh generated cuDLA Windows bindings (#2328) --- cuda_bindings/cuda/bindings/_internal/cudla_windows.pyx | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/cuda_bindings/cuda/bindings/_internal/cudla_windows.pyx b/cuda_bindings/cuda/bindings/_internal/cudla_windows.pyx index 7dad671bb67..9a5313639e4 100644 --- a/cuda_bindings/cuda/bindings/_internal/cudla_windows.pyx +++ b/cuda_bindings/cuda/bindings/_internal/cudla_windows.pyx @@ -1,8 +1,9 @@ # SPDX-FileCopyrightText: Copyright (c) 2024-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: Apache-2.0 -# This code was automatically generated across versions from 1.5.0 to 13.3.0, generator version 0.3.1.dev1465+gc5c5c8652. Do not modify it directly. +# This code was automatically generated across versions from 1.5.0 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=43403925d332dc0474938eb5f6b5d58c648884b9f056c1b319a515281b36757e from libc.stdint cimport intptr_t import threading From daf4a3c4b9cf79c378ee3ea5a47904261f62468b Mon Sep 17 00:00:00 2001 From: "Ralf W. Grosse-Kunstleve" Date: Wed, 8 Jul 2026 16:04:48 -0700 Subject: [PATCH 10/25] CI: remove restricted paths guard (#2297) --- .github/workflows/restricted-paths-guard.yml | 326 ------------------- 1 file changed, 326 deletions(-) delete mode 100644 .github/workflows/restricted-paths-guard.yml diff --git a/.github/workflows/restricted-paths-guard.yml b/.github/workflows/restricted-paths-guard.yml deleted file mode 100644 index e559c89136c..00000000000 --- a/.github/workflows/restricted-paths-guard.yml +++ /dev/null @@ -1,326 +0,0 @@ -# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-License-Identifier: Apache-2.0 - -name: "CI: Restricted Paths Guard" - -on: - # Run on drafts too so maintainers get early awareness on WIP PRs. - # Label updates on fork PRs require pull_request_target permissions. - pull_request_target: - types: - - opened - - synchronize - - reopened - - ready_for_review - -jobs: - restricted-paths-guard: - name: Apply review label if needed - if: github.repository_owner == 'NVIDIA' - runs-on: ubuntu-latest - permissions: - contents: write # needed for collaborator permission check - pull-requests: write - steps: - - name: Inspect PR author signals for restricted paths - env: - # PR metadata inputs (the event payload's author_association can be - # stale for fork PRs, so restricted-path PRs query the live PR API). - PR_AUTHOR: ${{ github.event.pull_request.user.login }} - PR_NUMBER: ${{ github.event.pull_request.number }} - PR_URL: ${{ github.event.pull_request.html_url }} - RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }} - - # Workflow policy inputs - REVIEW_LABEL: Needs-Restricted-Paths-Review - # Temporary testing recipe for agents: - # 1. Change pull_request_target to pull_request. - # 2. Set DRY_RUN_REVIEW_LABEL_WRITES to true. - # 3. Add a dummy comment or whitespace-only change in - # cuda_bindings/README.md to trigger restricted-path detection - # without affecting build/package behavior. - # 4. Replace both trusted case patterns below with DRY_RUN_NEVER_MATCH - # so the test does not depend on the tester's GitHub identity: - # MEMBER|OWNER and admin|maintain|write|triage. - # 5. Commit these changes as a temporary dry-run test commit and revert - # that commit before merge. - DRY_RUN_REVIEW_LABEL_WRITES: false - - # API request context/auth - GH_TOKEN: ${{ github.token }} - REPO: ${{ github.repository }} - run: | - set -euo pipefail - - COLLABORATOR_PERMISSION="not checked" - COLLABORATOR_PERMISSION_API_ERROR="" - AUTHOR_ASSOCIATION="not checked" - AUTHOR_ASSOCIATION_API_ERROR="" - - if ! MATCHING_RESTRICTED_PATHS=$( - gh api \ - --paginate \ - --jq ' - .[] - | select( - (.filename | startswith("cuda_bindings/")) - or ((.previous_filename // "") | startswith("cuda_bindings/")) - or (.filename | startswith("cuda_python/")) - or ((.previous_filename // "") | startswith("cuda_python/")) - ) - | if (.previous_filename // "") != "" then - "\(.previous_filename) -> \(.filename)" - else - .filename - end - ' \ - "repos/$REPO/pulls/$PR_NUMBER/files" - ); then - echo "::error::Failed to inspect the PR file list." - { - echo "## Restricted Paths Guard Failed" - echo "" - echo "- **Error**: Failed to inspect the PR file list." - echo "- **Author**: $PR_AUTHOR" - echo "- **Author association**: $AUTHOR_ASSOCIATION" - echo "- **Collaborator permission**: $COLLABORATOR_PERMISSION" - echo "" - echo "Please update the PR at: $PR_URL" - } >> "$GITHUB_STEP_SUMMARY" - exit 1 - fi - - # Fetch live PR labels to avoid stale event payload (race condition - # when labels are changed shortly before the workflow runs). - if ! LIVE_LABELS=$( - gh pr view "${PR_NUMBER}" --repo "${REPO}" \ - --json labels \ - --jq '[.labels[].name]' - ); then - echo "::error::Failed to inspect the current PR labels." - { - echo "## Restricted Paths Guard Failed" - echo "" - echo "- **Error**: Failed to inspect the current PR labels." - echo "- **Author**: $PR_AUTHOR" - echo "- **Author association**: $AUTHOR_ASSOCIATION" - echo "- **Collaborator permission**: $COLLABORATOR_PERMISSION" - echo "" - echo "Please update the PR at: $PR_URL" - } >> "$GITHUB_STEP_SUMMARY" - exit 1 - fi - - TOUCHES_RESTRICTED_PATHS=false - if [ -n "$MATCHING_RESTRICTED_PATHS" ]; then - TOUCHES_RESTRICTED_PATHS=true - fi - - write_matching_restricted_paths() { - echo "- **Matched restricted paths**:" - echo '```text' - printf '%s\n' "$MATCHING_RESTRICTED_PATHS" - echo '```' - } - - write_collaborator_permission_api_error() { - echo "- **Collaborator permission API error**:" - echo '```text' - printf '%s\n' "$COLLABORATOR_PERMISSION_API_ERROR" - echo '```' - } - - write_author_association_api_error() { - echo "- **Author association API error**:" - echo '```text' - printf '%s\n' "$AUTHOR_ASSOCIATION_API_ERROR" - echo '```' - } - - build_review_label_comment() { - printf '%s\n\n%s\n\n%s\n\n%s\n\n%s\n' \ - "\`$REVIEW_LABEL\` was assigned by \`CI: Restricted Paths Guard\`." \ - "For details, open [this workflow run]($RUN_URL) and click **Summary**." \ - "For external contributors: thank you for your interest in improving CUDA Python. The \`cuda_bindings/\` package is distributed under the [NVIDIA Software License](https://github.com/NVIDIA/cuda-python/blob/main/cuda_bindings/LICENSE), which does not allow us to accept external contributions to files under \`cuda_bindings/\` in this repository." \ - "Please close this PR. If your changes also include updates outside \`cuda_bindings/\`, please open a new PR containing only those changes so we can review them separately under the applicable license." \ - "If you are an NVIDIA employee and believe this label was applied in error, no action is needed; a maintainer will review and remove the label if appropriate." - } - - write_review_label_comment_dry_run() { - echo "- **Dry-run comment body**:" - echo '```markdown' - build_review_label_comment - echo '```' - } - - post_review_label_comment() { - local comment_body - comment_body=$(build_review_label_comment) - - if gh api "repos/$REPO/issues/$PR_NUMBER/comments" \ - -f body="$comment_body" >/dev/null; then - COMMENT_ACTION="posted" - else - COMMENT_ACTION="failed (non-fatal)" - echo "::warning::Failed to post PR comment about newly added $REVIEW_LABEL." - fi - } - - HAS_TRUSTED_SIGNAL=false - LABEL_ACTION="not needed (no restricted paths)" - TRUSTED_SIGNALS="(none)" - COMMENT_ACTION="not needed" - - if [ "$TOUCHES_RESTRICTED_PATHS" = "true" ]; then - if AUTHOR_ASSOCIATION_RESPONSE=$( - gh api "repos/$REPO/pulls/$PR_NUMBER" \ - --jq '.author_association // "NONE"' 2>&1 - ); then - AUTHOR_ASSOCIATION="$AUTHOR_ASSOCIATION_RESPONSE" - else - AUTHOR_ASSOCIATION="unknown" - AUTHOR_ASSOCIATION_API_ERROR="$AUTHOR_ASSOCIATION_RESPONSE" - echo "::error::Failed to inspect live author association for PR #$PR_NUMBER." - { - echo "## Restricted Paths Guard Failed" - echo "" - echo "- **Error**: Failed to inspect live author association." - echo "- **Author**: $PR_AUTHOR" - echo "- **Author association**: $AUTHOR_ASSOCIATION" - echo "" - write_matching_restricted_paths - echo "" - write_author_association_api_error - echo "" - echo "Please retry this workflow. If the failure persists, inspect the author association API error above." - } >> "$GITHUB_STEP_SUMMARY" - exit 1 - fi - - case "$AUTHOR_ASSOCIATION" in - MEMBER|OWNER) - HAS_TRUSTED_SIGNAL=true - LABEL_ACTION="not needed (live author association is a trusted signal)" - TRUSTED_SIGNALS="author_association:$AUTHOR_ASSOCIATION" - ;; - *) - # COLLABORATOR can still be too broad for this policy; use the - # collaborator permission API below for repo-level trust. - ;; - esac - - # Distinguish a legitimate 404 "not a collaborator" response from - # actual API failures. The former is an expected untrusted case; - # the latter fails the workflow so it can be rerun later. - if [ "$HAS_TRUSTED_SIGNAL" = "false" ]; then - if COLLABORATOR_PERMISSION_RESPONSE=$( - gh api "repos/$REPO/collaborators/$PR_AUTHOR/permission" \ - --jq '.permission' 2>&1 - ); then - COLLABORATOR_PERMISSION="$COLLABORATOR_PERMISSION_RESPONSE" - elif [[ "$COLLABORATOR_PERMISSION_RESPONSE" == *"(HTTP 404)"* ]]; then - COLLABORATOR_PERMISSION="none" - else - COLLABORATOR_PERMISSION="unknown" - COLLABORATOR_PERMISSION_API_ERROR="$COLLABORATOR_PERMISSION_RESPONSE" - echo "::error::Failed to inspect collaborator permission for $PR_AUTHOR." - { - echo "## Restricted Paths Guard Failed" - echo "" - echo "- **Error**: Failed to inspect collaborator permission." - echo "- **Author**: $PR_AUTHOR" - echo "- **Author association**: $AUTHOR_ASSOCIATION" - echo "- **Collaborator permission**: $COLLABORATOR_PERMISSION" - echo "" - write_matching_restricted_paths - echo "" - write_collaborator_permission_api_error - echo "" - echo "Please retry this workflow. If the failure persists, inspect the collaborator permission API error above." - } >> "$GITHUB_STEP_SUMMARY" - exit 1 - fi - - case "$COLLABORATOR_PERMISSION" in - admin|maintain|write|triage) - HAS_TRUSTED_SIGNAL=true - LABEL_ACTION="not needed (collaborator permission is a trusted signal)" - TRUSTED_SIGNALS="collaborator_permission:$COLLABORATOR_PERMISSION" - ;; - *) - # read or none: not a trusted signal. In a public repo, read - # can be the effective permission for any GitHub user. - ;; - esac - fi - fi - - NEEDS_REVIEW_LABEL=false - if [ "$TOUCHES_RESTRICTED_PATHS" = "true" ] && [ "$HAS_TRUSTED_SIGNAL" = "false" ]; then - NEEDS_REVIEW_LABEL=true - fi - - LABEL_ALREADY_PRESENT=false - if jq -e --arg label "$REVIEW_LABEL" '.[] == $label' <<<"$LIVE_LABELS" >/dev/null; then - LABEL_ALREADY_PRESENT=true - fi - - if [ "$NEEDS_REVIEW_LABEL" = "true" ]; then - if [ "$LABEL_ALREADY_PRESENT" = "true" ]; then - LABEL_ACTION="already present" - elif [ "$DRY_RUN_REVIEW_LABEL_WRITES" = "true" ]; then - LABEL_ACTION="would add (dry run)" - COMMENT_ACTION="would post (dry run)" - { - echo "## Restricted Paths Guard Dry Run" - echo "" - echo "- **Would add label**: \`$REVIEW_LABEL\`" - echo "" - write_review_label_comment_dry_run - } >> "$GITHUB_STEP_SUMMARY" - elif ! gh pr edit "$PR_NUMBER" --repo "$REPO" --add-label "$REVIEW_LABEL"; then - echo "::error::Failed to add the $REVIEW_LABEL label." - { - echo "## Restricted Paths Guard Failed" - echo "" - echo "- **Error**: Failed to add the \`$REVIEW_LABEL\` label." - echo "- **Author**: $PR_AUTHOR" - echo "- **Author association**: $AUTHOR_ASSOCIATION" - echo "- **Collaborator permission**: $COLLABORATOR_PERMISSION" - echo "" - write_matching_restricted_paths - echo "" - echo "Please update the PR at: $PR_URL" - } >> "$GITHUB_STEP_SUMMARY" - exit 1 - else - LABEL_ACTION="added" - post_review_label_comment - fi - elif [ "$LABEL_ALREADY_PRESENT" = "true" ]; then - LABEL_ACTION="left in place (manual removal required)" - fi - - { - echo "## Restricted Paths Guard Completed" - echo "" - echo "- **Author**: $PR_AUTHOR" - echo "- **Author association**: $AUTHOR_ASSOCIATION" - echo "- **Collaborator permission**: $COLLABORATOR_PERMISSION" - echo "- **Touches restricted paths**: $TOUCHES_RESTRICTED_PATHS" - echo "- **Restricted paths**: \`cuda_bindings/\`, \`cuda_python/\`" - echo "- **Trusted signals**: $TRUSTED_SIGNALS" - echo "- **Label action**: $LABEL_ACTION" - echo "- **Comment action**: $COMMENT_ACTION" - if [ "$TOUCHES_RESTRICTED_PATHS" = "true" ]; then - echo "" - write_matching_restricted_paths - fi - if [ "$NEEDS_REVIEW_LABEL" = "true" ]; then - echo "" - echo "- **Manual follow-up**: No trusted signal was found, so \`$REVIEW_LABEL\` is required." - elif [ "$LABEL_ALREADY_PRESENT" = "true" ]; then - echo "" - echo "- **Manual follow-up**: Existing \`$REVIEW_LABEL\` was left in place intentionally because this workflow does not inspect every commit. Remove it manually after reviewing the PR for restricted-paths policy compliance." - fi - } >> "$GITHUB_STEP_SUMMARY" From c08caa884f2ddd2876b2036921d25114b66b3999 Mon Sep 17 00:00:00 2001 From: Leo Fang Date: Wed, 8 Jul 2026 17:47:18 -0700 Subject: [PATCH 11/25] cuda.core: expose wqConcurrencyLimit on WorkqueueResource (#2329) * cuda.core: expose wqConcurrencyLimit on WorkqueueResource Add concurrency_limit to WorkqueueResourceOptions so callers can hint the expected maximum stream-ordered concurrency to the driver, and add a read-only WorkqueueResource.concurrency_limit property mirroring the driver-populated value. Also fix the sharing_scope-only early return in configure() so setting concurrency_limit alone isn't silently dropped. * cuda.core: move WorkqueueResourceOptions validation to __post_init__ Fail-fast at construction rather than deferring both `sharing_scope` and `concurrency_limit` validation to `configure()`. This surfaces bad options immediately (and on any build, not just CUDA 13.x) and keeps the invariant colocated with the field it protects. Also add a 1.1.0 release-notes entry for the new field/property. * cuda.core: trim 1.1.0 release notes entry for concurrency_limit * cuda.core tests: configure workqueue in test_with_workqueue_resource Exercise sharing_scope + concurrency_limit end-to-end through green ctx creation and kernel launch, not just the property round-trip. * cuda.core: apply ruff-format + regenerate .pyi stubs * cuda.core: drop WorkqueueResource.concurrency_limit property Keep the surface symmetric with sharing_scope: configure() is the only way to set concurrency_limit, and there is no query-side property. The end-to-end verification lives in test_with_workqueue_resource, which now exercises a configured workqueue through green ctx creation and a kernel launch. --- cuda_core/cuda/core/_device_resources.pyi | 13 +++++++- cuda_core/cuda/core/_device_resources.pyx | 32 +++++++++++++++---- cuda_core/docs/source/release/1.1.0-notes.rst | 4 +++ cuda_core/tests/test_green_context.py | 31 ++++++++++++++++-- 4 files changed, 69 insertions(+), 11 deletions(-) diff --git a/cuda_core/cuda/core/_device_resources.pyi b/cuda_core/cuda/core/_device_resources.pyi index 1544d71b28c..8ae6fb6b326 100644 --- a/cuda_core/cuda/core/_device_resources.pyi +++ b/cuda_core/cuda/core/_device_resources.pyi @@ -47,8 +47,19 @@ class WorkqueueResourceOptions: sharing_scope : str, optional Workqueue sharing scope. Accepted values: ``"device_ctx"`` or ``"green_ctx_balanced"``. (Default to ``None``) + concurrency_limit : int, optional + Expected maximum number of concurrent stream-ordered + workloads. Must be ``>= 1`` when set. The effective + driver-side cap is ``CUDA_DEVICE_MAX_CONNECTIONS`` + (typically ``[1, 32]``); configurations may exceed + this cap, but the driver will not guarantee that work + submission remains non-overlapping. (Default to ``None``) """ sharing_scope: str | None = None + concurrency_limit: int | None = None + + def __post_init__(self): + ... class SMResource: """Represent an SM (streaming multiprocessor) resource partition. @@ -120,7 +131,7 @@ class WorkqueueResource: Parameters ---------- options : :obj:`WorkqueueResourceOptions` - Configuration options (sharing scope, etc.). + Configuration options (sharing scope, concurrency limit). """ class DeviceResources: diff --git a/cuda_core/cuda/core/_device_resources.pyx b/cuda_core/cuda/core/_device_resources.pyx index bafc462c936..1e1f016f6cc 100644 --- a/cuda_core/cuda/core/_device_resources.pyx +++ b/cuda_core/cuda/core/_device_resources.pyx @@ -129,9 +129,28 @@ cdef class WorkqueueResourceOptions: sharing_scope : str, optional Workqueue sharing scope. Accepted values: ``"device_ctx"`` or ``"green_ctx_balanced"``. (Default to ``None``) + concurrency_limit : int, optional + Expected maximum number of concurrent stream-ordered + workloads. Must be ``>= 1`` when set. The effective + driver-side cap is ``CUDA_DEVICE_MAX_CONNECTIONS`` + (typically ``[1, 32]``); configurations may exceed + this cap, but the driver will not guarantee that work + submission remains non-overlapping. (Default to ``None``) """ sharing_scope: str | None = None + concurrency_limit: int | None = None + + def __post_init__(self): + if self.sharing_scope not in (None, "device_ctx", "green_ctx_balanced"): + raise ValueError( + f"Unknown sharing_scope: {self.sharing_scope!r}. " + "Expected 'device_ctx' or 'green_ctx_balanced'." + ) + if self.concurrency_limit is not None and self.concurrency_limit < 1: + raise ValueError( + f"concurrency_limit must be >= 1, got {self.concurrency_limit}" + ) cdef inline int _validate_split_field_length( @@ -541,17 +560,21 @@ cdef class WorkqueueResource: Parameters ---------- options : :obj:`WorkqueueResourceOptions` - Configuration options (sharing scope, etc.). + Configuration options (sharing scope, concurrency limit). """ cdef WorkqueueResourceOptions opts = check_or_create_options( WorkqueueResourceOptions, options, "Workqueue resource options" ) _check_green_ctx_support() _check_workqueue_support() - if opts.sharing_scope is None: + if opts.sharing_scope is None and opts.concurrency_limit is None: return None IF CUDA_CORE_BUILD_MAJOR >= 13: + if opts.concurrency_limit is not None: + self._wq_config_resource.wqConfig.wqConcurrencyLimit = ( + opts.concurrency_limit + ) if opts.sharing_scope == "device_ctx": self._wq_config_resource.wqConfig.sharingScope = ( cydriver.CUdevWorkqueueConfigScope.CU_WORKQUEUE_SCOPE_DEVICE_CTX @@ -560,11 +583,6 @@ cdef class WorkqueueResource: self._wq_config_resource.wqConfig.sharingScope = ( cydriver.CUdevWorkqueueConfigScope.CU_WORKQUEUE_SCOPE_GREEN_CTX_BALANCED ) - else: - raise ValueError( - f"Unknown sharing_scope: {opts.sharing_scope!r}. " - "Expected 'device_ctx' or 'green_ctx_balanced'." - ) ELSE: raise RuntimeError( "WorkqueueResource requires cuda.core to be built with CUDA 13.x bindings" diff --git a/cuda_core/docs/source/release/1.1.0-notes.rst b/cuda_core/docs/source/release/1.1.0-notes.rst index 529c9df9eb7..d9fe0a7a5b4 100644 --- a/cuda_core/docs/source/release/1.1.0-notes.rst +++ b/cuda_core/docs/source/release/1.1.0-notes.rst @@ -106,6 +106,10 @@ New features (`#2068 `__, closes `#2049 `__) +- Added ``concurrency_limit`` to :class:`WorkqueueResourceOptions` to + configure the expected maximum concurrent stream-ordered workloads. + (`#2329 `__) + Fixes and enhancements ---------------------- diff --git a/cuda_core/tests/test_green_context.py b/cuda_core/tests/test_green_context.py index 4078b166b7b..ee3896c53ec 100644 --- a/cuda_core/tests/test_green_context.py +++ b/cuda_core/tests/test_green_context.py @@ -216,9 +216,28 @@ def test_configure_none_is_noop(self, wq_resource): def test_configure_valid_scope(self, wq_resource): wq_resource.configure(WorkqueueResourceOptions(sharing_scope="green_ctx_balanced")) - def test_configure_invalid_scope_raises(self, wq_resource): + def test_invalid_scope_raises_at_construction(self): with pytest.raises(ValueError, match="Unknown sharing_scope"): - wq_resource.configure(WorkqueueResourceOptions(sharing_scope="bogus")) + WorkqueueResourceOptions(sharing_scope="bogus") + + def test_configure_concurrency_limit(self, wq_resource): + wq_resource.configure(WorkqueueResourceOptions(concurrency_limit=4)) + + def test_configure_concurrency_and_scope(self, wq_resource): + wq_resource.configure( + WorkqueueResourceOptions( + sharing_scope="green_ctx_balanced", + concurrency_limit=2, + ) + ) + + def test_concurrency_limit_zero_raises_at_construction(self): + with pytest.raises(ValueError, match="concurrency_limit must be >= 1"): + WorkqueueResourceOptions(concurrency_limit=0) + + def test_concurrency_limit_negative_raises_at_construction(self): + with pytest.raises(ValueError, match="concurrency_limit must be >= 1"): + WorkqueueResourceOptions(concurrency_limit=-3) # --------------------------------------------------------------------------- @@ -495,9 +514,15 @@ def test_two_green_contexts_independent(self, init_cuda, sm_resource, fill_kerne ctx_a.close() def test_with_workqueue_resource(self, init_cuda, sm_resource, wq_resource, fill_kernel): - """Green context with SM + workqueue resources can launch a kernel.""" + """Green context with SM + configured workqueue can launch a kernel.""" dev = init_cuda groups, _ = sm_resource.split(SMResourceOptions(count=None)) + wq_resource.configure( + WorkqueueResourceOptions( + sharing_scope="green_ctx_balanced", + concurrency_limit=4, + ) + ) try: ctx = dev.create_context(ContextOptions(resources=[groups[0], wq_resource])) From e1f5d97b9759a0acf063b5e7d803714083e9a3aa Mon Sep 17 00:00:00 2001 From: Michael Droettboom Date: Thu, 9 Jul 2026 12:38:11 -0400 Subject: [PATCH 12/25] BUG: Fix test name parsing in find_skipped_tests.py (#2275) --- toolshed/find_skipped_tests.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/toolshed/find_skipped_tests.py b/toolshed/find_skipped_tests.py index e15f0492769..af44d7c0ad5 100755 --- a/toolshed/find_skipped_tests.py +++ b/toolshed/find_skipped_tests.py @@ -36,7 +36,7 @@ ANSI_ESCAPE = re.compile(r"\x1B\[[0-9;]*[A-Za-z]") PYTEST_NODE_ID = re.compile(r"tests/\S+\.py::\S+") -PYTEST_TEST_OUTCOME = re.compile(r"(tests/\S+\.py::\S+(\[.*?\])?)\s+(PASSED|FAILED|ERROR|SKIPPED|XFAIL|XPASS)\b") +PYTEST_TEST_OUTCOME = re.compile(r"(tests/\S+\.py::\S+)\s+(PASSED|FAILED|ERROR|SKIPPED|XFAIL|XPASS)\b") # GHA log format markers used to identify which test suite is active. # `gh api` logs: ##[group] opens a section, ##[endgroup] closes it. From 52043f9c7a1d0c29dae708c1e1b7bc74c89d9b05 Mon Sep 17 00:00:00 2001 From: Leo Fang Date: Thu, 9 Jul 2026 12:01:40 -0700 Subject: [PATCH 13/25] cuda.core: expose driver-populated fields on WorkqueueResource (#2330) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * cuda.core: expose driver-populated fields on WorkqueueResource Add read-only sharing_scope, concurrency_limit, and device properties on WorkqueueResource so users can inspect the driver-populated config without dropping to raw cydriver. Add WorkqueueSharingScopeType StrEnum in cuda.core.typing to give the sharing scope a typed return; strings matching the enum member values remain accepted for backward compat. Follows section 5(d) "opaque but round-trippable" from the green ctx design doc, which was written into SMResource but not applied to WorkqueueResource. * cuda.core: fill in PR number in release-notes entry * cuda.core: drop TYPE_CHECKING Device import to satisfy cython-lint The lazy import inside WorkqueueResource.device already imports Device at call time; the top-level TYPE_CHECKING import was unused as far as cython-lint could see and blocked pre-commit. * cuda.core: fold #2329 + #2330 release notes; parametrize enum test; add 2-GPU device check - Merge the two 1.1.0 workqueue entries into one bullet crediting both PRs. - Parametrize test_configure_scope_with_enum over both WorkqueueSharingScopeType members. - Add test_device_id_matches_source_multi_gpu verifying WorkqueueResource.device.device_id tracks the source device when the caller switches devices. Uses the established system.get_num_devices() < 2 skip pattern. * cuda.core tests: drop init_cuda from multi-GPU workqueue test * cuda.core tests: drop unnecessary set_current calls in multi-GPU workqueue test cuDeviceGetDevResource doesn't require the device to be current; verified locally that cuCtxGetCurrent returns the same context before and after the test body. * cuda.core tests: extract shared _RESOURCE_UNAVAILABLE_ERRORS tuple with rationale * cuda.core: restore Device TYPE_CHECKING import with noqa mypy needs Device resolvable in the generated .pyi (WorkqueueResource.device returns 'Device' as a string forward reference); noqa: F401 keeps cython-lint from re-flagging it as unused. * cuda.core: simplify noqa to bare form (cython-lint didn't parse the parenthetical) * cuda.core: use bare Device annotation on WorkqueueResource.device cython-lint doesn't count string-quoted forward references as usage of the TYPE_CHECKING import. The bare form works because from __future__ import annotations makes it a string at runtime anyway (matches _stream.pyx pattern). * cuda.core tests: register WorkqueueSharingScopeType in _CASES test_all_str_enums_in_cases enforces that every StrEnum in cuda.core.typing is bound to a driver-side counterpart or explicitly marked unbound. WorkqueueSharingScopeType wraps CUdevWorkqueueConfigScope 1:1 — clean binding-coverage entry. * cuda.core tests: gate WorkqueueSharingScopeType binding entry on CUDA 13+ CUdevWorkqueueConfigScope doesn't exist in CUDA 12.x cuda_bindings, so importing test_enum_coverage crashed with AttributeError. Only register the binding-coverage entry when the driver exposes the enum; otherwise mark the wrapper as unbound so test_all_str_enums_in_cases still passes. Verified both paths locally (real CUDA 13 + delattr-simulated CUDA 12). * cuda.core tests: sharpen CUDA-version boundary in WorkqueueSharingScopeType comment CUdevWorkqueueConfigScope landed in the driver in 13.1, not 13.0. Update the inline comment on the hasattr gate to reflect that the missing-driver-enum path covers cuda-bindings for both CUDA 12.x and CUDA 13.0.x. * cuda.core: apply Mike's suggestion for WorkqueueResourceOptions.sharing_scope docstring * fix typing Co-authored-by: Michael Droettboom * Update _device_resources.pyi * cuda.core: regenerate .pyi to match stubgen-pyx output end-of-file-fixer excludes .pyi (per .pre-commit-config.yaml), so the trailing newline manually added in the previous commit made stubgen-pyx flag the file every run. Reverting to the newline-less form stubgen emits. * Apply suggestions from code review Co-authored-by: Michael Droettboom --------- Co-authored-by: Michael Droettboom --- cuda_core/cuda/core/_device_resources.pyi | 37 +++++++++-- cuda_core/cuda/core/_device_resources.pyx | 64 +++++++++++++++++-- cuda_core/cuda/core/typing.py | 16 +++++ cuda_core/docs/source/release/1.1.0-notes.rst | 16 ++++- cuda_core/tests/test_enum_coverage.py | 18 ++++++ cuda_core/tests/test_green_context.py | 42 +++++++++++- 6 files changed, 179 insertions(+), 14 deletions(-) diff --git a/cuda_core/cuda/core/_device_resources.pyi b/cuda_core/cuda/core/_device_resources.pyi index 8ae6fb6b326..7514f5a2f43 100644 --- a/cuda_core/cuda/core/_device_resources.pyi +++ b/cuda_core/cuda/core/_device_resources.pyi @@ -5,6 +5,9 @@ from __future__ import annotations from collections.abc import Sequence as SequenceABC from dataclasses import dataclass +from cuda.core._device import Device +from cuda.core.typing import WorkqueueSharingScopeType + @dataclass class SMResourceOptions: @@ -44,9 +47,9 @@ class WorkqueueResourceOptions: Attributes ---------- - sharing_scope : str, optional - Workqueue sharing scope. Accepted values: ``"device_ctx"`` - or ``"green_ctx_balanced"``. (Default to ``None``) + sharing_scope : :class:`~cuda.core.typing.WorkqueueSharingScopeType` | str, optional + Workqueue sharing scope. Accepted values: ``"device_ctx"`` or + ``"green_ctx_balanced"``. concurrency_limit : int, optional Expected maximum number of concurrent stream-ordered workloads. Must be ``>= 1`` when set. The effective @@ -55,7 +58,7 @@ class WorkqueueResourceOptions: this cap, but the driver will not guarantee that work submission remains non-overlapping. (Default to ``None``) """ - sharing_scope: str | None = None + sharing_scope: WorkqueueSharingScopeType | str | None = None concurrency_limit: int | None = None def __post_init__(self): @@ -125,6 +128,32 @@ class WorkqueueResource: def handle(self) -> int: """Return the address of the underlying config ``CUdevResource`` struct.""" + @property + def sharing_scope(self) -> WorkqueueSharingScopeType: + """Current sharing scope of this workqueue resource. + + Returns the :class:`~cuda.core.typing.WorkqueueSharingScopeType` + member corresponding to the driver-populated + ``wqConfig.sharingScope`` field. It can be updated via + :meth:`configure` with + :attr:`WorkqueueResourceOptions.sharing_scope`. + """ + + @property + def concurrency_limit(self) -> int: + """Current expected maximum concurrent stream-ordered workloads. + + Reflects the driver-populated ``wqConfig.wqConcurrencyLimit`` field. + When first queried from a device, this matches the driver-reported + cap (typically ``CUDA_DEVICE_MAX_CONNECTIONS``). It can be updated + via :meth:`configure` with + :attr:`WorkqueueResourceOptions.concurrency_limit`. + """ + + @property + def device(self) -> Device: + """The :class:`~cuda.core.Device` this workqueue resource is available on.""" + def configure(self, options: WorkqueueResourceOptions) -> None: """Configure the workqueue resource in place. diff --git a/cuda_core/cuda/core/_device_resources.pyx b/cuda_core/cuda/core/_device_resources.pyx index 1e1f016f6cc..0c01956d2ea 100644 --- a/cuda_core/cuda/core/_device_resources.pyx +++ b/cuda_core/cuda/core/_device_resources.pyx @@ -6,6 +6,11 @@ from __future__ import annotations from collections.abc import Sequence as SequenceABC from dataclasses import dataclass +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from cuda.core._device import Device + from cuda.core.typing import WorkqueueSharingScopeType from libc.stdint cimport intptr_t from libc.stdlib cimport free, malloc @@ -126,9 +131,9 @@ cdef class WorkqueueResourceOptions: Attributes ---------- - sharing_scope : str, optional - Workqueue sharing scope. Accepted values: ``"device_ctx"`` - or ``"green_ctx_balanced"``. (Default to ``None``) + sharing_scope : :class:`~cuda.core.typing.WorkqueueSharingScopeType` | str, optional + Workqueue sharing scope. Accepted values: ``"device_ctx"`` or + ``"green_ctx_balanced"``. concurrency_limit : int, optional Expected maximum number of concurrent stream-ordered workloads. Must be ``>= 1`` when set. The effective @@ -138,7 +143,7 @@ cdef class WorkqueueResourceOptions: submission remains non-overlapping. (Default to ``None``) """ - sharing_scope: str | None = None + sharing_scope: WorkqueueSharingScopeType | str | None = None concurrency_limit: int | None = None def __post_init__(self): @@ -554,6 +559,57 @@ cdef class WorkqueueResource: """Return the address of the underlying config ``CUdevResource`` struct.""" return (&self._wq_config_resource) + @property + def sharing_scope(self) -> WorkqueueSharingScopeType: + """Current sharing scope of this workqueue resource. + + Returns the :class:`~cuda.core.typing.WorkqueueSharingScopeType` + member corresponding to the driver-populated + ``wqConfig.sharingScope`` field. It can be updated via + :meth:`configure` with + :attr:`WorkqueueResourceOptions.sharing_scope`. + """ + IF CUDA_CORE_BUILD_MAJOR >= 13: + from cuda.core.typing import WorkqueueSharingScopeType + cdef object scope = self._wq_config_resource.wqConfig.sharingScope + if scope == cydriver.CUdevWorkqueueConfigScope.CU_WORKQUEUE_SCOPE_DEVICE_CTX: + return WorkqueueSharingScopeType.DEVICE_CTX + elif scope == cydriver.CUdevWorkqueueConfigScope.CU_WORKQUEUE_SCOPE_GREEN_CTX_BALANCED: + return WorkqueueSharingScopeType.GREEN_CTX_BALANCED + raise RuntimeError(f"Unknown sharing scope enum value: {scope}") + ELSE: + raise RuntimeError( + "WorkqueueResource requires cuda.core to be built with CUDA 13.x bindings" + ) + + @property + def concurrency_limit(self) -> int: + """Current expected maximum concurrent stream-ordered workloads. + + Reflects the driver-populated ``wqConfig.wqConcurrencyLimit`` field. + When first queried from a device, this matches the driver-reported + cap (typically ``CUDA_DEVICE_MAX_CONNECTIONS``). It can be updated + via :meth:`configure` with + :attr:`WorkqueueResourceOptions.concurrency_limit`. + """ + IF CUDA_CORE_BUILD_MAJOR >= 13: + return self._wq_config_resource.wqConfig.wqConcurrencyLimit + ELSE: + raise RuntimeError( + "WorkqueueResource requires cuda.core to be built with CUDA 13.x bindings" + ) + + @property + def device(self) -> Device: + """The :class:`~cuda.core.Device` this workqueue resource is available on.""" + IF CUDA_CORE_BUILD_MAJOR >= 13: + from cuda.core._device import Device # avoid circular import + return Device(int(self._wq_config_resource.wqConfig.device)) + ELSE: + raise RuntimeError( + "WorkqueueResource requires cuda.core to be built with CUDA 13.x bindings" + ) + def configure(self, options: WorkqueueResourceOptions) -> None: """Configure the workqueue resource in place. diff --git a/cuda_core/cuda/core/typing.py b/cuda_core/cuda/core/typing.py index 2d253d8ca5e..1bf9bb7c0d2 100644 --- a/cuda_core/cuda/core/typing.py +++ b/cuda_core/cuda/core/typing.py @@ -52,6 +52,7 @@ class StrEnum(str, Enum): "VirtualMemoryGranularityType", "VirtualMemoryHandleType", "VirtualMemoryLocationType", + "WorkqueueSharingScopeType", ] @@ -296,4 +297,19 @@ class ReadModeType(StrEnum): NORMALIZED_FLOAT = "normalized_float" +class WorkqueueSharingScopeType(StrEnum): + """Sharing scope for :class:`~cuda.core.WorkqueueResource`. + + * ``DEVICE_CTX`` — use all shared workqueue resources across all + contexts (default driver behavior). + * ``GREEN_CTX_BALANCED`` — when possible, use non-overlapping + workqueue resources with other balanced green contexts. + + .. versionadded:: 1.1.0 + """ + + DEVICE_CTX = "device_ctx" + GREEN_CTX_BALANCED = "green_ctx_balanced" + + del StrEnum diff --git a/cuda_core/docs/source/release/1.1.0-notes.rst b/cuda_core/docs/source/release/1.1.0-notes.rst index d9fe0a7a5b4..2a282904986 100644 --- a/cuda_core/docs/source/release/1.1.0-notes.rst +++ b/cuda_core/docs/source/release/1.1.0-notes.rst @@ -106,9 +106,19 @@ New features (`#2068 `__, closes `#2049 `__) -- Added ``concurrency_limit`` to :class:`WorkqueueResourceOptions` to - configure the expected maximum concurrent stream-ordered workloads. - (`#2329 `__) +- Extended :class:`WorkqueueResource` and :class:`WorkqueueResourceOptions` + to cover the full driver-side workqueue-config surface. Added + ``concurrency_limit`` to :class:`WorkqueueResourceOptions` for + configuring the expected maximum concurrent stream-ordered workloads, + and read-only :attr:`WorkqueueResource.sharing_scope`, + :attr:`~WorkqueueResource.concurrency_limit`, and + :attr:`~WorkqueueResource.device` properties for round-tripping the + driver-populated values. Added + :class:`~cuda.core.typing.WorkqueueSharingScopeType` StrEnum accepted + by :attr:`WorkqueueResourceOptions.sharing_scope` in addition to raw + strings. + (`#2329 `__, + `#2330 `__) Fixes and enhancements ---------------------- diff --git a/cuda_core/tests/test_enum_coverage.py b/cuda_core/tests/test_enum_coverage.py index 09c12bbaf52..8de26b25d4b 100644 --- a/cuda_core/tests/test_enum_coverage.py +++ b/cuda_core/tests/test_enum_coverage.py @@ -310,6 +310,24 @@ } +# CUdevWorkqueueConfigScope was added to the CUDA driver in 13.1 (missing +# from the 13.0.0 cuda.h and earlier); on cuda-bindings for CUDA 12.x or +# 13.0.x, WorkqueueSharingScopeType has no driver-side counterpart to +# check against. +if hasattr(driver, "CUdevWorkqueueConfigScope"): + _CASES.append( + ( + driver.CUdevWorkqueueConfigScope, + cuda.core.typing.WorkqueueSharingScopeType, + None, + set(), + set(), + ) + ) +else: + _UNBOUND_STR_ENUMS.add(cuda.core.typing.WorkqueueSharingScopeType) + + @pytest.mark.parametrize( "binding, str_enum, mapping, binding_unmapped, str_enum_unmapped", _CASES, diff --git a/cuda_core/tests/test_green_context.py b/cuda_core/tests/test_green_context.py index ee3896c53ec..effa7167371 100644 --- a/cuda_core/tests/test_green_context.py +++ b/cuda_core/tests/test_green_context.py @@ -22,6 +22,7 @@ launch, ) from cuda.core._utils.cuda_utils import CUDAError +from cuda.core.typing import WorkqueueSharingScopeType # --------------------------------------------------------------------------- # Kernel source @@ -42,12 +43,23 @@ # --------------------------------------------------------------------------- +# Resource queries (dev.resources.sm, dev.resources.workqueue) can fail in +# three orthogonal ways when the resource type isn't supported here: +# * RuntimeError — cuda.core was built against CUDA bindings that don't +# expose the resource (e.g. WorkqueueResource on 12.x). +# * ValueError — the runtime driver version is too old to support the +# resource (green-context / workqueue support gates). +# * CUDAError — the driver rejected the specific device-level query. +# Skip on any of them. +_RESOURCE_UNAVAILABLE_ERRORS = (RuntimeError, ValueError, CUDAError) + + @pytest.fixture def sm_resource(init_cuda): """Query SM resources from the device, skip if unsupported.""" try: return init_cuda.resources.sm - except (RuntimeError, ValueError, CUDAError) as exc: + except _RESOURCE_UNAVAILABLE_ERRORS as exc: pytest.skip(str(exc)) @@ -56,7 +68,7 @@ def wq_resource(init_cuda): """Query workqueue resources from the device, skip if unsupported.""" try: return init_cuda.resources.workqueue - except (RuntimeError, ValueError, CUDAError) as exc: + except _RESOURCE_UNAVAILABLE_ERRORS as exc: pytest.skip(str(exc)) @@ -207,8 +219,11 @@ def test_arch_constraints_hopper_plus(self, init_cuda, sm_resource): class TestWorkqueueResource: - def test_query(self, wq_resource): + def test_query(self, init_cuda, wq_resource): assert wq_resource.handle != 0 + assert isinstance(wq_resource.sharing_scope, WorkqueueSharingScopeType) + assert wq_resource.concurrency_limit >= 1 + assert wq_resource.device.device_id == init_cuda.device_id def test_configure_none_is_noop(self, wq_resource): assert wq_resource.configure(WorkqueueResourceOptions(sharing_scope=None)) is None @@ -216,12 +231,33 @@ def test_configure_none_is_noop(self, wq_resource): def test_configure_valid_scope(self, wq_resource): wq_resource.configure(WorkqueueResourceOptions(sharing_scope="green_ctx_balanced")) + @pytest.mark.parametrize("scope", list(WorkqueueSharingScopeType)) + def test_configure_scope_with_enum(self, wq_resource, scope): + wq_resource.configure(WorkqueueResourceOptions(sharing_scope=scope)) + assert wq_resource.sharing_scope is scope + + def test_device_id_matches_source_multi_gpu(self): + from cuda.core import Device, system + + if system.get_num_devices() < 2: + pytest.skip("requires 2+ GPUs") + dev0 = Device(0) + dev1 = Device(1) + try: + wq0 = dev0.resources.workqueue + wq1 = dev1.resources.workqueue + except _RESOURCE_UNAVAILABLE_ERRORS as exc: + pytest.skip(str(exc)) + assert wq0.device.device_id == 0 + assert wq1.device.device_id == 1 + def test_invalid_scope_raises_at_construction(self): with pytest.raises(ValueError, match="Unknown sharing_scope"): WorkqueueResourceOptions(sharing_scope="bogus") def test_configure_concurrency_limit(self, wq_resource): wq_resource.configure(WorkqueueResourceOptions(concurrency_limit=4)) + assert wq_resource.concurrency_limit == 4 def test_configure_concurrency_and_scope(self, wq_resource): wq_resource.configure( From c23833b9793464194da9d9c82cd8f031711c47f5 Mon Sep 17 00:00:00 2001 From: Andy Jost Date: Thu, 9 Jul 2026 14:26:57 -0700 Subject: [PATCH 14/25] Fix tag CI by installing cuda-python metapackage with --no-deps (#2334) During cuda-core tag releases, pip install cuda_python*.whl re-resolves cuda-core~=1.0.0 from PyPI and fails or downgrades the artifact wheel. Subpackages are already installed from CI artifacts, so skip dependency resolution in docs build and wheel test installability checks. --- .github/workflows/build-docs.yml | 4 +++- .github/workflows/test-wheel-linux.yml | 6 ++++-- .github/workflows/test-wheel-windows.yml | 6 ++++-- 3 files changed, 11 insertions(+), 5 deletions(-) diff --git a/.github/workflows/build-docs.yml b/.github/workflows/build-docs.yml index c8c4e28905e..7bb70809556 100644 --- a/.github/workflows/build-docs.yml +++ b/.github/workflows/build-docs.yml @@ -212,7 +212,9 @@ jobs: pip install *.whl popd - pip install cuda_python*.whl + # Subpackages are already installed from CI artifacts above. + # --no-deps avoids re-resolving cuda-core from PyPI during tag releases. + pip install --no-deps cuda_python*.whl # This step sets the PR_NUMBER/BUILD_LATEST/BUILD_PREVIEW env vars. - name: Get PR number diff --git a/.github/workflows/test-wheel-linux.yml b/.github/workflows/test-wheel-linux.yml index 16af4b15d34..ae1e2e5dafc 100644 --- a/.github/workflows/test-wheel-linux.yml +++ b/.github/workflows/test-wheel-linux.yml @@ -372,10 +372,12 @@ jobs: - name: Ensure cuda-python installable if: ${{ inputs.test-mode == 'standard' && env.BINDINGS_SOURCE == 'main' }} run: | + # Subpackages are already installed from CI artifacts; --no-deps keeps + # tag-release cuda-core wheels from being replaced by PyPI pins. if [[ "${{ matrix.LOCAL_CTK }}" == 1 ]]; then - pip install --only-binary=:all: cuda_python*.whl + pip install --only-binary=:all: --no-deps cuda_python*.whl else - pip install --only-binary=:all: $(ls cuda_python*.whl)[all] + pip install --only-binary=:all: --no-deps $(ls cuda_python*.whl)[all] fi - name: Install cuda.pathfinder extra wheels for testing diff --git a/.github/workflows/test-wheel-windows.yml b/.github/workflows/test-wheel-windows.yml index 0d9dc78d5da..46937cbd12d 100644 --- a/.github/workflows/test-wheel-windows.yml +++ b/.github/workflows/test-wheel-windows.yml @@ -341,10 +341,12 @@ jobs: - name: Ensure cuda-python installable if: ${{ inputs.test-mode == 'standard' && env.BINDINGS_SOURCE == 'main' }} run: | + # Subpackages are already installed from CI artifacts; --no-deps keeps + # tag-release cuda-core wheels from being replaced by PyPI pins. if ('${{ matrix.LOCAL_CTK }}' -eq '1') { - pip install --only-binary=:all: (Get-ChildItem -Filter cuda_python*.whl).FullName + pip install --only-binary=:all: --no-deps (Get-ChildItem -Filter cuda_python*.whl).FullName } else { - pip install --only-binary=:all: "$((Get-ChildItem -Filter cuda_python*.whl).FullName)[all]" + pip install --only-binary=:all: --no-deps "$((Get-ChildItem -Filter cuda_python*.whl).FullName)[all]" } - name: Install cuda.pathfinder extra wheels for testing From e83d43417562fb5a31d46060e1c93c0d00104b7e Mon Sep 17 00:00:00 2001 From: Michael Wang <13521008+isVoid@users.noreply.github.com> Date: Thu, 9 Jul 2026 15:45:38 -0700 Subject: [PATCH 15/25] Check nvJitLink driver major compatibility (#2320) * Check nvJitLink driver major compatibility * Narrow nvJitLink driver compatibility fallback * Fix cuLink state storage lifetimes * Isolate nvJitLink-specific cache tests * Use public linker backend query in tests * Use direct backend skips in program cache tests --------- Co-authored-by: Michael Wang --- cuda_core/cuda/core/_linker.pxd | 10 ++- cuda_core/cuda/core/_linker.pyi | 3 +- cuda_core/cuda/core/_linker.pyx | 64 +++++++++++++------ cuda_core/tests/test_linker.py | 55 +++++++++++++--- .../tests/test_optional_dependency_imports.py | 48 ++++++++++++++ cuda_core/tests/test_program_cache.py | 23 +++++-- 6 files changed, 167 insertions(+), 36 deletions(-) diff --git a/cuda_core/cuda/core/_linker.pxd b/cuda_core/cuda/core/_linker.pxd index e50ebb97705..1b7d39fd1d4 100644 --- a/cuda_core/cuda/core/_linker.pxd +++ b/cuda_core/cuda/core/_linker.pxd @@ -2,6 +2,10 @@ # # SPDX-License-Identifier: Apache-2.0 +from libcpp.vector cimport vector + +from cuda.bindings cimport cydriver + from ._resource_handles cimport NvJitLinkHandle, CuLinkHandle @@ -9,8 +13,12 @@ cdef class Linker: cdef: NvJitLinkHandle _nvjitlink_handle CuLinkHandle _culink_handle + # The driver retains these arrays until cuLinkDestroy. Declare them + # after the handle so their destructors run after cuLinkDestroy. + vector[cydriver.CUjit_option] _drv_jit_keys + vector[void*] _drv_jit_values bint _use_nvjitlink - object _drv_log_bufs # formatted_options list (driver); None for nvjitlink; cleared in link() + object _drv_log_bufs # formatted_options list (driver); None for nvjitlink str _info_log # decoded log; None until link() or pre-link get_*_log() str _error_log # decoded log; None until link() or pre-link get_*_log() object _options # LinkerOptions diff --git a/cuda_core/cuda/core/_linker.pyi b/cuda_core/cuda/core/_linker.pyi index 42b08313f78..37e05fc7fe6 100644 --- a/cuda_core/cuda/core/_linker.pyi +++ b/cuda_core/cuda/core/_linker.pyi @@ -112,7 +112,8 @@ class LinkerOptions: Since the linker may choose to use nvJitLink or the driver APIs as the linking backend, not all options are applicable. When the system's installed nvJitLink is too old (<12.3), - or not installed, the driver APIs (cuLink) will be used instead. + not installed, or older than the CUDA driver major version, the driver APIs (cuLink) + will be used instead. Attributes ---------- diff --git a/cuda_core/cuda/core/_linker.pyx b/cuda_core/cuda/core/_linker.pyx index 10a85b998a1..172b176c844 100644 --- a/cuda_core/cuda/core/_linker.pyx +++ b/cuda_core/cuda/core/_linker.pyx @@ -39,6 +39,7 @@ from cuda.core._utils.cuda_utils import ( driver, is_sequence, ) +from cuda.core._utils.version import driver_version from cuda.core.typing import CompilerBackendType, ObjectCodeFormatType if TYPE_CHECKING: @@ -52,7 +53,6 @@ _keep_driver_in_stub: "cuda.bindings.driver.CUlinkState" _keep_nvjitlink_in_stub: "cuda.bindings.nvjitlink.nvJitLinkHandle" ctypedef const char* const_char_ptr -ctypedef void* void_ptr __all__ = ["Linker", "LinkerOptions"] @@ -155,10 +155,21 @@ cdef class Linker: def close(self) -> None: """Destroy this linker.""" + cdef vector[cydriver.CUjit_option] empty_keys + cdef vector[void*] empty_values if self._use_nvjitlink: self._nvjitlink_handle.reset() else: + if self._drv_log_bufs is not None: + if self._info_log is None: + self._info_log = self.get_info_log() + if self._error_log is None: + self._error_log = self.get_error_log() + # Destroy the CUlinkState before releasing storage referenced by it. self._culink_handle.reset() + self._drv_jit_keys.swap(empty_keys) + self._drv_jit_values.swap(empty_values) + self._drv_log_bufs = None @property def handle(self) -> LinkerHandleT: @@ -207,7 +218,8 @@ class LinkerOptions: Since the linker may choose to use nvJitLink or the driver APIs as the linking backend, not all options are applicable. When the system's installed nvJitLink is too old (<12.3), - or not installed, the driver APIs (cuLink) will be used instead. + not installed, or older than the CUDA driver major version, the driver APIs (cuLink) + will be used instead. Attributes ---------- @@ -473,8 +485,8 @@ cdef inline int Linker_init(Linker self, tuple object_codes, object options) exc cdef cydriver.CUlinkState c_raw_culink cdef Py_ssize_t c_num_opts, i cdef vector[const_char_ptr] c_str_opts - cdef vector[cydriver.CUjit_option] c_jit_keys - cdef vector[void_ptr] c_jit_values + cdef cydriver.CUjit_option* c_drv_jit_keys_ptr + cdef void** c_drv_jit_values_ptr self._options = options = check_or_create_options(LinkerOptions, options, "Linker options") @@ -496,19 +508,24 @@ cdef inline int Linker_init(Linker self, tuple object_codes, object options) exc # the driver writes into via raw pointers during linking operations. self._drv_log_bufs = formatted_options c_num_opts = len(option_keys) - c_jit_keys.resize(c_num_opts) - c_jit_values.resize(c_num_opts) + self._drv_jit_keys.resize(c_num_opts) + self._drv_jit_values.resize(c_num_opts) for i in range(c_num_opts): - c_jit_keys[i] = option_keys[i] + self._drv_jit_keys[i] = option_keys[i] val = formatted_options[i] if isinstance(val, bytearray): - c_jit_values[i] = PyByteArray_AS_STRING(val) + self._drv_jit_values[i] = PyByteArray_AS_STRING(val) else: - c_jit_values[i] = int(val) + self._drv_jit_values[i] = int(val) + c_drv_jit_keys_ptr = self._drv_jit_keys.data() + c_drv_jit_values_ptr = self._drv_jit_values.data() try: with nogil: HANDLE_RETURN(cydriver.cuLinkCreate( - c_num_opts, c_jit_keys.data(), c_jit_values.data(), &c_raw_culink)) + c_num_opts, + c_drv_jit_keys_ptr, + c_drv_jit_values_ptr, + &c_raw_culink)) except CUDAError as e: Linker_annotate_error_log(self, e) raise @@ -622,11 +639,10 @@ cdef inline object Linker_link(Linker self, str target_type): raise code = (c_cubin_out)[:c_output_size] - # Linking is complete; cache the decoded log strings and release - # the driver's raw bytearray buffers (no longer written to). + # Linking is complete; cache the decoded logs. cuLinkDestroy may still + # dereference the raw log-buffer pointers, so retain them until close(). self._info_log = self.get_info_log() self._error_log = self.get_error_log() - self._drv_log_bufs = None return ObjectCode._init(bytes(code), target_type, name=self._options.name) @@ -680,12 +696,22 @@ def _decide_nvjitlink_or_driver() -> bool: from cuda.bindings._internal import nvjitlink if _nvjitlink_has_version_symbol(nvjitlink): - _use_nvjitlink_backend = True - return False # Use nvjitlink - warn_txt = ( - f"{'nvJitLink*.dll' if sys.platform == 'win32' else 'libnvJitLink.so*'} is too old (<12.3)." - f" Therefore cuda.bindings.nvjitlink is not usable and {warn_txt_common} nvJitLink." - ) + nvjitlink_version = nvjitlink_module.version() + driver_major = driver_version()[0] + if driver_major <= nvjitlink_version[0]: + _use_nvjitlink_backend = True + return False # Use nvjitlink + + warn_txt = ( + f"CUDA driver major version {driver_major} is newer than " + f"nvJitLink major version {nvjitlink_version[0]}; therefore " + f"{warn_txt_common} nvJitLink." + ) + else: + warn_txt = ( + f"{'nvJitLink*.dll' if sys.platform == 'win32' else 'libnvJitLink.so*'} is too old (<12.3)." + f" Therefore cuda.bindings.nvjitlink is not usable and {warn_txt_common} nvJitLink." + ) warn(warn_txt, stacklevel=2, category=RuntimeWarning) _use_nvjitlink_backend = False diff --git a/cuda_core/tests/test_linker.py b/cuda_core/tests/test_linker.py index 942ccb10640..9d95b5fd9c3 100644 --- a/cuda_core/tests/test_linker.py +++ b/cuda_core/tests/test_linker.py @@ -8,6 +8,7 @@ from cuda.core import Device, Linker, LinkerOptions, Program, ProgramOptions, _linker from cuda.core._module import ObjectCode +from cuda.core._program import _can_load_generated_ptx from cuda.core._utils.cuda_utils import CUDAError ARCH = "sm_" + "".join(f"{i}" for i in Device().compute_capability) @@ -196,19 +197,12 @@ def test_linker_options_as_bytes_nvjitlink(): assert "-maxrregcount=32" in options_str -def test_linker_options_as_bytes_invalid_backend(): +@pytest.mark.parametrize("backend", ("invalid", "driver")) +def test_linker_options_as_bytes_invalid_backend(backend): """Test LinkerOptions.as_bytes() with invalid backend""" options = LinkerOptions(arch="sm_80") with pytest.raises(ValueError, match="only supports 'nvjitlink' backend"): - options.as_bytes("invalid") - - -@pytest.mark.skipif(not is_culink_backend, reason="driver backend test") -def test_linker_options_as_bytes_driver_not_supported(): - """Test that as_bytes() is not supported for driver backend""" - options = LinkerOptions(arch="sm_80") - with pytest.raises(RuntimeError, match="as_bytes\\(\\) only supports 'nvjitlink' backend"): - options.as_bytes("driver") + options.as_bytes(backend) def test_linker_logs_cached_after_link(compile_ptx_functions): @@ -234,6 +228,47 @@ def test_linker_handle(compile_ptx_functions): assert int(handle) != 0 +@pytest.mark.agent_authored(model="gpt-5") +@pytest.mark.skipif(not is_culink_backend, reason="driver backend regression test") +def test_driver_linker_lifetime_no_heap_corruption(compile_ptx_functions): + if not _can_load_generated_ptx(): + pytest.skip("PTX version too new for current driver") + + linker = Linker(*compile_ptx_functions, options=LinkerOptions(arch=ARCH)) + linker.link("cubin") + linker.close() + del linker + + obj_a = Program(kernel_a, "c++", ProgramOptions(relocatable_device_code=True)).compile("ptx") + obj_b = Program(device_function_b, "c++", ProgramOptions(relocatable_device_code=True)).compile("ptx") + obj_c = Program(device_function_c, "c++", ProgramOptions(relocatable_device_code=True)).compile("ptx") + linker = Linker(obj_a, obj_b, obj_c, options=LinkerOptions(arch=ARCH)) + linker.link("cubin") + linker.close() + + +@pytest.mark.agent_authored(model="gpt-5") +@pytest.mark.skipif(not is_culink_backend, reason="driver backend regression test") +def test_driver_linker_preserves_error_log_after_close(init_cuda): + if not _can_load_generated_ptx(): + pytest.skip("PTX version too new for current driver") + + bad_kernel = """ +extern __device__ int Z(); +__global__ void A() { int r = Z(); } +""" + bad_obj = Program(bad_kernel, "c++", ProgramOptions(relocatable_device_code=True)).compile("ptx") + linker = Linker(bad_obj, options=LinkerOptions(arch=ARCH)) + with pytest.raises(CUDAError): + linker.link("cubin") + + error_log = linker.get_error_log() + assert error_log + linker.close() + assert linker.get_error_log() == error_log + assert isinstance(linker.get_info_log(), str) + + @pytest.mark.skipif(is_culink_backend, reason="nvjitlink options only tested with nvjitlink backend") def test_linker_options_nvjitlink_options_as_str(): """_prepare_nvjitlink_options(as_bytes=False) returns plain strings.""" diff --git a/cuda_core/tests/test_optional_dependency_imports.py b/cuda_core/tests/test_optional_dependency_imports.py index 02edcc9839a..6759fd3cfa4 100644 --- a/cuda_core/tests/test_optional_dependency_imports.py +++ b/cuda_core/tests/test_optional_dependency_imports.py @@ -7,6 +7,14 @@ from cuda.core import _linker, _program +class FakeNvJitLinkModule: + def __init__(self, version): + self._version = version + + def version(self): + return self._version + + @pytest.fixture(autouse=True) def restore_optional_import_state(): saved_nvvm_module = _program._nvvm_module @@ -103,3 +111,43 @@ def fake__optional_cuda_import(modname, probe_function=None): assert use_driver_backend is True assert _linker._use_nvjitlink_backend is False + + +@pytest.mark.agent_authored(model="gpt-5") +@pytest.mark.parametrize( + ("driver_version", "nvjitlink_version"), + [ + ((12, 8, 0), (12, 9)), + ((12, 9, 0), (13, 0)), + ], +) +def test_decide_nvjitlink_or_driver_uses_nvjitlink_when_driver_is_not_newer( + monkeypatch, driver_version, nvjitlink_version +): + monkeypatch.setattr( + _linker, + "_optional_cuda_import", + lambda *_args, **_kwargs: FakeNvJitLinkModule(nvjitlink_version), + ) + monkeypatch.setattr(_linker, "_nvjitlink_has_version_symbol", lambda _nvjitlink: True) + monkeypatch.setattr(_linker, "driver_version", lambda: driver_version) + + assert _linker._decide_nvjitlink_or_driver() is False + assert _linker._use_nvjitlink_backend is True + + +@pytest.mark.agent_authored(model="gpt-5") +def test_decide_nvjitlink_or_driver_falls_back_when_driver_is_newer(monkeypatch): + monkeypatch.setattr( + _linker, + "_optional_cuda_import", + lambda *_args, **_kwargs: FakeNvJitLinkModule((12, 9)), + ) + monkeypatch.setattr(_linker, "_nvjitlink_has_version_symbol", lambda _nvjitlink: True) + monkeypatch.setattr(_linker, "driver_version", lambda: (13, 0, 0)) + + with pytest.warns(RuntimeWarning, match="is newer than nvJitLink major version"): + use_driver_backend = _linker._decide_nvjitlink_or_driver() + + assert use_driver_backend is True + assert _linker._use_nvjitlink_backend is False diff --git a/cuda_core/tests/test_program_cache.py b/cuda_core/tests/test_program_cache.py index 963ec1cc04b..3bb579e2fe8 100644 --- a/cuda_core/tests/test_program_cache.py +++ b/cuda_core/tests/test_program_cache.py @@ -7,6 +7,10 @@ import pytest +from cuda.core import _linker + +is_culink_backend = _linker._decide_nvjitlink_or_driver() + def test_program_cache_resource_is_abstract(): from cuda.core.utils import ProgramCacheResource @@ -369,9 +373,6 @@ def test_make_program_cache_key_ignores_name_expressions_for_non_nvrtc(code_type {"link_time_optimization": None}, id="lto_false_eq_none", ), - # ``time`` is a presence gate: the linker emits ``-time`` for any - # non-None value, so True / "path" produce the same flag. - pytest.param({"time": True}, {"time": "timing.csv"}, id="time_true_eq_path"), # ``no_cache`` has an ``is True`` gate; False and None equivalent. pytest.param({"no_cache": False}, {"no_cache": None}, id="no_cache_false_eq_none"), ], @@ -390,6 +391,18 @@ def test_make_program_cache_key_ptx_linker_equivalent_options_hash_same(a, b, mo assert k_a == k_b +@pytest.mark.skipif(is_culink_backend, reason="test requires nvJitLink backend") +@pytest.mark.agent_authored(model="gpt-5") +def test_make_program_cache_key_ptx_nvjitlink_time_values_hash_same(monkeypatch): + """nvJitLink emits ``-time`` for any non-None value.""" + from cuda.core.utils import _program_cache + + monkeypatch.setattr(_program_cache._keys, "_linker_backend_and_version", lambda _use_driver: ("nvJitLink", "12030")) + k_true = _make_key(code=".version 7.0", code_type="ptx", options=_opts(time=True)) + k_path = _make_key(code=".version 7.0", code_type="ptx", options=_opts(time="timing.csv")) + assert k_true == k_path + + @pytest.mark.parametrize( "field, a, b", [ @@ -999,9 +1012,9 @@ def test_make_program_cache_key_rejects_side_effect_options_nvrtc(option_kw, ext pytest.param({"time": "whatever.csv"}, id="time_path"), ], ) +@pytest.mark.skipif(is_culink_backend, reason="test requires nvJitLink backend") def test_make_program_cache_key_accepts_side_effect_options_for_ptx(option_kw): - """The side-effect guard is NVRTC-specific: PTX (linker) and NVVM must - not be blocked by options whose side effects only apply under NVRTC.""" + """nvJitLink ``-time`` writes only to its info log, not the filesystem.""" _make_key(code=".version 7.0", code_type="ptx", options=_opts(**option_kw)) # no raise From 1af2e223780ec2c76bcde101cb1782e672344a53 Mon Sep 17 00:00:00 2001 From: Minh Vu Date: Fri, 10 Jul 2026 04:20:16 +0200 Subject: [PATCH 16/25] Include cuda.core C++ headers in packages (#2236) Co-authored-by: Michael Droettboom Co-authored-by: Leo Fang --- cuda_core/MANIFEST.in | 2 +- cuda_core/pyproject.toml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/cuda_core/MANIFEST.in b/cuda_core/MANIFEST.in index f93db82277c..f63b324cab7 100644 --- a/cuda_core/MANIFEST.in +++ b/cuda_core/MANIFEST.in @@ -3,7 +3,7 @@ # SPDX-License-Identifier: Apache-2.0 recursive-include cuda/core *.pyx *.pxd *.pxi *.pyi -recursive-include cuda/core/_cpp *.cpp *.hpp +recursive-include cuda/core/_cpp *.cpp *.h *.hpp recursive-include cuda/core/_include *.h *.hpp include cuda/core/py.typed include NOTICE diff --git a/cuda_core/pyproject.toml b/cuda_core/pyproject.toml index aba5b8b9fff..f3a0c3a70f9 100644 --- a/cuda_core/pyproject.toml +++ b/cuda_core/pyproject.toml @@ -109,7 +109,7 @@ include-package-data = false [tool.setuptools.package-data] "*" = ["*.pxd", "*.pyi", "py.typed"] "cuda.core._include" = ["*.h", "*.hpp"] -"cuda.core._cpp" = ["*.hpp"] +"cuda.core._cpp" = ["*.h", "*.hpp"] [tool.setuptools.dynamic] readme = { file = ["DESCRIPTION.rst"], content-type = "text/x-rst" } From 30d9c607b82328b20f26275845453a659b33f7ed Mon Sep 17 00:00:00 2001 From: "Ralf W. Grosse-Kunstleve" Date: Fri, 10 Jul 2026 12:02:04 -0700 Subject: [PATCH 17/25] Build cuda.core RDC test fixtures without Bash (#2335) * Run nvcc fixture build without Bash * Document narrow nvcc skip detection * Document nvcc test environment requirements --- .github/workflows/build-wheel.yml | 4 +- .../test_binaries/build_test_binaries.py | 56 +++++++++++++ .../test_binaries/build_test_binaries.sh | 28 ------- cuda_core/tests/test_module.py | 84 +++++++++++++++---- 4 files changed, 129 insertions(+), 43 deletions(-) create mode 100644 cuda_core/tests/test_binaries/build_test_binaries.py delete mode 100755 cuda_core/tests/test_binaries/build_test_binaries.sh diff --git a/.github/workflows/build-wheel.yml b/.github/workflows/build-wheel.yml index 235cfbe813f..4dac9c8eca9 100644 --- a/.github/workflows/build-wheel.yml +++ b/.github/workflows/build-wheel.yml @@ -463,7 +463,9 @@ jobs: cuda-path: "./cuda_toolkit_prev" - name: Build cuda.core test binaries - run: bash ${{ env.CUDA_CORE_TEST_BINARIES_DIR }}/build_test_binaries.sh + run: | + nvcc --version + python "${{ env.CUDA_CORE_TEST_BINARIES_DIR }}/build_test_binaries.py" - name: Upload cuda.core test binaries uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 diff --git a/cuda_core/tests/test_binaries/build_test_binaries.py b/cuda_core/tests/test_binaries/build_test_binaries.py new file mode 100644 index 00000000000..5dfa1fe7f08 --- /dev/null +++ b/cuda_core/tests/test_binaries/build_test_binaries.py @@ -0,0 +1,56 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +"""Build the relocatable-device-code fixtures used by cuda.core tests.""" + +from __future__ import annotations + +import os +import subprocess +import tempfile +from pathlib import Path + + +def _run(command: list[str]) -> None: + print(f"+ {subprocess.list2cmdline(command)}") + result = subprocess.run(command) # noqa: S603 + if result.returncode != 0: + raise SystemExit(result.returncode) + + +def main() -> None: + script_dir = Path(__file__).resolve().parent + source_path = script_dir / "saxpy.cu" + final_object_path = script_dir / "saxpy.o" + final_library_path = script_dir / ("saxpy.lib" if os.name == "nt" else "saxpy.a") + + nvcc_extra_flags = ["-std=c++17"] + if os.name == "nt": + nvcc_extra_flags.extend(["-Xcompiler", "/Zc:preprocessor"]) + + with tempfile.TemporaryDirectory(prefix="build_test_binaries-", dir=script_dir) as temp_dir: + temp_dir_path = Path(temp_dir) + object_path = temp_dir_path / final_object_path.name + library_path = temp_dir_path / final_library_path.name + + _run( + [ + "nvcc", + "-dc", + *nvcc_extra_flags, + "-arch=all-major", + "-o", + str(object_path), + str(source_path), + ] + ) + _run(["nvcc", "-lib", "-o", str(library_path), str(object_path)]) + + object_path.replace(final_object_path) + library_path.replace(final_library_path) + + for path in (final_object_path, final_library_path): + print(f"{path}: {path.stat().st_size} bytes") + + +if __name__ == "__main__": + main() diff --git a/cuda_core/tests/test_binaries/build_test_binaries.sh b/cuda_core/tests/test_binaries/build_test_binaries.sh deleted file mode 100755 index 077dd8e90cb..00000000000 --- a/cuda_core/tests/test_binaries/build_test_binaries.sh +++ /dev/null @@ -1,28 +0,0 @@ -#!/bin/bash - -# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-License-Identifier: Apache-2.0 - -set -euo pipefail - -# Build .o test fixtures. Invoked at CI build stage - -SCRIPTPATH=$(dirname "$(realpath "$0")") - -NVCC_EXTRA_FLAGS=(-std=c++17) -if [[ "${OS:-}" == "Windows_NT" ]]; then - NVCC_EXTRA_FLAGS+=(-Xcompiler /Zc:preprocessor) -fi - -NVCC="${NVCC:-nvcc}" - -"${NVCC}" -dc "${NVCC_EXTRA_FLAGS[@]}" -arch=all-major \ - -o "${SCRIPTPATH}/saxpy.o" "${SCRIPTPATH}/saxpy.cu" - -if [[ "${OS:-}" == "Windows_NT" ]]; then - "${NVCC}" -lib -o "${SCRIPTPATH}/saxpy.lib" "${SCRIPTPATH}/saxpy.o" - ls -lah "${SCRIPTPATH}/saxpy.o" "${SCRIPTPATH}/saxpy.lib" -else - "${NVCC}" -lib -o "${SCRIPTPATH}/saxpy.a" "${SCRIPTPATH}/saxpy.o" - ls -lah "${SCRIPTPATH}/saxpy.o" "${SCRIPTPATH}/saxpy.a" -fi diff --git a/cuda_core/tests/test_module.py b/cuda_core/tests/test_module.py index a0600966619..e56449a67dc 100644 --- a/cuda_core/tests/test_module.py +++ b/cuda_core/tests/test_module.py @@ -5,6 +5,7 @@ import os import pickle import subprocess +import sys import warnings from pathlib import Path @@ -16,7 +17,6 @@ from cuda.core._program import _can_load_generated_ptx from cuda.core._utils.cuda_utils import CUDAError, driver, handle_return from cuda.core._utils.version import binding_version, driver_version -from cuda.pathfinder import find_nvidia_binary_utility try: import numba @@ -193,22 +193,78 @@ def _read_saxpy_rdc(kind: str) -> bytes: raise ValueError(f"unknown saxpy RDC kind: {kind!r}") if not rdc_path.is_file(): - nvcc_path = find_nvidia_binary_utility("nvcc") - if nvcc_path is None: - pytest.skip( - f"{rdc_path.name} not found at {rdc_path} and nvcc is unavailable. " - "In CI this is downloaded from the build stage." - ) - env = os.environ.copy() - env["NVCC"] = nvcc_path - subprocess.run( # noqa: S603 - ["bash", str(binaries_dir / "build_test_binaries.sh")], # noqa: S607 - check=True, - env=env, - ) + _build_saxpy_rdc(binaries_dir) return rdc_path.read_bytes() +def _subprocess_output(result: subprocess.CompletedProcess[str]) -> str: + sections = [] + if result.stdout: + sections.append(f"stdout:\n{result.stdout.rstrip()}") + if result.stderr: + sections.append(f"stderr:\n{result.stderr.rstrip()}") + return "\n".join(sections) or "" + + +def _host_compiler_is_unavailable(output: str) -> bool: + normalized = output.lower() + # Keep these patterns narrow. Unknown nvcc failures should fail the test and + # expose their diagnostics, not be silently reclassified as environment skips. + windows_compiler_missing = ( + "cannot find compiler" in normalized and "cl.exe" in normalized and "in path" in normalized + ) + linux_compiler_missing = ( + "no such file or directory" in normalized and "failed to preprocess host compiler properties" in normalized + ) + return windows_compiler_missing or linux_compiler_missing + + +def _build_saxpy_rdc(binaries_dir: Path) -> None: + """Use nvcc from PATH with the host compiler environment configured by the caller.""" + try: + version_result = subprocess.run( + ["nvcc", "--version"], # noqa: S607 - PATH lookup is the behavior under test. + capture_output=True, + text=True, + errors="replace", + ) + except FileNotFoundError: + pytest.skip("RDC test fixtures are absent and nvcc is not available on PATH") + + if version_result.returncode != 0: + pytest.fail( + f"nvcc --version failed with exit code {version_result.returncode}\n{_subprocess_output(version_result)}", + pytrace=False, + ) + + print(version_result.stdout, end="") + if version_result.stderr: + print(version_result.stderr, end="", file=sys.stderr) + + builder_path = binaries_dir / "build_test_binaries.py" + build_result = subprocess.run( # noqa: S603 + [sys.executable, str(builder_path)], + capture_output=True, + text=True, + errors="replace", + ) + if build_result.returncode == 0: + print(build_result.stdout, end="") + if build_result.stderr: + print(build_result.stderr, end="", file=sys.stderr) + return + + output = _subprocess_output(build_result) + if _host_compiler_is_unavailable(output): + print(output, file=sys.stderr) + pytest.skip("nvcc is available, but its host compiler is not configured") + + pytest.fail( + f"RDC test fixture build failed with exit code {build_result.returncode}\n{output}", + pytrace=False, + ) + + def test_get_kernel(init_cuda): kernel = """extern "C" __global__ void ABC() { }""" From 060578ab92f676d760bf698a653584e31306d8cb Mon Sep 17 00:00:00 2001 From: Ralf Juengling Date: Fri, 10 Jul 2026 17:06:57 -0700 Subject: [PATCH 18/25] [chore] Remove unecessary imports and declarations from some pxd files (#2338) * [chore] Remove unecessary imports and declarations from some pxd files * Fix deprecated array syntax --- cuda_core/cuda/core/_memory/_buffer.pxd | 12 +- cuda_core/cuda/core/_memory/_buffer.pyx | 134 +++++++++--------- .../core/_memory/_device_memory_resource.pxd | 1 - cuda_core/cuda/core/_memory/_memory_pool.pxd | 10 -- cuda_core/cuda/core/_memory/_memory_pool.pyx | 2 + .../core/_memory/_pinned_memory_resource.pxd | 3 +- 6 files changed, 71 insertions(+), 91 deletions(-) diff --git a/cuda_core/cuda/core/_memory/_buffer.pxd b/cuda_core/cuda/core/_memory/_buffer.pxd index 83dcd4f68c2..b552e69554d 100644 --- a/cuda_core/cuda/core/_memory/_buffer.pxd +++ b/cuda_core/cuda/core/_memory/_buffer.pxd @@ -2,13 +2,10 @@ # # SPDX-License-Identifier: Apache-2.0 -from libc.stdint cimport uintptr_t from libcpp cimport bool as cpp_bool -from libcpp.atomic cimport atomic as std_atomic, memory_order_acquire, memory_order_release +from libcpp.atomic cimport atomic as std_atomic -from cuda.bindings cimport cydriver from cuda.core._resource_handles cimport DevicePtrHandle -from cuda.core._stream cimport Stream cdef struct _MemAttrs: @@ -47,10 +44,3 @@ cdef Buffer Buffer_from_deviceptr_handle( object ipc_descriptor = *, type cls = *, ) - -# Memory attribute query helpers (used by _managed_memory_ops) -cdef void _init_mem_attrs(Buffer self) -cdef int _query_memory_attrs( - _MemAttrs& out, - cydriver.CUdeviceptr ptr, -) except -1 nogil diff --git a/cuda_core/cuda/core/_memory/_buffer.pyx b/cuda_core/cuda/core/_memory/_buffer.pyx index f9b79bfdcc7..97ef892547d 100644 --- a/cuda_core/cuda/core/_memory/_buffer.pyx +++ b/cuda_core/cuda/core/_memory/_buffer.pyx @@ -6,6 +6,7 @@ from __future__ import annotations cimport cython from libc.stdint cimport uintptr_t +from libcpp.atomic cimport memory_order_acquire, memory_order_release from cuda.bindings cimport cydriver from cuda.core._memory._device_memory_resource import DeviceMemoryResource @@ -76,6 +77,68 @@ register_mr_dealloc_callback(_mr_dealloc_callback) __all__ = ['Buffer', 'MemoryResource'] +# Memory Attribute Query Helpers +# ------------------------------ +cdef inline int _query_memory_attrs( + _MemAttrs& out, + cydriver.CUdeviceptr ptr +) except -1 nogil: + """Query memory attributes for a device pointer.""" + cdef unsigned int memory_type = 0 + cdef int is_managed = 0 + cdef int device_id = 0 + cdef cydriver.CUpointer_attribute[3] attrs = [ + cydriver.CUpointer_attribute.CU_POINTER_ATTRIBUTE_MEMORY_TYPE, + cydriver.CUpointer_attribute.CU_POINTER_ATTRIBUTE_IS_MANAGED, + cydriver.CUpointer_attribute.CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL, + ] + cdef uintptr_t[3] vals = [ + &memory_type, + &is_managed, + &device_id, + ] + + cdef cydriver.CUresult ret + ret = cydriver.cuPointerGetAttributes(3, attrs, vals, ptr) + if ret == cydriver.CUresult.CUDA_ERROR_NOT_INITIALIZED: + with cython.gil: + # Device class handles the cuInit call internally + Device() + ret = cydriver.cuPointerGetAttributes(3, attrs, vals, ptr) + HANDLE_RETURN(ret) + + # TODO: HMM/ATS-enabled sysmem should also report is_managed=True; the + # CU_POINTER_ATTRIBUTE_IS_MANAGED query does not capture that yet. + out.is_managed = is_managed != 0 + + if memory_type == 0: + # unregistered host pointer + out.is_host_accessible = True + out.is_device_accessible = False + out.device_id = -1 + elif ( + is_managed + or memory_type == cydriver.CUmemorytype.CU_MEMORYTYPE_HOST + ): + # Managed memory or pinned host memory + out.is_host_accessible = True + out.is_device_accessible = True + out.device_id = device_id + elif memory_type == cydriver.CUmemorytype.CU_MEMORYTYPE_DEVICE: + out.is_host_accessible = False + out.is_device_accessible = True + out.device_id = device_id + else: + with cython.gil: + raise ValueError(f"Unsupported memory type: {memory_type}") + return 0 + + +cdef inline void _init_memory_attrs(Buffer self): + """Initialize memory attributes by querying the pointer.""" + if not self._mem_attrs_inited.load(memory_order_acquire): + _query_memory_attrs(self._mem_attrs, as_cu(self._h_ptr)) + self._mem_attrs_inited.store(True, memory_order_release) cdef class Buffer: @@ -381,7 +444,7 @@ cdef class Buffer: """Return the device ordinal of this buffer.""" if self._memory_resource is not None: return self._memory_resource.device_id - _init_mem_attrs(self) + _init_memory_attrs(self) return self._mem_attrs.device_id @property @@ -416,7 +479,7 @@ cdef class Buffer: """Return True if this buffer can be accessed by the GPU, otherwise False.""" if self._memory_resource is not None: return self._memory_resource.is_device_accessible - _init_mem_attrs(self) + _init_memory_attrs(self) return self._mem_attrs.is_device_accessible @property @@ -424,13 +487,13 @@ cdef class Buffer: """Return True if this buffer can be accessed by the CPU, otherwise False.""" if self._memory_resource is not None: return self._memory_resource.is_host_accessible - _init_mem_attrs(self) + _init_memory_attrs(self) return self._mem_attrs.is_host_accessible @property def is_managed(self) -> bool: """Return True if this buffer is CUDA managed (unified) memory, otherwise False.""" - _init_mem_attrs(self) + _init_memory_attrs(self) if self._mem_attrs.is_managed: return True # Pool-allocated managed memory does not set CU_POINTER_ATTRIBUTE_IS_MANAGED, @@ -459,69 +522,6 @@ cdef class Buffer: return self._owner -# Memory Attribute Query Helpers -# ------------------------------ -cdef inline void _init_mem_attrs(Buffer self): - """Initialize memory attributes by querying the pointer.""" - if not self._mem_attrs_inited.load(memory_order_acquire): - _query_memory_attrs(self._mem_attrs, as_cu(self._h_ptr)) - self._mem_attrs_inited.store(True, memory_order_release) - - -cdef inline int _query_memory_attrs( - _MemAttrs& out, - cydriver.CUdeviceptr ptr -) except -1 nogil: - """Query memory attributes for a device pointer.""" - cdef unsigned int memory_type = 0 - cdef int is_managed = 0 - cdef int device_id = 0 - cdef cydriver.CUpointer_attribute attrs[3] - cdef uintptr_t vals[3] - - attrs[0] = cydriver.CUpointer_attribute.CU_POINTER_ATTRIBUTE_MEMORY_TYPE - attrs[1] = cydriver.CUpointer_attribute.CU_POINTER_ATTRIBUTE_IS_MANAGED - attrs[2] = cydriver.CUpointer_attribute.CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL - vals[0] = &memory_type - vals[1] = &is_managed - vals[2] = &device_id - - cdef cydriver.CUresult ret - ret = cydriver.cuPointerGetAttributes(3, attrs, vals, ptr) - if ret == cydriver.CUresult.CUDA_ERROR_NOT_INITIALIZED: - with cython.gil: - # Device class handles the cuInit call internally - Device() - ret = cydriver.cuPointerGetAttributes(3, attrs, vals, ptr) - HANDLE_RETURN(ret) - - # TODO: HMM/ATS-enabled sysmem should also report is_managed=True; the - # CU_POINTER_ATTRIBUTE_IS_MANAGED query does not capture that yet. - out.is_managed = is_managed != 0 - - if memory_type == 0: - # unregistered host pointer - out.is_host_accessible = True - out.is_device_accessible = False - out.device_id = -1 - elif ( - is_managed - or memory_type == cydriver.CUmemorytype.CU_MEMORYTYPE_HOST - ): - # Managed memory or pinned host memory - out.is_host_accessible = True - out.is_device_accessible = True - out.device_id = device_id - elif memory_type == cydriver.CUmemorytype.CU_MEMORYTYPE_DEVICE: - out.is_host_accessible = False - out.is_device_accessible = True - out.device_id = device_id - else: - with cython.gil: - raise ValueError(f"Unsupported memory type: {memory_type}") - return 0 - - cdef class MemoryResource: """Abstract base class for memory resources that manage allocation and deallocation of buffers. diff --git a/cuda_core/cuda/core/_memory/_device_memory_resource.pxd b/cuda_core/cuda/core/_memory/_device_memory_resource.pxd index 47e626e2435..1c3134876eb 100644 --- a/cuda_core/cuda/core/_memory/_device_memory_resource.pxd +++ b/cuda_core/cuda/core/_memory/_device_memory_resource.pxd @@ -3,7 +3,6 @@ # SPDX-License-Identifier: Apache-2.0 from cuda.core._memory._memory_pool cimport _MemPool -from cuda.core._memory._ipc cimport IPCDataForMR cdef class DeviceMemoryResource(_MemPool): diff --git a/cuda_core/cuda/core/_memory/_memory_pool.pxd b/cuda_core/cuda/core/_memory/_memory_pool.pxd index aa9cf833da3..3a6c3107cfd 100644 --- a/cuda_core/cuda/core/_memory/_memory_pool.pxd +++ b/cuda_core/cuda/core/_memory/_memory_pool.pxd @@ -41,13 +41,3 @@ cdef int MP_raise_release_threshold(_MemPool self) except? -1 # Buffer). Subclasses (e.g. ManagedMemoryResource) pass their own buffer # subclass so their `allocate` returns the typed object. cdef Buffer _MP_allocate(_MemPool self, size_t size, Stream stream, type cls = *) - - -cdef class _MemPoolAttributes: - cdef: - MemoryPoolHandle _h_pool - - @staticmethod - cdef _MemPoolAttributes _init(MemoryPoolHandle h_pool) - - cdef int _getattribute(self, cydriver.CUmemPool_attribute attr_enum, void* value) except? -1 diff --git a/cuda_core/cuda/core/_memory/_memory_pool.pyx b/cuda_core/cuda/core/_memory/_memory_pool.pyx index ddcac2d6063..cf7c48068f1 100644 --- a/cuda_core/cuda/core/_memory/_memory_pool.pyx +++ b/cuda_core/cuda/core/_memory/_memory_pool.pyx @@ -38,6 +38,8 @@ if TYPE_CHECKING: cdef class _MemPoolAttributes: """Provides access to memory pool attributes.""" + cdef: + MemoryPoolHandle _h_pool def __init__(self, *args, **kwargs) -> None: raise RuntimeError("_MemPoolAttributes cannot be instantiated directly. Please use MemoryResource APIs.") diff --git a/cuda_core/cuda/core/_memory/_pinned_memory_resource.pxd b/cuda_core/cuda/core/_memory/_pinned_memory_resource.pxd index fcfcfeb3465..41336d4f61a 100644 --- a/cuda_core/cuda/core/_memory/_pinned_memory_resource.pxd +++ b/cuda_core/cuda/core/_memory/_pinned_memory_resource.pxd @@ -1,9 +1,8 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # # SPDX-License-Identifier: Apache-2.0 from cuda.core._memory._memory_pool cimport _MemPool -from cuda.core._memory._ipc cimport IPCDataForMR cdef class PinnedMemoryResource(_MemPool): From fcc9decd1b2424de24a9d351bd1de02e7f69dc3d Mon Sep 17 00:00:00 2001 From: Michael Wang <13521008+isVoid@users.noreply.github.com> Date: Mon, 13 Jul 2026 09:08:05 -0700 Subject: [PATCH 19/25] Add Windows ARM64 build support (#2312) * Add native Windows ARM64 CUDA bindings support * Build cuda-core AOTI shim for Windows ARM64 --------- Co-authored-by: Michael Wang --- cuda_bindings/build_hooks.py | 5 ++++- cuda_core/setup.py | 10 +++++++--- 2 files changed, 11 insertions(+), 4 deletions(-) diff --git a/cuda_bindings/build_hooks.py b/cuda_bindings/build_hooks.py index a23d0949258..36ec44416f8 100644 --- a/cuda_bindings/build_hooks.py +++ b/cuda_bindings/build_hooks.py @@ -400,7 +400,10 @@ def _build_cuda_bindings(debug=False): os.path.dirname(sysconfig.get_path("include")), ] + include_path_list library_dirs = [sysconfig.get_path("platlib"), os.path.join(os.sys.prefix, "lib")] - cudalib_subdirs = [r"lib\x64"] if sys.platform == "win32" else ["lib64", "lib"] + if sys.platform == "win32": + cudalib_subdirs = [r"lib\arm64"] if sysconfig.get_platform() == "win-arm64" else [r"lib\x64"] + else: + cudalib_subdirs = ["lib64", "lib"] library_dirs.extend(os.path.join(cuda_path, subdir) for subdir in cudalib_subdirs) extra_compile_args = [] diff --git a/cuda_core/setup.py b/cuda_core/setup.py index bde1fe22fee..e0d745b1f21 100644 --- a/cuda_core/setup.py +++ b/cuda_core/setup.py @@ -27,7 +27,7 @@ def _ensure_compiler_initialized(compiler, plat_name): initialize(plat_name) -def _build_aoti_shim_lib(compiler): +def _build_aoti_shim_lib(compiler, plat_name): # Reuse setuptools' initialized MSVC compiler instead of rediscovering # lib.exe separately in the build backend. lib_exe = getattr(compiler, "lib", None) @@ -35,12 +35,16 @@ def _build_aoti_shim_lib(compiler): raise RuntimeError("MSVC compiler did not expose lib.exe after initialization.") _AOTI_SHIM_LIB_FILE.parent.mkdir(exist_ok=True) + machine = { + "win-amd64": "X64", + "win-arm64": "ARM64", + }.get(plat_name, "X64") compiler.spawn( [ lib_exe, f"/DEF:{_AOTI_SHIM_DEF_FILE}", f"/OUT:{_AOTI_SHIM_LIB_FILE}", - "/MACHINE:X64", + f"/MACHINE:{machine}", ] ) return str(_AOTI_SHIM_LIB_FILE) @@ -58,7 +62,7 @@ def _configure_windows_tensor_bridge(self): continue _ensure_compiler_initialized(self.compiler, self.plat_name) - shim_lib = _build_aoti_shim_lib(self.compiler) + shim_lib = _build_aoti_shim_lib(self.compiler, self.plat_name) link_args = list(ext.extra_link_args or []) if shim_lib not in link_args: ext.extra_link_args = [*link_args, shim_lib] From c000331de6c37aa4565af74b001271ffcf6d5c99 Mon Sep 17 00:00:00 2001 From: Michael Droettboom Date: Mon, 13 Jul 2026 12:15:13 -0400 Subject: [PATCH 20/25] Use enums to validate their own values (#2333) * Use enums to validate their own values * Fix for Python < 3.12 --- cuda_core/cuda/core/_device_resources.pyx | 8 ++--- .../core/_memory/_managed_memory_resource.pyx | 12 +++---- cuda_core/cuda/core/_utils/validators.py | 35 +++++++++++++++++++ cuda_core/cuda/core/graph/_graph_node.pyx | 5 ++- .../cuda/core/utils/_program_cache/_keys.py | 11 +++--- .../tests/graph/test_graph_definition.py | 2 +- cuda_core/tests/test_green_context.py | 2 +- cuda_core/tests/test_memory.py | 2 +- cuda_core/tests/test_program_cache.py | 4 ++- 9 files changed, 57 insertions(+), 24 deletions(-) create mode 100644 cuda_core/cuda/core/_utils/validators.py diff --git a/cuda_core/cuda/core/_device_resources.pyx b/cuda_core/cuda/core/_device_resources.pyx index 0c01956d2ea..26c8863e063 100644 --- a/cuda_core/cuda/core/_device_resources.pyx +++ b/cuda_core/cuda/core/_device_resources.pyx @@ -21,6 +21,7 @@ from cuda.core._resource_handles cimport ContextHandle, GreenCtxHandle, as_cu, g from cuda.core._utils.cuda_utils cimport check_or_create_options, HANDLE_RETURN from cuda.core._utils.cuda_utils import is_sequence from cuda.core._utils.version cimport cy_binding_version, cy_driver_version +from cuda.core._utils.validators import check_str_enum __all__ = [ @@ -147,11 +148,8 @@ cdef class WorkqueueResourceOptions: concurrency_limit: int | None = None def __post_init__(self): - if self.sharing_scope not in (None, "device_ctx", "green_ctx_balanced"): - raise ValueError( - f"Unknown sharing_scope: {self.sharing_scope!r}. " - "Expected 'device_ctx' or 'green_ctx_balanced'." - ) + from cuda.core.typing import WorkqueueSharingScopeType + check_str_enum(self.sharing_scope, WorkqueueSharingScopeType, allow_none=True) if self.concurrency_limit is not None and self.concurrency_limit < 1: raise ValueError( f"concurrency_limit must be >= 1, got {self.concurrency_limit}" diff --git a/cuda_core/cuda/core/_memory/_managed_memory_resource.pyx b/cuda_core/cuda/core/_memory/_managed_memory_resource.pyx index 41b7a992bed..d5a637a7b50 100644 --- a/cuda_core/cuda/core/_memory/_managed_memory_resource.pyx +++ b/cuda_core/cuda/core/_memory/_managed_memory_resource.pyx @@ -21,6 +21,9 @@ import warnings from cuda.core._memory._managed_buffer import ManagedBuffer from cuda.core.typing import ManagedMemoryLocationType +IF CUDA_CORE_BUILD_MAJOR >= 13: + from cuda.core._utils.validators import check_str_enum + if TYPE_CHECKING: from cuda.core.graph import GraphBuilder @@ -163,9 +166,6 @@ cdef class ManagedMemoryResource(_MemPool): IF CUDA_CORE_BUILD_MAJOR >= 13: - cdef tuple _VALID_LOCATION_TYPES = ("device", "host", "host_numa") - - cdef _resolve_preferred_location(ManagedMemoryResourceOptions opts): """Resolve preferred location options into driver and stored values. @@ -175,11 +175,7 @@ IF CUDA_CORE_BUILD_MAJOR >= 13: cdef object pref_loc = opts.preferred_location if opts is not None else None cdef object pref_type = opts.preferred_location_type if opts is not None else None - if pref_type is not None and pref_type not in _VALID_LOCATION_TYPES: - raise ValueError( - f"preferred_location_type must be one of {_VALID_LOCATION_TYPES!r} " - f"or None, got {pref_type!r}" - ) + check_str_enum(pref_type, ManagedMemoryLocationType, allow_none=True) if pref_type is None: # Legacy behavior diff --git a/cuda_core/cuda/core/_utils/validators.py b/cuda_core/cuda/core/_utils/validators.py new file mode 100644 index 00000000000..dac3d1c788e --- /dev/null +++ b/cuda_core/cuda/core/_utils/validators.py @@ -0,0 +1,35 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# SPDX-License-Identifier: Apache-2.0 + + +def format_or_list(values): + """Format an iterable of values as a human-readable ``A, B or C`` string. + + Each value is passed through :func:`repr`. A single value is returned + as-is; two values are joined with ``" or "``; three or more use a + comma-separated list with ``" or "`` before the last item. + """ + reprs = [repr(v) for v in values] + if len(reprs) <= 1: + return reprs[0] if reprs else "" + *head, tail = reprs + return ", ".join(head) + " or " + tail + + +def check_str_enum(value, enum_class, *, allow_none=False): + """Raise ValueError if *value* is not a member of *enum_class*. + + Derives the list of acceptable values from the enum itself so callers + do not need to maintain a parallel copy of the valid strings. + + If *allow_none* is True, ``None`` is also accepted and included in the + error message when an invalid value is provided. + """ + if allow_none and value is None: + return + if value not in {m.value for m in enum_class}: + valid = sorted(m.value for m in enum_class) + if allow_none: + valid = [None, *valid] + raise ValueError(f"{value!r} is not a valid {enum_class.__name__}. Must be {format_or_list(valid)}") diff --git a/cuda_core/cuda/core/graph/_graph_node.pyx b/cuda_core/cuda/core/graph/_graph_node.pyx index 077eff77ea0..0adf69ad4b4 100644 --- a/cuda_core/cuda/core/graph/_graph_node.pyx +++ b/cuda_core/cuda/core/graph/_graph_node.pyx @@ -65,6 +65,7 @@ import ctypes as ct import weakref from cuda.core.graph._adjacency_set_proxy import AdjacencySetProxy +from cuda.core._utils.validators import check_str_enum from cuda.core._utils.cuda_utils import driver from cuda.core.typing import GraphMemoryType @@ -787,6 +788,7 @@ cdef inline AllocNode GN_alloc(GraphNode self, size_t size, object device, alloc_params.poolProps.handleTypes = cydriver.CUmemAllocationHandleType.CU_MEM_HANDLE_TYPE_NONE alloc_params.bytesize = size + check_str_enum(memory_type_str, GraphMemoryType) if memory_type_str == "device": alloc_params.poolProps.allocType = cydriver.CUmemAllocationType.CU_MEM_ALLOCATION_TYPE_PINNED alloc_params.poolProps.location.type = cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_DEVICE @@ -802,9 +804,6 @@ cdef inline AllocNode GN_alloc(GraphNode self, size_t size, object device, alloc_params.poolProps.location.id = device_id ELSE: raise ValueError("memory_type='managed' requires CUDA 13.0 or later") - else: - raise ValueError(f"Invalid memory_type: {memory_type_str!r}. " - "Must be 'device', 'host', or 'managed'.") if access_descs.size() > 0: alloc_params.accessDescs = access_descs.data() diff --git a/cuda_core/cuda/core/utils/_program_cache/_keys.py b/cuda_core/cuda/core/utils/_program_cache/_keys.py index 668a26257fb..e170bc18131 100644 --- a/cuda_core/cuda/core/utils/_program_cache/_keys.py +++ b/cuda_core/cuda/core/utils/_program_cache/_keys.py @@ -33,11 +33,12 @@ from cuda.core._utils.cuda_utils import ( nvrtc as _nvrtc, ) +from cuda.core._utils.validators import check_str_enum, format_or_list +from cuda.core.typing import SourceCodeType # Bump when the key schema changes in a way that invalidates existing caches. _KEY_SCHEMA_VERSION = 2 -_VALID_CODE_TYPES = frozenset({"c++", "ptx", "nvvm"}) _VALID_TARGET_TYPES = frozenset({"ptx", "cubin", "ltoir"}) # code_type -> allowed target_type set, mirroring Program.compile's @@ -752,10 +753,12 @@ def make_program_cache_key( # the lowercase form. code_type = code_type.lower() if isinstance(code_type, str) else code_type target_type = target_type.lower() if isinstance(target_type, str) else target_type - if code_type not in _VALID_CODE_TYPES: - raise ValueError(f"code_type={code_type!r} is not supported (must be one of {sorted(_VALID_CODE_TYPES)})") + check_str_enum(code_type, SourceCodeType) if target_type not in _VALID_TARGET_TYPES: - raise ValueError(f"target_type={target_type!r} is not supported (must be one of {sorted(_VALID_TARGET_TYPES)})") + raise ValueError( + f"target_type={target_type!r} is not supported by the program cache " + f"(must be {format_or_list(sorted(_VALID_TARGET_TYPES))})" + ) supported_for_code = _SUPPORTED_TARGETS_BY_CODE_TYPE[code_type] if target_type not in supported_for_code: raise ValueError( diff --git a/cuda_core/tests/graph/test_graph_definition.py b/cuda_core/tests/graph/test_graph_definition.py index da78bea577f..50d4b4ac253 100644 --- a/cuda_core/tests/graph/test_graph_definition.py +++ b/cuda_core/tests/graph/test_graph_definition.py @@ -833,7 +833,7 @@ def test_alloc_free_chain(sample_graphdef): def test_alloc_memory_type_invalid(sample_graphdef): """Invalid memory type raises ValueError.""" - with pytest.raises(ValueError, match="Invalid memory_type"): + with pytest.raises(ValueError, match="'invalid' is not a valid GraphMemoryType. Must be "): sample_graphdef.allocate(ALLOC_SIZE, memory_type="invalid") diff --git a/cuda_core/tests/test_green_context.py b/cuda_core/tests/test_green_context.py index effa7167371..999627a901a 100644 --- a/cuda_core/tests/test_green_context.py +++ b/cuda_core/tests/test_green_context.py @@ -252,7 +252,7 @@ def test_device_id_matches_source_multi_gpu(self): assert wq1.device.device_id == 1 def test_invalid_scope_raises_at_construction(self): - with pytest.raises(ValueError, match="Unknown sharing_scope"): + with pytest.raises(ValueError, match="'bogus' is not a valid WorkqueueSharingScopeType. Must be "): WorkqueueResourceOptions(sharing_scope="bogus") def test_configure_concurrency_limit(self, wq_resource): diff --git a/cuda_core/tests/test_memory.py b/cuda_core/tests/test_memory.py index f53e8244328..5ef48919a50 100644 --- a/cuda_core/tests/test_memory.py +++ b/cuda_core/tests/test_memory.py @@ -1278,7 +1278,7 @@ def test_managed_memory_resource_preferred_location_validation(init_cuda): device.set_current() # Invalid preferred_location_type - with pytest.raises(ValueError, match="preferred_location_type must be one of"): + with pytest.raises(ValueError, match="'invalid' is not a valid ManagedMemoryLocationType. Must be "): ManagedMemoryResource( ManagedMemoryResourceOptions( preferred_location_type="invalid", diff --git a/cuda_core/tests/test_program_cache.py b/cuda_core/tests/test_program_cache.py index 3bb579e2fe8..6b3f143a346 100644 --- a/cuda_core/tests/test_program_cache.py +++ b/cuda_core/tests/test_program_cache.py @@ -321,7 +321,9 @@ def test_make_program_cache_key_rejects_extra_sources_outside_nvvm(code_type, co @pytest.mark.parametrize( "kwargs, exc_type, match", [ - pytest.param({"code_type": "fortran"}, ValueError, "code_type", id="unknown_code_type"), + pytest.param( + {"code_type": "fortran"}, ValueError, "'fortran' is not a valid SourceCodeType", id="unknown_code_type" + ), pytest.param({"target_type": "exe"}, ValueError, "target_type", id="unknown_target_type"), pytest.param({"code": 12345}, TypeError, "code", id="non_str_bytes_code"), # Backend-specific target matrix -- Program.compile rejects these From ffbdc7b429383ed1d4ef13f870be6c825a921d51 Mon Sep 17 00:00:00 2001 From: Michael Droettboom Date: Mon, 13 Jul 2026 17:29:21 -0400 Subject: [PATCH 21/25] Generator changes (#2348) * Generator changes * Fix nvml.pyx content --- .../cuda/bindings/_internal/_fast_enum.py | 4 +- .../cuda/bindings/_internal/cudla_linux.pyx | 183 +- .../cuda/bindings/_internal/cudla_windows.pyx | 178 +- .../cuda/bindings/_internal/cufile_linux.pyx | 370 ++- .../cuda/bindings/_internal/driver_linux.pyx | 2194 ++++++++-------- .../bindings/_internal/driver_windows.pyx | 2213 ++++++++--------- .../bindings/_internal/nvfatbin_linux.pyx | 177 +- .../bindings/_internal/nvfatbin_windows.pyx | 173 +- .../bindings/_internal/nvjitlink_linux.pyx | 201 +- .../bindings/_internal/nvjitlink_windows.pyx | 189 +- .../cuda/bindings/_internal/nvml_linux.pyx | 2212 ++++++++-------- .../cuda/bindings/_internal/nvml_windows.pyx | 1527 ++++++------ .../cuda/bindings/_internal/nvrtc_linux.pyx | 279 +-- .../cuda/bindings/_internal/nvrtc_windows.pyx | 240 +- .../cuda/bindings/_internal/nvvm_linux.pyx | 190 +- .../cuda/bindings/_internal/nvvm_windows.pyx | 181 +- cuda_bindings/cuda/bindings/cudla.pyx | 16 +- cuda_bindings/cuda/bindings/cufile.pyx | 13 +- cuda_bindings/cuda/bindings/cycufile.pyx | 14 +- cuda_bindings/cuda/bindings/nvfatbin.pyx | 5 +- cuda_bindings/cuda/bindings/nvjitlink.pyx | 5 +- cuda_bindings/cuda/bindings/nvml.pyx | 12 +- cuda_bindings/cuda/bindings/nvvm.pyx | 10 +- 23 files changed, 4967 insertions(+), 5619 deletions(-) diff --git a/cuda_bindings/cuda/bindings/_internal/_fast_enum.py b/cuda_bindings/cuda/bindings/_internal/_fast_enum.py index cb3e6e900a3..63a2336da1a 100644 --- a/cuda_bindings/cuda/bindings/_internal/_fast_enum.py +++ b/cuda_bindings/cuda/bindings/_internal/_fast_enum.py @@ -1,10 +1,8 @@ # SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: Apache-2.0 -# -# This code was automatically generated across versions from 12.0.1 to 13.3.0. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=5791f341ee9bb6573f42300fbed50cc52fc5e808c1d6bb9156e6aabb9db29b17 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=581469c1fadb5f72c43b478d73f2b905562136c8723a25e2f4240b5b681e2894 """ This is a replacement for the stdlib enum.IntEnum. diff --git a/cuda_bindings/cuda/bindings/_internal/cudla_linux.pyx b/cuda_bindings/cuda/bindings/_internal/cudla_linux.pyx index 93ebdfa927d..7c4c9d311e1 100644 --- a/cuda_bindings/cuda/bindings/_internal/cudla_linux.pyx +++ b/cuda_bindings/cuda/bindings/_internal/cudla_linux.pyx @@ -2,63 +2,35 @@ # SPDX-License-Identifier: Apache-2.0 # This code was automatically generated across versions from 1.5.0 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=a7e70bc7234821ae1f02306321604d7605aee20e0fde536def5edd52263be5de -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=2b56e5f08b7806fe10648817d36d96ce420cb5a8329615fb283f71119128d090 -from libc.stdint cimport intptr_t, uintptr_t -import threading -from .utils import FunctionNotFoundError, NotSupportedError - -from cuda.pathfinder import load_nvidia_dynamic_lib - - -############################################################################### -# Extern -############################################################################### - -# You must 'from .utils import NotSupportedError' before using this template +# <<<< PREAMBLE CONTENT >>>> -cdef extern from "" nogil: - void* dlopen(const char*, int) - char* dlerror() - void* dlsym(void*, const char*) - int dlclose(void*) +cdef extern from "": + void* _cyb_dlsym "dlsym"(void*, const char*) nogil + const void * _cyb_RTLD_DEFAULT "RTLD_DEFAULT" - enum: - RTLD_LAZY - RTLD_NOW - RTLD_GLOBAL - RTLD_LOCAL +from libc.stdint cimport intptr_t as _cyb_intptr_t - const void* RTLD_DEFAULT 'RTLD_DEFAULT' +import threading as _cyb_threading -cdef int get_cuda_version(): - cdef void* handle = NULL - cdef int err, driver_ver = 0 +cdef bint _cyb___py_cudla_init = False +cdef dict _cyb_func_ptrs = None +cdef object _cyb_symbol_lock = _cyb_threading.Lock() - # Load driver to check version - handle = dlopen('libcuda.so.1', RTLD_NOW | RTLD_GLOBAL) - if handle == NULL: - err_msg = dlerror() - raise NotSupportedError(f'CUDA driver is not found ({err_msg.decode()})') - cuDriverGetVersion = dlsym(handle, "cuDriverGetVersion") - if cuDriverGetVersion == NULL: - raise RuntimeError('Did not find cuDriverGetVersion symbol in libcuda.so.1') - err = (cuDriverGetVersion)(&driver_ver) - if err != 0: - raise RuntimeError(f'cuDriverGetVersion returned error code {err}') +# <<<< END OF PREAMBLE CONTENT >>>> - return driver_ver +from libc.stdint cimport uintptr_t +from .utils import FunctionNotFoundError, NotSupportedError +from cuda.pathfinder import load_nvidia_dynamic_lib ############################################################################### # Wrapper init ############################################################################### -cdef object __symbol_lock = threading.Lock() -cdef bint __py_cudla_init = False - cdef void* __cudlaGetVersion = NULL cdef void* __cudlaDeviceGetCount = NULL cdef void* __cudlaCreateDevice = NULL @@ -73,183 +45,174 @@ cdef void* __cudlaGetLastError = NULL cdef void* __cudlaDestroyDevice = NULL cdef void* __cudlaSetTaskTimeoutInMs = NULL - -cdef void* load_library() except* with gil: - cdef uintptr_t handle = load_nvidia_dynamic_lib("cudla")._handle_uint - return handle - - cdef int _init_cudla() except -1 nogil: - global __py_cudla_init + global _cyb___py_cudla_init cdef void* handle = NULL + with gil, _cyb_symbol_lock: + if _cyb___py_cudla_init: return 0 - with gil, __symbol_lock: - # Recheck the flag after obtaining the locks - if __py_cudla_init: - return 0 - - # Load function global __cudlaGetVersion - __cudlaGetVersion = dlsym(RTLD_DEFAULT, 'cudlaGetVersion') + __cudlaGetVersion = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cudlaGetVersion') if __cudlaGetVersion == NULL: if handle == NULL: handle = load_library() - __cudlaGetVersion = dlsym(handle, 'cudlaGetVersion') + __cudlaGetVersion = _cyb_dlsym(handle, 'cudlaGetVersion') global __cudlaDeviceGetCount - __cudlaDeviceGetCount = dlsym(RTLD_DEFAULT, 'cudlaDeviceGetCount') + __cudlaDeviceGetCount = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cudlaDeviceGetCount') if __cudlaDeviceGetCount == NULL: if handle == NULL: handle = load_library() - __cudlaDeviceGetCount = dlsym(handle, 'cudlaDeviceGetCount') + __cudlaDeviceGetCount = _cyb_dlsym(handle, 'cudlaDeviceGetCount') global __cudlaCreateDevice - __cudlaCreateDevice = dlsym(RTLD_DEFAULT, 'cudlaCreateDevice') + __cudlaCreateDevice = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cudlaCreateDevice') if __cudlaCreateDevice == NULL: if handle == NULL: handle = load_library() - __cudlaCreateDevice = dlsym(handle, 'cudlaCreateDevice') + __cudlaCreateDevice = _cyb_dlsym(handle, 'cudlaCreateDevice') global __cudlaMemRegister - __cudlaMemRegister = dlsym(RTLD_DEFAULT, 'cudlaMemRegister') + __cudlaMemRegister = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cudlaMemRegister') if __cudlaMemRegister == NULL: if handle == NULL: handle = load_library() - __cudlaMemRegister = dlsym(handle, 'cudlaMemRegister') + __cudlaMemRegister = _cyb_dlsym(handle, 'cudlaMemRegister') global __cudlaModuleLoadFromMemory - __cudlaModuleLoadFromMemory = dlsym(RTLD_DEFAULT, 'cudlaModuleLoadFromMemory') + __cudlaModuleLoadFromMemory = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cudlaModuleLoadFromMemory') if __cudlaModuleLoadFromMemory == NULL: if handle == NULL: handle = load_library() - __cudlaModuleLoadFromMemory = dlsym(handle, 'cudlaModuleLoadFromMemory') + __cudlaModuleLoadFromMemory = _cyb_dlsym(handle, 'cudlaModuleLoadFromMemory') global __cudlaModuleGetAttributes - __cudlaModuleGetAttributes = dlsym(RTLD_DEFAULT, 'cudlaModuleGetAttributes') + __cudlaModuleGetAttributes = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cudlaModuleGetAttributes') if __cudlaModuleGetAttributes == NULL: if handle == NULL: handle = load_library() - __cudlaModuleGetAttributes = dlsym(handle, 'cudlaModuleGetAttributes') + __cudlaModuleGetAttributes = _cyb_dlsym(handle, 'cudlaModuleGetAttributes') global __cudlaModuleUnload - __cudlaModuleUnload = dlsym(RTLD_DEFAULT, 'cudlaModuleUnload') + __cudlaModuleUnload = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cudlaModuleUnload') if __cudlaModuleUnload == NULL: if handle == NULL: handle = load_library() - __cudlaModuleUnload = dlsym(handle, 'cudlaModuleUnload') + __cudlaModuleUnload = _cyb_dlsym(handle, 'cudlaModuleUnload') global __cudlaSubmitTask - __cudlaSubmitTask = dlsym(RTLD_DEFAULT, 'cudlaSubmitTask') + __cudlaSubmitTask = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cudlaSubmitTask') if __cudlaSubmitTask == NULL: if handle == NULL: handle = load_library() - __cudlaSubmitTask = dlsym(handle, 'cudlaSubmitTask') + __cudlaSubmitTask = _cyb_dlsym(handle, 'cudlaSubmitTask') global __cudlaDeviceGetAttribute - __cudlaDeviceGetAttribute = dlsym(RTLD_DEFAULT, 'cudlaDeviceGetAttribute') + __cudlaDeviceGetAttribute = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cudlaDeviceGetAttribute') if __cudlaDeviceGetAttribute == NULL: if handle == NULL: handle = load_library() - __cudlaDeviceGetAttribute = dlsym(handle, 'cudlaDeviceGetAttribute') + __cudlaDeviceGetAttribute = _cyb_dlsym(handle, 'cudlaDeviceGetAttribute') global __cudlaMemUnregister - __cudlaMemUnregister = dlsym(RTLD_DEFAULT, 'cudlaMemUnregister') + __cudlaMemUnregister = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cudlaMemUnregister') if __cudlaMemUnregister == NULL: if handle == NULL: handle = load_library() - __cudlaMemUnregister = dlsym(handle, 'cudlaMemUnregister') + __cudlaMemUnregister = _cyb_dlsym(handle, 'cudlaMemUnregister') global __cudlaGetLastError - __cudlaGetLastError = dlsym(RTLD_DEFAULT, 'cudlaGetLastError') + __cudlaGetLastError = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cudlaGetLastError') if __cudlaGetLastError == NULL: if handle == NULL: handle = load_library() - __cudlaGetLastError = dlsym(handle, 'cudlaGetLastError') + __cudlaGetLastError = _cyb_dlsym(handle, 'cudlaGetLastError') global __cudlaDestroyDevice - __cudlaDestroyDevice = dlsym(RTLD_DEFAULT, 'cudlaDestroyDevice') + __cudlaDestroyDevice = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cudlaDestroyDevice') if __cudlaDestroyDevice == NULL: if handle == NULL: handle = load_library() - __cudlaDestroyDevice = dlsym(handle, 'cudlaDestroyDevice') + __cudlaDestroyDevice = _cyb_dlsym(handle, 'cudlaDestroyDevice') global __cudlaSetTaskTimeoutInMs - __cudlaSetTaskTimeoutInMs = dlsym(RTLD_DEFAULT, 'cudlaSetTaskTimeoutInMs') + __cudlaSetTaskTimeoutInMs = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cudlaSetTaskTimeoutInMs') if __cudlaSetTaskTimeoutInMs == NULL: if handle == NULL: handle = load_library() - __cudlaSetTaskTimeoutInMs = dlsym(handle, 'cudlaSetTaskTimeoutInMs') + __cudlaSetTaskTimeoutInMs = _cyb_dlsym(handle, 'cudlaSetTaskTimeoutInMs') - __py_cudla_init = True + _cyb___py_cudla_init = True return 0 - cdef inline int _check_or_init_cudla() except -1 nogil: - if __py_cudla_init: + if _cyb___py_cudla_init: return 0 return _init_cudla() -cdef dict func_ptrs = None - - cpdef dict _inspect_function_pointers(): - global func_ptrs - if func_ptrs is not None: - return func_ptrs + global _cyb_func_ptrs + if _cyb_func_ptrs is not None: + return _cyb_func_ptrs _check_or_init_cudla() cdef dict data = {} - global __cudlaGetVersion - data["__cudlaGetVersion"] = __cudlaGetVersion + data["__cudlaGetVersion"] = <_cyb_intptr_t>__cudlaGetVersion global __cudlaDeviceGetCount - data["__cudlaDeviceGetCount"] = __cudlaDeviceGetCount + data["__cudlaDeviceGetCount"] = <_cyb_intptr_t>__cudlaDeviceGetCount global __cudlaCreateDevice - data["__cudlaCreateDevice"] = __cudlaCreateDevice + data["__cudlaCreateDevice"] = <_cyb_intptr_t>__cudlaCreateDevice global __cudlaMemRegister - data["__cudlaMemRegister"] = __cudlaMemRegister + data["__cudlaMemRegister"] = <_cyb_intptr_t>__cudlaMemRegister global __cudlaModuleLoadFromMemory - data["__cudlaModuleLoadFromMemory"] = __cudlaModuleLoadFromMemory + data["__cudlaModuleLoadFromMemory"] = <_cyb_intptr_t>__cudlaModuleLoadFromMemory global __cudlaModuleGetAttributes - data["__cudlaModuleGetAttributes"] = __cudlaModuleGetAttributes + data["__cudlaModuleGetAttributes"] = <_cyb_intptr_t>__cudlaModuleGetAttributes global __cudlaModuleUnload - data["__cudlaModuleUnload"] = __cudlaModuleUnload + data["__cudlaModuleUnload"] = <_cyb_intptr_t>__cudlaModuleUnload global __cudlaSubmitTask - data["__cudlaSubmitTask"] = __cudlaSubmitTask + data["__cudlaSubmitTask"] = <_cyb_intptr_t>__cudlaSubmitTask global __cudlaDeviceGetAttribute - data["__cudlaDeviceGetAttribute"] = __cudlaDeviceGetAttribute + data["__cudlaDeviceGetAttribute"] = <_cyb_intptr_t>__cudlaDeviceGetAttribute global __cudlaMemUnregister - data["__cudlaMemUnregister"] = __cudlaMemUnregister + data["__cudlaMemUnregister"] = <_cyb_intptr_t>__cudlaMemUnregister global __cudlaGetLastError - data["__cudlaGetLastError"] = __cudlaGetLastError + data["__cudlaGetLastError"] = <_cyb_intptr_t>__cudlaGetLastError global __cudlaDestroyDevice - data["__cudlaDestroyDevice"] = __cudlaDestroyDevice + data["__cudlaDestroyDevice"] = <_cyb_intptr_t>__cudlaDestroyDevice global __cudlaSetTaskTimeoutInMs - data["__cudlaSetTaskTimeoutInMs"] = __cudlaSetTaskTimeoutInMs - - func_ptrs = data + data["__cudlaSetTaskTimeoutInMs"] = <_cyb_intptr_t>__cudlaSetTaskTimeoutInMs + _cyb_func_ptrs = data return data cpdef _inspect_function_pointer(str name): - global func_ptrs - if func_ptrs is None: - func_ptrs = _inspect_function_pointers() - return func_ptrs[name] + global _cyb_func_ptrs + if _cyb_func_ptrs is None: + _cyb_func_ptrs = _inspect_function_pointers() + return _cyb_func_ptrs[name] + + + + +cdef void* load_library() except* with gil: + cdef uintptr_t handle = load_nvidia_dynamic_lib("cudla")._handle_uint + return handle ############################################################################### diff --git a/cuda_bindings/cuda/bindings/_internal/cudla_windows.pyx b/cuda_bindings/cuda/bindings/_internal/cudla_windows.pyx index 9a5313639e4..333ac59e92d 100644 --- a/cuda_bindings/cuda/bindings/_internal/cudla_windows.pyx +++ b/cuda_bindings/cuda/bindings/_internal/cudla_windows.pyx @@ -2,80 +2,36 @@ # SPDX-License-Identifier: Apache-2.0 # This code was automatically generated across versions from 1.5.0 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=2f2d196de722c29b044dff6aed4e22bd72347a0890d30c885d35780882c6800f -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=43403925d332dc0474938eb5f6b5d58c648884b9f056c1b319a515281b36757e -from libc.stdint cimport intptr_t -import threading -from .utils import FunctionNotFoundError, NotSupportedError +# <<<< PREAMBLE CONTENT >>>> -from cuda.pathfinder import load_nvidia_dynamic_lib +cdef extern from "": + ctypedef void* HMODULE + void* _cyb_GetProcAddress "GetProcAddress"(HMODULE, const char*) nogil -from libc.stddef cimport wchar_t -from libc.stdint cimport uintptr_t -from cpython cimport PyUnicode_AsWideCharString, PyMem_Free +from libc.stdint cimport intptr_t as _cyb_intptr_t -# You must 'from .utils import NotSupportedError' before using this template +import threading as _cyb_threading -cdef extern from "windows.h" nogil: - ctypedef void* HMODULE - ctypedef void* HANDLE - ctypedef void* FARPROC - ctypedef unsigned long DWORD - ctypedef const wchar_t *LPCWSTR - ctypedef const char *LPCSTR - - cdef DWORD LOAD_LIBRARY_SEARCH_SYSTEM32 = 0x00000800 - cdef DWORD LOAD_LIBRARY_SEARCH_DEFAULT_DIRS = 0x00001000 - cdef DWORD LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR = 0x00000100 - - HMODULE _LoadLibraryExW "LoadLibraryExW"( - LPCWSTR lpLibFileName, - HANDLE hFile, - DWORD dwFlags - ) - - FARPROC _GetProcAddress "GetProcAddress"(HMODULE hModule, LPCSTR lpProcName) - -cdef inline uintptr_t LoadLibraryExW(str path, HANDLE hFile, DWORD dwFlags): - cdef uintptr_t result - cdef wchar_t* wpath = PyUnicode_AsWideCharString(path, NULL) - with nogil: - result = _LoadLibraryExW( - wpath, - hFile, - dwFlags - ) - PyMem_Free(wpath) - return result - -cdef inline void *GetProcAddress(uintptr_t hModule, const char* lpProcName) nogil: - return _GetProcAddress(hModule, lpProcName) - -cdef int get_cuda_version(): - cdef int err, driver_ver = 0 - - # Load driver to check version - handle = LoadLibraryExW("nvcuda.dll", NULL, LOAD_LIBRARY_SEARCH_SYSTEM32) - if handle == 0: - raise NotSupportedError('CUDA driver is not found') - cuDriverGetVersion = GetProcAddress(handle, 'cuDriverGetVersion') - if cuDriverGetVersion == NULL: - raise RuntimeError('Did not find cuDriverGetVersion symbol in nvcuda.dll') - err = (cuDriverGetVersion)(&driver_ver) - if err != 0: - raise RuntimeError(f'cuDriverGetVersion returned error code {err}') - - return driver_ver +cdef bint _cyb___py_cudla_init = False +cdef dict _cyb_func_ptrs = None +cdef object _cyb_symbol_lock = _cyb_threading.Lock() + +# <<<< END OF PREAMBLE CONTENT >>>> +from libc.stdint cimport uintptr_t + +from .utils import FunctionNotFoundError, NotSupportedError + +from cuda.pathfinder import load_nvidia_dynamic_lib ############################################################################### # Wrapper init ############################################################################### -cdef object __symbol_lock = threading.Lock() -cdef bint __py_cudla_init = False cdef void* __cudlaGetVersion = NULL cdef void* __cudlaDeviceGetCount = NULL @@ -91,128 +47,124 @@ cdef void* __cudlaGetLastError = NULL cdef void* __cudlaDestroyDevice = NULL cdef void* __cudlaSetTaskTimeoutInMs = NULL - cdef int _init_cudla() except -1 nogil: - global __py_cudla_init - - with gil, __symbol_lock: - # Recheck the flag after obtaining the locks - if __py_cudla_init: - return 0 + global _cyb___py_cudla_init - # Load library - handle = load_nvidia_dynamic_lib("cudla")._handle_uint + cdef int err + cdef uintptr_t handle + with gil, _cyb_symbol_lock: + if _cyb___py_cudla_init: return 0 - # Load function + handle = load_library() global __cudlaGetVersion - __cudlaGetVersion = GetProcAddress(handle, 'cudlaGetVersion') + __cudlaGetVersion = _cyb_GetProcAddress(handle, 'cudlaGetVersion') global __cudlaDeviceGetCount - __cudlaDeviceGetCount = GetProcAddress(handle, 'cudlaDeviceGetCount') + __cudlaDeviceGetCount = _cyb_GetProcAddress(handle, 'cudlaDeviceGetCount') global __cudlaCreateDevice - __cudlaCreateDevice = GetProcAddress(handle, 'cudlaCreateDevice') + __cudlaCreateDevice = _cyb_GetProcAddress(handle, 'cudlaCreateDevice') global __cudlaMemRegister - __cudlaMemRegister = GetProcAddress(handle, 'cudlaMemRegister') + __cudlaMemRegister = _cyb_GetProcAddress(handle, 'cudlaMemRegister') global __cudlaModuleLoadFromMemory - __cudlaModuleLoadFromMemory = GetProcAddress(handle, 'cudlaModuleLoadFromMemory') + __cudlaModuleLoadFromMemory = _cyb_GetProcAddress(handle, 'cudlaModuleLoadFromMemory') global __cudlaModuleGetAttributes - __cudlaModuleGetAttributes = GetProcAddress(handle, 'cudlaModuleGetAttributes') + __cudlaModuleGetAttributes = _cyb_GetProcAddress(handle, 'cudlaModuleGetAttributes') global __cudlaModuleUnload - __cudlaModuleUnload = GetProcAddress(handle, 'cudlaModuleUnload') + __cudlaModuleUnload = _cyb_GetProcAddress(handle, 'cudlaModuleUnload') global __cudlaSubmitTask - __cudlaSubmitTask = GetProcAddress(handle, 'cudlaSubmitTask') + __cudlaSubmitTask = _cyb_GetProcAddress(handle, 'cudlaSubmitTask') global __cudlaDeviceGetAttribute - __cudlaDeviceGetAttribute = GetProcAddress(handle, 'cudlaDeviceGetAttribute') + __cudlaDeviceGetAttribute = _cyb_GetProcAddress(handle, 'cudlaDeviceGetAttribute') global __cudlaMemUnregister - __cudlaMemUnregister = GetProcAddress(handle, 'cudlaMemUnregister') + __cudlaMemUnregister = _cyb_GetProcAddress(handle, 'cudlaMemUnregister') global __cudlaGetLastError - __cudlaGetLastError = GetProcAddress(handle, 'cudlaGetLastError') + __cudlaGetLastError = _cyb_GetProcAddress(handle, 'cudlaGetLastError') global __cudlaDestroyDevice - __cudlaDestroyDevice = GetProcAddress(handle, 'cudlaDestroyDevice') + __cudlaDestroyDevice = _cyb_GetProcAddress(handle, 'cudlaDestroyDevice') global __cudlaSetTaskTimeoutInMs - __cudlaSetTaskTimeoutInMs = GetProcAddress(handle, 'cudlaSetTaskTimeoutInMs') + __cudlaSetTaskTimeoutInMs = _cyb_GetProcAddress(handle, 'cudlaSetTaskTimeoutInMs') - __py_cudla_init = True + _cyb___py_cudla_init = True return 0 - cdef inline int _check_or_init_cudla() except -1 nogil: - if __py_cudla_init: + if _cyb___py_cudla_init: return 0 return _init_cudla() -cdef dict func_ptrs = None - - cpdef dict _inspect_function_pointers(): - global func_ptrs - if func_ptrs is not None: - return func_ptrs + global _cyb_func_ptrs + if _cyb_func_ptrs is not None: + return _cyb_func_ptrs _check_or_init_cudla() cdef dict data = {} - global __cudlaGetVersion - data["__cudlaGetVersion"] = __cudlaGetVersion + data["__cudlaGetVersion"] = <_cyb_intptr_t>__cudlaGetVersion global __cudlaDeviceGetCount - data["__cudlaDeviceGetCount"] = __cudlaDeviceGetCount + data["__cudlaDeviceGetCount"] = <_cyb_intptr_t>__cudlaDeviceGetCount global __cudlaCreateDevice - data["__cudlaCreateDevice"] = __cudlaCreateDevice + data["__cudlaCreateDevice"] = <_cyb_intptr_t>__cudlaCreateDevice global __cudlaMemRegister - data["__cudlaMemRegister"] = __cudlaMemRegister + data["__cudlaMemRegister"] = <_cyb_intptr_t>__cudlaMemRegister global __cudlaModuleLoadFromMemory - data["__cudlaModuleLoadFromMemory"] = __cudlaModuleLoadFromMemory + data["__cudlaModuleLoadFromMemory"] = <_cyb_intptr_t>__cudlaModuleLoadFromMemory global __cudlaModuleGetAttributes - data["__cudlaModuleGetAttributes"] = __cudlaModuleGetAttributes + data["__cudlaModuleGetAttributes"] = <_cyb_intptr_t>__cudlaModuleGetAttributes global __cudlaModuleUnload - data["__cudlaModuleUnload"] = __cudlaModuleUnload + data["__cudlaModuleUnload"] = <_cyb_intptr_t>__cudlaModuleUnload global __cudlaSubmitTask - data["__cudlaSubmitTask"] = __cudlaSubmitTask + data["__cudlaSubmitTask"] = <_cyb_intptr_t>__cudlaSubmitTask global __cudlaDeviceGetAttribute - data["__cudlaDeviceGetAttribute"] = __cudlaDeviceGetAttribute + data["__cudlaDeviceGetAttribute"] = <_cyb_intptr_t>__cudlaDeviceGetAttribute global __cudlaMemUnregister - data["__cudlaMemUnregister"] = __cudlaMemUnregister + data["__cudlaMemUnregister"] = <_cyb_intptr_t>__cudlaMemUnregister global __cudlaGetLastError - data["__cudlaGetLastError"] = __cudlaGetLastError + data["__cudlaGetLastError"] = <_cyb_intptr_t>__cudlaGetLastError global __cudlaDestroyDevice - data["__cudlaDestroyDevice"] = __cudlaDestroyDevice + data["__cudlaDestroyDevice"] = <_cyb_intptr_t>__cudlaDestroyDevice global __cudlaSetTaskTimeoutInMs - data["__cudlaSetTaskTimeoutInMs"] = __cudlaSetTaskTimeoutInMs - - func_ptrs = data + data["__cudlaSetTaskTimeoutInMs"] = <_cyb_intptr_t>__cudlaSetTaskTimeoutInMs + _cyb_func_ptrs = data return data cpdef _inspect_function_pointer(str name): - global func_ptrs - if func_ptrs is None: - func_ptrs = _inspect_function_pointers() - return func_ptrs[name] + global _cyb_func_ptrs + if _cyb_func_ptrs is None: + _cyb_func_ptrs = _inspect_function_pointers() + return _cyb_func_ptrs[name] + + + + +cdef uintptr_t load_library() except* with gil: + return load_nvidia_dynamic_lib("cudla")._handle_uint ############################################################################### diff --git a/cuda_bindings/cuda/bindings/_internal/cufile_linux.pyx b/cuda_bindings/cuda/bindings/_internal/cufile_linux.pyx index 0917a2b368b..46c8928d0ba 100644 --- a/cuda_bindings/cuda/bindings/_internal/cufile_linux.pyx +++ b/cuda_bindings/cuda/bindings/_internal/cufile_linux.pyx @@ -3,64 +3,36 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.9.1 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=ae15aefcbc4ccf2d415fb5d6436ae854690559f5561704523ba7d6f45abfc592 -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=b43946a1b7b010b7d9ee95ed67723e3dfc54b46a6dc68829e936ffad6ba852dc -from libc.stdint cimport intptr_t, uintptr_t -import threading -from .utils import FunctionNotFoundError, NotSupportedError - -from cuda.pathfinder import load_nvidia_dynamic_lib - -import cython - - -############################################################################### -# Extern -############################################################################### +# <<<< PREAMBLE CONTENT >>>> -# You must 'from .utils import NotSupportedError' before using this template +cdef extern from "": + void* _cyb_dlsym "dlsym"(void*, const char*) nogil + const void * _cyb_RTLD_DEFAULT "RTLD_DEFAULT" -cdef extern from "" nogil: - void* dlopen(const char*, int) - char* dlerror() - void* dlsym(void*, const char*) - int dlclose(void*) +cimport cython as _cyb_cython +from libc.stdint cimport intptr_t as _cyb_intptr_t - enum: - RTLD_LAZY - RTLD_NOW - RTLD_GLOBAL - RTLD_LOCAL +import threading as _cyb_threading - const void* RTLD_DEFAULT 'RTLD_DEFAULT' +cdef bint _cyb___py_cufile_init = False +cdef dict _cyb_func_ptrs = None +cdef object _cyb_symbol_lock = _cyb_threading.Lock() -cdef int get_cuda_version(): - cdef void* handle = NULL - cdef int err, driver_ver = 0 - - # Load driver to check version - handle = dlopen('libcuda.so.1', RTLD_NOW | RTLD_GLOBAL) - if handle == NULL: - err_msg = dlerror() - raise NotSupportedError(f'CUDA driver is not found ({err_msg.decode()})') - cuDriverGetVersion = dlsym(handle, "cuDriverGetVersion") - if cuDriverGetVersion == NULL: - raise RuntimeError('Did not find cuDriverGetVersion symbol in libcuda.so.1') - err = (cuDriverGetVersion)(&driver_ver) - if err != 0: - raise RuntimeError(f'cuDriverGetVersion returned error code {err}') +# <<<< END OF PREAMBLE CONTENT >>>> - return driver_ver +from libc.stdint cimport uintptr_t +from .utils import FunctionNotFoundError, NotSupportedError +from cuda.pathfinder import load_nvidia_dynamic_lib ############################################################################### # Wrapper init ############################################################################### -cdef object __symbol_lock = threading.Lock() -cdef bint __py_cufile_init = False cdef void* __cuFileHandleRegister = NULL cdef void* __cuFileHandleDeregister = NULL @@ -106,488 +78,478 @@ cdef void* __cuFileGetBARSizeInKB = NULL cdef void* __cuFileSetParameterPosixPoolSlabArray = NULL cdef void* __cuFileGetParameterPosixPoolSlabArray = NULL - -cdef void* load_library() except* with gil: - cdef uintptr_t handle = load_nvidia_dynamic_lib("cufile")._handle_uint - return handle - - cdef int _init_cufile() except -1 nogil: - global __py_cufile_init - + global _cyb___py_cufile_init cdef void* handle = NULL + with gil, _cyb_symbol_lock: + if _cyb___py_cufile_init: return 0 - with gil, __symbol_lock: - # Recheck the flag after obtaining the locks - if __py_cufile_init: - return 0 - # Load function global __cuFileHandleRegister - __cuFileHandleRegister = dlsym(RTLD_DEFAULT, 'cuFileHandleRegister') + __cuFileHandleRegister = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileHandleRegister') if __cuFileHandleRegister == NULL: if handle == NULL: handle = load_library() - __cuFileHandleRegister = dlsym(handle, 'cuFileHandleRegister') + __cuFileHandleRegister = _cyb_dlsym(handle, 'cuFileHandleRegister') global __cuFileHandleDeregister - __cuFileHandleDeregister = dlsym(RTLD_DEFAULT, 'cuFileHandleDeregister') + __cuFileHandleDeregister = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileHandleDeregister') if __cuFileHandleDeregister == NULL: if handle == NULL: handle = load_library() - __cuFileHandleDeregister = dlsym(handle, 'cuFileHandleDeregister') + __cuFileHandleDeregister = _cyb_dlsym(handle, 'cuFileHandleDeregister') global __cuFileBufRegister - __cuFileBufRegister = dlsym(RTLD_DEFAULT, 'cuFileBufRegister') + __cuFileBufRegister = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileBufRegister') if __cuFileBufRegister == NULL: if handle == NULL: handle = load_library() - __cuFileBufRegister = dlsym(handle, 'cuFileBufRegister') + __cuFileBufRegister = _cyb_dlsym(handle, 'cuFileBufRegister') global __cuFileBufDeregister - __cuFileBufDeregister = dlsym(RTLD_DEFAULT, 'cuFileBufDeregister') + __cuFileBufDeregister = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileBufDeregister') if __cuFileBufDeregister == NULL: if handle == NULL: handle = load_library() - __cuFileBufDeregister = dlsym(handle, 'cuFileBufDeregister') + __cuFileBufDeregister = _cyb_dlsym(handle, 'cuFileBufDeregister') global __cuFileRead - __cuFileRead = dlsym(RTLD_DEFAULT, 'cuFileRead') + __cuFileRead = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileRead') if __cuFileRead == NULL: if handle == NULL: handle = load_library() - __cuFileRead = dlsym(handle, 'cuFileRead') + __cuFileRead = _cyb_dlsym(handle, 'cuFileRead') global __cuFileWrite - __cuFileWrite = dlsym(RTLD_DEFAULT, 'cuFileWrite') + __cuFileWrite = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileWrite') if __cuFileWrite == NULL: if handle == NULL: handle = load_library() - __cuFileWrite = dlsym(handle, 'cuFileWrite') + __cuFileWrite = _cyb_dlsym(handle, 'cuFileWrite') global __cuFileDriverOpen - __cuFileDriverOpen = dlsym(RTLD_DEFAULT, 'cuFileDriverOpen') + __cuFileDriverOpen = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileDriverOpen') if __cuFileDriverOpen == NULL: if handle == NULL: handle = load_library() - __cuFileDriverOpen = dlsym(handle, 'cuFileDriverOpen') + __cuFileDriverOpen = _cyb_dlsym(handle, 'cuFileDriverOpen') global __cuFileDriverClose - __cuFileDriverClose = dlsym(RTLD_DEFAULT, 'cuFileDriverClose') + __cuFileDriverClose = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileDriverClose') if __cuFileDriverClose == NULL: if handle == NULL: handle = load_library() - __cuFileDriverClose = dlsym(handle, 'cuFileDriverClose') + __cuFileDriverClose = _cyb_dlsym(handle, 'cuFileDriverClose') global __cuFileDriverClose_v2 - __cuFileDriverClose_v2 = dlsym(RTLD_DEFAULT, 'cuFileDriverClose_v2') + __cuFileDriverClose_v2 = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileDriverClose_v2') if __cuFileDriverClose_v2 == NULL: if handle == NULL: handle = load_library() - __cuFileDriverClose_v2 = dlsym(handle, 'cuFileDriverClose_v2') + __cuFileDriverClose_v2 = _cyb_dlsym(handle, 'cuFileDriverClose_v2') global __cuFileUseCount - __cuFileUseCount = dlsym(RTLD_DEFAULT, 'cuFileUseCount') + __cuFileUseCount = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileUseCount') if __cuFileUseCount == NULL: if handle == NULL: handle = load_library() - __cuFileUseCount = dlsym(handle, 'cuFileUseCount') + __cuFileUseCount = _cyb_dlsym(handle, 'cuFileUseCount') global __cuFileDriverGetProperties - __cuFileDriverGetProperties = dlsym(RTLD_DEFAULT, 'cuFileDriverGetProperties') + __cuFileDriverGetProperties = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileDriverGetProperties') if __cuFileDriverGetProperties == NULL: if handle == NULL: handle = load_library() - __cuFileDriverGetProperties = dlsym(handle, 'cuFileDriverGetProperties') + __cuFileDriverGetProperties = _cyb_dlsym(handle, 'cuFileDriverGetProperties') global __cuFileDriverSetPollMode - __cuFileDriverSetPollMode = dlsym(RTLD_DEFAULT, 'cuFileDriverSetPollMode') + __cuFileDriverSetPollMode = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileDriverSetPollMode') if __cuFileDriverSetPollMode == NULL: if handle == NULL: handle = load_library() - __cuFileDriverSetPollMode = dlsym(handle, 'cuFileDriverSetPollMode') + __cuFileDriverSetPollMode = _cyb_dlsym(handle, 'cuFileDriverSetPollMode') global __cuFileDriverSetMaxDirectIOSize - __cuFileDriverSetMaxDirectIOSize = dlsym(RTLD_DEFAULT, 'cuFileDriverSetMaxDirectIOSize') + __cuFileDriverSetMaxDirectIOSize = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileDriverSetMaxDirectIOSize') if __cuFileDriverSetMaxDirectIOSize == NULL: if handle == NULL: handle = load_library() - __cuFileDriverSetMaxDirectIOSize = dlsym(handle, 'cuFileDriverSetMaxDirectIOSize') + __cuFileDriverSetMaxDirectIOSize = _cyb_dlsym(handle, 'cuFileDriverSetMaxDirectIOSize') global __cuFileDriverSetMaxCacheSize - __cuFileDriverSetMaxCacheSize = dlsym(RTLD_DEFAULT, 'cuFileDriverSetMaxCacheSize') + __cuFileDriverSetMaxCacheSize = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileDriverSetMaxCacheSize') if __cuFileDriverSetMaxCacheSize == NULL: if handle == NULL: handle = load_library() - __cuFileDriverSetMaxCacheSize = dlsym(handle, 'cuFileDriverSetMaxCacheSize') + __cuFileDriverSetMaxCacheSize = _cyb_dlsym(handle, 'cuFileDriverSetMaxCacheSize') global __cuFileDriverSetMaxPinnedMemSize - __cuFileDriverSetMaxPinnedMemSize = dlsym(RTLD_DEFAULT, 'cuFileDriverSetMaxPinnedMemSize') + __cuFileDriverSetMaxPinnedMemSize = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileDriverSetMaxPinnedMemSize') if __cuFileDriverSetMaxPinnedMemSize == NULL: if handle == NULL: handle = load_library() - __cuFileDriverSetMaxPinnedMemSize = dlsym(handle, 'cuFileDriverSetMaxPinnedMemSize') + __cuFileDriverSetMaxPinnedMemSize = _cyb_dlsym(handle, 'cuFileDriverSetMaxPinnedMemSize') global __cuFileBatchIOSetUp - __cuFileBatchIOSetUp = dlsym(RTLD_DEFAULT, 'cuFileBatchIOSetUp') + __cuFileBatchIOSetUp = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileBatchIOSetUp') if __cuFileBatchIOSetUp == NULL: if handle == NULL: handle = load_library() - __cuFileBatchIOSetUp = dlsym(handle, 'cuFileBatchIOSetUp') + __cuFileBatchIOSetUp = _cyb_dlsym(handle, 'cuFileBatchIOSetUp') global __cuFileBatchIOSubmit - __cuFileBatchIOSubmit = dlsym(RTLD_DEFAULT, 'cuFileBatchIOSubmit') + __cuFileBatchIOSubmit = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileBatchIOSubmit') if __cuFileBatchIOSubmit == NULL: if handle == NULL: handle = load_library() - __cuFileBatchIOSubmit = dlsym(handle, 'cuFileBatchIOSubmit') + __cuFileBatchIOSubmit = _cyb_dlsym(handle, 'cuFileBatchIOSubmit') global __cuFileBatchIOGetStatus - __cuFileBatchIOGetStatus = dlsym(RTLD_DEFAULT, 'cuFileBatchIOGetStatus') + __cuFileBatchIOGetStatus = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileBatchIOGetStatus') if __cuFileBatchIOGetStatus == NULL: if handle == NULL: handle = load_library() - __cuFileBatchIOGetStatus = dlsym(handle, 'cuFileBatchIOGetStatus') + __cuFileBatchIOGetStatus = _cyb_dlsym(handle, 'cuFileBatchIOGetStatus') global __cuFileBatchIOCancel - __cuFileBatchIOCancel = dlsym(RTLD_DEFAULT, 'cuFileBatchIOCancel') + __cuFileBatchIOCancel = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileBatchIOCancel') if __cuFileBatchIOCancel == NULL: if handle == NULL: handle = load_library() - __cuFileBatchIOCancel = dlsym(handle, 'cuFileBatchIOCancel') + __cuFileBatchIOCancel = _cyb_dlsym(handle, 'cuFileBatchIOCancel') global __cuFileBatchIODestroy - __cuFileBatchIODestroy = dlsym(RTLD_DEFAULT, 'cuFileBatchIODestroy') + __cuFileBatchIODestroy = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileBatchIODestroy') if __cuFileBatchIODestroy == NULL: if handle == NULL: handle = load_library() - __cuFileBatchIODestroy = dlsym(handle, 'cuFileBatchIODestroy') + __cuFileBatchIODestroy = _cyb_dlsym(handle, 'cuFileBatchIODestroy') global __cuFileReadAsync - __cuFileReadAsync = dlsym(RTLD_DEFAULT, 'cuFileReadAsync') + __cuFileReadAsync = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileReadAsync') if __cuFileReadAsync == NULL: if handle == NULL: handle = load_library() - __cuFileReadAsync = dlsym(handle, 'cuFileReadAsync') + __cuFileReadAsync = _cyb_dlsym(handle, 'cuFileReadAsync') global __cuFileWriteAsync - __cuFileWriteAsync = dlsym(RTLD_DEFAULT, 'cuFileWriteAsync') + __cuFileWriteAsync = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileWriteAsync') if __cuFileWriteAsync == NULL: if handle == NULL: handle = load_library() - __cuFileWriteAsync = dlsym(handle, 'cuFileWriteAsync') + __cuFileWriteAsync = _cyb_dlsym(handle, 'cuFileWriteAsync') global __cuFileStreamRegister - __cuFileStreamRegister = dlsym(RTLD_DEFAULT, 'cuFileStreamRegister') + __cuFileStreamRegister = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileStreamRegister') if __cuFileStreamRegister == NULL: if handle == NULL: handle = load_library() - __cuFileStreamRegister = dlsym(handle, 'cuFileStreamRegister') + __cuFileStreamRegister = _cyb_dlsym(handle, 'cuFileStreamRegister') global __cuFileStreamDeregister - __cuFileStreamDeregister = dlsym(RTLD_DEFAULT, 'cuFileStreamDeregister') + __cuFileStreamDeregister = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileStreamDeregister') if __cuFileStreamDeregister == NULL: if handle == NULL: handle = load_library() - __cuFileStreamDeregister = dlsym(handle, 'cuFileStreamDeregister') + __cuFileStreamDeregister = _cyb_dlsym(handle, 'cuFileStreamDeregister') global __cuFileGetVersion - __cuFileGetVersion = dlsym(RTLD_DEFAULT, 'cuFileGetVersion') + __cuFileGetVersion = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileGetVersion') if __cuFileGetVersion == NULL: if handle == NULL: handle = load_library() - __cuFileGetVersion = dlsym(handle, 'cuFileGetVersion') + __cuFileGetVersion = _cyb_dlsym(handle, 'cuFileGetVersion') global __cuFileGetParameterSizeT - __cuFileGetParameterSizeT = dlsym(RTLD_DEFAULT, 'cuFileGetParameterSizeT') + __cuFileGetParameterSizeT = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileGetParameterSizeT') if __cuFileGetParameterSizeT == NULL: if handle == NULL: handle = load_library() - __cuFileGetParameterSizeT = dlsym(handle, 'cuFileGetParameterSizeT') + __cuFileGetParameterSizeT = _cyb_dlsym(handle, 'cuFileGetParameterSizeT') global __cuFileGetParameterBool - __cuFileGetParameterBool = dlsym(RTLD_DEFAULT, 'cuFileGetParameterBool') + __cuFileGetParameterBool = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileGetParameterBool') if __cuFileGetParameterBool == NULL: if handle == NULL: handle = load_library() - __cuFileGetParameterBool = dlsym(handle, 'cuFileGetParameterBool') + __cuFileGetParameterBool = _cyb_dlsym(handle, 'cuFileGetParameterBool') global __cuFileGetParameterString - __cuFileGetParameterString = dlsym(RTLD_DEFAULT, 'cuFileGetParameterString') + __cuFileGetParameterString = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileGetParameterString') if __cuFileGetParameterString == NULL: if handle == NULL: handle = load_library() - __cuFileGetParameterString = dlsym(handle, 'cuFileGetParameterString') + __cuFileGetParameterString = _cyb_dlsym(handle, 'cuFileGetParameterString') global __cuFileSetParameterSizeT - __cuFileSetParameterSizeT = dlsym(RTLD_DEFAULT, 'cuFileSetParameterSizeT') + __cuFileSetParameterSizeT = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileSetParameterSizeT') if __cuFileSetParameterSizeT == NULL: if handle == NULL: handle = load_library() - __cuFileSetParameterSizeT = dlsym(handle, 'cuFileSetParameterSizeT') + __cuFileSetParameterSizeT = _cyb_dlsym(handle, 'cuFileSetParameterSizeT') global __cuFileSetParameterBool - __cuFileSetParameterBool = dlsym(RTLD_DEFAULT, 'cuFileSetParameterBool') + __cuFileSetParameterBool = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileSetParameterBool') if __cuFileSetParameterBool == NULL: if handle == NULL: handle = load_library() - __cuFileSetParameterBool = dlsym(handle, 'cuFileSetParameterBool') + __cuFileSetParameterBool = _cyb_dlsym(handle, 'cuFileSetParameterBool') global __cuFileSetParameterString - __cuFileSetParameterString = dlsym(RTLD_DEFAULT, 'cuFileSetParameterString') + __cuFileSetParameterString = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileSetParameterString') if __cuFileSetParameterString == NULL: if handle == NULL: handle = load_library() - __cuFileSetParameterString = dlsym(handle, 'cuFileSetParameterString') + __cuFileSetParameterString = _cyb_dlsym(handle, 'cuFileSetParameterString') global __cuFileGetParameterMinMaxValue - __cuFileGetParameterMinMaxValue = dlsym(RTLD_DEFAULT, 'cuFileGetParameterMinMaxValue') + __cuFileGetParameterMinMaxValue = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileGetParameterMinMaxValue') if __cuFileGetParameterMinMaxValue == NULL: if handle == NULL: handle = load_library() - __cuFileGetParameterMinMaxValue = dlsym(handle, 'cuFileGetParameterMinMaxValue') + __cuFileGetParameterMinMaxValue = _cyb_dlsym(handle, 'cuFileGetParameterMinMaxValue') global __cuFileSetStatsLevel - __cuFileSetStatsLevel = dlsym(RTLD_DEFAULT, 'cuFileSetStatsLevel') + __cuFileSetStatsLevel = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileSetStatsLevel') if __cuFileSetStatsLevel == NULL: if handle == NULL: handle = load_library() - __cuFileSetStatsLevel = dlsym(handle, 'cuFileSetStatsLevel') + __cuFileSetStatsLevel = _cyb_dlsym(handle, 'cuFileSetStatsLevel') global __cuFileGetStatsLevel - __cuFileGetStatsLevel = dlsym(RTLD_DEFAULT, 'cuFileGetStatsLevel') + __cuFileGetStatsLevel = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileGetStatsLevel') if __cuFileGetStatsLevel == NULL: if handle == NULL: handle = load_library() - __cuFileGetStatsLevel = dlsym(handle, 'cuFileGetStatsLevel') + __cuFileGetStatsLevel = _cyb_dlsym(handle, 'cuFileGetStatsLevel') global __cuFileStatsStart - __cuFileStatsStart = dlsym(RTLD_DEFAULT, 'cuFileStatsStart') + __cuFileStatsStart = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileStatsStart') if __cuFileStatsStart == NULL: if handle == NULL: handle = load_library() - __cuFileStatsStart = dlsym(handle, 'cuFileStatsStart') + __cuFileStatsStart = _cyb_dlsym(handle, 'cuFileStatsStart') global __cuFileStatsStop - __cuFileStatsStop = dlsym(RTLD_DEFAULT, 'cuFileStatsStop') + __cuFileStatsStop = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileStatsStop') if __cuFileStatsStop == NULL: if handle == NULL: handle = load_library() - __cuFileStatsStop = dlsym(handle, 'cuFileStatsStop') + __cuFileStatsStop = _cyb_dlsym(handle, 'cuFileStatsStop') global __cuFileStatsReset - __cuFileStatsReset = dlsym(RTLD_DEFAULT, 'cuFileStatsReset') + __cuFileStatsReset = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileStatsReset') if __cuFileStatsReset == NULL: if handle == NULL: handle = load_library() - __cuFileStatsReset = dlsym(handle, 'cuFileStatsReset') + __cuFileStatsReset = _cyb_dlsym(handle, 'cuFileStatsReset') global __cuFileGetStatsL1 - __cuFileGetStatsL1 = dlsym(RTLD_DEFAULT, 'cuFileGetStatsL1') + __cuFileGetStatsL1 = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileGetStatsL1') if __cuFileGetStatsL1 == NULL: if handle == NULL: handle = load_library() - __cuFileGetStatsL1 = dlsym(handle, 'cuFileGetStatsL1') + __cuFileGetStatsL1 = _cyb_dlsym(handle, 'cuFileGetStatsL1') global __cuFileGetStatsL2 - __cuFileGetStatsL2 = dlsym(RTLD_DEFAULT, 'cuFileGetStatsL2') + __cuFileGetStatsL2 = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileGetStatsL2') if __cuFileGetStatsL2 == NULL: if handle == NULL: handle = load_library() - __cuFileGetStatsL2 = dlsym(handle, 'cuFileGetStatsL2') + __cuFileGetStatsL2 = _cyb_dlsym(handle, 'cuFileGetStatsL2') global __cuFileGetStatsL3 - __cuFileGetStatsL3 = dlsym(RTLD_DEFAULT, 'cuFileGetStatsL3') + __cuFileGetStatsL3 = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileGetStatsL3') if __cuFileGetStatsL3 == NULL: if handle == NULL: handle = load_library() - __cuFileGetStatsL3 = dlsym(handle, 'cuFileGetStatsL3') + __cuFileGetStatsL3 = _cyb_dlsym(handle, 'cuFileGetStatsL3') global __cuFileGetBARSizeInKB - __cuFileGetBARSizeInKB = dlsym(RTLD_DEFAULT, 'cuFileGetBARSizeInKB') + __cuFileGetBARSizeInKB = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileGetBARSizeInKB') if __cuFileGetBARSizeInKB == NULL: if handle == NULL: handle = load_library() - __cuFileGetBARSizeInKB = dlsym(handle, 'cuFileGetBARSizeInKB') + __cuFileGetBARSizeInKB = _cyb_dlsym(handle, 'cuFileGetBARSizeInKB') global __cuFileSetParameterPosixPoolSlabArray - __cuFileSetParameterPosixPoolSlabArray = dlsym(RTLD_DEFAULT, 'cuFileSetParameterPosixPoolSlabArray') + __cuFileSetParameterPosixPoolSlabArray = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileSetParameterPosixPoolSlabArray') if __cuFileSetParameterPosixPoolSlabArray == NULL: if handle == NULL: handle = load_library() - __cuFileSetParameterPosixPoolSlabArray = dlsym(handle, 'cuFileSetParameterPosixPoolSlabArray') + __cuFileSetParameterPosixPoolSlabArray = _cyb_dlsym(handle, 'cuFileSetParameterPosixPoolSlabArray') global __cuFileGetParameterPosixPoolSlabArray - __cuFileGetParameterPosixPoolSlabArray = dlsym(RTLD_DEFAULT, 'cuFileGetParameterPosixPoolSlabArray') + __cuFileGetParameterPosixPoolSlabArray = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileGetParameterPosixPoolSlabArray') if __cuFileGetParameterPosixPoolSlabArray == NULL: if handle == NULL: handle = load_library() - __cuFileGetParameterPosixPoolSlabArray = dlsym(handle, 'cuFileGetParameterPosixPoolSlabArray') + __cuFileGetParameterPosixPoolSlabArray = _cyb_dlsym(handle, 'cuFileGetParameterPosixPoolSlabArray') - __py_cufile_init = True + _cyb___py_cufile_init = True return 0 - cdef inline int _check_or_init_cufile() except -1 nogil: - if __py_cufile_init: + if _cyb___py_cufile_init: return 0 return _init_cufile() -cdef dict func_ptrs = None - - cpdef dict _inspect_function_pointers(): - global func_ptrs - if func_ptrs is not None: - return func_ptrs + global _cyb_func_ptrs + if _cyb_func_ptrs is not None: + return _cyb_func_ptrs _check_or_init_cufile() cdef dict data = {} - global __cuFileHandleRegister - data["__cuFileHandleRegister"] = __cuFileHandleRegister + data["__cuFileHandleRegister"] = <_cyb_intptr_t>__cuFileHandleRegister global __cuFileHandleDeregister - data["__cuFileHandleDeregister"] = __cuFileHandleDeregister + data["__cuFileHandleDeregister"] = <_cyb_intptr_t>__cuFileHandleDeregister global __cuFileBufRegister - data["__cuFileBufRegister"] = __cuFileBufRegister + data["__cuFileBufRegister"] = <_cyb_intptr_t>__cuFileBufRegister global __cuFileBufDeregister - data["__cuFileBufDeregister"] = __cuFileBufDeregister + data["__cuFileBufDeregister"] = <_cyb_intptr_t>__cuFileBufDeregister global __cuFileRead - data["__cuFileRead"] = __cuFileRead + data["__cuFileRead"] = <_cyb_intptr_t>__cuFileRead global __cuFileWrite - data["__cuFileWrite"] = __cuFileWrite + data["__cuFileWrite"] = <_cyb_intptr_t>__cuFileWrite global __cuFileDriverOpen - data["__cuFileDriverOpen"] = __cuFileDriverOpen + data["__cuFileDriverOpen"] = <_cyb_intptr_t>__cuFileDriverOpen global __cuFileDriverClose - data["__cuFileDriverClose"] = __cuFileDriverClose + data["__cuFileDriverClose"] = <_cyb_intptr_t>__cuFileDriverClose global __cuFileDriverClose_v2 - data["__cuFileDriverClose_v2"] = __cuFileDriverClose_v2 + data["__cuFileDriverClose_v2"] = <_cyb_intptr_t>__cuFileDriverClose_v2 global __cuFileUseCount - data["__cuFileUseCount"] = __cuFileUseCount + data["__cuFileUseCount"] = <_cyb_intptr_t>__cuFileUseCount global __cuFileDriverGetProperties - data["__cuFileDriverGetProperties"] = __cuFileDriverGetProperties + data["__cuFileDriverGetProperties"] = <_cyb_intptr_t>__cuFileDriverGetProperties global __cuFileDriverSetPollMode - data["__cuFileDriverSetPollMode"] = __cuFileDriverSetPollMode + data["__cuFileDriverSetPollMode"] = <_cyb_intptr_t>__cuFileDriverSetPollMode global __cuFileDriverSetMaxDirectIOSize - data["__cuFileDriverSetMaxDirectIOSize"] = __cuFileDriverSetMaxDirectIOSize + data["__cuFileDriverSetMaxDirectIOSize"] = <_cyb_intptr_t>__cuFileDriverSetMaxDirectIOSize global __cuFileDriverSetMaxCacheSize - data["__cuFileDriverSetMaxCacheSize"] = __cuFileDriverSetMaxCacheSize + data["__cuFileDriverSetMaxCacheSize"] = <_cyb_intptr_t>__cuFileDriverSetMaxCacheSize global __cuFileDriverSetMaxPinnedMemSize - data["__cuFileDriverSetMaxPinnedMemSize"] = __cuFileDriverSetMaxPinnedMemSize + data["__cuFileDriverSetMaxPinnedMemSize"] = <_cyb_intptr_t>__cuFileDriverSetMaxPinnedMemSize global __cuFileBatchIOSetUp - data["__cuFileBatchIOSetUp"] = __cuFileBatchIOSetUp + data["__cuFileBatchIOSetUp"] = <_cyb_intptr_t>__cuFileBatchIOSetUp global __cuFileBatchIOSubmit - data["__cuFileBatchIOSubmit"] = __cuFileBatchIOSubmit + data["__cuFileBatchIOSubmit"] = <_cyb_intptr_t>__cuFileBatchIOSubmit global __cuFileBatchIOGetStatus - data["__cuFileBatchIOGetStatus"] = __cuFileBatchIOGetStatus + data["__cuFileBatchIOGetStatus"] = <_cyb_intptr_t>__cuFileBatchIOGetStatus global __cuFileBatchIOCancel - data["__cuFileBatchIOCancel"] = __cuFileBatchIOCancel + data["__cuFileBatchIOCancel"] = <_cyb_intptr_t>__cuFileBatchIOCancel global __cuFileBatchIODestroy - data["__cuFileBatchIODestroy"] = __cuFileBatchIODestroy + data["__cuFileBatchIODestroy"] = <_cyb_intptr_t>__cuFileBatchIODestroy global __cuFileReadAsync - data["__cuFileReadAsync"] = __cuFileReadAsync + data["__cuFileReadAsync"] = <_cyb_intptr_t>__cuFileReadAsync global __cuFileWriteAsync - data["__cuFileWriteAsync"] = __cuFileWriteAsync + data["__cuFileWriteAsync"] = <_cyb_intptr_t>__cuFileWriteAsync global __cuFileStreamRegister - data["__cuFileStreamRegister"] = __cuFileStreamRegister + data["__cuFileStreamRegister"] = <_cyb_intptr_t>__cuFileStreamRegister global __cuFileStreamDeregister - data["__cuFileStreamDeregister"] = __cuFileStreamDeregister + data["__cuFileStreamDeregister"] = <_cyb_intptr_t>__cuFileStreamDeregister global __cuFileGetVersion - data["__cuFileGetVersion"] = __cuFileGetVersion + data["__cuFileGetVersion"] = <_cyb_intptr_t>__cuFileGetVersion global __cuFileGetParameterSizeT - data["__cuFileGetParameterSizeT"] = __cuFileGetParameterSizeT + data["__cuFileGetParameterSizeT"] = <_cyb_intptr_t>__cuFileGetParameterSizeT global __cuFileGetParameterBool - data["__cuFileGetParameterBool"] = __cuFileGetParameterBool + data["__cuFileGetParameterBool"] = <_cyb_intptr_t>__cuFileGetParameterBool global __cuFileGetParameterString - data["__cuFileGetParameterString"] = __cuFileGetParameterString + data["__cuFileGetParameterString"] = <_cyb_intptr_t>__cuFileGetParameterString global __cuFileSetParameterSizeT - data["__cuFileSetParameterSizeT"] = __cuFileSetParameterSizeT + data["__cuFileSetParameterSizeT"] = <_cyb_intptr_t>__cuFileSetParameterSizeT global __cuFileSetParameterBool - data["__cuFileSetParameterBool"] = __cuFileSetParameterBool + data["__cuFileSetParameterBool"] = <_cyb_intptr_t>__cuFileSetParameterBool global __cuFileSetParameterString - data["__cuFileSetParameterString"] = __cuFileSetParameterString + data["__cuFileSetParameterString"] = <_cyb_intptr_t>__cuFileSetParameterString global __cuFileGetParameterMinMaxValue - data["__cuFileGetParameterMinMaxValue"] = __cuFileGetParameterMinMaxValue + data["__cuFileGetParameterMinMaxValue"] = <_cyb_intptr_t>__cuFileGetParameterMinMaxValue global __cuFileSetStatsLevel - data["__cuFileSetStatsLevel"] = __cuFileSetStatsLevel + data["__cuFileSetStatsLevel"] = <_cyb_intptr_t>__cuFileSetStatsLevel global __cuFileGetStatsLevel - data["__cuFileGetStatsLevel"] = __cuFileGetStatsLevel + data["__cuFileGetStatsLevel"] = <_cyb_intptr_t>__cuFileGetStatsLevel global __cuFileStatsStart - data["__cuFileStatsStart"] = __cuFileStatsStart + data["__cuFileStatsStart"] = <_cyb_intptr_t>__cuFileStatsStart global __cuFileStatsStop - data["__cuFileStatsStop"] = __cuFileStatsStop + data["__cuFileStatsStop"] = <_cyb_intptr_t>__cuFileStatsStop global __cuFileStatsReset - data["__cuFileStatsReset"] = __cuFileStatsReset + data["__cuFileStatsReset"] = <_cyb_intptr_t>__cuFileStatsReset global __cuFileGetStatsL1 - data["__cuFileGetStatsL1"] = __cuFileGetStatsL1 + data["__cuFileGetStatsL1"] = <_cyb_intptr_t>__cuFileGetStatsL1 global __cuFileGetStatsL2 - data["__cuFileGetStatsL2"] = __cuFileGetStatsL2 + data["__cuFileGetStatsL2"] = <_cyb_intptr_t>__cuFileGetStatsL2 global __cuFileGetStatsL3 - data["__cuFileGetStatsL3"] = __cuFileGetStatsL3 + data["__cuFileGetStatsL3"] = <_cyb_intptr_t>__cuFileGetStatsL3 global __cuFileGetBARSizeInKB - data["__cuFileGetBARSizeInKB"] = __cuFileGetBARSizeInKB + data["__cuFileGetBARSizeInKB"] = <_cyb_intptr_t>__cuFileGetBARSizeInKB global __cuFileSetParameterPosixPoolSlabArray - data["__cuFileSetParameterPosixPoolSlabArray"] = __cuFileSetParameterPosixPoolSlabArray + data["__cuFileSetParameterPosixPoolSlabArray"] = <_cyb_intptr_t>__cuFileSetParameterPosixPoolSlabArray global __cuFileGetParameterPosixPoolSlabArray - data["__cuFileGetParameterPosixPoolSlabArray"] = __cuFileGetParameterPosixPoolSlabArray - - func_ptrs = data + data["__cuFileGetParameterPosixPoolSlabArray"] = <_cyb_intptr_t>__cuFileGetParameterPosixPoolSlabArray + _cyb_func_ptrs = data return data cpdef _inspect_function_pointer(str name): - global func_ptrs - if func_ptrs is None: - func_ptrs = _inspect_function_pointers() - return func_ptrs[name] + global _cyb_func_ptrs + if _cyb_func_ptrs is None: + _cyb_func_ptrs = _inspect_function_pointers() + return _cyb_func_ptrs[name] + + + + +cdef void* load_library() except* with gil: + cdef uintptr_t handle = load_nvidia_dynamic_lib("cufile")._handle_uint + return handle ############################################################################### # Wrapper functions -############################################################################### cdef CUfileError_t _cuFileHandleRegister(CUfileHandle_t* fh, CUfileDescr_t* descr) except?CUFILE_LOADING_ERROR nogil: global __cuFileHandleRegister @@ -599,7 +561,7 @@ cdef CUfileError_t _cuFileHandleRegister(CUfileHandle_t* fh, CUfileDescr_t* desc fh, descr) -@cython.show_performance_hints(False) +@_cyb_cython.show_performance_hints(False) cdef void _cuFileHandleDeregister(CUfileHandle_t fh) except* nogil: global __cuFileHandleDeregister _check_or_init_cufile() @@ -780,7 +742,7 @@ cdef CUfileError_t _cuFileBatchIOCancel(CUfileBatchHandle_t batch_idp) except?>>> -from cuda.pathfinder import load_nvidia_dynamic_lib +cdef extern from "": + void* _cyb_dlsym "dlsym"(void*, const char*) nogil +from libc.stdint cimport intptr_t as _cyb_intptr_t -############################################################################### -# Extern -############################################################################### +from os import getenv as _cyb_getenv +import threading as _cyb_threading -# You must 'from .utils import NotSupportedError' before using this template +ctypedef int (*_cyb_cuGetProcAddress_v2_T)(const char *, void **, int, cuuint64_t, CUdriverProcAddressQueryResult *)except?CUDA_ERROR_NOT_FOUND nogil -cdef extern from "" nogil: - void* dlopen(const char*, int) - char* dlerror() - void* dlsym(void*, const char*) - int dlclose(void*) +cdef bint _cyb___py_driver_init = False +cdef dict _cyb_func_ptrs = None +cdef object _cyb_symbol_lock = _cyb_threading.Lock() - enum: - RTLD_LAZY - RTLD_NOW - RTLD_GLOBAL - RTLD_LOCAL +# <<<< END OF PREAMBLE CONTENT >>>> - const void* RTLD_DEFAULT 'RTLD_DEFAULT' - -cdef int get_cuda_version(): - cdef void* handle = NULL - cdef int err, driver_ver = 0 - - # Load driver to check version - handle = dlopen('libcuda.so.1', RTLD_NOW | RTLD_GLOBAL) - if handle == NULL: - err_msg = dlerror() - raise NotSupportedError(f'CUDA driver is not found ({err_msg.decode()})') - cuDriverGetVersion = dlsym(handle, "cuDriverGetVersion") - if cuDriverGetVersion == NULL: - raise RuntimeError('Did not find cuDriverGetVersion symbol in libcuda.so.1') - err = (cuDriverGetVersion)(&driver_ver) - if err != 0: - raise RuntimeError(f'cuDriverGetVersion returned error code {err}') - - return driver_ver +from libc.stdint cimport uintptr_t +from .utils import FunctionNotFoundError, NotSupportedError +from cuda.pathfinder import load_nvidia_dynamic_lib ############################################################################### # Wrapper init ############################################################################### -cdef object __symbol_lock = threading.Lock() -cdef bint __py_driver_init = False cdef void* __cuGetErrorString = NULL cdef void* __cuGetErrorName = NULL @@ -579,3177 +553,3159 @@ cdef void* __cuLogicalEndpointGetLimits = NULL cdef void* __cuLogicalEndpointQuery = NULL cdef void* __cuStreamBeginRecaptureToGraph = NULL - - -cdef void* load_library() except* with gil: - cdef uintptr_t handle = load_nvidia_dynamic_lib("cuda")._handle_uint - return handle - - -ctypedef CUresult (*__cuGetProcAddress_v2_T)(const char*, void**, int, cuuint64_t, CUdriverProcAddressQueryResult*) except?CUDA_ERROR_NOT_FOUND nogil -cdef __cuGetProcAddress_v2_T _F_cuGetProcAddress_v2 = NULL - - cdef int _init_driver() except -1 nogil: - global __py_driver_init - + global _cyb___py_driver_init cdef void* handle = NULL cdef int ptds_mode - - with gil, __symbol_lock: - # Recheck the flag after obtaining the locks - if __py_driver_init: - return 0 + cdef _cyb_cuGetProcAddress_v2_T cuGetProcAddress_v2 + with gil, _cyb_symbol_lock: + if _cyb___py_driver_init: return 0 handle = load_library() if handle == NULL: raise RuntimeError('Failed to open cuda') - - # Get latest __cuGetProcAddress_v2 - global __cuGetProcAddress_v2 - __cuGetProcAddress_v2 = dlsym(handle, 'cuGetProcAddress_v2') - if __cuGetProcAddress_v2 == NULL: - raise RuntimeError("Failed to get __cuGetProcAddress_v2") - _F_cuGetProcAddress_v2 = <__cuGetProcAddress_v2_T>__cuGetProcAddress_v2 - - if bool(int(os.getenv('CUDA_PYTHON_CUDA_PER_THREAD_DEFAULT_STREAM', default=0))): + # Get latest cuGetProcAddress_v2 + cuGetProcAddress_v2 = <_cyb_cuGetProcAddress_v2_T>_cyb_dlsym(handle, 'cuGetProcAddress_v2') + if cuGetProcAddress_v2 == NULL: + raise RuntimeError("Failed to get cuGetProcAddress_v2") + if bool(int(_cyb_getenv('CUDA_PYTHON_CUDA_PER_THREAD_DEFAULT_STREAM', default=0))): ptds_mode = CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else: ptds_mode = CU_GET_PROC_ADDRESS_DEFAULT - - # Load function global __cuGetErrorString - _F_cuGetProcAddress_v2('cuGetErrorString', &__cuGetErrorString, 6000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGetErrorString', &__cuGetErrorString, 6000, ptds_mode, NULL) global __cuGetErrorName - _F_cuGetProcAddress_v2('cuGetErrorName', &__cuGetErrorName, 6000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGetErrorName', &__cuGetErrorName, 6000, ptds_mode, NULL) global __cuInit - _F_cuGetProcAddress_v2('cuInit', &__cuInit, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuInit', &__cuInit, 2000, ptds_mode, NULL) global __cuDriverGetVersion - _F_cuGetProcAddress_v2('cuDriverGetVersion', &__cuDriverGetVersion, 2020, ptds_mode, NULL) + cuGetProcAddress_v2('cuDriverGetVersion', &__cuDriverGetVersion, 2020, ptds_mode, NULL) global __cuDeviceGet - _F_cuGetProcAddress_v2('cuDeviceGet', &__cuDeviceGet, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceGet', &__cuDeviceGet, 2000, ptds_mode, NULL) global __cuDeviceGetCount - _F_cuGetProcAddress_v2('cuDeviceGetCount', &__cuDeviceGetCount, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceGetCount', &__cuDeviceGetCount, 2000, ptds_mode, NULL) global __cuDeviceGetName - _F_cuGetProcAddress_v2('cuDeviceGetName', &__cuDeviceGetName, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceGetName', &__cuDeviceGetName, 2000, ptds_mode, NULL) global __cuDeviceGetUuid_v2 - _F_cuGetProcAddress_v2('cuDeviceGetUuid', &__cuDeviceGetUuid_v2, 11040, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceGetUuid', &__cuDeviceGetUuid_v2, 11040, ptds_mode, NULL) global __cuDeviceGetLuid - _F_cuGetProcAddress_v2('cuDeviceGetLuid', &__cuDeviceGetLuid, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceGetLuid', &__cuDeviceGetLuid, 10000, ptds_mode, NULL) global __cuDeviceTotalMem_v2 - _F_cuGetProcAddress_v2('cuDeviceTotalMem', &__cuDeviceTotalMem_v2, 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceTotalMem', &__cuDeviceTotalMem_v2, 3020, ptds_mode, NULL) global __cuDeviceGetTexture1DLinearMaxWidth - _F_cuGetProcAddress_v2('cuDeviceGetTexture1DLinearMaxWidth', &__cuDeviceGetTexture1DLinearMaxWidth, 11010, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceGetTexture1DLinearMaxWidth', &__cuDeviceGetTexture1DLinearMaxWidth, 11010, ptds_mode, NULL) global __cuDeviceGetAttribute - _F_cuGetProcAddress_v2('cuDeviceGetAttribute', &__cuDeviceGetAttribute, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceGetAttribute', &__cuDeviceGetAttribute, 2000, ptds_mode, NULL) global __cuDeviceGetNvSciSyncAttributes - _F_cuGetProcAddress_v2('cuDeviceGetNvSciSyncAttributes', &__cuDeviceGetNvSciSyncAttributes, 10020, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceGetNvSciSyncAttributes', &__cuDeviceGetNvSciSyncAttributes, 10020, ptds_mode, NULL) global __cuDeviceSetMemPool - _F_cuGetProcAddress_v2('cuDeviceSetMemPool', &__cuDeviceSetMemPool, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceSetMemPool', &__cuDeviceSetMemPool, 11020, ptds_mode, NULL) global __cuDeviceGetMemPool - _F_cuGetProcAddress_v2('cuDeviceGetMemPool', &__cuDeviceGetMemPool, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceGetMemPool', &__cuDeviceGetMemPool, 11020, ptds_mode, NULL) global __cuDeviceGetDefaultMemPool - _F_cuGetProcAddress_v2('cuDeviceGetDefaultMemPool', &__cuDeviceGetDefaultMemPool, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceGetDefaultMemPool', &__cuDeviceGetDefaultMemPool, 11020, ptds_mode, NULL) global __cuDeviceGetExecAffinitySupport - _F_cuGetProcAddress_v2('cuDeviceGetExecAffinitySupport', &__cuDeviceGetExecAffinitySupport, 11040, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceGetExecAffinitySupport', &__cuDeviceGetExecAffinitySupport, 11040, ptds_mode, NULL) global __cuFlushGPUDirectRDMAWrites - _F_cuGetProcAddress_v2('cuFlushGPUDirectRDMAWrites', &__cuFlushGPUDirectRDMAWrites, 11030, ptds_mode, NULL) + cuGetProcAddress_v2('cuFlushGPUDirectRDMAWrites', &__cuFlushGPUDirectRDMAWrites, 11030, ptds_mode, NULL) global __cuDeviceGetProperties - _F_cuGetProcAddress_v2('cuDeviceGetProperties', &__cuDeviceGetProperties, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceGetProperties', &__cuDeviceGetProperties, 2000, ptds_mode, NULL) global __cuDeviceComputeCapability - _F_cuGetProcAddress_v2('cuDeviceComputeCapability', &__cuDeviceComputeCapability, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceComputeCapability', &__cuDeviceComputeCapability, 2000, ptds_mode, NULL) global __cuDevicePrimaryCtxRetain - _F_cuGetProcAddress_v2('cuDevicePrimaryCtxRetain', &__cuDevicePrimaryCtxRetain, 7000, ptds_mode, NULL) + cuGetProcAddress_v2('cuDevicePrimaryCtxRetain', &__cuDevicePrimaryCtxRetain, 7000, ptds_mode, NULL) global __cuDevicePrimaryCtxRelease_v2 - _F_cuGetProcAddress_v2('cuDevicePrimaryCtxRelease', &__cuDevicePrimaryCtxRelease_v2, 11000, ptds_mode, NULL) + cuGetProcAddress_v2('cuDevicePrimaryCtxRelease', &__cuDevicePrimaryCtxRelease_v2, 11000, ptds_mode, NULL) global __cuDevicePrimaryCtxSetFlags_v2 - _F_cuGetProcAddress_v2('cuDevicePrimaryCtxSetFlags', &__cuDevicePrimaryCtxSetFlags_v2, 11000, ptds_mode, NULL) + cuGetProcAddress_v2('cuDevicePrimaryCtxSetFlags', &__cuDevicePrimaryCtxSetFlags_v2, 11000, ptds_mode, NULL) global __cuDevicePrimaryCtxGetState - _F_cuGetProcAddress_v2('cuDevicePrimaryCtxGetState', &__cuDevicePrimaryCtxGetState, 7000, ptds_mode, NULL) + cuGetProcAddress_v2('cuDevicePrimaryCtxGetState', &__cuDevicePrimaryCtxGetState, 7000, ptds_mode, NULL) global __cuDevicePrimaryCtxReset_v2 - _F_cuGetProcAddress_v2('cuDevicePrimaryCtxReset', &__cuDevicePrimaryCtxReset_v2, 11000, ptds_mode, NULL) + cuGetProcAddress_v2('cuDevicePrimaryCtxReset', &__cuDevicePrimaryCtxReset_v2, 11000, ptds_mode, NULL) global __cuCtxCreate_v2 - _F_cuGetProcAddress_v2('cuCtxCreate', &__cuCtxCreate_v2, 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxCreate', &__cuCtxCreate_v2, 3020, ptds_mode, NULL) global __cuCtxCreate_v3 - _F_cuGetProcAddress_v2('cuCtxCreate', &__cuCtxCreate_v3, 11040, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxCreate', &__cuCtxCreate_v3, 11040, ptds_mode, NULL) global __cuCtxCreate_v4 - _F_cuGetProcAddress_v2('cuCtxCreate', &__cuCtxCreate_v4, 12050, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxCreate', &__cuCtxCreate_v4, 12050, ptds_mode, NULL) global __cuCtxDestroy_v2 - _F_cuGetProcAddress_v2('cuCtxDestroy', &__cuCtxDestroy_v2, 4000, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxDestroy', &__cuCtxDestroy_v2, 4000, ptds_mode, NULL) global __cuCtxPushCurrent_v2 - _F_cuGetProcAddress_v2('cuCtxPushCurrent', &__cuCtxPushCurrent_v2, 4000, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxPushCurrent', &__cuCtxPushCurrent_v2, 4000, ptds_mode, NULL) global __cuCtxPopCurrent_v2 - _F_cuGetProcAddress_v2('cuCtxPopCurrent', &__cuCtxPopCurrent_v2, 4000, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxPopCurrent', &__cuCtxPopCurrent_v2, 4000, ptds_mode, NULL) global __cuCtxSetCurrent - _F_cuGetProcAddress_v2('cuCtxSetCurrent', &__cuCtxSetCurrent, 4000, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxSetCurrent', &__cuCtxSetCurrent, 4000, ptds_mode, NULL) global __cuCtxGetCurrent - _F_cuGetProcAddress_v2('cuCtxGetCurrent', &__cuCtxGetCurrent, 4000, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxGetCurrent', &__cuCtxGetCurrent, 4000, ptds_mode, NULL) global __cuCtxGetDevice - _F_cuGetProcAddress_v2('cuCtxGetDevice', &__cuCtxGetDevice, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxGetDevice', &__cuCtxGetDevice, 2000, ptds_mode, NULL) global __cuCtxGetFlags - _F_cuGetProcAddress_v2('cuCtxGetFlags', &__cuCtxGetFlags, 7000, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxGetFlags', &__cuCtxGetFlags, 7000, ptds_mode, NULL) global __cuCtxSetFlags - _F_cuGetProcAddress_v2('cuCtxSetFlags', &__cuCtxSetFlags, 12010, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxSetFlags', &__cuCtxSetFlags, 12010, ptds_mode, NULL) global __cuCtxGetId - _F_cuGetProcAddress_v2('cuCtxGetId', &__cuCtxGetId, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxGetId', &__cuCtxGetId, 12000, ptds_mode, NULL) global __cuCtxSynchronize - _F_cuGetProcAddress_v2('cuCtxSynchronize', &__cuCtxSynchronize, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxSynchronize', &__cuCtxSynchronize, 2000, ptds_mode, NULL) global __cuCtxSetLimit - _F_cuGetProcAddress_v2('cuCtxSetLimit', &__cuCtxSetLimit, 3010, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxSetLimit', &__cuCtxSetLimit, 3010, ptds_mode, NULL) global __cuCtxGetLimit - _F_cuGetProcAddress_v2('cuCtxGetLimit', &__cuCtxGetLimit, 3010, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxGetLimit', &__cuCtxGetLimit, 3010, ptds_mode, NULL) global __cuCtxGetCacheConfig - _F_cuGetProcAddress_v2('cuCtxGetCacheConfig', &__cuCtxGetCacheConfig, 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxGetCacheConfig', &__cuCtxGetCacheConfig, 3020, ptds_mode, NULL) global __cuCtxSetCacheConfig - _F_cuGetProcAddress_v2('cuCtxSetCacheConfig', &__cuCtxSetCacheConfig, 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxSetCacheConfig', &__cuCtxSetCacheConfig, 3020, ptds_mode, NULL) global __cuCtxGetApiVersion - _F_cuGetProcAddress_v2('cuCtxGetApiVersion', &__cuCtxGetApiVersion, 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxGetApiVersion', &__cuCtxGetApiVersion, 3020, ptds_mode, NULL) global __cuCtxGetStreamPriorityRange - _F_cuGetProcAddress_v2('cuCtxGetStreamPriorityRange', &__cuCtxGetStreamPriorityRange, 5050, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxGetStreamPriorityRange', &__cuCtxGetStreamPriorityRange, 5050, ptds_mode, NULL) global __cuCtxResetPersistingL2Cache - _F_cuGetProcAddress_v2('cuCtxResetPersistingL2Cache', &__cuCtxResetPersistingL2Cache, 11000, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxResetPersistingL2Cache', &__cuCtxResetPersistingL2Cache, 11000, ptds_mode, NULL) global __cuCtxGetExecAffinity - _F_cuGetProcAddress_v2('cuCtxGetExecAffinity', &__cuCtxGetExecAffinity, 11040, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxGetExecAffinity', &__cuCtxGetExecAffinity, 11040, ptds_mode, NULL) global __cuCtxRecordEvent - _F_cuGetProcAddress_v2('cuCtxRecordEvent', &__cuCtxRecordEvent, 12050, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxRecordEvent', &__cuCtxRecordEvent, 12050, ptds_mode, NULL) global __cuCtxWaitEvent - _F_cuGetProcAddress_v2('cuCtxWaitEvent', &__cuCtxWaitEvent, 12050, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxWaitEvent', &__cuCtxWaitEvent, 12050, ptds_mode, NULL) global __cuCtxAttach - _F_cuGetProcAddress_v2('cuCtxAttach', &__cuCtxAttach, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxAttach', &__cuCtxAttach, 2000, ptds_mode, NULL) global __cuCtxDetach - _F_cuGetProcAddress_v2('cuCtxDetach', &__cuCtxDetach, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxDetach', &__cuCtxDetach, 2000, ptds_mode, NULL) global __cuCtxGetSharedMemConfig - _F_cuGetProcAddress_v2('cuCtxGetSharedMemConfig', &__cuCtxGetSharedMemConfig, 4020, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxGetSharedMemConfig', &__cuCtxGetSharedMemConfig, 4020, ptds_mode, NULL) global __cuCtxSetSharedMemConfig - _F_cuGetProcAddress_v2('cuCtxSetSharedMemConfig', &__cuCtxSetSharedMemConfig, 4020, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxSetSharedMemConfig', &__cuCtxSetSharedMemConfig, 4020, ptds_mode, NULL) global __cuModuleLoad - _F_cuGetProcAddress_v2('cuModuleLoad', &__cuModuleLoad, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuModuleLoad', &__cuModuleLoad, 2000, ptds_mode, NULL) global __cuModuleLoadData - _F_cuGetProcAddress_v2('cuModuleLoadData', &__cuModuleLoadData, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuModuleLoadData', &__cuModuleLoadData, 2000, ptds_mode, NULL) global __cuModuleLoadDataEx - _F_cuGetProcAddress_v2('cuModuleLoadDataEx', &__cuModuleLoadDataEx, 2010, ptds_mode, NULL) + cuGetProcAddress_v2('cuModuleLoadDataEx', &__cuModuleLoadDataEx, 2010, ptds_mode, NULL) global __cuModuleLoadFatBinary - _F_cuGetProcAddress_v2('cuModuleLoadFatBinary', &__cuModuleLoadFatBinary, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuModuleLoadFatBinary', &__cuModuleLoadFatBinary, 2000, ptds_mode, NULL) global __cuModuleUnload - _F_cuGetProcAddress_v2('cuModuleUnload', &__cuModuleUnload, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuModuleUnload', &__cuModuleUnload, 2000, ptds_mode, NULL) global __cuModuleGetLoadingMode - _F_cuGetProcAddress_v2('cuModuleGetLoadingMode', &__cuModuleGetLoadingMode, 11070, ptds_mode, NULL) + cuGetProcAddress_v2('cuModuleGetLoadingMode', &__cuModuleGetLoadingMode, 11070, ptds_mode, NULL) global __cuModuleGetFunction - _F_cuGetProcAddress_v2('cuModuleGetFunction', &__cuModuleGetFunction, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuModuleGetFunction', &__cuModuleGetFunction, 2000, ptds_mode, NULL) global __cuModuleGetFunctionCount - _F_cuGetProcAddress_v2('cuModuleGetFunctionCount', &__cuModuleGetFunctionCount, 12040, ptds_mode, NULL) + cuGetProcAddress_v2('cuModuleGetFunctionCount', &__cuModuleGetFunctionCount, 12040, ptds_mode, NULL) global __cuModuleEnumerateFunctions - _F_cuGetProcAddress_v2('cuModuleEnumerateFunctions', &__cuModuleEnumerateFunctions, 12040, ptds_mode, NULL) + cuGetProcAddress_v2('cuModuleEnumerateFunctions', &__cuModuleEnumerateFunctions, 12040, ptds_mode, NULL) global __cuModuleGetGlobal_v2 - _F_cuGetProcAddress_v2('cuModuleGetGlobal', &__cuModuleGetGlobal_v2, 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuModuleGetGlobal', &__cuModuleGetGlobal_v2, 3020, ptds_mode, NULL) global __cuLinkCreate_v2 - _F_cuGetProcAddress_v2('cuLinkCreate', &__cuLinkCreate_v2, 6050, ptds_mode, NULL) + cuGetProcAddress_v2('cuLinkCreate', &__cuLinkCreate_v2, 6050, ptds_mode, NULL) global __cuLinkAddData_v2 - _F_cuGetProcAddress_v2('cuLinkAddData', &__cuLinkAddData_v2, 6050, ptds_mode, NULL) + cuGetProcAddress_v2('cuLinkAddData', &__cuLinkAddData_v2, 6050, ptds_mode, NULL) global __cuLinkAddFile_v2 - _F_cuGetProcAddress_v2('cuLinkAddFile', &__cuLinkAddFile_v2, 6050, ptds_mode, NULL) + cuGetProcAddress_v2('cuLinkAddFile', &__cuLinkAddFile_v2, 6050, ptds_mode, NULL) global __cuLinkComplete - _F_cuGetProcAddress_v2('cuLinkComplete', &__cuLinkComplete, 5050, ptds_mode, NULL) + cuGetProcAddress_v2('cuLinkComplete', &__cuLinkComplete, 5050, ptds_mode, NULL) global __cuLinkDestroy - _F_cuGetProcAddress_v2('cuLinkDestroy', &__cuLinkDestroy, 5050, ptds_mode, NULL) + cuGetProcAddress_v2('cuLinkDestroy', &__cuLinkDestroy, 5050, ptds_mode, NULL) global __cuModuleGetTexRef - _F_cuGetProcAddress_v2('cuModuleGetTexRef', &__cuModuleGetTexRef, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuModuleGetTexRef', &__cuModuleGetTexRef, 2000, ptds_mode, NULL) global __cuModuleGetSurfRef - _F_cuGetProcAddress_v2('cuModuleGetSurfRef', &__cuModuleGetSurfRef, 3000, ptds_mode, NULL) + cuGetProcAddress_v2('cuModuleGetSurfRef', &__cuModuleGetSurfRef, 3000, ptds_mode, NULL) global __cuLibraryLoadData - _F_cuGetProcAddress_v2('cuLibraryLoadData', &__cuLibraryLoadData, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuLibraryLoadData', &__cuLibraryLoadData, 12000, ptds_mode, NULL) global __cuLibraryLoadFromFile - _F_cuGetProcAddress_v2('cuLibraryLoadFromFile', &__cuLibraryLoadFromFile, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuLibraryLoadFromFile', &__cuLibraryLoadFromFile, 12000, ptds_mode, NULL) global __cuLibraryUnload - _F_cuGetProcAddress_v2('cuLibraryUnload', &__cuLibraryUnload, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuLibraryUnload', &__cuLibraryUnload, 12000, ptds_mode, NULL) global __cuLibraryGetKernel - _F_cuGetProcAddress_v2('cuLibraryGetKernel', &__cuLibraryGetKernel, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuLibraryGetKernel', &__cuLibraryGetKernel, 12000, ptds_mode, NULL) global __cuLibraryGetKernelCount - _F_cuGetProcAddress_v2('cuLibraryGetKernelCount', &__cuLibraryGetKernelCount, 12040, ptds_mode, NULL) + cuGetProcAddress_v2('cuLibraryGetKernelCount', &__cuLibraryGetKernelCount, 12040, ptds_mode, NULL) global __cuLibraryEnumerateKernels - _F_cuGetProcAddress_v2('cuLibraryEnumerateKernels', &__cuLibraryEnumerateKernels, 12040, ptds_mode, NULL) + cuGetProcAddress_v2('cuLibraryEnumerateKernels', &__cuLibraryEnumerateKernels, 12040, ptds_mode, NULL) global __cuLibraryGetModule - _F_cuGetProcAddress_v2('cuLibraryGetModule', &__cuLibraryGetModule, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuLibraryGetModule', &__cuLibraryGetModule, 12000, ptds_mode, NULL) global __cuKernelGetFunction - _F_cuGetProcAddress_v2('cuKernelGetFunction', &__cuKernelGetFunction, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuKernelGetFunction', &__cuKernelGetFunction, 12000, ptds_mode, NULL) global __cuKernelGetLibrary - _F_cuGetProcAddress_v2('cuKernelGetLibrary', &__cuKernelGetLibrary, 12050, ptds_mode, NULL) + cuGetProcAddress_v2('cuKernelGetLibrary', &__cuKernelGetLibrary, 12050, ptds_mode, NULL) global __cuLibraryGetGlobal - _F_cuGetProcAddress_v2('cuLibraryGetGlobal', &__cuLibraryGetGlobal, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuLibraryGetGlobal', &__cuLibraryGetGlobal, 12000, ptds_mode, NULL) global __cuLibraryGetManaged - _F_cuGetProcAddress_v2('cuLibraryGetManaged', &__cuLibraryGetManaged, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuLibraryGetManaged', &__cuLibraryGetManaged, 12000, ptds_mode, NULL) global __cuLibraryGetUnifiedFunction - _F_cuGetProcAddress_v2('cuLibraryGetUnifiedFunction', &__cuLibraryGetUnifiedFunction, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuLibraryGetUnifiedFunction', &__cuLibraryGetUnifiedFunction, 12000, ptds_mode, NULL) global __cuKernelGetAttribute - _F_cuGetProcAddress_v2('cuKernelGetAttribute', &__cuKernelGetAttribute, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuKernelGetAttribute', &__cuKernelGetAttribute, 12000, ptds_mode, NULL) global __cuKernelSetAttribute - _F_cuGetProcAddress_v2('cuKernelSetAttribute', &__cuKernelSetAttribute, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuKernelSetAttribute', &__cuKernelSetAttribute, 12000, ptds_mode, NULL) global __cuKernelSetCacheConfig - _F_cuGetProcAddress_v2('cuKernelSetCacheConfig', &__cuKernelSetCacheConfig, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuKernelSetCacheConfig', &__cuKernelSetCacheConfig, 12000, ptds_mode, NULL) global __cuKernelGetName - _F_cuGetProcAddress_v2('cuKernelGetName', &__cuKernelGetName, 12030, ptds_mode, NULL) + cuGetProcAddress_v2('cuKernelGetName', &__cuKernelGetName, 12030, ptds_mode, NULL) global __cuKernelGetParamInfo - _F_cuGetProcAddress_v2('cuKernelGetParamInfo', &__cuKernelGetParamInfo, 12040, ptds_mode, NULL) + cuGetProcAddress_v2('cuKernelGetParamInfo', &__cuKernelGetParamInfo, 12040, ptds_mode, NULL) global __cuMemGetInfo_v2 - _F_cuGetProcAddress_v2('cuMemGetInfo', &__cuMemGetInfo_v2, 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemGetInfo', &__cuMemGetInfo_v2, 3020, ptds_mode, NULL) global __cuMemAlloc_v2 - _F_cuGetProcAddress_v2('cuMemAlloc', &__cuMemAlloc_v2, 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemAlloc', &__cuMemAlloc_v2, 3020, ptds_mode, NULL) global __cuMemAllocPitch_v2 - _F_cuGetProcAddress_v2('cuMemAllocPitch', &__cuMemAllocPitch_v2, 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemAllocPitch', &__cuMemAllocPitch_v2, 3020, ptds_mode, NULL) global __cuMemFree_v2 - _F_cuGetProcAddress_v2('cuMemFree', &__cuMemFree_v2, 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemFree', &__cuMemFree_v2, 3020, ptds_mode, NULL) global __cuMemGetAddressRange_v2 - _F_cuGetProcAddress_v2('cuMemGetAddressRange', &__cuMemGetAddressRange_v2, 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemGetAddressRange', &__cuMemGetAddressRange_v2, 3020, ptds_mode, NULL) global __cuMemAllocHost_v2 - _F_cuGetProcAddress_v2('cuMemAllocHost', &__cuMemAllocHost_v2, 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemAllocHost', &__cuMemAllocHost_v2, 3020, ptds_mode, NULL) global __cuMemFreeHost - _F_cuGetProcAddress_v2('cuMemFreeHost', &__cuMemFreeHost, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemFreeHost', &__cuMemFreeHost, 2000, ptds_mode, NULL) global __cuMemHostAlloc - _F_cuGetProcAddress_v2('cuMemHostAlloc', &__cuMemHostAlloc, 2020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemHostAlloc', &__cuMemHostAlloc, 2020, ptds_mode, NULL) global __cuMemHostGetDevicePointer_v2 - _F_cuGetProcAddress_v2('cuMemHostGetDevicePointer', &__cuMemHostGetDevicePointer_v2, 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemHostGetDevicePointer', &__cuMemHostGetDevicePointer_v2, 3020, ptds_mode, NULL) global __cuMemHostGetFlags - _F_cuGetProcAddress_v2('cuMemHostGetFlags', &__cuMemHostGetFlags, 2030, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemHostGetFlags', &__cuMemHostGetFlags, 2030, ptds_mode, NULL) global __cuMemAllocManaged - _F_cuGetProcAddress_v2('cuMemAllocManaged', &__cuMemAllocManaged, 6000, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemAllocManaged', &__cuMemAllocManaged, 6000, ptds_mode, NULL) global __cuDeviceRegisterAsyncNotification - _F_cuGetProcAddress_v2('cuDeviceRegisterAsyncNotification', &__cuDeviceRegisterAsyncNotification, 12040, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceRegisterAsyncNotification', &__cuDeviceRegisterAsyncNotification, 12040, ptds_mode, NULL) global __cuDeviceUnregisterAsyncNotification - _F_cuGetProcAddress_v2('cuDeviceUnregisterAsyncNotification', &__cuDeviceUnregisterAsyncNotification, 12040, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceUnregisterAsyncNotification', &__cuDeviceUnregisterAsyncNotification, 12040, ptds_mode, NULL) global __cuDeviceGetByPCIBusId - _F_cuGetProcAddress_v2('cuDeviceGetByPCIBusId', &__cuDeviceGetByPCIBusId, 4010, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceGetByPCIBusId', &__cuDeviceGetByPCIBusId, 4010, ptds_mode, NULL) global __cuDeviceGetPCIBusId - _F_cuGetProcAddress_v2('cuDeviceGetPCIBusId', &__cuDeviceGetPCIBusId, 4010, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceGetPCIBusId', &__cuDeviceGetPCIBusId, 4010, ptds_mode, NULL) global __cuIpcGetEventHandle - _F_cuGetProcAddress_v2('cuIpcGetEventHandle', &__cuIpcGetEventHandle, 4010, ptds_mode, NULL) + cuGetProcAddress_v2('cuIpcGetEventHandle', &__cuIpcGetEventHandle, 4010, ptds_mode, NULL) global __cuIpcOpenEventHandle - _F_cuGetProcAddress_v2('cuIpcOpenEventHandle', &__cuIpcOpenEventHandle, 4010, ptds_mode, NULL) + cuGetProcAddress_v2('cuIpcOpenEventHandle', &__cuIpcOpenEventHandle, 4010, ptds_mode, NULL) global __cuIpcGetMemHandle - _F_cuGetProcAddress_v2('cuIpcGetMemHandle', &__cuIpcGetMemHandle, 4010, ptds_mode, NULL) + cuGetProcAddress_v2('cuIpcGetMemHandle', &__cuIpcGetMemHandle, 4010, ptds_mode, NULL) global __cuIpcOpenMemHandle_v2 - _F_cuGetProcAddress_v2('cuIpcOpenMemHandle', &__cuIpcOpenMemHandle_v2, 11000, ptds_mode, NULL) + cuGetProcAddress_v2('cuIpcOpenMemHandle', &__cuIpcOpenMemHandle_v2, 11000, ptds_mode, NULL) global __cuIpcCloseMemHandle - _F_cuGetProcAddress_v2('cuIpcCloseMemHandle', &__cuIpcCloseMemHandle, 4010, ptds_mode, NULL) + cuGetProcAddress_v2('cuIpcCloseMemHandle', &__cuIpcCloseMemHandle, 4010, ptds_mode, NULL) global __cuMemHostRegister_v2 - _F_cuGetProcAddress_v2('cuMemHostRegister', &__cuMemHostRegister_v2, 6050, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemHostRegister', &__cuMemHostRegister_v2, 6050, ptds_mode, NULL) global __cuMemHostUnregister - _F_cuGetProcAddress_v2('cuMemHostUnregister', &__cuMemHostUnregister, 4000, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemHostUnregister', &__cuMemHostUnregister, 4000, ptds_mode, NULL) global __cuMemcpy - _F_cuGetProcAddress_v2('cuMemcpy', &__cuMemcpy, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 4000, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpy', &__cuMemcpy, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 4000, ptds_mode, NULL) global __cuMemcpyPeer - _F_cuGetProcAddress_v2('cuMemcpyPeer', &__cuMemcpyPeer, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 4000, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpyPeer', &__cuMemcpyPeer, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 4000, ptds_mode, NULL) global __cuMemcpyHtoD_v2 - _F_cuGetProcAddress_v2('cuMemcpyHtoD', &__cuMemcpyHtoD_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpyHtoD', &__cuMemcpyHtoD_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemcpyDtoH_v2 - _F_cuGetProcAddress_v2('cuMemcpyDtoH', &__cuMemcpyDtoH_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpyDtoH', &__cuMemcpyDtoH_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemcpyDtoD_v2 - _F_cuGetProcAddress_v2('cuMemcpyDtoD', &__cuMemcpyDtoD_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpyDtoD', &__cuMemcpyDtoD_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemcpyDtoA_v2 - _F_cuGetProcAddress_v2('cuMemcpyDtoA', &__cuMemcpyDtoA_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpyDtoA', &__cuMemcpyDtoA_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemcpyAtoD_v2 - _F_cuGetProcAddress_v2('cuMemcpyAtoD', &__cuMemcpyAtoD_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpyAtoD', &__cuMemcpyAtoD_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemcpyHtoA_v2 - _F_cuGetProcAddress_v2('cuMemcpyHtoA', &__cuMemcpyHtoA_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpyHtoA', &__cuMemcpyHtoA_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemcpyAtoH_v2 - _F_cuGetProcAddress_v2('cuMemcpyAtoH', &__cuMemcpyAtoH_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpyAtoH', &__cuMemcpyAtoH_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemcpyAtoA_v2 - _F_cuGetProcAddress_v2('cuMemcpyAtoA', &__cuMemcpyAtoA_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpyAtoA', &__cuMemcpyAtoA_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemcpy2D_v2 - _F_cuGetProcAddress_v2('cuMemcpy2D', &__cuMemcpy2D_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpy2D', &__cuMemcpy2D_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemcpy2DUnaligned_v2 - _F_cuGetProcAddress_v2('cuMemcpy2DUnaligned', &__cuMemcpy2DUnaligned_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpy2DUnaligned', &__cuMemcpy2DUnaligned_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemcpy3D_v2 - _F_cuGetProcAddress_v2('cuMemcpy3D', &__cuMemcpy3D_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpy3D', &__cuMemcpy3D_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemcpy3DPeer - _F_cuGetProcAddress_v2('cuMemcpy3DPeer', &__cuMemcpy3DPeer, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 4000, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpy3DPeer', &__cuMemcpy3DPeer, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 4000, ptds_mode, NULL) global __cuMemcpyAsync - _F_cuGetProcAddress_v2('cuMemcpyAsync', &__cuMemcpyAsync, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 4000, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpyAsync', &__cuMemcpyAsync, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 4000, ptds_mode, NULL) global __cuMemcpyPeerAsync - _F_cuGetProcAddress_v2('cuMemcpyPeerAsync', &__cuMemcpyPeerAsync, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 4000, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpyPeerAsync', &__cuMemcpyPeerAsync, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 4000, ptds_mode, NULL) global __cuMemcpyHtoDAsync_v2 - _F_cuGetProcAddress_v2('cuMemcpyHtoDAsync', &__cuMemcpyHtoDAsync_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpyHtoDAsync', &__cuMemcpyHtoDAsync_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemcpyDtoHAsync_v2 - _F_cuGetProcAddress_v2('cuMemcpyDtoHAsync', &__cuMemcpyDtoHAsync_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpyDtoHAsync', &__cuMemcpyDtoHAsync_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemcpyDtoDAsync_v2 - _F_cuGetProcAddress_v2('cuMemcpyDtoDAsync', &__cuMemcpyDtoDAsync_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpyDtoDAsync', &__cuMemcpyDtoDAsync_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemcpyHtoAAsync_v2 - _F_cuGetProcAddress_v2('cuMemcpyHtoAAsync', &__cuMemcpyHtoAAsync_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpyHtoAAsync', &__cuMemcpyHtoAAsync_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemcpyAtoHAsync_v2 - _F_cuGetProcAddress_v2('cuMemcpyAtoHAsync', &__cuMemcpyAtoHAsync_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpyAtoHAsync', &__cuMemcpyAtoHAsync_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemcpy2DAsync_v2 - _F_cuGetProcAddress_v2('cuMemcpy2DAsync', &__cuMemcpy2DAsync_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpy2DAsync', &__cuMemcpy2DAsync_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemcpy3DAsync_v2 - _F_cuGetProcAddress_v2('cuMemcpy3DAsync', &__cuMemcpy3DAsync_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpy3DAsync', &__cuMemcpy3DAsync_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemcpy3DPeerAsync - _F_cuGetProcAddress_v2('cuMemcpy3DPeerAsync', &__cuMemcpy3DPeerAsync, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 4000, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpy3DPeerAsync', &__cuMemcpy3DPeerAsync, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 4000, ptds_mode, NULL) global __cuMemsetD8_v2 - _F_cuGetProcAddress_v2('cuMemsetD8', &__cuMemsetD8_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemsetD8', &__cuMemsetD8_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemsetD16_v2 - _F_cuGetProcAddress_v2('cuMemsetD16', &__cuMemsetD16_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemsetD16', &__cuMemsetD16_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemsetD32_v2 - _F_cuGetProcAddress_v2('cuMemsetD32', &__cuMemsetD32_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemsetD32', &__cuMemsetD32_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemsetD2D8_v2 - _F_cuGetProcAddress_v2('cuMemsetD2D8', &__cuMemsetD2D8_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemsetD2D8', &__cuMemsetD2D8_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemsetD2D16_v2 - _F_cuGetProcAddress_v2('cuMemsetD2D16', &__cuMemsetD2D16_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemsetD2D16', &__cuMemsetD2D16_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemsetD2D32_v2 - _F_cuGetProcAddress_v2('cuMemsetD2D32', &__cuMemsetD2D32_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemsetD2D32', &__cuMemsetD2D32_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemsetD8Async - _F_cuGetProcAddress_v2('cuMemsetD8Async', &__cuMemsetD8Async, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemsetD8Async', &__cuMemsetD8Async, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemsetD16Async - _F_cuGetProcAddress_v2('cuMemsetD16Async', &__cuMemsetD16Async, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemsetD16Async', &__cuMemsetD16Async, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemsetD32Async - _F_cuGetProcAddress_v2('cuMemsetD32Async', &__cuMemsetD32Async, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemsetD32Async', &__cuMemsetD32Async, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemsetD2D8Async - _F_cuGetProcAddress_v2('cuMemsetD2D8Async', &__cuMemsetD2D8Async, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemsetD2D8Async', &__cuMemsetD2D8Async, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemsetD2D16Async - _F_cuGetProcAddress_v2('cuMemsetD2D16Async', &__cuMemsetD2D16Async, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemsetD2D16Async', &__cuMemsetD2D16Async, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemsetD2D32Async - _F_cuGetProcAddress_v2('cuMemsetD2D32Async', &__cuMemsetD2D32Async, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemsetD2D32Async', &__cuMemsetD2D32Async, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuArrayCreate_v2 - _F_cuGetProcAddress_v2('cuArrayCreate', &__cuArrayCreate_v2, 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuArrayCreate', &__cuArrayCreate_v2, 3020, ptds_mode, NULL) global __cuArrayGetDescriptor_v2 - _F_cuGetProcAddress_v2('cuArrayGetDescriptor', &__cuArrayGetDescriptor_v2, 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuArrayGetDescriptor', &__cuArrayGetDescriptor_v2, 3020, ptds_mode, NULL) global __cuArrayGetSparseProperties - _F_cuGetProcAddress_v2('cuArrayGetSparseProperties', &__cuArrayGetSparseProperties, 11010, ptds_mode, NULL) + cuGetProcAddress_v2('cuArrayGetSparseProperties', &__cuArrayGetSparseProperties, 11010, ptds_mode, NULL) global __cuMipmappedArrayGetSparseProperties - _F_cuGetProcAddress_v2('cuMipmappedArrayGetSparseProperties', &__cuMipmappedArrayGetSparseProperties, 11010, ptds_mode, NULL) + cuGetProcAddress_v2('cuMipmappedArrayGetSparseProperties', &__cuMipmappedArrayGetSparseProperties, 11010, ptds_mode, NULL) global __cuArrayGetMemoryRequirements - _F_cuGetProcAddress_v2('cuArrayGetMemoryRequirements', &__cuArrayGetMemoryRequirements, 11060, ptds_mode, NULL) + cuGetProcAddress_v2('cuArrayGetMemoryRequirements', &__cuArrayGetMemoryRequirements, 11060, ptds_mode, NULL) global __cuMipmappedArrayGetMemoryRequirements - _F_cuGetProcAddress_v2('cuMipmappedArrayGetMemoryRequirements', &__cuMipmappedArrayGetMemoryRequirements, 11060, ptds_mode, NULL) + cuGetProcAddress_v2('cuMipmappedArrayGetMemoryRequirements', &__cuMipmappedArrayGetMemoryRequirements, 11060, ptds_mode, NULL) global __cuArrayGetPlane - _F_cuGetProcAddress_v2('cuArrayGetPlane', &__cuArrayGetPlane, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuArrayGetPlane', &__cuArrayGetPlane, 11020, ptds_mode, NULL) global __cuArrayDestroy - _F_cuGetProcAddress_v2('cuArrayDestroy', &__cuArrayDestroy, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuArrayDestroy', &__cuArrayDestroy, 2000, ptds_mode, NULL) global __cuArray3DCreate_v2 - _F_cuGetProcAddress_v2('cuArray3DCreate', &__cuArray3DCreate_v2, 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuArray3DCreate', &__cuArray3DCreate_v2, 3020, ptds_mode, NULL) global __cuArray3DGetDescriptor_v2 - _F_cuGetProcAddress_v2('cuArray3DGetDescriptor', &__cuArray3DGetDescriptor_v2, 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuArray3DGetDescriptor', &__cuArray3DGetDescriptor_v2, 3020, ptds_mode, NULL) global __cuMipmappedArrayCreate - _F_cuGetProcAddress_v2('cuMipmappedArrayCreate', &__cuMipmappedArrayCreate, 5000, ptds_mode, NULL) + cuGetProcAddress_v2('cuMipmappedArrayCreate', &__cuMipmappedArrayCreate, 5000, ptds_mode, NULL) global __cuMipmappedArrayGetLevel - _F_cuGetProcAddress_v2('cuMipmappedArrayGetLevel', &__cuMipmappedArrayGetLevel, 5000, ptds_mode, NULL) + cuGetProcAddress_v2('cuMipmappedArrayGetLevel', &__cuMipmappedArrayGetLevel, 5000, ptds_mode, NULL) global __cuMipmappedArrayDestroy - _F_cuGetProcAddress_v2('cuMipmappedArrayDestroy', &__cuMipmappedArrayDestroy, 5000, ptds_mode, NULL) + cuGetProcAddress_v2('cuMipmappedArrayDestroy', &__cuMipmappedArrayDestroy, 5000, ptds_mode, NULL) global __cuMemGetHandleForAddressRange - _F_cuGetProcAddress_v2('cuMemGetHandleForAddressRange', &__cuMemGetHandleForAddressRange, 11070, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemGetHandleForAddressRange', &__cuMemGetHandleForAddressRange, 11070, ptds_mode, NULL) global __cuMemBatchDecompressAsync - _F_cuGetProcAddress_v2('cuMemBatchDecompressAsync', &__cuMemBatchDecompressAsync, 12060, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemBatchDecompressAsync', &__cuMemBatchDecompressAsync, 12060, ptds_mode, NULL) global __cuMemAddressReserve - _F_cuGetProcAddress_v2('cuMemAddressReserve', &__cuMemAddressReserve, 10020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemAddressReserve', &__cuMemAddressReserve, 10020, ptds_mode, NULL) global __cuMemAddressFree - _F_cuGetProcAddress_v2('cuMemAddressFree', &__cuMemAddressFree, 10020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemAddressFree', &__cuMemAddressFree, 10020, ptds_mode, NULL) global __cuMemCreate - _F_cuGetProcAddress_v2('cuMemCreate', &__cuMemCreate, 10020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemCreate', &__cuMemCreate, 10020, ptds_mode, NULL) global __cuMemRelease - _F_cuGetProcAddress_v2('cuMemRelease', &__cuMemRelease, 10020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemRelease', &__cuMemRelease, 10020, ptds_mode, NULL) global __cuMemMap - _F_cuGetProcAddress_v2('cuMemMap', &__cuMemMap, 10020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemMap', &__cuMemMap, 10020, ptds_mode, NULL) global __cuMemMapArrayAsync - _F_cuGetProcAddress_v2('cuMemMapArrayAsync', &__cuMemMapArrayAsync, 11010, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemMapArrayAsync', &__cuMemMapArrayAsync, 11010, ptds_mode, NULL) global __cuMemUnmap - _F_cuGetProcAddress_v2('cuMemUnmap', &__cuMemUnmap, 10020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemUnmap', &__cuMemUnmap, 10020, ptds_mode, NULL) global __cuMemSetAccess - _F_cuGetProcAddress_v2('cuMemSetAccess', &__cuMemSetAccess, 10020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemSetAccess', &__cuMemSetAccess, 10020, ptds_mode, NULL) global __cuMemGetAccess - _F_cuGetProcAddress_v2('cuMemGetAccess', &__cuMemGetAccess, 10020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemGetAccess', &__cuMemGetAccess, 10020, ptds_mode, NULL) global __cuMemExportToShareableHandle - _F_cuGetProcAddress_v2('cuMemExportToShareableHandle', &__cuMemExportToShareableHandle, 10020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemExportToShareableHandle', &__cuMemExportToShareableHandle, 10020, ptds_mode, NULL) global __cuMemImportFromShareableHandle - _F_cuGetProcAddress_v2('cuMemImportFromShareableHandle', &__cuMemImportFromShareableHandle, 10020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemImportFromShareableHandle', &__cuMemImportFromShareableHandle, 10020, ptds_mode, NULL) global __cuMemGetAllocationGranularity - _F_cuGetProcAddress_v2('cuMemGetAllocationGranularity', &__cuMemGetAllocationGranularity, 10020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemGetAllocationGranularity', &__cuMemGetAllocationGranularity, 10020, ptds_mode, NULL) global __cuMemGetAllocationPropertiesFromHandle - _F_cuGetProcAddress_v2('cuMemGetAllocationPropertiesFromHandle', &__cuMemGetAllocationPropertiesFromHandle, 10020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemGetAllocationPropertiesFromHandle', &__cuMemGetAllocationPropertiesFromHandle, 10020, ptds_mode, NULL) global __cuMemRetainAllocationHandle - _F_cuGetProcAddress_v2('cuMemRetainAllocationHandle', &__cuMemRetainAllocationHandle, 11000, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemRetainAllocationHandle', &__cuMemRetainAllocationHandle, 11000, ptds_mode, NULL) global __cuMemFreeAsync - _F_cuGetProcAddress_v2('cuMemFreeAsync', &__cuMemFreeAsync, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemFreeAsync', &__cuMemFreeAsync, 11020, ptds_mode, NULL) global __cuMemAllocAsync - _F_cuGetProcAddress_v2('cuMemAllocAsync', &__cuMemAllocAsync, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemAllocAsync', &__cuMemAllocAsync, 11020, ptds_mode, NULL) global __cuMemPoolTrimTo - _F_cuGetProcAddress_v2('cuMemPoolTrimTo', &__cuMemPoolTrimTo, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemPoolTrimTo', &__cuMemPoolTrimTo, 11020, ptds_mode, NULL) global __cuMemPoolSetAttribute - _F_cuGetProcAddress_v2('cuMemPoolSetAttribute', &__cuMemPoolSetAttribute, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemPoolSetAttribute', &__cuMemPoolSetAttribute, 11020, ptds_mode, NULL) global __cuMemPoolGetAttribute - _F_cuGetProcAddress_v2('cuMemPoolGetAttribute', &__cuMemPoolGetAttribute, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemPoolGetAttribute', &__cuMemPoolGetAttribute, 11020, ptds_mode, NULL) global __cuMemPoolSetAccess - _F_cuGetProcAddress_v2('cuMemPoolSetAccess', &__cuMemPoolSetAccess, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemPoolSetAccess', &__cuMemPoolSetAccess, 11020, ptds_mode, NULL) global __cuMemPoolGetAccess - _F_cuGetProcAddress_v2('cuMemPoolGetAccess', &__cuMemPoolGetAccess, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemPoolGetAccess', &__cuMemPoolGetAccess, 11020, ptds_mode, NULL) global __cuMemPoolCreate - _F_cuGetProcAddress_v2('cuMemPoolCreate', &__cuMemPoolCreate, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemPoolCreate', &__cuMemPoolCreate, 11020, ptds_mode, NULL) global __cuMemPoolDestroy - _F_cuGetProcAddress_v2('cuMemPoolDestroy', &__cuMemPoolDestroy, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemPoolDestroy', &__cuMemPoolDestroy, 11020, ptds_mode, NULL) global __cuMemAllocFromPoolAsync - _F_cuGetProcAddress_v2('cuMemAllocFromPoolAsync', &__cuMemAllocFromPoolAsync, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemAllocFromPoolAsync', &__cuMemAllocFromPoolAsync, 11020, ptds_mode, NULL) global __cuMemPoolExportToShareableHandle - _F_cuGetProcAddress_v2('cuMemPoolExportToShareableHandle', &__cuMemPoolExportToShareableHandle, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemPoolExportToShareableHandle', &__cuMemPoolExportToShareableHandle, 11020, ptds_mode, NULL) global __cuMemPoolImportFromShareableHandle - _F_cuGetProcAddress_v2('cuMemPoolImportFromShareableHandle', &__cuMemPoolImportFromShareableHandle, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemPoolImportFromShareableHandle', &__cuMemPoolImportFromShareableHandle, 11020, ptds_mode, NULL) global __cuMemPoolExportPointer - _F_cuGetProcAddress_v2('cuMemPoolExportPointer', &__cuMemPoolExportPointer, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemPoolExportPointer', &__cuMemPoolExportPointer, 11020, ptds_mode, NULL) global __cuMemPoolImportPointer - _F_cuGetProcAddress_v2('cuMemPoolImportPointer', &__cuMemPoolImportPointer, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemPoolImportPointer', &__cuMemPoolImportPointer, 11020, ptds_mode, NULL) global __cuMulticastCreate - _F_cuGetProcAddress_v2('cuMulticastCreate', &__cuMulticastCreate, 12010, ptds_mode, NULL) + cuGetProcAddress_v2('cuMulticastCreate', &__cuMulticastCreate, 12010, ptds_mode, NULL) global __cuMulticastAddDevice - _F_cuGetProcAddress_v2('cuMulticastAddDevice', &__cuMulticastAddDevice, 12010, ptds_mode, NULL) + cuGetProcAddress_v2('cuMulticastAddDevice', &__cuMulticastAddDevice, 12010, ptds_mode, NULL) global __cuMulticastBindMem - _F_cuGetProcAddress_v2('cuMulticastBindMem', &__cuMulticastBindMem, 12010, ptds_mode, NULL) + cuGetProcAddress_v2('cuMulticastBindMem', &__cuMulticastBindMem, 12010, ptds_mode, NULL) global __cuMulticastBindAddr - _F_cuGetProcAddress_v2('cuMulticastBindAddr', &__cuMulticastBindAddr, 12010, ptds_mode, NULL) + cuGetProcAddress_v2('cuMulticastBindAddr', &__cuMulticastBindAddr, 12010, ptds_mode, NULL) global __cuMulticastUnbind - _F_cuGetProcAddress_v2('cuMulticastUnbind', &__cuMulticastUnbind, 12010, ptds_mode, NULL) + cuGetProcAddress_v2('cuMulticastUnbind', &__cuMulticastUnbind, 12010, ptds_mode, NULL) global __cuMulticastGetGranularity - _F_cuGetProcAddress_v2('cuMulticastGetGranularity', &__cuMulticastGetGranularity, 12010, ptds_mode, NULL) + cuGetProcAddress_v2('cuMulticastGetGranularity', &__cuMulticastGetGranularity, 12010, ptds_mode, NULL) global __cuPointerGetAttribute - _F_cuGetProcAddress_v2('cuPointerGetAttribute', &__cuPointerGetAttribute, 4000, ptds_mode, NULL) + cuGetProcAddress_v2('cuPointerGetAttribute', &__cuPointerGetAttribute, 4000, ptds_mode, NULL) global __cuMemPrefetchAsync_v2 - _F_cuGetProcAddress_v2('cuMemPrefetchAsync', &__cuMemPrefetchAsync_v2, 12020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemPrefetchAsync', &__cuMemPrefetchAsync_v2, 12020, ptds_mode, NULL) global __cuMemAdvise_v2 - _F_cuGetProcAddress_v2('cuMemAdvise', &__cuMemAdvise_v2, 12020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemAdvise', &__cuMemAdvise_v2, 12020, ptds_mode, NULL) global __cuMemRangeGetAttribute - _F_cuGetProcAddress_v2('cuMemRangeGetAttribute', &__cuMemRangeGetAttribute, 8000, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemRangeGetAttribute', &__cuMemRangeGetAttribute, 8000, ptds_mode, NULL) global __cuMemRangeGetAttributes - _F_cuGetProcAddress_v2('cuMemRangeGetAttributes', &__cuMemRangeGetAttributes, 8000, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemRangeGetAttributes', &__cuMemRangeGetAttributes, 8000, ptds_mode, NULL) global __cuPointerSetAttribute - _F_cuGetProcAddress_v2('cuPointerSetAttribute', &__cuPointerSetAttribute, 6000, ptds_mode, NULL) + cuGetProcAddress_v2('cuPointerSetAttribute', &__cuPointerSetAttribute, 6000, ptds_mode, NULL) global __cuPointerGetAttributes - _F_cuGetProcAddress_v2('cuPointerGetAttributes', &__cuPointerGetAttributes, 7000, ptds_mode, NULL) + cuGetProcAddress_v2('cuPointerGetAttributes', &__cuPointerGetAttributes, 7000, ptds_mode, NULL) global __cuStreamCreate - _F_cuGetProcAddress_v2('cuStreamCreate', &__cuStreamCreate, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamCreate', &__cuStreamCreate, 2000, ptds_mode, NULL) global __cuStreamCreateWithPriority - _F_cuGetProcAddress_v2('cuStreamCreateWithPriority', &__cuStreamCreateWithPriority, 5050, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamCreateWithPriority', &__cuStreamCreateWithPriority, 5050, ptds_mode, NULL) global __cuStreamGetPriority - _F_cuGetProcAddress_v2('cuStreamGetPriority', &__cuStreamGetPriority, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 5050, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamGetPriority', &__cuStreamGetPriority, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 5050, ptds_mode, NULL) global __cuStreamGetDevice - _F_cuGetProcAddress_v2('cuStreamGetDevice', &__cuStreamGetDevice, 12080, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamGetDevice', &__cuStreamGetDevice, 12080, ptds_mode, NULL) global __cuStreamGetFlags - _F_cuGetProcAddress_v2('cuStreamGetFlags', &__cuStreamGetFlags, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 5050, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamGetFlags', &__cuStreamGetFlags, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 5050, ptds_mode, NULL) global __cuStreamGetId - _F_cuGetProcAddress_v2('cuStreamGetId', &__cuStreamGetId, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamGetId', &__cuStreamGetId, 12000, ptds_mode, NULL) global __cuStreamGetCtx - _F_cuGetProcAddress_v2('cuStreamGetCtx', &__cuStreamGetCtx, 9020, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamGetCtx', &__cuStreamGetCtx, 9020, ptds_mode, NULL) global __cuStreamGetCtx_v2 - _F_cuGetProcAddress_v2('cuStreamGetCtx', &__cuStreamGetCtx_v2, 12050, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamGetCtx', &__cuStreamGetCtx_v2, 12050, ptds_mode, NULL) global __cuStreamWaitEvent - _F_cuGetProcAddress_v2('cuStreamWaitEvent', &__cuStreamWaitEvent, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamWaitEvent', &__cuStreamWaitEvent, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuStreamAddCallback - _F_cuGetProcAddress_v2('cuStreamAddCallback', &__cuStreamAddCallback, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 5000, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamAddCallback', &__cuStreamAddCallback, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 5000, ptds_mode, NULL) global __cuStreamBeginCapture_v2 - _F_cuGetProcAddress_v2('cuStreamBeginCapture', &__cuStreamBeginCapture_v2, 10010, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamBeginCapture', &__cuStreamBeginCapture_v2, 10010, ptds_mode, NULL) global __cuStreamBeginCaptureToGraph - _F_cuGetProcAddress_v2('cuStreamBeginCaptureToGraph', &__cuStreamBeginCaptureToGraph, 12030, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamBeginCaptureToGraph', &__cuStreamBeginCaptureToGraph, 12030, ptds_mode, NULL) global __cuThreadExchangeStreamCaptureMode - _F_cuGetProcAddress_v2('cuThreadExchangeStreamCaptureMode', &__cuThreadExchangeStreamCaptureMode, 10010, ptds_mode, NULL) + cuGetProcAddress_v2('cuThreadExchangeStreamCaptureMode', &__cuThreadExchangeStreamCaptureMode, 10010, ptds_mode, NULL) global __cuStreamEndCapture - _F_cuGetProcAddress_v2('cuStreamEndCapture', &__cuStreamEndCapture, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamEndCapture', &__cuStreamEndCapture, 10000, ptds_mode, NULL) global __cuStreamIsCapturing - _F_cuGetProcAddress_v2('cuStreamIsCapturing', &__cuStreamIsCapturing, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamIsCapturing', &__cuStreamIsCapturing, 10000, ptds_mode, NULL) global __cuStreamGetCaptureInfo_v2 - _F_cuGetProcAddress_v2('cuStreamGetCaptureInfo', &__cuStreamGetCaptureInfo_v2, 11030, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamGetCaptureInfo', &__cuStreamGetCaptureInfo_v2, 11030, ptds_mode, NULL) global __cuStreamGetCaptureInfo_v3 - _F_cuGetProcAddress_v2('cuStreamGetCaptureInfo', &__cuStreamGetCaptureInfo_v3, 12030, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamGetCaptureInfo', &__cuStreamGetCaptureInfo_v3, 12030, ptds_mode, NULL) global __cuStreamUpdateCaptureDependencies_v2 - _F_cuGetProcAddress_v2('cuStreamUpdateCaptureDependencies', &__cuStreamUpdateCaptureDependencies_v2, 12030, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamUpdateCaptureDependencies', &__cuStreamUpdateCaptureDependencies_v2, 12030, ptds_mode, NULL) global __cuStreamAttachMemAsync - _F_cuGetProcAddress_v2('cuStreamAttachMemAsync', &__cuStreamAttachMemAsync, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 6000, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamAttachMemAsync', &__cuStreamAttachMemAsync, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 6000, ptds_mode, NULL) global __cuStreamQuery - _F_cuGetProcAddress_v2('cuStreamQuery', &__cuStreamQuery, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamQuery', &__cuStreamQuery, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 2000, ptds_mode, NULL) global __cuStreamSynchronize - _F_cuGetProcAddress_v2('cuStreamSynchronize', &__cuStreamSynchronize, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamSynchronize', &__cuStreamSynchronize, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 2000, ptds_mode, NULL) global __cuStreamDestroy_v2 - _F_cuGetProcAddress_v2('cuStreamDestroy', &__cuStreamDestroy_v2, 4000, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamDestroy', &__cuStreamDestroy_v2, 4000, ptds_mode, NULL) global __cuStreamCopyAttributes - _F_cuGetProcAddress_v2('cuStreamCopyAttributes', &__cuStreamCopyAttributes, 11000, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamCopyAttributes', &__cuStreamCopyAttributes, 11000, ptds_mode, NULL) global __cuStreamGetAttribute - _F_cuGetProcAddress_v2('cuStreamGetAttribute', &__cuStreamGetAttribute, 11000, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamGetAttribute', &__cuStreamGetAttribute, 11000, ptds_mode, NULL) global __cuStreamSetAttribute - _F_cuGetProcAddress_v2('cuStreamSetAttribute', &__cuStreamSetAttribute, 11000, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamSetAttribute', &__cuStreamSetAttribute, 11000, ptds_mode, NULL) global __cuEventCreate - _F_cuGetProcAddress_v2('cuEventCreate', &__cuEventCreate, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuEventCreate', &__cuEventCreate, 2000, ptds_mode, NULL) global __cuEventRecord - _F_cuGetProcAddress_v2('cuEventRecord', &__cuEventRecord, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuEventRecord', &__cuEventRecord, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 2000, ptds_mode, NULL) global __cuEventRecordWithFlags - _F_cuGetProcAddress_v2('cuEventRecordWithFlags', &__cuEventRecordWithFlags, 11010, ptds_mode, NULL) + cuGetProcAddress_v2('cuEventRecordWithFlags', &__cuEventRecordWithFlags, 11010, ptds_mode, NULL) global __cuEventQuery - _F_cuGetProcAddress_v2('cuEventQuery', &__cuEventQuery, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuEventQuery', &__cuEventQuery, 2000, ptds_mode, NULL) global __cuEventSynchronize - _F_cuGetProcAddress_v2('cuEventSynchronize', &__cuEventSynchronize, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuEventSynchronize', &__cuEventSynchronize, 2000, ptds_mode, NULL) global __cuEventDestroy_v2 - _F_cuGetProcAddress_v2('cuEventDestroy', &__cuEventDestroy_v2, 4000, ptds_mode, NULL) + cuGetProcAddress_v2('cuEventDestroy', &__cuEventDestroy_v2, 4000, ptds_mode, NULL) global __cuEventElapsedTime_v2 - _F_cuGetProcAddress_v2('cuEventElapsedTime', &__cuEventElapsedTime_v2, 12080, ptds_mode, NULL) + cuGetProcAddress_v2('cuEventElapsedTime', &__cuEventElapsedTime_v2, 12080, ptds_mode, NULL) global __cuImportExternalMemory - _F_cuGetProcAddress_v2('cuImportExternalMemory', &__cuImportExternalMemory, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuImportExternalMemory', &__cuImportExternalMemory, 10000, ptds_mode, NULL) global __cuExternalMemoryGetMappedBuffer - _F_cuGetProcAddress_v2('cuExternalMemoryGetMappedBuffer', &__cuExternalMemoryGetMappedBuffer, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuExternalMemoryGetMappedBuffer', &__cuExternalMemoryGetMappedBuffer, 10000, ptds_mode, NULL) global __cuExternalMemoryGetMappedMipmappedArray - _F_cuGetProcAddress_v2('cuExternalMemoryGetMappedMipmappedArray', &__cuExternalMemoryGetMappedMipmappedArray, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuExternalMemoryGetMappedMipmappedArray', &__cuExternalMemoryGetMappedMipmappedArray, 10000, ptds_mode, NULL) global __cuDestroyExternalMemory - _F_cuGetProcAddress_v2('cuDestroyExternalMemory', &__cuDestroyExternalMemory, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuDestroyExternalMemory', &__cuDestroyExternalMemory, 10000, ptds_mode, NULL) global __cuImportExternalSemaphore - _F_cuGetProcAddress_v2('cuImportExternalSemaphore', &__cuImportExternalSemaphore, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuImportExternalSemaphore', &__cuImportExternalSemaphore, 10000, ptds_mode, NULL) global __cuSignalExternalSemaphoresAsync - _F_cuGetProcAddress_v2('cuSignalExternalSemaphoresAsync', &__cuSignalExternalSemaphoresAsync, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuSignalExternalSemaphoresAsync', &__cuSignalExternalSemaphoresAsync, 10000, ptds_mode, NULL) global __cuWaitExternalSemaphoresAsync - _F_cuGetProcAddress_v2('cuWaitExternalSemaphoresAsync', &__cuWaitExternalSemaphoresAsync, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuWaitExternalSemaphoresAsync', &__cuWaitExternalSemaphoresAsync, 10000, ptds_mode, NULL) global __cuDestroyExternalSemaphore - _F_cuGetProcAddress_v2('cuDestroyExternalSemaphore', &__cuDestroyExternalSemaphore, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuDestroyExternalSemaphore', &__cuDestroyExternalSemaphore, 10000, ptds_mode, NULL) global __cuStreamWaitValue32_v2 - _F_cuGetProcAddress_v2('cuStreamWaitValue32', &__cuStreamWaitValue32_v2, 11070, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamWaitValue32', &__cuStreamWaitValue32_v2, 11070, ptds_mode, NULL) global __cuStreamWaitValue64_v2 - _F_cuGetProcAddress_v2('cuStreamWaitValue64', &__cuStreamWaitValue64_v2, 11070, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamWaitValue64', &__cuStreamWaitValue64_v2, 11070, ptds_mode, NULL) global __cuStreamWriteValue32_v2 - _F_cuGetProcAddress_v2('cuStreamWriteValue32', &__cuStreamWriteValue32_v2, 11070, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamWriteValue32', &__cuStreamWriteValue32_v2, 11070, ptds_mode, NULL) global __cuStreamWriteValue64_v2 - _F_cuGetProcAddress_v2('cuStreamWriteValue64', &__cuStreamWriteValue64_v2, 11070, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamWriteValue64', &__cuStreamWriteValue64_v2, 11070, ptds_mode, NULL) global __cuStreamBatchMemOp_v2 - _F_cuGetProcAddress_v2('cuStreamBatchMemOp', &__cuStreamBatchMemOp_v2, 11070, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamBatchMemOp', &__cuStreamBatchMemOp_v2, 11070, ptds_mode, NULL) global __cuFuncGetAttribute - _F_cuGetProcAddress_v2('cuFuncGetAttribute', &__cuFuncGetAttribute, 2020, ptds_mode, NULL) + cuGetProcAddress_v2('cuFuncGetAttribute', &__cuFuncGetAttribute, 2020, ptds_mode, NULL) global __cuFuncSetAttribute - _F_cuGetProcAddress_v2('cuFuncSetAttribute', &__cuFuncSetAttribute, 9000, ptds_mode, NULL) + cuGetProcAddress_v2('cuFuncSetAttribute', &__cuFuncSetAttribute, 9000, ptds_mode, NULL) global __cuFuncSetCacheConfig - _F_cuGetProcAddress_v2('cuFuncSetCacheConfig', &__cuFuncSetCacheConfig, 3000, ptds_mode, NULL) + cuGetProcAddress_v2('cuFuncSetCacheConfig', &__cuFuncSetCacheConfig, 3000, ptds_mode, NULL) global __cuFuncGetModule - _F_cuGetProcAddress_v2('cuFuncGetModule', &__cuFuncGetModule, 11000, ptds_mode, NULL) + cuGetProcAddress_v2('cuFuncGetModule', &__cuFuncGetModule, 11000, ptds_mode, NULL) global __cuFuncGetName - _F_cuGetProcAddress_v2('cuFuncGetName', &__cuFuncGetName, 12030, ptds_mode, NULL) + cuGetProcAddress_v2('cuFuncGetName', &__cuFuncGetName, 12030, ptds_mode, NULL) global __cuFuncGetParamInfo - _F_cuGetProcAddress_v2('cuFuncGetParamInfo', &__cuFuncGetParamInfo, 12040, ptds_mode, NULL) + cuGetProcAddress_v2('cuFuncGetParamInfo', &__cuFuncGetParamInfo, 12040, ptds_mode, NULL) global __cuFuncIsLoaded - _F_cuGetProcAddress_v2('cuFuncIsLoaded', &__cuFuncIsLoaded, 12040, ptds_mode, NULL) + cuGetProcAddress_v2('cuFuncIsLoaded', &__cuFuncIsLoaded, 12040, ptds_mode, NULL) global __cuFuncLoad - _F_cuGetProcAddress_v2('cuFuncLoad', &__cuFuncLoad, 12040, ptds_mode, NULL) + cuGetProcAddress_v2('cuFuncLoad', &__cuFuncLoad, 12040, ptds_mode, NULL) global __cuLaunchKernel - _F_cuGetProcAddress_v2('cuLaunchKernel', &__cuLaunchKernel, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 4000, ptds_mode, NULL) + cuGetProcAddress_v2('cuLaunchKernel', &__cuLaunchKernel, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 4000, ptds_mode, NULL) global __cuLaunchKernelEx - _F_cuGetProcAddress_v2('cuLaunchKernelEx', &__cuLaunchKernelEx, 11060, ptds_mode, NULL) + cuGetProcAddress_v2('cuLaunchKernelEx', &__cuLaunchKernelEx, 11060, ptds_mode, NULL) global __cuLaunchCooperativeKernel - _F_cuGetProcAddress_v2('cuLaunchCooperativeKernel', &__cuLaunchCooperativeKernel, 9000, ptds_mode, NULL) + cuGetProcAddress_v2('cuLaunchCooperativeKernel', &__cuLaunchCooperativeKernel, 9000, ptds_mode, NULL) global __cuLaunchCooperativeKernelMultiDevice - _F_cuGetProcAddress_v2('cuLaunchCooperativeKernelMultiDevice', &__cuLaunchCooperativeKernelMultiDevice, 9000, ptds_mode, NULL) + cuGetProcAddress_v2('cuLaunchCooperativeKernelMultiDevice', &__cuLaunchCooperativeKernelMultiDevice, 9000, ptds_mode, NULL) global __cuLaunchHostFunc - _F_cuGetProcAddress_v2('cuLaunchHostFunc', &__cuLaunchHostFunc, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuLaunchHostFunc', &__cuLaunchHostFunc, 10000, ptds_mode, NULL) global __cuFuncSetBlockShape - _F_cuGetProcAddress_v2('cuFuncSetBlockShape', &__cuFuncSetBlockShape, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuFuncSetBlockShape', &__cuFuncSetBlockShape, 2000, ptds_mode, NULL) global __cuFuncSetSharedSize - _F_cuGetProcAddress_v2('cuFuncSetSharedSize', &__cuFuncSetSharedSize, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuFuncSetSharedSize', &__cuFuncSetSharedSize, 2000, ptds_mode, NULL) global __cuParamSetSize - _F_cuGetProcAddress_v2('cuParamSetSize', &__cuParamSetSize, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuParamSetSize', &__cuParamSetSize, 2000, ptds_mode, NULL) global __cuParamSeti - _F_cuGetProcAddress_v2('cuParamSeti', &__cuParamSeti, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuParamSeti', &__cuParamSeti, 2000, ptds_mode, NULL) global __cuParamSetf - _F_cuGetProcAddress_v2('cuParamSetf', &__cuParamSetf, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuParamSetf', &__cuParamSetf, 2000, ptds_mode, NULL) global __cuParamSetv - _F_cuGetProcAddress_v2('cuParamSetv', &__cuParamSetv, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuParamSetv', &__cuParamSetv, 2000, ptds_mode, NULL) global __cuLaunch - _F_cuGetProcAddress_v2('cuLaunch', &__cuLaunch, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuLaunch', &__cuLaunch, 2000, ptds_mode, NULL) global __cuLaunchGrid - _F_cuGetProcAddress_v2('cuLaunchGrid', &__cuLaunchGrid, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuLaunchGrid', &__cuLaunchGrid, 2000, ptds_mode, NULL) global __cuLaunchGridAsync - _F_cuGetProcAddress_v2('cuLaunchGridAsync', &__cuLaunchGridAsync, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuLaunchGridAsync', &__cuLaunchGridAsync, 2000, ptds_mode, NULL) global __cuParamSetTexRef - _F_cuGetProcAddress_v2('cuParamSetTexRef', &__cuParamSetTexRef, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuParamSetTexRef', &__cuParamSetTexRef, 2000, ptds_mode, NULL) global __cuFuncSetSharedMemConfig - _F_cuGetProcAddress_v2('cuFuncSetSharedMemConfig', &__cuFuncSetSharedMemConfig, 4020, ptds_mode, NULL) + cuGetProcAddress_v2('cuFuncSetSharedMemConfig', &__cuFuncSetSharedMemConfig, 4020, ptds_mode, NULL) global __cuGraphCreate - _F_cuGetProcAddress_v2('cuGraphCreate', &__cuGraphCreate, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphCreate', &__cuGraphCreate, 10000, ptds_mode, NULL) global __cuGraphAddKernelNode_v2 - _F_cuGetProcAddress_v2('cuGraphAddKernelNode', &__cuGraphAddKernelNode_v2, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphAddKernelNode', &__cuGraphAddKernelNode_v2, 12000, ptds_mode, NULL) global __cuGraphKernelNodeGetParams_v2 - _F_cuGetProcAddress_v2('cuGraphKernelNodeGetParams', &__cuGraphKernelNodeGetParams_v2, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphKernelNodeGetParams', &__cuGraphKernelNodeGetParams_v2, 12000, ptds_mode, NULL) global __cuGraphKernelNodeSetParams_v2 - _F_cuGetProcAddress_v2('cuGraphKernelNodeSetParams', &__cuGraphKernelNodeSetParams_v2, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphKernelNodeSetParams', &__cuGraphKernelNodeSetParams_v2, 12000, ptds_mode, NULL) global __cuGraphAddMemcpyNode - _F_cuGetProcAddress_v2('cuGraphAddMemcpyNode', &__cuGraphAddMemcpyNode, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphAddMemcpyNode', &__cuGraphAddMemcpyNode, 10000, ptds_mode, NULL) global __cuGraphMemcpyNodeGetParams - _F_cuGetProcAddress_v2('cuGraphMemcpyNodeGetParams', &__cuGraphMemcpyNodeGetParams, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphMemcpyNodeGetParams', &__cuGraphMemcpyNodeGetParams, 10000, ptds_mode, NULL) global __cuGraphMemcpyNodeSetParams - _F_cuGetProcAddress_v2('cuGraphMemcpyNodeSetParams', &__cuGraphMemcpyNodeSetParams, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphMemcpyNodeSetParams', &__cuGraphMemcpyNodeSetParams, 10000, ptds_mode, NULL) global __cuGraphAddMemsetNode - _F_cuGetProcAddress_v2('cuGraphAddMemsetNode', &__cuGraphAddMemsetNode, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphAddMemsetNode', &__cuGraphAddMemsetNode, 10000, ptds_mode, NULL) global __cuGraphMemsetNodeGetParams - _F_cuGetProcAddress_v2('cuGraphMemsetNodeGetParams', &__cuGraphMemsetNodeGetParams, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphMemsetNodeGetParams', &__cuGraphMemsetNodeGetParams, 10000, ptds_mode, NULL) global __cuGraphMemsetNodeSetParams - _F_cuGetProcAddress_v2('cuGraphMemsetNodeSetParams', &__cuGraphMemsetNodeSetParams, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphMemsetNodeSetParams', &__cuGraphMemsetNodeSetParams, 10000, ptds_mode, NULL) global __cuGraphAddHostNode - _F_cuGetProcAddress_v2('cuGraphAddHostNode', &__cuGraphAddHostNode, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphAddHostNode', &__cuGraphAddHostNode, 10000, ptds_mode, NULL) global __cuGraphHostNodeGetParams - _F_cuGetProcAddress_v2('cuGraphHostNodeGetParams', &__cuGraphHostNodeGetParams, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphHostNodeGetParams', &__cuGraphHostNodeGetParams, 10000, ptds_mode, NULL) global __cuGraphHostNodeSetParams - _F_cuGetProcAddress_v2('cuGraphHostNodeSetParams', &__cuGraphHostNodeSetParams, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphHostNodeSetParams', &__cuGraphHostNodeSetParams, 10000, ptds_mode, NULL) global __cuGraphAddChildGraphNode - _F_cuGetProcAddress_v2('cuGraphAddChildGraphNode', &__cuGraphAddChildGraphNode, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphAddChildGraphNode', &__cuGraphAddChildGraphNode, 10000, ptds_mode, NULL) global __cuGraphChildGraphNodeGetGraph - _F_cuGetProcAddress_v2('cuGraphChildGraphNodeGetGraph', &__cuGraphChildGraphNodeGetGraph, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphChildGraphNodeGetGraph', &__cuGraphChildGraphNodeGetGraph, 10000, ptds_mode, NULL) global __cuGraphAddEmptyNode - _F_cuGetProcAddress_v2('cuGraphAddEmptyNode', &__cuGraphAddEmptyNode, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphAddEmptyNode', &__cuGraphAddEmptyNode, 10000, ptds_mode, NULL) global __cuGraphAddEventRecordNode - _F_cuGetProcAddress_v2('cuGraphAddEventRecordNode', &__cuGraphAddEventRecordNode, 11010, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphAddEventRecordNode', &__cuGraphAddEventRecordNode, 11010, ptds_mode, NULL) global __cuGraphEventRecordNodeGetEvent - _F_cuGetProcAddress_v2('cuGraphEventRecordNodeGetEvent', &__cuGraphEventRecordNodeGetEvent, 11010, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphEventRecordNodeGetEvent', &__cuGraphEventRecordNodeGetEvent, 11010, ptds_mode, NULL) global __cuGraphEventRecordNodeSetEvent - _F_cuGetProcAddress_v2('cuGraphEventRecordNodeSetEvent', &__cuGraphEventRecordNodeSetEvent, 11010, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphEventRecordNodeSetEvent', &__cuGraphEventRecordNodeSetEvent, 11010, ptds_mode, NULL) global __cuGraphAddEventWaitNode - _F_cuGetProcAddress_v2('cuGraphAddEventWaitNode', &__cuGraphAddEventWaitNode, 11010, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphAddEventWaitNode', &__cuGraphAddEventWaitNode, 11010, ptds_mode, NULL) global __cuGraphEventWaitNodeGetEvent - _F_cuGetProcAddress_v2('cuGraphEventWaitNodeGetEvent', &__cuGraphEventWaitNodeGetEvent, 11010, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphEventWaitNodeGetEvent', &__cuGraphEventWaitNodeGetEvent, 11010, ptds_mode, NULL) global __cuGraphEventWaitNodeSetEvent - _F_cuGetProcAddress_v2('cuGraphEventWaitNodeSetEvent', &__cuGraphEventWaitNodeSetEvent, 11010, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphEventWaitNodeSetEvent', &__cuGraphEventWaitNodeSetEvent, 11010, ptds_mode, NULL) global __cuGraphAddExternalSemaphoresSignalNode - _F_cuGetProcAddress_v2('cuGraphAddExternalSemaphoresSignalNode', &__cuGraphAddExternalSemaphoresSignalNode, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphAddExternalSemaphoresSignalNode', &__cuGraphAddExternalSemaphoresSignalNode, 11020, ptds_mode, NULL) global __cuGraphExternalSemaphoresSignalNodeGetParams - _F_cuGetProcAddress_v2('cuGraphExternalSemaphoresSignalNodeGetParams', &__cuGraphExternalSemaphoresSignalNodeGetParams, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphExternalSemaphoresSignalNodeGetParams', &__cuGraphExternalSemaphoresSignalNodeGetParams, 11020, ptds_mode, NULL) global __cuGraphExternalSemaphoresSignalNodeSetParams - _F_cuGetProcAddress_v2('cuGraphExternalSemaphoresSignalNodeSetParams', &__cuGraphExternalSemaphoresSignalNodeSetParams, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphExternalSemaphoresSignalNodeSetParams', &__cuGraphExternalSemaphoresSignalNodeSetParams, 11020, ptds_mode, NULL) global __cuGraphAddExternalSemaphoresWaitNode - _F_cuGetProcAddress_v2('cuGraphAddExternalSemaphoresWaitNode', &__cuGraphAddExternalSemaphoresWaitNode, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphAddExternalSemaphoresWaitNode', &__cuGraphAddExternalSemaphoresWaitNode, 11020, ptds_mode, NULL) global __cuGraphExternalSemaphoresWaitNodeGetParams - _F_cuGetProcAddress_v2('cuGraphExternalSemaphoresWaitNodeGetParams', &__cuGraphExternalSemaphoresWaitNodeGetParams, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphExternalSemaphoresWaitNodeGetParams', &__cuGraphExternalSemaphoresWaitNodeGetParams, 11020, ptds_mode, NULL) global __cuGraphExternalSemaphoresWaitNodeSetParams - _F_cuGetProcAddress_v2('cuGraphExternalSemaphoresWaitNodeSetParams', &__cuGraphExternalSemaphoresWaitNodeSetParams, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphExternalSemaphoresWaitNodeSetParams', &__cuGraphExternalSemaphoresWaitNodeSetParams, 11020, ptds_mode, NULL) global __cuGraphAddBatchMemOpNode - _F_cuGetProcAddress_v2('cuGraphAddBatchMemOpNode', &__cuGraphAddBatchMemOpNode, 11070, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphAddBatchMemOpNode', &__cuGraphAddBatchMemOpNode, 11070, ptds_mode, NULL) global __cuGraphBatchMemOpNodeGetParams - _F_cuGetProcAddress_v2('cuGraphBatchMemOpNodeGetParams', &__cuGraphBatchMemOpNodeGetParams, 11070, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphBatchMemOpNodeGetParams', &__cuGraphBatchMemOpNodeGetParams, 11070, ptds_mode, NULL) global __cuGraphBatchMemOpNodeSetParams - _F_cuGetProcAddress_v2('cuGraphBatchMemOpNodeSetParams', &__cuGraphBatchMemOpNodeSetParams, 11070, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphBatchMemOpNodeSetParams', &__cuGraphBatchMemOpNodeSetParams, 11070, ptds_mode, NULL) global __cuGraphExecBatchMemOpNodeSetParams - _F_cuGetProcAddress_v2('cuGraphExecBatchMemOpNodeSetParams', &__cuGraphExecBatchMemOpNodeSetParams, 11070, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphExecBatchMemOpNodeSetParams', &__cuGraphExecBatchMemOpNodeSetParams, 11070, ptds_mode, NULL) global __cuGraphAddMemAllocNode - _F_cuGetProcAddress_v2('cuGraphAddMemAllocNode', &__cuGraphAddMemAllocNode, 11040, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphAddMemAllocNode', &__cuGraphAddMemAllocNode, 11040, ptds_mode, NULL) global __cuGraphMemAllocNodeGetParams - _F_cuGetProcAddress_v2('cuGraphMemAllocNodeGetParams', &__cuGraphMemAllocNodeGetParams, 11040, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphMemAllocNodeGetParams', &__cuGraphMemAllocNodeGetParams, 11040, ptds_mode, NULL) global __cuGraphAddMemFreeNode - _F_cuGetProcAddress_v2('cuGraphAddMemFreeNode', &__cuGraphAddMemFreeNode, 11040, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphAddMemFreeNode', &__cuGraphAddMemFreeNode, 11040, ptds_mode, NULL) global __cuGraphMemFreeNodeGetParams - _F_cuGetProcAddress_v2('cuGraphMemFreeNodeGetParams', &__cuGraphMemFreeNodeGetParams, 11040, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphMemFreeNodeGetParams', &__cuGraphMemFreeNodeGetParams, 11040, ptds_mode, NULL) global __cuDeviceGraphMemTrim - _F_cuGetProcAddress_v2('cuDeviceGraphMemTrim', &__cuDeviceGraphMemTrim, 11040, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceGraphMemTrim', &__cuDeviceGraphMemTrim, 11040, ptds_mode, NULL) global __cuDeviceGetGraphMemAttribute - _F_cuGetProcAddress_v2('cuDeviceGetGraphMemAttribute', &__cuDeviceGetGraphMemAttribute, 11040, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceGetGraphMemAttribute', &__cuDeviceGetGraphMemAttribute, 11040, ptds_mode, NULL) global __cuDeviceSetGraphMemAttribute - _F_cuGetProcAddress_v2('cuDeviceSetGraphMemAttribute', &__cuDeviceSetGraphMemAttribute, 11040, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceSetGraphMemAttribute', &__cuDeviceSetGraphMemAttribute, 11040, ptds_mode, NULL) global __cuGraphClone - _F_cuGetProcAddress_v2('cuGraphClone', &__cuGraphClone, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphClone', &__cuGraphClone, 10000, ptds_mode, NULL) global __cuGraphNodeFindInClone - _F_cuGetProcAddress_v2('cuGraphNodeFindInClone', &__cuGraphNodeFindInClone, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphNodeFindInClone', &__cuGraphNodeFindInClone, 10000, ptds_mode, NULL) global __cuGraphNodeGetType - _F_cuGetProcAddress_v2('cuGraphNodeGetType', &__cuGraphNodeGetType, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphNodeGetType', &__cuGraphNodeGetType, 10000, ptds_mode, NULL) global __cuGraphGetNodes - _F_cuGetProcAddress_v2('cuGraphGetNodes', &__cuGraphGetNodes, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphGetNodes', &__cuGraphGetNodes, 10000, ptds_mode, NULL) global __cuGraphGetRootNodes - _F_cuGetProcAddress_v2('cuGraphGetRootNodes', &__cuGraphGetRootNodes, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphGetRootNodes', &__cuGraphGetRootNodes, 10000, ptds_mode, NULL) global __cuGraphGetEdges_v2 - _F_cuGetProcAddress_v2('cuGraphGetEdges', &__cuGraphGetEdges_v2, 12030, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphGetEdges', &__cuGraphGetEdges_v2, 12030, ptds_mode, NULL) global __cuGraphNodeGetDependencies_v2 - _F_cuGetProcAddress_v2('cuGraphNodeGetDependencies', &__cuGraphNodeGetDependencies_v2, 12030, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphNodeGetDependencies', &__cuGraphNodeGetDependencies_v2, 12030, ptds_mode, NULL) global __cuGraphNodeGetDependentNodes_v2 - _F_cuGetProcAddress_v2('cuGraphNodeGetDependentNodes', &__cuGraphNodeGetDependentNodes_v2, 12030, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphNodeGetDependentNodes', &__cuGraphNodeGetDependentNodes_v2, 12030, ptds_mode, NULL) global __cuGraphAddDependencies_v2 - _F_cuGetProcAddress_v2('cuGraphAddDependencies', &__cuGraphAddDependencies_v2, 12030, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphAddDependencies', &__cuGraphAddDependencies_v2, 12030, ptds_mode, NULL) global __cuGraphRemoveDependencies_v2 - _F_cuGetProcAddress_v2('cuGraphRemoveDependencies', &__cuGraphRemoveDependencies_v2, 12030, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphRemoveDependencies', &__cuGraphRemoveDependencies_v2, 12030, ptds_mode, NULL) global __cuGraphDestroyNode - _F_cuGetProcAddress_v2('cuGraphDestroyNode', &__cuGraphDestroyNode, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphDestroyNode', &__cuGraphDestroyNode, 10000, ptds_mode, NULL) global __cuGraphInstantiateWithFlags - _F_cuGetProcAddress_v2('cuGraphInstantiateWithFlags', &__cuGraphInstantiateWithFlags, 11040, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphInstantiateWithFlags', &__cuGraphInstantiateWithFlags, 11040, ptds_mode, NULL) global __cuGraphInstantiateWithParams - _F_cuGetProcAddress_v2('cuGraphInstantiateWithParams', &__cuGraphInstantiateWithParams, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphInstantiateWithParams', &__cuGraphInstantiateWithParams, 12000, ptds_mode, NULL) global __cuGraphExecGetFlags - _F_cuGetProcAddress_v2('cuGraphExecGetFlags', &__cuGraphExecGetFlags, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphExecGetFlags', &__cuGraphExecGetFlags, 12000, ptds_mode, NULL) global __cuGraphExecKernelNodeSetParams_v2 - _F_cuGetProcAddress_v2('cuGraphExecKernelNodeSetParams', &__cuGraphExecKernelNodeSetParams_v2, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphExecKernelNodeSetParams', &__cuGraphExecKernelNodeSetParams_v2, 12000, ptds_mode, NULL) global __cuGraphExecMemcpyNodeSetParams - _F_cuGetProcAddress_v2('cuGraphExecMemcpyNodeSetParams', &__cuGraphExecMemcpyNodeSetParams, 10020, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphExecMemcpyNodeSetParams', &__cuGraphExecMemcpyNodeSetParams, 10020, ptds_mode, NULL) global __cuGraphExecMemsetNodeSetParams - _F_cuGetProcAddress_v2('cuGraphExecMemsetNodeSetParams', &__cuGraphExecMemsetNodeSetParams, 10020, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphExecMemsetNodeSetParams', &__cuGraphExecMemsetNodeSetParams, 10020, ptds_mode, NULL) global __cuGraphExecHostNodeSetParams - _F_cuGetProcAddress_v2('cuGraphExecHostNodeSetParams', &__cuGraphExecHostNodeSetParams, 10020, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphExecHostNodeSetParams', &__cuGraphExecHostNodeSetParams, 10020, ptds_mode, NULL) global __cuGraphExecChildGraphNodeSetParams - _F_cuGetProcAddress_v2('cuGraphExecChildGraphNodeSetParams', &__cuGraphExecChildGraphNodeSetParams, 11010, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphExecChildGraphNodeSetParams', &__cuGraphExecChildGraphNodeSetParams, 11010, ptds_mode, NULL) global __cuGraphExecEventRecordNodeSetEvent - _F_cuGetProcAddress_v2('cuGraphExecEventRecordNodeSetEvent', &__cuGraphExecEventRecordNodeSetEvent, 11010, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphExecEventRecordNodeSetEvent', &__cuGraphExecEventRecordNodeSetEvent, 11010, ptds_mode, NULL) global __cuGraphExecEventWaitNodeSetEvent - _F_cuGetProcAddress_v2('cuGraphExecEventWaitNodeSetEvent', &__cuGraphExecEventWaitNodeSetEvent, 11010, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphExecEventWaitNodeSetEvent', &__cuGraphExecEventWaitNodeSetEvent, 11010, ptds_mode, NULL) global __cuGraphExecExternalSemaphoresSignalNodeSetParams - _F_cuGetProcAddress_v2('cuGraphExecExternalSemaphoresSignalNodeSetParams', &__cuGraphExecExternalSemaphoresSignalNodeSetParams, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphExecExternalSemaphoresSignalNodeSetParams', &__cuGraphExecExternalSemaphoresSignalNodeSetParams, 11020, ptds_mode, NULL) global __cuGraphExecExternalSemaphoresWaitNodeSetParams - _F_cuGetProcAddress_v2('cuGraphExecExternalSemaphoresWaitNodeSetParams', &__cuGraphExecExternalSemaphoresWaitNodeSetParams, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphExecExternalSemaphoresWaitNodeSetParams', &__cuGraphExecExternalSemaphoresWaitNodeSetParams, 11020, ptds_mode, NULL) global __cuGraphNodeSetEnabled - _F_cuGetProcAddress_v2('cuGraphNodeSetEnabled', &__cuGraphNodeSetEnabled, 11060, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphNodeSetEnabled', &__cuGraphNodeSetEnabled, 11060, ptds_mode, NULL) global __cuGraphNodeGetEnabled - _F_cuGetProcAddress_v2('cuGraphNodeGetEnabled', &__cuGraphNodeGetEnabled, 11060, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphNodeGetEnabled', &__cuGraphNodeGetEnabled, 11060, ptds_mode, NULL) global __cuGraphUpload - _F_cuGetProcAddress_v2('cuGraphUpload', &__cuGraphUpload, 11010, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphUpload', &__cuGraphUpload, 11010, ptds_mode, NULL) global __cuGraphLaunch - _F_cuGetProcAddress_v2('cuGraphLaunch', &__cuGraphLaunch, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphLaunch', &__cuGraphLaunch, 10000, ptds_mode, NULL) global __cuGraphExecDestroy - _F_cuGetProcAddress_v2('cuGraphExecDestroy', &__cuGraphExecDestroy, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphExecDestroy', &__cuGraphExecDestroy, 10000, ptds_mode, NULL) global __cuGraphDestroy - _F_cuGetProcAddress_v2('cuGraphDestroy', &__cuGraphDestroy, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphDestroy', &__cuGraphDestroy, 10000, ptds_mode, NULL) global __cuGraphExecUpdate_v2 - _F_cuGetProcAddress_v2('cuGraphExecUpdate', &__cuGraphExecUpdate_v2, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphExecUpdate', &__cuGraphExecUpdate_v2, 12000, ptds_mode, NULL) global __cuGraphKernelNodeCopyAttributes - _F_cuGetProcAddress_v2('cuGraphKernelNodeCopyAttributes', &__cuGraphKernelNodeCopyAttributes, 11000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphKernelNodeCopyAttributes', &__cuGraphKernelNodeCopyAttributes, 11000, ptds_mode, NULL) global __cuGraphKernelNodeGetAttribute - _F_cuGetProcAddress_v2('cuGraphKernelNodeGetAttribute', &__cuGraphKernelNodeGetAttribute, 11000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphKernelNodeGetAttribute', &__cuGraphKernelNodeGetAttribute, 11000, ptds_mode, NULL) global __cuGraphKernelNodeSetAttribute - _F_cuGetProcAddress_v2('cuGraphKernelNodeSetAttribute', &__cuGraphKernelNodeSetAttribute, 11000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphKernelNodeSetAttribute', &__cuGraphKernelNodeSetAttribute, 11000, ptds_mode, NULL) global __cuGraphDebugDotPrint - _F_cuGetProcAddress_v2('cuGraphDebugDotPrint', &__cuGraphDebugDotPrint, 11030, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphDebugDotPrint', &__cuGraphDebugDotPrint, 11030, ptds_mode, NULL) global __cuUserObjectCreate - _F_cuGetProcAddress_v2('cuUserObjectCreate', &__cuUserObjectCreate, 11030, ptds_mode, NULL) + cuGetProcAddress_v2('cuUserObjectCreate', &__cuUserObjectCreate, 11030, ptds_mode, NULL) global __cuUserObjectRetain - _F_cuGetProcAddress_v2('cuUserObjectRetain', &__cuUserObjectRetain, 11030, ptds_mode, NULL) + cuGetProcAddress_v2('cuUserObjectRetain', &__cuUserObjectRetain, 11030, ptds_mode, NULL) global __cuUserObjectRelease - _F_cuGetProcAddress_v2('cuUserObjectRelease', &__cuUserObjectRelease, 11030, ptds_mode, NULL) + cuGetProcAddress_v2('cuUserObjectRelease', &__cuUserObjectRelease, 11030, ptds_mode, NULL) global __cuGraphRetainUserObject - _F_cuGetProcAddress_v2('cuGraphRetainUserObject', &__cuGraphRetainUserObject, 11030, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphRetainUserObject', &__cuGraphRetainUserObject, 11030, ptds_mode, NULL) global __cuGraphReleaseUserObject - _F_cuGetProcAddress_v2('cuGraphReleaseUserObject', &__cuGraphReleaseUserObject, 11030, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphReleaseUserObject', &__cuGraphReleaseUserObject, 11030, ptds_mode, NULL) global __cuGraphAddNode_v2 - _F_cuGetProcAddress_v2('cuGraphAddNode', &__cuGraphAddNode_v2, 12030, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphAddNode', &__cuGraphAddNode_v2, 12030, ptds_mode, NULL) global __cuGraphNodeSetParams - _F_cuGetProcAddress_v2('cuGraphNodeSetParams', &__cuGraphNodeSetParams, 12020, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphNodeSetParams', &__cuGraphNodeSetParams, 12020, ptds_mode, NULL) global __cuGraphExecNodeSetParams - _F_cuGetProcAddress_v2('cuGraphExecNodeSetParams', &__cuGraphExecNodeSetParams, 12020, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphExecNodeSetParams', &__cuGraphExecNodeSetParams, 12020, ptds_mode, NULL) global __cuGraphConditionalHandleCreate - _F_cuGetProcAddress_v2('cuGraphConditionalHandleCreate', &__cuGraphConditionalHandleCreate, 12030, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphConditionalHandleCreate', &__cuGraphConditionalHandleCreate, 12030, ptds_mode, NULL) global __cuOccupancyMaxActiveBlocksPerMultiprocessor - _F_cuGetProcAddress_v2('cuOccupancyMaxActiveBlocksPerMultiprocessor', &__cuOccupancyMaxActiveBlocksPerMultiprocessor, 6050, ptds_mode, NULL) + cuGetProcAddress_v2('cuOccupancyMaxActiveBlocksPerMultiprocessor', &__cuOccupancyMaxActiveBlocksPerMultiprocessor, 6050, ptds_mode, NULL) global __cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags - _F_cuGetProcAddress_v2('cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags', &__cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags, 7000, ptds_mode, NULL) + cuGetProcAddress_v2('cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags', &__cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags, 7000, ptds_mode, NULL) global __cuOccupancyMaxPotentialBlockSize - _F_cuGetProcAddress_v2('cuOccupancyMaxPotentialBlockSize', &__cuOccupancyMaxPotentialBlockSize, 6050, ptds_mode, NULL) + cuGetProcAddress_v2('cuOccupancyMaxPotentialBlockSize', &__cuOccupancyMaxPotentialBlockSize, 6050, ptds_mode, NULL) global __cuOccupancyMaxPotentialBlockSizeWithFlags - _F_cuGetProcAddress_v2('cuOccupancyMaxPotentialBlockSizeWithFlags', &__cuOccupancyMaxPotentialBlockSizeWithFlags, 7000, ptds_mode, NULL) + cuGetProcAddress_v2('cuOccupancyMaxPotentialBlockSizeWithFlags', &__cuOccupancyMaxPotentialBlockSizeWithFlags, 7000, ptds_mode, NULL) global __cuOccupancyAvailableDynamicSMemPerBlock - _F_cuGetProcAddress_v2('cuOccupancyAvailableDynamicSMemPerBlock', &__cuOccupancyAvailableDynamicSMemPerBlock, 10020, ptds_mode, NULL) + cuGetProcAddress_v2('cuOccupancyAvailableDynamicSMemPerBlock', &__cuOccupancyAvailableDynamicSMemPerBlock, 10020, ptds_mode, NULL) global __cuOccupancyMaxPotentialClusterSize - _F_cuGetProcAddress_v2('cuOccupancyMaxPotentialClusterSize', &__cuOccupancyMaxPotentialClusterSize, 11070, ptds_mode, NULL) + cuGetProcAddress_v2('cuOccupancyMaxPotentialClusterSize', &__cuOccupancyMaxPotentialClusterSize, 11070, ptds_mode, NULL) global __cuOccupancyMaxActiveClusters - _F_cuGetProcAddress_v2('cuOccupancyMaxActiveClusters', &__cuOccupancyMaxActiveClusters, 11070, ptds_mode, NULL) + cuGetProcAddress_v2('cuOccupancyMaxActiveClusters', &__cuOccupancyMaxActiveClusters, 11070, ptds_mode, NULL) global __cuTexRefSetArray - _F_cuGetProcAddress_v2('cuTexRefSetArray', &__cuTexRefSetArray, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefSetArray', &__cuTexRefSetArray, 2000, ptds_mode, NULL) global __cuTexRefSetMipmappedArray - _F_cuGetProcAddress_v2('cuTexRefSetMipmappedArray', &__cuTexRefSetMipmappedArray, 5000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefSetMipmappedArray', &__cuTexRefSetMipmappedArray, 5000, ptds_mode, NULL) global __cuTexRefSetAddress_v2 - _F_cuGetProcAddress_v2('cuTexRefSetAddress', &__cuTexRefSetAddress_v2, 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefSetAddress', &__cuTexRefSetAddress_v2, 3020, ptds_mode, NULL) global __cuTexRefSetAddress2D_v3 - _F_cuGetProcAddress_v2('cuTexRefSetAddress2D', &__cuTexRefSetAddress2D_v3, 4010, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefSetAddress2D', &__cuTexRefSetAddress2D_v3, 4010, ptds_mode, NULL) global __cuTexRefSetFormat - _F_cuGetProcAddress_v2('cuTexRefSetFormat', &__cuTexRefSetFormat, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefSetFormat', &__cuTexRefSetFormat, 2000, ptds_mode, NULL) global __cuTexRefSetAddressMode - _F_cuGetProcAddress_v2('cuTexRefSetAddressMode', &__cuTexRefSetAddressMode, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefSetAddressMode', &__cuTexRefSetAddressMode, 2000, ptds_mode, NULL) global __cuTexRefSetFilterMode - _F_cuGetProcAddress_v2('cuTexRefSetFilterMode', &__cuTexRefSetFilterMode, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefSetFilterMode', &__cuTexRefSetFilterMode, 2000, ptds_mode, NULL) global __cuTexRefSetMipmapFilterMode - _F_cuGetProcAddress_v2('cuTexRefSetMipmapFilterMode', &__cuTexRefSetMipmapFilterMode, 5000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefSetMipmapFilterMode', &__cuTexRefSetMipmapFilterMode, 5000, ptds_mode, NULL) global __cuTexRefSetMipmapLevelBias - _F_cuGetProcAddress_v2('cuTexRefSetMipmapLevelBias', &__cuTexRefSetMipmapLevelBias, 5000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefSetMipmapLevelBias', &__cuTexRefSetMipmapLevelBias, 5000, ptds_mode, NULL) global __cuTexRefSetMipmapLevelClamp - _F_cuGetProcAddress_v2('cuTexRefSetMipmapLevelClamp', &__cuTexRefSetMipmapLevelClamp, 5000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefSetMipmapLevelClamp', &__cuTexRefSetMipmapLevelClamp, 5000, ptds_mode, NULL) global __cuTexRefSetMaxAnisotropy - _F_cuGetProcAddress_v2('cuTexRefSetMaxAnisotropy', &__cuTexRefSetMaxAnisotropy, 5000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefSetMaxAnisotropy', &__cuTexRefSetMaxAnisotropy, 5000, ptds_mode, NULL) global __cuTexRefSetBorderColor - _F_cuGetProcAddress_v2('cuTexRefSetBorderColor', &__cuTexRefSetBorderColor, 8000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefSetBorderColor', &__cuTexRefSetBorderColor, 8000, ptds_mode, NULL) global __cuTexRefSetFlags - _F_cuGetProcAddress_v2('cuTexRefSetFlags', &__cuTexRefSetFlags, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefSetFlags', &__cuTexRefSetFlags, 2000, ptds_mode, NULL) global __cuTexRefGetAddress_v2 - _F_cuGetProcAddress_v2('cuTexRefGetAddress', &__cuTexRefGetAddress_v2, 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefGetAddress', &__cuTexRefGetAddress_v2, 3020, ptds_mode, NULL) global __cuTexRefGetArray - _F_cuGetProcAddress_v2('cuTexRefGetArray', &__cuTexRefGetArray, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefGetArray', &__cuTexRefGetArray, 2000, ptds_mode, NULL) global __cuTexRefGetMipmappedArray - _F_cuGetProcAddress_v2('cuTexRefGetMipmappedArray', &__cuTexRefGetMipmappedArray, 5000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefGetMipmappedArray', &__cuTexRefGetMipmappedArray, 5000, ptds_mode, NULL) global __cuTexRefGetAddressMode - _F_cuGetProcAddress_v2('cuTexRefGetAddressMode', &__cuTexRefGetAddressMode, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefGetAddressMode', &__cuTexRefGetAddressMode, 2000, ptds_mode, NULL) global __cuTexRefGetFilterMode - _F_cuGetProcAddress_v2('cuTexRefGetFilterMode', &__cuTexRefGetFilterMode, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefGetFilterMode', &__cuTexRefGetFilterMode, 2000, ptds_mode, NULL) global __cuTexRefGetFormat - _F_cuGetProcAddress_v2('cuTexRefGetFormat', &__cuTexRefGetFormat, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefGetFormat', &__cuTexRefGetFormat, 2000, ptds_mode, NULL) global __cuTexRefGetMipmapFilterMode - _F_cuGetProcAddress_v2('cuTexRefGetMipmapFilterMode', &__cuTexRefGetMipmapFilterMode, 5000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefGetMipmapFilterMode', &__cuTexRefGetMipmapFilterMode, 5000, ptds_mode, NULL) global __cuTexRefGetMipmapLevelBias - _F_cuGetProcAddress_v2('cuTexRefGetMipmapLevelBias', &__cuTexRefGetMipmapLevelBias, 5000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefGetMipmapLevelBias', &__cuTexRefGetMipmapLevelBias, 5000, ptds_mode, NULL) global __cuTexRefGetMipmapLevelClamp - _F_cuGetProcAddress_v2('cuTexRefGetMipmapLevelClamp', &__cuTexRefGetMipmapLevelClamp, 5000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefGetMipmapLevelClamp', &__cuTexRefGetMipmapLevelClamp, 5000, ptds_mode, NULL) global __cuTexRefGetMaxAnisotropy - _F_cuGetProcAddress_v2('cuTexRefGetMaxAnisotropy', &__cuTexRefGetMaxAnisotropy, 5000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefGetMaxAnisotropy', &__cuTexRefGetMaxAnisotropy, 5000, ptds_mode, NULL) global __cuTexRefGetBorderColor - _F_cuGetProcAddress_v2('cuTexRefGetBorderColor', &__cuTexRefGetBorderColor, 8000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefGetBorderColor', &__cuTexRefGetBorderColor, 8000, ptds_mode, NULL) global __cuTexRefGetFlags - _F_cuGetProcAddress_v2('cuTexRefGetFlags', &__cuTexRefGetFlags, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefGetFlags', &__cuTexRefGetFlags, 2000, ptds_mode, NULL) global __cuTexRefCreate - _F_cuGetProcAddress_v2('cuTexRefCreate', &__cuTexRefCreate, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefCreate', &__cuTexRefCreate, 2000, ptds_mode, NULL) global __cuTexRefDestroy - _F_cuGetProcAddress_v2('cuTexRefDestroy', &__cuTexRefDestroy, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefDestroy', &__cuTexRefDestroy, 2000, ptds_mode, NULL) global __cuSurfRefSetArray - _F_cuGetProcAddress_v2('cuSurfRefSetArray', &__cuSurfRefSetArray, 3000, ptds_mode, NULL) + cuGetProcAddress_v2('cuSurfRefSetArray', &__cuSurfRefSetArray, 3000, ptds_mode, NULL) global __cuSurfRefGetArray - _F_cuGetProcAddress_v2('cuSurfRefGetArray', &__cuSurfRefGetArray, 3000, ptds_mode, NULL) + cuGetProcAddress_v2('cuSurfRefGetArray', &__cuSurfRefGetArray, 3000, ptds_mode, NULL) global __cuTexObjectCreate - _F_cuGetProcAddress_v2('cuTexObjectCreate', &__cuTexObjectCreate, 5000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexObjectCreate', &__cuTexObjectCreate, 5000, ptds_mode, NULL) global __cuTexObjectDestroy - _F_cuGetProcAddress_v2('cuTexObjectDestroy', &__cuTexObjectDestroy, 5000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexObjectDestroy', &__cuTexObjectDestroy, 5000, ptds_mode, NULL) global __cuTexObjectGetResourceDesc - _F_cuGetProcAddress_v2('cuTexObjectGetResourceDesc', &__cuTexObjectGetResourceDesc, 5000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexObjectGetResourceDesc', &__cuTexObjectGetResourceDesc, 5000, ptds_mode, NULL) global __cuTexObjectGetTextureDesc - _F_cuGetProcAddress_v2('cuTexObjectGetTextureDesc', &__cuTexObjectGetTextureDesc, 5000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexObjectGetTextureDesc', &__cuTexObjectGetTextureDesc, 5000, ptds_mode, NULL) global __cuTexObjectGetResourceViewDesc - _F_cuGetProcAddress_v2('cuTexObjectGetResourceViewDesc', &__cuTexObjectGetResourceViewDesc, 5000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexObjectGetResourceViewDesc', &__cuTexObjectGetResourceViewDesc, 5000, ptds_mode, NULL) global __cuSurfObjectCreate - _F_cuGetProcAddress_v2('cuSurfObjectCreate', &__cuSurfObjectCreate, 5000, ptds_mode, NULL) + cuGetProcAddress_v2('cuSurfObjectCreate', &__cuSurfObjectCreate, 5000, ptds_mode, NULL) global __cuSurfObjectDestroy - _F_cuGetProcAddress_v2('cuSurfObjectDestroy', &__cuSurfObjectDestroy, 5000, ptds_mode, NULL) + cuGetProcAddress_v2('cuSurfObjectDestroy', &__cuSurfObjectDestroy, 5000, ptds_mode, NULL) global __cuSurfObjectGetResourceDesc - _F_cuGetProcAddress_v2('cuSurfObjectGetResourceDesc', &__cuSurfObjectGetResourceDesc, 5000, ptds_mode, NULL) + cuGetProcAddress_v2('cuSurfObjectGetResourceDesc', &__cuSurfObjectGetResourceDesc, 5000, ptds_mode, NULL) global __cuTensorMapEncodeTiled - _F_cuGetProcAddress_v2('cuTensorMapEncodeTiled', &__cuTensorMapEncodeTiled, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTensorMapEncodeTiled', &__cuTensorMapEncodeTiled, 12000, ptds_mode, NULL) global __cuTensorMapEncodeIm2col - _F_cuGetProcAddress_v2('cuTensorMapEncodeIm2col', &__cuTensorMapEncodeIm2col, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTensorMapEncodeIm2col', &__cuTensorMapEncodeIm2col, 12000, ptds_mode, NULL) global __cuTensorMapEncodeIm2colWide - _F_cuGetProcAddress_v2('cuTensorMapEncodeIm2colWide', &__cuTensorMapEncodeIm2colWide, 12080, ptds_mode, NULL) + cuGetProcAddress_v2('cuTensorMapEncodeIm2colWide', &__cuTensorMapEncodeIm2colWide, 12080, ptds_mode, NULL) global __cuTensorMapReplaceAddress - _F_cuGetProcAddress_v2('cuTensorMapReplaceAddress', &__cuTensorMapReplaceAddress, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTensorMapReplaceAddress', &__cuTensorMapReplaceAddress, 12000, ptds_mode, NULL) global __cuDeviceCanAccessPeer - _F_cuGetProcAddress_v2('cuDeviceCanAccessPeer', &__cuDeviceCanAccessPeer, 4000, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceCanAccessPeer', &__cuDeviceCanAccessPeer, 4000, ptds_mode, NULL) global __cuCtxEnablePeerAccess - _F_cuGetProcAddress_v2('cuCtxEnablePeerAccess', &__cuCtxEnablePeerAccess, 4000, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxEnablePeerAccess', &__cuCtxEnablePeerAccess, 4000, ptds_mode, NULL) global __cuCtxDisablePeerAccess - _F_cuGetProcAddress_v2('cuCtxDisablePeerAccess', &__cuCtxDisablePeerAccess, 4000, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxDisablePeerAccess', &__cuCtxDisablePeerAccess, 4000, ptds_mode, NULL) global __cuDeviceGetP2PAttribute - _F_cuGetProcAddress_v2('cuDeviceGetP2PAttribute', &__cuDeviceGetP2PAttribute, 8000, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceGetP2PAttribute', &__cuDeviceGetP2PAttribute, 8000, ptds_mode, NULL) global __cuGraphicsUnregisterResource - _F_cuGetProcAddress_v2('cuGraphicsUnregisterResource', &__cuGraphicsUnregisterResource, 3000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphicsUnregisterResource', &__cuGraphicsUnregisterResource, 3000, ptds_mode, NULL) global __cuGraphicsSubResourceGetMappedArray - _F_cuGetProcAddress_v2('cuGraphicsSubResourceGetMappedArray', &__cuGraphicsSubResourceGetMappedArray, 3000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphicsSubResourceGetMappedArray', &__cuGraphicsSubResourceGetMappedArray, 3000, ptds_mode, NULL) global __cuGraphicsResourceGetMappedMipmappedArray - _F_cuGetProcAddress_v2('cuGraphicsResourceGetMappedMipmappedArray', &__cuGraphicsResourceGetMappedMipmappedArray, 5000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphicsResourceGetMappedMipmappedArray', &__cuGraphicsResourceGetMappedMipmappedArray, 5000, ptds_mode, NULL) global __cuGraphicsResourceGetMappedPointer_v2 - _F_cuGetProcAddress_v2('cuGraphicsResourceGetMappedPointer', &__cuGraphicsResourceGetMappedPointer_v2, 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphicsResourceGetMappedPointer', &__cuGraphicsResourceGetMappedPointer_v2, 3020, ptds_mode, NULL) global __cuGraphicsResourceSetMapFlags_v2 - _F_cuGetProcAddress_v2('cuGraphicsResourceSetMapFlags', &__cuGraphicsResourceSetMapFlags_v2, 6050, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphicsResourceSetMapFlags', &__cuGraphicsResourceSetMapFlags_v2, 6050, ptds_mode, NULL) global __cuGraphicsMapResources - _F_cuGetProcAddress_v2('cuGraphicsMapResources', &__cuGraphicsMapResources, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphicsMapResources', &__cuGraphicsMapResources, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3000, ptds_mode, NULL) global __cuGraphicsUnmapResources - _F_cuGetProcAddress_v2('cuGraphicsUnmapResources', &__cuGraphicsUnmapResources, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphicsUnmapResources', &__cuGraphicsUnmapResources, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3000, ptds_mode, NULL) global __cuGetProcAddress_v2 - _F_cuGetProcAddress_v2('cuGetProcAddress', &__cuGetProcAddress_v2, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGetProcAddress', &__cuGetProcAddress_v2, 12000, ptds_mode, NULL) global __cuCoredumpGetAttribute - _F_cuGetProcAddress_v2('cuCoredumpGetAttribute', &__cuCoredumpGetAttribute, 12010, ptds_mode, NULL) + cuGetProcAddress_v2('cuCoredumpGetAttribute', &__cuCoredumpGetAttribute, 12010, ptds_mode, NULL) global __cuCoredumpGetAttributeGlobal - _F_cuGetProcAddress_v2('cuCoredumpGetAttributeGlobal', &__cuCoredumpGetAttributeGlobal, 12010, ptds_mode, NULL) + cuGetProcAddress_v2('cuCoredumpGetAttributeGlobal', &__cuCoredumpGetAttributeGlobal, 12010, ptds_mode, NULL) global __cuCoredumpSetAttribute - _F_cuGetProcAddress_v2('cuCoredumpSetAttribute', &__cuCoredumpSetAttribute, 12010, ptds_mode, NULL) + cuGetProcAddress_v2('cuCoredumpSetAttribute', &__cuCoredumpSetAttribute, 12010, ptds_mode, NULL) global __cuCoredumpSetAttributeGlobal - _F_cuGetProcAddress_v2('cuCoredumpSetAttributeGlobal', &__cuCoredumpSetAttributeGlobal, 12010, ptds_mode, NULL) + cuGetProcAddress_v2('cuCoredumpSetAttributeGlobal', &__cuCoredumpSetAttributeGlobal, 12010, ptds_mode, NULL) global __cuGetExportTable - _F_cuGetProcAddress_v2('cuGetExportTable', &__cuGetExportTable, 3000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGetExportTable', &__cuGetExportTable, 3000, ptds_mode, NULL) global __cuGreenCtxCreate - _F_cuGetProcAddress_v2('cuGreenCtxCreate', &__cuGreenCtxCreate, 12040, ptds_mode, NULL) + cuGetProcAddress_v2('cuGreenCtxCreate', &__cuGreenCtxCreate, 12040, ptds_mode, NULL) global __cuGreenCtxDestroy - _F_cuGetProcAddress_v2('cuGreenCtxDestroy', &__cuGreenCtxDestroy, 12040, ptds_mode, NULL) + cuGetProcAddress_v2('cuGreenCtxDestroy', &__cuGreenCtxDestroy, 12040, ptds_mode, NULL) global __cuCtxFromGreenCtx - _F_cuGetProcAddress_v2('cuCtxFromGreenCtx', &__cuCtxFromGreenCtx, 12040, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxFromGreenCtx', &__cuCtxFromGreenCtx, 12040, ptds_mode, NULL) global __cuDeviceGetDevResource - _F_cuGetProcAddress_v2('cuDeviceGetDevResource', &__cuDeviceGetDevResource, 12040, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceGetDevResource', &__cuDeviceGetDevResource, 12040, ptds_mode, NULL) global __cuCtxGetDevResource - _F_cuGetProcAddress_v2('cuCtxGetDevResource', &__cuCtxGetDevResource, 12040, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxGetDevResource', &__cuCtxGetDevResource, 12040, ptds_mode, NULL) global __cuGreenCtxGetDevResource - _F_cuGetProcAddress_v2('cuGreenCtxGetDevResource', &__cuGreenCtxGetDevResource, 12040, ptds_mode, NULL) + cuGetProcAddress_v2('cuGreenCtxGetDevResource', &__cuGreenCtxGetDevResource, 12040, ptds_mode, NULL) global __cuDevSmResourceSplitByCount - _F_cuGetProcAddress_v2('cuDevSmResourceSplitByCount', &__cuDevSmResourceSplitByCount, 12040, ptds_mode, NULL) + cuGetProcAddress_v2('cuDevSmResourceSplitByCount', &__cuDevSmResourceSplitByCount, 12040, ptds_mode, NULL) global __cuDevResourceGenerateDesc - _F_cuGetProcAddress_v2('cuDevResourceGenerateDesc', &__cuDevResourceGenerateDesc, 12040, ptds_mode, NULL) + cuGetProcAddress_v2('cuDevResourceGenerateDesc', &__cuDevResourceGenerateDesc, 12040, ptds_mode, NULL) global __cuGreenCtxRecordEvent - _F_cuGetProcAddress_v2('cuGreenCtxRecordEvent', &__cuGreenCtxRecordEvent, 12040, ptds_mode, NULL) + cuGetProcAddress_v2('cuGreenCtxRecordEvent', &__cuGreenCtxRecordEvent, 12040, ptds_mode, NULL) global __cuGreenCtxWaitEvent - _F_cuGetProcAddress_v2('cuGreenCtxWaitEvent', &__cuGreenCtxWaitEvent, 12040, ptds_mode, NULL) + cuGetProcAddress_v2('cuGreenCtxWaitEvent', &__cuGreenCtxWaitEvent, 12040, ptds_mode, NULL) global __cuStreamGetGreenCtx - _F_cuGetProcAddress_v2('cuStreamGetGreenCtx', &__cuStreamGetGreenCtx, 12040, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamGetGreenCtx', &__cuStreamGetGreenCtx, 12040, ptds_mode, NULL) global __cuGreenCtxStreamCreate - _F_cuGetProcAddress_v2('cuGreenCtxStreamCreate', &__cuGreenCtxStreamCreate, 12050, ptds_mode, NULL) + cuGetProcAddress_v2('cuGreenCtxStreamCreate', &__cuGreenCtxStreamCreate, 12050, ptds_mode, NULL) global __cuLogsRegisterCallback - _F_cuGetProcAddress_v2('cuLogsRegisterCallback', &__cuLogsRegisterCallback, 12080, ptds_mode, NULL) + cuGetProcAddress_v2('cuLogsRegisterCallback', &__cuLogsRegisterCallback, 12080, ptds_mode, NULL) global __cuLogsUnregisterCallback - _F_cuGetProcAddress_v2('cuLogsUnregisterCallback', &__cuLogsUnregisterCallback, 12080, ptds_mode, NULL) + cuGetProcAddress_v2('cuLogsUnregisterCallback', &__cuLogsUnregisterCallback, 12080, ptds_mode, NULL) global __cuLogsCurrent - _F_cuGetProcAddress_v2('cuLogsCurrent', &__cuLogsCurrent, 12080, ptds_mode, NULL) + cuGetProcAddress_v2('cuLogsCurrent', &__cuLogsCurrent, 12080, ptds_mode, NULL) global __cuLogsDumpToFile - _F_cuGetProcAddress_v2('cuLogsDumpToFile', &__cuLogsDumpToFile, 12080, ptds_mode, NULL) + cuGetProcAddress_v2('cuLogsDumpToFile', &__cuLogsDumpToFile, 12080, ptds_mode, NULL) global __cuLogsDumpToMemory - _F_cuGetProcAddress_v2('cuLogsDumpToMemory', &__cuLogsDumpToMemory, 12080, ptds_mode, NULL) + cuGetProcAddress_v2('cuLogsDumpToMemory', &__cuLogsDumpToMemory, 12080, ptds_mode, NULL) global __cuCheckpointProcessGetRestoreThreadId - _F_cuGetProcAddress_v2('cuCheckpointProcessGetRestoreThreadId', &__cuCheckpointProcessGetRestoreThreadId, 12080, ptds_mode, NULL) + cuGetProcAddress_v2('cuCheckpointProcessGetRestoreThreadId', &__cuCheckpointProcessGetRestoreThreadId, 12080, ptds_mode, NULL) global __cuCheckpointProcessGetState - _F_cuGetProcAddress_v2('cuCheckpointProcessGetState', &__cuCheckpointProcessGetState, 12080, ptds_mode, NULL) + cuGetProcAddress_v2('cuCheckpointProcessGetState', &__cuCheckpointProcessGetState, 12080, ptds_mode, NULL) global __cuCheckpointProcessLock - _F_cuGetProcAddress_v2('cuCheckpointProcessLock', &__cuCheckpointProcessLock, 12080, ptds_mode, NULL) + cuGetProcAddress_v2('cuCheckpointProcessLock', &__cuCheckpointProcessLock, 12080, ptds_mode, NULL) global __cuCheckpointProcessCheckpoint - _F_cuGetProcAddress_v2('cuCheckpointProcessCheckpoint', &__cuCheckpointProcessCheckpoint, 12080, ptds_mode, NULL) + cuGetProcAddress_v2('cuCheckpointProcessCheckpoint', &__cuCheckpointProcessCheckpoint, 12080, ptds_mode, NULL) global __cuCheckpointProcessRestore - _F_cuGetProcAddress_v2('cuCheckpointProcessRestore', &__cuCheckpointProcessRestore, 12080, ptds_mode, NULL) + cuGetProcAddress_v2('cuCheckpointProcessRestore', &__cuCheckpointProcessRestore, 12080, ptds_mode, NULL) global __cuCheckpointProcessUnlock - _F_cuGetProcAddress_v2('cuCheckpointProcessUnlock', &__cuCheckpointProcessUnlock, 12080, ptds_mode, NULL) + cuGetProcAddress_v2('cuCheckpointProcessUnlock', &__cuCheckpointProcessUnlock, 12080, ptds_mode, NULL) global __cuGraphicsEGLRegisterImage - _F_cuGetProcAddress_v2('cuGraphicsEGLRegisterImage', &__cuGraphicsEGLRegisterImage, 7000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphicsEGLRegisterImage', &__cuGraphicsEGLRegisterImage, 7000, ptds_mode, NULL) global __cuEGLStreamConsumerConnect - _F_cuGetProcAddress_v2('cuEGLStreamConsumerConnect', &__cuEGLStreamConsumerConnect, 7000, ptds_mode, NULL) + cuGetProcAddress_v2('cuEGLStreamConsumerConnect', &__cuEGLStreamConsumerConnect, 7000, ptds_mode, NULL) global __cuEGLStreamConsumerConnectWithFlags - _F_cuGetProcAddress_v2('cuEGLStreamConsumerConnectWithFlags', &__cuEGLStreamConsumerConnectWithFlags, 8000, ptds_mode, NULL) + cuGetProcAddress_v2('cuEGLStreamConsumerConnectWithFlags', &__cuEGLStreamConsumerConnectWithFlags, 8000, ptds_mode, NULL) global __cuEGLStreamConsumerDisconnect - _F_cuGetProcAddress_v2('cuEGLStreamConsumerDisconnect', &__cuEGLStreamConsumerDisconnect, 7000, ptds_mode, NULL) + cuGetProcAddress_v2('cuEGLStreamConsumerDisconnect', &__cuEGLStreamConsumerDisconnect, 7000, ptds_mode, NULL) global __cuEGLStreamConsumerAcquireFrame - _F_cuGetProcAddress_v2('cuEGLStreamConsumerAcquireFrame', &__cuEGLStreamConsumerAcquireFrame, 7000, ptds_mode, NULL) + cuGetProcAddress_v2('cuEGLStreamConsumerAcquireFrame', &__cuEGLStreamConsumerAcquireFrame, 7000, ptds_mode, NULL) global __cuEGLStreamConsumerReleaseFrame - _F_cuGetProcAddress_v2('cuEGLStreamConsumerReleaseFrame', &__cuEGLStreamConsumerReleaseFrame, 7000, ptds_mode, NULL) + cuGetProcAddress_v2('cuEGLStreamConsumerReleaseFrame', &__cuEGLStreamConsumerReleaseFrame, 7000, ptds_mode, NULL) global __cuEGLStreamProducerConnect - _F_cuGetProcAddress_v2('cuEGLStreamProducerConnect', &__cuEGLStreamProducerConnect, 7000, ptds_mode, NULL) + cuGetProcAddress_v2('cuEGLStreamProducerConnect', &__cuEGLStreamProducerConnect, 7000, ptds_mode, NULL) global __cuEGLStreamProducerDisconnect - _F_cuGetProcAddress_v2('cuEGLStreamProducerDisconnect', &__cuEGLStreamProducerDisconnect, 7000, ptds_mode, NULL) + cuGetProcAddress_v2('cuEGLStreamProducerDisconnect', &__cuEGLStreamProducerDisconnect, 7000, ptds_mode, NULL) global __cuEGLStreamProducerPresentFrame - _F_cuGetProcAddress_v2('cuEGLStreamProducerPresentFrame', &__cuEGLStreamProducerPresentFrame, 7000, ptds_mode, NULL) + cuGetProcAddress_v2('cuEGLStreamProducerPresentFrame', &__cuEGLStreamProducerPresentFrame, 7000, ptds_mode, NULL) global __cuEGLStreamProducerReturnFrame - _F_cuGetProcAddress_v2('cuEGLStreamProducerReturnFrame', &__cuEGLStreamProducerReturnFrame, 7000, ptds_mode, NULL) + cuGetProcAddress_v2('cuEGLStreamProducerReturnFrame', &__cuEGLStreamProducerReturnFrame, 7000, ptds_mode, NULL) global __cuGraphicsResourceGetMappedEglFrame - _F_cuGetProcAddress_v2('cuGraphicsResourceGetMappedEglFrame', &__cuGraphicsResourceGetMappedEglFrame, 7000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphicsResourceGetMappedEglFrame', &__cuGraphicsResourceGetMappedEglFrame, 7000, ptds_mode, NULL) global __cuEventCreateFromEGLSync - _F_cuGetProcAddress_v2('cuEventCreateFromEGLSync', &__cuEventCreateFromEGLSync, 9000, ptds_mode, NULL) + cuGetProcAddress_v2('cuEventCreateFromEGLSync', &__cuEventCreateFromEGLSync, 9000, ptds_mode, NULL) global __cuGraphicsGLRegisterBuffer - _F_cuGetProcAddress_v2('cuGraphicsGLRegisterBuffer', &__cuGraphicsGLRegisterBuffer, 3000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphicsGLRegisterBuffer', &__cuGraphicsGLRegisterBuffer, 3000, ptds_mode, NULL) global __cuGraphicsGLRegisterImage - _F_cuGetProcAddress_v2('cuGraphicsGLRegisterImage', &__cuGraphicsGLRegisterImage, 3000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphicsGLRegisterImage', &__cuGraphicsGLRegisterImage, 3000, ptds_mode, NULL) global __cuGLGetDevices_v2 - _F_cuGetProcAddress_v2('cuGLGetDevices', &__cuGLGetDevices_v2, 6050, ptds_mode, NULL) + cuGetProcAddress_v2('cuGLGetDevices', &__cuGLGetDevices_v2, 6050, ptds_mode, NULL) global __cuGLCtxCreate_v2 - _F_cuGetProcAddress_v2('cuGLCtxCreate', &__cuGLCtxCreate_v2, 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuGLCtxCreate', &__cuGLCtxCreate_v2, 3020, ptds_mode, NULL) global __cuGLInit - _F_cuGetProcAddress_v2('cuGLInit', &__cuGLInit, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGLInit', &__cuGLInit, 2000, ptds_mode, NULL) global __cuGLRegisterBufferObject - _F_cuGetProcAddress_v2('cuGLRegisterBufferObject', &__cuGLRegisterBufferObject, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGLRegisterBufferObject', &__cuGLRegisterBufferObject, 2000, ptds_mode, NULL) global __cuGLMapBufferObject_v2 - _F_cuGetProcAddress_v2('cuGLMapBufferObject', &__cuGLMapBufferObject_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuGLMapBufferObject', &__cuGLMapBufferObject_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuGLUnmapBufferObject - _F_cuGetProcAddress_v2('cuGLUnmapBufferObject', &__cuGLUnmapBufferObject, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGLUnmapBufferObject', &__cuGLUnmapBufferObject, 2000, ptds_mode, NULL) global __cuGLUnregisterBufferObject - _F_cuGetProcAddress_v2('cuGLUnregisterBufferObject', &__cuGLUnregisterBufferObject, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGLUnregisterBufferObject', &__cuGLUnregisterBufferObject, 2000, ptds_mode, NULL) global __cuGLSetBufferObjectMapFlags - _F_cuGetProcAddress_v2('cuGLSetBufferObjectMapFlags', &__cuGLSetBufferObjectMapFlags, 2030, ptds_mode, NULL) + cuGetProcAddress_v2('cuGLSetBufferObjectMapFlags', &__cuGLSetBufferObjectMapFlags, 2030, ptds_mode, NULL) global __cuGLMapBufferObjectAsync_v2 - _F_cuGetProcAddress_v2('cuGLMapBufferObjectAsync', &__cuGLMapBufferObjectAsync_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuGLMapBufferObjectAsync', &__cuGLMapBufferObjectAsync_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuGLUnmapBufferObjectAsync - _F_cuGetProcAddress_v2('cuGLUnmapBufferObjectAsync', &__cuGLUnmapBufferObjectAsync, 2030, ptds_mode, NULL) + cuGetProcAddress_v2('cuGLUnmapBufferObjectAsync', &__cuGLUnmapBufferObjectAsync, 2030, ptds_mode, NULL) global __cuProfilerInitialize - _F_cuGetProcAddress_v2('cuProfilerInitialize', &__cuProfilerInitialize, 4000, ptds_mode, NULL) + cuGetProcAddress_v2('cuProfilerInitialize', &__cuProfilerInitialize, 4000, ptds_mode, NULL) global __cuProfilerStart - _F_cuGetProcAddress_v2('cuProfilerStart', &__cuProfilerStart, 4000, ptds_mode, NULL) + cuGetProcAddress_v2('cuProfilerStart', &__cuProfilerStart, 4000, ptds_mode, NULL) global __cuProfilerStop - _F_cuGetProcAddress_v2('cuProfilerStop', &__cuProfilerStop, 4000, ptds_mode, NULL) + cuGetProcAddress_v2('cuProfilerStop', &__cuProfilerStop, 4000, ptds_mode, NULL) global __cuVDPAUGetDevice - _F_cuGetProcAddress_v2('cuVDPAUGetDevice', &__cuVDPAUGetDevice, 3010, ptds_mode, NULL) + cuGetProcAddress_v2('cuVDPAUGetDevice', &__cuVDPAUGetDevice, 3010, ptds_mode, NULL) global __cuVDPAUCtxCreate_v2 - _F_cuGetProcAddress_v2('cuVDPAUCtxCreate', &__cuVDPAUCtxCreate_v2, 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuVDPAUCtxCreate', &__cuVDPAUCtxCreate_v2, 3020, ptds_mode, NULL) global __cuGraphicsVDPAURegisterVideoSurface - _F_cuGetProcAddress_v2('cuGraphicsVDPAURegisterVideoSurface', &__cuGraphicsVDPAURegisterVideoSurface, 3010, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphicsVDPAURegisterVideoSurface', &__cuGraphicsVDPAURegisterVideoSurface, 3010, ptds_mode, NULL) global __cuGraphicsVDPAURegisterOutputSurface - _F_cuGetProcAddress_v2('cuGraphicsVDPAURegisterOutputSurface', &__cuGraphicsVDPAURegisterOutputSurface, 3010, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphicsVDPAURegisterOutputSurface', &__cuGraphicsVDPAURegisterOutputSurface, 3010, ptds_mode, NULL) global __cuDeviceGetHostAtomicCapabilities - _F_cuGetProcAddress_v2('cuDeviceGetHostAtomicCapabilities', &__cuDeviceGetHostAtomicCapabilities, 13000, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceGetHostAtomicCapabilities', &__cuDeviceGetHostAtomicCapabilities, 13000, ptds_mode, NULL) global __cuCtxGetDevice_v2 - _F_cuGetProcAddress_v2('cuCtxGetDevice', &__cuCtxGetDevice_v2, 13000, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxGetDevice', &__cuCtxGetDevice_v2, 13000, ptds_mode, NULL) global __cuCtxSynchronize_v2 - _F_cuGetProcAddress_v2('cuCtxSynchronize', &__cuCtxSynchronize_v2, 13000, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxSynchronize', &__cuCtxSynchronize_v2, 13000, ptds_mode, NULL) global __cuMemcpyBatchAsync_v2 - _F_cuGetProcAddress_v2('cuMemcpyBatchAsync', &__cuMemcpyBatchAsync_v2, 13000, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpyBatchAsync', &__cuMemcpyBatchAsync_v2, 13000, ptds_mode, NULL) global __cuMemcpy3DBatchAsync_v2 - _F_cuGetProcAddress_v2('cuMemcpy3DBatchAsync', &__cuMemcpy3DBatchAsync_v2, 13000, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpy3DBatchAsync', &__cuMemcpy3DBatchAsync_v2, 13000, ptds_mode, NULL) global __cuMemGetDefaultMemPool - _F_cuGetProcAddress_v2('cuMemGetDefaultMemPool', &__cuMemGetDefaultMemPool, 13000, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemGetDefaultMemPool', &__cuMemGetDefaultMemPool, 13000, ptds_mode, NULL) global __cuMemGetMemPool - _F_cuGetProcAddress_v2('cuMemGetMemPool', &__cuMemGetMemPool, 13000, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemGetMemPool', &__cuMemGetMemPool, 13000, ptds_mode, NULL) global __cuMemSetMemPool - _F_cuGetProcAddress_v2('cuMemSetMemPool', &__cuMemSetMemPool, 13000, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemSetMemPool', &__cuMemSetMemPool, 13000, ptds_mode, NULL) global __cuMemPrefetchBatchAsync - _F_cuGetProcAddress_v2('cuMemPrefetchBatchAsync', &__cuMemPrefetchBatchAsync, 13000, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemPrefetchBatchAsync', &__cuMemPrefetchBatchAsync, 13000, ptds_mode, NULL) global __cuMemDiscardBatchAsync - _F_cuGetProcAddress_v2('cuMemDiscardBatchAsync', &__cuMemDiscardBatchAsync, 13000, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemDiscardBatchAsync', &__cuMemDiscardBatchAsync, 13000, ptds_mode, NULL) global __cuMemDiscardAndPrefetchBatchAsync - _F_cuGetProcAddress_v2('cuMemDiscardAndPrefetchBatchAsync', &__cuMemDiscardAndPrefetchBatchAsync, 13000, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemDiscardAndPrefetchBatchAsync', &__cuMemDiscardAndPrefetchBatchAsync, 13000, ptds_mode, NULL) global __cuDeviceGetP2PAtomicCapabilities - _F_cuGetProcAddress_v2('cuDeviceGetP2PAtomicCapabilities', &__cuDeviceGetP2PAtomicCapabilities, 13000, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceGetP2PAtomicCapabilities', &__cuDeviceGetP2PAtomicCapabilities, 13000, ptds_mode, NULL) global __cuGreenCtxGetId - _F_cuGetProcAddress_v2('cuGreenCtxGetId', &__cuGreenCtxGetId, 13000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGreenCtxGetId', &__cuGreenCtxGetId, 13000, ptds_mode, NULL) global __cuMulticastBindMem_v2 - _F_cuGetProcAddress_v2('cuMulticastBindMem', &__cuMulticastBindMem_v2, 13010, ptds_mode, NULL) + cuGetProcAddress_v2('cuMulticastBindMem', &__cuMulticastBindMem_v2, 13010, ptds_mode, NULL) global __cuMulticastBindAddr_v2 - _F_cuGetProcAddress_v2('cuMulticastBindAddr', &__cuMulticastBindAddr_v2, 13010, ptds_mode, NULL) + cuGetProcAddress_v2('cuMulticastBindAddr', &__cuMulticastBindAddr_v2, 13010, ptds_mode, NULL) global __cuGraphNodeGetContainingGraph - _F_cuGetProcAddress_v2('cuGraphNodeGetContainingGraph', &__cuGraphNodeGetContainingGraph, 13010, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphNodeGetContainingGraph', &__cuGraphNodeGetContainingGraph, 13010, ptds_mode, NULL) global __cuGraphNodeGetLocalId - _F_cuGetProcAddress_v2('cuGraphNodeGetLocalId', &__cuGraphNodeGetLocalId, 13010, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphNodeGetLocalId', &__cuGraphNodeGetLocalId, 13010, ptds_mode, NULL) global __cuGraphNodeGetToolsId - _F_cuGetProcAddress_v2('cuGraphNodeGetToolsId', &__cuGraphNodeGetToolsId, 13010, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphNodeGetToolsId', &__cuGraphNodeGetToolsId, 13010, ptds_mode, NULL) global __cuGraphGetId - _F_cuGetProcAddress_v2('cuGraphGetId', &__cuGraphGetId, 13010, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphGetId', &__cuGraphGetId, 13010, ptds_mode, NULL) global __cuGraphExecGetId - _F_cuGetProcAddress_v2('cuGraphExecGetId', &__cuGraphExecGetId, 13010, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphExecGetId', &__cuGraphExecGetId, 13010, ptds_mode, NULL) global __cuDevSmResourceSplit - _F_cuGetProcAddress_v2('cuDevSmResourceSplit', &__cuDevSmResourceSplit, 13010, ptds_mode, NULL) + cuGetProcAddress_v2('cuDevSmResourceSplit', &__cuDevSmResourceSplit, 13010, ptds_mode, NULL) global __cuStreamGetDevResource - _F_cuGetProcAddress_v2('cuStreamGetDevResource', &__cuStreamGetDevResource, 13010, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamGetDevResource', &__cuStreamGetDevResource, 13010, ptds_mode, NULL) global __cuKernelGetParamCount - _F_cuGetProcAddress_v2('cuKernelGetParamCount', &__cuKernelGetParamCount, 13020, ptds_mode, NULL) + cuGetProcAddress_v2('cuKernelGetParamCount', &__cuKernelGetParamCount, 13020, ptds_mode, NULL) global __cuMemcpyWithAttributesAsync - _F_cuGetProcAddress_v2('cuMemcpyWithAttributesAsync', &__cuMemcpyWithAttributesAsync, 13020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpyWithAttributesAsync', &__cuMemcpyWithAttributesAsync, 13020, ptds_mode, NULL) global __cuMemcpy3DWithAttributesAsync - _F_cuGetProcAddress_v2('cuMemcpy3DWithAttributesAsync', &__cuMemcpy3DWithAttributesAsync, 13020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpy3DWithAttributesAsync', &__cuMemcpy3DWithAttributesAsync, 13020, ptds_mode, NULL) global __cuStreamBeginCaptureToCig - _F_cuGetProcAddress_v2('cuStreamBeginCaptureToCig', &__cuStreamBeginCaptureToCig, 13020, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamBeginCaptureToCig', &__cuStreamBeginCaptureToCig, 13020, ptds_mode, NULL) global __cuStreamEndCaptureToCig - _F_cuGetProcAddress_v2('cuStreamEndCaptureToCig', &__cuStreamEndCaptureToCig, 13020, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamEndCaptureToCig', &__cuStreamEndCaptureToCig, 13020, ptds_mode, NULL) global __cuFuncGetParamCount - _F_cuGetProcAddress_v2('cuFuncGetParamCount', &__cuFuncGetParamCount, 13020, ptds_mode, NULL) + cuGetProcAddress_v2('cuFuncGetParamCount', &__cuFuncGetParamCount, 13020, ptds_mode, NULL) global __cuLaunchHostFunc_v2 - _F_cuGetProcAddress_v2('cuLaunchHostFunc', &__cuLaunchHostFunc_v2, 13020, ptds_mode, NULL) + cuGetProcAddress_v2('cuLaunchHostFunc', &__cuLaunchHostFunc_v2, 13020, ptds_mode, NULL) global __cuGraphNodeGetParams - _F_cuGetProcAddress_v2('cuGraphNodeGetParams', &__cuGraphNodeGetParams, 13020, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphNodeGetParams', &__cuGraphNodeGetParams, 13020, ptds_mode, NULL) global __cuCoredumpRegisterStartCallback - _F_cuGetProcAddress_v2('cuCoredumpRegisterStartCallback', &__cuCoredumpRegisterStartCallback, 13020, ptds_mode, NULL) + cuGetProcAddress_v2('cuCoredumpRegisterStartCallback', &__cuCoredumpRegisterStartCallback, 13020, ptds_mode, NULL) global __cuCoredumpRegisterCompleteCallback - _F_cuGetProcAddress_v2('cuCoredumpRegisterCompleteCallback', &__cuCoredumpRegisterCompleteCallback, 13020, ptds_mode, NULL) + cuGetProcAddress_v2('cuCoredumpRegisterCompleteCallback', &__cuCoredumpRegisterCompleteCallback, 13020, ptds_mode, NULL) global __cuCoredumpDeregisterStartCallback - _F_cuGetProcAddress_v2('cuCoredumpDeregisterStartCallback', &__cuCoredumpDeregisterStartCallback, 13020, ptds_mode, NULL) + cuGetProcAddress_v2('cuCoredumpDeregisterStartCallback', &__cuCoredumpDeregisterStartCallback, 13020, ptds_mode, NULL) global __cuCoredumpDeregisterCompleteCallback - _F_cuGetProcAddress_v2('cuCoredumpDeregisterCompleteCallback', &__cuCoredumpDeregisterCompleteCallback, 13020, ptds_mode, NULL) + cuGetProcAddress_v2('cuCoredumpDeregisterCompleteCallback', &__cuCoredumpDeregisterCompleteCallback, 13020, ptds_mode, NULL) global __cuLogicalEndpointIdReserve - _F_cuGetProcAddress_v2('cuLogicalEndpointIdReserve', &__cuLogicalEndpointIdReserve, 13030, ptds_mode, NULL) + cuGetProcAddress_v2('cuLogicalEndpointIdReserve', &__cuLogicalEndpointIdReserve, 13030, ptds_mode, NULL) global __cuLogicalEndpointIdRelease - _F_cuGetProcAddress_v2('cuLogicalEndpointIdRelease', &__cuLogicalEndpointIdRelease, 13030, ptds_mode, NULL) + cuGetProcAddress_v2('cuLogicalEndpointIdRelease', &__cuLogicalEndpointIdRelease, 13030, ptds_mode, NULL) global __cuLogicalEndpointCreate - _F_cuGetProcAddress_v2('cuLogicalEndpointCreate', &__cuLogicalEndpointCreate, 13030, ptds_mode, NULL) + cuGetProcAddress_v2('cuLogicalEndpointCreate', &__cuLogicalEndpointCreate, 13030, ptds_mode, NULL) global __cuLogicalEndpointAddDevice - _F_cuGetProcAddress_v2('cuLogicalEndpointAddDevice', &__cuLogicalEndpointAddDevice, 13030, ptds_mode, NULL) + cuGetProcAddress_v2('cuLogicalEndpointAddDevice', &__cuLogicalEndpointAddDevice, 13030, ptds_mode, NULL) global __cuLogicalEndpointDestroy - _F_cuGetProcAddress_v2('cuLogicalEndpointDestroy', &__cuLogicalEndpointDestroy, 13030, ptds_mode, NULL) + cuGetProcAddress_v2('cuLogicalEndpointDestroy', &__cuLogicalEndpointDestroy, 13030, ptds_mode, NULL) global __cuLogicalEndpointBindAddr - _F_cuGetProcAddress_v2('cuLogicalEndpointBindAddr', &__cuLogicalEndpointBindAddr, 13030, ptds_mode, NULL) + cuGetProcAddress_v2('cuLogicalEndpointBindAddr', &__cuLogicalEndpointBindAddr, 13030, ptds_mode, NULL) global __cuLogicalEndpointBindMem - _F_cuGetProcAddress_v2('cuLogicalEndpointBindMem', &__cuLogicalEndpointBindMem, 13030, ptds_mode, NULL) + cuGetProcAddress_v2('cuLogicalEndpointBindMem', &__cuLogicalEndpointBindMem, 13030, ptds_mode, NULL) global __cuLogicalEndpointUnbind - _F_cuGetProcAddress_v2('cuLogicalEndpointUnbind', &__cuLogicalEndpointUnbind, 13030, ptds_mode, NULL) + cuGetProcAddress_v2('cuLogicalEndpointUnbind', &__cuLogicalEndpointUnbind, 13030, ptds_mode, NULL) global __cuLogicalEndpointExport - _F_cuGetProcAddress_v2('cuLogicalEndpointExport', &__cuLogicalEndpointExport, 13030, ptds_mode, NULL) + cuGetProcAddress_v2('cuLogicalEndpointExport', &__cuLogicalEndpointExport, 13030, ptds_mode, NULL) global __cuLogicalEndpointImport - _F_cuGetProcAddress_v2('cuLogicalEndpointImport', &__cuLogicalEndpointImport, 13030, ptds_mode, NULL) + cuGetProcAddress_v2('cuLogicalEndpointImport', &__cuLogicalEndpointImport, 13030, ptds_mode, NULL) global __cuLogicalEndpointGetLimits - _F_cuGetProcAddress_v2('cuLogicalEndpointGetLimits', &__cuLogicalEndpointGetLimits, 13030, ptds_mode, NULL) + cuGetProcAddress_v2('cuLogicalEndpointGetLimits', &__cuLogicalEndpointGetLimits, 13030, ptds_mode, NULL) global __cuLogicalEndpointQuery - _F_cuGetProcAddress_v2('cuLogicalEndpointQuery', &__cuLogicalEndpointQuery, 13030, ptds_mode, NULL) + cuGetProcAddress_v2('cuLogicalEndpointQuery', &__cuLogicalEndpointQuery, 13030, ptds_mode, NULL) global __cuStreamBeginRecaptureToGraph - _F_cuGetProcAddress_v2('cuStreamBeginRecaptureToGraph', &__cuStreamBeginRecaptureToGraph, 13030, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamBeginRecaptureToGraph', &__cuStreamBeginRecaptureToGraph, 13030, ptds_mode, NULL) - __py_driver_init = True + _cyb___py_driver_init = True return 0 - cdef inline int _check_or_init_driver() except -1 nogil: - if __py_driver_init: + if _cyb___py_driver_init: return 0 return _init_driver() -cdef dict func_ptrs = None - cpdef dict _inspect_function_pointers(): - global func_ptrs - if func_ptrs is not None: - return func_ptrs + global _cyb_func_ptrs + if _cyb_func_ptrs is not None: + return _cyb_func_ptrs _check_or_init_driver() cdef dict data = {} - global __cuGetErrorString - data["__cuGetErrorString"] = __cuGetErrorString + data["__cuGetErrorString"] = <_cyb_intptr_t>__cuGetErrorString global __cuGetErrorName - data["__cuGetErrorName"] = __cuGetErrorName + data["__cuGetErrorName"] = <_cyb_intptr_t>__cuGetErrorName global __cuInit - data["__cuInit"] = __cuInit + data["__cuInit"] = <_cyb_intptr_t>__cuInit global __cuDriverGetVersion - data["__cuDriverGetVersion"] = __cuDriverGetVersion + data["__cuDriverGetVersion"] = <_cyb_intptr_t>__cuDriverGetVersion global __cuDeviceGet - data["__cuDeviceGet"] = __cuDeviceGet + data["__cuDeviceGet"] = <_cyb_intptr_t>__cuDeviceGet global __cuDeviceGetCount - data["__cuDeviceGetCount"] = __cuDeviceGetCount + data["__cuDeviceGetCount"] = <_cyb_intptr_t>__cuDeviceGetCount global __cuDeviceGetName - data["__cuDeviceGetName"] = __cuDeviceGetName + data["__cuDeviceGetName"] = <_cyb_intptr_t>__cuDeviceGetName global __cuDeviceGetUuid_v2 - data["__cuDeviceGetUuid_v2"] = __cuDeviceGetUuid_v2 + data["__cuDeviceGetUuid_v2"] = <_cyb_intptr_t>__cuDeviceGetUuid_v2 global __cuDeviceGetLuid - data["__cuDeviceGetLuid"] = __cuDeviceGetLuid + data["__cuDeviceGetLuid"] = <_cyb_intptr_t>__cuDeviceGetLuid global __cuDeviceTotalMem_v2 - data["__cuDeviceTotalMem_v2"] = __cuDeviceTotalMem_v2 + data["__cuDeviceTotalMem_v2"] = <_cyb_intptr_t>__cuDeviceTotalMem_v2 global __cuDeviceGetTexture1DLinearMaxWidth - data["__cuDeviceGetTexture1DLinearMaxWidth"] = __cuDeviceGetTexture1DLinearMaxWidth + data["__cuDeviceGetTexture1DLinearMaxWidth"] = <_cyb_intptr_t>__cuDeviceGetTexture1DLinearMaxWidth global __cuDeviceGetAttribute - data["__cuDeviceGetAttribute"] = __cuDeviceGetAttribute + data["__cuDeviceGetAttribute"] = <_cyb_intptr_t>__cuDeviceGetAttribute global __cuDeviceGetNvSciSyncAttributes - data["__cuDeviceGetNvSciSyncAttributes"] = __cuDeviceGetNvSciSyncAttributes + data["__cuDeviceGetNvSciSyncAttributes"] = <_cyb_intptr_t>__cuDeviceGetNvSciSyncAttributes global __cuDeviceSetMemPool - data["__cuDeviceSetMemPool"] = __cuDeviceSetMemPool + data["__cuDeviceSetMemPool"] = <_cyb_intptr_t>__cuDeviceSetMemPool global __cuDeviceGetMemPool - data["__cuDeviceGetMemPool"] = __cuDeviceGetMemPool + data["__cuDeviceGetMemPool"] = <_cyb_intptr_t>__cuDeviceGetMemPool global __cuDeviceGetDefaultMemPool - data["__cuDeviceGetDefaultMemPool"] = __cuDeviceGetDefaultMemPool + data["__cuDeviceGetDefaultMemPool"] = <_cyb_intptr_t>__cuDeviceGetDefaultMemPool global __cuDeviceGetExecAffinitySupport - data["__cuDeviceGetExecAffinitySupport"] = __cuDeviceGetExecAffinitySupport + data["__cuDeviceGetExecAffinitySupport"] = <_cyb_intptr_t>__cuDeviceGetExecAffinitySupport global __cuFlushGPUDirectRDMAWrites - data["__cuFlushGPUDirectRDMAWrites"] = __cuFlushGPUDirectRDMAWrites + data["__cuFlushGPUDirectRDMAWrites"] = <_cyb_intptr_t>__cuFlushGPUDirectRDMAWrites global __cuDeviceGetProperties - data["__cuDeviceGetProperties"] = __cuDeviceGetProperties + data["__cuDeviceGetProperties"] = <_cyb_intptr_t>__cuDeviceGetProperties global __cuDeviceComputeCapability - data["__cuDeviceComputeCapability"] = __cuDeviceComputeCapability + data["__cuDeviceComputeCapability"] = <_cyb_intptr_t>__cuDeviceComputeCapability global __cuDevicePrimaryCtxRetain - data["__cuDevicePrimaryCtxRetain"] = __cuDevicePrimaryCtxRetain + data["__cuDevicePrimaryCtxRetain"] = <_cyb_intptr_t>__cuDevicePrimaryCtxRetain global __cuDevicePrimaryCtxRelease_v2 - data["__cuDevicePrimaryCtxRelease_v2"] = __cuDevicePrimaryCtxRelease_v2 + data["__cuDevicePrimaryCtxRelease_v2"] = <_cyb_intptr_t>__cuDevicePrimaryCtxRelease_v2 global __cuDevicePrimaryCtxSetFlags_v2 - data["__cuDevicePrimaryCtxSetFlags_v2"] = __cuDevicePrimaryCtxSetFlags_v2 + data["__cuDevicePrimaryCtxSetFlags_v2"] = <_cyb_intptr_t>__cuDevicePrimaryCtxSetFlags_v2 global __cuDevicePrimaryCtxGetState - data["__cuDevicePrimaryCtxGetState"] = __cuDevicePrimaryCtxGetState + data["__cuDevicePrimaryCtxGetState"] = <_cyb_intptr_t>__cuDevicePrimaryCtxGetState global __cuDevicePrimaryCtxReset_v2 - data["__cuDevicePrimaryCtxReset_v2"] = __cuDevicePrimaryCtxReset_v2 + data["__cuDevicePrimaryCtxReset_v2"] = <_cyb_intptr_t>__cuDevicePrimaryCtxReset_v2 global __cuCtxCreate_v2 - data["__cuCtxCreate_v2"] = __cuCtxCreate_v2 + data["__cuCtxCreate_v2"] = <_cyb_intptr_t>__cuCtxCreate_v2 global __cuCtxCreate_v3 - data["__cuCtxCreate_v3"] = __cuCtxCreate_v3 + data["__cuCtxCreate_v3"] = <_cyb_intptr_t>__cuCtxCreate_v3 global __cuCtxCreate_v4 - data["__cuCtxCreate_v4"] = __cuCtxCreate_v4 + data["__cuCtxCreate_v4"] = <_cyb_intptr_t>__cuCtxCreate_v4 global __cuCtxDestroy_v2 - data["__cuCtxDestroy_v2"] = __cuCtxDestroy_v2 + data["__cuCtxDestroy_v2"] = <_cyb_intptr_t>__cuCtxDestroy_v2 global __cuCtxPushCurrent_v2 - data["__cuCtxPushCurrent_v2"] = __cuCtxPushCurrent_v2 + data["__cuCtxPushCurrent_v2"] = <_cyb_intptr_t>__cuCtxPushCurrent_v2 global __cuCtxPopCurrent_v2 - data["__cuCtxPopCurrent_v2"] = __cuCtxPopCurrent_v2 + data["__cuCtxPopCurrent_v2"] = <_cyb_intptr_t>__cuCtxPopCurrent_v2 global __cuCtxSetCurrent - data["__cuCtxSetCurrent"] = __cuCtxSetCurrent + data["__cuCtxSetCurrent"] = <_cyb_intptr_t>__cuCtxSetCurrent global __cuCtxGetCurrent - data["__cuCtxGetCurrent"] = __cuCtxGetCurrent + data["__cuCtxGetCurrent"] = <_cyb_intptr_t>__cuCtxGetCurrent global __cuCtxGetDevice - data["__cuCtxGetDevice"] = __cuCtxGetDevice + data["__cuCtxGetDevice"] = <_cyb_intptr_t>__cuCtxGetDevice global __cuCtxGetFlags - data["__cuCtxGetFlags"] = __cuCtxGetFlags + data["__cuCtxGetFlags"] = <_cyb_intptr_t>__cuCtxGetFlags global __cuCtxSetFlags - data["__cuCtxSetFlags"] = __cuCtxSetFlags + data["__cuCtxSetFlags"] = <_cyb_intptr_t>__cuCtxSetFlags global __cuCtxGetId - data["__cuCtxGetId"] = __cuCtxGetId + data["__cuCtxGetId"] = <_cyb_intptr_t>__cuCtxGetId global __cuCtxSynchronize - data["__cuCtxSynchronize"] = __cuCtxSynchronize + data["__cuCtxSynchronize"] = <_cyb_intptr_t>__cuCtxSynchronize global __cuCtxSetLimit - data["__cuCtxSetLimit"] = __cuCtxSetLimit + data["__cuCtxSetLimit"] = <_cyb_intptr_t>__cuCtxSetLimit global __cuCtxGetLimit - data["__cuCtxGetLimit"] = __cuCtxGetLimit + data["__cuCtxGetLimit"] = <_cyb_intptr_t>__cuCtxGetLimit global __cuCtxGetCacheConfig - data["__cuCtxGetCacheConfig"] = __cuCtxGetCacheConfig + data["__cuCtxGetCacheConfig"] = <_cyb_intptr_t>__cuCtxGetCacheConfig global __cuCtxSetCacheConfig - data["__cuCtxSetCacheConfig"] = __cuCtxSetCacheConfig + data["__cuCtxSetCacheConfig"] = <_cyb_intptr_t>__cuCtxSetCacheConfig global __cuCtxGetApiVersion - data["__cuCtxGetApiVersion"] = __cuCtxGetApiVersion + data["__cuCtxGetApiVersion"] = <_cyb_intptr_t>__cuCtxGetApiVersion global __cuCtxGetStreamPriorityRange - data["__cuCtxGetStreamPriorityRange"] = __cuCtxGetStreamPriorityRange + data["__cuCtxGetStreamPriorityRange"] = <_cyb_intptr_t>__cuCtxGetStreamPriorityRange global __cuCtxResetPersistingL2Cache - data["__cuCtxResetPersistingL2Cache"] = __cuCtxResetPersistingL2Cache + data["__cuCtxResetPersistingL2Cache"] = <_cyb_intptr_t>__cuCtxResetPersistingL2Cache global __cuCtxGetExecAffinity - data["__cuCtxGetExecAffinity"] = __cuCtxGetExecAffinity + data["__cuCtxGetExecAffinity"] = <_cyb_intptr_t>__cuCtxGetExecAffinity global __cuCtxRecordEvent - data["__cuCtxRecordEvent"] = __cuCtxRecordEvent + data["__cuCtxRecordEvent"] = <_cyb_intptr_t>__cuCtxRecordEvent global __cuCtxWaitEvent - data["__cuCtxWaitEvent"] = __cuCtxWaitEvent + data["__cuCtxWaitEvent"] = <_cyb_intptr_t>__cuCtxWaitEvent global __cuCtxAttach - data["__cuCtxAttach"] = __cuCtxAttach + data["__cuCtxAttach"] = <_cyb_intptr_t>__cuCtxAttach global __cuCtxDetach - data["__cuCtxDetach"] = __cuCtxDetach + data["__cuCtxDetach"] = <_cyb_intptr_t>__cuCtxDetach global __cuCtxGetSharedMemConfig - data["__cuCtxGetSharedMemConfig"] = __cuCtxGetSharedMemConfig + data["__cuCtxGetSharedMemConfig"] = <_cyb_intptr_t>__cuCtxGetSharedMemConfig global __cuCtxSetSharedMemConfig - data["__cuCtxSetSharedMemConfig"] = __cuCtxSetSharedMemConfig + data["__cuCtxSetSharedMemConfig"] = <_cyb_intptr_t>__cuCtxSetSharedMemConfig global __cuModuleLoad - data["__cuModuleLoad"] = __cuModuleLoad + data["__cuModuleLoad"] = <_cyb_intptr_t>__cuModuleLoad global __cuModuleLoadData - data["__cuModuleLoadData"] = __cuModuleLoadData + data["__cuModuleLoadData"] = <_cyb_intptr_t>__cuModuleLoadData global __cuModuleLoadDataEx - data["__cuModuleLoadDataEx"] = __cuModuleLoadDataEx + data["__cuModuleLoadDataEx"] = <_cyb_intptr_t>__cuModuleLoadDataEx global __cuModuleLoadFatBinary - data["__cuModuleLoadFatBinary"] = __cuModuleLoadFatBinary + data["__cuModuleLoadFatBinary"] = <_cyb_intptr_t>__cuModuleLoadFatBinary global __cuModuleUnload - data["__cuModuleUnload"] = __cuModuleUnload + data["__cuModuleUnload"] = <_cyb_intptr_t>__cuModuleUnload global __cuModuleGetLoadingMode - data["__cuModuleGetLoadingMode"] = __cuModuleGetLoadingMode + data["__cuModuleGetLoadingMode"] = <_cyb_intptr_t>__cuModuleGetLoadingMode global __cuModuleGetFunction - data["__cuModuleGetFunction"] = __cuModuleGetFunction + data["__cuModuleGetFunction"] = <_cyb_intptr_t>__cuModuleGetFunction global __cuModuleGetFunctionCount - data["__cuModuleGetFunctionCount"] = __cuModuleGetFunctionCount + data["__cuModuleGetFunctionCount"] = <_cyb_intptr_t>__cuModuleGetFunctionCount global __cuModuleEnumerateFunctions - data["__cuModuleEnumerateFunctions"] = __cuModuleEnumerateFunctions + data["__cuModuleEnumerateFunctions"] = <_cyb_intptr_t>__cuModuleEnumerateFunctions global __cuModuleGetGlobal_v2 - data["__cuModuleGetGlobal_v2"] = __cuModuleGetGlobal_v2 + data["__cuModuleGetGlobal_v2"] = <_cyb_intptr_t>__cuModuleGetGlobal_v2 global __cuLinkCreate_v2 - data["__cuLinkCreate_v2"] = __cuLinkCreate_v2 + data["__cuLinkCreate_v2"] = <_cyb_intptr_t>__cuLinkCreate_v2 global __cuLinkAddData_v2 - data["__cuLinkAddData_v2"] = __cuLinkAddData_v2 + data["__cuLinkAddData_v2"] = <_cyb_intptr_t>__cuLinkAddData_v2 global __cuLinkAddFile_v2 - data["__cuLinkAddFile_v2"] = __cuLinkAddFile_v2 + data["__cuLinkAddFile_v2"] = <_cyb_intptr_t>__cuLinkAddFile_v2 global __cuLinkComplete - data["__cuLinkComplete"] = __cuLinkComplete + data["__cuLinkComplete"] = <_cyb_intptr_t>__cuLinkComplete global __cuLinkDestroy - data["__cuLinkDestroy"] = __cuLinkDestroy + data["__cuLinkDestroy"] = <_cyb_intptr_t>__cuLinkDestroy global __cuModuleGetTexRef - data["__cuModuleGetTexRef"] = __cuModuleGetTexRef + data["__cuModuleGetTexRef"] = <_cyb_intptr_t>__cuModuleGetTexRef global __cuModuleGetSurfRef - data["__cuModuleGetSurfRef"] = __cuModuleGetSurfRef + data["__cuModuleGetSurfRef"] = <_cyb_intptr_t>__cuModuleGetSurfRef global __cuLibraryLoadData - data["__cuLibraryLoadData"] = __cuLibraryLoadData + data["__cuLibraryLoadData"] = <_cyb_intptr_t>__cuLibraryLoadData global __cuLibraryLoadFromFile - data["__cuLibraryLoadFromFile"] = __cuLibraryLoadFromFile + data["__cuLibraryLoadFromFile"] = <_cyb_intptr_t>__cuLibraryLoadFromFile global __cuLibraryUnload - data["__cuLibraryUnload"] = __cuLibraryUnload + data["__cuLibraryUnload"] = <_cyb_intptr_t>__cuLibraryUnload global __cuLibraryGetKernel - data["__cuLibraryGetKernel"] = __cuLibraryGetKernel + data["__cuLibraryGetKernel"] = <_cyb_intptr_t>__cuLibraryGetKernel global __cuLibraryGetKernelCount - data["__cuLibraryGetKernelCount"] = __cuLibraryGetKernelCount + data["__cuLibraryGetKernelCount"] = <_cyb_intptr_t>__cuLibraryGetKernelCount global __cuLibraryEnumerateKernels - data["__cuLibraryEnumerateKernels"] = __cuLibraryEnumerateKernels + data["__cuLibraryEnumerateKernels"] = <_cyb_intptr_t>__cuLibraryEnumerateKernels global __cuLibraryGetModule - data["__cuLibraryGetModule"] = __cuLibraryGetModule + data["__cuLibraryGetModule"] = <_cyb_intptr_t>__cuLibraryGetModule global __cuKernelGetFunction - data["__cuKernelGetFunction"] = __cuKernelGetFunction + data["__cuKernelGetFunction"] = <_cyb_intptr_t>__cuKernelGetFunction global __cuKernelGetLibrary - data["__cuKernelGetLibrary"] = __cuKernelGetLibrary + data["__cuKernelGetLibrary"] = <_cyb_intptr_t>__cuKernelGetLibrary global __cuLibraryGetGlobal - data["__cuLibraryGetGlobal"] = __cuLibraryGetGlobal + data["__cuLibraryGetGlobal"] = <_cyb_intptr_t>__cuLibraryGetGlobal global __cuLibraryGetManaged - data["__cuLibraryGetManaged"] = __cuLibraryGetManaged + data["__cuLibraryGetManaged"] = <_cyb_intptr_t>__cuLibraryGetManaged global __cuLibraryGetUnifiedFunction - data["__cuLibraryGetUnifiedFunction"] = __cuLibraryGetUnifiedFunction + data["__cuLibraryGetUnifiedFunction"] = <_cyb_intptr_t>__cuLibraryGetUnifiedFunction global __cuKernelGetAttribute - data["__cuKernelGetAttribute"] = __cuKernelGetAttribute + data["__cuKernelGetAttribute"] = <_cyb_intptr_t>__cuKernelGetAttribute global __cuKernelSetAttribute - data["__cuKernelSetAttribute"] = __cuKernelSetAttribute + data["__cuKernelSetAttribute"] = <_cyb_intptr_t>__cuKernelSetAttribute global __cuKernelSetCacheConfig - data["__cuKernelSetCacheConfig"] = __cuKernelSetCacheConfig + data["__cuKernelSetCacheConfig"] = <_cyb_intptr_t>__cuKernelSetCacheConfig global __cuKernelGetName - data["__cuKernelGetName"] = __cuKernelGetName + data["__cuKernelGetName"] = <_cyb_intptr_t>__cuKernelGetName global __cuKernelGetParamInfo - data["__cuKernelGetParamInfo"] = __cuKernelGetParamInfo + data["__cuKernelGetParamInfo"] = <_cyb_intptr_t>__cuKernelGetParamInfo global __cuMemGetInfo_v2 - data["__cuMemGetInfo_v2"] = __cuMemGetInfo_v2 + data["__cuMemGetInfo_v2"] = <_cyb_intptr_t>__cuMemGetInfo_v2 global __cuMemAlloc_v2 - data["__cuMemAlloc_v2"] = __cuMemAlloc_v2 + data["__cuMemAlloc_v2"] = <_cyb_intptr_t>__cuMemAlloc_v2 global __cuMemAllocPitch_v2 - data["__cuMemAllocPitch_v2"] = __cuMemAllocPitch_v2 + data["__cuMemAllocPitch_v2"] = <_cyb_intptr_t>__cuMemAllocPitch_v2 global __cuMemFree_v2 - data["__cuMemFree_v2"] = __cuMemFree_v2 + data["__cuMemFree_v2"] = <_cyb_intptr_t>__cuMemFree_v2 global __cuMemGetAddressRange_v2 - data["__cuMemGetAddressRange_v2"] = __cuMemGetAddressRange_v2 + data["__cuMemGetAddressRange_v2"] = <_cyb_intptr_t>__cuMemGetAddressRange_v2 global __cuMemAllocHost_v2 - data["__cuMemAllocHost_v2"] = __cuMemAllocHost_v2 + data["__cuMemAllocHost_v2"] = <_cyb_intptr_t>__cuMemAllocHost_v2 global __cuMemFreeHost - data["__cuMemFreeHost"] = __cuMemFreeHost + data["__cuMemFreeHost"] = <_cyb_intptr_t>__cuMemFreeHost global __cuMemHostAlloc - data["__cuMemHostAlloc"] = __cuMemHostAlloc + data["__cuMemHostAlloc"] = <_cyb_intptr_t>__cuMemHostAlloc global __cuMemHostGetDevicePointer_v2 - data["__cuMemHostGetDevicePointer_v2"] = __cuMemHostGetDevicePointer_v2 + data["__cuMemHostGetDevicePointer_v2"] = <_cyb_intptr_t>__cuMemHostGetDevicePointer_v2 global __cuMemHostGetFlags - data["__cuMemHostGetFlags"] = __cuMemHostGetFlags + data["__cuMemHostGetFlags"] = <_cyb_intptr_t>__cuMemHostGetFlags global __cuMemAllocManaged - data["__cuMemAllocManaged"] = __cuMemAllocManaged + data["__cuMemAllocManaged"] = <_cyb_intptr_t>__cuMemAllocManaged global __cuDeviceRegisterAsyncNotification - data["__cuDeviceRegisterAsyncNotification"] = __cuDeviceRegisterAsyncNotification + data["__cuDeviceRegisterAsyncNotification"] = <_cyb_intptr_t>__cuDeviceRegisterAsyncNotification global __cuDeviceUnregisterAsyncNotification - data["__cuDeviceUnregisterAsyncNotification"] = __cuDeviceUnregisterAsyncNotification + data["__cuDeviceUnregisterAsyncNotification"] = <_cyb_intptr_t>__cuDeviceUnregisterAsyncNotification global __cuDeviceGetByPCIBusId - data["__cuDeviceGetByPCIBusId"] = __cuDeviceGetByPCIBusId + data["__cuDeviceGetByPCIBusId"] = <_cyb_intptr_t>__cuDeviceGetByPCIBusId global __cuDeviceGetPCIBusId - data["__cuDeviceGetPCIBusId"] = __cuDeviceGetPCIBusId + data["__cuDeviceGetPCIBusId"] = <_cyb_intptr_t>__cuDeviceGetPCIBusId global __cuIpcGetEventHandle - data["__cuIpcGetEventHandle"] = __cuIpcGetEventHandle + data["__cuIpcGetEventHandle"] = <_cyb_intptr_t>__cuIpcGetEventHandle global __cuIpcOpenEventHandle - data["__cuIpcOpenEventHandle"] = __cuIpcOpenEventHandle + data["__cuIpcOpenEventHandle"] = <_cyb_intptr_t>__cuIpcOpenEventHandle global __cuIpcGetMemHandle - data["__cuIpcGetMemHandle"] = __cuIpcGetMemHandle + data["__cuIpcGetMemHandle"] = <_cyb_intptr_t>__cuIpcGetMemHandle global __cuIpcOpenMemHandle_v2 - data["__cuIpcOpenMemHandle_v2"] = __cuIpcOpenMemHandle_v2 + data["__cuIpcOpenMemHandle_v2"] = <_cyb_intptr_t>__cuIpcOpenMemHandle_v2 global __cuIpcCloseMemHandle - data["__cuIpcCloseMemHandle"] = __cuIpcCloseMemHandle + data["__cuIpcCloseMemHandle"] = <_cyb_intptr_t>__cuIpcCloseMemHandle global __cuMemHostRegister_v2 - data["__cuMemHostRegister_v2"] = __cuMemHostRegister_v2 + data["__cuMemHostRegister_v2"] = <_cyb_intptr_t>__cuMemHostRegister_v2 global __cuMemHostUnregister - data["__cuMemHostUnregister"] = __cuMemHostUnregister + data["__cuMemHostUnregister"] = <_cyb_intptr_t>__cuMemHostUnregister global __cuMemcpy - data["__cuMemcpy"] = __cuMemcpy + data["__cuMemcpy"] = <_cyb_intptr_t>__cuMemcpy global __cuMemcpyPeer - data["__cuMemcpyPeer"] = __cuMemcpyPeer + data["__cuMemcpyPeer"] = <_cyb_intptr_t>__cuMemcpyPeer global __cuMemcpyHtoD_v2 - data["__cuMemcpyHtoD_v2"] = __cuMemcpyHtoD_v2 + data["__cuMemcpyHtoD_v2"] = <_cyb_intptr_t>__cuMemcpyHtoD_v2 global __cuMemcpyDtoH_v2 - data["__cuMemcpyDtoH_v2"] = __cuMemcpyDtoH_v2 + data["__cuMemcpyDtoH_v2"] = <_cyb_intptr_t>__cuMemcpyDtoH_v2 global __cuMemcpyDtoD_v2 - data["__cuMemcpyDtoD_v2"] = __cuMemcpyDtoD_v2 + data["__cuMemcpyDtoD_v2"] = <_cyb_intptr_t>__cuMemcpyDtoD_v2 global __cuMemcpyDtoA_v2 - data["__cuMemcpyDtoA_v2"] = __cuMemcpyDtoA_v2 + data["__cuMemcpyDtoA_v2"] = <_cyb_intptr_t>__cuMemcpyDtoA_v2 global __cuMemcpyAtoD_v2 - data["__cuMemcpyAtoD_v2"] = __cuMemcpyAtoD_v2 + data["__cuMemcpyAtoD_v2"] = <_cyb_intptr_t>__cuMemcpyAtoD_v2 global __cuMemcpyHtoA_v2 - data["__cuMemcpyHtoA_v2"] = __cuMemcpyHtoA_v2 + data["__cuMemcpyHtoA_v2"] = <_cyb_intptr_t>__cuMemcpyHtoA_v2 global __cuMemcpyAtoH_v2 - data["__cuMemcpyAtoH_v2"] = __cuMemcpyAtoH_v2 + data["__cuMemcpyAtoH_v2"] = <_cyb_intptr_t>__cuMemcpyAtoH_v2 global __cuMemcpyAtoA_v2 - data["__cuMemcpyAtoA_v2"] = __cuMemcpyAtoA_v2 + data["__cuMemcpyAtoA_v2"] = <_cyb_intptr_t>__cuMemcpyAtoA_v2 global __cuMemcpy2D_v2 - data["__cuMemcpy2D_v2"] = __cuMemcpy2D_v2 + data["__cuMemcpy2D_v2"] = <_cyb_intptr_t>__cuMemcpy2D_v2 global __cuMemcpy2DUnaligned_v2 - data["__cuMemcpy2DUnaligned_v2"] = __cuMemcpy2DUnaligned_v2 + data["__cuMemcpy2DUnaligned_v2"] = <_cyb_intptr_t>__cuMemcpy2DUnaligned_v2 global __cuMemcpy3D_v2 - data["__cuMemcpy3D_v2"] = __cuMemcpy3D_v2 + data["__cuMemcpy3D_v2"] = <_cyb_intptr_t>__cuMemcpy3D_v2 global __cuMemcpy3DPeer - data["__cuMemcpy3DPeer"] = __cuMemcpy3DPeer + data["__cuMemcpy3DPeer"] = <_cyb_intptr_t>__cuMemcpy3DPeer global __cuMemcpyAsync - data["__cuMemcpyAsync"] = __cuMemcpyAsync + data["__cuMemcpyAsync"] = <_cyb_intptr_t>__cuMemcpyAsync global __cuMemcpyPeerAsync - data["__cuMemcpyPeerAsync"] = __cuMemcpyPeerAsync + data["__cuMemcpyPeerAsync"] = <_cyb_intptr_t>__cuMemcpyPeerAsync global __cuMemcpyHtoDAsync_v2 - data["__cuMemcpyHtoDAsync_v2"] = __cuMemcpyHtoDAsync_v2 + data["__cuMemcpyHtoDAsync_v2"] = <_cyb_intptr_t>__cuMemcpyHtoDAsync_v2 global __cuMemcpyDtoHAsync_v2 - data["__cuMemcpyDtoHAsync_v2"] = __cuMemcpyDtoHAsync_v2 + data["__cuMemcpyDtoHAsync_v2"] = <_cyb_intptr_t>__cuMemcpyDtoHAsync_v2 global __cuMemcpyDtoDAsync_v2 - data["__cuMemcpyDtoDAsync_v2"] = __cuMemcpyDtoDAsync_v2 + data["__cuMemcpyDtoDAsync_v2"] = <_cyb_intptr_t>__cuMemcpyDtoDAsync_v2 global __cuMemcpyHtoAAsync_v2 - data["__cuMemcpyHtoAAsync_v2"] = __cuMemcpyHtoAAsync_v2 + data["__cuMemcpyHtoAAsync_v2"] = <_cyb_intptr_t>__cuMemcpyHtoAAsync_v2 global __cuMemcpyAtoHAsync_v2 - data["__cuMemcpyAtoHAsync_v2"] = __cuMemcpyAtoHAsync_v2 + data["__cuMemcpyAtoHAsync_v2"] = <_cyb_intptr_t>__cuMemcpyAtoHAsync_v2 global __cuMemcpy2DAsync_v2 - data["__cuMemcpy2DAsync_v2"] = __cuMemcpy2DAsync_v2 + data["__cuMemcpy2DAsync_v2"] = <_cyb_intptr_t>__cuMemcpy2DAsync_v2 global __cuMemcpy3DAsync_v2 - data["__cuMemcpy3DAsync_v2"] = __cuMemcpy3DAsync_v2 + data["__cuMemcpy3DAsync_v2"] = <_cyb_intptr_t>__cuMemcpy3DAsync_v2 global __cuMemcpy3DPeerAsync - data["__cuMemcpy3DPeerAsync"] = __cuMemcpy3DPeerAsync + data["__cuMemcpy3DPeerAsync"] = <_cyb_intptr_t>__cuMemcpy3DPeerAsync global __cuMemsetD8_v2 - data["__cuMemsetD8_v2"] = __cuMemsetD8_v2 + data["__cuMemsetD8_v2"] = <_cyb_intptr_t>__cuMemsetD8_v2 global __cuMemsetD16_v2 - data["__cuMemsetD16_v2"] = __cuMemsetD16_v2 + data["__cuMemsetD16_v2"] = <_cyb_intptr_t>__cuMemsetD16_v2 global __cuMemsetD32_v2 - data["__cuMemsetD32_v2"] = __cuMemsetD32_v2 + data["__cuMemsetD32_v2"] = <_cyb_intptr_t>__cuMemsetD32_v2 global __cuMemsetD2D8_v2 - data["__cuMemsetD2D8_v2"] = __cuMemsetD2D8_v2 + data["__cuMemsetD2D8_v2"] = <_cyb_intptr_t>__cuMemsetD2D8_v2 global __cuMemsetD2D16_v2 - data["__cuMemsetD2D16_v2"] = __cuMemsetD2D16_v2 + data["__cuMemsetD2D16_v2"] = <_cyb_intptr_t>__cuMemsetD2D16_v2 global __cuMemsetD2D32_v2 - data["__cuMemsetD2D32_v2"] = __cuMemsetD2D32_v2 + data["__cuMemsetD2D32_v2"] = <_cyb_intptr_t>__cuMemsetD2D32_v2 global __cuMemsetD8Async - data["__cuMemsetD8Async"] = __cuMemsetD8Async + data["__cuMemsetD8Async"] = <_cyb_intptr_t>__cuMemsetD8Async global __cuMemsetD16Async - data["__cuMemsetD16Async"] = __cuMemsetD16Async + data["__cuMemsetD16Async"] = <_cyb_intptr_t>__cuMemsetD16Async global __cuMemsetD32Async - data["__cuMemsetD32Async"] = __cuMemsetD32Async + data["__cuMemsetD32Async"] = <_cyb_intptr_t>__cuMemsetD32Async global __cuMemsetD2D8Async - data["__cuMemsetD2D8Async"] = __cuMemsetD2D8Async + data["__cuMemsetD2D8Async"] = <_cyb_intptr_t>__cuMemsetD2D8Async global __cuMemsetD2D16Async - data["__cuMemsetD2D16Async"] = __cuMemsetD2D16Async + data["__cuMemsetD2D16Async"] = <_cyb_intptr_t>__cuMemsetD2D16Async global __cuMemsetD2D32Async - data["__cuMemsetD2D32Async"] = __cuMemsetD2D32Async + data["__cuMemsetD2D32Async"] = <_cyb_intptr_t>__cuMemsetD2D32Async global __cuArrayCreate_v2 - data["__cuArrayCreate_v2"] = __cuArrayCreate_v2 + data["__cuArrayCreate_v2"] = <_cyb_intptr_t>__cuArrayCreate_v2 global __cuArrayGetDescriptor_v2 - data["__cuArrayGetDescriptor_v2"] = __cuArrayGetDescriptor_v2 + data["__cuArrayGetDescriptor_v2"] = <_cyb_intptr_t>__cuArrayGetDescriptor_v2 global __cuArrayGetSparseProperties - data["__cuArrayGetSparseProperties"] = __cuArrayGetSparseProperties + data["__cuArrayGetSparseProperties"] = <_cyb_intptr_t>__cuArrayGetSparseProperties global __cuMipmappedArrayGetSparseProperties - data["__cuMipmappedArrayGetSparseProperties"] = __cuMipmappedArrayGetSparseProperties + data["__cuMipmappedArrayGetSparseProperties"] = <_cyb_intptr_t>__cuMipmappedArrayGetSparseProperties global __cuArrayGetMemoryRequirements - data["__cuArrayGetMemoryRequirements"] = __cuArrayGetMemoryRequirements + data["__cuArrayGetMemoryRequirements"] = <_cyb_intptr_t>__cuArrayGetMemoryRequirements global __cuMipmappedArrayGetMemoryRequirements - data["__cuMipmappedArrayGetMemoryRequirements"] = __cuMipmappedArrayGetMemoryRequirements + data["__cuMipmappedArrayGetMemoryRequirements"] = <_cyb_intptr_t>__cuMipmappedArrayGetMemoryRequirements global __cuArrayGetPlane - data["__cuArrayGetPlane"] = __cuArrayGetPlane + data["__cuArrayGetPlane"] = <_cyb_intptr_t>__cuArrayGetPlane global __cuArrayDestroy - data["__cuArrayDestroy"] = __cuArrayDestroy + data["__cuArrayDestroy"] = <_cyb_intptr_t>__cuArrayDestroy global __cuArray3DCreate_v2 - data["__cuArray3DCreate_v2"] = __cuArray3DCreate_v2 + data["__cuArray3DCreate_v2"] = <_cyb_intptr_t>__cuArray3DCreate_v2 global __cuArray3DGetDescriptor_v2 - data["__cuArray3DGetDescriptor_v2"] = __cuArray3DGetDescriptor_v2 + data["__cuArray3DGetDescriptor_v2"] = <_cyb_intptr_t>__cuArray3DGetDescriptor_v2 global __cuMipmappedArrayCreate - data["__cuMipmappedArrayCreate"] = __cuMipmappedArrayCreate + data["__cuMipmappedArrayCreate"] = <_cyb_intptr_t>__cuMipmappedArrayCreate global __cuMipmappedArrayGetLevel - data["__cuMipmappedArrayGetLevel"] = __cuMipmappedArrayGetLevel + data["__cuMipmappedArrayGetLevel"] = <_cyb_intptr_t>__cuMipmappedArrayGetLevel global __cuMipmappedArrayDestroy - data["__cuMipmappedArrayDestroy"] = __cuMipmappedArrayDestroy + data["__cuMipmappedArrayDestroy"] = <_cyb_intptr_t>__cuMipmappedArrayDestroy global __cuMemGetHandleForAddressRange - data["__cuMemGetHandleForAddressRange"] = __cuMemGetHandleForAddressRange + data["__cuMemGetHandleForAddressRange"] = <_cyb_intptr_t>__cuMemGetHandleForAddressRange global __cuMemBatchDecompressAsync - data["__cuMemBatchDecompressAsync"] = __cuMemBatchDecompressAsync + data["__cuMemBatchDecompressAsync"] = <_cyb_intptr_t>__cuMemBatchDecompressAsync global __cuMemAddressReserve - data["__cuMemAddressReserve"] = __cuMemAddressReserve + data["__cuMemAddressReserve"] = <_cyb_intptr_t>__cuMemAddressReserve global __cuMemAddressFree - data["__cuMemAddressFree"] = __cuMemAddressFree + data["__cuMemAddressFree"] = <_cyb_intptr_t>__cuMemAddressFree global __cuMemCreate - data["__cuMemCreate"] = __cuMemCreate + data["__cuMemCreate"] = <_cyb_intptr_t>__cuMemCreate global __cuMemRelease - data["__cuMemRelease"] = __cuMemRelease + data["__cuMemRelease"] = <_cyb_intptr_t>__cuMemRelease global __cuMemMap - data["__cuMemMap"] = __cuMemMap + data["__cuMemMap"] = <_cyb_intptr_t>__cuMemMap global __cuMemMapArrayAsync - data["__cuMemMapArrayAsync"] = __cuMemMapArrayAsync + data["__cuMemMapArrayAsync"] = <_cyb_intptr_t>__cuMemMapArrayAsync global __cuMemUnmap - data["__cuMemUnmap"] = __cuMemUnmap + data["__cuMemUnmap"] = <_cyb_intptr_t>__cuMemUnmap global __cuMemSetAccess - data["__cuMemSetAccess"] = __cuMemSetAccess + data["__cuMemSetAccess"] = <_cyb_intptr_t>__cuMemSetAccess global __cuMemGetAccess - data["__cuMemGetAccess"] = __cuMemGetAccess + data["__cuMemGetAccess"] = <_cyb_intptr_t>__cuMemGetAccess global __cuMemExportToShareableHandle - data["__cuMemExportToShareableHandle"] = __cuMemExportToShareableHandle + data["__cuMemExportToShareableHandle"] = <_cyb_intptr_t>__cuMemExportToShareableHandle global __cuMemImportFromShareableHandle - data["__cuMemImportFromShareableHandle"] = __cuMemImportFromShareableHandle + data["__cuMemImportFromShareableHandle"] = <_cyb_intptr_t>__cuMemImportFromShareableHandle global __cuMemGetAllocationGranularity - data["__cuMemGetAllocationGranularity"] = __cuMemGetAllocationGranularity + data["__cuMemGetAllocationGranularity"] = <_cyb_intptr_t>__cuMemGetAllocationGranularity global __cuMemGetAllocationPropertiesFromHandle - data["__cuMemGetAllocationPropertiesFromHandle"] = __cuMemGetAllocationPropertiesFromHandle + data["__cuMemGetAllocationPropertiesFromHandle"] = <_cyb_intptr_t>__cuMemGetAllocationPropertiesFromHandle global __cuMemRetainAllocationHandle - data["__cuMemRetainAllocationHandle"] = __cuMemRetainAllocationHandle + data["__cuMemRetainAllocationHandle"] = <_cyb_intptr_t>__cuMemRetainAllocationHandle global __cuMemFreeAsync - data["__cuMemFreeAsync"] = __cuMemFreeAsync + data["__cuMemFreeAsync"] = <_cyb_intptr_t>__cuMemFreeAsync global __cuMemAllocAsync - data["__cuMemAllocAsync"] = __cuMemAllocAsync + data["__cuMemAllocAsync"] = <_cyb_intptr_t>__cuMemAllocAsync global __cuMemPoolTrimTo - data["__cuMemPoolTrimTo"] = __cuMemPoolTrimTo + data["__cuMemPoolTrimTo"] = <_cyb_intptr_t>__cuMemPoolTrimTo global __cuMemPoolSetAttribute - data["__cuMemPoolSetAttribute"] = __cuMemPoolSetAttribute + data["__cuMemPoolSetAttribute"] = <_cyb_intptr_t>__cuMemPoolSetAttribute global __cuMemPoolGetAttribute - data["__cuMemPoolGetAttribute"] = __cuMemPoolGetAttribute + data["__cuMemPoolGetAttribute"] = <_cyb_intptr_t>__cuMemPoolGetAttribute global __cuMemPoolSetAccess - data["__cuMemPoolSetAccess"] = __cuMemPoolSetAccess + data["__cuMemPoolSetAccess"] = <_cyb_intptr_t>__cuMemPoolSetAccess global __cuMemPoolGetAccess - data["__cuMemPoolGetAccess"] = __cuMemPoolGetAccess + data["__cuMemPoolGetAccess"] = <_cyb_intptr_t>__cuMemPoolGetAccess global __cuMemPoolCreate - data["__cuMemPoolCreate"] = __cuMemPoolCreate + data["__cuMemPoolCreate"] = <_cyb_intptr_t>__cuMemPoolCreate global __cuMemPoolDestroy - data["__cuMemPoolDestroy"] = __cuMemPoolDestroy + data["__cuMemPoolDestroy"] = <_cyb_intptr_t>__cuMemPoolDestroy global __cuMemAllocFromPoolAsync - data["__cuMemAllocFromPoolAsync"] = __cuMemAllocFromPoolAsync + data["__cuMemAllocFromPoolAsync"] = <_cyb_intptr_t>__cuMemAllocFromPoolAsync global __cuMemPoolExportToShareableHandle - data["__cuMemPoolExportToShareableHandle"] = __cuMemPoolExportToShareableHandle + data["__cuMemPoolExportToShareableHandle"] = <_cyb_intptr_t>__cuMemPoolExportToShareableHandle global __cuMemPoolImportFromShareableHandle - data["__cuMemPoolImportFromShareableHandle"] = __cuMemPoolImportFromShareableHandle + data["__cuMemPoolImportFromShareableHandle"] = <_cyb_intptr_t>__cuMemPoolImportFromShareableHandle global __cuMemPoolExportPointer - data["__cuMemPoolExportPointer"] = __cuMemPoolExportPointer + data["__cuMemPoolExportPointer"] = <_cyb_intptr_t>__cuMemPoolExportPointer global __cuMemPoolImportPointer - data["__cuMemPoolImportPointer"] = __cuMemPoolImportPointer + data["__cuMemPoolImportPointer"] = <_cyb_intptr_t>__cuMemPoolImportPointer global __cuMulticastCreate - data["__cuMulticastCreate"] = __cuMulticastCreate + data["__cuMulticastCreate"] = <_cyb_intptr_t>__cuMulticastCreate global __cuMulticastAddDevice - data["__cuMulticastAddDevice"] = __cuMulticastAddDevice + data["__cuMulticastAddDevice"] = <_cyb_intptr_t>__cuMulticastAddDevice global __cuMulticastBindMem - data["__cuMulticastBindMem"] = __cuMulticastBindMem + data["__cuMulticastBindMem"] = <_cyb_intptr_t>__cuMulticastBindMem global __cuMulticastBindAddr - data["__cuMulticastBindAddr"] = __cuMulticastBindAddr + data["__cuMulticastBindAddr"] = <_cyb_intptr_t>__cuMulticastBindAddr global __cuMulticastUnbind - data["__cuMulticastUnbind"] = __cuMulticastUnbind + data["__cuMulticastUnbind"] = <_cyb_intptr_t>__cuMulticastUnbind global __cuMulticastGetGranularity - data["__cuMulticastGetGranularity"] = __cuMulticastGetGranularity + data["__cuMulticastGetGranularity"] = <_cyb_intptr_t>__cuMulticastGetGranularity global __cuPointerGetAttribute - data["__cuPointerGetAttribute"] = __cuPointerGetAttribute + data["__cuPointerGetAttribute"] = <_cyb_intptr_t>__cuPointerGetAttribute global __cuMemPrefetchAsync_v2 - data["__cuMemPrefetchAsync_v2"] = __cuMemPrefetchAsync_v2 + data["__cuMemPrefetchAsync_v2"] = <_cyb_intptr_t>__cuMemPrefetchAsync_v2 global __cuMemAdvise_v2 - data["__cuMemAdvise_v2"] = __cuMemAdvise_v2 + data["__cuMemAdvise_v2"] = <_cyb_intptr_t>__cuMemAdvise_v2 global __cuMemRangeGetAttribute - data["__cuMemRangeGetAttribute"] = __cuMemRangeGetAttribute + data["__cuMemRangeGetAttribute"] = <_cyb_intptr_t>__cuMemRangeGetAttribute global __cuMemRangeGetAttributes - data["__cuMemRangeGetAttributes"] = __cuMemRangeGetAttributes + data["__cuMemRangeGetAttributes"] = <_cyb_intptr_t>__cuMemRangeGetAttributes global __cuPointerSetAttribute - data["__cuPointerSetAttribute"] = __cuPointerSetAttribute + data["__cuPointerSetAttribute"] = <_cyb_intptr_t>__cuPointerSetAttribute global __cuPointerGetAttributes - data["__cuPointerGetAttributes"] = __cuPointerGetAttributes + data["__cuPointerGetAttributes"] = <_cyb_intptr_t>__cuPointerGetAttributes global __cuStreamCreate - data["__cuStreamCreate"] = __cuStreamCreate + data["__cuStreamCreate"] = <_cyb_intptr_t>__cuStreamCreate global __cuStreamCreateWithPriority - data["__cuStreamCreateWithPriority"] = __cuStreamCreateWithPriority + data["__cuStreamCreateWithPriority"] = <_cyb_intptr_t>__cuStreamCreateWithPriority global __cuStreamGetPriority - data["__cuStreamGetPriority"] = __cuStreamGetPriority + data["__cuStreamGetPriority"] = <_cyb_intptr_t>__cuStreamGetPriority global __cuStreamGetDevice - data["__cuStreamGetDevice"] = __cuStreamGetDevice + data["__cuStreamGetDevice"] = <_cyb_intptr_t>__cuStreamGetDevice global __cuStreamGetFlags - data["__cuStreamGetFlags"] = __cuStreamGetFlags + data["__cuStreamGetFlags"] = <_cyb_intptr_t>__cuStreamGetFlags global __cuStreamGetId - data["__cuStreamGetId"] = __cuStreamGetId + data["__cuStreamGetId"] = <_cyb_intptr_t>__cuStreamGetId global __cuStreamGetCtx - data["__cuStreamGetCtx"] = __cuStreamGetCtx + data["__cuStreamGetCtx"] = <_cyb_intptr_t>__cuStreamGetCtx global __cuStreamGetCtx_v2 - data["__cuStreamGetCtx_v2"] = __cuStreamGetCtx_v2 + data["__cuStreamGetCtx_v2"] = <_cyb_intptr_t>__cuStreamGetCtx_v2 global __cuStreamWaitEvent - data["__cuStreamWaitEvent"] = __cuStreamWaitEvent + data["__cuStreamWaitEvent"] = <_cyb_intptr_t>__cuStreamWaitEvent global __cuStreamAddCallback - data["__cuStreamAddCallback"] = __cuStreamAddCallback + data["__cuStreamAddCallback"] = <_cyb_intptr_t>__cuStreamAddCallback global __cuStreamBeginCapture_v2 - data["__cuStreamBeginCapture_v2"] = __cuStreamBeginCapture_v2 + data["__cuStreamBeginCapture_v2"] = <_cyb_intptr_t>__cuStreamBeginCapture_v2 global __cuStreamBeginCaptureToGraph - data["__cuStreamBeginCaptureToGraph"] = __cuStreamBeginCaptureToGraph + data["__cuStreamBeginCaptureToGraph"] = <_cyb_intptr_t>__cuStreamBeginCaptureToGraph global __cuThreadExchangeStreamCaptureMode - data["__cuThreadExchangeStreamCaptureMode"] = __cuThreadExchangeStreamCaptureMode + data["__cuThreadExchangeStreamCaptureMode"] = <_cyb_intptr_t>__cuThreadExchangeStreamCaptureMode global __cuStreamEndCapture - data["__cuStreamEndCapture"] = __cuStreamEndCapture + data["__cuStreamEndCapture"] = <_cyb_intptr_t>__cuStreamEndCapture global __cuStreamIsCapturing - data["__cuStreamIsCapturing"] = __cuStreamIsCapturing + data["__cuStreamIsCapturing"] = <_cyb_intptr_t>__cuStreamIsCapturing global __cuStreamGetCaptureInfo_v2 - data["__cuStreamGetCaptureInfo_v2"] = __cuStreamGetCaptureInfo_v2 + data["__cuStreamGetCaptureInfo_v2"] = <_cyb_intptr_t>__cuStreamGetCaptureInfo_v2 global __cuStreamGetCaptureInfo_v3 - data["__cuStreamGetCaptureInfo_v3"] = __cuStreamGetCaptureInfo_v3 + data["__cuStreamGetCaptureInfo_v3"] = <_cyb_intptr_t>__cuStreamGetCaptureInfo_v3 global __cuStreamUpdateCaptureDependencies_v2 - data["__cuStreamUpdateCaptureDependencies_v2"] = __cuStreamUpdateCaptureDependencies_v2 + data["__cuStreamUpdateCaptureDependencies_v2"] = <_cyb_intptr_t>__cuStreamUpdateCaptureDependencies_v2 global __cuStreamAttachMemAsync - data["__cuStreamAttachMemAsync"] = __cuStreamAttachMemAsync + data["__cuStreamAttachMemAsync"] = <_cyb_intptr_t>__cuStreamAttachMemAsync global __cuStreamQuery - data["__cuStreamQuery"] = __cuStreamQuery + data["__cuStreamQuery"] = <_cyb_intptr_t>__cuStreamQuery global __cuStreamSynchronize - data["__cuStreamSynchronize"] = __cuStreamSynchronize + data["__cuStreamSynchronize"] = <_cyb_intptr_t>__cuStreamSynchronize global __cuStreamDestroy_v2 - data["__cuStreamDestroy_v2"] = __cuStreamDestroy_v2 + data["__cuStreamDestroy_v2"] = <_cyb_intptr_t>__cuStreamDestroy_v2 global __cuStreamCopyAttributes - data["__cuStreamCopyAttributes"] = __cuStreamCopyAttributes + data["__cuStreamCopyAttributes"] = <_cyb_intptr_t>__cuStreamCopyAttributes global __cuStreamGetAttribute - data["__cuStreamGetAttribute"] = __cuStreamGetAttribute + data["__cuStreamGetAttribute"] = <_cyb_intptr_t>__cuStreamGetAttribute global __cuStreamSetAttribute - data["__cuStreamSetAttribute"] = __cuStreamSetAttribute + data["__cuStreamSetAttribute"] = <_cyb_intptr_t>__cuStreamSetAttribute global __cuEventCreate - data["__cuEventCreate"] = __cuEventCreate + data["__cuEventCreate"] = <_cyb_intptr_t>__cuEventCreate global __cuEventRecord - data["__cuEventRecord"] = __cuEventRecord + data["__cuEventRecord"] = <_cyb_intptr_t>__cuEventRecord global __cuEventRecordWithFlags - data["__cuEventRecordWithFlags"] = __cuEventRecordWithFlags + data["__cuEventRecordWithFlags"] = <_cyb_intptr_t>__cuEventRecordWithFlags global __cuEventQuery - data["__cuEventQuery"] = __cuEventQuery + data["__cuEventQuery"] = <_cyb_intptr_t>__cuEventQuery global __cuEventSynchronize - data["__cuEventSynchronize"] = __cuEventSynchronize + data["__cuEventSynchronize"] = <_cyb_intptr_t>__cuEventSynchronize global __cuEventDestroy_v2 - data["__cuEventDestroy_v2"] = __cuEventDestroy_v2 + data["__cuEventDestroy_v2"] = <_cyb_intptr_t>__cuEventDestroy_v2 global __cuEventElapsedTime_v2 - data["__cuEventElapsedTime_v2"] = __cuEventElapsedTime_v2 + data["__cuEventElapsedTime_v2"] = <_cyb_intptr_t>__cuEventElapsedTime_v2 global __cuImportExternalMemory - data["__cuImportExternalMemory"] = __cuImportExternalMemory + data["__cuImportExternalMemory"] = <_cyb_intptr_t>__cuImportExternalMemory global __cuExternalMemoryGetMappedBuffer - data["__cuExternalMemoryGetMappedBuffer"] = __cuExternalMemoryGetMappedBuffer + data["__cuExternalMemoryGetMappedBuffer"] = <_cyb_intptr_t>__cuExternalMemoryGetMappedBuffer global __cuExternalMemoryGetMappedMipmappedArray - data["__cuExternalMemoryGetMappedMipmappedArray"] = __cuExternalMemoryGetMappedMipmappedArray + data["__cuExternalMemoryGetMappedMipmappedArray"] = <_cyb_intptr_t>__cuExternalMemoryGetMappedMipmappedArray global __cuDestroyExternalMemory - data["__cuDestroyExternalMemory"] = __cuDestroyExternalMemory + data["__cuDestroyExternalMemory"] = <_cyb_intptr_t>__cuDestroyExternalMemory global __cuImportExternalSemaphore - data["__cuImportExternalSemaphore"] = __cuImportExternalSemaphore + data["__cuImportExternalSemaphore"] = <_cyb_intptr_t>__cuImportExternalSemaphore global __cuSignalExternalSemaphoresAsync - data["__cuSignalExternalSemaphoresAsync"] = __cuSignalExternalSemaphoresAsync + data["__cuSignalExternalSemaphoresAsync"] = <_cyb_intptr_t>__cuSignalExternalSemaphoresAsync global __cuWaitExternalSemaphoresAsync - data["__cuWaitExternalSemaphoresAsync"] = __cuWaitExternalSemaphoresAsync + data["__cuWaitExternalSemaphoresAsync"] = <_cyb_intptr_t>__cuWaitExternalSemaphoresAsync global __cuDestroyExternalSemaphore - data["__cuDestroyExternalSemaphore"] = __cuDestroyExternalSemaphore + data["__cuDestroyExternalSemaphore"] = <_cyb_intptr_t>__cuDestroyExternalSemaphore global __cuStreamWaitValue32_v2 - data["__cuStreamWaitValue32_v2"] = __cuStreamWaitValue32_v2 + data["__cuStreamWaitValue32_v2"] = <_cyb_intptr_t>__cuStreamWaitValue32_v2 global __cuStreamWaitValue64_v2 - data["__cuStreamWaitValue64_v2"] = __cuStreamWaitValue64_v2 + data["__cuStreamWaitValue64_v2"] = <_cyb_intptr_t>__cuStreamWaitValue64_v2 global __cuStreamWriteValue32_v2 - data["__cuStreamWriteValue32_v2"] = __cuStreamWriteValue32_v2 + data["__cuStreamWriteValue32_v2"] = <_cyb_intptr_t>__cuStreamWriteValue32_v2 global __cuStreamWriteValue64_v2 - data["__cuStreamWriteValue64_v2"] = __cuStreamWriteValue64_v2 + data["__cuStreamWriteValue64_v2"] = <_cyb_intptr_t>__cuStreamWriteValue64_v2 global __cuStreamBatchMemOp_v2 - data["__cuStreamBatchMemOp_v2"] = __cuStreamBatchMemOp_v2 + data["__cuStreamBatchMemOp_v2"] = <_cyb_intptr_t>__cuStreamBatchMemOp_v2 global __cuFuncGetAttribute - data["__cuFuncGetAttribute"] = __cuFuncGetAttribute + data["__cuFuncGetAttribute"] = <_cyb_intptr_t>__cuFuncGetAttribute global __cuFuncSetAttribute - data["__cuFuncSetAttribute"] = __cuFuncSetAttribute + data["__cuFuncSetAttribute"] = <_cyb_intptr_t>__cuFuncSetAttribute global __cuFuncSetCacheConfig - data["__cuFuncSetCacheConfig"] = __cuFuncSetCacheConfig + data["__cuFuncSetCacheConfig"] = <_cyb_intptr_t>__cuFuncSetCacheConfig global __cuFuncGetModule - data["__cuFuncGetModule"] = __cuFuncGetModule + data["__cuFuncGetModule"] = <_cyb_intptr_t>__cuFuncGetModule global __cuFuncGetName - data["__cuFuncGetName"] = __cuFuncGetName + data["__cuFuncGetName"] = <_cyb_intptr_t>__cuFuncGetName global __cuFuncGetParamInfo - data["__cuFuncGetParamInfo"] = __cuFuncGetParamInfo + data["__cuFuncGetParamInfo"] = <_cyb_intptr_t>__cuFuncGetParamInfo global __cuFuncIsLoaded - data["__cuFuncIsLoaded"] = __cuFuncIsLoaded + data["__cuFuncIsLoaded"] = <_cyb_intptr_t>__cuFuncIsLoaded global __cuFuncLoad - data["__cuFuncLoad"] = __cuFuncLoad + data["__cuFuncLoad"] = <_cyb_intptr_t>__cuFuncLoad global __cuLaunchKernel - data["__cuLaunchKernel"] = __cuLaunchKernel + data["__cuLaunchKernel"] = <_cyb_intptr_t>__cuLaunchKernel global __cuLaunchKernelEx - data["__cuLaunchKernelEx"] = __cuLaunchKernelEx + data["__cuLaunchKernelEx"] = <_cyb_intptr_t>__cuLaunchKernelEx global __cuLaunchCooperativeKernel - data["__cuLaunchCooperativeKernel"] = __cuLaunchCooperativeKernel + data["__cuLaunchCooperativeKernel"] = <_cyb_intptr_t>__cuLaunchCooperativeKernel global __cuLaunchCooperativeKernelMultiDevice - data["__cuLaunchCooperativeKernelMultiDevice"] = __cuLaunchCooperativeKernelMultiDevice + data["__cuLaunchCooperativeKernelMultiDevice"] = <_cyb_intptr_t>__cuLaunchCooperativeKernelMultiDevice global __cuLaunchHostFunc - data["__cuLaunchHostFunc"] = __cuLaunchHostFunc + data["__cuLaunchHostFunc"] = <_cyb_intptr_t>__cuLaunchHostFunc global __cuFuncSetBlockShape - data["__cuFuncSetBlockShape"] = __cuFuncSetBlockShape + data["__cuFuncSetBlockShape"] = <_cyb_intptr_t>__cuFuncSetBlockShape global __cuFuncSetSharedSize - data["__cuFuncSetSharedSize"] = __cuFuncSetSharedSize + data["__cuFuncSetSharedSize"] = <_cyb_intptr_t>__cuFuncSetSharedSize global __cuParamSetSize - data["__cuParamSetSize"] = __cuParamSetSize + data["__cuParamSetSize"] = <_cyb_intptr_t>__cuParamSetSize global __cuParamSeti - data["__cuParamSeti"] = __cuParamSeti + data["__cuParamSeti"] = <_cyb_intptr_t>__cuParamSeti global __cuParamSetf - data["__cuParamSetf"] = __cuParamSetf + data["__cuParamSetf"] = <_cyb_intptr_t>__cuParamSetf global __cuParamSetv - data["__cuParamSetv"] = __cuParamSetv + data["__cuParamSetv"] = <_cyb_intptr_t>__cuParamSetv global __cuLaunch - data["__cuLaunch"] = __cuLaunch + data["__cuLaunch"] = <_cyb_intptr_t>__cuLaunch global __cuLaunchGrid - data["__cuLaunchGrid"] = __cuLaunchGrid + data["__cuLaunchGrid"] = <_cyb_intptr_t>__cuLaunchGrid global __cuLaunchGridAsync - data["__cuLaunchGridAsync"] = __cuLaunchGridAsync + data["__cuLaunchGridAsync"] = <_cyb_intptr_t>__cuLaunchGridAsync global __cuParamSetTexRef - data["__cuParamSetTexRef"] = __cuParamSetTexRef + data["__cuParamSetTexRef"] = <_cyb_intptr_t>__cuParamSetTexRef global __cuFuncSetSharedMemConfig - data["__cuFuncSetSharedMemConfig"] = __cuFuncSetSharedMemConfig + data["__cuFuncSetSharedMemConfig"] = <_cyb_intptr_t>__cuFuncSetSharedMemConfig global __cuGraphCreate - data["__cuGraphCreate"] = __cuGraphCreate + data["__cuGraphCreate"] = <_cyb_intptr_t>__cuGraphCreate global __cuGraphAddKernelNode_v2 - data["__cuGraphAddKernelNode_v2"] = __cuGraphAddKernelNode_v2 + data["__cuGraphAddKernelNode_v2"] = <_cyb_intptr_t>__cuGraphAddKernelNode_v2 global __cuGraphKernelNodeGetParams_v2 - data["__cuGraphKernelNodeGetParams_v2"] = __cuGraphKernelNodeGetParams_v2 + data["__cuGraphKernelNodeGetParams_v2"] = <_cyb_intptr_t>__cuGraphKernelNodeGetParams_v2 global __cuGraphKernelNodeSetParams_v2 - data["__cuGraphKernelNodeSetParams_v2"] = __cuGraphKernelNodeSetParams_v2 + data["__cuGraphKernelNodeSetParams_v2"] = <_cyb_intptr_t>__cuGraphKernelNodeSetParams_v2 global __cuGraphAddMemcpyNode - data["__cuGraphAddMemcpyNode"] = __cuGraphAddMemcpyNode + data["__cuGraphAddMemcpyNode"] = <_cyb_intptr_t>__cuGraphAddMemcpyNode global __cuGraphMemcpyNodeGetParams - data["__cuGraphMemcpyNodeGetParams"] = __cuGraphMemcpyNodeGetParams + data["__cuGraphMemcpyNodeGetParams"] = <_cyb_intptr_t>__cuGraphMemcpyNodeGetParams global __cuGraphMemcpyNodeSetParams - data["__cuGraphMemcpyNodeSetParams"] = __cuGraphMemcpyNodeSetParams + data["__cuGraphMemcpyNodeSetParams"] = <_cyb_intptr_t>__cuGraphMemcpyNodeSetParams global __cuGraphAddMemsetNode - data["__cuGraphAddMemsetNode"] = __cuGraphAddMemsetNode + data["__cuGraphAddMemsetNode"] = <_cyb_intptr_t>__cuGraphAddMemsetNode global __cuGraphMemsetNodeGetParams - data["__cuGraphMemsetNodeGetParams"] = __cuGraphMemsetNodeGetParams + data["__cuGraphMemsetNodeGetParams"] = <_cyb_intptr_t>__cuGraphMemsetNodeGetParams global __cuGraphMemsetNodeSetParams - data["__cuGraphMemsetNodeSetParams"] = __cuGraphMemsetNodeSetParams + data["__cuGraphMemsetNodeSetParams"] = <_cyb_intptr_t>__cuGraphMemsetNodeSetParams global __cuGraphAddHostNode - data["__cuGraphAddHostNode"] = __cuGraphAddHostNode + data["__cuGraphAddHostNode"] = <_cyb_intptr_t>__cuGraphAddHostNode global __cuGraphHostNodeGetParams - data["__cuGraphHostNodeGetParams"] = __cuGraphHostNodeGetParams + data["__cuGraphHostNodeGetParams"] = <_cyb_intptr_t>__cuGraphHostNodeGetParams global __cuGraphHostNodeSetParams - data["__cuGraphHostNodeSetParams"] = __cuGraphHostNodeSetParams + data["__cuGraphHostNodeSetParams"] = <_cyb_intptr_t>__cuGraphHostNodeSetParams global __cuGraphAddChildGraphNode - data["__cuGraphAddChildGraphNode"] = __cuGraphAddChildGraphNode + data["__cuGraphAddChildGraphNode"] = <_cyb_intptr_t>__cuGraphAddChildGraphNode global __cuGraphChildGraphNodeGetGraph - data["__cuGraphChildGraphNodeGetGraph"] = __cuGraphChildGraphNodeGetGraph + data["__cuGraphChildGraphNodeGetGraph"] = <_cyb_intptr_t>__cuGraphChildGraphNodeGetGraph global __cuGraphAddEmptyNode - data["__cuGraphAddEmptyNode"] = __cuGraphAddEmptyNode + data["__cuGraphAddEmptyNode"] = <_cyb_intptr_t>__cuGraphAddEmptyNode global __cuGraphAddEventRecordNode - data["__cuGraphAddEventRecordNode"] = __cuGraphAddEventRecordNode + data["__cuGraphAddEventRecordNode"] = <_cyb_intptr_t>__cuGraphAddEventRecordNode global __cuGraphEventRecordNodeGetEvent - data["__cuGraphEventRecordNodeGetEvent"] = __cuGraphEventRecordNodeGetEvent + data["__cuGraphEventRecordNodeGetEvent"] = <_cyb_intptr_t>__cuGraphEventRecordNodeGetEvent global __cuGraphEventRecordNodeSetEvent - data["__cuGraphEventRecordNodeSetEvent"] = __cuGraphEventRecordNodeSetEvent + data["__cuGraphEventRecordNodeSetEvent"] = <_cyb_intptr_t>__cuGraphEventRecordNodeSetEvent global __cuGraphAddEventWaitNode - data["__cuGraphAddEventWaitNode"] = __cuGraphAddEventWaitNode + data["__cuGraphAddEventWaitNode"] = <_cyb_intptr_t>__cuGraphAddEventWaitNode global __cuGraphEventWaitNodeGetEvent - data["__cuGraphEventWaitNodeGetEvent"] = __cuGraphEventWaitNodeGetEvent + data["__cuGraphEventWaitNodeGetEvent"] = <_cyb_intptr_t>__cuGraphEventWaitNodeGetEvent global __cuGraphEventWaitNodeSetEvent - data["__cuGraphEventWaitNodeSetEvent"] = __cuGraphEventWaitNodeSetEvent + data["__cuGraphEventWaitNodeSetEvent"] = <_cyb_intptr_t>__cuGraphEventWaitNodeSetEvent global __cuGraphAddExternalSemaphoresSignalNode - data["__cuGraphAddExternalSemaphoresSignalNode"] = __cuGraphAddExternalSemaphoresSignalNode + data["__cuGraphAddExternalSemaphoresSignalNode"] = <_cyb_intptr_t>__cuGraphAddExternalSemaphoresSignalNode global __cuGraphExternalSemaphoresSignalNodeGetParams - data["__cuGraphExternalSemaphoresSignalNodeGetParams"] = __cuGraphExternalSemaphoresSignalNodeGetParams + data["__cuGraphExternalSemaphoresSignalNodeGetParams"] = <_cyb_intptr_t>__cuGraphExternalSemaphoresSignalNodeGetParams global __cuGraphExternalSemaphoresSignalNodeSetParams - data["__cuGraphExternalSemaphoresSignalNodeSetParams"] = __cuGraphExternalSemaphoresSignalNodeSetParams + data["__cuGraphExternalSemaphoresSignalNodeSetParams"] = <_cyb_intptr_t>__cuGraphExternalSemaphoresSignalNodeSetParams global __cuGraphAddExternalSemaphoresWaitNode - data["__cuGraphAddExternalSemaphoresWaitNode"] = __cuGraphAddExternalSemaphoresWaitNode + data["__cuGraphAddExternalSemaphoresWaitNode"] = <_cyb_intptr_t>__cuGraphAddExternalSemaphoresWaitNode global __cuGraphExternalSemaphoresWaitNodeGetParams - data["__cuGraphExternalSemaphoresWaitNodeGetParams"] = __cuGraphExternalSemaphoresWaitNodeGetParams + data["__cuGraphExternalSemaphoresWaitNodeGetParams"] = <_cyb_intptr_t>__cuGraphExternalSemaphoresWaitNodeGetParams global __cuGraphExternalSemaphoresWaitNodeSetParams - data["__cuGraphExternalSemaphoresWaitNodeSetParams"] = __cuGraphExternalSemaphoresWaitNodeSetParams + data["__cuGraphExternalSemaphoresWaitNodeSetParams"] = <_cyb_intptr_t>__cuGraphExternalSemaphoresWaitNodeSetParams global __cuGraphAddBatchMemOpNode - data["__cuGraphAddBatchMemOpNode"] = __cuGraphAddBatchMemOpNode + data["__cuGraphAddBatchMemOpNode"] = <_cyb_intptr_t>__cuGraphAddBatchMemOpNode global __cuGraphBatchMemOpNodeGetParams - data["__cuGraphBatchMemOpNodeGetParams"] = __cuGraphBatchMemOpNodeGetParams + data["__cuGraphBatchMemOpNodeGetParams"] = <_cyb_intptr_t>__cuGraphBatchMemOpNodeGetParams global __cuGraphBatchMemOpNodeSetParams - data["__cuGraphBatchMemOpNodeSetParams"] = __cuGraphBatchMemOpNodeSetParams + data["__cuGraphBatchMemOpNodeSetParams"] = <_cyb_intptr_t>__cuGraphBatchMemOpNodeSetParams global __cuGraphExecBatchMemOpNodeSetParams - data["__cuGraphExecBatchMemOpNodeSetParams"] = __cuGraphExecBatchMemOpNodeSetParams + data["__cuGraphExecBatchMemOpNodeSetParams"] = <_cyb_intptr_t>__cuGraphExecBatchMemOpNodeSetParams global __cuGraphAddMemAllocNode - data["__cuGraphAddMemAllocNode"] = __cuGraphAddMemAllocNode + data["__cuGraphAddMemAllocNode"] = <_cyb_intptr_t>__cuGraphAddMemAllocNode global __cuGraphMemAllocNodeGetParams - data["__cuGraphMemAllocNodeGetParams"] = __cuGraphMemAllocNodeGetParams + data["__cuGraphMemAllocNodeGetParams"] = <_cyb_intptr_t>__cuGraphMemAllocNodeGetParams global __cuGraphAddMemFreeNode - data["__cuGraphAddMemFreeNode"] = __cuGraphAddMemFreeNode + data["__cuGraphAddMemFreeNode"] = <_cyb_intptr_t>__cuGraphAddMemFreeNode global __cuGraphMemFreeNodeGetParams - data["__cuGraphMemFreeNodeGetParams"] = __cuGraphMemFreeNodeGetParams + data["__cuGraphMemFreeNodeGetParams"] = <_cyb_intptr_t>__cuGraphMemFreeNodeGetParams global __cuDeviceGraphMemTrim - data["__cuDeviceGraphMemTrim"] = __cuDeviceGraphMemTrim + data["__cuDeviceGraphMemTrim"] = <_cyb_intptr_t>__cuDeviceGraphMemTrim global __cuDeviceGetGraphMemAttribute - data["__cuDeviceGetGraphMemAttribute"] = __cuDeviceGetGraphMemAttribute + data["__cuDeviceGetGraphMemAttribute"] = <_cyb_intptr_t>__cuDeviceGetGraphMemAttribute global __cuDeviceSetGraphMemAttribute - data["__cuDeviceSetGraphMemAttribute"] = __cuDeviceSetGraphMemAttribute + data["__cuDeviceSetGraphMemAttribute"] = <_cyb_intptr_t>__cuDeviceSetGraphMemAttribute global __cuGraphClone - data["__cuGraphClone"] = __cuGraphClone + data["__cuGraphClone"] = <_cyb_intptr_t>__cuGraphClone global __cuGraphNodeFindInClone - data["__cuGraphNodeFindInClone"] = __cuGraphNodeFindInClone + data["__cuGraphNodeFindInClone"] = <_cyb_intptr_t>__cuGraphNodeFindInClone global __cuGraphNodeGetType - data["__cuGraphNodeGetType"] = __cuGraphNodeGetType + data["__cuGraphNodeGetType"] = <_cyb_intptr_t>__cuGraphNodeGetType global __cuGraphGetNodes - data["__cuGraphGetNodes"] = __cuGraphGetNodes + data["__cuGraphGetNodes"] = <_cyb_intptr_t>__cuGraphGetNodes global __cuGraphGetRootNodes - data["__cuGraphGetRootNodes"] = __cuGraphGetRootNodes + data["__cuGraphGetRootNodes"] = <_cyb_intptr_t>__cuGraphGetRootNodes global __cuGraphGetEdges_v2 - data["__cuGraphGetEdges_v2"] = __cuGraphGetEdges_v2 + data["__cuGraphGetEdges_v2"] = <_cyb_intptr_t>__cuGraphGetEdges_v2 global __cuGraphNodeGetDependencies_v2 - data["__cuGraphNodeGetDependencies_v2"] = __cuGraphNodeGetDependencies_v2 + data["__cuGraphNodeGetDependencies_v2"] = <_cyb_intptr_t>__cuGraphNodeGetDependencies_v2 global __cuGraphNodeGetDependentNodes_v2 - data["__cuGraphNodeGetDependentNodes_v2"] = __cuGraphNodeGetDependentNodes_v2 + data["__cuGraphNodeGetDependentNodes_v2"] = <_cyb_intptr_t>__cuGraphNodeGetDependentNodes_v2 global __cuGraphAddDependencies_v2 - data["__cuGraphAddDependencies_v2"] = __cuGraphAddDependencies_v2 + data["__cuGraphAddDependencies_v2"] = <_cyb_intptr_t>__cuGraphAddDependencies_v2 global __cuGraphRemoveDependencies_v2 - data["__cuGraphRemoveDependencies_v2"] = __cuGraphRemoveDependencies_v2 + data["__cuGraphRemoveDependencies_v2"] = <_cyb_intptr_t>__cuGraphRemoveDependencies_v2 global __cuGraphDestroyNode - data["__cuGraphDestroyNode"] = __cuGraphDestroyNode + data["__cuGraphDestroyNode"] = <_cyb_intptr_t>__cuGraphDestroyNode global __cuGraphInstantiateWithFlags - data["__cuGraphInstantiateWithFlags"] = __cuGraphInstantiateWithFlags + data["__cuGraphInstantiateWithFlags"] = <_cyb_intptr_t>__cuGraphInstantiateWithFlags global __cuGraphInstantiateWithParams - data["__cuGraphInstantiateWithParams"] = __cuGraphInstantiateWithParams + data["__cuGraphInstantiateWithParams"] = <_cyb_intptr_t>__cuGraphInstantiateWithParams global __cuGraphExecGetFlags - data["__cuGraphExecGetFlags"] = __cuGraphExecGetFlags + data["__cuGraphExecGetFlags"] = <_cyb_intptr_t>__cuGraphExecGetFlags global __cuGraphExecKernelNodeSetParams_v2 - data["__cuGraphExecKernelNodeSetParams_v2"] = __cuGraphExecKernelNodeSetParams_v2 + data["__cuGraphExecKernelNodeSetParams_v2"] = <_cyb_intptr_t>__cuGraphExecKernelNodeSetParams_v2 global __cuGraphExecMemcpyNodeSetParams - data["__cuGraphExecMemcpyNodeSetParams"] = __cuGraphExecMemcpyNodeSetParams + data["__cuGraphExecMemcpyNodeSetParams"] = <_cyb_intptr_t>__cuGraphExecMemcpyNodeSetParams global __cuGraphExecMemsetNodeSetParams - data["__cuGraphExecMemsetNodeSetParams"] = __cuGraphExecMemsetNodeSetParams + data["__cuGraphExecMemsetNodeSetParams"] = <_cyb_intptr_t>__cuGraphExecMemsetNodeSetParams global __cuGraphExecHostNodeSetParams - data["__cuGraphExecHostNodeSetParams"] = __cuGraphExecHostNodeSetParams + data["__cuGraphExecHostNodeSetParams"] = <_cyb_intptr_t>__cuGraphExecHostNodeSetParams global __cuGraphExecChildGraphNodeSetParams - data["__cuGraphExecChildGraphNodeSetParams"] = __cuGraphExecChildGraphNodeSetParams + data["__cuGraphExecChildGraphNodeSetParams"] = <_cyb_intptr_t>__cuGraphExecChildGraphNodeSetParams global __cuGraphExecEventRecordNodeSetEvent - data["__cuGraphExecEventRecordNodeSetEvent"] = __cuGraphExecEventRecordNodeSetEvent + data["__cuGraphExecEventRecordNodeSetEvent"] = <_cyb_intptr_t>__cuGraphExecEventRecordNodeSetEvent global __cuGraphExecEventWaitNodeSetEvent - data["__cuGraphExecEventWaitNodeSetEvent"] = __cuGraphExecEventWaitNodeSetEvent + data["__cuGraphExecEventWaitNodeSetEvent"] = <_cyb_intptr_t>__cuGraphExecEventWaitNodeSetEvent global __cuGraphExecExternalSemaphoresSignalNodeSetParams - data["__cuGraphExecExternalSemaphoresSignalNodeSetParams"] = __cuGraphExecExternalSemaphoresSignalNodeSetParams + data["__cuGraphExecExternalSemaphoresSignalNodeSetParams"] = <_cyb_intptr_t>__cuGraphExecExternalSemaphoresSignalNodeSetParams global __cuGraphExecExternalSemaphoresWaitNodeSetParams - data["__cuGraphExecExternalSemaphoresWaitNodeSetParams"] = __cuGraphExecExternalSemaphoresWaitNodeSetParams + data["__cuGraphExecExternalSemaphoresWaitNodeSetParams"] = <_cyb_intptr_t>__cuGraphExecExternalSemaphoresWaitNodeSetParams global __cuGraphNodeSetEnabled - data["__cuGraphNodeSetEnabled"] = __cuGraphNodeSetEnabled + data["__cuGraphNodeSetEnabled"] = <_cyb_intptr_t>__cuGraphNodeSetEnabled global __cuGraphNodeGetEnabled - data["__cuGraphNodeGetEnabled"] = __cuGraphNodeGetEnabled + data["__cuGraphNodeGetEnabled"] = <_cyb_intptr_t>__cuGraphNodeGetEnabled global __cuGraphUpload - data["__cuGraphUpload"] = __cuGraphUpload + data["__cuGraphUpload"] = <_cyb_intptr_t>__cuGraphUpload global __cuGraphLaunch - data["__cuGraphLaunch"] = __cuGraphLaunch + data["__cuGraphLaunch"] = <_cyb_intptr_t>__cuGraphLaunch global __cuGraphExecDestroy - data["__cuGraphExecDestroy"] = __cuGraphExecDestroy + data["__cuGraphExecDestroy"] = <_cyb_intptr_t>__cuGraphExecDestroy global __cuGraphDestroy - data["__cuGraphDestroy"] = __cuGraphDestroy + data["__cuGraphDestroy"] = <_cyb_intptr_t>__cuGraphDestroy global __cuGraphExecUpdate_v2 - data["__cuGraphExecUpdate_v2"] = __cuGraphExecUpdate_v2 + data["__cuGraphExecUpdate_v2"] = <_cyb_intptr_t>__cuGraphExecUpdate_v2 global __cuGraphKernelNodeCopyAttributes - data["__cuGraphKernelNodeCopyAttributes"] = __cuGraphKernelNodeCopyAttributes + data["__cuGraphKernelNodeCopyAttributes"] = <_cyb_intptr_t>__cuGraphKernelNodeCopyAttributes global __cuGraphKernelNodeGetAttribute - data["__cuGraphKernelNodeGetAttribute"] = __cuGraphKernelNodeGetAttribute + data["__cuGraphKernelNodeGetAttribute"] = <_cyb_intptr_t>__cuGraphKernelNodeGetAttribute global __cuGraphKernelNodeSetAttribute - data["__cuGraphKernelNodeSetAttribute"] = __cuGraphKernelNodeSetAttribute + data["__cuGraphKernelNodeSetAttribute"] = <_cyb_intptr_t>__cuGraphKernelNodeSetAttribute global __cuGraphDebugDotPrint - data["__cuGraphDebugDotPrint"] = __cuGraphDebugDotPrint + data["__cuGraphDebugDotPrint"] = <_cyb_intptr_t>__cuGraphDebugDotPrint global __cuUserObjectCreate - data["__cuUserObjectCreate"] = __cuUserObjectCreate + data["__cuUserObjectCreate"] = <_cyb_intptr_t>__cuUserObjectCreate global __cuUserObjectRetain - data["__cuUserObjectRetain"] = __cuUserObjectRetain + data["__cuUserObjectRetain"] = <_cyb_intptr_t>__cuUserObjectRetain global __cuUserObjectRelease - data["__cuUserObjectRelease"] = __cuUserObjectRelease + data["__cuUserObjectRelease"] = <_cyb_intptr_t>__cuUserObjectRelease global __cuGraphRetainUserObject - data["__cuGraphRetainUserObject"] = __cuGraphRetainUserObject + data["__cuGraphRetainUserObject"] = <_cyb_intptr_t>__cuGraphRetainUserObject global __cuGraphReleaseUserObject - data["__cuGraphReleaseUserObject"] = __cuGraphReleaseUserObject + data["__cuGraphReleaseUserObject"] = <_cyb_intptr_t>__cuGraphReleaseUserObject global __cuGraphAddNode_v2 - data["__cuGraphAddNode_v2"] = __cuGraphAddNode_v2 + data["__cuGraphAddNode_v2"] = <_cyb_intptr_t>__cuGraphAddNode_v2 global __cuGraphNodeSetParams - data["__cuGraphNodeSetParams"] = __cuGraphNodeSetParams + data["__cuGraphNodeSetParams"] = <_cyb_intptr_t>__cuGraphNodeSetParams global __cuGraphExecNodeSetParams - data["__cuGraphExecNodeSetParams"] = __cuGraphExecNodeSetParams + data["__cuGraphExecNodeSetParams"] = <_cyb_intptr_t>__cuGraphExecNodeSetParams global __cuGraphConditionalHandleCreate - data["__cuGraphConditionalHandleCreate"] = __cuGraphConditionalHandleCreate + data["__cuGraphConditionalHandleCreate"] = <_cyb_intptr_t>__cuGraphConditionalHandleCreate global __cuOccupancyMaxActiveBlocksPerMultiprocessor - data["__cuOccupancyMaxActiveBlocksPerMultiprocessor"] = __cuOccupancyMaxActiveBlocksPerMultiprocessor + data["__cuOccupancyMaxActiveBlocksPerMultiprocessor"] = <_cyb_intptr_t>__cuOccupancyMaxActiveBlocksPerMultiprocessor global __cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags - data["__cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags"] = __cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags + data["__cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags"] = <_cyb_intptr_t>__cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags global __cuOccupancyMaxPotentialBlockSize - data["__cuOccupancyMaxPotentialBlockSize"] = __cuOccupancyMaxPotentialBlockSize + data["__cuOccupancyMaxPotentialBlockSize"] = <_cyb_intptr_t>__cuOccupancyMaxPotentialBlockSize global __cuOccupancyMaxPotentialBlockSizeWithFlags - data["__cuOccupancyMaxPotentialBlockSizeWithFlags"] = __cuOccupancyMaxPotentialBlockSizeWithFlags + data["__cuOccupancyMaxPotentialBlockSizeWithFlags"] = <_cyb_intptr_t>__cuOccupancyMaxPotentialBlockSizeWithFlags global __cuOccupancyAvailableDynamicSMemPerBlock - data["__cuOccupancyAvailableDynamicSMemPerBlock"] = __cuOccupancyAvailableDynamicSMemPerBlock + data["__cuOccupancyAvailableDynamicSMemPerBlock"] = <_cyb_intptr_t>__cuOccupancyAvailableDynamicSMemPerBlock global __cuOccupancyMaxPotentialClusterSize - data["__cuOccupancyMaxPotentialClusterSize"] = __cuOccupancyMaxPotentialClusterSize + data["__cuOccupancyMaxPotentialClusterSize"] = <_cyb_intptr_t>__cuOccupancyMaxPotentialClusterSize global __cuOccupancyMaxActiveClusters - data["__cuOccupancyMaxActiveClusters"] = __cuOccupancyMaxActiveClusters + data["__cuOccupancyMaxActiveClusters"] = <_cyb_intptr_t>__cuOccupancyMaxActiveClusters global __cuTexRefSetArray - data["__cuTexRefSetArray"] = __cuTexRefSetArray + data["__cuTexRefSetArray"] = <_cyb_intptr_t>__cuTexRefSetArray global __cuTexRefSetMipmappedArray - data["__cuTexRefSetMipmappedArray"] = __cuTexRefSetMipmappedArray + data["__cuTexRefSetMipmappedArray"] = <_cyb_intptr_t>__cuTexRefSetMipmappedArray global __cuTexRefSetAddress_v2 - data["__cuTexRefSetAddress_v2"] = __cuTexRefSetAddress_v2 + data["__cuTexRefSetAddress_v2"] = <_cyb_intptr_t>__cuTexRefSetAddress_v2 global __cuTexRefSetAddress2D_v3 - data["__cuTexRefSetAddress2D_v3"] = __cuTexRefSetAddress2D_v3 + data["__cuTexRefSetAddress2D_v3"] = <_cyb_intptr_t>__cuTexRefSetAddress2D_v3 global __cuTexRefSetFormat - data["__cuTexRefSetFormat"] = __cuTexRefSetFormat + data["__cuTexRefSetFormat"] = <_cyb_intptr_t>__cuTexRefSetFormat global __cuTexRefSetAddressMode - data["__cuTexRefSetAddressMode"] = __cuTexRefSetAddressMode + data["__cuTexRefSetAddressMode"] = <_cyb_intptr_t>__cuTexRefSetAddressMode global __cuTexRefSetFilterMode - data["__cuTexRefSetFilterMode"] = __cuTexRefSetFilterMode + data["__cuTexRefSetFilterMode"] = <_cyb_intptr_t>__cuTexRefSetFilterMode global __cuTexRefSetMipmapFilterMode - data["__cuTexRefSetMipmapFilterMode"] = __cuTexRefSetMipmapFilterMode + data["__cuTexRefSetMipmapFilterMode"] = <_cyb_intptr_t>__cuTexRefSetMipmapFilterMode global __cuTexRefSetMipmapLevelBias - data["__cuTexRefSetMipmapLevelBias"] = __cuTexRefSetMipmapLevelBias + data["__cuTexRefSetMipmapLevelBias"] = <_cyb_intptr_t>__cuTexRefSetMipmapLevelBias global __cuTexRefSetMipmapLevelClamp - data["__cuTexRefSetMipmapLevelClamp"] = __cuTexRefSetMipmapLevelClamp + data["__cuTexRefSetMipmapLevelClamp"] = <_cyb_intptr_t>__cuTexRefSetMipmapLevelClamp global __cuTexRefSetMaxAnisotropy - data["__cuTexRefSetMaxAnisotropy"] = __cuTexRefSetMaxAnisotropy + data["__cuTexRefSetMaxAnisotropy"] = <_cyb_intptr_t>__cuTexRefSetMaxAnisotropy global __cuTexRefSetBorderColor - data["__cuTexRefSetBorderColor"] = __cuTexRefSetBorderColor + data["__cuTexRefSetBorderColor"] = <_cyb_intptr_t>__cuTexRefSetBorderColor global __cuTexRefSetFlags - data["__cuTexRefSetFlags"] = __cuTexRefSetFlags + data["__cuTexRefSetFlags"] = <_cyb_intptr_t>__cuTexRefSetFlags global __cuTexRefGetAddress_v2 - data["__cuTexRefGetAddress_v2"] = __cuTexRefGetAddress_v2 + data["__cuTexRefGetAddress_v2"] = <_cyb_intptr_t>__cuTexRefGetAddress_v2 global __cuTexRefGetArray - data["__cuTexRefGetArray"] = __cuTexRefGetArray + data["__cuTexRefGetArray"] = <_cyb_intptr_t>__cuTexRefGetArray global __cuTexRefGetMipmappedArray - data["__cuTexRefGetMipmappedArray"] = __cuTexRefGetMipmappedArray + data["__cuTexRefGetMipmappedArray"] = <_cyb_intptr_t>__cuTexRefGetMipmappedArray global __cuTexRefGetAddressMode - data["__cuTexRefGetAddressMode"] = __cuTexRefGetAddressMode + data["__cuTexRefGetAddressMode"] = <_cyb_intptr_t>__cuTexRefGetAddressMode global __cuTexRefGetFilterMode - data["__cuTexRefGetFilterMode"] = __cuTexRefGetFilterMode + data["__cuTexRefGetFilterMode"] = <_cyb_intptr_t>__cuTexRefGetFilterMode global __cuTexRefGetFormat - data["__cuTexRefGetFormat"] = __cuTexRefGetFormat + data["__cuTexRefGetFormat"] = <_cyb_intptr_t>__cuTexRefGetFormat global __cuTexRefGetMipmapFilterMode - data["__cuTexRefGetMipmapFilterMode"] = __cuTexRefGetMipmapFilterMode + data["__cuTexRefGetMipmapFilterMode"] = <_cyb_intptr_t>__cuTexRefGetMipmapFilterMode global __cuTexRefGetMipmapLevelBias - data["__cuTexRefGetMipmapLevelBias"] = __cuTexRefGetMipmapLevelBias + data["__cuTexRefGetMipmapLevelBias"] = <_cyb_intptr_t>__cuTexRefGetMipmapLevelBias global __cuTexRefGetMipmapLevelClamp - data["__cuTexRefGetMipmapLevelClamp"] = __cuTexRefGetMipmapLevelClamp + data["__cuTexRefGetMipmapLevelClamp"] = <_cyb_intptr_t>__cuTexRefGetMipmapLevelClamp global __cuTexRefGetMaxAnisotropy - data["__cuTexRefGetMaxAnisotropy"] = __cuTexRefGetMaxAnisotropy + data["__cuTexRefGetMaxAnisotropy"] = <_cyb_intptr_t>__cuTexRefGetMaxAnisotropy global __cuTexRefGetBorderColor - data["__cuTexRefGetBorderColor"] = __cuTexRefGetBorderColor + data["__cuTexRefGetBorderColor"] = <_cyb_intptr_t>__cuTexRefGetBorderColor global __cuTexRefGetFlags - data["__cuTexRefGetFlags"] = __cuTexRefGetFlags + data["__cuTexRefGetFlags"] = <_cyb_intptr_t>__cuTexRefGetFlags global __cuTexRefCreate - data["__cuTexRefCreate"] = __cuTexRefCreate + data["__cuTexRefCreate"] = <_cyb_intptr_t>__cuTexRefCreate global __cuTexRefDestroy - data["__cuTexRefDestroy"] = __cuTexRefDestroy + data["__cuTexRefDestroy"] = <_cyb_intptr_t>__cuTexRefDestroy global __cuSurfRefSetArray - data["__cuSurfRefSetArray"] = __cuSurfRefSetArray + data["__cuSurfRefSetArray"] = <_cyb_intptr_t>__cuSurfRefSetArray global __cuSurfRefGetArray - data["__cuSurfRefGetArray"] = __cuSurfRefGetArray + data["__cuSurfRefGetArray"] = <_cyb_intptr_t>__cuSurfRefGetArray global __cuTexObjectCreate - data["__cuTexObjectCreate"] = __cuTexObjectCreate + data["__cuTexObjectCreate"] = <_cyb_intptr_t>__cuTexObjectCreate global __cuTexObjectDestroy - data["__cuTexObjectDestroy"] = __cuTexObjectDestroy + data["__cuTexObjectDestroy"] = <_cyb_intptr_t>__cuTexObjectDestroy global __cuTexObjectGetResourceDesc - data["__cuTexObjectGetResourceDesc"] = __cuTexObjectGetResourceDesc + data["__cuTexObjectGetResourceDesc"] = <_cyb_intptr_t>__cuTexObjectGetResourceDesc global __cuTexObjectGetTextureDesc - data["__cuTexObjectGetTextureDesc"] = __cuTexObjectGetTextureDesc + data["__cuTexObjectGetTextureDesc"] = <_cyb_intptr_t>__cuTexObjectGetTextureDesc global __cuTexObjectGetResourceViewDesc - data["__cuTexObjectGetResourceViewDesc"] = __cuTexObjectGetResourceViewDesc + data["__cuTexObjectGetResourceViewDesc"] = <_cyb_intptr_t>__cuTexObjectGetResourceViewDesc global __cuSurfObjectCreate - data["__cuSurfObjectCreate"] = __cuSurfObjectCreate + data["__cuSurfObjectCreate"] = <_cyb_intptr_t>__cuSurfObjectCreate global __cuSurfObjectDestroy - data["__cuSurfObjectDestroy"] = __cuSurfObjectDestroy + data["__cuSurfObjectDestroy"] = <_cyb_intptr_t>__cuSurfObjectDestroy global __cuSurfObjectGetResourceDesc - data["__cuSurfObjectGetResourceDesc"] = __cuSurfObjectGetResourceDesc + data["__cuSurfObjectGetResourceDesc"] = <_cyb_intptr_t>__cuSurfObjectGetResourceDesc global __cuTensorMapEncodeTiled - data["__cuTensorMapEncodeTiled"] = __cuTensorMapEncodeTiled + data["__cuTensorMapEncodeTiled"] = <_cyb_intptr_t>__cuTensorMapEncodeTiled global __cuTensorMapEncodeIm2col - data["__cuTensorMapEncodeIm2col"] = __cuTensorMapEncodeIm2col + data["__cuTensorMapEncodeIm2col"] = <_cyb_intptr_t>__cuTensorMapEncodeIm2col global __cuTensorMapEncodeIm2colWide - data["__cuTensorMapEncodeIm2colWide"] = __cuTensorMapEncodeIm2colWide + data["__cuTensorMapEncodeIm2colWide"] = <_cyb_intptr_t>__cuTensorMapEncodeIm2colWide global __cuTensorMapReplaceAddress - data["__cuTensorMapReplaceAddress"] = __cuTensorMapReplaceAddress + data["__cuTensorMapReplaceAddress"] = <_cyb_intptr_t>__cuTensorMapReplaceAddress global __cuDeviceCanAccessPeer - data["__cuDeviceCanAccessPeer"] = __cuDeviceCanAccessPeer + data["__cuDeviceCanAccessPeer"] = <_cyb_intptr_t>__cuDeviceCanAccessPeer global __cuCtxEnablePeerAccess - data["__cuCtxEnablePeerAccess"] = __cuCtxEnablePeerAccess + data["__cuCtxEnablePeerAccess"] = <_cyb_intptr_t>__cuCtxEnablePeerAccess global __cuCtxDisablePeerAccess - data["__cuCtxDisablePeerAccess"] = __cuCtxDisablePeerAccess + data["__cuCtxDisablePeerAccess"] = <_cyb_intptr_t>__cuCtxDisablePeerAccess global __cuDeviceGetP2PAttribute - data["__cuDeviceGetP2PAttribute"] = __cuDeviceGetP2PAttribute + data["__cuDeviceGetP2PAttribute"] = <_cyb_intptr_t>__cuDeviceGetP2PAttribute global __cuGraphicsUnregisterResource - data["__cuGraphicsUnregisterResource"] = __cuGraphicsUnregisterResource + data["__cuGraphicsUnregisterResource"] = <_cyb_intptr_t>__cuGraphicsUnregisterResource global __cuGraphicsSubResourceGetMappedArray - data["__cuGraphicsSubResourceGetMappedArray"] = __cuGraphicsSubResourceGetMappedArray + data["__cuGraphicsSubResourceGetMappedArray"] = <_cyb_intptr_t>__cuGraphicsSubResourceGetMappedArray global __cuGraphicsResourceGetMappedMipmappedArray - data["__cuGraphicsResourceGetMappedMipmappedArray"] = __cuGraphicsResourceGetMappedMipmappedArray + data["__cuGraphicsResourceGetMappedMipmappedArray"] = <_cyb_intptr_t>__cuGraphicsResourceGetMappedMipmappedArray global __cuGraphicsResourceGetMappedPointer_v2 - data["__cuGraphicsResourceGetMappedPointer_v2"] = __cuGraphicsResourceGetMappedPointer_v2 + data["__cuGraphicsResourceGetMappedPointer_v2"] = <_cyb_intptr_t>__cuGraphicsResourceGetMappedPointer_v2 global __cuGraphicsResourceSetMapFlags_v2 - data["__cuGraphicsResourceSetMapFlags_v2"] = __cuGraphicsResourceSetMapFlags_v2 + data["__cuGraphicsResourceSetMapFlags_v2"] = <_cyb_intptr_t>__cuGraphicsResourceSetMapFlags_v2 global __cuGraphicsMapResources - data["__cuGraphicsMapResources"] = __cuGraphicsMapResources + data["__cuGraphicsMapResources"] = <_cyb_intptr_t>__cuGraphicsMapResources global __cuGraphicsUnmapResources - data["__cuGraphicsUnmapResources"] = __cuGraphicsUnmapResources + data["__cuGraphicsUnmapResources"] = <_cyb_intptr_t>__cuGraphicsUnmapResources global __cuGetProcAddress_v2 - data["__cuGetProcAddress_v2"] = __cuGetProcAddress_v2 + data["__cuGetProcAddress_v2"] = <_cyb_intptr_t>__cuGetProcAddress_v2 global __cuCoredumpGetAttribute - data["__cuCoredumpGetAttribute"] = __cuCoredumpGetAttribute + data["__cuCoredumpGetAttribute"] = <_cyb_intptr_t>__cuCoredumpGetAttribute global __cuCoredumpGetAttributeGlobal - data["__cuCoredumpGetAttributeGlobal"] = __cuCoredumpGetAttributeGlobal + data["__cuCoredumpGetAttributeGlobal"] = <_cyb_intptr_t>__cuCoredumpGetAttributeGlobal global __cuCoredumpSetAttribute - data["__cuCoredumpSetAttribute"] = __cuCoredumpSetAttribute + data["__cuCoredumpSetAttribute"] = <_cyb_intptr_t>__cuCoredumpSetAttribute global __cuCoredumpSetAttributeGlobal - data["__cuCoredumpSetAttributeGlobal"] = __cuCoredumpSetAttributeGlobal + data["__cuCoredumpSetAttributeGlobal"] = <_cyb_intptr_t>__cuCoredumpSetAttributeGlobal global __cuGetExportTable - data["__cuGetExportTable"] = __cuGetExportTable + data["__cuGetExportTable"] = <_cyb_intptr_t>__cuGetExportTable global __cuGreenCtxCreate - data["__cuGreenCtxCreate"] = __cuGreenCtxCreate + data["__cuGreenCtxCreate"] = <_cyb_intptr_t>__cuGreenCtxCreate global __cuGreenCtxDestroy - data["__cuGreenCtxDestroy"] = __cuGreenCtxDestroy + data["__cuGreenCtxDestroy"] = <_cyb_intptr_t>__cuGreenCtxDestroy global __cuCtxFromGreenCtx - data["__cuCtxFromGreenCtx"] = __cuCtxFromGreenCtx + data["__cuCtxFromGreenCtx"] = <_cyb_intptr_t>__cuCtxFromGreenCtx global __cuDeviceGetDevResource - data["__cuDeviceGetDevResource"] = __cuDeviceGetDevResource + data["__cuDeviceGetDevResource"] = <_cyb_intptr_t>__cuDeviceGetDevResource global __cuCtxGetDevResource - data["__cuCtxGetDevResource"] = __cuCtxGetDevResource + data["__cuCtxGetDevResource"] = <_cyb_intptr_t>__cuCtxGetDevResource global __cuGreenCtxGetDevResource - data["__cuGreenCtxGetDevResource"] = __cuGreenCtxGetDevResource + data["__cuGreenCtxGetDevResource"] = <_cyb_intptr_t>__cuGreenCtxGetDevResource global __cuDevSmResourceSplitByCount - data["__cuDevSmResourceSplitByCount"] = __cuDevSmResourceSplitByCount + data["__cuDevSmResourceSplitByCount"] = <_cyb_intptr_t>__cuDevSmResourceSplitByCount global __cuDevResourceGenerateDesc - data["__cuDevResourceGenerateDesc"] = __cuDevResourceGenerateDesc + data["__cuDevResourceGenerateDesc"] = <_cyb_intptr_t>__cuDevResourceGenerateDesc global __cuGreenCtxRecordEvent - data["__cuGreenCtxRecordEvent"] = __cuGreenCtxRecordEvent + data["__cuGreenCtxRecordEvent"] = <_cyb_intptr_t>__cuGreenCtxRecordEvent global __cuGreenCtxWaitEvent - data["__cuGreenCtxWaitEvent"] = __cuGreenCtxWaitEvent + data["__cuGreenCtxWaitEvent"] = <_cyb_intptr_t>__cuGreenCtxWaitEvent global __cuStreamGetGreenCtx - data["__cuStreamGetGreenCtx"] = __cuStreamGetGreenCtx + data["__cuStreamGetGreenCtx"] = <_cyb_intptr_t>__cuStreamGetGreenCtx global __cuGreenCtxStreamCreate - data["__cuGreenCtxStreamCreate"] = __cuGreenCtxStreamCreate + data["__cuGreenCtxStreamCreate"] = <_cyb_intptr_t>__cuGreenCtxStreamCreate global __cuLogsRegisterCallback - data["__cuLogsRegisterCallback"] = __cuLogsRegisterCallback + data["__cuLogsRegisterCallback"] = <_cyb_intptr_t>__cuLogsRegisterCallback global __cuLogsUnregisterCallback - data["__cuLogsUnregisterCallback"] = __cuLogsUnregisterCallback + data["__cuLogsUnregisterCallback"] = <_cyb_intptr_t>__cuLogsUnregisterCallback global __cuLogsCurrent - data["__cuLogsCurrent"] = __cuLogsCurrent + data["__cuLogsCurrent"] = <_cyb_intptr_t>__cuLogsCurrent global __cuLogsDumpToFile - data["__cuLogsDumpToFile"] = __cuLogsDumpToFile + data["__cuLogsDumpToFile"] = <_cyb_intptr_t>__cuLogsDumpToFile global __cuLogsDumpToMemory - data["__cuLogsDumpToMemory"] = __cuLogsDumpToMemory + data["__cuLogsDumpToMemory"] = <_cyb_intptr_t>__cuLogsDumpToMemory global __cuCheckpointProcessGetRestoreThreadId - data["__cuCheckpointProcessGetRestoreThreadId"] = __cuCheckpointProcessGetRestoreThreadId + data["__cuCheckpointProcessGetRestoreThreadId"] = <_cyb_intptr_t>__cuCheckpointProcessGetRestoreThreadId global __cuCheckpointProcessGetState - data["__cuCheckpointProcessGetState"] = __cuCheckpointProcessGetState + data["__cuCheckpointProcessGetState"] = <_cyb_intptr_t>__cuCheckpointProcessGetState global __cuCheckpointProcessLock - data["__cuCheckpointProcessLock"] = __cuCheckpointProcessLock + data["__cuCheckpointProcessLock"] = <_cyb_intptr_t>__cuCheckpointProcessLock global __cuCheckpointProcessCheckpoint - data["__cuCheckpointProcessCheckpoint"] = __cuCheckpointProcessCheckpoint + data["__cuCheckpointProcessCheckpoint"] = <_cyb_intptr_t>__cuCheckpointProcessCheckpoint global __cuCheckpointProcessRestore - data["__cuCheckpointProcessRestore"] = __cuCheckpointProcessRestore + data["__cuCheckpointProcessRestore"] = <_cyb_intptr_t>__cuCheckpointProcessRestore global __cuCheckpointProcessUnlock - data["__cuCheckpointProcessUnlock"] = __cuCheckpointProcessUnlock + data["__cuCheckpointProcessUnlock"] = <_cyb_intptr_t>__cuCheckpointProcessUnlock global __cuGraphicsEGLRegisterImage - data["__cuGraphicsEGLRegisterImage"] = __cuGraphicsEGLRegisterImage + data["__cuGraphicsEGLRegisterImage"] = <_cyb_intptr_t>__cuGraphicsEGLRegisterImage global __cuEGLStreamConsumerConnect - data["__cuEGLStreamConsumerConnect"] = __cuEGLStreamConsumerConnect + data["__cuEGLStreamConsumerConnect"] = <_cyb_intptr_t>__cuEGLStreamConsumerConnect global __cuEGLStreamConsumerConnectWithFlags - data["__cuEGLStreamConsumerConnectWithFlags"] = __cuEGLStreamConsumerConnectWithFlags + data["__cuEGLStreamConsumerConnectWithFlags"] = <_cyb_intptr_t>__cuEGLStreamConsumerConnectWithFlags global __cuEGLStreamConsumerDisconnect - data["__cuEGLStreamConsumerDisconnect"] = __cuEGLStreamConsumerDisconnect + data["__cuEGLStreamConsumerDisconnect"] = <_cyb_intptr_t>__cuEGLStreamConsumerDisconnect global __cuEGLStreamConsumerAcquireFrame - data["__cuEGLStreamConsumerAcquireFrame"] = __cuEGLStreamConsumerAcquireFrame + data["__cuEGLStreamConsumerAcquireFrame"] = <_cyb_intptr_t>__cuEGLStreamConsumerAcquireFrame global __cuEGLStreamConsumerReleaseFrame - data["__cuEGLStreamConsumerReleaseFrame"] = __cuEGLStreamConsumerReleaseFrame + data["__cuEGLStreamConsumerReleaseFrame"] = <_cyb_intptr_t>__cuEGLStreamConsumerReleaseFrame global __cuEGLStreamProducerConnect - data["__cuEGLStreamProducerConnect"] = __cuEGLStreamProducerConnect + data["__cuEGLStreamProducerConnect"] = <_cyb_intptr_t>__cuEGLStreamProducerConnect global __cuEGLStreamProducerDisconnect - data["__cuEGLStreamProducerDisconnect"] = __cuEGLStreamProducerDisconnect + data["__cuEGLStreamProducerDisconnect"] = <_cyb_intptr_t>__cuEGLStreamProducerDisconnect global __cuEGLStreamProducerPresentFrame - data["__cuEGLStreamProducerPresentFrame"] = __cuEGLStreamProducerPresentFrame + data["__cuEGLStreamProducerPresentFrame"] = <_cyb_intptr_t>__cuEGLStreamProducerPresentFrame global __cuEGLStreamProducerReturnFrame - data["__cuEGLStreamProducerReturnFrame"] = __cuEGLStreamProducerReturnFrame + data["__cuEGLStreamProducerReturnFrame"] = <_cyb_intptr_t>__cuEGLStreamProducerReturnFrame global __cuGraphicsResourceGetMappedEglFrame - data["__cuGraphicsResourceGetMappedEglFrame"] = __cuGraphicsResourceGetMappedEglFrame + data["__cuGraphicsResourceGetMappedEglFrame"] = <_cyb_intptr_t>__cuGraphicsResourceGetMappedEglFrame global __cuEventCreateFromEGLSync - data["__cuEventCreateFromEGLSync"] = __cuEventCreateFromEGLSync + data["__cuEventCreateFromEGLSync"] = <_cyb_intptr_t>__cuEventCreateFromEGLSync global __cuGraphicsGLRegisterBuffer - data["__cuGraphicsGLRegisterBuffer"] = __cuGraphicsGLRegisterBuffer + data["__cuGraphicsGLRegisterBuffer"] = <_cyb_intptr_t>__cuGraphicsGLRegisterBuffer global __cuGraphicsGLRegisterImage - data["__cuGraphicsGLRegisterImage"] = __cuGraphicsGLRegisterImage + data["__cuGraphicsGLRegisterImage"] = <_cyb_intptr_t>__cuGraphicsGLRegisterImage global __cuGLGetDevices_v2 - data["__cuGLGetDevices_v2"] = __cuGLGetDevices_v2 + data["__cuGLGetDevices_v2"] = <_cyb_intptr_t>__cuGLGetDevices_v2 global __cuGLCtxCreate_v2 - data["__cuGLCtxCreate_v2"] = __cuGLCtxCreate_v2 + data["__cuGLCtxCreate_v2"] = <_cyb_intptr_t>__cuGLCtxCreate_v2 global __cuGLInit - data["__cuGLInit"] = __cuGLInit + data["__cuGLInit"] = <_cyb_intptr_t>__cuGLInit global __cuGLRegisterBufferObject - data["__cuGLRegisterBufferObject"] = __cuGLRegisterBufferObject + data["__cuGLRegisterBufferObject"] = <_cyb_intptr_t>__cuGLRegisterBufferObject global __cuGLMapBufferObject_v2 - data["__cuGLMapBufferObject_v2"] = __cuGLMapBufferObject_v2 + data["__cuGLMapBufferObject_v2"] = <_cyb_intptr_t>__cuGLMapBufferObject_v2 global __cuGLUnmapBufferObject - data["__cuGLUnmapBufferObject"] = __cuGLUnmapBufferObject + data["__cuGLUnmapBufferObject"] = <_cyb_intptr_t>__cuGLUnmapBufferObject global __cuGLUnregisterBufferObject - data["__cuGLUnregisterBufferObject"] = __cuGLUnregisterBufferObject + data["__cuGLUnregisterBufferObject"] = <_cyb_intptr_t>__cuGLUnregisterBufferObject global __cuGLSetBufferObjectMapFlags - data["__cuGLSetBufferObjectMapFlags"] = __cuGLSetBufferObjectMapFlags + data["__cuGLSetBufferObjectMapFlags"] = <_cyb_intptr_t>__cuGLSetBufferObjectMapFlags global __cuGLMapBufferObjectAsync_v2 - data["__cuGLMapBufferObjectAsync_v2"] = __cuGLMapBufferObjectAsync_v2 + data["__cuGLMapBufferObjectAsync_v2"] = <_cyb_intptr_t>__cuGLMapBufferObjectAsync_v2 global __cuGLUnmapBufferObjectAsync - data["__cuGLUnmapBufferObjectAsync"] = __cuGLUnmapBufferObjectAsync + data["__cuGLUnmapBufferObjectAsync"] = <_cyb_intptr_t>__cuGLUnmapBufferObjectAsync global __cuProfilerInitialize - data["__cuProfilerInitialize"] = __cuProfilerInitialize + data["__cuProfilerInitialize"] = <_cyb_intptr_t>__cuProfilerInitialize global __cuProfilerStart - data["__cuProfilerStart"] = __cuProfilerStart + data["__cuProfilerStart"] = <_cyb_intptr_t>__cuProfilerStart global __cuProfilerStop - data["__cuProfilerStop"] = __cuProfilerStop + data["__cuProfilerStop"] = <_cyb_intptr_t>__cuProfilerStop global __cuVDPAUGetDevice - data["__cuVDPAUGetDevice"] = __cuVDPAUGetDevice + data["__cuVDPAUGetDevice"] = <_cyb_intptr_t>__cuVDPAUGetDevice global __cuVDPAUCtxCreate_v2 - data["__cuVDPAUCtxCreate_v2"] = __cuVDPAUCtxCreate_v2 + data["__cuVDPAUCtxCreate_v2"] = <_cyb_intptr_t>__cuVDPAUCtxCreate_v2 global __cuGraphicsVDPAURegisterVideoSurface - data["__cuGraphicsVDPAURegisterVideoSurface"] = __cuGraphicsVDPAURegisterVideoSurface + data["__cuGraphicsVDPAURegisterVideoSurface"] = <_cyb_intptr_t>__cuGraphicsVDPAURegisterVideoSurface global __cuGraphicsVDPAURegisterOutputSurface - data["__cuGraphicsVDPAURegisterOutputSurface"] = __cuGraphicsVDPAURegisterOutputSurface + data["__cuGraphicsVDPAURegisterOutputSurface"] = <_cyb_intptr_t>__cuGraphicsVDPAURegisterOutputSurface global __cuDeviceGetHostAtomicCapabilities - data["__cuDeviceGetHostAtomicCapabilities"] = __cuDeviceGetHostAtomicCapabilities + data["__cuDeviceGetHostAtomicCapabilities"] = <_cyb_intptr_t>__cuDeviceGetHostAtomicCapabilities global __cuCtxGetDevice_v2 - data["__cuCtxGetDevice_v2"] = __cuCtxGetDevice_v2 + data["__cuCtxGetDevice_v2"] = <_cyb_intptr_t>__cuCtxGetDevice_v2 global __cuCtxSynchronize_v2 - data["__cuCtxSynchronize_v2"] = __cuCtxSynchronize_v2 + data["__cuCtxSynchronize_v2"] = <_cyb_intptr_t>__cuCtxSynchronize_v2 global __cuMemcpyBatchAsync_v2 - data["__cuMemcpyBatchAsync_v2"] = __cuMemcpyBatchAsync_v2 + data["__cuMemcpyBatchAsync_v2"] = <_cyb_intptr_t>__cuMemcpyBatchAsync_v2 global __cuMemcpy3DBatchAsync_v2 - data["__cuMemcpy3DBatchAsync_v2"] = __cuMemcpy3DBatchAsync_v2 + data["__cuMemcpy3DBatchAsync_v2"] = <_cyb_intptr_t>__cuMemcpy3DBatchAsync_v2 global __cuMemGetDefaultMemPool - data["__cuMemGetDefaultMemPool"] = __cuMemGetDefaultMemPool + data["__cuMemGetDefaultMemPool"] = <_cyb_intptr_t>__cuMemGetDefaultMemPool global __cuMemGetMemPool - data["__cuMemGetMemPool"] = __cuMemGetMemPool + data["__cuMemGetMemPool"] = <_cyb_intptr_t>__cuMemGetMemPool global __cuMemSetMemPool - data["__cuMemSetMemPool"] = __cuMemSetMemPool + data["__cuMemSetMemPool"] = <_cyb_intptr_t>__cuMemSetMemPool global __cuMemPrefetchBatchAsync - data["__cuMemPrefetchBatchAsync"] = __cuMemPrefetchBatchAsync + data["__cuMemPrefetchBatchAsync"] = <_cyb_intptr_t>__cuMemPrefetchBatchAsync global __cuMemDiscardBatchAsync - data["__cuMemDiscardBatchAsync"] = __cuMemDiscardBatchAsync + data["__cuMemDiscardBatchAsync"] = <_cyb_intptr_t>__cuMemDiscardBatchAsync global __cuMemDiscardAndPrefetchBatchAsync - data["__cuMemDiscardAndPrefetchBatchAsync"] = __cuMemDiscardAndPrefetchBatchAsync + data["__cuMemDiscardAndPrefetchBatchAsync"] = <_cyb_intptr_t>__cuMemDiscardAndPrefetchBatchAsync global __cuDeviceGetP2PAtomicCapabilities - data["__cuDeviceGetP2PAtomicCapabilities"] = __cuDeviceGetP2PAtomicCapabilities + data["__cuDeviceGetP2PAtomicCapabilities"] = <_cyb_intptr_t>__cuDeviceGetP2PAtomicCapabilities global __cuGreenCtxGetId - data["__cuGreenCtxGetId"] = __cuGreenCtxGetId + data["__cuGreenCtxGetId"] = <_cyb_intptr_t>__cuGreenCtxGetId global __cuMulticastBindMem_v2 - data["__cuMulticastBindMem_v2"] = __cuMulticastBindMem_v2 + data["__cuMulticastBindMem_v2"] = <_cyb_intptr_t>__cuMulticastBindMem_v2 global __cuMulticastBindAddr_v2 - data["__cuMulticastBindAddr_v2"] = __cuMulticastBindAddr_v2 + data["__cuMulticastBindAddr_v2"] = <_cyb_intptr_t>__cuMulticastBindAddr_v2 global __cuGraphNodeGetContainingGraph - data["__cuGraphNodeGetContainingGraph"] = __cuGraphNodeGetContainingGraph + data["__cuGraphNodeGetContainingGraph"] = <_cyb_intptr_t>__cuGraphNodeGetContainingGraph global __cuGraphNodeGetLocalId - data["__cuGraphNodeGetLocalId"] = __cuGraphNodeGetLocalId + data["__cuGraphNodeGetLocalId"] = <_cyb_intptr_t>__cuGraphNodeGetLocalId global __cuGraphNodeGetToolsId - data["__cuGraphNodeGetToolsId"] = __cuGraphNodeGetToolsId + data["__cuGraphNodeGetToolsId"] = <_cyb_intptr_t>__cuGraphNodeGetToolsId global __cuGraphGetId - data["__cuGraphGetId"] = __cuGraphGetId + data["__cuGraphGetId"] = <_cyb_intptr_t>__cuGraphGetId global __cuGraphExecGetId - data["__cuGraphExecGetId"] = __cuGraphExecGetId + data["__cuGraphExecGetId"] = <_cyb_intptr_t>__cuGraphExecGetId global __cuDevSmResourceSplit - data["__cuDevSmResourceSplit"] = __cuDevSmResourceSplit + data["__cuDevSmResourceSplit"] = <_cyb_intptr_t>__cuDevSmResourceSplit global __cuStreamGetDevResource - data["__cuStreamGetDevResource"] = __cuStreamGetDevResource + data["__cuStreamGetDevResource"] = <_cyb_intptr_t>__cuStreamGetDevResource global __cuKernelGetParamCount - data["__cuKernelGetParamCount"] = __cuKernelGetParamCount + data["__cuKernelGetParamCount"] = <_cyb_intptr_t>__cuKernelGetParamCount global __cuMemcpyWithAttributesAsync - data["__cuMemcpyWithAttributesAsync"] = __cuMemcpyWithAttributesAsync + data["__cuMemcpyWithAttributesAsync"] = <_cyb_intptr_t>__cuMemcpyWithAttributesAsync global __cuMemcpy3DWithAttributesAsync - data["__cuMemcpy3DWithAttributesAsync"] = __cuMemcpy3DWithAttributesAsync + data["__cuMemcpy3DWithAttributesAsync"] = <_cyb_intptr_t>__cuMemcpy3DWithAttributesAsync global __cuStreamBeginCaptureToCig - data["__cuStreamBeginCaptureToCig"] = __cuStreamBeginCaptureToCig + data["__cuStreamBeginCaptureToCig"] = <_cyb_intptr_t>__cuStreamBeginCaptureToCig global __cuStreamEndCaptureToCig - data["__cuStreamEndCaptureToCig"] = __cuStreamEndCaptureToCig + data["__cuStreamEndCaptureToCig"] = <_cyb_intptr_t>__cuStreamEndCaptureToCig global __cuFuncGetParamCount - data["__cuFuncGetParamCount"] = __cuFuncGetParamCount + data["__cuFuncGetParamCount"] = <_cyb_intptr_t>__cuFuncGetParamCount global __cuLaunchHostFunc_v2 - data["__cuLaunchHostFunc_v2"] = __cuLaunchHostFunc_v2 + data["__cuLaunchHostFunc_v2"] = <_cyb_intptr_t>__cuLaunchHostFunc_v2 global __cuGraphNodeGetParams - data["__cuGraphNodeGetParams"] = __cuGraphNodeGetParams + data["__cuGraphNodeGetParams"] = <_cyb_intptr_t>__cuGraphNodeGetParams global __cuCoredumpRegisterStartCallback - data["__cuCoredumpRegisterStartCallback"] = __cuCoredumpRegisterStartCallback + data["__cuCoredumpRegisterStartCallback"] = <_cyb_intptr_t>__cuCoredumpRegisterStartCallback global __cuCoredumpRegisterCompleteCallback - data["__cuCoredumpRegisterCompleteCallback"] = __cuCoredumpRegisterCompleteCallback + data["__cuCoredumpRegisterCompleteCallback"] = <_cyb_intptr_t>__cuCoredumpRegisterCompleteCallback global __cuCoredumpDeregisterStartCallback - data["__cuCoredumpDeregisterStartCallback"] = __cuCoredumpDeregisterStartCallback + data["__cuCoredumpDeregisterStartCallback"] = <_cyb_intptr_t>__cuCoredumpDeregisterStartCallback global __cuCoredumpDeregisterCompleteCallback - data["__cuCoredumpDeregisterCompleteCallback"] = __cuCoredumpDeregisterCompleteCallback + data["__cuCoredumpDeregisterCompleteCallback"] = <_cyb_intptr_t>__cuCoredumpDeregisterCompleteCallback global __cuLogicalEndpointIdReserve - data["__cuLogicalEndpointIdReserve"] = __cuLogicalEndpointIdReserve + data["__cuLogicalEndpointIdReserve"] = <_cyb_intptr_t>__cuLogicalEndpointIdReserve global __cuLogicalEndpointIdRelease - data["__cuLogicalEndpointIdRelease"] = __cuLogicalEndpointIdRelease + data["__cuLogicalEndpointIdRelease"] = <_cyb_intptr_t>__cuLogicalEndpointIdRelease global __cuLogicalEndpointCreate - data["__cuLogicalEndpointCreate"] = __cuLogicalEndpointCreate + data["__cuLogicalEndpointCreate"] = <_cyb_intptr_t>__cuLogicalEndpointCreate global __cuLogicalEndpointAddDevice - data["__cuLogicalEndpointAddDevice"] = __cuLogicalEndpointAddDevice + data["__cuLogicalEndpointAddDevice"] = <_cyb_intptr_t>__cuLogicalEndpointAddDevice global __cuLogicalEndpointDestroy - data["__cuLogicalEndpointDestroy"] = __cuLogicalEndpointDestroy + data["__cuLogicalEndpointDestroy"] = <_cyb_intptr_t>__cuLogicalEndpointDestroy global __cuLogicalEndpointBindAddr - data["__cuLogicalEndpointBindAddr"] = __cuLogicalEndpointBindAddr + data["__cuLogicalEndpointBindAddr"] = <_cyb_intptr_t>__cuLogicalEndpointBindAddr global __cuLogicalEndpointBindMem - data["__cuLogicalEndpointBindMem"] = __cuLogicalEndpointBindMem + data["__cuLogicalEndpointBindMem"] = <_cyb_intptr_t>__cuLogicalEndpointBindMem global __cuLogicalEndpointUnbind - data["__cuLogicalEndpointUnbind"] = __cuLogicalEndpointUnbind + data["__cuLogicalEndpointUnbind"] = <_cyb_intptr_t>__cuLogicalEndpointUnbind global __cuLogicalEndpointExport - data["__cuLogicalEndpointExport"] = __cuLogicalEndpointExport + data["__cuLogicalEndpointExport"] = <_cyb_intptr_t>__cuLogicalEndpointExport global __cuLogicalEndpointImport - data["__cuLogicalEndpointImport"] = __cuLogicalEndpointImport + data["__cuLogicalEndpointImport"] = <_cyb_intptr_t>__cuLogicalEndpointImport global __cuLogicalEndpointGetLimits - data["__cuLogicalEndpointGetLimits"] = __cuLogicalEndpointGetLimits + data["__cuLogicalEndpointGetLimits"] = <_cyb_intptr_t>__cuLogicalEndpointGetLimits global __cuLogicalEndpointQuery - data["__cuLogicalEndpointQuery"] = __cuLogicalEndpointQuery + data["__cuLogicalEndpointQuery"] = <_cyb_intptr_t>__cuLogicalEndpointQuery global __cuStreamBeginRecaptureToGraph - data["__cuStreamBeginRecaptureToGraph"] = __cuStreamBeginRecaptureToGraph - - func_ptrs = data + data["__cuStreamBeginRecaptureToGraph"] = <_cyb_intptr_t>__cuStreamBeginRecaptureToGraph + _cyb_func_ptrs = data return data cpdef _inspect_function_pointer(str name): - global func_ptrs - if func_ptrs is None: - func_ptrs = _inspect_function_pointers() - return func_ptrs[name] + global _cyb_func_ptrs + if _cyb_func_ptrs is None: + _cyb_func_ptrs = _inspect_function_pointers() + return _cyb_func_ptrs[name] + + + + +cdef void* load_library() except* with gil: + cdef uintptr_t handle = load_nvidia_dynamic_lib("cuda")._handle_uint + return handle ############################################################################### diff --git a/cuda_bindings/cuda/bindings/_internal/driver_windows.pyx b/cuda_bindings/cuda/bindings/_internal/driver_windows.pyx index 96c7545dd11..4cc1ab3e1c5 100644 --- a/cuda_bindings/cuda/bindings/_internal/driver_windows.pyx +++ b/cuda_bindings/cuda/bindings/_internal/driver_windows.pyx @@ -3,81 +3,38 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.9.0 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=501497a3d88840c62eda1dfb0b72fe7494ff20a208230b1f45ad2f0c11bf47a5 -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=51232c67845ad8bb70e4d63f8f48ed1246b27d371b929f229fa09c27b23235c8 -from libc.stdint cimport intptr_t -import os -import threading -from .utils import FunctionNotFoundError, NotSupportedError +# <<<< PREAMBLE CONTENT >>>> -from cuda.pathfinder import load_nvidia_dynamic_lib +cdef extern from "": + ctypedef void* HMODULE + void* _cyb_GetProcAddress "GetProcAddress"(HMODULE, const char*) nogil -from libc.stddef cimport wchar_t -from libc.stdint cimport uintptr_t -from cpython cimport PyUnicode_AsWideCharString, PyMem_Free +from libc.stdint cimport intptr_t as _cyb_intptr_t -# You must 'from .utils import NotSupportedError' before using this template +from os import getenv as _cyb_getenv +import threading as _cyb_threading -cdef extern from "windows.h" nogil: - ctypedef void* HMODULE - ctypedef void* HANDLE - ctypedef void* FARPROC - ctypedef unsigned long DWORD - ctypedef const wchar_t *LPCWSTR - ctypedef const char *LPCSTR - - cdef DWORD LOAD_LIBRARY_SEARCH_SYSTEM32 = 0x00000800 - cdef DWORD LOAD_LIBRARY_SEARCH_DEFAULT_DIRS = 0x00001000 - cdef DWORD LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR = 0x00000100 - - HMODULE _LoadLibraryExW "LoadLibraryExW"( - LPCWSTR lpLibFileName, - HANDLE hFile, - DWORD dwFlags - ) - - FARPROC _GetProcAddress "GetProcAddress"(HMODULE hModule, LPCSTR lpProcName) - -cdef inline uintptr_t LoadLibraryExW(str path, HANDLE hFile, DWORD dwFlags): - cdef uintptr_t result - cdef wchar_t* wpath = PyUnicode_AsWideCharString(path, NULL) - with nogil: - result = _LoadLibraryExW( - wpath, - hFile, - dwFlags - ) - PyMem_Free(wpath) - return result - -cdef inline void *GetProcAddress(uintptr_t hModule, const char* lpProcName) nogil: - return _GetProcAddress(hModule, lpProcName) +ctypedef int (*_cyb_cuGetProcAddress_v2_T)(const char *, void **, int, cuuint64_t, CUdriverProcAddressQueryResult *)except?CUDA_ERROR_NOT_FOUND nogil -cdef int get_cuda_version(): - cdef int err, driver_ver = 0 +cdef bint _cyb___py_driver_init = False +cdef dict _cyb_func_ptrs = None +cdef object _cyb_symbol_lock = _cyb_threading.Lock() - # Load driver to check version - handle = LoadLibraryExW("nvcuda.dll", NULL, LOAD_LIBRARY_SEARCH_SYSTEM32) - if handle == 0: - raise NotSupportedError('CUDA driver is not found') - cuDriverGetVersion = GetProcAddress(handle, 'cuDriverGetVersion') - if cuDriverGetVersion == NULL: - raise RuntimeError('Did not find cuDriverGetVersion symbol in nvcuda.dll') - err = (cuDriverGetVersion)(&driver_ver) - if err != 0: - raise RuntimeError(f'cuDriverGetVersion returned error code {err}') +# <<<< END OF PREAMBLE CONTENT >>>> - return driver_ver +from libc.stdint cimport uintptr_t +from .utils import FunctionNotFoundError, NotSupportedError +from cuda.pathfinder import load_nvidia_dynamic_lib ############################################################################### # Wrapper init ############################################################################### -cdef object __symbol_lock = threading.Lock() -cdef bint __py_driver_init = False cdef void* __cuGetErrorString = NULL cdef void* __cuGetErrorName = NULL @@ -597,3177 +554,3161 @@ cdef void* __cuLogicalEndpointGetLimits = NULL cdef void* __cuLogicalEndpointQuery = NULL cdef void* __cuStreamBeginRecaptureToGraph = NULL - -cdef uintptr_t load_library() except* with gil: - cdef uintptr_t handle = load_nvidia_dynamic_lib("cuda")._handle_uint - return handle - - -ctypedef CUresult (*__cuGetProcAddress_v2_T)(const char*, void**, int, cuuint64_t, CUdriverProcAddressQueryResult*) except?CUDA_ERROR_NOT_FOUND nogil -cdef __cuGetProcAddress_v2_T _F_cuGetProcAddress_v2 = NULL - - cdef int _init_driver() except -1 nogil: - global __py_driver_init - + global _cyb___py_driver_init cdef uintptr_t handle = 0 cdef int ptds_mode + cdef _cyb_cuGetProcAddress_v2_T cuGetProcAddress_v2 + with gil, _cyb_symbol_lock: + if _cyb___py_driver_init: return 0 - with gil, __symbol_lock: - # Recheck the flag after obtaining the locks - if __py_driver_init: - return 0 - - # Load library handle = load_library() if handle == 0: raise RuntimeError('Failed to open cuda') - # Get latest __cuGetProcAddress_v2 - global __cuGetProcAddress_v2 - __cuGetProcAddress_v2 = GetProcAddress(handle, 'cuGetProcAddress_v2') - if __cuGetProcAddress_v2 == NULL: - raise RuntimeError("Failed to get __cuGetProcAddress_v2") - _F_cuGetProcAddress_v2 = <__cuGetProcAddress_v2_T>__cuGetProcAddress_v2 - - if bool(int(os.getenv('CUDA_PYTHON_CUDA_PER_THREAD_DEFAULT_STREAM', default=0))): + cuGetProcAddress_v2 = <_cyb_cuGetProcAddress_v2_T>_cyb_GetProcAddress( + handle, 'cuGetProcAddress_v2' + ) + if cuGetProcAddress_v2 == NULL: + raise RuntimeError("Failed to get cuGetProcAddress_v2") + if bool(int(_cyb_getenv('CUDA_PYTHON_CUDA_PER_THREAD_DEFAULT_STREAM', default=0))): ptds_mode = CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else: ptds_mode = CU_GET_PROC_ADDRESS_DEFAULT - - # Load function global __cuGetErrorString - _F_cuGetProcAddress_v2('cuGetErrorString', &__cuGetErrorString, 6000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGetErrorString', &__cuGetErrorString, 6000, ptds_mode, NULL) global __cuGetErrorName - _F_cuGetProcAddress_v2('cuGetErrorName', &__cuGetErrorName, 6000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGetErrorName', &__cuGetErrorName, 6000, ptds_mode, NULL) global __cuInit - _F_cuGetProcAddress_v2('cuInit', &__cuInit, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuInit', &__cuInit, 2000, ptds_mode, NULL) global __cuDriverGetVersion - _F_cuGetProcAddress_v2('cuDriverGetVersion', &__cuDriverGetVersion, 2020, ptds_mode, NULL) + cuGetProcAddress_v2('cuDriverGetVersion', &__cuDriverGetVersion, 2020, ptds_mode, NULL) global __cuDeviceGet - _F_cuGetProcAddress_v2('cuDeviceGet', &__cuDeviceGet, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceGet', &__cuDeviceGet, 2000, ptds_mode, NULL) global __cuDeviceGetCount - _F_cuGetProcAddress_v2('cuDeviceGetCount', &__cuDeviceGetCount, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceGetCount', &__cuDeviceGetCount, 2000, ptds_mode, NULL) global __cuDeviceGetName - _F_cuGetProcAddress_v2('cuDeviceGetName', &__cuDeviceGetName, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceGetName', &__cuDeviceGetName, 2000, ptds_mode, NULL) global __cuDeviceGetUuid_v2 - _F_cuGetProcAddress_v2('cuDeviceGetUuid', &__cuDeviceGetUuid_v2, 11040, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceGetUuid', &__cuDeviceGetUuid_v2, 11040, ptds_mode, NULL) global __cuDeviceGetLuid - _F_cuGetProcAddress_v2('cuDeviceGetLuid', &__cuDeviceGetLuid, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceGetLuid', &__cuDeviceGetLuid, 10000, ptds_mode, NULL) global __cuDeviceTotalMem_v2 - _F_cuGetProcAddress_v2('cuDeviceTotalMem', &__cuDeviceTotalMem_v2, 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceTotalMem', &__cuDeviceTotalMem_v2, 3020, ptds_mode, NULL) global __cuDeviceGetTexture1DLinearMaxWidth - _F_cuGetProcAddress_v2('cuDeviceGetTexture1DLinearMaxWidth', &__cuDeviceGetTexture1DLinearMaxWidth, 11010, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceGetTexture1DLinearMaxWidth', &__cuDeviceGetTexture1DLinearMaxWidth, 11010, ptds_mode, NULL) global __cuDeviceGetAttribute - _F_cuGetProcAddress_v2('cuDeviceGetAttribute', &__cuDeviceGetAttribute, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceGetAttribute', &__cuDeviceGetAttribute, 2000, ptds_mode, NULL) global __cuDeviceGetNvSciSyncAttributes - _F_cuGetProcAddress_v2('cuDeviceGetNvSciSyncAttributes', &__cuDeviceGetNvSciSyncAttributes, 10020, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceGetNvSciSyncAttributes', &__cuDeviceGetNvSciSyncAttributes, 10020, ptds_mode, NULL) global __cuDeviceSetMemPool - _F_cuGetProcAddress_v2('cuDeviceSetMemPool', &__cuDeviceSetMemPool, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceSetMemPool', &__cuDeviceSetMemPool, 11020, ptds_mode, NULL) global __cuDeviceGetMemPool - _F_cuGetProcAddress_v2('cuDeviceGetMemPool', &__cuDeviceGetMemPool, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceGetMemPool', &__cuDeviceGetMemPool, 11020, ptds_mode, NULL) global __cuDeviceGetDefaultMemPool - _F_cuGetProcAddress_v2('cuDeviceGetDefaultMemPool', &__cuDeviceGetDefaultMemPool, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceGetDefaultMemPool', &__cuDeviceGetDefaultMemPool, 11020, ptds_mode, NULL) global __cuDeviceGetExecAffinitySupport - _F_cuGetProcAddress_v2('cuDeviceGetExecAffinitySupport', &__cuDeviceGetExecAffinitySupport, 11040, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceGetExecAffinitySupport', &__cuDeviceGetExecAffinitySupport, 11040, ptds_mode, NULL) global __cuFlushGPUDirectRDMAWrites - _F_cuGetProcAddress_v2('cuFlushGPUDirectRDMAWrites', &__cuFlushGPUDirectRDMAWrites, 11030, ptds_mode, NULL) + cuGetProcAddress_v2('cuFlushGPUDirectRDMAWrites', &__cuFlushGPUDirectRDMAWrites, 11030, ptds_mode, NULL) global __cuDeviceGetProperties - _F_cuGetProcAddress_v2('cuDeviceGetProperties', &__cuDeviceGetProperties, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceGetProperties', &__cuDeviceGetProperties, 2000, ptds_mode, NULL) global __cuDeviceComputeCapability - _F_cuGetProcAddress_v2('cuDeviceComputeCapability', &__cuDeviceComputeCapability, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceComputeCapability', &__cuDeviceComputeCapability, 2000, ptds_mode, NULL) global __cuDevicePrimaryCtxRetain - _F_cuGetProcAddress_v2('cuDevicePrimaryCtxRetain', &__cuDevicePrimaryCtxRetain, 7000, ptds_mode, NULL) + cuGetProcAddress_v2('cuDevicePrimaryCtxRetain', &__cuDevicePrimaryCtxRetain, 7000, ptds_mode, NULL) global __cuDevicePrimaryCtxRelease_v2 - _F_cuGetProcAddress_v2('cuDevicePrimaryCtxRelease', &__cuDevicePrimaryCtxRelease_v2, 11000, ptds_mode, NULL) + cuGetProcAddress_v2('cuDevicePrimaryCtxRelease', &__cuDevicePrimaryCtxRelease_v2, 11000, ptds_mode, NULL) global __cuDevicePrimaryCtxSetFlags_v2 - _F_cuGetProcAddress_v2('cuDevicePrimaryCtxSetFlags', &__cuDevicePrimaryCtxSetFlags_v2, 11000, ptds_mode, NULL) + cuGetProcAddress_v2('cuDevicePrimaryCtxSetFlags', &__cuDevicePrimaryCtxSetFlags_v2, 11000, ptds_mode, NULL) global __cuDevicePrimaryCtxGetState - _F_cuGetProcAddress_v2('cuDevicePrimaryCtxGetState', &__cuDevicePrimaryCtxGetState, 7000, ptds_mode, NULL) + cuGetProcAddress_v2('cuDevicePrimaryCtxGetState', &__cuDevicePrimaryCtxGetState, 7000, ptds_mode, NULL) global __cuDevicePrimaryCtxReset_v2 - _F_cuGetProcAddress_v2('cuDevicePrimaryCtxReset', &__cuDevicePrimaryCtxReset_v2, 11000, ptds_mode, NULL) + cuGetProcAddress_v2('cuDevicePrimaryCtxReset', &__cuDevicePrimaryCtxReset_v2, 11000, ptds_mode, NULL) global __cuCtxCreate_v2 - _F_cuGetProcAddress_v2('cuCtxCreate', &__cuCtxCreate_v2, 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxCreate', &__cuCtxCreate_v2, 3020, ptds_mode, NULL) global __cuCtxCreate_v3 - _F_cuGetProcAddress_v2('cuCtxCreate', &__cuCtxCreate_v3, 11040, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxCreate', &__cuCtxCreate_v3, 11040, ptds_mode, NULL) global __cuCtxCreate_v4 - _F_cuGetProcAddress_v2('cuCtxCreate', &__cuCtxCreate_v4, 12050, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxCreate', &__cuCtxCreate_v4, 12050, ptds_mode, NULL) global __cuCtxDestroy_v2 - _F_cuGetProcAddress_v2('cuCtxDestroy', &__cuCtxDestroy_v2, 4000, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxDestroy', &__cuCtxDestroy_v2, 4000, ptds_mode, NULL) global __cuCtxPushCurrent_v2 - _F_cuGetProcAddress_v2('cuCtxPushCurrent', &__cuCtxPushCurrent_v2, 4000, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxPushCurrent', &__cuCtxPushCurrent_v2, 4000, ptds_mode, NULL) global __cuCtxPopCurrent_v2 - _F_cuGetProcAddress_v2('cuCtxPopCurrent', &__cuCtxPopCurrent_v2, 4000, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxPopCurrent', &__cuCtxPopCurrent_v2, 4000, ptds_mode, NULL) global __cuCtxSetCurrent - _F_cuGetProcAddress_v2('cuCtxSetCurrent', &__cuCtxSetCurrent, 4000, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxSetCurrent', &__cuCtxSetCurrent, 4000, ptds_mode, NULL) global __cuCtxGetCurrent - _F_cuGetProcAddress_v2('cuCtxGetCurrent', &__cuCtxGetCurrent, 4000, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxGetCurrent', &__cuCtxGetCurrent, 4000, ptds_mode, NULL) global __cuCtxGetDevice - _F_cuGetProcAddress_v2('cuCtxGetDevice', &__cuCtxGetDevice, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxGetDevice', &__cuCtxGetDevice, 2000, ptds_mode, NULL) global __cuCtxGetFlags - _F_cuGetProcAddress_v2('cuCtxGetFlags', &__cuCtxGetFlags, 7000, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxGetFlags', &__cuCtxGetFlags, 7000, ptds_mode, NULL) global __cuCtxSetFlags - _F_cuGetProcAddress_v2('cuCtxSetFlags', &__cuCtxSetFlags, 12010, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxSetFlags', &__cuCtxSetFlags, 12010, ptds_mode, NULL) global __cuCtxGetId - _F_cuGetProcAddress_v2('cuCtxGetId', &__cuCtxGetId, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxGetId', &__cuCtxGetId, 12000, ptds_mode, NULL) global __cuCtxSynchronize - _F_cuGetProcAddress_v2('cuCtxSynchronize', &__cuCtxSynchronize, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxSynchronize', &__cuCtxSynchronize, 2000, ptds_mode, NULL) global __cuCtxSetLimit - _F_cuGetProcAddress_v2('cuCtxSetLimit', &__cuCtxSetLimit, 3010, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxSetLimit', &__cuCtxSetLimit, 3010, ptds_mode, NULL) global __cuCtxGetLimit - _F_cuGetProcAddress_v2('cuCtxGetLimit', &__cuCtxGetLimit, 3010, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxGetLimit', &__cuCtxGetLimit, 3010, ptds_mode, NULL) global __cuCtxGetCacheConfig - _F_cuGetProcAddress_v2('cuCtxGetCacheConfig', &__cuCtxGetCacheConfig, 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxGetCacheConfig', &__cuCtxGetCacheConfig, 3020, ptds_mode, NULL) global __cuCtxSetCacheConfig - _F_cuGetProcAddress_v2('cuCtxSetCacheConfig', &__cuCtxSetCacheConfig, 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxSetCacheConfig', &__cuCtxSetCacheConfig, 3020, ptds_mode, NULL) global __cuCtxGetApiVersion - _F_cuGetProcAddress_v2('cuCtxGetApiVersion', &__cuCtxGetApiVersion, 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxGetApiVersion', &__cuCtxGetApiVersion, 3020, ptds_mode, NULL) global __cuCtxGetStreamPriorityRange - _F_cuGetProcAddress_v2('cuCtxGetStreamPriorityRange', &__cuCtxGetStreamPriorityRange, 5050, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxGetStreamPriorityRange', &__cuCtxGetStreamPriorityRange, 5050, ptds_mode, NULL) global __cuCtxResetPersistingL2Cache - _F_cuGetProcAddress_v2('cuCtxResetPersistingL2Cache', &__cuCtxResetPersistingL2Cache, 11000, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxResetPersistingL2Cache', &__cuCtxResetPersistingL2Cache, 11000, ptds_mode, NULL) global __cuCtxGetExecAffinity - _F_cuGetProcAddress_v2('cuCtxGetExecAffinity', &__cuCtxGetExecAffinity, 11040, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxGetExecAffinity', &__cuCtxGetExecAffinity, 11040, ptds_mode, NULL) global __cuCtxRecordEvent - _F_cuGetProcAddress_v2('cuCtxRecordEvent', &__cuCtxRecordEvent, 12050, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxRecordEvent', &__cuCtxRecordEvent, 12050, ptds_mode, NULL) global __cuCtxWaitEvent - _F_cuGetProcAddress_v2('cuCtxWaitEvent', &__cuCtxWaitEvent, 12050, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxWaitEvent', &__cuCtxWaitEvent, 12050, ptds_mode, NULL) global __cuCtxAttach - _F_cuGetProcAddress_v2('cuCtxAttach', &__cuCtxAttach, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxAttach', &__cuCtxAttach, 2000, ptds_mode, NULL) global __cuCtxDetach - _F_cuGetProcAddress_v2('cuCtxDetach', &__cuCtxDetach, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxDetach', &__cuCtxDetach, 2000, ptds_mode, NULL) global __cuCtxGetSharedMemConfig - _F_cuGetProcAddress_v2('cuCtxGetSharedMemConfig', &__cuCtxGetSharedMemConfig, 4020, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxGetSharedMemConfig', &__cuCtxGetSharedMemConfig, 4020, ptds_mode, NULL) global __cuCtxSetSharedMemConfig - _F_cuGetProcAddress_v2('cuCtxSetSharedMemConfig', &__cuCtxSetSharedMemConfig, 4020, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxSetSharedMemConfig', &__cuCtxSetSharedMemConfig, 4020, ptds_mode, NULL) global __cuModuleLoad - _F_cuGetProcAddress_v2('cuModuleLoad', &__cuModuleLoad, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuModuleLoad', &__cuModuleLoad, 2000, ptds_mode, NULL) global __cuModuleLoadData - _F_cuGetProcAddress_v2('cuModuleLoadData', &__cuModuleLoadData, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuModuleLoadData', &__cuModuleLoadData, 2000, ptds_mode, NULL) global __cuModuleLoadDataEx - _F_cuGetProcAddress_v2('cuModuleLoadDataEx', &__cuModuleLoadDataEx, 2010, ptds_mode, NULL) + cuGetProcAddress_v2('cuModuleLoadDataEx', &__cuModuleLoadDataEx, 2010, ptds_mode, NULL) global __cuModuleLoadFatBinary - _F_cuGetProcAddress_v2('cuModuleLoadFatBinary', &__cuModuleLoadFatBinary, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuModuleLoadFatBinary', &__cuModuleLoadFatBinary, 2000, ptds_mode, NULL) global __cuModuleUnload - _F_cuGetProcAddress_v2('cuModuleUnload', &__cuModuleUnload, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuModuleUnload', &__cuModuleUnload, 2000, ptds_mode, NULL) global __cuModuleGetLoadingMode - _F_cuGetProcAddress_v2('cuModuleGetLoadingMode', &__cuModuleGetLoadingMode, 11070, ptds_mode, NULL) + cuGetProcAddress_v2('cuModuleGetLoadingMode', &__cuModuleGetLoadingMode, 11070, ptds_mode, NULL) global __cuModuleGetFunction - _F_cuGetProcAddress_v2('cuModuleGetFunction', &__cuModuleGetFunction, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuModuleGetFunction', &__cuModuleGetFunction, 2000, ptds_mode, NULL) global __cuModuleGetFunctionCount - _F_cuGetProcAddress_v2('cuModuleGetFunctionCount', &__cuModuleGetFunctionCount, 12040, ptds_mode, NULL) + cuGetProcAddress_v2('cuModuleGetFunctionCount', &__cuModuleGetFunctionCount, 12040, ptds_mode, NULL) global __cuModuleEnumerateFunctions - _F_cuGetProcAddress_v2('cuModuleEnumerateFunctions', &__cuModuleEnumerateFunctions, 12040, ptds_mode, NULL) + cuGetProcAddress_v2('cuModuleEnumerateFunctions', &__cuModuleEnumerateFunctions, 12040, ptds_mode, NULL) global __cuModuleGetGlobal_v2 - _F_cuGetProcAddress_v2('cuModuleGetGlobal', &__cuModuleGetGlobal_v2, 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuModuleGetGlobal', &__cuModuleGetGlobal_v2, 3020, ptds_mode, NULL) global __cuLinkCreate_v2 - _F_cuGetProcAddress_v2('cuLinkCreate', &__cuLinkCreate_v2, 6050, ptds_mode, NULL) + cuGetProcAddress_v2('cuLinkCreate', &__cuLinkCreate_v2, 6050, ptds_mode, NULL) global __cuLinkAddData_v2 - _F_cuGetProcAddress_v2('cuLinkAddData', &__cuLinkAddData_v2, 6050, ptds_mode, NULL) + cuGetProcAddress_v2('cuLinkAddData', &__cuLinkAddData_v2, 6050, ptds_mode, NULL) global __cuLinkAddFile_v2 - _F_cuGetProcAddress_v2('cuLinkAddFile', &__cuLinkAddFile_v2, 6050, ptds_mode, NULL) + cuGetProcAddress_v2('cuLinkAddFile', &__cuLinkAddFile_v2, 6050, ptds_mode, NULL) global __cuLinkComplete - _F_cuGetProcAddress_v2('cuLinkComplete', &__cuLinkComplete, 5050, ptds_mode, NULL) + cuGetProcAddress_v2('cuLinkComplete', &__cuLinkComplete, 5050, ptds_mode, NULL) global __cuLinkDestroy - _F_cuGetProcAddress_v2('cuLinkDestroy', &__cuLinkDestroy, 5050, ptds_mode, NULL) + cuGetProcAddress_v2('cuLinkDestroy', &__cuLinkDestroy, 5050, ptds_mode, NULL) global __cuModuleGetTexRef - _F_cuGetProcAddress_v2('cuModuleGetTexRef', &__cuModuleGetTexRef, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuModuleGetTexRef', &__cuModuleGetTexRef, 2000, ptds_mode, NULL) global __cuModuleGetSurfRef - _F_cuGetProcAddress_v2('cuModuleGetSurfRef', &__cuModuleGetSurfRef, 3000, ptds_mode, NULL) + cuGetProcAddress_v2('cuModuleGetSurfRef', &__cuModuleGetSurfRef, 3000, ptds_mode, NULL) global __cuLibraryLoadData - _F_cuGetProcAddress_v2('cuLibraryLoadData', &__cuLibraryLoadData, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuLibraryLoadData', &__cuLibraryLoadData, 12000, ptds_mode, NULL) global __cuLibraryLoadFromFile - _F_cuGetProcAddress_v2('cuLibraryLoadFromFile', &__cuLibraryLoadFromFile, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuLibraryLoadFromFile', &__cuLibraryLoadFromFile, 12000, ptds_mode, NULL) global __cuLibraryUnload - _F_cuGetProcAddress_v2('cuLibraryUnload', &__cuLibraryUnload, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuLibraryUnload', &__cuLibraryUnload, 12000, ptds_mode, NULL) global __cuLibraryGetKernel - _F_cuGetProcAddress_v2('cuLibraryGetKernel', &__cuLibraryGetKernel, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuLibraryGetKernel', &__cuLibraryGetKernel, 12000, ptds_mode, NULL) global __cuLibraryGetKernelCount - _F_cuGetProcAddress_v2('cuLibraryGetKernelCount', &__cuLibraryGetKernelCount, 12040, ptds_mode, NULL) + cuGetProcAddress_v2('cuLibraryGetKernelCount', &__cuLibraryGetKernelCount, 12040, ptds_mode, NULL) global __cuLibraryEnumerateKernels - _F_cuGetProcAddress_v2('cuLibraryEnumerateKernels', &__cuLibraryEnumerateKernels, 12040, ptds_mode, NULL) + cuGetProcAddress_v2('cuLibraryEnumerateKernels', &__cuLibraryEnumerateKernels, 12040, ptds_mode, NULL) global __cuLibraryGetModule - _F_cuGetProcAddress_v2('cuLibraryGetModule', &__cuLibraryGetModule, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuLibraryGetModule', &__cuLibraryGetModule, 12000, ptds_mode, NULL) global __cuKernelGetFunction - _F_cuGetProcAddress_v2('cuKernelGetFunction', &__cuKernelGetFunction, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuKernelGetFunction', &__cuKernelGetFunction, 12000, ptds_mode, NULL) global __cuKernelGetLibrary - _F_cuGetProcAddress_v2('cuKernelGetLibrary', &__cuKernelGetLibrary, 12050, ptds_mode, NULL) + cuGetProcAddress_v2('cuKernelGetLibrary', &__cuKernelGetLibrary, 12050, ptds_mode, NULL) global __cuLibraryGetGlobal - _F_cuGetProcAddress_v2('cuLibraryGetGlobal', &__cuLibraryGetGlobal, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuLibraryGetGlobal', &__cuLibraryGetGlobal, 12000, ptds_mode, NULL) global __cuLibraryGetManaged - _F_cuGetProcAddress_v2('cuLibraryGetManaged', &__cuLibraryGetManaged, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuLibraryGetManaged', &__cuLibraryGetManaged, 12000, ptds_mode, NULL) global __cuLibraryGetUnifiedFunction - _F_cuGetProcAddress_v2('cuLibraryGetUnifiedFunction', &__cuLibraryGetUnifiedFunction, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuLibraryGetUnifiedFunction', &__cuLibraryGetUnifiedFunction, 12000, ptds_mode, NULL) global __cuKernelGetAttribute - _F_cuGetProcAddress_v2('cuKernelGetAttribute', &__cuKernelGetAttribute, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuKernelGetAttribute', &__cuKernelGetAttribute, 12000, ptds_mode, NULL) global __cuKernelSetAttribute - _F_cuGetProcAddress_v2('cuKernelSetAttribute', &__cuKernelSetAttribute, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuKernelSetAttribute', &__cuKernelSetAttribute, 12000, ptds_mode, NULL) global __cuKernelSetCacheConfig - _F_cuGetProcAddress_v2('cuKernelSetCacheConfig', &__cuKernelSetCacheConfig, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuKernelSetCacheConfig', &__cuKernelSetCacheConfig, 12000, ptds_mode, NULL) global __cuKernelGetName - _F_cuGetProcAddress_v2('cuKernelGetName', &__cuKernelGetName, 12030, ptds_mode, NULL) + cuGetProcAddress_v2('cuKernelGetName', &__cuKernelGetName, 12030, ptds_mode, NULL) global __cuKernelGetParamInfo - _F_cuGetProcAddress_v2('cuKernelGetParamInfo', &__cuKernelGetParamInfo, 12040, ptds_mode, NULL) + cuGetProcAddress_v2('cuKernelGetParamInfo', &__cuKernelGetParamInfo, 12040, ptds_mode, NULL) global __cuMemGetInfo_v2 - _F_cuGetProcAddress_v2('cuMemGetInfo', &__cuMemGetInfo_v2, 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemGetInfo', &__cuMemGetInfo_v2, 3020, ptds_mode, NULL) global __cuMemAlloc_v2 - _F_cuGetProcAddress_v2('cuMemAlloc', &__cuMemAlloc_v2, 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemAlloc', &__cuMemAlloc_v2, 3020, ptds_mode, NULL) global __cuMemAllocPitch_v2 - _F_cuGetProcAddress_v2('cuMemAllocPitch', &__cuMemAllocPitch_v2, 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemAllocPitch', &__cuMemAllocPitch_v2, 3020, ptds_mode, NULL) global __cuMemFree_v2 - _F_cuGetProcAddress_v2('cuMemFree', &__cuMemFree_v2, 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemFree', &__cuMemFree_v2, 3020, ptds_mode, NULL) global __cuMemGetAddressRange_v2 - _F_cuGetProcAddress_v2('cuMemGetAddressRange', &__cuMemGetAddressRange_v2, 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemGetAddressRange', &__cuMemGetAddressRange_v2, 3020, ptds_mode, NULL) global __cuMemAllocHost_v2 - _F_cuGetProcAddress_v2('cuMemAllocHost', &__cuMemAllocHost_v2, 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemAllocHost', &__cuMemAllocHost_v2, 3020, ptds_mode, NULL) global __cuMemFreeHost - _F_cuGetProcAddress_v2('cuMemFreeHost', &__cuMemFreeHost, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemFreeHost', &__cuMemFreeHost, 2000, ptds_mode, NULL) global __cuMemHostAlloc - _F_cuGetProcAddress_v2('cuMemHostAlloc', &__cuMemHostAlloc, 2020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemHostAlloc', &__cuMemHostAlloc, 2020, ptds_mode, NULL) global __cuMemHostGetDevicePointer_v2 - _F_cuGetProcAddress_v2('cuMemHostGetDevicePointer', &__cuMemHostGetDevicePointer_v2, 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemHostGetDevicePointer', &__cuMemHostGetDevicePointer_v2, 3020, ptds_mode, NULL) global __cuMemHostGetFlags - _F_cuGetProcAddress_v2('cuMemHostGetFlags', &__cuMemHostGetFlags, 2030, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemHostGetFlags', &__cuMemHostGetFlags, 2030, ptds_mode, NULL) global __cuMemAllocManaged - _F_cuGetProcAddress_v2('cuMemAllocManaged', &__cuMemAllocManaged, 6000, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemAllocManaged', &__cuMemAllocManaged, 6000, ptds_mode, NULL) global __cuDeviceRegisterAsyncNotification - _F_cuGetProcAddress_v2('cuDeviceRegisterAsyncNotification', &__cuDeviceRegisterAsyncNotification, 12040, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceRegisterAsyncNotification', &__cuDeviceRegisterAsyncNotification, 12040, ptds_mode, NULL) global __cuDeviceUnregisterAsyncNotification - _F_cuGetProcAddress_v2('cuDeviceUnregisterAsyncNotification', &__cuDeviceUnregisterAsyncNotification, 12040, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceUnregisterAsyncNotification', &__cuDeviceUnregisterAsyncNotification, 12040, ptds_mode, NULL) global __cuDeviceGetByPCIBusId - _F_cuGetProcAddress_v2('cuDeviceGetByPCIBusId', &__cuDeviceGetByPCIBusId, 4010, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceGetByPCIBusId', &__cuDeviceGetByPCIBusId, 4010, ptds_mode, NULL) global __cuDeviceGetPCIBusId - _F_cuGetProcAddress_v2('cuDeviceGetPCIBusId', &__cuDeviceGetPCIBusId, 4010, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceGetPCIBusId', &__cuDeviceGetPCIBusId, 4010, ptds_mode, NULL) global __cuIpcGetEventHandle - _F_cuGetProcAddress_v2('cuIpcGetEventHandle', &__cuIpcGetEventHandle, 4010, ptds_mode, NULL) + cuGetProcAddress_v2('cuIpcGetEventHandle', &__cuIpcGetEventHandle, 4010, ptds_mode, NULL) global __cuIpcOpenEventHandle - _F_cuGetProcAddress_v2('cuIpcOpenEventHandle', &__cuIpcOpenEventHandle, 4010, ptds_mode, NULL) + cuGetProcAddress_v2('cuIpcOpenEventHandle', &__cuIpcOpenEventHandle, 4010, ptds_mode, NULL) global __cuIpcGetMemHandle - _F_cuGetProcAddress_v2('cuIpcGetMemHandle', &__cuIpcGetMemHandle, 4010, ptds_mode, NULL) + cuGetProcAddress_v2('cuIpcGetMemHandle', &__cuIpcGetMemHandle, 4010, ptds_mode, NULL) global __cuIpcOpenMemHandle_v2 - _F_cuGetProcAddress_v2('cuIpcOpenMemHandle', &__cuIpcOpenMemHandle_v2, 11000, ptds_mode, NULL) + cuGetProcAddress_v2('cuIpcOpenMemHandle', &__cuIpcOpenMemHandle_v2, 11000, ptds_mode, NULL) global __cuIpcCloseMemHandle - _F_cuGetProcAddress_v2('cuIpcCloseMemHandle', &__cuIpcCloseMemHandle, 4010, ptds_mode, NULL) + cuGetProcAddress_v2('cuIpcCloseMemHandle', &__cuIpcCloseMemHandle, 4010, ptds_mode, NULL) global __cuMemHostRegister_v2 - _F_cuGetProcAddress_v2('cuMemHostRegister', &__cuMemHostRegister_v2, 6050, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemHostRegister', &__cuMemHostRegister_v2, 6050, ptds_mode, NULL) global __cuMemHostUnregister - _F_cuGetProcAddress_v2('cuMemHostUnregister', &__cuMemHostUnregister, 4000, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemHostUnregister', &__cuMemHostUnregister, 4000, ptds_mode, NULL) global __cuMemcpy - _F_cuGetProcAddress_v2('cuMemcpy', &__cuMemcpy, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 4000, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpy', &__cuMemcpy, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 4000, ptds_mode, NULL) global __cuMemcpyPeer - _F_cuGetProcAddress_v2('cuMemcpyPeer', &__cuMemcpyPeer, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 4000, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpyPeer', &__cuMemcpyPeer, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 4000, ptds_mode, NULL) global __cuMemcpyHtoD_v2 - _F_cuGetProcAddress_v2('cuMemcpyHtoD', &__cuMemcpyHtoD_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpyHtoD', &__cuMemcpyHtoD_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemcpyDtoH_v2 - _F_cuGetProcAddress_v2('cuMemcpyDtoH', &__cuMemcpyDtoH_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpyDtoH', &__cuMemcpyDtoH_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemcpyDtoD_v2 - _F_cuGetProcAddress_v2('cuMemcpyDtoD', &__cuMemcpyDtoD_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpyDtoD', &__cuMemcpyDtoD_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemcpyDtoA_v2 - _F_cuGetProcAddress_v2('cuMemcpyDtoA', &__cuMemcpyDtoA_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpyDtoA', &__cuMemcpyDtoA_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemcpyAtoD_v2 - _F_cuGetProcAddress_v2('cuMemcpyAtoD', &__cuMemcpyAtoD_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpyAtoD', &__cuMemcpyAtoD_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemcpyHtoA_v2 - _F_cuGetProcAddress_v2('cuMemcpyHtoA', &__cuMemcpyHtoA_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpyHtoA', &__cuMemcpyHtoA_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemcpyAtoH_v2 - _F_cuGetProcAddress_v2('cuMemcpyAtoH', &__cuMemcpyAtoH_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpyAtoH', &__cuMemcpyAtoH_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemcpyAtoA_v2 - _F_cuGetProcAddress_v2('cuMemcpyAtoA', &__cuMemcpyAtoA_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpyAtoA', &__cuMemcpyAtoA_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemcpy2D_v2 - _F_cuGetProcAddress_v2('cuMemcpy2D', &__cuMemcpy2D_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpy2D', &__cuMemcpy2D_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemcpy2DUnaligned_v2 - _F_cuGetProcAddress_v2('cuMemcpy2DUnaligned', &__cuMemcpy2DUnaligned_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpy2DUnaligned', &__cuMemcpy2DUnaligned_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemcpy3D_v2 - _F_cuGetProcAddress_v2('cuMemcpy3D', &__cuMemcpy3D_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpy3D', &__cuMemcpy3D_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemcpy3DPeer - _F_cuGetProcAddress_v2('cuMemcpy3DPeer', &__cuMemcpy3DPeer, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 4000, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpy3DPeer', &__cuMemcpy3DPeer, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 4000, ptds_mode, NULL) global __cuMemcpyAsync - _F_cuGetProcAddress_v2('cuMemcpyAsync', &__cuMemcpyAsync, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 4000, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpyAsync', &__cuMemcpyAsync, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 4000, ptds_mode, NULL) global __cuMemcpyPeerAsync - _F_cuGetProcAddress_v2('cuMemcpyPeerAsync', &__cuMemcpyPeerAsync, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 4000, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpyPeerAsync', &__cuMemcpyPeerAsync, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 4000, ptds_mode, NULL) global __cuMemcpyHtoDAsync_v2 - _F_cuGetProcAddress_v2('cuMemcpyHtoDAsync', &__cuMemcpyHtoDAsync_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpyHtoDAsync', &__cuMemcpyHtoDAsync_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemcpyDtoHAsync_v2 - _F_cuGetProcAddress_v2('cuMemcpyDtoHAsync', &__cuMemcpyDtoHAsync_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpyDtoHAsync', &__cuMemcpyDtoHAsync_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemcpyDtoDAsync_v2 - _F_cuGetProcAddress_v2('cuMemcpyDtoDAsync', &__cuMemcpyDtoDAsync_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpyDtoDAsync', &__cuMemcpyDtoDAsync_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemcpyHtoAAsync_v2 - _F_cuGetProcAddress_v2('cuMemcpyHtoAAsync', &__cuMemcpyHtoAAsync_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpyHtoAAsync', &__cuMemcpyHtoAAsync_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemcpyAtoHAsync_v2 - _F_cuGetProcAddress_v2('cuMemcpyAtoHAsync', &__cuMemcpyAtoHAsync_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpyAtoHAsync', &__cuMemcpyAtoHAsync_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemcpy2DAsync_v2 - _F_cuGetProcAddress_v2('cuMemcpy2DAsync', &__cuMemcpy2DAsync_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpy2DAsync', &__cuMemcpy2DAsync_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemcpy3DAsync_v2 - _F_cuGetProcAddress_v2('cuMemcpy3DAsync', &__cuMemcpy3DAsync_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpy3DAsync', &__cuMemcpy3DAsync_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemcpy3DPeerAsync - _F_cuGetProcAddress_v2('cuMemcpy3DPeerAsync', &__cuMemcpy3DPeerAsync, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 4000, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpy3DPeerAsync', &__cuMemcpy3DPeerAsync, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 4000, ptds_mode, NULL) global __cuMemsetD8_v2 - _F_cuGetProcAddress_v2('cuMemsetD8', &__cuMemsetD8_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemsetD8', &__cuMemsetD8_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemsetD16_v2 - _F_cuGetProcAddress_v2('cuMemsetD16', &__cuMemsetD16_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemsetD16', &__cuMemsetD16_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemsetD32_v2 - _F_cuGetProcAddress_v2('cuMemsetD32', &__cuMemsetD32_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemsetD32', &__cuMemsetD32_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemsetD2D8_v2 - _F_cuGetProcAddress_v2('cuMemsetD2D8', &__cuMemsetD2D8_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemsetD2D8', &__cuMemsetD2D8_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemsetD2D16_v2 - _F_cuGetProcAddress_v2('cuMemsetD2D16', &__cuMemsetD2D16_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemsetD2D16', &__cuMemsetD2D16_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemsetD2D32_v2 - _F_cuGetProcAddress_v2('cuMemsetD2D32', &__cuMemsetD2D32_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemsetD2D32', &__cuMemsetD2D32_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemsetD8Async - _F_cuGetProcAddress_v2('cuMemsetD8Async', &__cuMemsetD8Async, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemsetD8Async', &__cuMemsetD8Async, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemsetD16Async - _F_cuGetProcAddress_v2('cuMemsetD16Async', &__cuMemsetD16Async, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemsetD16Async', &__cuMemsetD16Async, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemsetD32Async - _F_cuGetProcAddress_v2('cuMemsetD32Async', &__cuMemsetD32Async, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemsetD32Async', &__cuMemsetD32Async, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemsetD2D8Async - _F_cuGetProcAddress_v2('cuMemsetD2D8Async', &__cuMemsetD2D8Async, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemsetD2D8Async', &__cuMemsetD2D8Async, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemsetD2D16Async - _F_cuGetProcAddress_v2('cuMemsetD2D16Async', &__cuMemsetD2D16Async, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemsetD2D16Async', &__cuMemsetD2D16Async, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuMemsetD2D32Async - _F_cuGetProcAddress_v2('cuMemsetD2D32Async', &__cuMemsetD2D32Async, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemsetD2D32Async', &__cuMemsetD2D32Async, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuArrayCreate_v2 - _F_cuGetProcAddress_v2('cuArrayCreate', &__cuArrayCreate_v2, 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuArrayCreate', &__cuArrayCreate_v2, 3020, ptds_mode, NULL) global __cuArrayGetDescriptor_v2 - _F_cuGetProcAddress_v2('cuArrayGetDescriptor', &__cuArrayGetDescriptor_v2, 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuArrayGetDescriptor', &__cuArrayGetDescriptor_v2, 3020, ptds_mode, NULL) global __cuArrayGetSparseProperties - _F_cuGetProcAddress_v2('cuArrayGetSparseProperties', &__cuArrayGetSparseProperties, 11010, ptds_mode, NULL) + cuGetProcAddress_v2('cuArrayGetSparseProperties', &__cuArrayGetSparseProperties, 11010, ptds_mode, NULL) global __cuMipmappedArrayGetSparseProperties - _F_cuGetProcAddress_v2('cuMipmappedArrayGetSparseProperties', &__cuMipmappedArrayGetSparseProperties, 11010, ptds_mode, NULL) + cuGetProcAddress_v2('cuMipmappedArrayGetSparseProperties', &__cuMipmappedArrayGetSparseProperties, 11010, ptds_mode, NULL) global __cuArrayGetMemoryRequirements - _F_cuGetProcAddress_v2('cuArrayGetMemoryRequirements', &__cuArrayGetMemoryRequirements, 11060, ptds_mode, NULL) + cuGetProcAddress_v2('cuArrayGetMemoryRequirements', &__cuArrayGetMemoryRequirements, 11060, ptds_mode, NULL) global __cuMipmappedArrayGetMemoryRequirements - _F_cuGetProcAddress_v2('cuMipmappedArrayGetMemoryRequirements', &__cuMipmappedArrayGetMemoryRequirements, 11060, ptds_mode, NULL) + cuGetProcAddress_v2('cuMipmappedArrayGetMemoryRequirements', &__cuMipmappedArrayGetMemoryRequirements, 11060, ptds_mode, NULL) global __cuArrayGetPlane - _F_cuGetProcAddress_v2('cuArrayGetPlane', &__cuArrayGetPlane, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuArrayGetPlane', &__cuArrayGetPlane, 11020, ptds_mode, NULL) global __cuArrayDestroy - _F_cuGetProcAddress_v2('cuArrayDestroy', &__cuArrayDestroy, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuArrayDestroy', &__cuArrayDestroy, 2000, ptds_mode, NULL) global __cuArray3DCreate_v2 - _F_cuGetProcAddress_v2('cuArray3DCreate', &__cuArray3DCreate_v2, 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuArray3DCreate', &__cuArray3DCreate_v2, 3020, ptds_mode, NULL) global __cuArray3DGetDescriptor_v2 - _F_cuGetProcAddress_v2('cuArray3DGetDescriptor', &__cuArray3DGetDescriptor_v2, 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuArray3DGetDescriptor', &__cuArray3DGetDescriptor_v2, 3020, ptds_mode, NULL) global __cuMipmappedArrayCreate - _F_cuGetProcAddress_v2('cuMipmappedArrayCreate', &__cuMipmappedArrayCreate, 5000, ptds_mode, NULL) + cuGetProcAddress_v2('cuMipmappedArrayCreate', &__cuMipmappedArrayCreate, 5000, ptds_mode, NULL) global __cuMipmappedArrayGetLevel - _F_cuGetProcAddress_v2('cuMipmappedArrayGetLevel', &__cuMipmappedArrayGetLevel, 5000, ptds_mode, NULL) + cuGetProcAddress_v2('cuMipmappedArrayGetLevel', &__cuMipmappedArrayGetLevel, 5000, ptds_mode, NULL) global __cuMipmappedArrayDestroy - _F_cuGetProcAddress_v2('cuMipmappedArrayDestroy', &__cuMipmappedArrayDestroy, 5000, ptds_mode, NULL) + cuGetProcAddress_v2('cuMipmappedArrayDestroy', &__cuMipmappedArrayDestroy, 5000, ptds_mode, NULL) global __cuMemGetHandleForAddressRange - _F_cuGetProcAddress_v2('cuMemGetHandleForAddressRange', &__cuMemGetHandleForAddressRange, 11070, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemGetHandleForAddressRange', &__cuMemGetHandleForAddressRange, 11070, ptds_mode, NULL) global __cuMemBatchDecompressAsync - _F_cuGetProcAddress_v2('cuMemBatchDecompressAsync', &__cuMemBatchDecompressAsync, 12060, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemBatchDecompressAsync', &__cuMemBatchDecompressAsync, 12060, ptds_mode, NULL) global __cuMemAddressReserve - _F_cuGetProcAddress_v2('cuMemAddressReserve', &__cuMemAddressReserve, 10020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemAddressReserve', &__cuMemAddressReserve, 10020, ptds_mode, NULL) global __cuMemAddressFree - _F_cuGetProcAddress_v2('cuMemAddressFree', &__cuMemAddressFree, 10020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemAddressFree', &__cuMemAddressFree, 10020, ptds_mode, NULL) global __cuMemCreate - _F_cuGetProcAddress_v2('cuMemCreate', &__cuMemCreate, 10020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemCreate', &__cuMemCreate, 10020, ptds_mode, NULL) global __cuMemRelease - _F_cuGetProcAddress_v2('cuMemRelease', &__cuMemRelease, 10020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemRelease', &__cuMemRelease, 10020, ptds_mode, NULL) global __cuMemMap - _F_cuGetProcAddress_v2('cuMemMap', &__cuMemMap, 10020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemMap', &__cuMemMap, 10020, ptds_mode, NULL) global __cuMemMapArrayAsync - _F_cuGetProcAddress_v2('cuMemMapArrayAsync', &__cuMemMapArrayAsync, 11010, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemMapArrayAsync', &__cuMemMapArrayAsync, 11010, ptds_mode, NULL) global __cuMemUnmap - _F_cuGetProcAddress_v2('cuMemUnmap', &__cuMemUnmap, 10020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemUnmap', &__cuMemUnmap, 10020, ptds_mode, NULL) global __cuMemSetAccess - _F_cuGetProcAddress_v2('cuMemSetAccess', &__cuMemSetAccess, 10020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemSetAccess', &__cuMemSetAccess, 10020, ptds_mode, NULL) global __cuMemGetAccess - _F_cuGetProcAddress_v2('cuMemGetAccess', &__cuMemGetAccess, 10020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemGetAccess', &__cuMemGetAccess, 10020, ptds_mode, NULL) global __cuMemExportToShareableHandle - _F_cuGetProcAddress_v2('cuMemExportToShareableHandle', &__cuMemExportToShareableHandle, 10020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemExportToShareableHandle', &__cuMemExportToShareableHandle, 10020, ptds_mode, NULL) global __cuMemImportFromShareableHandle - _F_cuGetProcAddress_v2('cuMemImportFromShareableHandle', &__cuMemImportFromShareableHandle, 10020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemImportFromShareableHandle', &__cuMemImportFromShareableHandle, 10020, ptds_mode, NULL) global __cuMemGetAllocationGranularity - _F_cuGetProcAddress_v2('cuMemGetAllocationGranularity', &__cuMemGetAllocationGranularity, 10020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemGetAllocationGranularity', &__cuMemGetAllocationGranularity, 10020, ptds_mode, NULL) global __cuMemGetAllocationPropertiesFromHandle - _F_cuGetProcAddress_v2('cuMemGetAllocationPropertiesFromHandle', &__cuMemGetAllocationPropertiesFromHandle, 10020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemGetAllocationPropertiesFromHandle', &__cuMemGetAllocationPropertiesFromHandle, 10020, ptds_mode, NULL) global __cuMemRetainAllocationHandle - _F_cuGetProcAddress_v2('cuMemRetainAllocationHandle', &__cuMemRetainAllocationHandle, 11000, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemRetainAllocationHandle', &__cuMemRetainAllocationHandle, 11000, ptds_mode, NULL) global __cuMemFreeAsync - _F_cuGetProcAddress_v2('cuMemFreeAsync', &__cuMemFreeAsync, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemFreeAsync', &__cuMemFreeAsync, 11020, ptds_mode, NULL) global __cuMemAllocAsync - _F_cuGetProcAddress_v2('cuMemAllocAsync', &__cuMemAllocAsync, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemAllocAsync', &__cuMemAllocAsync, 11020, ptds_mode, NULL) global __cuMemPoolTrimTo - _F_cuGetProcAddress_v2('cuMemPoolTrimTo', &__cuMemPoolTrimTo, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemPoolTrimTo', &__cuMemPoolTrimTo, 11020, ptds_mode, NULL) global __cuMemPoolSetAttribute - _F_cuGetProcAddress_v2('cuMemPoolSetAttribute', &__cuMemPoolSetAttribute, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemPoolSetAttribute', &__cuMemPoolSetAttribute, 11020, ptds_mode, NULL) global __cuMemPoolGetAttribute - _F_cuGetProcAddress_v2('cuMemPoolGetAttribute', &__cuMemPoolGetAttribute, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemPoolGetAttribute', &__cuMemPoolGetAttribute, 11020, ptds_mode, NULL) global __cuMemPoolSetAccess - _F_cuGetProcAddress_v2('cuMemPoolSetAccess', &__cuMemPoolSetAccess, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemPoolSetAccess', &__cuMemPoolSetAccess, 11020, ptds_mode, NULL) global __cuMemPoolGetAccess - _F_cuGetProcAddress_v2('cuMemPoolGetAccess', &__cuMemPoolGetAccess, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemPoolGetAccess', &__cuMemPoolGetAccess, 11020, ptds_mode, NULL) global __cuMemPoolCreate - _F_cuGetProcAddress_v2('cuMemPoolCreate', &__cuMemPoolCreate, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemPoolCreate', &__cuMemPoolCreate, 11020, ptds_mode, NULL) global __cuMemPoolDestroy - _F_cuGetProcAddress_v2('cuMemPoolDestroy', &__cuMemPoolDestroy, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemPoolDestroy', &__cuMemPoolDestroy, 11020, ptds_mode, NULL) global __cuMemAllocFromPoolAsync - _F_cuGetProcAddress_v2('cuMemAllocFromPoolAsync', &__cuMemAllocFromPoolAsync, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemAllocFromPoolAsync', &__cuMemAllocFromPoolAsync, 11020, ptds_mode, NULL) global __cuMemPoolExportToShareableHandle - _F_cuGetProcAddress_v2('cuMemPoolExportToShareableHandle', &__cuMemPoolExportToShareableHandle, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemPoolExportToShareableHandle', &__cuMemPoolExportToShareableHandle, 11020, ptds_mode, NULL) global __cuMemPoolImportFromShareableHandle - _F_cuGetProcAddress_v2('cuMemPoolImportFromShareableHandle', &__cuMemPoolImportFromShareableHandle, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemPoolImportFromShareableHandle', &__cuMemPoolImportFromShareableHandle, 11020, ptds_mode, NULL) global __cuMemPoolExportPointer - _F_cuGetProcAddress_v2('cuMemPoolExportPointer', &__cuMemPoolExportPointer, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemPoolExportPointer', &__cuMemPoolExportPointer, 11020, ptds_mode, NULL) global __cuMemPoolImportPointer - _F_cuGetProcAddress_v2('cuMemPoolImportPointer', &__cuMemPoolImportPointer, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemPoolImportPointer', &__cuMemPoolImportPointer, 11020, ptds_mode, NULL) global __cuMulticastCreate - _F_cuGetProcAddress_v2('cuMulticastCreate', &__cuMulticastCreate, 12010, ptds_mode, NULL) + cuGetProcAddress_v2('cuMulticastCreate', &__cuMulticastCreate, 12010, ptds_mode, NULL) global __cuMulticastAddDevice - _F_cuGetProcAddress_v2('cuMulticastAddDevice', &__cuMulticastAddDevice, 12010, ptds_mode, NULL) + cuGetProcAddress_v2('cuMulticastAddDevice', &__cuMulticastAddDevice, 12010, ptds_mode, NULL) global __cuMulticastBindMem - _F_cuGetProcAddress_v2('cuMulticastBindMem', &__cuMulticastBindMem, 12010, ptds_mode, NULL) + cuGetProcAddress_v2('cuMulticastBindMem', &__cuMulticastBindMem, 12010, ptds_mode, NULL) global __cuMulticastBindAddr - _F_cuGetProcAddress_v2('cuMulticastBindAddr', &__cuMulticastBindAddr, 12010, ptds_mode, NULL) + cuGetProcAddress_v2('cuMulticastBindAddr', &__cuMulticastBindAddr, 12010, ptds_mode, NULL) global __cuMulticastUnbind - _F_cuGetProcAddress_v2('cuMulticastUnbind', &__cuMulticastUnbind, 12010, ptds_mode, NULL) + cuGetProcAddress_v2('cuMulticastUnbind', &__cuMulticastUnbind, 12010, ptds_mode, NULL) global __cuMulticastGetGranularity - _F_cuGetProcAddress_v2('cuMulticastGetGranularity', &__cuMulticastGetGranularity, 12010, ptds_mode, NULL) + cuGetProcAddress_v2('cuMulticastGetGranularity', &__cuMulticastGetGranularity, 12010, ptds_mode, NULL) global __cuPointerGetAttribute - _F_cuGetProcAddress_v2('cuPointerGetAttribute', &__cuPointerGetAttribute, 4000, ptds_mode, NULL) + cuGetProcAddress_v2('cuPointerGetAttribute', &__cuPointerGetAttribute, 4000, ptds_mode, NULL) global __cuMemPrefetchAsync_v2 - _F_cuGetProcAddress_v2('cuMemPrefetchAsync', &__cuMemPrefetchAsync_v2, 12020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemPrefetchAsync', &__cuMemPrefetchAsync_v2, 12020, ptds_mode, NULL) global __cuMemAdvise_v2 - _F_cuGetProcAddress_v2('cuMemAdvise', &__cuMemAdvise_v2, 12020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemAdvise', &__cuMemAdvise_v2, 12020, ptds_mode, NULL) global __cuMemRangeGetAttribute - _F_cuGetProcAddress_v2('cuMemRangeGetAttribute', &__cuMemRangeGetAttribute, 8000, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemRangeGetAttribute', &__cuMemRangeGetAttribute, 8000, ptds_mode, NULL) global __cuMemRangeGetAttributes - _F_cuGetProcAddress_v2('cuMemRangeGetAttributes', &__cuMemRangeGetAttributes, 8000, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemRangeGetAttributes', &__cuMemRangeGetAttributes, 8000, ptds_mode, NULL) global __cuPointerSetAttribute - _F_cuGetProcAddress_v2('cuPointerSetAttribute', &__cuPointerSetAttribute, 6000, ptds_mode, NULL) + cuGetProcAddress_v2('cuPointerSetAttribute', &__cuPointerSetAttribute, 6000, ptds_mode, NULL) global __cuPointerGetAttributes - _F_cuGetProcAddress_v2('cuPointerGetAttributes', &__cuPointerGetAttributes, 7000, ptds_mode, NULL) + cuGetProcAddress_v2('cuPointerGetAttributes', &__cuPointerGetAttributes, 7000, ptds_mode, NULL) global __cuStreamCreate - _F_cuGetProcAddress_v2('cuStreamCreate', &__cuStreamCreate, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamCreate', &__cuStreamCreate, 2000, ptds_mode, NULL) global __cuStreamCreateWithPriority - _F_cuGetProcAddress_v2('cuStreamCreateWithPriority', &__cuStreamCreateWithPriority, 5050, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamCreateWithPriority', &__cuStreamCreateWithPriority, 5050, ptds_mode, NULL) global __cuStreamGetPriority - _F_cuGetProcAddress_v2('cuStreamGetPriority', &__cuStreamGetPriority, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 5050, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamGetPriority', &__cuStreamGetPriority, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 5050, ptds_mode, NULL) global __cuStreamGetDevice - _F_cuGetProcAddress_v2('cuStreamGetDevice', &__cuStreamGetDevice, 12080, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamGetDevice', &__cuStreamGetDevice, 12080, ptds_mode, NULL) global __cuStreamGetFlags - _F_cuGetProcAddress_v2('cuStreamGetFlags', &__cuStreamGetFlags, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 5050, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamGetFlags', &__cuStreamGetFlags, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 5050, ptds_mode, NULL) global __cuStreamGetId - _F_cuGetProcAddress_v2('cuStreamGetId', &__cuStreamGetId, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamGetId', &__cuStreamGetId, 12000, ptds_mode, NULL) global __cuStreamGetCtx - _F_cuGetProcAddress_v2('cuStreamGetCtx', &__cuStreamGetCtx, 9020, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamGetCtx', &__cuStreamGetCtx, 9020, ptds_mode, NULL) global __cuStreamGetCtx_v2 - _F_cuGetProcAddress_v2('cuStreamGetCtx', &__cuStreamGetCtx_v2, 12050, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamGetCtx', &__cuStreamGetCtx_v2, 12050, ptds_mode, NULL) global __cuStreamWaitEvent - _F_cuGetProcAddress_v2('cuStreamWaitEvent', &__cuStreamWaitEvent, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamWaitEvent', &__cuStreamWaitEvent, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuStreamAddCallback - _F_cuGetProcAddress_v2('cuStreamAddCallback', &__cuStreamAddCallback, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 5000, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamAddCallback', &__cuStreamAddCallback, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 5000, ptds_mode, NULL) global __cuStreamBeginCapture_v2 - _F_cuGetProcAddress_v2('cuStreamBeginCapture', &__cuStreamBeginCapture_v2, 10010, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamBeginCapture', &__cuStreamBeginCapture_v2, 10010, ptds_mode, NULL) global __cuStreamBeginCaptureToGraph - _F_cuGetProcAddress_v2('cuStreamBeginCaptureToGraph', &__cuStreamBeginCaptureToGraph, 12030, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamBeginCaptureToGraph', &__cuStreamBeginCaptureToGraph, 12030, ptds_mode, NULL) global __cuThreadExchangeStreamCaptureMode - _F_cuGetProcAddress_v2('cuThreadExchangeStreamCaptureMode', &__cuThreadExchangeStreamCaptureMode, 10010, ptds_mode, NULL) + cuGetProcAddress_v2('cuThreadExchangeStreamCaptureMode', &__cuThreadExchangeStreamCaptureMode, 10010, ptds_mode, NULL) global __cuStreamEndCapture - _F_cuGetProcAddress_v2('cuStreamEndCapture', &__cuStreamEndCapture, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamEndCapture', &__cuStreamEndCapture, 10000, ptds_mode, NULL) global __cuStreamIsCapturing - _F_cuGetProcAddress_v2('cuStreamIsCapturing', &__cuStreamIsCapturing, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamIsCapturing', &__cuStreamIsCapturing, 10000, ptds_mode, NULL) global __cuStreamGetCaptureInfo_v2 - _F_cuGetProcAddress_v2('cuStreamGetCaptureInfo', &__cuStreamGetCaptureInfo_v2, 11030, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamGetCaptureInfo', &__cuStreamGetCaptureInfo_v2, 11030, ptds_mode, NULL) global __cuStreamGetCaptureInfo_v3 - _F_cuGetProcAddress_v2('cuStreamGetCaptureInfo', &__cuStreamGetCaptureInfo_v3, 12030, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamGetCaptureInfo', &__cuStreamGetCaptureInfo_v3, 12030, ptds_mode, NULL) global __cuStreamUpdateCaptureDependencies_v2 - _F_cuGetProcAddress_v2('cuStreamUpdateCaptureDependencies', &__cuStreamUpdateCaptureDependencies_v2, 12030, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamUpdateCaptureDependencies', &__cuStreamUpdateCaptureDependencies_v2, 12030, ptds_mode, NULL) global __cuStreamAttachMemAsync - _F_cuGetProcAddress_v2('cuStreamAttachMemAsync', &__cuStreamAttachMemAsync, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 6000, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamAttachMemAsync', &__cuStreamAttachMemAsync, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 6000, ptds_mode, NULL) global __cuStreamQuery - _F_cuGetProcAddress_v2('cuStreamQuery', &__cuStreamQuery, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamQuery', &__cuStreamQuery, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 2000, ptds_mode, NULL) global __cuStreamSynchronize - _F_cuGetProcAddress_v2('cuStreamSynchronize', &__cuStreamSynchronize, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamSynchronize', &__cuStreamSynchronize, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 2000, ptds_mode, NULL) global __cuStreamDestroy_v2 - _F_cuGetProcAddress_v2('cuStreamDestroy', &__cuStreamDestroy_v2, 4000, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamDestroy', &__cuStreamDestroy_v2, 4000, ptds_mode, NULL) global __cuStreamCopyAttributes - _F_cuGetProcAddress_v2('cuStreamCopyAttributes', &__cuStreamCopyAttributes, 11000, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamCopyAttributes', &__cuStreamCopyAttributes, 11000, ptds_mode, NULL) global __cuStreamGetAttribute - _F_cuGetProcAddress_v2('cuStreamGetAttribute', &__cuStreamGetAttribute, 11000, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamGetAttribute', &__cuStreamGetAttribute, 11000, ptds_mode, NULL) global __cuStreamSetAttribute - _F_cuGetProcAddress_v2('cuStreamSetAttribute', &__cuStreamSetAttribute, 11000, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamSetAttribute', &__cuStreamSetAttribute, 11000, ptds_mode, NULL) global __cuEventCreate - _F_cuGetProcAddress_v2('cuEventCreate', &__cuEventCreate, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuEventCreate', &__cuEventCreate, 2000, ptds_mode, NULL) global __cuEventRecord - _F_cuGetProcAddress_v2('cuEventRecord', &__cuEventRecord, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuEventRecord', &__cuEventRecord, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 2000, ptds_mode, NULL) global __cuEventRecordWithFlags - _F_cuGetProcAddress_v2('cuEventRecordWithFlags', &__cuEventRecordWithFlags, 11010, ptds_mode, NULL) + cuGetProcAddress_v2('cuEventRecordWithFlags', &__cuEventRecordWithFlags, 11010, ptds_mode, NULL) global __cuEventQuery - _F_cuGetProcAddress_v2('cuEventQuery', &__cuEventQuery, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuEventQuery', &__cuEventQuery, 2000, ptds_mode, NULL) global __cuEventSynchronize - _F_cuGetProcAddress_v2('cuEventSynchronize', &__cuEventSynchronize, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuEventSynchronize', &__cuEventSynchronize, 2000, ptds_mode, NULL) global __cuEventDestroy_v2 - _F_cuGetProcAddress_v2('cuEventDestroy', &__cuEventDestroy_v2, 4000, ptds_mode, NULL) + cuGetProcAddress_v2('cuEventDestroy', &__cuEventDestroy_v2, 4000, ptds_mode, NULL) global __cuEventElapsedTime_v2 - _F_cuGetProcAddress_v2('cuEventElapsedTime', &__cuEventElapsedTime_v2, 12080, ptds_mode, NULL) + cuGetProcAddress_v2('cuEventElapsedTime', &__cuEventElapsedTime_v2, 12080, ptds_mode, NULL) global __cuImportExternalMemory - _F_cuGetProcAddress_v2('cuImportExternalMemory', &__cuImportExternalMemory, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuImportExternalMemory', &__cuImportExternalMemory, 10000, ptds_mode, NULL) global __cuExternalMemoryGetMappedBuffer - _F_cuGetProcAddress_v2('cuExternalMemoryGetMappedBuffer', &__cuExternalMemoryGetMappedBuffer, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuExternalMemoryGetMappedBuffer', &__cuExternalMemoryGetMappedBuffer, 10000, ptds_mode, NULL) global __cuExternalMemoryGetMappedMipmappedArray - _F_cuGetProcAddress_v2('cuExternalMemoryGetMappedMipmappedArray', &__cuExternalMemoryGetMappedMipmappedArray, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuExternalMemoryGetMappedMipmappedArray', &__cuExternalMemoryGetMappedMipmappedArray, 10000, ptds_mode, NULL) global __cuDestroyExternalMemory - _F_cuGetProcAddress_v2('cuDestroyExternalMemory', &__cuDestroyExternalMemory, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuDestroyExternalMemory', &__cuDestroyExternalMemory, 10000, ptds_mode, NULL) global __cuImportExternalSemaphore - _F_cuGetProcAddress_v2('cuImportExternalSemaphore', &__cuImportExternalSemaphore, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuImportExternalSemaphore', &__cuImportExternalSemaphore, 10000, ptds_mode, NULL) global __cuSignalExternalSemaphoresAsync - _F_cuGetProcAddress_v2('cuSignalExternalSemaphoresAsync', &__cuSignalExternalSemaphoresAsync, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuSignalExternalSemaphoresAsync', &__cuSignalExternalSemaphoresAsync, 10000, ptds_mode, NULL) global __cuWaitExternalSemaphoresAsync - _F_cuGetProcAddress_v2('cuWaitExternalSemaphoresAsync', &__cuWaitExternalSemaphoresAsync, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuWaitExternalSemaphoresAsync', &__cuWaitExternalSemaphoresAsync, 10000, ptds_mode, NULL) global __cuDestroyExternalSemaphore - _F_cuGetProcAddress_v2('cuDestroyExternalSemaphore', &__cuDestroyExternalSemaphore, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuDestroyExternalSemaphore', &__cuDestroyExternalSemaphore, 10000, ptds_mode, NULL) global __cuStreamWaitValue32_v2 - _F_cuGetProcAddress_v2('cuStreamWaitValue32', &__cuStreamWaitValue32_v2, 11070, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamWaitValue32', &__cuStreamWaitValue32_v2, 11070, ptds_mode, NULL) global __cuStreamWaitValue64_v2 - _F_cuGetProcAddress_v2('cuStreamWaitValue64', &__cuStreamWaitValue64_v2, 11070, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamWaitValue64', &__cuStreamWaitValue64_v2, 11070, ptds_mode, NULL) global __cuStreamWriteValue32_v2 - _F_cuGetProcAddress_v2('cuStreamWriteValue32', &__cuStreamWriteValue32_v2, 11070, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamWriteValue32', &__cuStreamWriteValue32_v2, 11070, ptds_mode, NULL) global __cuStreamWriteValue64_v2 - _F_cuGetProcAddress_v2('cuStreamWriteValue64', &__cuStreamWriteValue64_v2, 11070, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamWriteValue64', &__cuStreamWriteValue64_v2, 11070, ptds_mode, NULL) global __cuStreamBatchMemOp_v2 - _F_cuGetProcAddress_v2('cuStreamBatchMemOp', &__cuStreamBatchMemOp_v2, 11070, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamBatchMemOp', &__cuStreamBatchMemOp_v2, 11070, ptds_mode, NULL) global __cuFuncGetAttribute - _F_cuGetProcAddress_v2('cuFuncGetAttribute', &__cuFuncGetAttribute, 2020, ptds_mode, NULL) + cuGetProcAddress_v2('cuFuncGetAttribute', &__cuFuncGetAttribute, 2020, ptds_mode, NULL) global __cuFuncSetAttribute - _F_cuGetProcAddress_v2('cuFuncSetAttribute', &__cuFuncSetAttribute, 9000, ptds_mode, NULL) + cuGetProcAddress_v2('cuFuncSetAttribute', &__cuFuncSetAttribute, 9000, ptds_mode, NULL) global __cuFuncSetCacheConfig - _F_cuGetProcAddress_v2('cuFuncSetCacheConfig', &__cuFuncSetCacheConfig, 3000, ptds_mode, NULL) + cuGetProcAddress_v2('cuFuncSetCacheConfig', &__cuFuncSetCacheConfig, 3000, ptds_mode, NULL) global __cuFuncGetModule - _F_cuGetProcAddress_v2('cuFuncGetModule', &__cuFuncGetModule, 11000, ptds_mode, NULL) + cuGetProcAddress_v2('cuFuncGetModule', &__cuFuncGetModule, 11000, ptds_mode, NULL) global __cuFuncGetName - _F_cuGetProcAddress_v2('cuFuncGetName', &__cuFuncGetName, 12030, ptds_mode, NULL) + cuGetProcAddress_v2('cuFuncGetName', &__cuFuncGetName, 12030, ptds_mode, NULL) global __cuFuncGetParamInfo - _F_cuGetProcAddress_v2('cuFuncGetParamInfo', &__cuFuncGetParamInfo, 12040, ptds_mode, NULL) + cuGetProcAddress_v2('cuFuncGetParamInfo', &__cuFuncGetParamInfo, 12040, ptds_mode, NULL) global __cuFuncIsLoaded - _F_cuGetProcAddress_v2('cuFuncIsLoaded', &__cuFuncIsLoaded, 12040, ptds_mode, NULL) + cuGetProcAddress_v2('cuFuncIsLoaded', &__cuFuncIsLoaded, 12040, ptds_mode, NULL) global __cuFuncLoad - _F_cuGetProcAddress_v2('cuFuncLoad', &__cuFuncLoad, 12040, ptds_mode, NULL) + cuGetProcAddress_v2('cuFuncLoad', &__cuFuncLoad, 12040, ptds_mode, NULL) global __cuLaunchKernel - _F_cuGetProcAddress_v2('cuLaunchKernel', &__cuLaunchKernel, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 4000, ptds_mode, NULL) + cuGetProcAddress_v2('cuLaunchKernel', &__cuLaunchKernel, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 4000, ptds_mode, NULL) global __cuLaunchKernelEx - _F_cuGetProcAddress_v2('cuLaunchKernelEx', &__cuLaunchKernelEx, 11060, ptds_mode, NULL) + cuGetProcAddress_v2('cuLaunchKernelEx', &__cuLaunchKernelEx, 11060, ptds_mode, NULL) global __cuLaunchCooperativeKernel - _F_cuGetProcAddress_v2('cuLaunchCooperativeKernel', &__cuLaunchCooperativeKernel, 9000, ptds_mode, NULL) + cuGetProcAddress_v2('cuLaunchCooperativeKernel', &__cuLaunchCooperativeKernel, 9000, ptds_mode, NULL) global __cuLaunchCooperativeKernelMultiDevice - _F_cuGetProcAddress_v2('cuLaunchCooperativeKernelMultiDevice', &__cuLaunchCooperativeKernelMultiDevice, 9000, ptds_mode, NULL) + cuGetProcAddress_v2('cuLaunchCooperativeKernelMultiDevice', &__cuLaunchCooperativeKernelMultiDevice, 9000, ptds_mode, NULL) global __cuLaunchHostFunc - _F_cuGetProcAddress_v2('cuLaunchHostFunc', &__cuLaunchHostFunc, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuLaunchHostFunc', &__cuLaunchHostFunc, 10000, ptds_mode, NULL) global __cuFuncSetBlockShape - _F_cuGetProcAddress_v2('cuFuncSetBlockShape', &__cuFuncSetBlockShape, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuFuncSetBlockShape', &__cuFuncSetBlockShape, 2000, ptds_mode, NULL) global __cuFuncSetSharedSize - _F_cuGetProcAddress_v2('cuFuncSetSharedSize', &__cuFuncSetSharedSize, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuFuncSetSharedSize', &__cuFuncSetSharedSize, 2000, ptds_mode, NULL) global __cuParamSetSize - _F_cuGetProcAddress_v2('cuParamSetSize', &__cuParamSetSize, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuParamSetSize', &__cuParamSetSize, 2000, ptds_mode, NULL) global __cuParamSeti - _F_cuGetProcAddress_v2('cuParamSeti', &__cuParamSeti, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuParamSeti', &__cuParamSeti, 2000, ptds_mode, NULL) global __cuParamSetf - _F_cuGetProcAddress_v2('cuParamSetf', &__cuParamSetf, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuParamSetf', &__cuParamSetf, 2000, ptds_mode, NULL) global __cuParamSetv - _F_cuGetProcAddress_v2('cuParamSetv', &__cuParamSetv, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuParamSetv', &__cuParamSetv, 2000, ptds_mode, NULL) global __cuLaunch - _F_cuGetProcAddress_v2('cuLaunch', &__cuLaunch, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuLaunch', &__cuLaunch, 2000, ptds_mode, NULL) global __cuLaunchGrid - _F_cuGetProcAddress_v2('cuLaunchGrid', &__cuLaunchGrid, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuLaunchGrid', &__cuLaunchGrid, 2000, ptds_mode, NULL) global __cuLaunchGridAsync - _F_cuGetProcAddress_v2('cuLaunchGridAsync', &__cuLaunchGridAsync, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuLaunchGridAsync', &__cuLaunchGridAsync, 2000, ptds_mode, NULL) global __cuParamSetTexRef - _F_cuGetProcAddress_v2('cuParamSetTexRef', &__cuParamSetTexRef, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuParamSetTexRef', &__cuParamSetTexRef, 2000, ptds_mode, NULL) global __cuFuncSetSharedMemConfig - _F_cuGetProcAddress_v2('cuFuncSetSharedMemConfig', &__cuFuncSetSharedMemConfig, 4020, ptds_mode, NULL) + cuGetProcAddress_v2('cuFuncSetSharedMemConfig', &__cuFuncSetSharedMemConfig, 4020, ptds_mode, NULL) global __cuGraphCreate - _F_cuGetProcAddress_v2('cuGraphCreate', &__cuGraphCreate, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphCreate', &__cuGraphCreate, 10000, ptds_mode, NULL) global __cuGraphAddKernelNode_v2 - _F_cuGetProcAddress_v2('cuGraphAddKernelNode', &__cuGraphAddKernelNode_v2, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphAddKernelNode', &__cuGraphAddKernelNode_v2, 12000, ptds_mode, NULL) global __cuGraphKernelNodeGetParams_v2 - _F_cuGetProcAddress_v2('cuGraphKernelNodeGetParams', &__cuGraphKernelNodeGetParams_v2, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphKernelNodeGetParams', &__cuGraphKernelNodeGetParams_v2, 12000, ptds_mode, NULL) global __cuGraphKernelNodeSetParams_v2 - _F_cuGetProcAddress_v2('cuGraphKernelNodeSetParams', &__cuGraphKernelNodeSetParams_v2, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphKernelNodeSetParams', &__cuGraphKernelNodeSetParams_v2, 12000, ptds_mode, NULL) global __cuGraphAddMemcpyNode - _F_cuGetProcAddress_v2('cuGraphAddMemcpyNode', &__cuGraphAddMemcpyNode, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphAddMemcpyNode', &__cuGraphAddMemcpyNode, 10000, ptds_mode, NULL) global __cuGraphMemcpyNodeGetParams - _F_cuGetProcAddress_v2('cuGraphMemcpyNodeGetParams', &__cuGraphMemcpyNodeGetParams, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphMemcpyNodeGetParams', &__cuGraphMemcpyNodeGetParams, 10000, ptds_mode, NULL) global __cuGraphMemcpyNodeSetParams - _F_cuGetProcAddress_v2('cuGraphMemcpyNodeSetParams', &__cuGraphMemcpyNodeSetParams, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphMemcpyNodeSetParams', &__cuGraphMemcpyNodeSetParams, 10000, ptds_mode, NULL) global __cuGraphAddMemsetNode - _F_cuGetProcAddress_v2('cuGraphAddMemsetNode', &__cuGraphAddMemsetNode, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphAddMemsetNode', &__cuGraphAddMemsetNode, 10000, ptds_mode, NULL) global __cuGraphMemsetNodeGetParams - _F_cuGetProcAddress_v2('cuGraphMemsetNodeGetParams', &__cuGraphMemsetNodeGetParams, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphMemsetNodeGetParams', &__cuGraphMemsetNodeGetParams, 10000, ptds_mode, NULL) global __cuGraphMemsetNodeSetParams - _F_cuGetProcAddress_v2('cuGraphMemsetNodeSetParams', &__cuGraphMemsetNodeSetParams, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphMemsetNodeSetParams', &__cuGraphMemsetNodeSetParams, 10000, ptds_mode, NULL) global __cuGraphAddHostNode - _F_cuGetProcAddress_v2('cuGraphAddHostNode', &__cuGraphAddHostNode, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphAddHostNode', &__cuGraphAddHostNode, 10000, ptds_mode, NULL) global __cuGraphHostNodeGetParams - _F_cuGetProcAddress_v2('cuGraphHostNodeGetParams', &__cuGraphHostNodeGetParams, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphHostNodeGetParams', &__cuGraphHostNodeGetParams, 10000, ptds_mode, NULL) global __cuGraphHostNodeSetParams - _F_cuGetProcAddress_v2('cuGraphHostNodeSetParams', &__cuGraphHostNodeSetParams, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphHostNodeSetParams', &__cuGraphHostNodeSetParams, 10000, ptds_mode, NULL) global __cuGraphAddChildGraphNode - _F_cuGetProcAddress_v2('cuGraphAddChildGraphNode', &__cuGraphAddChildGraphNode, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphAddChildGraphNode', &__cuGraphAddChildGraphNode, 10000, ptds_mode, NULL) global __cuGraphChildGraphNodeGetGraph - _F_cuGetProcAddress_v2('cuGraphChildGraphNodeGetGraph', &__cuGraphChildGraphNodeGetGraph, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphChildGraphNodeGetGraph', &__cuGraphChildGraphNodeGetGraph, 10000, ptds_mode, NULL) global __cuGraphAddEmptyNode - _F_cuGetProcAddress_v2('cuGraphAddEmptyNode', &__cuGraphAddEmptyNode, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphAddEmptyNode', &__cuGraphAddEmptyNode, 10000, ptds_mode, NULL) global __cuGraphAddEventRecordNode - _F_cuGetProcAddress_v2('cuGraphAddEventRecordNode', &__cuGraphAddEventRecordNode, 11010, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphAddEventRecordNode', &__cuGraphAddEventRecordNode, 11010, ptds_mode, NULL) global __cuGraphEventRecordNodeGetEvent - _F_cuGetProcAddress_v2('cuGraphEventRecordNodeGetEvent', &__cuGraphEventRecordNodeGetEvent, 11010, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphEventRecordNodeGetEvent', &__cuGraphEventRecordNodeGetEvent, 11010, ptds_mode, NULL) global __cuGraphEventRecordNodeSetEvent - _F_cuGetProcAddress_v2('cuGraphEventRecordNodeSetEvent', &__cuGraphEventRecordNodeSetEvent, 11010, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphEventRecordNodeSetEvent', &__cuGraphEventRecordNodeSetEvent, 11010, ptds_mode, NULL) global __cuGraphAddEventWaitNode - _F_cuGetProcAddress_v2('cuGraphAddEventWaitNode', &__cuGraphAddEventWaitNode, 11010, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphAddEventWaitNode', &__cuGraphAddEventWaitNode, 11010, ptds_mode, NULL) global __cuGraphEventWaitNodeGetEvent - _F_cuGetProcAddress_v2('cuGraphEventWaitNodeGetEvent', &__cuGraphEventWaitNodeGetEvent, 11010, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphEventWaitNodeGetEvent', &__cuGraphEventWaitNodeGetEvent, 11010, ptds_mode, NULL) global __cuGraphEventWaitNodeSetEvent - _F_cuGetProcAddress_v2('cuGraphEventWaitNodeSetEvent', &__cuGraphEventWaitNodeSetEvent, 11010, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphEventWaitNodeSetEvent', &__cuGraphEventWaitNodeSetEvent, 11010, ptds_mode, NULL) global __cuGraphAddExternalSemaphoresSignalNode - _F_cuGetProcAddress_v2('cuGraphAddExternalSemaphoresSignalNode', &__cuGraphAddExternalSemaphoresSignalNode, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphAddExternalSemaphoresSignalNode', &__cuGraphAddExternalSemaphoresSignalNode, 11020, ptds_mode, NULL) global __cuGraphExternalSemaphoresSignalNodeGetParams - _F_cuGetProcAddress_v2('cuGraphExternalSemaphoresSignalNodeGetParams', &__cuGraphExternalSemaphoresSignalNodeGetParams, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphExternalSemaphoresSignalNodeGetParams', &__cuGraphExternalSemaphoresSignalNodeGetParams, 11020, ptds_mode, NULL) global __cuGraphExternalSemaphoresSignalNodeSetParams - _F_cuGetProcAddress_v2('cuGraphExternalSemaphoresSignalNodeSetParams', &__cuGraphExternalSemaphoresSignalNodeSetParams, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphExternalSemaphoresSignalNodeSetParams', &__cuGraphExternalSemaphoresSignalNodeSetParams, 11020, ptds_mode, NULL) global __cuGraphAddExternalSemaphoresWaitNode - _F_cuGetProcAddress_v2('cuGraphAddExternalSemaphoresWaitNode', &__cuGraphAddExternalSemaphoresWaitNode, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphAddExternalSemaphoresWaitNode', &__cuGraphAddExternalSemaphoresWaitNode, 11020, ptds_mode, NULL) global __cuGraphExternalSemaphoresWaitNodeGetParams - _F_cuGetProcAddress_v2('cuGraphExternalSemaphoresWaitNodeGetParams', &__cuGraphExternalSemaphoresWaitNodeGetParams, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphExternalSemaphoresWaitNodeGetParams', &__cuGraphExternalSemaphoresWaitNodeGetParams, 11020, ptds_mode, NULL) global __cuGraphExternalSemaphoresWaitNodeSetParams - _F_cuGetProcAddress_v2('cuGraphExternalSemaphoresWaitNodeSetParams', &__cuGraphExternalSemaphoresWaitNodeSetParams, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphExternalSemaphoresWaitNodeSetParams', &__cuGraphExternalSemaphoresWaitNodeSetParams, 11020, ptds_mode, NULL) global __cuGraphAddBatchMemOpNode - _F_cuGetProcAddress_v2('cuGraphAddBatchMemOpNode', &__cuGraphAddBatchMemOpNode, 11070, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphAddBatchMemOpNode', &__cuGraphAddBatchMemOpNode, 11070, ptds_mode, NULL) global __cuGraphBatchMemOpNodeGetParams - _F_cuGetProcAddress_v2('cuGraphBatchMemOpNodeGetParams', &__cuGraphBatchMemOpNodeGetParams, 11070, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphBatchMemOpNodeGetParams', &__cuGraphBatchMemOpNodeGetParams, 11070, ptds_mode, NULL) global __cuGraphBatchMemOpNodeSetParams - _F_cuGetProcAddress_v2('cuGraphBatchMemOpNodeSetParams', &__cuGraphBatchMemOpNodeSetParams, 11070, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphBatchMemOpNodeSetParams', &__cuGraphBatchMemOpNodeSetParams, 11070, ptds_mode, NULL) global __cuGraphExecBatchMemOpNodeSetParams - _F_cuGetProcAddress_v2('cuGraphExecBatchMemOpNodeSetParams', &__cuGraphExecBatchMemOpNodeSetParams, 11070, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphExecBatchMemOpNodeSetParams', &__cuGraphExecBatchMemOpNodeSetParams, 11070, ptds_mode, NULL) global __cuGraphAddMemAllocNode - _F_cuGetProcAddress_v2('cuGraphAddMemAllocNode', &__cuGraphAddMemAllocNode, 11040, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphAddMemAllocNode', &__cuGraphAddMemAllocNode, 11040, ptds_mode, NULL) global __cuGraphMemAllocNodeGetParams - _F_cuGetProcAddress_v2('cuGraphMemAllocNodeGetParams', &__cuGraphMemAllocNodeGetParams, 11040, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphMemAllocNodeGetParams', &__cuGraphMemAllocNodeGetParams, 11040, ptds_mode, NULL) global __cuGraphAddMemFreeNode - _F_cuGetProcAddress_v2('cuGraphAddMemFreeNode', &__cuGraphAddMemFreeNode, 11040, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphAddMemFreeNode', &__cuGraphAddMemFreeNode, 11040, ptds_mode, NULL) global __cuGraphMemFreeNodeGetParams - _F_cuGetProcAddress_v2('cuGraphMemFreeNodeGetParams', &__cuGraphMemFreeNodeGetParams, 11040, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphMemFreeNodeGetParams', &__cuGraphMemFreeNodeGetParams, 11040, ptds_mode, NULL) global __cuDeviceGraphMemTrim - _F_cuGetProcAddress_v2('cuDeviceGraphMemTrim', &__cuDeviceGraphMemTrim, 11040, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceGraphMemTrim', &__cuDeviceGraphMemTrim, 11040, ptds_mode, NULL) global __cuDeviceGetGraphMemAttribute - _F_cuGetProcAddress_v2('cuDeviceGetGraphMemAttribute', &__cuDeviceGetGraphMemAttribute, 11040, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceGetGraphMemAttribute', &__cuDeviceGetGraphMemAttribute, 11040, ptds_mode, NULL) global __cuDeviceSetGraphMemAttribute - _F_cuGetProcAddress_v2('cuDeviceSetGraphMemAttribute', &__cuDeviceSetGraphMemAttribute, 11040, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceSetGraphMemAttribute', &__cuDeviceSetGraphMemAttribute, 11040, ptds_mode, NULL) global __cuGraphClone - _F_cuGetProcAddress_v2('cuGraphClone', &__cuGraphClone, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphClone', &__cuGraphClone, 10000, ptds_mode, NULL) global __cuGraphNodeFindInClone - _F_cuGetProcAddress_v2('cuGraphNodeFindInClone', &__cuGraphNodeFindInClone, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphNodeFindInClone', &__cuGraphNodeFindInClone, 10000, ptds_mode, NULL) global __cuGraphNodeGetType - _F_cuGetProcAddress_v2('cuGraphNodeGetType', &__cuGraphNodeGetType, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphNodeGetType', &__cuGraphNodeGetType, 10000, ptds_mode, NULL) global __cuGraphGetNodes - _F_cuGetProcAddress_v2('cuGraphGetNodes', &__cuGraphGetNodes, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphGetNodes', &__cuGraphGetNodes, 10000, ptds_mode, NULL) global __cuGraphGetRootNodes - _F_cuGetProcAddress_v2('cuGraphGetRootNodes', &__cuGraphGetRootNodes, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphGetRootNodes', &__cuGraphGetRootNodes, 10000, ptds_mode, NULL) global __cuGraphGetEdges_v2 - _F_cuGetProcAddress_v2('cuGraphGetEdges', &__cuGraphGetEdges_v2, 12030, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphGetEdges', &__cuGraphGetEdges_v2, 12030, ptds_mode, NULL) global __cuGraphNodeGetDependencies_v2 - _F_cuGetProcAddress_v2('cuGraphNodeGetDependencies', &__cuGraphNodeGetDependencies_v2, 12030, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphNodeGetDependencies', &__cuGraphNodeGetDependencies_v2, 12030, ptds_mode, NULL) global __cuGraphNodeGetDependentNodes_v2 - _F_cuGetProcAddress_v2('cuGraphNodeGetDependentNodes', &__cuGraphNodeGetDependentNodes_v2, 12030, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphNodeGetDependentNodes', &__cuGraphNodeGetDependentNodes_v2, 12030, ptds_mode, NULL) global __cuGraphAddDependencies_v2 - _F_cuGetProcAddress_v2('cuGraphAddDependencies', &__cuGraphAddDependencies_v2, 12030, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphAddDependencies', &__cuGraphAddDependencies_v2, 12030, ptds_mode, NULL) global __cuGraphRemoveDependencies_v2 - _F_cuGetProcAddress_v2('cuGraphRemoveDependencies', &__cuGraphRemoveDependencies_v2, 12030, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphRemoveDependencies', &__cuGraphRemoveDependencies_v2, 12030, ptds_mode, NULL) global __cuGraphDestroyNode - _F_cuGetProcAddress_v2('cuGraphDestroyNode', &__cuGraphDestroyNode, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphDestroyNode', &__cuGraphDestroyNode, 10000, ptds_mode, NULL) global __cuGraphInstantiateWithFlags - _F_cuGetProcAddress_v2('cuGraphInstantiateWithFlags', &__cuGraphInstantiateWithFlags, 11040, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphInstantiateWithFlags', &__cuGraphInstantiateWithFlags, 11040, ptds_mode, NULL) global __cuGraphInstantiateWithParams - _F_cuGetProcAddress_v2('cuGraphInstantiateWithParams', &__cuGraphInstantiateWithParams, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphInstantiateWithParams', &__cuGraphInstantiateWithParams, 12000, ptds_mode, NULL) global __cuGraphExecGetFlags - _F_cuGetProcAddress_v2('cuGraphExecGetFlags', &__cuGraphExecGetFlags, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphExecGetFlags', &__cuGraphExecGetFlags, 12000, ptds_mode, NULL) global __cuGraphExecKernelNodeSetParams_v2 - _F_cuGetProcAddress_v2('cuGraphExecKernelNodeSetParams', &__cuGraphExecKernelNodeSetParams_v2, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphExecKernelNodeSetParams', &__cuGraphExecKernelNodeSetParams_v2, 12000, ptds_mode, NULL) global __cuGraphExecMemcpyNodeSetParams - _F_cuGetProcAddress_v2('cuGraphExecMemcpyNodeSetParams', &__cuGraphExecMemcpyNodeSetParams, 10020, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphExecMemcpyNodeSetParams', &__cuGraphExecMemcpyNodeSetParams, 10020, ptds_mode, NULL) global __cuGraphExecMemsetNodeSetParams - _F_cuGetProcAddress_v2('cuGraphExecMemsetNodeSetParams', &__cuGraphExecMemsetNodeSetParams, 10020, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphExecMemsetNodeSetParams', &__cuGraphExecMemsetNodeSetParams, 10020, ptds_mode, NULL) global __cuGraphExecHostNodeSetParams - _F_cuGetProcAddress_v2('cuGraphExecHostNodeSetParams', &__cuGraphExecHostNodeSetParams, 10020, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphExecHostNodeSetParams', &__cuGraphExecHostNodeSetParams, 10020, ptds_mode, NULL) global __cuGraphExecChildGraphNodeSetParams - _F_cuGetProcAddress_v2('cuGraphExecChildGraphNodeSetParams', &__cuGraphExecChildGraphNodeSetParams, 11010, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphExecChildGraphNodeSetParams', &__cuGraphExecChildGraphNodeSetParams, 11010, ptds_mode, NULL) global __cuGraphExecEventRecordNodeSetEvent - _F_cuGetProcAddress_v2('cuGraphExecEventRecordNodeSetEvent', &__cuGraphExecEventRecordNodeSetEvent, 11010, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphExecEventRecordNodeSetEvent', &__cuGraphExecEventRecordNodeSetEvent, 11010, ptds_mode, NULL) global __cuGraphExecEventWaitNodeSetEvent - _F_cuGetProcAddress_v2('cuGraphExecEventWaitNodeSetEvent', &__cuGraphExecEventWaitNodeSetEvent, 11010, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphExecEventWaitNodeSetEvent', &__cuGraphExecEventWaitNodeSetEvent, 11010, ptds_mode, NULL) global __cuGraphExecExternalSemaphoresSignalNodeSetParams - _F_cuGetProcAddress_v2('cuGraphExecExternalSemaphoresSignalNodeSetParams', &__cuGraphExecExternalSemaphoresSignalNodeSetParams, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphExecExternalSemaphoresSignalNodeSetParams', &__cuGraphExecExternalSemaphoresSignalNodeSetParams, 11020, ptds_mode, NULL) global __cuGraphExecExternalSemaphoresWaitNodeSetParams - _F_cuGetProcAddress_v2('cuGraphExecExternalSemaphoresWaitNodeSetParams', &__cuGraphExecExternalSemaphoresWaitNodeSetParams, 11020, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphExecExternalSemaphoresWaitNodeSetParams', &__cuGraphExecExternalSemaphoresWaitNodeSetParams, 11020, ptds_mode, NULL) global __cuGraphNodeSetEnabled - _F_cuGetProcAddress_v2('cuGraphNodeSetEnabled', &__cuGraphNodeSetEnabled, 11060, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphNodeSetEnabled', &__cuGraphNodeSetEnabled, 11060, ptds_mode, NULL) global __cuGraphNodeGetEnabled - _F_cuGetProcAddress_v2('cuGraphNodeGetEnabled', &__cuGraphNodeGetEnabled, 11060, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphNodeGetEnabled', &__cuGraphNodeGetEnabled, 11060, ptds_mode, NULL) global __cuGraphUpload - _F_cuGetProcAddress_v2('cuGraphUpload', &__cuGraphUpload, 11010, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphUpload', &__cuGraphUpload, 11010, ptds_mode, NULL) global __cuGraphLaunch - _F_cuGetProcAddress_v2('cuGraphLaunch', &__cuGraphLaunch, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphLaunch', &__cuGraphLaunch, 10000, ptds_mode, NULL) global __cuGraphExecDestroy - _F_cuGetProcAddress_v2('cuGraphExecDestroy', &__cuGraphExecDestroy, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphExecDestroy', &__cuGraphExecDestroy, 10000, ptds_mode, NULL) global __cuGraphDestroy - _F_cuGetProcAddress_v2('cuGraphDestroy', &__cuGraphDestroy, 10000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphDestroy', &__cuGraphDestroy, 10000, ptds_mode, NULL) global __cuGraphExecUpdate_v2 - _F_cuGetProcAddress_v2('cuGraphExecUpdate', &__cuGraphExecUpdate_v2, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphExecUpdate', &__cuGraphExecUpdate_v2, 12000, ptds_mode, NULL) global __cuGraphKernelNodeCopyAttributes - _F_cuGetProcAddress_v2('cuGraphKernelNodeCopyAttributes', &__cuGraphKernelNodeCopyAttributes, 11000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphKernelNodeCopyAttributes', &__cuGraphKernelNodeCopyAttributes, 11000, ptds_mode, NULL) global __cuGraphKernelNodeGetAttribute - _F_cuGetProcAddress_v2('cuGraphKernelNodeGetAttribute', &__cuGraphKernelNodeGetAttribute, 11000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphKernelNodeGetAttribute', &__cuGraphKernelNodeGetAttribute, 11000, ptds_mode, NULL) global __cuGraphKernelNodeSetAttribute - _F_cuGetProcAddress_v2('cuGraphKernelNodeSetAttribute', &__cuGraphKernelNodeSetAttribute, 11000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphKernelNodeSetAttribute', &__cuGraphKernelNodeSetAttribute, 11000, ptds_mode, NULL) global __cuGraphDebugDotPrint - _F_cuGetProcAddress_v2('cuGraphDebugDotPrint', &__cuGraphDebugDotPrint, 11030, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphDebugDotPrint', &__cuGraphDebugDotPrint, 11030, ptds_mode, NULL) global __cuUserObjectCreate - _F_cuGetProcAddress_v2('cuUserObjectCreate', &__cuUserObjectCreate, 11030, ptds_mode, NULL) + cuGetProcAddress_v2('cuUserObjectCreate', &__cuUserObjectCreate, 11030, ptds_mode, NULL) global __cuUserObjectRetain - _F_cuGetProcAddress_v2('cuUserObjectRetain', &__cuUserObjectRetain, 11030, ptds_mode, NULL) + cuGetProcAddress_v2('cuUserObjectRetain', &__cuUserObjectRetain, 11030, ptds_mode, NULL) global __cuUserObjectRelease - _F_cuGetProcAddress_v2('cuUserObjectRelease', &__cuUserObjectRelease, 11030, ptds_mode, NULL) + cuGetProcAddress_v2('cuUserObjectRelease', &__cuUserObjectRelease, 11030, ptds_mode, NULL) global __cuGraphRetainUserObject - _F_cuGetProcAddress_v2('cuGraphRetainUserObject', &__cuGraphRetainUserObject, 11030, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphRetainUserObject', &__cuGraphRetainUserObject, 11030, ptds_mode, NULL) global __cuGraphReleaseUserObject - _F_cuGetProcAddress_v2('cuGraphReleaseUserObject', &__cuGraphReleaseUserObject, 11030, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphReleaseUserObject', &__cuGraphReleaseUserObject, 11030, ptds_mode, NULL) global __cuGraphAddNode_v2 - _F_cuGetProcAddress_v2('cuGraphAddNode', &__cuGraphAddNode_v2, 12030, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphAddNode', &__cuGraphAddNode_v2, 12030, ptds_mode, NULL) global __cuGraphNodeSetParams - _F_cuGetProcAddress_v2('cuGraphNodeSetParams', &__cuGraphNodeSetParams, 12020, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphNodeSetParams', &__cuGraphNodeSetParams, 12020, ptds_mode, NULL) global __cuGraphExecNodeSetParams - _F_cuGetProcAddress_v2('cuGraphExecNodeSetParams', &__cuGraphExecNodeSetParams, 12020, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphExecNodeSetParams', &__cuGraphExecNodeSetParams, 12020, ptds_mode, NULL) global __cuGraphConditionalHandleCreate - _F_cuGetProcAddress_v2('cuGraphConditionalHandleCreate', &__cuGraphConditionalHandleCreate, 12030, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphConditionalHandleCreate', &__cuGraphConditionalHandleCreate, 12030, ptds_mode, NULL) global __cuOccupancyMaxActiveBlocksPerMultiprocessor - _F_cuGetProcAddress_v2('cuOccupancyMaxActiveBlocksPerMultiprocessor', &__cuOccupancyMaxActiveBlocksPerMultiprocessor, 6050, ptds_mode, NULL) + cuGetProcAddress_v2('cuOccupancyMaxActiveBlocksPerMultiprocessor', &__cuOccupancyMaxActiveBlocksPerMultiprocessor, 6050, ptds_mode, NULL) global __cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags - _F_cuGetProcAddress_v2('cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags', &__cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags, 7000, ptds_mode, NULL) + cuGetProcAddress_v2('cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags', &__cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags, 7000, ptds_mode, NULL) global __cuOccupancyMaxPotentialBlockSize - _F_cuGetProcAddress_v2('cuOccupancyMaxPotentialBlockSize', &__cuOccupancyMaxPotentialBlockSize, 6050, ptds_mode, NULL) + cuGetProcAddress_v2('cuOccupancyMaxPotentialBlockSize', &__cuOccupancyMaxPotentialBlockSize, 6050, ptds_mode, NULL) global __cuOccupancyMaxPotentialBlockSizeWithFlags - _F_cuGetProcAddress_v2('cuOccupancyMaxPotentialBlockSizeWithFlags', &__cuOccupancyMaxPotentialBlockSizeWithFlags, 7000, ptds_mode, NULL) + cuGetProcAddress_v2('cuOccupancyMaxPotentialBlockSizeWithFlags', &__cuOccupancyMaxPotentialBlockSizeWithFlags, 7000, ptds_mode, NULL) global __cuOccupancyAvailableDynamicSMemPerBlock - _F_cuGetProcAddress_v2('cuOccupancyAvailableDynamicSMemPerBlock', &__cuOccupancyAvailableDynamicSMemPerBlock, 10020, ptds_mode, NULL) + cuGetProcAddress_v2('cuOccupancyAvailableDynamicSMemPerBlock', &__cuOccupancyAvailableDynamicSMemPerBlock, 10020, ptds_mode, NULL) global __cuOccupancyMaxPotentialClusterSize - _F_cuGetProcAddress_v2('cuOccupancyMaxPotentialClusterSize', &__cuOccupancyMaxPotentialClusterSize, 11070, ptds_mode, NULL) + cuGetProcAddress_v2('cuOccupancyMaxPotentialClusterSize', &__cuOccupancyMaxPotentialClusterSize, 11070, ptds_mode, NULL) global __cuOccupancyMaxActiveClusters - _F_cuGetProcAddress_v2('cuOccupancyMaxActiveClusters', &__cuOccupancyMaxActiveClusters, 11070, ptds_mode, NULL) + cuGetProcAddress_v2('cuOccupancyMaxActiveClusters', &__cuOccupancyMaxActiveClusters, 11070, ptds_mode, NULL) global __cuTexRefSetArray - _F_cuGetProcAddress_v2('cuTexRefSetArray', &__cuTexRefSetArray, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefSetArray', &__cuTexRefSetArray, 2000, ptds_mode, NULL) global __cuTexRefSetMipmappedArray - _F_cuGetProcAddress_v2('cuTexRefSetMipmappedArray', &__cuTexRefSetMipmappedArray, 5000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefSetMipmappedArray', &__cuTexRefSetMipmappedArray, 5000, ptds_mode, NULL) global __cuTexRefSetAddress_v2 - _F_cuGetProcAddress_v2('cuTexRefSetAddress', &__cuTexRefSetAddress_v2, 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefSetAddress', &__cuTexRefSetAddress_v2, 3020, ptds_mode, NULL) global __cuTexRefSetAddress2D_v3 - _F_cuGetProcAddress_v2('cuTexRefSetAddress2D', &__cuTexRefSetAddress2D_v3, 4010, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefSetAddress2D', &__cuTexRefSetAddress2D_v3, 4010, ptds_mode, NULL) global __cuTexRefSetFormat - _F_cuGetProcAddress_v2('cuTexRefSetFormat', &__cuTexRefSetFormat, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefSetFormat', &__cuTexRefSetFormat, 2000, ptds_mode, NULL) global __cuTexRefSetAddressMode - _F_cuGetProcAddress_v2('cuTexRefSetAddressMode', &__cuTexRefSetAddressMode, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefSetAddressMode', &__cuTexRefSetAddressMode, 2000, ptds_mode, NULL) global __cuTexRefSetFilterMode - _F_cuGetProcAddress_v2('cuTexRefSetFilterMode', &__cuTexRefSetFilterMode, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefSetFilterMode', &__cuTexRefSetFilterMode, 2000, ptds_mode, NULL) global __cuTexRefSetMipmapFilterMode - _F_cuGetProcAddress_v2('cuTexRefSetMipmapFilterMode', &__cuTexRefSetMipmapFilterMode, 5000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefSetMipmapFilterMode', &__cuTexRefSetMipmapFilterMode, 5000, ptds_mode, NULL) global __cuTexRefSetMipmapLevelBias - _F_cuGetProcAddress_v2('cuTexRefSetMipmapLevelBias', &__cuTexRefSetMipmapLevelBias, 5000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefSetMipmapLevelBias', &__cuTexRefSetMipmapLevelBias, 5000, ptds_mode, NULL) global __cuTexRefSetMipmapLevelClamp - _F_cuGetProcAddress_v2('cuTexRefSetMipmapLevelClamp', &__cuTexRefSetMipmapLevelClamp, 5000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefSetMipmapLevelClamp', &__cuTexRefSetMipmapLevelClamp, 5000, ptds_mode, NULL) global __cuTexRefSetMaxAnisotropy - _F_cuGetProcAddress_v2('cuTexRefSetMaxAnisotropy', &__cuTexRefSetMaxAnisotropy, 5000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefSetMaxAnisotropy', &__cuTexRefSetMaxAnisotropy, 5000, ptds_mode, NULL) global __cuTexRefSetBorderColor - _F_cuGetProcAddress_v2('cuTexRefSetBorderColor', &__cuTexRefSetBorderColor, 8000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefSetBorderColor', &__cuTexRefSetBorderColor, 8000, ptds_mode, NULL) global __cuTexRefSetFlags - _F_cuGetProcAddress_v2('cuTexRefSetFlags', &__cuTexRefSetFlags, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefSetFlags', &__cuTexRefSetFlags, 2000, ptds_mode, NULL) global __cuTexRefGetAddress_v2 - _F_cuGetProcAddress_v2('cuTexRefGetAddress', &__cuTexRefGetAddress_v2, 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefGetAddress', &__cuTexRefGetAddress_v2, 3020, ptds_mode, NULL) global __cuTexRefGetArray - _F_cuGetProcAddress_v2('cuTexRefGetArray', &__cuTexRefGetArray, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefGetArray', &__cuTexRefGetArray, 2000, ptds_mode, NULL) global __cuTexRefGetMipmappedArray - _F_cuGetProcAddress_v2('cuTexRefGetMipmappedArray', &__cuTexRefGetMipmappedArray, 5000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefGetMipmappedArray', &__cuTexRefGetMipmappedArray, 5000, ptds_mode, NULL) global __cuTexRefGetAddressMode - _F_cuGetProcAddress_v2('cuTexRefGetAddressMode', &__cuTexRefGetAddressMode, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefGetAddressMode', &__cuTexRefGetAddressMode, 2000, ptds_mode, NULL) global __cuTexRefGetFilterMode - _F_cuGetProcAddress_v2('cuTexRefGetFilterMode', &__cuTexRefGetFilterMode, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefGetFilterMode', &__cuTexRefGetFilterMode, 2000, ptds_mode, NULL) global __cuTexRefGetFormat - _F_cuGetProcAddress_v2('cuTexRefGetFormat', &__cuTexRefGetFormat, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefGetFormat', &__cuTexRefGetFormat, 2000, ptds_mode, NULL) global __cuTexRefGetMipmapFilterMode - _F_cuGetProcAddress_v2('cuTexRefGetMipmapFilterMode', &__cuTexRefGetMipmapFilterMode, 5000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefGetMipmapFilterMode', &__cuTexRefGetMipmapFilterMode, 5000, ptds_mode, NULL) global __cuTexRefGetMipmapLevelBias - _F_cuGetProcAddress_v2('cuTexRefGetMipmapLevelBias', &__cuTexRefGetMipmapLevelBias, 5000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefGetMipmapLevelBias', &__cuTexRefGetMipmapLevelBias, 5000, ptds_mode, NULL) global __cuTexRefGetMipmapLevelClamp - _F_cuGetProcAddress_v2('cuTexRefGetMipmapLevelClamp', &__cuTexRefGetMipmapLevelClamp, 5000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefGetMipmapLevelClamp', &__cuTexRefGetMipmapLevelClamp, 5000, ptds_mode, NULL) global __cuTexRefGetMaxAnisotropy - _F_cuGetProcAddress_v2('cuTexRefGetMaxAnisotropy', &__cuTexRefGetMaxAnisotropy, 5000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefGetMaxAnisotropy', &__cuTexRefGetMaxAnisotropy, 5000, ptds_mode, NULL) global __cuTexRefGetBorderColor - _F_cuGetProcAddress_v2('cuTexRefGetBorderColor', &__cuTexRefGetBorderColor, 8000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefGetBorderColor', &__cuTexRefGetBorderColor, 8000, ptds_mode, NULL) global __cuTexRefGetFlags - _F_cuGetProcAddress_v2('cuTexRefGetFlags', &__cuTexRefGetFlags, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefGetFlags', &__cuTexRefGetFlags, 2000, ptds_mode, NULL) global __cuTexRefCreate - _F_cuGetProcAddress_v2('cuTexRefCreate', &__cuTexRefCreate, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefCreate', &__cuTexRefCreate, 2000, ptds_mode, NULL) global __cuTexRefDestroy - _F_cuGetProcAddress_v2('cuTexRefDestroy', &__cuTexRefDestroy, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexRefDestroy', &__cuTexRefDestroy, 2000, ptds_mode, NULL) global __cuSurfRefSetArray - _F_cuGetProcAddress_v2('cuSurfRefSetArray', &__cuSurfRefSetArray, 3000, ptds_mode, NULL) + cuGetProcAddress_v2('cuSurfRefSetArray', &__cuSurfRefSetArray, 3000, ptds_mode, NULL) global __cuSurfRefGetArray - _F_cuGetProcAddress_v2('cuSurfRefGetArray', &__cuSurfRefGetArray, 3000, ptds_mode, NULL) + cuGetProcAddress_v2('cuSurfRefGetArray', &__cuSurfRefGetArray, 3000, ptds_mode, NULL) global __cuTexObjectCreate - _F_cuGetProcAddress_v2('cuTexObjectCreate', &__cuTexObjectCreate, 5000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexObjectCreate', &__cuTexObjectCreate, 5000, ptds_mode, NULL) global __cuTexObjectDestroy - _F_cuGetProcAddress_v2('cuTexObjectDestroy', &__cuTexObjectDestroy, 5000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexObjectDestroy', &__cuTexObjectDestroy, 5000, ptds_mode, NULL) global __cuTexObjectGetResourceDesc - _F_cuGetProcAddress_v2('cuTexObjectGetResourceDesc', &__cuTexObjectGetResourceDesc, 5000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexObjectGetResourceDesc', &__cuTexObjectGetResourceDesc, 5000, ptds_mode, NULL) global __cuTexObjectGetTextureDesc - _F_cuGetProcAddress_v2('cuTexObjectGetTextureDesc', &__cuTexObjectGetTextureDesc, 5000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexObjectGetTextureDesc', &__cuTexObjectGetTextureDesc, 5000, ptds_mode, NULL) global __cuTexObjectGetResourceViewDesc - _F_cuGetProcAddress_v2('cuTexObjectGetResourceViewDesc', &__cuTexObjectGetResourceViewDesc, 5000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTexObjectGetResourceViewDesc', &__cuTexObjectGetResourceViewDesc, 5000, ptds_mode, NULL) global __cuSurfObjectCreate - _F_cuGetProcAddress_v2('cuSurfObjectCreate', &__cuSurfObjectCreate, 5000, ptds_mode, NULL) + cuGetProcAddress_v2('cuSurfObjectCreate', &__cuSurfObjectCreate, 5000, ptds_mode, NULL) global __cuSurfObjectDestroy - _F_cuGetProcAddress_v2('cuSurfObjectDestroy', &__cuSurfObjectDestroy, 5000, ptds_mode, NULL) + cuGetProcAddress_v2('cuSurfObjectDestroy', &__cuSurfObjectDestroy, 5000, ptds_mode, NULL) global __cuSurfObjectGetResourceDesc - _F_cuGetProcAddress_v2('cuSurfObjectGetResourceDesc', &__cuSurfObjectGetResourceDesc, 5000, ptds_mode, NULL) + cuGetProcAddress_v2('cuSurfObjectGetResourceDesc', &__cuSurfObjectGetResourceDesc, 5000, ptds_mode, NULL) global __cuTensorMapEncodeTiled - _F_cuGetProcAddress_v2('cuTensorMapEncodeTiled', &__cuTensorMapEncodeTiled, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTensorMapEncodeTiled', &__cuTensorMapEncodeTiled, 12000, ptds_mode, NULL) global __cuTensorMapEncodeIm2col - _F_cuGetProcAddress_v2('cuTensorMapEncodeIm2col', &__cuTensorMapEncodeIm2col, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTensorMapEncodeIm2col', &__cuTensorMapEncodeIm2col, 12000, ptds_mode, NULL) global __cuTensorMapEncodeIm2colWide - _F_cuGetProcAddress_v2('cuTensorMapEncodeIm2colWide', &__cuTensorMapEncodeIm2colWide, 12080, ptds_mode, NULL) + cuGetProcAddress_v2('cuTensorMapEncodeIm2colWide', &__cuTensorMapEncodeIm2colWide, 12080, ptds_mode, NULL) global __cuTensorMapReplaceAddress - _F_cuGetProcAddress_v2('cuTensorMapReplaceAddress', &__cuTensorMapReplaceAddress, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuTensorMapReplaceAddress', &__cuTensorMapReplaceAddress, 12000, ptds_mode, NULL) global __cuDeviceCanAccessPeer - _F_cuGetProcAddress_v2('cuDeviceCanAccessPeer', &__cuDeviceCanAccessPeer, 4000, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceCanAccessPeer', &__cuDeviceCanAccessPeer, 4000, ptds_mode, NULL) global __cuCtxEnablePeerAccess - _F_cuGetProcAddress_v2('cuCtxEnablePeerAccess', &__cuCtxEnablePeerAccess, 4000, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxEnablePeerAccess', &__cuCtxEnablePeerAccess, 4000, ptds_mode, NULL) global __cuCtxDisablePeerAccess - _F_cuGetProcAddress_v2('cuCtxDisablePeerAccess', &__cuCtxDisablePeerAccess, 4000, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxDisablePeerAccess', &__cuCtxDisablePeerAccess, 4000, ptds_mode, NULL) global __cuDeviceGetP2PAttribute - _F_cuGetProcAddress_v2('cuDeviceGetP2PAttribute', &__cuDeviceGetP2PAttribute, 8000, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceGetP2PAttribute', &__cuDeviceGetP2PAttribute, 8000, ptds_mode, NULL) global __cuGraphicsUnregisterResource - _F_cuGetProcAddress_v2('cuGraphicsUnregisterResource', &__cuGraphicsUnregisterResource, 3000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphicsUnregisterResource', &__cuGraphicsUnregisterResource, 3000, ptds_mode, NULL) global __cuGraphicsSubResourceGetMappedArray - _F_cuGetProcAddress_v2('cuGraphicsSubResourceGetMappedArray', &__cuGraphicsSubResourceGetMappedArray, 3000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphicsSubResourceGetMappedArray', &__cuGraphicsSubResourceGetMappedArray, 3000, ptds_mode, NULL) global __cuGraphicsResourceGetMappedMipmappedArray - _F_cuGetProcAddress_v2('cuGraphicsResourceGetMappedMipmappedArray', &__cuGraphicsResourceGetMappedMipmappedArray, 5000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphicsResourceGetMappedMipmappedArray', &__cuGraphicsResourceGetMappedMipmappedArray, 5000, ptds_mode, NULL) global __cuGraphicsResourceGetMappedPointer_v2 - _F_cuGetProcAddress_v2('cuGraphicsResourceGetMappedPointer', &__cuGraphicsResourceGetMappedPointer_v2, 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphicsResourceGetMappedPointer', &__cuGraphicsResourceGetMappedPointer_v2, 3020, ptds_mode, NULL) global __cuGraphicsResourceSetMapFlags_v2 - _F_cuGetProcAddress_v2('cuGraphicsResourceSetMapFlags', &__cuGraphicsResourceSetMapFlags_v2, 6050, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphicsResourceSetMapFlags', &__cuGraphicsResourceSetMapFlags_v2, 6050, ptds_mode, NULL) global __cuGraphicsMapResources - _F_cuGetProcAddress_v2('cuGraphicsMapResources', &__cuGraphicsMapResources, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphicsMapResources', &__cuGraphicsMapResources, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3000, ptds_mode, NULL) global __cuGraphicsUnmapResources - _F_cuGetProcAddress_v2('cuGraphicsUnmapResources', &__cuGraphicsUnmapResources, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphicsUnmapResources', &__cuGraphicsUnmapResources, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3000, ptds_mode, NULL) global __cuGetProcAddress_v2 - _F_cuGetProcAddress_v2('cuGetProcAddress', &__cuGetProcAddress_v2, 12000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGetProcAddress', &__cuGetProcAddress_v2, 12000, ptds_mode, NULL) global __cuCoredumpGetAttribute - _F_cuGetProcAddress_v2('cuCoredumpGetAttribute', &__cuCoredumpGetAttribute, 12010, ptds_mode, NULL) + cuGetProcAddress_v2('cuCoredumpGetAttribute', &__cuCoredumpGetAttribute, 12010, ptds_mode, NULL) global __cuCoredumpGetAttributeGlobal - _F_cuGetProcAddress_v2('cuCoredumpGetAttributeGlobal', &__cuCoredumpGetAttributeGlobal, 12010, ptds_mode, NULL) + cuGetProcAddress_v2('cuCoredumpGetAttributeGlobal', &__cuCoredumpGetAttributeGlobal, 12010, ptds_mode, NULL) global __cuCoredumpSetAttribute - _F_cuGetProcAddress_v2('cuCoredumpSetAttribute', &__cuCoredumpSetAttribute, 12010, ptds_mode, NULL) + cuGetProcAddress_v2('cuCoredumpSetAttribute', &__cuCoredumpSetAttribute, 12010, ptds_mode, NULL) global __cuCoredumpSetAttributeGlobal - _F_cuGetProcAddress_v2('cuCoredumpSetAttributeGlobal', &__cuCoredumpSetAttributeGlobal, 12010, ptds_mode, NULL) + cuGetProcAddress_v2('cuCoredumpSetAttributeGlobal', &__cuCoredumpSetAttributeGlobal, 12010, ptds_mode, NULL) global __cuGetExportTable - _F_cuGetProcAddress_v2('cuGetExportTable', &__cuGetExportTable, 3000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGetExportTable', &__cuGetExportTable, 3000, ptds_mode, NULL) global __cuGreenCtxCreate - _F_cuGetProcAddress_v2('cuGreenCtxCreate', &__cuGreenCtxCreate, 12040, ptds_mode, NULL) + cuGetProcAddress_v2('cuGreenCtxCreate', &__cuGreenCtxCreate, 12040, ptds_mode, NULL) global __cuGreenCtxDestroy - _F_cuGetProcAddress_v2('cuGreenCtxDestroy', &__cuGreenCtxDestroy, 12040, ptds_mode, NULL) + cuGetProcAddress_v2('cuGreenCtxDestroy', &__cuGreenCtxDestroy, 12040, ptds_mode, NULL) global __cuCtxFromGreenCtx - _F_cuGetProcAddress_v2('cuCtxFromGreenCtx', &__cuCtxFromGreenCtx, 12040, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxFromGreenCtx', &__cuCtxFromGreenCtx, 12040, ptds_mode, NULL) global __cuDeviceGetDevResource - _F_cuGetProcAddress_v2('cuDeviceGetDevResource', &__cuDeviceGetDevResource, 12040, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceGetDevResource', &__cuDeviceGetDevResource, 12040, ptds_mode, NULL) global __cuCtxGetDevResource - _F_cuGetProcAddress_v2('cuCtxGetDevResource', &__cuCtxGetDevResource, 12040, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxGetDevResource', &__cuCtxGetDevResource, 12040, ptds_mode, NULL) global __cuGreenCtxGetDevResource - _F_cuGetProcAddress_v2('cuGreenCtxGetDevResource', &__cuGreenCtxGetDevResource, 12040, ptds_mode, NULL) + cuGetProcAddress_v2('cuGreenCtxGetDevResource', &__cuGreenCtxGetDevResource, 12040, ptds_mode, NULL) global __cuDevSmResourceSplitByCount - _F_cuGetProcAddress_v2('cuDevSmResourceSplitByCount', &__cuDevSmResourceSplitByCount, 12040, ptds_mode, NULL) + cuGetProcAddress_v2('cuDevSmResourceSplitByCount', &__cuDevSmResourceSplitByCount, 12040, ptds_mode, NULL) global __cuDevResourceGenerateDesc - _F_cuGetProcAddress_v2('cuDevResourceGenerateDesc', &__cuDevResourceGenerateDesc, 12040, ptds_mode, NULL) + cuGetProcAddress_v2('cuDevResourceGenerateDesc', &__cuDevResourceGenerateDesc, 12040, ptds_mode, NULL) global __cuGreenCtxRecordEvent - _F_cuGetProcAddress_v2('cuGreenCtxRecordEvent', &__cuGreenCtxRecordEvent, 12040, ptds_mode, NULL) + cuGetProcAddress_v2('cuGreenCtxRecordEvent', &__cuGreenCtxRecordEvent, 12040, ptds_mode, NULL) global __cuGreenCtxWaitEvent - _F_cuGetProcAddress_v2('cuGreenCtxWaitEvent', &__cuGreenCtxWaitEvent, 12040, ptds_mode, NULL) + cuGetProcAddress_v2('cuGreenCtxWaitEvent', &__cuGreenCtxWaitEvent, 12040, ptds_mode, NULL) global __cuStreamGetGreenCtx - _F_cuGetProcAddress_v2('cuStreamGetGreenCtx', &__cuStreamGetGreenCtx, 12040, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamGetGreenCtx', &__cuStreamGetGreenCtx, 12040, ptds_mode, NULL) global __cuGreenCtxStreamCreate - _F_cuGetProcAddress_v2('cuGreenCtxStreamCreate', &__cuGreenCtxStreamCreate, 12050, ptds_mode, NULL) + cuGetProcAddress_v2('cuGreenCtxStreamCreate', &__cuGreenCtxStreamCreate, 12050, ptds_mode, NULL) global __cuLogsRegisterCallback - _F_cuGetProcAddress_v2('cuLogsRegisterCallback', &__cuLogsRegisterCallback, 12080, ptds_mode, NULL) + cuGetProcAddress_v2('cuLogsRegisterCallback', &__cuLogsRegisterCallback, 12080, ptds_mode, NULL) global __cuLogsUnregisterCallback - _F_cuGetProcAddress_v2('cuLogsUnregisterCallback', &__cuLogsUnregisterCallback, 12080, ptds_mode, NULL) + cuGetProcAddress_v2('cuLogsUnregisterCallback', &__cuLogsUnregisterCallback, 12080, ptds_mode, NULL) global __cuLogsCurrent - _F_cuGetProcAddress_v2('cuLogsCurrent', &__cuLogsCurrent, 12080, ptds_mode, NULL) + cuGetProcAddress_v2('cuLogsCurrent', &__cuLogsCurrent, 12080, ptds_mode, NULL) global __cuLogsDumpToFile - _F_cuGetProcAddress_v2('cuLogsDumpToFile', &__cuLogsDumpToFile, 12080, ptds_mode, NULL) + cuGetProcAddress_v2('cuLogsDumpToFile', &__cuLogsDumpToFile, 12080, ptds_mode, NULL) global __cuLogsDumpToMemory - _F_cuGetProcAddress_v2('cuLogsDumpToMemory', &__cuLogsDumpToMemory, 12080, ptds_mode, NULL) + cuGetProcAddress_v2('cuLogsDumpToMemory', &__cuLogsDumpToMemory, 12080, ptds_mode, NULL) global __cuCheckpointProcessGetRestoreThreadId - _F_cuGetProcAddress_v2('cuCheckpointProcessGetRestoreThreadId', &__cuCheckpointProcessGetRestoreThreadId, 12080, ptds_mode, NULL) + cuGetProcAddress_v2('cuCheckpointProcessGetRestoreThreadId', &__cuCheckpointProcessGetRestoreThreadId, 12080, ptds_mode, NULL) global __cuCheckpointProcessGetState - _F_cuGetProcAddress_v2('cuCheckpointProcessGetState', &__cuCheckpointProcessGetState, 12080, ptds_mode, NULL) + cuGetProcAddress_v2('cuCheckpointProcessGetState', &__cuCheckpointProcessGetState, 12080, ptds_mode, NULL) global __cuCheckpointProcessLock - _F_cuGetProcAddress_v2('cuCheckpointProcessLock', &__cuCheckpointProcessLock, 12080, ptds_mode, NULL) + cuGetProcAddress_v2('cuCheckpointProcessLock', &__cuCheckpointProcessLock, 12080, ptds_mode, NULL) global __cuCheckpointProcessCheckpoint - _F_cuGetProcAddress_v2('cuCheckpointProcessCheckpoint', &__cuCheckpointProcessCheckpoint, 12080, ptds_mode, NULL) + cuGetProcAddress_v2('cuCheckpointProcessCheckpoint', &__cuCheckpointProcessCheckpoint, 12080, ptds_mode, NULL) global __cuCheckpointProcessRestore - _F_cuGetProcAddress_v2('cuCheckpointProcessRestore', &__cuCheckpointProcessRestore, 12080, ptds_mode, NULL) + cuGetProcAddress_v2('cuCheckpointProcessRestore', &__cuCheckpointProcessRestore, 12080, ptds_mode, NULL) global __cuCheckpointProcessUnlock - _F_cuGetProcAddress_v2('cuCheckpointProcessUnlock', &__cuCheckpointProcessUnlock, 12080, ptds_mode, NULL) + cuGetProcAddress_v2('cuCheckpointProcessUnlock', &__cuCheckpointProcessUnlock, 12080, ptds_mode, NULL) global __cuGraphicsEGLRegisterImage - _F_cuGetProcAddress_v2('cuGraphicsEGLRegisterImage', &__cuGraphicsEGLRegisterImage, 7000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphicsEGLRegisterImage', &__cuGraphicsEGLRegisterImage, 7000, ptds_mode, NULL) global __cuEGLStreamConsumerConnect - _F_cuGetProcAddress_v2('cuEGLStreamConsumerConnect', &__cuEGLStreamConsumerConnect, 7000, ptds_mode, NULL) + cuGetProcAddress_v2('cuEGLStreamConsumerConnect', &__cuEGLStreamConsumerConnect, 7000, ptds_mode, NULL) global __cuEGLStreamConsumerConnectWithFlags - _F_cuGetProcAddress_v2('cuEGLStreamConsumerConnectWithFlags', &__cuEGLStreamConsumerConnectWithFlags, 8000, ptds_mode, NULL) + cuGetProcAddress_v2('cuEGLStreamConsumerConnectWithFlags', &__cuEGLStreamConsumerConnectWithFlags, 8000, ptds_mode, NULL) global __cuEGLStreamConsumerDisconnect - _F_cuGetProcAddress_v2('cuEGLStreamConsumerDisconnect', &__cuEGLStreamConsumerDisconnect, 7000, ptds_mode, NULL) + cuGetProcAddress_v2('cuEGLStreamConsumerDisconnect', &__cuEGLStreamConsumerDisconnect, 7000, ptds_mode, NULL) global __cuEGLStreamConsumerAcquireFrame - _F_cuGetProcAddress_v2('cuEGLStreamConsumerAcquireFrame', &__cuEGLStreamConsumerAcquireFrame, 7000, ptds_mode, NULL) + cuGetProcAddress_v2('cuEGLStreamConsumerAcquireFrame', &__cuEGLStreamConsumerAcquireFrame, 7000, ptds_mode, NULL) global __cuEGLStreamConsumerReleaseFrame - _F_cuGetProcAddress_v2('cuEGLStreamConsumerReleaseFrame', &__cuEGLStreamConsumerReleaseFrame, 7000, ptds_mode, NULL) + cuGetProcAddress_v2('cuEGLStreamConsumerReleaseFrame', &__cuEGLStreamConsumerReleaseFrame, 7000, ptds_mode, NULL) global __cuEGLStreamProducerConnect - _F_cuGetProcAddress_v2('cuEGLStreamProducerConnect', &__cuEGLStreamProducerConnect, 7000, ptds_mode, NULL) + cuGetProcAddress_v2('cuEGLStreamProducerConnect', &__cuEGLStreamProducerConnect, 7000, ptds_mode, NULL) global __cuEGLStreamProducerDisconnect - _F_cuGetProcAddress_v2('cuEGLStreamProducerDisconnect', &__cuEGLStreamProducerDisconnect, 7000, ptds_mode, NULL) + cuGetProcAddress_v2('cuEGLStreamProducerDisconnect', &__cuEGLStreamProducerDisconnect, 7000, ptds_mode, NULL) global __cuEGLStreamProducerPresentFrame - _F_cuGetProcAddress_v2('cuEGLStreamProducerPresentFrame', &__cuEGLStreamProducerPresentFrame, 7000, ptds_mode, NULL) + cuGetProcAddress_v2('cuEGLStreamProducerPresentFrame', &__cuEGLStreamProducerPresentFrame, 7000, ptds_mode, NULL) global __cuEGLStreamProducerReturnFrame - _F_cuGetProcAddress_v2('cuEGLStreamProducerReturnFrame', &__cuEGLStreamProducerReturnFrame, 7000, ptds_mode, NULL) + cuGetProcAddress_v2('cuEGLStreamProducerReturnFrame', &__cuEGLStreamProducerReturnFrame, 7000, ptds_mode, NULL) global __cuGraphicsResourceGetMappedEglFrame - _F_cuGetProcAddress_v2('cuGraphicsResourceGetMappedEglFrame', &__cuGraphicsResourceGetMappedEglFrame, 7000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphicsResourceGetMappedEglFrame', &__cuGraphicsResourceGetMappedEglFrame, 7000, ptds_mode, NULL) global __cuEventCreateFromEGLSync - _F_cuGetProcAddress_v2('cuEventCreateFromEGLSync', &__cuEventCreateFromEGLSync, 9000, ptds_mode, NULL) + cuGetProcAddress_v2('cuEventCreateFromEGLSync', &__cuEventCreateFromEGLSync, 9000, ptds_mode, NULL) global __cuGraphicsGLRegisterBuffer - _F_cuGetProcAddress_v2('cuGraphicsGLRegisterBuffer', &__cuGraphicsGLRegisterBuffer, 3000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphicsGLRegisterBuffer', &__cuGraphicsGLRegisterBuffer, 3000, ptds_mode, NULL) global __cuGraphicsGLRegisterImage - _F_cuGetProcAddress_v2('cuGraphicsGLRegisterImage', &__cuGraphicsGLRegisterImage, 3000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphicsGLRegisterImage', &__cuGraphicsGLRegisterImage, 3000, ptds_mode, NULL) global __cuGLGetDevices_v2 - _F_cuGetProcAddress_v2('cuGLGetDevices', &__cuGLGetDevices_v2, 6050, ptds_mode, NULL) + cuGetProcAddress_v2('cuGLGetDevices', &__cuGLGetDevices_v2, 6050, ptds_mode, NULL) global __cuGLCtxCreate_v2 - _F_cuGetProcAddress_v2('cuGLCtxCreate', &__cuGLCtxCreate_v2, 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuGLCtxCreate', &__cuGLCtxCreate_v2, 3020, ptds_mode, NULL) global __cuGLInit - _F_cuGetProcAddress_v2('cuGLInit', &__cuGLInit, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGLInit', &__cuGLInit, 2000, ptds_mode, NULL) global __cuGLRegisterBufferObject - _F_cuGetProcAddress_v2('cuGLRegisterBufferObject', &__cuGLRegisterBufferObject, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGLRegisterBufferObject', &__cuGLRegisterBufferObject, 2000, ptds_mode, NULL) global __cuGLMapBufferObject_v2 - _F_cuGetProcAddress_v2('cuGLMapBufferObject', &__cuGLMapBufferObject_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuGLMapBufferObject', &__cuGLMapBufferObject_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuGLUnmapBufferObject - _F_cuGetProcAddress_v2('cuGLUnmapBufferObject', &__cuGLUnmapBufferObject, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGLUnmapBufferObject', &__cuGLUnmapBufferObject, 2000, ptds_mode, NULL) global __cuGLUnregisterBufferObject - _F_cuGetProcAddress_v2('cuGLUnregisterBufferObject', &__cuGLUnregisterBufferObject, 2000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGLUnregisterBufferObject', &__cuGLUnregisterBufferObject, 2000, ptds_mode, NULL) global __cuGLSetBufferObjectMapFlags - _F_cuGetProcAddress_v2('cuGLSetBufferObjectMapFlags', &__cuGLSetBufferObjectMapFlags, 2030, ptds_mode, NULL) + cuGetProcAddress_v2('cuGLSetBufferObjectMapFlags', &__cuGLSetBufferObjectMapFlags, 2030, ptds_mode, NULL) global __cuGLMapBufferObjectAsync_v2 - _F_cuGetProcAddress_v2('cuGLMapBufferObjectAsync', &__cuGLMapBufferObjectAsync_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuGLMapBufferObjectAsync', &__cuGLMapBufferObjectAsync_v2, 7000 if ptds_mode == CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM else 3020, ptds_mode, NULL) global __cuGLUnmapBufferObjectAsync - _F_cuGetProcAddress_v2('cuGLUnmapBufferObjectAsync', &__cuGLUnmapBufferObjectAsync, 2030, ptds_mode, NULL) + cuGetProcAddress_v2('cuGLUnmapBufferObjectAsync', &__cuGLUnmapBufferObjectAsync, 2030, ptds_mode, NULL) global __cuProfilerInitialize - _F_cuGetProcAddress_v2('cuProfilerInitialize', &__cuProfilerInitialize, 4000, ptds_mode, NULL) + cuGetProcAddress_v2('cuProfilerInitialize', &__cuProfilerInitialize, 4000, ptds_mode, NULL) global __cuProfilerStart - _F_cuGetProcAddress_v2('cuProfilerStart', &__cuProfilerStart, 4000, ptds_mode, NULL) + cuGetProcAddress_v2('cuProfilerStart', &__cuProfilerStart, 4000, ptds_mode, NULL) global __cuProfilerStop - _F_cuGetProcAddress_v2('cuProfilerStop', &__cuProfilerStop, 4000, ptds_mode, NULL) + cuGetProcAddress_v2('cuProfilerStop', &__cuProfilerStop, 4000, ptds_mode, NULL) global __cuVDPAUGetDevice - _F_cuGetProcAddress_v2('cuVDPAUGetDevice', &__cuVDPAUGetDevice, 3010, ptds_mode, NULL) + cuGetProcAddress_v2('cuVDPAUGetDevice', &__cuVDPAUGetDevice, 3010, ptds_mode, NULL) global __cuVDPAUCtxCreate_v2 - _F_cuGetProcAddress_v2('cuVDPAUCtxCreate', &__cuVDPAUCtxCreate_v2, 3020, ptds_mode, NULL) + cuGetProcAddress_v2('cuVDPAUCtxCreate', &__cuVDPAUCtxCreate_v2, 3020, ptds_mode, NULL) global __cuGraphicsVDPAURegisterVideoSurface - _F_cuGetProcAddress_v2('cuGraphicsVDPAURegisterVideoSurface', &__cuGraphicsVDPAURegisterVideoSurface, 3010, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphicsVDPAURegisterVideoSurface', &__cuGraphicsVDPAURegisterVideoSurface, 3010, ptds_mode, NULL) global __cuGraphicsVDPAURegisterOutputSurface - _F_cuGetProcAddress_v2('cuGraphicsVDPAURegisterOutputSurface', &__cuGraphicsVDPAURegisterOutputSurface, 3010, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphicsVDPAURegisterOutputSurface', &__cuGraphicsVDPAURegisterOutputSurface, 3010, ptds_mode, NULL) global __cuDeviceGetHostAtomicCapabilities - _F_cuGetProcAddress_v2('cuDeviceGetHostAtomicCapabilities', &__cuDeviceGetHostAtomicCapabilities, 13000, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceGetHostAtomicCapabilities', &__cuDeviceGetHostAtomicCapabilities, 13000, ptds_mode, NULL) global __cuCtxGetDevice_v2 - _F_cuGetProcAddress_v2('cuCtxGetDevice', &__cuCtxGetDevice_v2, 13000, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxGetDevice', &__cuCtxGetDevice_v2, 13000, ptds_mode, NULL) global __cuCtxSynchronize_v2 - _F_cuGetProcAddress_v2('cuCtxSynchronize', &__cuCtxSynchronize_v2, 13000, ptds_mode, NULL) + cuGetProcAddress_v2('cuCtxSynchronize', &__cuCtxSynchronize_v2, 13000, ptds_mode, NULL) global __cuMemcpyBatchAsync_v2 - _F_cuGetProcAddress_v2('cuMemcpyBatchAsync', &__cuMemcpyBatchAsync_v2, 13000, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpyBatchAsync', &__cuMemcpyBatchAsync_v2, 13000, ptds_mode, NULL) global __cuMemcpy3DBatchAsync_v2 - _F_cuGetProcAddress_v2('cuMemcpy3DBatchAsync', &__cuMemcpy3DBatchAsync_v2, 13000, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpy3DBatchAsync', &__cuMemcpy3DBatchAsync_v2, 13000, ptds_mode, NULL) global __cuMemGetDefaultMemPool - _F_cuGetProcAddress_v2('cuMemGetDefaultMemPool', &__cuMemGetDefaultMemPool, 13000, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemGetDefaultMemPool', &__cuMemGetDefaultMemPool, 13000, ptds_mode, NULL) global __cuMemGetMemPool - _F_cuGetProcAddress_v2('cuMemGetMemPool', &__cuMemGetMemPool, 13000, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemGetMemPool', &__cuMemGetMemPool, 13000, ptds_mode, NULL) global __cuMemSetMemPool - _F_cuGetProcAddress_v2('cuMemSetMemPool', &__cuMemSetMemPool, 13000, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemSetMemPool', &__cuMemSetMemPool, 13000, ptds_mode, NULL) global __cuMemPrefetchBatchAsync - _F_cuGetProcAddress_v2('cuMemPrefetchBatchAsync', &__cuMemPrefetchBatchAsync, 13000, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemPrefetchBatchAsync', &__cuMemPrefetchBatchAsync, 13000, ptds_mode, NULL) global __cuMemDiscardBatchAsync - _F_cuGetProcAddress_v2('cuMemDiscardBatchAsync', &__cuMemDiscardBatchAsync, 13000, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemDiscardBatchAsync', &__cuMemDiscardBatchAsync, 13000, ptds_mode, NULL) global __cuMemDiscardAndPrefetchBatchAsync - _F_cuGetProcAddress_v2('cuMemDiscardAndPrefetchBatchAsync', &__cuMemDiscardAndPrefetchBatchAsync, 13000, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemDiscardAndPrefetchBatchAsync', &__cuMemDiscardAndPrefetchBatchAsync, 13000, ptds_mode, NULL) global __cuDeviceGetP2PAtomicCapabilities - _F_cuGetProcAddress_v2('cuDeviceGetP2PAtomicCapabilities', &__cuDeviceGetP2PAtomicCapabilities, 13000, ptds_mode, NULL) + cuGetProcAddress_v2('cuDeviceGetP2PAtomicCapabilities', &__cuDeviceGetP2PAtomicCapabilities, 13000, ptds_mode, NULL) global __cuGreenCtxGetId - _F_cuGetProcAddress_v2('cuGreenCtxGetId', &__cuGreenCtxGetId, 13000, ptds_mode, NULL) + cuGetProcAddress_v2('cuGreenCtxGetId', &__cuGreenCtxGetId, 13000, ptds_mode, NULL) global __cuMulticastBindMem_v2 - _F_cuGetProcAddress_v2('cuMulticastBindMem', &__cuMulticastBindMem_v2, 13010, ptds_mode, NULL) + cuGetProcAddress_v2('cuMulticastBindMem', &__cuMulticastBindMem_v2, 13010, ptds_mode, NULL) global __cuMulticastBindAddr_v2 - _F_cuGetProcAddress_v2('cuMulticastBindAddr', &__cuMulticastBindAddr_v2, 13010, ptds_mode, NULL) + cuGetProcAddress_v2('cuMulticastBindAddr', &__cuMulticastBindAddr_v2, 13010, ptds_mode, NULL) global __cuGraphNodeGetContainingGraph - _F_cuGetProcAddress_v2('cuGraphNodeGetContainingGraph', &__cuGraphNodeGetContainingGraph, 13010, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphNodeGetContainingGraph', &__cuGraphNodeGetContainingGraph, 13010, ptds_mode, NULL) global __cuGraphNodeGetLocalId - _F_cuGetProcAddress_v2('cuGraphNodeGetLocalId', &__cuGraphNodeGetLocalId, 13010, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphNodeGetLocalId', &__cuGraphNodeGetLocalId, 13010, ptds_mode, NULL) global __cuGraphNodeGetToolsId - _F_cuGetProcAddress_v2('cuGraphNodeGetToolsId', &__cuGraphNodeGetToolsId, 13010, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphNodeGetToolsId', &__cuGraphNodeGetToolsId, 13010, ptds_mode, NULL) global __cuGraphGetId - _F_cuGetProcAddress_v2('cuGraphGetId', &__cuGraphGetId, 13010, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphGetId', &__cuGraphGetId, 13010, ptds_mode, NULL) global __cuGraphExecGetId - _F_cuGetProcAddress_v2('cuGraphExecGetId', &__cuGraphExecGetId, 13010, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphExecGetId', &__cuGraphExecGetId, 13010, ptds_mode, NULL) global __cuDevSmResourceSplit - _F_cuGetProcAddress_v2('cuDevSmResourceSplit', &__cuDevSmResourceSplit, 13010, ptds_mode, NULL) + cuGetProcAddress_v2('cuDevSmResourceSplit', &__cuDevSmResourceSplit, 13010, ptds_mode, NULL) global __cuStreamGetDevResource - _F_cuGetProcAddress_v2('cuStreamGetDevResource', &__cuStreamGetDevResource, 13010, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamGetDevResource', &__cuStreamGetDevResource, 13010, ptds_mode, NULL) global __cuKernelGetParamCount - _F_cuGetProcAddress_v2('cuKernelGetParamCount', &__cuKernelGetParamCount, 13020, ptds_mode, NULL) + cuGetProcAddress_v2('cuKernelGetParamCount', &__cuKernelGetParamCount, 13020, ptds_mode, NULL) global __cuMemcpyWithAttributesAsync - _F_cuGetProcAddress_v2('cuMemcpyWithAttributesAsync', &__cuMemcpyWithAttributesAsync, 13020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpyWithAttributesAsync', &__cuMemcpyWithAttributesAsync, 13020, ptds_mode, NULL) global __cuMemcpy3DWithAttributesAsync - _F_cuGetProcAddress_v2('cuMemcpy3DWithAttributesAsync', &__cuMemcpy3DWithAttributesAsync, 13020, ptds_mode, NULL) + cuGetProcAddress_v2('cuMemcpy3DWithAttributesAsync', &__cuMemcpy3DWithAttributesAsync, 13020, ptds_mode, NULL) global __cuStreamBeginCaptureToCig - _F_cuGetProcAddress_v2('cuStreamBeginCaptureToCig', &__cuStreamBeginCaptureToCig, 13020, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamBeginCaptureToCig', &__cuStreamBeginCaptureToCig, 13020, ptds_mode, NULL) global __cuStreamEndCaptureToCig - _F_cuGetProcAddress_v2('cuStreamEndCaptureToCig', &__cuStreamEndCaptureToCig, 13020, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamEndCaptureToCig', &__cuStreamEndCaptureToCig, 13020, ptds_mode, NULL) global __cuFuncGetParamCount - _F_cuGetProcAddress_v2('cuFuncGetParamCount', &__cuFuncGetParamCount, 13020, ptds_mode, NULL) + cuGetProcAddress_v2('cuFuncGetParamCount', &__cuFuncGetParamCount, 13020, ptds_mode, NULL) global __cuLaunchHostFunc_v2 - _F_cuGetProcAddress_v2('cuLaunchHostFunc', &__cuLaunchHostFunc_v2, 13020, ptds_mode, NULL) + cuGetProcAddress_v2('cuLaunchHostFunc', &__cuLaunchHostFunc_v2, 13020, ptds_mode, NULL) global __cuGraphNodeGetParams - _F_cuGetProcAddress_v2('cuGraphNodeGetParams', &__cuGraphNodeGetParams, 13020, ptds_mode, NULL) + cuGetProcAddress_v2('cuGraphNodeGetParams', &__cuGraphNodeGetParams, 13020, ptds_mode, NULL) global __cuCoredumpRegisterStartCallback - _F_cuGetProcAddress_v2('cuCoredumpRegisterStartCallback', &__cuCoredumpRegisterStartCallback, 13020, ptds_mode, NULL) + cuGetProcAddress_v2('cuCoredumpRegisterStartCallback', &__cuCoredumpRegisterStartCallback, 13020, ptds_mode, NULL) global __cuCoredumpRegisterCompleteCallback - _F_cuGetProcAddress_v2('cuCoredumpRegisterCompleteCallback', &__cuCoredumpRegisterCompleteCallback, 13020, ptds_mode, NULL) + cuGetProcAddress_v2('cuCoredumpRegisterCompleteCallback', &__cuCoredumpRegisterCompleteCallback, 13020, ptds_mode, NULL) global __cuCoredumpDeregisterStartCallback - _F_cuGetProcAddress_v2('cuCoredumpDeregisterStartCallback', &__cuCoredumpDeregisterStartCallback, 13020, ptds_mode, NULL) + cuGetProcAddress_v2('cuCoredumpDeregisterStartCallback', &__cuCoredumpDeregisterStartCallback, 13020, ptds_mode, NULL) global __cuCoredumpDeregisterCompleteCallback - _F_cuGetProcAddress_v2('cuCoredumpDeregisterCompleteCallback', &__cuCoredumpDeregisterCompleteCallback, 13020, ptds_mode, NULL) + cuGetProcAddress_v2('cuCoredumpDeregisterCompleteCallback', &__cuCoredumpDeregisterCompleteCallback, 13020, ptds_mode, NULL) global __cuLogicalEndpointIdReserve - _F_cuGetProcAddress_v2('cuLogicalEndpointIdReserve', &__cuLogicalEndpointIdReserve, 13030, ptds_mode, NULL) + cuGetProcAddress_v2('cuLogicalEndpointIdReserve', &__cuLogicalEndpointIdReserve, 13030, ptds_mode, NULL) global __cuLogicalEndpointIdRelease - _F_cuGetProcAddress_v2('cuLogicalEndpointIdRelease', &__cuLogicalEndpointIdRelease, 13030, ptds_mode, NULL) + cuGetProcAddress_v2('cuLogicalEndpointIdRelease', &__cuLogicalEndpointIdRelease, 13030, ptds_mode, NULL) global __cuLogicalEndpointCreate - _F_cuGetProcAddress_v2('cuLogicalEndpointCreate', &__cuLogicalEndpointCreate, 13030, ptds_mode, NULL) + cuGetProcAddress_v2('cuLogicalEndpointCreate', &__cuLogicalEndpointCreate, 13030, ptds_mode, NULL) global __cuLogicalEndpointAddDevice - _F_cuGetProcAddress_v2('cuLogicalEndpointAddDevice', &__cuLogicalEndpointAddDevice, 13030, ptds_mode, NULL) + cuGetProcAddress_v2('cuLogicalEndpointAddDevice', &__cuLogicalEndpointAddDevice, 13030, ptds_mode, NULL) global __cuLogicalEndpointDestroy - _F_cuGetProcAddress_v2('cuLogicalEndpointDestroy', &__cuLogicalEndpointDestroy, 13030, ptds_mode, NULL) + cuGetProcAddress_v2('cuLogicalEndpointDestroy', &__cuLogicalEndpointDestroy, 13030, ptds_mode, NULL) global __cuLogicalEndpointBindAddr - _F_cuGetProcAddress_v2('cuLogicalEndpointBindAddr', &__cuLogicalEndpointBindAddr, 13030, ptds_mode, NULL) + cuGetProcAddress_v2('cuLogicalEndpointBindAddr', &__cuLogicalEndpointBindAddr, 13030, ptds_mode, NULL) global __cuLogicalEndpointBindMem - _F_cuGetProcAddress_v2('cuLogicalEndpointBindMem', &__cuLogicalEndpointBindMem, 13030, ptds_mode, NULL) + cuGetProcAddress_v2('cuLogicalEndpointBindMem', &__cuLogicalEndpointBindMem, 13030, ptds_mode, NULL) global __cuLogicalEndpointUnbind - _F_cuGetProcAddress_v2('cuLogicalEndpointUnbind', &__cuLogicalEndpointUnbind, 13030, ptds_mode, NULL) + cuGetProcAddress_v2('cuLogicalEndpointUnbind', &__cuLogicalEndpointUnbind, 13030, ptds_mode, NULL) global __cuLogicalEndpointExport - _F_cuGetProcAddress_v2('cuLogicalEndpointExport', &__cuLogicalEndpointExport, 13030, ptds_mode, NULL) + cuGetProcAddress_v2('cuLogicalEndpointExport', &__cuLogicalEndpointExport, 13030, ptds_mode, NULL) global __cuLogicalEndpointImport - _F_cuGetProcAddress_v2('cuLogicalEndpointImport', &__cuLogicalEndpointImport, 13030, ptds_mode, NULL) + cuGetProcAddress_v2('cuLogicalEndpointImport', &__cuLogicalEndpointImport, 13030, ptds_mode, NULL) global __cuLogicalEndpointGetLimits - _F_cuGetProcAddress_v2('cuLogicalEndpointGetLimits', &__cuLogicalEndpointGetLimits, 13030, ptds_mode, NULL) + cuGetProcAddress_v2('cuLogicalEndpointGetLimits', &__cuLogicalEndpointGetLimits, 13030, ptds_mode, NULL) global __cuLogicalEndpointQuery - _F_cuGetProcAddress_v2('cuLogicalEndpointQuery', &__cuLogicalEndpointQuery, 13030, ptds_mode, NULL) + cuGetProcAddress_v2('cuLogicalEndpointQuery', &__cuLogicalEndpointQuery, 13030, ptds_mode, NULL) global __cuStreamBeginRecaptureToGraph - _F_cuGetProcAddress_v2('cuStreamBeginRecaptureToGraph', &__cuStreamBeginRecaptureToGraph, 13030, ptds_mode, NULL) + cuGetProcAddress_v2('cuStreamBeginRecaptureToGraph', &__cuStreamBeginRecaptureToGraph, 13030, ptds_mode, NULL) - __py_driver_init = True + _cyb___py_driver_init = True return 0 - cdef inline int _check_or_init_driver() except -1 nogil: - if __py_driver_init: + if _cyb___py_driver_init: return 0 return _init_driver() -cdef dict func_ptrs = None - cpdef dict _inspect_function_pointers(): - global func_ptrs - if func_ptrs is not None: - return func_ptrs + global _cyb_func_ptrs + if _cyb_func_ptrs is not None: + return _cyb_func_ptrs _check_or_init_driver() cdef dict data = {} - global __cuGetErrorString - data["__cuGetErrorString"] = __cuGetErrorString + data["__cuGetErrorString"] = <_cyb_intptr_t>__cuGetErrorString global __cuGetErrorName - data["__cuGetErrorName"] = __cuGetErrorName + data["__cuGetErrorName"] = <_cyb_intptr_t>__cuGetErrorName global __cuInit - data["__cuInit"] = __cuInit + data["__cuInit"] = <_cyb_intptr_t>__cuInit global __cuDriverGetVersion - data["__cuDriverGetVersion"] = __cuDriverGetVersion + data["__cuDriverGetVersion"] = <_cyb_intptr_t>__cuDriverGetVersion global __cuDeviceGet - data["__cuDeviceGet"] = __cuDeviceGet + data["__cuDeviceGet"] = <_cyb_intptr_t>__cuDeviceGet global __cuDeviceGetCount - data["__cuDeviceGetCount"] = __cuDeviceGetCount + data["__cuDeviceGetCount"] = <_cyb_intptr_t>__cuDeviceGetCount global __cuDeviceGetName - data["__cuDeviceGetName"] = __cuDeviceGetName + data["__cuDeviceGetName"] = <_cyb_intptr_t>__cuDeviceGetName global __cuDeviceGetUuid_v2 - data["__cuDeviceGetUuid_v2"] = __cuDeviceGetUuid_v2 + data["__cuDeviceGetUuid_v2"] = <_cyb_intptr_t>__cuDeviceGetUuid_v2 global __cuDeviceGetLuid - data["__cuDeviceGetLuid"] = __cuDeviceGetLuid + data["__cuDeviceGetLuid"] = <_cyb_intptr_t>__cuDeviceGetLuid global __cuDeviceTotalMem_v2 - data["__cuDeviceTotalMem_v2"] = __cuDeviceTotalMem_v2 + data["__cuDeviceTotalMem_v2"] = <_cyb_intptr_t>__cuDeviceTotalMem_v2 global __cuDeviceGetTexture1DLinearMaxWidth - data["__cuDeviceGetTexture1DLinearMaxWidth"] = __cuDeviceGetTexture1DLinearMaxWidth + data["__cuDeviceGetTexture1DLinearMaxWidth"] = <_cyb_intptr_t>__cuDeviceGetTexture1DLinearMaxWidth global __cuDeviceGetAttribute - data["__cuDeviceGetAttribute"] = __cuDeviceGetAttribute + data["__cuDeviceGetAttribute"] = <_cyb_intptr_t>__cuDeviceGetAttribute global __cuDeviceGetNvSciSyncAttributes - data["__cuDeviceGetNvSciSyncAttributes"] = __cuDeviceGetNvSciSyncAttributes + data["__cuDeviceGetNvSciSyncAttributes"] = <_cyb_intptr_t>__cuDeviceGetNvSciSyncAttributes global __cuDeviceSetMemPool - data["__cuDeviceSetMemPool"] = __cuDeviceSetMemPool + data["__cuDeviceSetMemPool"] = <_cyb_intptr_t>__cuDeviceSetMemPool global __cuDeviceGetMemPool - data["__cuDeviceGetMemPool"] = __cuDeviceGetMemPool + data["__cuDeviceGetMemPool"] = <_cyb_intptr_t>__cuDeviceGetMemPool global __cuDeviceGetDefaultMemPool - data["__cuDeviceGetDefaultMemPool"] = __cuDeviceGetDefaultMemPool + data["__cuDeviceGetDefaultMemPool"] = <_cyb_intptr_t>__cuDeviceGetDefaultMemPool global __cuDeviceGetExecAffinitySupport - data["__cuDeviceGetExecAffinitySupport"] = __cuDeviceGetExecAffinitySupport + data["__cuDeviceGetExecAffinitySupport"] = <_cyb_intptr_t>__cuDeviceGetExecAffinitySupport global __cuFlushGPUDirectRDMAWrites - data["__cuFlushGPUDirectRDMAWrites"] = __cuFlushGPUDirectRDMAWrites + data["__cuFlushGPUDirectRDMAWrites"] = <_cyb_intptr_t>__cuFlushGPUDirectRDMAWrites global __cuDeviceGetProperties - data["__cuDeviceGetProperties"] = __cuDeviceGetProperties + data["__cuDeviceGetProperties"] = <_cyb_intptr_t>__cuDeviceGetProperties global __cuDeviceComputeCapability - data["__cuDeviceComputeCapability"] = __cuDeviceComputeCapability + data["__cuDeviceComputeCapability"] = <_cyb_intptr_t>__cuDeviceComputeCapability global __cuDevicePrimaryCtxRetain - data["__cuDevicePrimaryCtxRetain"] = __cuDevicePrimaryCtxRetain + data["__cuDevicePrimaryCtxRetain"] = <_cyb_intptr_t>__cuDevicePrimaryCtxRetain global __cuDevicePrimaryCtxRelease_v2 - data["__cuDevicePrimaryCtxRelease_v2"] = __cuDevicePrimaryCtxRelease_v2 + data["__cuDevicePrimaryCtxRelease_v2"] = <_cyb_intptr_t>__cuDevicePrimaryCtxRelease_v2 global __cuDevicePrimaryCtxSetFlags_v2 - data["__cuDevicePrimaryCtxSetFlags_v2"] = __cuDevicePrimaryCtxSetFlags_v2 + data["__cuDevicePrimaryCtxSetFlags_v2"] = <_cyb_intptr_t>__cuDevicePrimaryCtxSetFlags_v2 global __cuDevicePrimaryCtxGetState - data["__cuDevicePrimaryCtxGetState"] = __cuDevicePrimaryCtxGetState + data["__cuDevicePrimaryCtxGetState"] = <_cyb_intptr_t>__cuDevicePrimaryCtxGetState global __cuDevicePrimaryCtxReset_v2 - data["__cuDevicePrimaryCtxReset_v2"] = __cuDevicePrimaryCtxReset_v2 + data["__cuDevicePrimaryCtxReset_v2"] = <_cyb_intptr_t>__cuDevicePrimaryCtxReset_v2 global __cuCtxCreate_v2 - data["__cuCtxCreate_v2"] = __cuCtxCreate_v2 + data["__cuCtxCreate_v2"] = <_cyb_intptr_t>__cuCtxCreate_v2 global __cuCtxCreate_v3 - data["__cuCtxCreate_v3"] = __cuCtxCreate_v3 + data["__cuCtxCreate_v3"] = <_cyb_intptr_t>__cuCtxCreate_v3 global __cuCtxCreate_v4 - data["__cuCtxCreate_v4"] = __cuCtxCreate_v4 + data["__cuCtxCreate_v4"] = <_cyb_intptr_t>__cuCtxCreate_v4 global __cuCtxDestroy_v2 - data["__cuCtxDestroy_v2"] = __cuCtxDestroy_v2 + data["__cuCtxDestroy_v2"] = <_cyb_intptr_t>__cuCtxDestroy_v2 global __cuCtxPushCurrent_v2 - data["__cuCtxPushCurrent_v2"] = __cuCtxPushCurrent_v2 + data["__cuCtxPushCurrent_v2"] = <_cyb_intptr_t>__cuCtxPushCurrent_v2 global __cuCtxPopCurrent_v2 - data["__cuCtxPopCurrent_v2"] = __cuCtxPopCurrent_v2 + data["__cuCtxPopCurrent_v2"] = <_cyb_intptr_t>__cuCtxPopCurrent_v2 global __cuCtxSetCurrent - data["__cuCtxSetCurrent"] = __cuCtxSetCurrent + data["__cuCtxSetCurrent"] = <_cyb_intptr_t>__cuCtxSetCurrent global __cuCtxGetCurrent - data["__cuCtxGetCurrent"] = __cuCtxGetCurrent + data["__cuCtxGetCurrent"] = <_cyb_intptr_t>__cuCtxGetCurrent global __cuCtxGetDevice - data["__cuCtxGetDevice"] = __cuCtxGetDevice + data["__cuCtxGetDevice"] = <_cyb_intptr_t>__cuCtxGetDevice global __cuCtxGetFlags - data["__cuCtxGetFlags"] = __cuCtxGetFlags + data["__cuCtxGetFlags"] = <_cyb_intptr_t>__cuCtxGetFlags global __cuCtxSetFlags - data["__cuCtxSetFlags"] = __cuCtxSetFlags + data["__cuCtxSetFlags"] = <_cyb_intptr_t>__cuCtxSetFlags global __cuCtxGetId - data["__cuCtxGetId"] = __cuCtxGetId + data["__cuCtxGetId"] = <_cyb_intptr_t>__cuCtxGetId global __cuCtxSynchronize - data["__cuCtxSynchronize"] = __cuCtxSynchronize + data["__cuCtxSynchronize"] = <_cyb_intptr_t>__cuCtxSynchronize global __cuCtxSetLimit - data["__cuCtxSetLimit"] = __cuCtxSetLimit + data["__cuCtxSetLimit"] = <_cyb_intptr_t>__cuCtxSetLimit global __cuCtxGetLimit - data["__cuCtxGetLimit"] = __cuCtxGetLimit + data["__cuCtxGetLimit"] = <_cyb_intptr_t>__cuCtxGetLimit global __cuCtxGetCacheConfig - data["__cuCtxGetCacheConfig"] = __cuCtxGetCacheConfig + data["__cuCtxGetCacheConfig"] = <_cyb_intptr_t>__cuCtxGetCacheConfig global __cuCtxSetCacheConfig - data["__cuCtxSetCacheConfig"] = __cuCtxSetCacheConfig + data["__cuCtxSetCacheConfig"] = <_cyb_intptr_t>__cuCtxSetCacheConfig global __cuCtxGetApiVersion - data["__cuCtxGetApiVersion"] = __cuCtxGetApiVersion + data["__cuCtxGetApiVersion"] = <_cyb_intptr_t>__cuCtxGetApiVersion global __cuCtxGetStreamPriorityRange - data["__cuCtxGetStreamPriorityRange"] = __cuCtxGetStreamPriorityRange + data["__cuCtxGetStreamPriorityRange"] = <_cyb_intptr_t>__cuCtxGetStreamPriorityRange global __cuCtxResetPersistingL2Cache - data["__cuCtxResetPersistingL2Cache"] = __cuCtxResetPersistingL2Cache + data["__cuCtxResetPersistingL2Cache"] = <_cyb_intptr_t>__cuCtxResetPersistingL2Cache global __cuCtxGetExecAffinity - data["__cuCtxGetExecAffinity"] = __cuCtxGetExecAffinity + data["__cuCtxGetExecAffinity"] = <_cyb_intptr_t>__cuCtxGetExecAffinity global __cuCtxRecordEvent - data["__cuCtxRecordEvent"] = __cuCtxRecordEvent + data["__cuCtxRecordEvent"] = <_cyb_intptr_t>__cuCtxRecordEvent global __cuCtxWaitEvent - data["__cuCtxWaitEvent"] = __cuCtxWaitEvent + data["__cuCtxWaitEvent"] = <_cyb_intptr_t>__cuCtxWaitEvent global __cuCtxAttach - data["__cuCtxAttach"] = __cuCtxAttach + data["__cuCtxAttach"] = <_cyb_intptr_t>__cuCtxAttach global __cuCtxDetach - data["__cuCtxDetach"] = __cuCtxDetach + data["__cuCtxDetach"] = <_cyb_intptr_t>__cuCtxDetach global __cuCtxGetSharedMemConfig - data["__cuCtxGetSharedMemConfig"] = __cuCtxGetSharedMemConfig + data["__cuCtxGetSharedMemConfig"] = <_cyb_intptr_t>__cuCtxGetSharedMemConfig global __cuCtxSetSharedMemConfig - data["__cuCtxSetSharedMemConfig"] = __cuCtxSetSharedMemConfig + data["__cuCtxSetSharedMemConfig"] = <_cyb_intptr_t>__cuCtxSetSharedMemConfig global __cuModuleLoad - data["__cuModuleLoad"] = __cuModuleLoad + data["__cuModuleLoad"] = <_cyb_intptr_t>__cuModuleLoad global __cuModuleLoadData - data["__cuModuleLoadData"] = __cuModuleLoadData + data["__cuModuleLoadData"] = <_cyb_intptr_t>__cuModuleLoadData global __cuModuleLoadDataEx - data["__cuModuleLoadDataEx"] = __cuModuleLoadDataEx + data["__cuModuleLoadDataEx"] = <_cyb_intptr_t>__cuModuleLoadDataEx global __cuModuleLoadFatBinary - data["__cuModuleLoadFatBinary"] = __cuModuleLoadFatBinary + data["__cuModuleLoadFatBinary"] = <_cyb_intptr_t>__cuModuleLoadFatBinary global __cuModuleUnload - data["__cuModuleUnload"] = __cuModuleUnload + data["__cuModuleUnload"] = <_cyb_intptr_t>__cuModuleUnload global __cuModuleGetLoadingMode - data["__cuModuleGetLoadingMode"] = __cuModuleGetLoadingMode + data["__cuModuleGetLoadingMode"] = <_cyb_intptr_t>__cuModuleGetLoadingMode global __cuModuleGetFunction - data["__cuModuleGetFunction"] = __cuModuleGetFunction + data["__cuModuleGetFunction"] = <_cyb_intptr_t>__cuModuleGetFunction global __cuModuleGetFunctionCount - data["__cuModuleGetFunctionCount"] = __cuModuleGetFunctionCount + data["__cuModuleGetFunctionCount"] = <_cyb_intptr_t>__cuModuleGetFunctionCount global __cuModuleEnumerateFunctions - data["__cuModuleEnumerateFunctions"] = __cuModuleEnumerateFunctions + data["__cuModuleEnumerateFunctions"] = <_cyb_intptr_t>__cuModuleEnumerateFunctions global __cuModuleGetGlobal_v2 - data["__cuModuleGetGlobal_v2"] = __cuModuleGetGlobal_v2 + data["__cuModuleGetGlobal_v2"] = <_cyb_intptr_t>__cuModuleGetGlobal_v2 global __cuLinkCreate_v2 - data["__cuLinkCreate_v2"] = __cuLinkCreate_v2 + data["__cuLinkCreate_v2"] = <_cyb_intptr_t>__cuLinkCreate_v2 global __cuLinkAddData_v2 - data["__cuLinkAddData_v2"] = __cuLinkAddData_v2 + data["__cuLinkAddData_v2"] = <_cyb_intptr_t>__cuLinkAddData_v2 global __cuLinkAddFile_v2 - data["__cuLinkAddFile_v2"] = __cuLinkAddFile_v2 + data["__cuLinkAddFile_v2"] = <_cyb_intptr_t>__cuLinkAddFile_v2 global __cuLinkComplete - data["__cuLinkComplete"] = __cuLinkComplete + data["__cuLinkComplete"] = <_cyb_intptr_t>__cuLinkComplete global __cuLinkDestroy - data["__cuLinkDestroy"] = __cuLinkDestroy + data["__cuLinkDestroy"] = <_cyb_intptr_t>__cuLinkDestroy global __cuModuleGetTexRef - data["__cuModuleGetTexRef"] = __cuModuleGetTexRef + data["__cuModuleGetTexRef"] = <_cyb_intptr_t>__cuModuleGetTexRef global __cuModuleGetSurfRef - data["__cuModuleGetSurfRef"] = __cuModuleGetSurfRef + data["__cuModuleGetSurfRef"] = <_cyb_intptr_t>__cuModuleGetSurfRef global __cuLibraryLoadData - data["__cuLibraryLoadData"] = __cuLibraryLoadData + data["__cuLibraryLoadData"] = <_cyb_intptr_t>__cuLibraryLoadData global __cuLibraryLoadFromFile - data["__cuLibraryLoadFromFile"] = __cuLibraryLoadFromFile + data["__cuLibraryLoadFromFile"] = <_cyb_intptr_t>__cuLibraryLoadFromFile global __cuLibraryUnload - data["__cuLibraryUnload"] = __cuLibraryUnload + data["__cuLibraryUnload"] = <_cyb_intptr_t>__cuLibraryUnload global __cuLibraryGetKernel - data["__cuLibraryGetKernel"] = __cuLibraryGetKernel + data["__cuLibraryGetKernel"] = <_cyb_intptr_t>__cuLibraryGetKernel global __cuLibraryGetKernelCount - data["__cuLibraryGetKernelCount"] = __cuLibraryGetKernelCount + data["__cuLibraryGetKernelCount"] = <_cyb_intptr_t>__cuLibraryGetKernelCount global __cuLibraryEnumerateKernels - data["__cuLibraryEnumerateKernels"] = __cuLibraryEnumerateKernels + data["__cuLibraryEnumerateKernels"] = <_cyb_intptr_t>__cuLibraryEnumerateKernels global __cuLibraryGetModule - data["__cuLibraryGetModule"] = __cuLibraryGetModule + data["__cuLibraryGetModule"] = <_cyb_intptr_t>__cuLibraryGetModule global __cuKernelGetFunction - data["__cuKernelGetFunction"] = __cuKernelGetFunction + data["__cuKernelGetFunction"] = <_cyb_intptr_t>__cuKernelGetFunction global __cuKernelGetLibrary - data["__cuKernelGetLibrary"] = __cuKernelGetLibrary + data["__cuKernelGetLibrary"] = <_cyb_intptr_t>__cuKernelGetLibrary global __cuLibraryGetGlobal - data["__cuLibraryGetGlobal"] = __cuLibraryGetGlobal + data["__cuLibraryGetGlobal"] = <_cyb_intptr_t>__cuLibraryGetGlobal global __cuLibraryGetManaged - data["__cuLibraryGetManaged"] = __cuLibraryGetManaged + data["__cuLibraryGetManaged"] = <_cyb_intptr_t>__cuLibraryGetManaged global __cuLibraryGetUnifiedFunction - data["__cuLibraryGetUnifiedFunction"] = __cuLibraryGetUnifiedFunction + data["__cuLibraryGetUnifiedFunction"] = <_cyb_intptr_t>__cuLibraryGetUnifiedFunction global __cuKernelGetAttribute - data["__cuKernelGetAttribute"] = __cuKernelGetAttribute + data["__cuKernelGetAttribute"] = <_cyb_intptr_t>__cuKernelGetAttribute global __cuKernelSetAttribute - data["__cuKernelSetAttribute"] = __cuKernelSetAttribute + data["__cuKernelSetAttribute"] = <_cyb_intptr_t>__cuKernelSetAttribute global __cuKernelSetCacheConfig - data["__cuKernelSetCacheConfig"] = __cuKernelSetCacheConfig + data["__cuKernelSetCacheConfig"] = <_cyb_intptr_t>__cuKernelSetCacheConfig global __cuKernelGetName - data["__cuKernelGetName"] = __cuKernelGetName + data["__cuKernelGetName"] = <_cyb_intptr_t>__cuKernelGetName global __cuKernelGetParamInfo - data["__cuKernelGetParamInfo"] = __cuKernelGetParamInfo + data["__cuKernelGetParamInfo"] = <_cyb_intptr_t>__cuKernelGetParamInfo global __cuMemGetInfo_v2 - data["__cuMemGetInfo_v2"] = __cuMemGetInfo_v2 + data["__cuMemGetInfo_v2"] = <_cyb_intptr_t>__cuMemGetInfo_v2 global __cuMemAlloc_v2 - data["__cuMemAlloc_v2"] = __cuMemAlloc_v2 + data["__cuMemAlloc_v2"] = <_cyb_intptr_t>__cuMemAlloc_v2 global __cuMemAllocPitch_v2 - data["__cuMemAllocPitch_v2"] = __cuMemAllocPitch_v2 + data["__cuMemAllocPitch_v2"] = <_cyb_intptr_t>__cuMemAllocPitch_v2 global __cuMemFree_v2 - data["__cuMemFree_v2"] = __cuMemFree_v2 + data["__cuMemFree_v2"] = <_cyb_intptr_t>__cuMemFree_v2 global __cuMemGetAddressRange_v2 - data["__cuMemGetAddressRange_v2"] = __cuMemGetAddressRange_v2 + data["__cuMemGetAddressRange_v2"] = <_cyb_intptr_t>__cuMemGetAddressRange_v2 global __cuMemAllocHost_v2 - data["__cuMemAllocHost_v2"] = __cuMemAllocHost_v2 + data["__cuMemAllocHost_v2"] = <_cyb_intptr_t>__cuMemAllocHost_v2 global __cuMemFreeHost - data["__cuMemFreeHost"] = __cuMemFreeHost + data["__cuMemFreeHost"] = <_cyb_intptr_t>__cuMemFreeHost global __cuMemHostAlloc - data["__cuMemHostAlloc"] = __cuMemHostAlloc + data["__cuMemHostAlloc"] = <_cyb_intptr_t>__cuMemHostAlloc global __cuMemHostGetDevicePointer_v2 - data["__cuMemHostGetDevicePointer_v2"] = __cuMemHostGetDevicePointer_v2 + data["__cuMemHostGetDevicePointer_v2"] = <_cyb_intptr_t>__cuMemHostGetDevicePointer_v2 global __cuMemHostGetFlags - data["__cuMemHostGetFlags"] = __cuMemHostGetFlags + data["__cuMemHostGetFlags"] = <_cyb_intptr_t>__cuMemHostGetFlags global __cuMemAllocManaged - data["__cuMemAllocManaged"] = __cuMemAllocManaged + data["__cuMemAllocManaged"] = <_cyb_intptr_t>__cuMemAllocManaged global __cuDeviceRegisterAsyncNotification - data["__cuDeviceRegisterAsyncNotification"] = __cuDeviceRegisterAsyncNotification + data["__cuDeviceRegisterAsyncNotification"] = <_cyb_intptr_t>__cuDeviceRegisterAsyncNotification global __cuDeviceUnregisterAsyncNotification - data["__cuDeviceUnregisterAsyncNotification"] = __cuDeviceUnregisterAsyncNotification + data["__cuDeviceUnregisterAsyncNotification"] = <_cyb_intptr_t>__cuDeviceUnregisterAsyncNotification global __cuDeviceGetByPCIBusId - data["__cuDeviceGetByPCIBusId"] = __cuDeviceGetByPCIBusId + data["__cuDeviceGetByPCIBusId"] = <_cyb_intptr_t>__cuDeviceGetByPCIBusId global __cuDeviceGetPCIBusId - data["__cuDeviceGetPCIBusId"] = __cuDeviceGetPCIBusId + data["__cuDeviceGetPCIBusId"] = <_cyb_intptr_t>__cuDeviceGetPCIBusId global __cuIpcGetEventHandle - data["__cuIpcGetEventHandle"] = __cuIpcGetEventHandle + data["__cuIpcGetEventHandle"] = <_cyb_intptr_t>__cuIpcGetEventHandle global __cuIpcOpenEventHandle - data["__cuIpcOpenEventHandle"] = __cuIpcOpenEventHandle + data["__cuIpcOpenEventHandle"] = <_cyb_intptr_t>__cuIpcOpenEventHandle global __cuIpcGetMemHandle - data["__cuIpcGetMemHandle"] = __cuIpcGetMemHandle + data["__cuIpcGetMemHandle"] = <_cyb_intptr_t>__cuIpcGetMemHandle global __cuIpcOpenMemHandle_v2 - data["__cuIpcOpenMemHandle_v2"] = __cuIpcOpenMemHandle_v2 + data["__cuIpcOpenMemHandle_v2"] = <_cyb_intptr_t>__cuIpcOpenMemHandle_v2 global __cuIpcCloseMemHandle - data["__cuIpcCloseMemHandle"] = __cuIpcCloseMemHandle + data["__cuIpcCloseMemHandle"] = <_cyb_intptr_t>__cuIpcCloseMemHandle global __cuMemHostRegister_v2 - data["__cuMemHostRegister_v2"] = __cuMemHostRegister_v2 + data["__cuMemHostRegister_v2"] = <_cyb_intptr_t>__cuMemHostRegister_v2 global __cuMemHostUnregister - data["__cuMemHostUnregister"] = __cuMemHostUnregister + data["__cuMemHostUnregister"] = <_cyb_intptr_t>__cuMemHostUnregister global __cuMemcpy - data["__cuMemcpy"] = __cuMemcpy + data["__cuMemcpy"] = <_cyb_intptr_t>__cuMemcpy global __cuMemcpyPeer - data["__cuMemcpyPeer"] = __cuMemcpyPeer + data["__cuMemcpyPeer"] = <_cyb_intptr_t>__cuMemcpyPeer global __cuMemcpyHtoD_v2 - data["__cuMemcpyHtoD_v2"] = __cuMemcpyHtoD_v2 + data["__cuMemcpyHtoD_v2"] = <_cyb_intptr_t>__cuMemcpyHtoD_v2 global __cuMemcpyDtoH_v2 - data["__cuMemcpyDtoH_v2"] = __cuMemcpyDtoH_v2 + data["__cuMemcpyDtoH_v2"] = <_cyb_intptr_t>__cuMemcpyDtoH_v2 global __cuMemcpyDtoD_v2 - data["__cuMemcpyDtoD_v2"] = __cuMemcpyDtoD_v2 + data["__cuMemcpyDtoD_v2"] = <_cyb_intptr_t>__cuMemcpyDtoD_v2 global __cuMemcpyDtoA_v2 - data["__cuMemcpyDtoA_v2"] = __cuMemcpyDtoA_v2 + data["__cuMemcpyDtoA_v2"] = <_cyb_intptr_t>__cuMemcpyDtoA_v2 global __cuMemcpyAtoD_v2 - data["__cuMemcpyAtoD_v2"] = __cuMemcpyAtoD_v2 + data["__cuMemcpyAtoD_v2"] = <_cyb_intptr_t>__cuMemcpyAtoD_v2 global __cuMemcpyHtoA_v2 - data["__cuMemcpyHtoA_v2"] = __cuMemcpyHtoA_v2 + data["__cuMemcpyHtoA_v2"] = <_cyb_intptr_t>__cuMemcpyHtoA_v2 global __cuMemcpyAtoH_v2 - data["__cuMemcpyAtoH_v2"] = __cuMemcpyAtoH_v2 + data["__cuMemcpyAtoH_v2"] = <_cyb_intptr_t>__cuMemcpyAtoH_v2 global __cuMemcpyAtoA_v2 - data["__cuMemcpyAtoA_v2"] = __cuMemcpyAtoA_v2 + data["__cuMemcpyAtoA_v2"] = <_cyb_intptr_t>__cuMemcpyAtoA_v2 global __cuMemcpy2D_v2 - data["__cuMemcpy2D_v2"] = __cuMemcpy2D_v2 + data["__cuMemcpy2D_v2"] = <_cyb_intptr_t>__cuMemcpy2D_v2 global __cuMemcpy2DUnaligned_v2 - data["__cuMemcpy2DUnaligned_v2"] = __cuMemcpy2DUnaligned_v2 + data["__cuMemcpy2DUnaligned_v2"] = <_cyb_intptr_t>__cuMemcpy2DUnaligned_v2 global __cuMemcpy3D_v2 - data["__cuMemcpy3D_v2"] = __cuMemcpy3D_v2 + data["__cuMemcpy3D_v2"] = <_cyb_intptr_t>__cuMemcpy3D_v2 global __cuMemcpy3DPeer - data["__cuMemcpy3DPeer"] = __cuMemcpy3DPeer + data["__cuMemcpy3DPeer"] = <_cyb_intptr_t>__cuMemcpy3DPeer global __cuMemcpyAsync - data["__cuMemcpyAsync"] = __cuMemcpyAsync + data["__cuMemcpyAsync"] = <_cyb_intptr_t>__cuMemcpyAsync global __cuMemcpyPeerAsync - data["__cuMemcpyPeerAsync"] = __cuMemcpyPeerAsync + data["__cuMemcpyPeerAsync"] = <_cyb_intptr_t>__cuMemcpyPeerAsync global __cuMemcpyHtoDAsync_v2 - data["__cuMemcpyHtoDAsync_v2"] = __cuMemcpyHtoDAsync_v2 + data["__cuMemcpyHtoDAsync_v2"] = <_cyb_intptr_t>__cuMemcpyHtoDAsync_v2 global __cuMemcpyDtoHAsync_v2 - data["__cuMemcpyDtoHAsync_v2"] = __cuMemcpyDtoHAsync_v2 + data["__cuMemcpyDtoHAsync_v2"] = <_cyb_intptr_t>__cuMemcpyDtoHAsync_v2 global __cuMemcpyDtoDAsync_v2 - data["__cuMemcpyDtoDAsync_v2"] = __cuMemcpyDtoDAsync_v2 + data["__cuMemcpyDtoDAsync_v2"] = <_cyb_intptr_t>__cuMemcpyDtoDAsync_v2 global __cuMemcpyHtoAAsync_v2 - data["__cuMemcpyHtoAAsync_v2"] = __cuMemcpyHtoAAsync_v2 + data["__cuMemcpyHtoAAsync_v2"] = <_cyb_intptr_t>__cuMemcpyHtoAAsync_v2 global __cuMemcpyAtoHAsync_v2 - data["__cuMemcpyAtoHAsync_v2"] = __cuMemcpyAtoHAsync_v2 + data["__cuMemcpyAtoHAsync_v2"] = <_cyb_intptr_t>__cuMemcpyAtoHAsync_v2 global __cuMemcpy2DAsync_v2 - data["__cuMemcpy2DAsync_v2"] = __cuMemcpy2DAsync_v2 + data["__cuMemcpy2DAsync_v2"] = <_cyb_intptr_t>__cuMemcpy2DAsync_v2 global __cuMemcpy3DAsync_v2 - data["__cuMemcpy3DAsync_v2"] = __cuMemcpy3DAsync_v2 + data["__cuMemcpy3DAsync_v2"] = <_cyb_intptr_t>__cuMemcpy3DAsync_v2 global __cuMemcpy3DPeerAsync - data["__cuMemcpy3DPeerAsync"] = __cuMemcpy3DPeerAsync + data["__cuMemcpy3DPeerAsync"] = <_cyb_intptr_t>__cuMemcpy3DPeerAsync global __cuMemsetD8_v2 - data["__cuMemsetD8_v2"] = __cuMemsetD8_v2 + data["__cuMemsetD8_v2"] = <_cyb_intptr_t>__cuMemsetD8_v2 global __cuMemsetD16_v2 - data["__cuMemsetD16_v2"] = __cuMemsetD16_v2 + data["__cuMemsetD16_v2"] = <_cyb_intptr_t>__cuMemsetD16_v2 global __cuMemsetD32_v2 - data["__cuMemsetD32_v2"] = __cuMemsetD32_v2 + data["__cuMemsetD32_v2"] = <_cyb_intptr_t>__cuMemsetD32_v2 global __cuMemsetD2D8_v2 - data["__cuMemsetD2D8_v2"] = __cuMemsetD2D8_v2 + data["__cuMemsetD2D8_v2"] = <_cyb_intptr_t>__cuMemsetD2D8_v2 global __cuMemsetD2D16_v2 - data["__cuMemsetD2D16_v2"] = __cuMemsetD2D16_v2 + data["__cuMemsetD2D16_v2"] = <_cyb_intptr_t>__cuMemsetD2D16_v2 global __cuMemsetD2D32_v2 - data["__cuMemsetD2D32_v2"] = __cuMemsetD2D32_v2 + data["__cuMemsetD2D32_v2"] = <_cyb_intptr_t>__cuMemsetD2D32_v2 global __cuMemsetD8Async - data["__cuMemsetD8Async"] = __cuMemsetD8Async + data["__cuMemsetD8Async"] = <_cyb_intptr_t>__cuMemsetD8Async global __cuMemsetD16Async - data["__cuMemsetD16Async"] = __cuMemsetD16Async + data["__cuMemsetD16Async"] = <_cyb_intptr_t>__cuMemsetD16Async global __cuMemsetD32Async - data["__cuMemsetD32Async"] = __cuMemsetD32Async + data["__cuMemsetD32Async"] = <_cyb_intptr_t>__cuMemsetD32Async global __cuMemsetD2D8Async - data["__cuMemsetD2D8Async"] = __cuMemsetD2D8Async + data["__cuMemsetD2D8Async"] = <_cyb_intptr_t>__cuMemsetD2D8Async global __cuMemsetD2D16Async - data["__cuMemsetD2D16Async"] = __cuMemsetD2D16Async + data["__cuMemsetD2D16Async"] = <_cyb_intptr_t>__cuMemsetD2D16Async global __cuMemsetD2D32Async - data["__cuMemsetD2D32Async"] = __cuMemsetD2D32Async + data["__cuMemsetD2D32Async"] = <_cyb_intptr_t>__cuMemsetD2D32Async global __cuArrayCreate_v2 - data["__cuArrayCreate_v2"] = __cuArrayCreate_v2 + data["__cuArrayCreate_v2"] = <_cyb_intptr_t>__cuArrayCreate_v2 global __cuArrayGetDescriptor_v2 - data["__cuArrayGetDescriptor_v2"] = __cuArrayGetDescriptor_v2 + data["__cuArrayGetDescriptor_v2"] = <_cyb_intptr_t>__cuArrayGetDescriptor_v2 global __cuArrayGetSparseProperties - data["__cuArrayGetSparseProperties"] = __cuArrayGetSparseProperties + data["__cuArrayGetSparseProperties"] = <_cyb_intptr_t>__cuArrayGetSparseProperties global __cuMipmappedArrayGetSparseProperties - data["__cuMipmappedArrayGetSparseProperties"] = __cuMipmappedArrayGetSparseProperties + data["__cuMipmappedArrayGetSparseProperties"] = <_cyb_intptr_t>__cuMipmappedArrayGetSparseProperties global __cuArrayGetMemoryRequirements - data["__cuArrayGetMemoryRequirements"] = __cuArrayGetMemoryRequirements + data["__cuArrayGetMemoryRequirements"] = <_cyb_intptr_t>__cuArrayGetMemoryRequirements global __cuMipmappedArrayGetMemoryRequirements - data["__cuMipmappedArrayGetMemoryRequirements"] = __cuMipmappedArrayGetMemoryRequirements + data["__cuMipmappedArrayGetMemoryRequirements"] = <_cyb_intptr_t>__cuMipmappedArrayGetMemoryRequirements global __cuArrayGetPlane - data["__cuArrayGetPlane"] = __cuArrayGetPlane + data["__cuArrayGetPlane"] = <_cyb_intptr_t>__cuArrayGetPlane global __cuArrayDestroy - data["__cuArrayDestroy"] = __cuArrayDestroy + data["__cuArrayDestroy"] = <_cyb_intptr_t>__cuArrayDestroy global __cuArray3DCreate_v2 - data["__cuArray3DCreate_v2"] = __cuArray3DCreate_v2 + data["__cuArray3DCreate_v2"] = <_cyb_intptr_t>__cuArray3DCreate_v2 global __cuArray3DGetDescriptor_v2 - data["__cuArray3DGetDescriptor_v2"] = __cuArray3DGetDescriptor_v2 + data["__cuArray3DGetDescriptor_v2"] = <_cyb_intptr_t>__cuArray3DGetDescriptor_v2 global __cuMipmappedArrayCreate - data["__cuMipmappedArrayCreate"] = __cuMipmappedArrayCreate + data["__cuMipmappedArrayCreate"] = <_cyb_intptr_t>__cuMipmappedArrayCreate global __cuMipmappedArrayGetLevel - data["__cuMipmappedArrayGetLevel"] = __cuMipmappedArrayGetLevel + data["__cuMipmappedArrayGetLevel"] = <_cyb_intptr_t>__cuMipmappedArrayGetLevel global __cuMipmappedArrayDestroy - data["__cuMipmappedArrayDestroy"] = __cuMipmappedArrayDestroy + data["__cuMipmappedArrayDestroy"] = <_cyb_intptr_t>__cuMipmappedArrayDestroy global __cuMemGetHandleForAddressRange - data["__cuMemGetHandleForAddressRange"] = __cuMemGetHandleForAddressRange + data["__cuMemGetHandleForAddressRange"] = <_cyb_intptr_t>__cuMemGetHandleForAddressRange global __cuMemBatchDecompressAsync - data["__cuMemBatchDecompressAsync"] = __cuMemBatchDecompressAsync + data["__cuMemBatchDecompressAsync"] = <_cyb_intptr_t>__cuMemBatchDecompressAsync global __cuMemAddressReserve - data["__cuMemAddressReserve"] = __cuMemAddressReserve + data["__cuMemAddressReserve"] = <_cyb_intptr_t>__cuMemAddressReserve global __cuMemAddressFree - data["__cuMemAddressFree"] = __cuMemAddressFree + data["__cuMemAddressFree"] = <_cyb_intptr_t>__cuMemAddressFree global __cuMemCreate - data["__cuMemCreate"] = __cuMemCreate + data["__cuMemCreate"] = <_cyb_intptr_t>__cuMemCreate global __cuMemRelease - data["__cuMemRelease"] = __cuMemRelease + data["__cuMemRelease"] = <_cyb_intptr_t>__cuMemRelease global __cuMemMap - data["__cuMemMap"] = __cuMemMap + data["__cuMemMap"] = <_cyb_intptr_t>__cuMemMap global __cuMemMapArrayAsync - data["__cuMemMapArrayAsync"] = __cuMemMapArrayAsync + data["__cuMemMapArrayAsync"] = <_cyb_intptr_t>__cuMemMapArrayAsync global __cuMemUnmap - data["__cuMemUnmap"] = __cuMemUnmap + data["__cuMemUnmap"] = <_cyb_intptr_t>__cuMemUnmap global __cuMemSetAccess - data["__cuMemSetAccess"] = __cuMemSetAccess + data["__cuMemSetAccess"] = <_cyb_intptr_t>__cuMemSetAccess global __cuMemGetAccess - data["__cuMemGetAccess"] = __cuMemGetAccess + data["__cuMemGetAccess"] = <_cyb_intptr_t>__cuMemGetAccess global __cuMemExportToShareableHandle - data["__cuMemExportToShareableHandle"] = __cuMemExportToShareableHandle + data["__cuMemExportToShareableHandle"] = <_cyb_intptr_t>__cuMemExportToShareableHandle global __cuMemImportFromShareableHandle - data["__cuMemImportFromShareableHandle"] = __cuMemImportFromShareableHandle + data["__cuMemImportFromShareableHandle"] = <_cyb_intptr_t>__cuMemImportFromShareableHandle global __cuMemGetAllocationGranularity - data["__cuMemGetAllocationGranularity"] = __cuMemGetAllocationGranularity + data["__cuMemGetAllocationGranularity"] = <_cyb_intptr_t>__cuMemGetAllocationGranularity global __cuMemGetAllocationPropertiesFromHandle - data["__cuMemGetAllocationPropertiesFromHandle"] = __cuMemGetAllocationPropertiesFromHandle + data["__cuMemGetAllocationPropertiesFromHandle"] = <_cyb_intptr_t>__cuMemGetAllocationPropertiesFromHandle global __cuMemRetainAllocationHandle - data["__cuMemRetainAllocationHandle"] = __cuMemRetainAllocationHandle + data["__cuMemRetainAllocationHandle"] = <_cyb_intptr_t>__cuMemRetainAllocationHandle global __cuMemFreeAsync - data["__cuMemFreeAsync"] = __cuMemFreeAsync + data["__cuMemFreeAsync"] = <_cyb_intptr_t>__cuMemFreeAsync global __cuMemAllocAsync - data["__cuMemAllocAsync"] = __cuMemAllocAsync + data["__cuMemAllocAsync"] = <_cyb_intptr_t>__cuMemAllocAsync global __cuMemPoolTrimTo - data["__cuMemPoolTrimTo"] = __cuMemPoolTrimTo + data["__cuMemPoolTrimTo"] = <_cyb_intptr_t>__cuMemPoolTrimTo global __cuMemPoolSetAttribute - data["__cuMemPoolSetAttribute"] = __cuMemPoolSetAttribute + data["__cuMemPoolSetAttribute"] = <_cyb_intptr_t>__cuMemPoolSetAttribute global __cuMemPoolGetAttribute - data["__cuMemPoolGetAttribute"] = __cuMemPoolGetAttribute + data["__cuMemPoolGetAttribute"] = <_cyb_intptr_t>__cuMemPoolGetAttribute global __cuMemPoolSetAccess - data["__cuMemPoolSetAccess"] = __cuMemPoolSetAccess + data["__cuMemPoolSetAccess"] = <_cyb_intptr_t>__cuMemPoolSetAccess global __cuMemPoolGetAccess - data["__cuMemPoolGetAccess"] = __cuMemPoolGetAccess + data["__cuMemPoolGetAccess"] = <_cyb_intptr_t>__cuMemPoolGetAccess global __cuMemPoolCreate - data["__cuMemPoolCreate"] = __cuMemPoolCreate + data["__cuMemPoolCreate"] = <_cyb_intptr_t>__cuMemPoolCreate global __cuMemPoolDestroy - data["__cuMemPoolDestroy"] = __cuMemPoolDestroy + data["__cuMemPoolDestroy"] = <_cyb_intptr_t>__cuMemPoolDestroy global __cuMemAllocFromPoolAsync - data["__cuMemAllocFromPoolAsync"] = __cuMemAllocFromPoolAsync + data["__cuMemAllocFromPoolAsync"] = <_cyb_intptr_t>__cuMemAllocFromPoolAsync global __cuMemPoolExportToShareableHandle - data["__cuMemPoolExportToShareableHandle"] = __cuMemPoolExportToShareableHandle + data["__cuMemPoolExportToShareableHandle"] = <_cyb_intptr_t>__cuMemPoolExportToShareableHandle global __cuMemPoolImportFromShareableHandle - data["__cuMemPoolImportFromShareableHandle"] = __cuMemPoolImportFromShareableHandle + data["__cuMemPoolImportFromShareableHandle"] = <_cyb_intptr_t>__cuMemPoolImportFromShareableHandle global __cuMemPoolExportPointer - data["__cuMemPoolExportPointer"] = __cuMemPoolExportPointer + data["__cuMemPoolExportPointer"] = <_cyb_intptr_t>__cuMemPoolExportPointer global __cuMemPoolImportPointer - data["__cuMemPoolImportPointer"] = __cuMemPoolImportPointer + data["__cuMemPoolImportPointer"] = <_cyb_intptr_t>__cuMemPoolImportPointer global __cuMulticastCreate - data["__cuMulticastCreate"] = __cuMulticastCreate + data["__cuMulticastCreate"] = <_cyb_intptr_t>__cuMulticastCreate global __cuMulticastAddDevice - data["__cuMulticastAddDevice"] = __cuMulticastAddDevice + data["__cuMulticastAddDevice"] = <_cyb_intptr_t>__cuMulticastAddDevice global __cuMulticastBindMem - data["__cuMulticastBindMem"] = __cuMulticastBindMem + data["__cuMulticastBindMem"] = <_cyb_intptr_t>__cuMulticastBindMem global __cuMulticastBindAddr - data["__cuMulticastBindAddr"] = __cuMulticastBindAddr + data["__cuMulticastBindAddr"] = <_cyb_intptr_t>__cuMulticastBindAddr global __cuMulticastUnbind - data["__cuMulticastUnbind"] = __cuMulticastUnbind + data["__cuMulticastUnbind"] = <_cyb_intptr_t>__cuMulticastUnbind global __cuMulticastGetGranularity - data["__cuMulticastGetGranularity"] = __cuMulticastGetGranularity + data["__cuMulticastGetGranularity"] = <_cyb_intptr_t>__cuMulticastGetGranularity global __cuPointerGetAttribute - data["__cuPointerGetAttribute"] = __cuPointerGetAttribute + data["__cuPointerGetAttribute"] = <_cyb_intptr_t>__cuPointerGetAttribute global __cuMemPrefetchAsync_v2 - data["__cuMemPrefetchAsync_v2"] = __cuMemPrefetchAsync_v2 + data["__cuMemPrefetchAsync_v2"] = <_cyb_intptr_t>__cuMemPrefetchAsync_v2 global __cuMemAdvise_v2 - data["__cuMemAdvise_v2"] = __cuMemAdvise_v2 + data["__cuMemAdvise_v2"] = <_cyb_intptr_t>__cuMemAdvise_v2 global __cuMemRangeGetAttribute - data["__cuMemRangeGetAttribute"] = __cuMemRangeGetAttribute + data["__cuMemRangeGetAttribute"] = <_cyb_intptr_t>__cuMemRangeGetAttribute global __cuMemRangeGetAttributes - data["__cuMemRangeGetAttributes"] = __cuMemRangeGetAttributes + data["__cuMemRangeGetAttributes"] = <_cyb_intptr_t>__cuMemRangeGetAttributes global __cuPointerSetAttribute - data["__cuPointerSetAttribute"] = __cuPointerSetAttribute + data["__cuPointerSetAttribute"] = <_cyb_intptr_t>__cuPointerSetAttribute global __cuPointerGetAttributes - data["__cuPointerGetAttributes"] = __cuPointerGetAttributes + data["__cuPointerGetAttributes"] = <_cyb_intptr_t>__cuPointerGetAttributes global __cuStreamCreate - data["__cuStreamCreate"] = __cuStreamCreate + data["__cuStreamCreate"] = <_cyb_intptr_t>__cuStreamCreate global __cuStreamCreateWithPriority - data["__cuStreamCreateWithPriority"] = __cuStreamCreateWithPriority + data["__cuStreamCreateWithPriority"] = <_cyb_intptr_t>__cuStreamCreateWithPriority global __cuStreamGetPriority - data["__cuStreamGetPriority"] = __cuStreamGetPriority + data["__cuStreamGetPriority"] = <_cyb_intptr_t>__cuStreamGetPriority global __cuStreamGetDevice - data["__cuStreamGetDevice"] = __cuStreamGetDevice + data["__cuStreamGetDevice"] = <_cyb_intptr_t>__cuStreamGetDevice global __cuStreamGetFlags - data["__cuStreamGetFlags"] = __cuStreamGetFlags + data["__cuStreamGetFlags"] = <_cyb_intptr_t>__cuStreamGetFlags global __cuStreamGetId - data["__cuStreamGetId"] = __cuStreamGetId + data["__cuStreamGetId"] = <_cyb_intptr_t>__cuStreamGetId global __cuStreamGetCtx - data["__cuStreamGetCtx"] = __cuStreamGetCtx + data["__cuStreamGetCtx"] = <_cyb_intptr_t>__cuStreamGetCtx global __cuStreamGetCtx_v2 - data["__cuStreamGetCtx_v2"] = __cuStreamGetCtx_v2 + data["__cuStreamGetCtx_v2"] = <_cyb_intptr_t>__cuStreamGetCtx_v2 global __cuStreamWaitEvent - data["__cuStreamWaitEvent"] = __cuStreamWaitEvent + data["__cuStreamWaitEvent"] = <_cyb_intptr_t>__cuStreamWaitEvent global __cuStreamAddCallback - data["__cuStreamAddCallback"] = __cuStreamAddCallback + data["__cuStreamAddCallback"] = <_cyb_intptr_t>__cuStreamAddCallback global __cuStreamBeginCapture_v2 - data["__cuStreamBeginCapture_v2"] = __cuStreamBeginCapture_v2 + data["__cuStreamBeginCapture_v2"] = <_cyb_intptr_t>__cuStreamBeginCapture_v2 global __cuStreamBeginCaptureToGraph - data["__cuStreamBeginCaptureToGraph"] = __cuStreamBeginCaptureToGraph + data["__cuStreamBeginCaptureToGraph"] = <_cyb_intptr_t>__cuStreamBeginCaptureToGraph global __cuThreadExchangeStreamCaptureMode - data["__cuThreadExchangeStreamCaptureMode"] = __cuThreadExchangeStreamCaptureMode + data["__cuThreadExchangeStreamCaptureMode"] = <_cyb_intptr_t>__cuThreadExchangeStreamCaptureMode global __cuStreamEndCapture - data["__cuStreamEndCapture"] = __cuStreamEndCapture + data["__cuStreamEndCapture"] = <_cyb_intptr_t>__cuStreamEndCapture global __cuStreamIsCapturing - data["__cuStreamIsCapturing"] = __cuStreamIsCapturing + data["__cuStreamIsCapturing"] = <_cyb_intptr_t>__cuStreamIsCapturing global __cuStreamGetCaptureInfo_v2 - data["__cuStreamGetCaptureInfo_v2"] = __cuStreamGetCaptureInfo_v2 + data["__cuStreamGetCaptureInfo_v2"] = <_cyb_intptr_t>__cuStreamGetCaptureInfo_v2 global __cuStreamGetCaptureInfo_v3 - data["__cuStreamGetCaptureInfo_v3"] = __cuStreamGetCaptureInfo_v3 + data["__cuStreamGetCaptureInfo_v3"] = <_cyb_intptr_t>__cuStreamGetCaptureInfo_v3 global __cuStreamUpdateCaptureDependencies_v2 - data["__cuStreamUpdateCaptureDependencies_v2"] = __cuStreamUpdateCaptureDependencies_v2 + data["__cuStreamUpdateCaptureDependencies_v2"] = <_cyb_intptr_t>__cuStreamUpdateCaptureDependencies_v2 global __cuStreamAttachMemAsync - data["__cuStreamAttachMemAsync"] = __cuStreamAttachMemAsync + data["__cuStreamAttachMemAsync"] = <_cyb_intptr_t>__cuStreamAttachMemAsync global __cuStreamQuery - data["__cuStreamQuery"] = __cuStreamQuery + data["__cuStreamQuery"] = <_cyb_intptr_t>__cuStreamQuery global __cuStreamSynchronize - data["__cuStreamSynchronize"] = __cuStreamSynchronize + data["__cuStreamSynchronize"] = <_cyb_intptr_t>__cuStreamSynchronize global __cuStreamDestroy_v2 - data["__cuStreamDestroy_v2"] = __cuStreamDestroy_v2 + data["__cuStreamDestroy_v2"] = <_cyb_intptr_t>__cuStreamDestroy_v2 global __cuStreamCopyAttributes - data["__cuStreamCopyAttributes"] = __cuStreamCopyAttributes + data["__cuStreamCopyAttributes"] = <_cyb_intptr_t>__cuStreamCopyAttributes global __cuStreamGetAttribute - data["__cuStreamGetAttribute"] = __cuStreamGetAttribute + data["__cuStreamGetAttribute"] = <_cyb_intptr_t>__cuStreamGetAttribute global __cuStreamSetAttribute - data["__cuStreamSetAttribute"] = __cuStreamSetAttribute + data["__cuStreamSetAttribute"] = <_cyb_intptr_t>__cuStreamSetAttribute global __cuEventCreate - data["__cuEventCreate"] = __cuEventCreate + data["__cuEventCreate"] = <_cyb_intptr_t>__cuEventCreate global __cuEventRecord - data["__cuEventRecord"] = __cuEventRecord + data["__cuEventRecord"] = <_cyb_intptr_t>__cuEventRecord global __cuEventRecordWithFlags - data["__cuEventRecordWithFlags"] = __cuEventRecordWithFlags + data["__cuEventRecordWithFlags"] = <_cyb_intptr_t>__cuEventRecordWithFlags global __cuEventQuery - data["__cuEventQuery"] = __cuEventQuery + data["__cuEventQuery"] = <_cyb_intptr_t>__cuEventQuery global __cuEventSynchronize - data["__cuEventSynchronize"] = __cuEventSynchronize + data["__cuEventSynchronize"] = <_cyb_intptr_t>__cuEventSynchronize global __cuEventDestroy_v2 - data["__cuEventDestroy_v2"] = __cuEventDestroy_v2 + data["__cuEventDestroy_v2"] = <_cyb_intptr_t>__cuEventDestroy_v2 global __cuEventElapsedTime_v2 - data["__cuEventElapsedTime_v2"] = __cuEventElapsedTime_v2 + data["__cuEventElapsedTime_v2"] = <_cyb_intptr_t>__cuEventElapsedTime_v2 global __cuImportExternalMemory - data["__cuImportExternalMemory"] = __cuImportExternalMemory + data["__cuImportExternalMemory"] = <_cyb_intptr_t>__cuImportExternalMemory global __cuExternalMemoryGetMappedBuffer - data["__cuExternalMemoryGetMappedBuffer"] = __cuExternalMemoryGetMappedBuffer + data["__cuExternalMemoryGetMappedBuffer"] = <_cyb_intptr_t>__cuExternalMemoryGetMappedBuffer global __cuExternalMemoryGetMappedMipmappedArray - data["__cuExternalMemoryGetMappedMipmappedArray"] = __cuExternalMemoryGetMappedMipmappedArray + data["__cuExternalMemoryGetMappedMipmappedArray"] = <_cyb_intptr_t>__cuExternalMemoryGetMappedMipmappedArray global __cuDestroyExternalMemory - data["__cuDestroyExternalMemory"] = __cuDestroyExternalMemory + data["__cuDestroyExternalMemory"] = <_cyb_intptr_t>__cuDestroyExternalMemory global __cuImportExternalSemaphore - data["__cuImportExternalSemaphore"] = __cuImportExternalSemaphore + data["__cuImportExternalSemaphore"] = <_cyb_intptr_t>__cuImportExternalSemaphore global __cuSignalExternalSemaphoresAsync - data["__cuSignalExternalSemaphoresAsync"] = __cuSignalExternalSemaphoresAsync + data["__cuSignalExternalSemaphoresAsync"] = <_cyb_intptr_t>__cuSignalExternalSemaphoresAsync global __cuWaitExternalSemaphoresAsync - data["__cuWaitExternalSemaphoresAsync"] = __cuWaitExternalSemaphoresAsync + data["__cuWaitExternalSemaphoresAsync"] = <_cyb_intptr_t>__cuWaitExternalSemaphoresAsync global __cuDestroyExternalSemaphore - data["__cuDestroyExternalSemaphore"] = __cuDestroyExternalSemaphore + data["__cuDestroyExternalSemaphore"] = <_cyb_intptr_t>__cuDestroyExternalSemaphore global __cuStreamWaitValue32_v2 - data["__cuStreamWaitValue32_v2"] = __cuStreamWaitValue32_v2 + data["__cuStreamWaitValue32_v2"] = <_cyb_intptr_t>__cuStreamWaitValue32_v2 global __cuStreamWaitValue64_v2 - data["__cuStreamWaitValue64_v2"] = __cuStreamWaitValue64_v2 + data["__cuStreamWaitValue64_v2"] = <_cyb_intptr_t>__cuStreamWaitValue64_v2 global __cuStreamWriteValue32_v2 - data["__cuStreamWriteValue32_v2"] = __cuStreamWriteValue32_v2 + data["__cuStreamWriteValue32_v2"] = <_cyb_intptr_t>__cuStreamWriteValue32_v2 global __cuStreamWriteValue64_v2 - data["__cuStreamWriteValue64_v2"] = __cuStreamWriteValue64_v2 + data["__cuStreamWriteValue64_v2"] = <_cyb_intptr_t>__cuStreamWriteValue64_v2 global __cuStreamBatchMemOp_v2 - data["__cuStreamBatchMemOp_v2"] = __cuStreamBatchMemOp_v2 + data["__cuStreamBatchMemOp_v2"] = <_cyb_intptr_t>__cuStreamBatchMemOp_v2 global __cuFuncGetAttribute - data["__cuFuncGetAttribute"] = __cuFuncGetAttribute + data["__cuFuncGetAttribute"] = <_cyb_intptr_t>__cuFuncGetAttribute global __cuFuncSetAttribute - data["__cuFuncSetAttribute"] = __cuFuncSetAttribute + data["__cuFuncSetAttribute"] = <_cyb_intptr_t>__cuFuncSetAttribute global __cuFuncSetCacheConfig - data["__cuFuncSetCacheConfig"] = __cuFuncSetCacheConfig + data["__cuFuncSetCacheConfig"] = <_cyb_intptr_t>__cuFuncSetCacheConfig global __cuFuncGetModule - data["__cuFuncGetModule"] = __cuFuncGetModule + data["__cuFuncGetModule"] = <_cyb_intptr_t>__cuFuncGetModule global __cuFuncGetName - data["__cuFuncGetName"] = __cuFuncGetName + data["__cuFuncGetName"] = <_cyb_intptr_t>__cuFuncGetName global __cuFuncGetParamInfo - data["__cuFuncGetParamInfo"] = __cuFuncGetParamInfo + data["__cuFuncGetParamInfo"] = <_cyb_intptr_t>__cuFuncGetParamInfo global __cuFuncIsLoaded - data["__cuFuncIsLoaded"] = __cuFuncIsLoaded + data["__cuFuncIsLoaded"] = <_cyb_intptr_t>__cuFuncIsLoaded global __cuFuncLoad - data["__cuFuncLoad"] = __cuFuncLoad + data["__cuFuncLoad"] = <_cyb_intptr_t>__cuFuncLoad global __cuLaunchKernel - data["__cuLaunchKernel"] = __cuLaunchKernel + data["__cuLaunchKernel"] = <_cyb_intptr_t>__cuLaunchKernel global __cuLaunchKernelEx - data["__cuLaunchKernelEx"] = __cuLaunchKernelEx + data["__cuLaunchKernelEx"] = <_cyb_intptr_t>__cuLaunchKernelEx global __cuLaunchCooperativeKernel - data["__cuLaunchCooperativeKernel"] = __cuLaunchCooperativeKernel + data["__cuLaunchCooperativeKernel"] = <_cyb_intptr_t>__cuLaunchCooperativeKernel global __cuLaunchCooperativeKernelMultiDevice - data["__cuLaunchCooperativeKernelMultiDevice"] = __cuLaunchCooperativeKernelMultiDevice + data["__cuLaunchCooperativeKernelMultiDevice"] = <_cyb_intptr_t>__cuLaunchCooperativeKernelMultiDevice global __cuLaunchHostFunc - data["__cuLaunchHostFunc"] = __cuLaunchHostFunc + data["__cuLaunchHostFunc"] = <_cyb_intptr_t>__cuLaunchHostFunc global __cuFuncSetBlockShape - data["__cuFuncSetBlockShape"] = __cuFuncSetBlockShape + data["__cuFuncSetBlockShape"] = <_cyb_intptr_t>__cuFuncSetBlockShape global __cuFuncSetSharedSize - data["__cuFuncSetSharedSize"] = __cuFuncSetSharedSize + data["__cuFuncSetSharedSize"] = <_cyb_intptr_t>__cuFuncSetSharedSize global __cuParamSetSize - data["__cuParamSetSize"] = __cuParamSetSize + data["__cuParamSetSize"] = <_cyb_intptr_t>__cuParamSetSize global __cuParamSeti - data["__cuParamSeti"] = __cuParamSeti + data["__cuParamSeti"] = <_cyb_intptr_t>__cuParamSeti global __cuParamSetf - data["__cuParamSetf"] = __cuParamSetf + data["__cuParamSetf"] = <_cyb_intptr_t>__cuParamSetf global __cuParamSetv - data["__cuParamSetv"] = __cuParamSetv + data["__cuParamSetv"] = <_cyb_intptr_t>__cuParamSetv global __cuLaunch - data["__cuLaunch"] = __cuLaunch + data["__cuLaunch"] = <_cyb_intptr_t>__cuLaunch global __cuLaunchGrid - data["__cuLaunchGrid"] = __cuLaunchGrid + data["__cuLaunchGrid"] = <_cyb_intptr_t>__cuLaunchGrid global __cuLaunchGridAsync - data["__cuLaunchGridAsync"] = __cuLaunchGridAsync + data["__cuLaunchGridAsync"] = <_cyb_intptr_t>__cuLaunchGridAsync global __cuParamSetTexRef - data["__cuParamSetTexRef"] = __cuParamSetTexRef + data["__cuParamSetTexRef"] = <_cyb_intptr_t>__cuParamSetTexRef global __cuFuncSetSharedMemConfig - data["__cuFuncSetSharedMemConfig"] = __cuFuncSetSharedMemConfig + data["__cuFuncSetSharedMemConfig"] = <_cyb_intptr_t>__cuFuncSetSharedMemConfig global __cuGraphCreate - data["__cuGraphCreate"] = __cuGraphCreate + data["__cuGraphCreate"] = <_cyb_intptr_t>__cuGraphCreate global __cuGraphAddKernelNode_v2 - data["__cuGraphAddKernelNode_v2"] = __cuGraphAddKernelNode_v2 + data["__cuGraphAddKernelNode_v2"] = <_cyb_intptr_t>__cuGraphAddKernelNode_v2 global __cuGraphKernelNodeGetParams_v2 - data["__cuGraphKernelNodeGetParams_v2"] = __cuGraphKernelNodeGetParams_v2 + data["__cuGraphKernelNodeGetParams_v2"] = <_cyb_intptr_t>__cuGraphKernelNodeGetParams_v2 global __cuGraphKernelNodeSetParams_v2 - data["__cuGraphKernelNodeSetParams_v2"] = __cuGraphKernelNodeSetParams_v2 + data["__cuGraphKernelNodeSetParams_v2"] = <_cyb_intptr_t>__cuGraphKernelNodeSetParams_v2 global __cuGraphAddMemcpyNode - data["__cuGraphAddMemcpyNode"] = __cuGraphAddMemcpyNode + data["__cuGraphAddMemcpyNode"] = <_cyb_intptr_t>__cuGraphAddMemcpyNode global __cuGraphMemcpyNodeGetParams - data["__cuGraphMemcpyNodeGetParams"] = __cuGraphMemcpyNodeGetParams + data["__cuGraphMemcpyNodeGetParams"] = <_cyb_intptr_t>__cuGraphMemcpyNodeGetParams global __cuGraphMemcpyNodeSetParams - data["__cuGraphMemcpyNodeSetParams"] = __cuGraphMemcpyNodeSetParams + data["__cuGraphMemcpyNodeSetParams"] = <_cyb_intptr_t>__cuGraphMemcpyNodeSetParams global __cuGraphAddMemsetNode - data["__cuGraphAddMemsetNode"] = __cuGraphAddMemsetNode + data["__cuGraphAddMemsetNode"] = <_cyb_intptr_t>__cuGraphAddMemsetNode global __cuGraphMemsetNodeGetParams - data["__cuGraphMemsetNodeGetParams"] = __cuGraphMemsetNodeGetParams + data["__cuGraphMemsetNodeGetParams"] = <_cyb_intptr_t>__cuGraphMemsetNodeGetParams global __cuGraphMemsetNodeSetParams - data["__cuGraphMemsetNodeSetParams"] = __cuGraphMemsetNodeSetParams + data["__cuGraphMemsetNodeSetParams"] = <_cyb_intptr_t>__cuGraphMemsetNodeSetParams global __cuGraphAddHostNode - data["__cuGraphAddHostNode"] = __cuGraphAddHostNode + data["__cuGraphAddHostNode"] = <_cyb_intptr_t>__cuGraphAddHostNode global __cuGraphHostNodeGetParams - data["__cuGraphHostNodeGetParams"] = __cuGraphHostNodeGetParams + data["__cuGraphHostNodeGetParams"] = <_cyb_intptr_t>__cuGraphHostNodeGetParams global __cuGraphHostNodeSetParams - data["__cuGraphHostNodeSetParams"] = __cuGraphHostNodeSetParams + data["__cuGraphHostNodeSetParams"] = <_cyb_intptr_t>__cuGraphHostNodeSetParams global __cuGraphAddChildGraphNode - data["__cuGraphAddChildGraphNode"] = __cuGraphAddChildGraphNode + data["__cuGraphAddChildGraphNode"] = <_cyb_intptr_t>__cuGraphAddChildGraphNode global __cuGraphChildGraphNodeGetGraph - data["__cuGraphChildGraphNodeGetGraph"] = __cuGraphChildGraphNodeGetGraph + data["__cuGraphChildGraphNodeGetGraph"] = <_cyb_intptr_t>__cuGraphChildGraphNodeGetGraph global __cuGraphAddEmptyNode - data["__cuGraphAddEmptyNode"] = __cuGraphAddEmptyNode + data["__cuGraphAddEmptyNode"] = <_cyb_intptr_t>__cuGraphAddEmptyNode global __cuGraphAddEventRecordNode - data["__cuGraphAddEventRecordNode"] = __cuGraphAddEventRecordNode + data["__cuGraphAddEventRecordNode"] = <_cyb_intptr_t>__cuGraphAddEventRecordNode global __cuGraphEventRecordNodeGetEvent - data["__cuGraphEventRecordNodeGetEvent"] = __cuGraphEventRecordNodeGetEvent + data["__cuGraphEventRecordNodeGetEvent"] = <_cyb_intptr_t>__cuGraphEventRecordNodeGetEvent global __cuGraphEventRecordNodeSetEvent - data["__cuGraphEventRecordNodeSetEvent"] = __cuGraphEventRecordNodeSetEvent + data["__cuGraphEventRecordNodeSetEvent"] = <_cyb_intptr_t>__cuGraphEventRecordNodeSetEvent global __cuGraphAddEventWaitNode - data["__cuGraphAddEventWaitNode"] = __cuGraphAddEventWaitNode + data["__cuGraphAddEventWaitNode"] = <_cyb_intptr_t>__cuGraphAddEventWaitNode global __cuGraphEventWaitNodeGetEvent - data["__cuGraphEventWaitNodeGetEvent"] = __cuGraphEventWaitNodeGetEvent + data["__cuGraphEventWaitNodeGetEvent"] = <_cyb_intptr_t>__cuGraphEventWaitNodeGetEvent global __cuGraphEventWaitNodeSetEvent - data["__cuGraphEventWaitNodeSetEvent"] = __cuGraphEventWaitNodeSetEvent + data["__cuGraphEventWaitNodeSetEvent"] = <_cyb_intptr_t>__cuGraphEventWaitNodeSetEvent global __cuGraphAddExternalSemaphoresSignalNode - data["__cuGraphAddExternalSemaphoresSignalNode"] = __cuGraphAddExternalSemaphoresSignalNode + data["__cuGraphAddExternalSemaphoresSignalNode"] = <_cyb_intptr_t>__cuGraphAddExternalSemaphoresSignalNode global __cuGraphExternalSemaphoresSignalNodeGetParams - data["__cuGraphExternalSemaphoresSignalNodeGetParams"] = __cuGraphExternalSemaphoresSignalNodeGetParams + data["__cuGraphExternalSemaphoresSignalNodeGetParams"] = <_cyb_intptr_t>__cuGraphExternalSemaphoresSignalNodeGetParams global __cuGraphExternalSemaphoresSignalNodeSetParams - data["__cuGraphExternalSemaphoresSignalNodeSetParams"] = __cuGraphExternalSemaphoresSignalNodeSetParams + data["__cuGraphExternalSemaphoresSignalNodeSetParams"] = <_cyb_intptr_t>__cuGraphExternalSemaphoresSignalNodeSetParams global __cuGraphAddExternalSemaphoresWaitNode - data["__cuGraphAddExternalSemaphoresWaitNode"] = __cuGraphAddExternalSemaphoresWaitNode + data["__cuGraphAddExternalSemaphoresWaitNode"] = <_cyb_intptr_t>__cuGraphAddExternalSemaphoresWaitNode global __cuGraphExternalSemaphoresWaitNodeGetParams - data["__cuGraphExternalSemaphoresWaitNodeGetParams"] = __cuGraphExternalSemaphoresWaitNodeGetParams + data["__cuGraphExternalSemaphoresWaitNodeGetParams"] = <_cyb_intptr_t>__cuGraphExternalSemaphoresWaitNodeGetParams global __cuGraphExternalSemaphoresWaitNodeSetParams - data["__cuGraphExternalSemaphoresWaitNodeSetParams"] = __cuGraphExternalSemaphoresWaitNodeSetParams + data["__cuGraphExternalSemaphoresWaitNodeSetParams"] = <_cyb_intptr_t>__cuGraphExternalSemaphoresWaitNodeSetParams global __cuGraphAddBatchMemOpNode - data["__cuGraphAddBatchMemOpNode"] = __cuGraphAddBatchMemOpNode + data["__cuGraphAddBatchMemOpNode"] = <_cyb_intptr_t>__cuGraphAddBatchMemOpNode global __cuGraphBatchMemOpNodeGetParams - data["__cuGraphBatchMemOpNodeGetParams"] = __cuGraphBatchMemOpNodeGetParams + data["__cuGraphBatchMemOpNodeGetParams"] = <_cyb_intptr_t>__cuGraphBatchMemOpNodeGetParams global __cuGraphBatchMemOpNodeSetParams - data["__cuGraphBatchMemOpNodeSetParams"] = __cuGraphBatchMemOpNodeSetParams + data["__cuGraphBatchMemOpNodeSetParams"] = <_cyb_intptr_t>__cuGraphBatchMemOpNodeSetParams global __cuGraphExecBatchMemOpNodeSetParams - data["__cuGraphExecBatchMemOpNodeSetParams"] = __cuGraphExecBatchMemOpNodeSetParams + data["__cuGraphExecBatchMemOpNodeSetParams"] = <_cyb_intptr_t>__cuGraphExecBatchMemOpNodeSetParams global __cuGraphAddMemAllocNode - data["__cuGraphAddMemAllocNode"] = __cuGraphAddMemAllocNode + data["__cuGraphAddMemAllocNode"] = <_cyb_intptr_t>__cuGraphAddMemAllocNode global __cuGraphMemAllocNodeGetParams - data["__cuGraphMemAllocNodeGetParams"] = __cuGraphMemAllocNodeGetParams + data["__cuGraphMemAllocNodeGetParams"] = <_cyb_intptr_t>__cuGraphMemAllocNodeGetParams global __cuGraphAddMemFreeNode - data["__cuGraphAddMemFreeNode"] = __cuGraphAddMemFreeNode + data["__cuGraphAddMemFreeNode"] = <_cyb_intptr_t>__cuGraphAddMemFreeNode global __cuGraphMemFreeNodeGetParams - data["__cuGraphMemFreeNodeGetParams"] = __cuGraphMemFreeNodeGetParams + data["__cuGraphMemFreeNodeGetParams"] = <_cyb_intptr_t>__cuGraphMemFreeNodeGetParams global __cuDeviceGraphMemTrim - data["__cuDeviceGraphMemTrim"] = __cuDeviceGraphMemTrim + data["__cuDeviceGraphMemTrim"] = <_cyb_intptr_t>__cuDeviceGraphMemTrim global __cuDeviceGetGraphMemAttribute - data["__cuDeviceGetGraphMemAttribute"] = __cuDeviceGetGraphMemAttribute + data["__cuDeviceGetGraphMemAttribute"] = <_cyb_intptr_t>__cuDeviceGetGraphMemAttribute global __cuDeviceSetGraphMemAttribute - data["__cuDeviceSetGraphMemAttribute"] = __cuDeviceSetGraphMemAttribute + data["__cuDeviceSetGraphMemAttribute"] = <_cyb_intptr_t>__cuDeviceSetGraphMemAttribute global __cuGraphClone - data["__cuGraphClone"] = __cuGraphClone + data["__cuGraphClone"] = <_cyb_intptr_t>__cuGraphClone global __cuGraphNodeFindInClone - data["__cuGraphNodeFindInClone"] = __cuGraphNodeFindInClone + data["__cuGraphNodeFindInClone"] = <_cyb_intptr_t>__cuGraphNodeFindInClone global __cuGraphNodeGetType - data["__cuGraphNodeGetType"] = __cuGraphNodeGetType + data["__cuGraphNodeGetType"] = <_cyb_intptr_t>__cuGraphNodeGetType global __cuGraphGetNodes - data["__cuGraphGetNodes"] = __cuGraphGetNodes + data["__cuGraphGetNodes"] = <_cyb_intptr_t>__cuGraphGetNodes global __cuGraphGetRootNodes - data["__cuGraphGetRootNodes"] = __cuGraphGetRootNodes + data["__cuGraphGetRootNodes"] = <_cyb_intptr_t>__cuGraphGetRootNodes global __cuGraphGetEdges_v2 - data["__cuGraphGetEdges_v2"] = __cuGraphGetEdges_v2 + data["__cuGraphGetEdges_v2"] = <_cyb_intptr_t>__cuGraphGetEdges_v2 global __cuGraphNodeGetDependencies_v2 - data["__cuGraphNodeGetDependencies_v2"] = __cuGraphNodeGetDependencies_v2 + data["__cuGraphNodeGetDependencies_v2"] = <_cyb_intptr_t>__cuGraphNodeGetDependencies_v2 global __cuGraphNodeGetDependentNodes_v2 - data["__cuGraphNodeGetDependentNodes_v2"] = __cuGraphNodeGetDependentNodes_v2 + data["__cuGraphNodeGetDependentNodes_v2"] = <_cyb_intptr_t>__cuGraphNodeGetDependentNodes_v2 global __cuGraphAddDependencies_v2 - data["__cuGraphAddDependencies_v2"] = __cuGraphAddDependencies_v2 + data["__cuGraphAddDependencies_v2"] = <_cyb_intptr_t>__cuGraphAddDependencies_v2 global __cuGraphRemoveDependencies_v2 - data["__cuGraphRemoveDependencies_v2"] = __cuGraphRemoveDependencies_v2 + data["__cuGraphRemoveDependencies_v2"] = <_cyb_intptr_t>__cuGraphRemoveDependencies_v2 global __cuGraphDestroyNode - data["__cuGraphDestroyNode"] = __cuGraphDestroyNode + data["__cuGraphDestroyNode"] = <_cyb_intptr_t>__cuGraphDestroyNode global __cuGraphInstantiateWithFlags - data["__cuGraphInstantiateWithFlags"] = __cuGraphInstantiateWithFlags + data["__cuGraphInstantiateWithFlags"] = <_cyb_intptr_t>__cuGraphInstantiateWithFlags global __cuGraphInstantiateWithParams - data["__cuGraphInstantiateWithParams"] = __cuGraphInstantiateWithParams + data["__cuGraphInstantiateWithParams"] = <_cyb_intptr_t>__cuGraphInstantiateWithParams global __cuGraphExecGetFlags - data["__cuGraphExecGetFlags"] = __cuGraphExecGetFlags + data["__cuGraphExecGetFlags"] = <_cyb_intptr_t>__cuGraphExecGetFlags global __cuGraphExecKernelNodeSetParams_v2 - data["__cuGraphExecKernelNodeSetParams_v2"] = __cuGraphExecKernelNodeSetParams_v2 + data["__cuGraphExecKernelNodeSetParams_v2"] = <_cyb_intptr_t>__cuGraphExecKernelNodeSetParams_v2 global __cuGraphExecMemcpyNodeSetParams - data["__cuGraphExecMemcpyNodeSetParams"] = __cuGraphExecMemcpyNodeSetParams + data["__cuGraphExecMemcpyNodeSetParams"] = <_cyb_intptr_t>__cuGraphExecMemcpyNodeSetParams global __cuGraphExecMemsetNodeSetParams - data["__cuGraphExecMemsetNodeSetParams"] = __cuGraphExecMemsetNodeSetParams + data["__cuGraphExecMemsetNodeSetParams"] = <_cyb_intptr_t>__cuGraphExecMemsetNodeSetParams global __cuGraphExecHostNodeSetParams - data["__cuGraphExecHostNodeSetParams"] = __cuGraphExecHostNodeSetParams + data["__cuGraphExecHostNodeSetParams"] = <_cyb_intptr_t>__cuGraphExecHostNodeSetParams global __cuGraphExecChildGraphNodeSetParams - data["__cuGraphExecChildGraphNodeSetParams"] = __cuGraphExecChildGraphNodeSetParams + data["__cuGraphExecChildGraphNodeSetParams"] = <_cyb_intptr_t>__cuGraphExecChildGraphNodeSetParams global __cuGraphExecEventRecordNodeSetEvent - data["__cuGraphExecEventRecordNodeSetEvent"] = __cuGraphExecEventRecordNodeSetEvent + data["__cuGraphExecEventRecordNodeSetEvent"] = <_cyb_intptr_t>__cuGraphExecEventRecordNodeSetEvent global __cuGraphExecEventWaitNodeSetEvent - data["__cuGraphExecEventWaitNodeSetEvent"] = __cuGraphExecEventWaitNodeSetEvent + data["__cuGraphExecEventWaitNodeSetEvent"] = <_cyb_intptr_t>__cuGraphExecEventWaitNodeSetEvent global __cuGraphExecExternalSemaphoresSignalNodeSetParams - data["__cuGraphExecExternalSemaphoresSignalNodeSetParams"] = __cuGraphExecExternalSemaphoresSignalNodeSetParams + data["__cuGraphExecExternalSemaphoresSignalNodeSetParams"] = <_cyb_intptr_t>__cuGraphExecExternalSemaphoresSignalNodeSetParams global __cuGraphExecExternalSemaphoresWaitNodeSetParams - data["__cuGraphExecExternalSemaphoresWaitNodeSetParams"] = __cuGraphExecExternalSemaphoresWaitNodeSetParams + data["__cuGraphExecExternalSemaphoresWaitNodeSetParams"] = <_cyb_intptr_t>__cuGraphExecExternalSemaphoresWaitNodeSetParams global __cuGraphNodeSetEnabled - data["__cuGraphNodeSetEnabled"] = __cuGraphNodeSetEnabled + data["__cuGraphNodeSetEnabled"] = <_cyb_intptr_t>__cuGraphNodeSetEnabled global __cuGraphNodeGetEnabled - data["__cuGraphNodeGetEnabled"] = __cuGraphNodeGetEnabled + data["__cuGraphNodeGetEnabled"] = <_cyb_intptr_t>__cuGraphNodeGetEnabled global __cuGraphUpload - data["__cuGraphUpload"] = __cuGraphUpload + data["__cuGraphUpload"] = <_cyb_intptr_t>__cuGraphUpload global __cuGraphLaunch - data["__cuGraphLaunch"] = __cuGraphLaunch + data["__cuGraphLaunch"] = <_cyb_intptr_t>__cuGraphLaunch global __cuGraphExecDestroy - data["__cuGraphExecDestroy"] = __cuGraphExecDestroy + data["__cuGraphExecDestroy"] = <_cyb_intptr_t>__cuGraphExecDestroy global __cuGraphDestroy - data["__cuGraphDestroy"] = __cuGraphDestroy + data["__cuGraphDestroy"] = <_cyb_intptr_t>__cuGraphDestroy global __cuGraphExecUpdate_v2 - data["__cuGraphExecUpdate_v2"] = __cuGraphExecUpdate_v2 + data["__cuGraphExecUpdate_v2"] = <_cyb_intptr_t>__cuGraphExecUpdate_v2 global __cuGraphKernelNodeCopyAttributes - data["__cuGraphKernelNodeCopyAttributes"] = __cuGraphKernelNodeCopyAttributes + data["__cuGraphKernelNodeCopyAttributes"] = <_cyb_intptr_t>__cuGraphKernelNodeCopyAttributes global __cuGraphKernelNodeGetAttribute - data["__cuGraphKernelNodeGetAttribute"] = __cuGraphKernelNodeGetAttribute + data["__cuGraphKernelNodeGetAttribute"] = <_cyb_intptr_t>__cuGraphKernelNodeGetAttribute global __cuGraphKernelNodeSetAttribute - data["__cuGraphKernelNodeSetAttribute"] = __cuGraphKernelNodeSetAttribute + data["__cuGraphKernelNodeSetAttribute"] = <_cyb_intptr_t>__cuGraphKernelNodeSetAttribute global __cuGraphDebugDotPrint - data["__cuGraphDebugDotPrint"] = __cuGraphDebugDotPrint + data["__cuGraphDebugDotPrint"] = <_cyb_intptr_t>__cuGraphDebugDotPrint global __cuUserObjectCreate - data["__cuUserObjectCreate"] = __cuUserObjectCreate + data["__cuUserObjectCreate"] = <_cyb_intptr_t>__cuUserObjectCreate global __cuUserObjectRetain - data["__cuUserObjectRetain"] = __cuUserObjectRetain + data["__cuUserObjectRetain"] = <_cyb_intptr_t>__cuUserObjectRetain global __cuUserObjectRelease - data["__cuUserObjectRelease"] = __cuUserObjectRelease + data["__cuUserObjectRelease"] = <_cyb_intptr_t>__cuUserObjectRelease global __cuGraphRetainUserObject - data["__cuGraphRetainUserObject"] = __cuGraphRetainUserObject + data["__cuGraphRetainUserObject"] = <_cyb_intptr_t>__cuGraphRetainUserObject global __cuGraphReleaseUserObject - data["__cuGraphReleaseUserObject"] = __cuGraphReleaseUserObject + data["__cuGraphReleaseUserObject"] = <_cyb_intptr_t>__cuGraphReleaseUserObject global __cuGraphAddNode_v2 - data["__cuGraphAddNode_v2"] = __cuGraphAddNode_v2 + data["__cuGraphAddNode_v2"] = <_cyb_intptr_t>__cuGraphAddNode_v2 global __cuGraphNodeSetParams - data["__cuGraphNodeSetParams"] = __cuGraphNodeSetParams + data["__cuGraphNodeSetParams"] = <_cyb_intptr_t>__cuGraphNodeSetParams global __cuGraphExecNodeSetParams - data["__cuGraphExecNodeSetParams"] = __cuGraphExecNodeSetParams + data["__cuGraphExecNodeSetParams"] = <_cyb_intptr_t>__cuGraphExecNodeSetParams global __cuGraphConditionalHandleCreate - data["__cuGraphConditionalHandleCreate"] = __cuGraphConditionalHandleCreate + data["__cuGraphConditionalHandleCreate"] = <_cyb_intptr_t>__cuGraphConditionalHandleCreate global __cuOccupancyMaxActiveBlocksPerMultiprocessor - data["__cuOccupancyMaxActiveBlocksPerMultiprocessor"] = __cuOccupancyMaxActiveBlocksPerMultiprocessor + data["__cuOccupancyMaxActiveBlocksPerMultiprocessor"] = <_cyb_intptr_t>__cuOccupancyMaxActiveBlocksPerMultiprocessor global __cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags - data["__cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags"] = __cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags + data["__cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags"] = <_cyb_intptr_t>__cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags global __cuOccupancyMaxPotentialBlockSize - data["__cuOccupancyMaxPotentialBlockSize"] = __cuOccupancyMaxPotentialBlockSize + data["__cuOccupancyMaxPotentialBlockSize"] = <_cyb_intptr_t>__cuOccupancyMaxPotentialBlockSize global __cuOccupancyMaxPotentialBlockSizeWithFlags - data["__cuOccupancyMaxPotentialBlockSizeWithFlags"] = __cuOccupancyMaxPotentialBlockSizeWithFlags + data["__cuOccupancyMaxPotentialBlockSizeWithFlags"] = <_cyb_intptr_t>__cuOccupancyMaxPotentialBlockSizeWithFlags global __cuOccupancyAvailableDynamicSMemPerBlock - data["__cuOccupancyAvailableDynamicSMemPerBlock"] = __cuOccupancyAvailableDynamicSMemPerBlock + data["__cuOccupancyAvailableDynamicSMemPerBlock"] = <_cyb_intptr_t>__cuOccupancyAvailableDynamicSMemPerBlock global __cuOccupancyMaxPotentialClusterSize - data["__cuOccupancyMaxPotentialClusterSize"] = __cuOccupancyMaxPotentialClusterSize + data["__cuOccupancyMaxPotentialClusterSize"] = <_cyb_intptr_t>__cuOccupancyMaxPotentialClusterSize global __cuOccupancyMaxActiveClusters - data["__cuOccupancyMaxActiveClusters"] = __cuOccupancyMaxActiveClusters + data["__cuOccupancyMaxActiveClusters"] = <_cyb_intptr_t>__cuOccupancyMaxActiveClusters global __cuTexRefSetArray - data["__cuTexRefSetArray"] = __cuTexRefSetArray + data["__cuTexRefSetArray"] = <_cyb_intptr_t>__cuTexRefSetArray global __cuTexRefSetMipmappedArray - data["__cuTexRefSetMipmappedArray"] = __cuTexRefSetMipmappedArray + data["__cuTexRefSetMipmappedArray"] = <_cyb_intptr_t>__cuTexRefSetMipmappedArray global __cuTexRefSetAddress_v2 - data["__cuTexRefSetAddress_v2"] = __cuTexRefSetAddress_v2 + data["__cuTexRefSetAddress_v2"] = <_cyb_intptr_t>__cuTexRefSetAddress_v2 global __cuTexRefSetAddress2D_v3 - data["__cuTexRefSetAddress2D_v3"] = __cuTexRefSetAddress2D_v3 + data["__cuTexRefSetAddress2D_v3"] = <_cyb_intptr_t>__cuTexRefSetAddress2D_v3 global __cuTexRefSetFormat - data["__cuTexRefSetFormat"] = __cuTexRefSetFormat + data["__cuTexRefSetFormat"] = <_cyb_intptr_t>__cuTexRefSetFormat global __cuTexRefSetAddressMode - data["__cuTexRefSetAddressMode"] = __cuTexRefSetAddressMode + data["__cuTexRefSetAddressMode"] = <_cyb_intptr_t>__cuTexRefSetAddressMode global __cuTexRefSetFilterMode - data["__cuTexRefSetFilterMode"] = __cuTexRefSetFilterMode + data["__cuTexRefSetFilterMode"] = <_cyb_intptr_t>__cuTexRefSetFilterMode global __cuTexRefSetMipmapFilterMode - data["__cuTexRefSetMipmapFilterMode"] = __cuTexRefSetMipmapFilterMode + data["__cuTexRefSetMipmapFilterMode"] = <_cyb_intptr_t>__cuTexRefSetMipmapFilterMode global __cuTexRefSetMipmapLevelBias - data["__cuTexRefSetMipmapLevelBias"] = __cuTexRefSetMipmapLevelBias + data["__cuTexRefSetMipmapLevelBias"] = <_cyb_intptr_t>__cuTexRefSetMipmapLevelBias global __cuTexRefSetMipmapLevelClamp - data["__cuTexRefSetMipmapLevelClamp"] = __cuTexRefSetMipmapLevelClamp + data["__cuTexRefSetMipmapLevelClamp"] = <_cyb_intptr_t>__cuTexRefSetMipmapLevelClamp global __cuTexRefSetMaxAnisotropy - data["__cuTexRefSetMaxAnisotropy"] = __cuTexRefSetMaxAnisotropy + data["__cuTexRefSetMaxAnisotropy"] = <_cyb_intptr_t>__cuTexRefSetMaxAnisotropy global __cuTexRefSetBorderColor - data["__cuTexRefSetBorderColor"] = __cuTexRefSetBorderColor + data["__cuTexRefSetBorderColor"] = <_cyb_intptr_t>__cuTexRefSetBorderColor global __cuTexRefSetFlags - data["__cuTexRefSetFlags"] = __cuTexRefSetFlags + data["__cuTexRefSetFlags"] = <_cyb_intptr_t>__cuTexRefSetFlags global __cuTexRefGetAddress_v2 - data["__cuTexRefGetAddress_v2"] = __cuTexRefGetAddress_v2 + data["__cuTexRefGetAddress_v2"] = <_cyb_intptr_t>__cuTexRefGetAddress_v2 global __cuTexRefGetArray - data["__cuTexRefGetArray"] = __cuTexRefGetArray + data["__cuTexRefGetArray"] = <_cyb_intptr_t>__cuTexRefGetArray global __cuTexRefGetMipmappedArray - data["__cuTexRefGetMipmappedArray"] = __cuTexRefGetMipmappedArray + data["__cuTexRefGetMipmappedArray"] = <_cyb_intptr_t>__cuTexRefGetMipmappedArray global __cuTexRefGetAddressMode - data["__cuTexRefGetAddressMode"] = __cuTexRefGetAddressMode + data["__cuTexRefGetAddressMode"] = <_cyb_intptr_t>__cuTexRefGetAddressMode global __cuTexRefGetFilterMode - data["__cuTexRefGetFilterMode"] = __cuTexRefGetFilterMode + data["__cuTexRefGetFilterMode"] = <_cyb_intptr_t>__cuTexRefGetFilterMode global __cuTexRefGetFormat - data["__cuTexRefGetFormat"] = __cuTexRefGetFormat + data["__cuTexRefGetFormat"] = <_cyb_intptr_t>__cuTexRefGetFormat global __cuTexRefGetMipmapFilterMode - data["__cuTexRefGetMipmapFilterMode"] = __cuTexRefGetMipmapFilterMode + data["__cuTexRefGetMipmapFilterMode"] = <_cyb_intptr_t>__cuTexRefGetMipmapFilterMode global __cuTexRefGetMipmapLevelBias - data["__cuTexRefGetMipmapLevelBias"] = __cuTexRefGetMipmapLevelBias + data["__cuTexRefGetMipmapLevelBias"] = <_cyb_intptr_t>__cuTexRefGetMipmapLevelBias global __cuTexRefGetMipmapLevelClamp - data["__cuTexRefGetMipmapLevelClamp"] = __cuTexRefGetMipmapLevelClamp + data["__cuTexRefGetMipmapLevelClamp"] = <_cyb_intptr_t>__cuTexRefGetMipmapLevelClamp global __cuTexRefGetMaxAnisotropy - data["__cuTexRefGetMaxAnisotropy"] = __cuTexRefGetMaxAnisotropy + data["__cuTexRefGetMaxAnisotropy"] = <_cyb_intptr_t>__cuTexRefGetMaxAnisotropy global __cuTexRefGetBorderColor - data["__cuTexRefGetBorderColor"] = __cuTexRefGetBorderColor + data["__cuTexRefGetBorderColor"] = <_cyb_intptr_t>__cuTexRefGetBorderColor global __cuTexRefGetFlags - data["__cuTexRefGetFlags"] = __cuTexRefGetFlags + data["__cuTexRefGetFlags"] = <_cyb_intptr_t>__cuTexRefGetFlags global __cuTexRefCreate - data["__cuTexRefCreate"] = __cuTexRefCreate + data["__cuTexRefCreate"] = <_cyb_intptr_t>__cuTexRefCreate global __cuTexRefDestroy - data["__cuTexRefDestroy"] = __cuTexRefDestroy + data["__cuTexRefDestroy"] = <_cyb_intptr_t>__cuTexRefDestroy global __cuSurfRefSetArray - data["__cuSurfRefSetArray"] = __cuSurfRefSetArray + data["__cuSurfRefSetArray"] = <_cyb_intptr_t>__cuSurfRefSetArray global __cuSurfRefGetArray - data["__cuSurfRefGetArray"] = __cuSurfRefGetArray + data["__cuSurfRefGetArray"] = <_cyb_intptr_t>__cuSurfRefGetArray global __cuTexObjectCreate - data["__cuTexObjectCreate"] = __cuTexObjectCreate + data["__cuTexObjectCreate"] = <_cyb_intptr_t>__cuTexObjectCreate global __cuTexObjectDestroy - data["__cuTexObjectDestroy"] = __cuTexObjectDestroy + data["__cuTexObjectDestroy"] = <_cyb_intptr_t>__cuTexObjectDestroy global __cuTexObjectGetResourceDesc - data["__cuTexObjectGetResourceDesc"] = __cuTexObjectGetResourceDesc + data["__cuTexObjectGetResourceDesc"] = <_cyb_intptr_t>__cuTexObjectGetResourceDesc global __cuTexObjectGetTextureDesc - data["__cuTexObjectGetTextureDesc"] = __cuTexObjectGetTextureDesc + data["__cuTexObjectGetTextureDesc"] = <_cyb_intptr_t>__cuTexObjectGetTextureDesc global __cuTexObjectGetResourceViewDesc - data["__cuTexObjectGetResourceViewDesc"] = __cuTexObjectGetResourceViewDesc + data["__cuTexObjectGetResourceViewDesc"] = <_cyb_intptr_t>__cuTexObjectGetResourceViewDesc global __cuSurfObjectCreate - data["__cuSurfObjectCreate"] = __cuSurfObjectCreate + data["__cuSurfObjectCreate"] = <_cyb_intptr_t>__cuSurfObjectCreate global __cuSurfObjectDestroy - data["__cuSurfObjectDestroy"] = __cuSurfObjectDestroy + data["__cuSurfObjectDestroy"] = <_cyb_intptr_t>__cuSurfObjectDestroy global __cuSurfObjectGetResourceDesc - data["__cuSurfObjectGetResourceDesc"] = __cuSurfObjectGetResourceDesc + data["__cuSurfObjectGetResourceDesc"] = <_cyb_intptr_t>__cuSurfObjectGetResourceDesc global __cuTensorMapEncodeTiled - data["__cuTensorMapEncodeTiled"] = __cuTensorMapEncodeTiled + data["__cuTensorMapEncodeTiled"] = <_cyb_intptr_t>__cuTensorMapEncodeTiled global __cuTensorMapEncodeIm2col - data["__cuTensorMapEncodeIm2col"] = __cuTensorMapEncodeIm2col + data["__cuTensorMapEncodeIm2col"] = <_cyb_intptr_t>__cuTensorMapEncodeIm2col global __cuTensorMapEncodeIm2colWide - data["__cuTensorMapEncodeIm2colWide"] = __cuTensorMapEncodeIm2colWide + data["__cuTensorMapEncodeIm2colWide"] = <_cyb_intptr_t>__cuTensorMapEncodeIm2colWide global __cuTensorMapReplaceAddress - data["__cuTensorMapReplaceAddress"] = __cuTensorMapReplaceAddress + data["__cuTensorMapReplaceAddress"] = <_cyb_intptr_t>__cuTensorMapReplaceAddress global __cuDeviceCanAccessPeer - data["__cuDeviceCanAccessPeer"] = __cuDeviceCanAccessPeer + data["__cuDeviceCanAccessPeer"] = <_cyb_intptr_t>__cuDeviceCanAccessPeer global __cuCtxEnablePeerAccess - data["__cuCtxEnablePeerAccess"] = __cuCtxEnablePeerAccess + data["__cuCtxEnablePeerAccess"] = <_cyb_intptr_t>__cuCtxEnablePeerAccess global __cuCtxDisablePeerAccess - data["__cuCtxDisablePeerAccess"] = __cuCtxDisablePeerAccess + data["__cuCtxDisablePeerAccess"] = <_cyb_intptr_t>__cuCtxDisablePeerAccess global __cuDeviceGetP2PAttribute - data["__cuDeviceGetP2PAttribute"] = __cuDeviceGetP2PAttribute + data["__cuDeviceGetP2PAttribute"] = <_cyb_intptr_t>__cuDeviceGetP2PAttribute global __cuGraphicsUnregisterResource - data["__cuGraphicsUnregisterResource"] = __cuGraphicsUnregisterResource + data["__cuGraphicsUnregisterResource"] = <_cyb_intptr_t>__cuGraphicsUnregisterResource global __cuGraphicsSubResourceGetMappedArray - data["__cuGraphicsSubResourceGetMappedArray"] = __cuGraphicsSubResourceGetMappedArray + data["__cuGraphicsSubResourceGetMappedArray"] = <_cyb_intptr_t>__cuGraphicsSubResourceGetMappedArray global __cuGraphicsResourceGetMappedMipmappedArray - data["__cuGraphicsResourceGetMappedMipmappedArray"] = __cuGraphicsResourceGetMappedMipmappedArray + data["__cuGraphicsResourceGetMappedMipmappedArray"] = <_cyb_intptr_t>__cuGraphicsResourceGetMappedMipmappedArray global __cuGraphicsResourceGetMappedPointer_v2 - data["__cuGraphicsResourceGetMappedPointer_v2"] = __cuGraphicsResourceGetMappedPointer_v2 + data["__cuGraphicsResourceGetMappedPointer_v2"] = <_cyb_intptr_t>__cuGraphicsResourceGetMappedPointer_v2 global __cuGraphicsResourceSetMapFlags_v2 - data["__cuGraphicsResourceSetMapFlags_v2"] = __cuGraphicsResourceSetMapFlags_v2 + data["__cuGraphicsResourceSetMapFlags_v2"] = <_cyb_intptr_t>__cuGraphicsResourceSetMapFlags_v2 global __cuGraphicsMapResources - data["__cuGraphicsMapResources"] = __cuGraphicsMapResources + data["__cuGraphicsMapResources"] = <_cyb_intptr_t>__cuGraphicsMapResources global __cuGraphicsUnmapResources - data["__cuGraphicsUnmapResources"] = __cuGraphicsUnmapResources + data["__cuGraphicsUnmapResources"] = <_cyb_intptr_t>__cuGraphicsUnmapResources global __cuGetProcAddress_v2 - data["__cuGetProcAddress_v2"] = __cuGetProcAddress_v2 + data["__cuGetProcAddress_v2"] = <_cyb_intptr_t>__cuGetProcAddress_v2 global __cuCoredumpGetAttribute - data["__cuCoredumpGetAttribute"] = __cuCoredumpGetAttribute + data["__cuCoredumpGetAttribute"] = <_cyb_intptr_t>__cuCoredumpGetAttribute global __cuCoredumpGetAttributeGlobal - data["__cuCoredumpGetAttributeGlobal"] = __cuCoredumpGetAttributeGlobal + data["__cuCoredumpGetAttributeGlobal"] = <_cyb_intptr_t>__cuCoredumpGetAttributeGlobal global __cuCoredumpSetAttribute - data["__cuCoredumpSetAttribute"] = __cuCoredumpSetAttribute + data["__cuCoredumpSetAttribute"] = <_cyb_intptr_t>__cuCoredumpSetAttribute global __cuCoredumpSetAttributeGlobal - data["__cuCoredumpSetAttributeGlobal"] = __cuCoredumpSetAttributeGlobal + data["__cuCoredumpSetAttributeGlobal"] = <_cyb_intptr_t>__cuCoredumpSetAttributeGlobal global __cuGetExportTable - data["__cuGetExportTable"] = __cuGetExportTable + data["__cuGetExportTable"] = <_cyb_intptr_t>__cuGetExportTable global __cuGreenCtxCreate - data["__cuGreenCtxCreate"] = __cuGreenCtxCreate + data["__cuGreenCtxCreate"] = <_cyb_intptr_t>__cuGreenCtxCreate global __cuGreenCtxDestroy - data["__cuGreenCtxDestroy"] = __cuGreenCtxDestroy + data["__cuGreenCtxDestroy"] = <_cyb_intptr_t>__cuGreenCtxDestroy global __cuCtxFromGreenCtx - data["__cuCtxFromGreenCtx"] = __cuCtxFromGreenCtx + data["__cuCtxFromGreenCtx"] = <_cyb_intptr_t>__cuCtxFromGreenCtx global __cuDeviceGetDevResource - data["__cuDeviceGetDevResource"] = __cuDeviceGetDevResource + data["__cuDeviceGetDevResource"] = <_cyb_intptr_t>__cuDeviceGetDevResource global __cuCtxGetDevResource - data["__cuCtxGetDevResource"] = __cuCtxGetDevResource + data["__cuCtxGetDevResource"] = <_cyb_intptr_t>__cuCtxGetDevResource global __cuGreenCtxGetDevResource - data["__cuGreenCtxGetDevResource"] = __cuGreenCtxGetDevResource + data["__cuGreenCtxGetDevResource"] = <_cyb_intptr_t>__cuGreenCtxGetDevResource global __cuDevSmResourceSplitByCount - data["__cuDevSmResourceSplitByCount"] = __cuDevSmResourceSplitByCount + data["__cuDevSmResourceSplitByCount"] = <_cyb_intptr_t>__cuDevSmResourceSplitByCount global __cuDevResourceGenerateDesc - data["__cuDevResourceGenerateDesc"] = __cuDevResourceGenerateDesc + data["__cuDevResourceGenerateDesc"] = <_cyb_intptr_t>__cuDevResourceGenerateDesc global __cuGreenCtxRecordEvent - data["__cuGreenCtxRecordEvent"] = __cuGreenCtxRecordEvent + data["__cuGreenCtxRecordEvent"] = <_cyb_intptr_t>__cuGreenCtxRecordEvent global __cuGreenCtxWaitEvent - data["__cuGreenCtxWaitEvent"] = __cuGreenCtxWaitEvent + data["__cuGreenCtxWaitEvent"] = <_cyb_intptr_t>__cuGreenCtxWaitEvent global __cuStreamGetGreenCtx - data["__cuStreamGetGreenCtx"] = __cuStreamGetGreenCtx + data["__cuStreamGetGreenCtx"] = <_cyb_intptr_t>__cuStreamGetGreenCtx global __cuGreenCtxStreamCreate - data["__cuGreenCtxStreamCreate"] = __cuGreenCtxStreamCreate + data["__cuGreenCtxStreamCreate"] = <_cyb_intptr_t>__cuGreenCtxStreamCreate global __cuLogsRegisterCallback - data["__cuLogsRegisterCallback"] = __cuLogsRegisterCallback + data["__cuLogsRegisterCallback"] = <_cyb_intptr_t>__cuLogsRegisterCallback global __cuLogsUnregisterCallback - data["__cuLogsUnregisterCallback"] = __cuLogsUnregisterCallback + data["__cuLogsUnregisterCallback"] = <_cyb_intptr_t>__cuLogsUnregisterCallback global __cuLogsCurrent - data["__cuLogsCurrent"] = __cuLogsCurrent + data["__cuLogsCurrent"] = <_cyb_intptr_t>__cuLogsCurrent global __cuLogsDumpToFile - data["__cuLogsDumpToFile"] = __cuLogsDumpToFile + data["__cuLogsDumpToFile"] = <_cyb_intptr_t>__cuLogsDumpToFile global __cuLogsDumpToMemory - data["__cuLogsDumpToMemory"] = __cuLogsDumpToMemory + data["__cuLogsDumpToMemory"] = <_cyb_intptr_t>__cuLogsDumpToMemory global __cuCheckpointProcessGetRestoreThreadId - data["__cuCheckpointProcessGetRestoreThreadId"] = __cuCheckpointProcessGetRestoreThreadId + data["__cuCheckpointProcessGetRestoreThreadId"] = <_cyb_intptr_t>__cuCheckpointProcessGetRestoreThreadId global __cuCheckpointProcessGetState - data["__cuCheckpointProcessGetState"] = __cuCheckpointProcessGetState + data["__cuCheckpointProcessGetState"] = <_cyb_intptr_t>__cuCheckpointProcessGetState global __cuCheckpointProcessLock - data["__cuCheckpointProcessLock"] = __cuCheckpointProcessLock + data["__cuCheckpointProcessLock"] = <_cyb_intptr_t>__cuCheckpointProcessLock global __cuCheckpointProcessCheckpoint - data["__cuCheckpointProcessCheckpoint"] = __cuCheckpointProcessCheckpoint + data["__cuCheckpointProcessCheckpoint"] = <_cyb_intptr_t>__cuCheckpointProcessCheckpoint global __cuCheckpointProcessRestore - data["__cuCheckpointProcessRestore"] = __cuCheckpointProcessRestore + data["__cuCheckpointProcessRestore"] = <_cyb_intptr_t>__cuCheckpointProcessRestore global __cuCheckpointProcessUnlock - data["__cuCheckpointProcessUnlock"] = __cuCheckpointProcessUnlock + data["__cuCheckpointProcessUnlock"] = <_cyb_intptr_t>__cuCheckpointProcessUnlock global __cuGraphicsEGLRegisterImage - data["__cuGraphicsEGLRegisterImage"] = __cuGraphicsEGLRegisterImage + data["__cuGraphicsEGLRegisterImage"] = <_cyb_intptr_t>__cuGraphicsEGLRegisterImage global __cuEGLStreamConsumerConnect - data["__cuEGLStreamConsumerConnect"] = __cuEGLStreamConsumerConnect + data["__cuEGLStreamConsumerConnect"] = <_cyb_intptr_t>__cuEGLStreamConsumerConnect global __cuEGLStreamConsumerConnectWithFlags - data["__cuEGLStreamConsumerConnectWithFlags"] = __cuEGLStreamConsumerConnectWithFlags + data["__cuEGLStreamConsumerConnectWithFlags"] = <_cyb_intptr_t>__cuEGLStreamConsumerConnectWithFlags global __cuEGLStreamConsumerDisconnect - data["__cuEGLStreamConsumerDisconnect"] = __cuEGLStreamConsumerDisconnect + data["__cuEGLStreamConsumerDisconnect"] = <_cyb_intptr_t>__cuEGLStreamConsumerDisconnect global __cuEGLStreamConsumerAcquireFrame - data["__cuEGLStreamConsumerAcquireFrame"] = __cuEGLStreamConsumerAcquireFrame + data["__cuEGLStreamConsumerAcquireFrame"] = <_cyb_intptr_t>__cuEGLStreamConsumerAcquireFrame global __cuEGLStreamConsumerReleaseFrame - data["__cuEGLStreamConsumerReleaseFrame"] = __cuEGLStreamConsumerReleaseFrame + data["__cuEGLStreamConsumerReleaseFrame"] = <_cyb_intptr_t>__cuEGLStreamConsumerReleaseFrame global __cuEGLStreamProducerConnect - data["__cuEGLStreamProducerConnect"] = __cuEGLStreamProducerConnect + data["__cuEGLStreamProducerConnect"] = <_cyb_intptr_t>__cuEGLStreamProducerConnect global __cuEGLStreamProducerDisconnect - data["__cuEGLStreamProducerDisconnect"] = __cuEGLStreamProducerDisconnect + data["__cuEGLStreamProducerDisconnect"] = <_cyb_intptr_t>__cuEGLStreamProducerDisconnect global __cuEGLStreamProducerPresentFrame - data["__cuEGLStreamProducerPresentFrame"] = __cuEGLStreamProducerPresentFrame + data["__cuEGLStreamProducerPresentFrame"] = <_cyb_intptr_t>__cuEGLStreamProducerPresentFrame global __cuEGLStreamProducerReturnFrame - data["__cuEGLStreamProducerReturnFrame"] = __cuEGLStreamProducerReturnFrame + data["__cuEGLStreamProducerReturnFrame"] = <_cyb_intptr_t>__cuEGLStreamProducerReturnFrame global __cuGraphicsResourceGetMappedEglFrame - data["__cuGraphicsResourceGetMappedEglFrame"] = __cuGraphicsResourceGetMappedEglFrame + data["__cuGraphicsResourceGetMappedEglFrame"] = <_cyb_intptr_t>__cuGraphicsResourceGetMappedEglFrame global __cuEventCreateFromEGLSync - data["__cuEventCreateFromEGLSync"] = __cuEventCreateFromEGLSync + data["__cuEventCreateFromEGLSync"] = <_cyb_intptr_t>__cuEventCreateFromEGLSync global __cuGraphicsGLRegisterBuffer - data["__cuGraphicsGLRegisterBuffer"] = __cuGraphicsGLRegisterBuffer + data["__cuGraphicsGLRegisterBuffer"] = <_cyb_intptr_t>__cuGraphicsGLRegisterBuffer global __cuGraphicsGLRegisterImage - data["__cuGraphicsGLRegisterImage"] = __cuGraphicsGLRegisterImage + data["__cuGraphicsGLRegisterImage"] = <_cyb_intptr_t>__cuGraphicsGLRegisterImage global __cuGLGetDevices_v2 - data["__cuGLGetDevices_v2"] = __cuGLGetDevices_v2 + data["__cuGLGetDevices_v2"] = <_cyb_intptr_t>__cuGLGetDevices_v2 global __cuGLCtxCreate_v2 - data["__cuGLCtxCreate_v2"] = __cuGLCtxCreate_v2 + data["__cuGLCtxCreate_v2"] = <_cyb_intptr_t>__cuGLCtxCreate_v2 global __cuGLInit - data["__cuGLInit"] = __cuGLInit + data["__cuGLInit"] = <_cyb_intptr_t>__cuGLInit global __cuGLRegisterBufferObject - data["__cuGLRegisterBufferObject"] = __cuGLRegisterBufferObject + data["__cuGLRegisterBufferObject"] = <_cyb_intptr_t>__cuGLRegisterBufferObject global __cuGLMapBufferObject_v2 - data["__cuGLMapBufferObject_v2"] = __cuGLMapBufferObject_v2 + data["__cuGLMapBufferObject_v2"] = <_cyb_intptr_t>__cuGLMapBufferObject_v2 global __cuGLUnmapBufferObject - data["__cuGLUnmapBufferObject"] = __cuGLUnmapBufferObject + data["__cuGLUnmapBufferObject"] = <_cyb_intptr_t>__cuGLUnmapBufferObject global __cuGLUnregisterBufferObject - data["__cuGLUnregisterBufferObject"] = __cuGLUnregisterBufferObject + data["__cuGLUnregisterBufferObject"] = <_cyb_intptr_t>__cuGLUnregisterBufferObject global __cuGLSetBufferObjectMapFlags - data["__cuGLSetBufferObjectMapFlags"] = __cuGLSetBufferObjectMapFlags + data["__cuGLSetBufferObjectMapFlags"] = <_cyb_intptr_t>__cuGLSetBufferObjectMapFlags global __cuGLMapBufferObjectAsync_v2 - data["__cuGLMapBufferObjectAsync_v2"] = __cuGLMapBufferObjectAsync_v2 + data["__cuGLMapBufferObjectAsync_v2"] = <_cyb_intptr_t>__cuGLMapBufferObjectAsync_v2 global __cuGLUnmapBufferObjectAsync - data["__cuGLUnmapBufferObjectAsync"] = __cuGLUnmapBufferObjectAsync + data["__cuGLUnmapBufferObjectAsync"] = <_cyb_intptr_t>__cuGLUnmapBufferObjectAsync global __cuProfilerInitialize - data["__cuProfilerInitialize"] = __cuProfilerInitialize + data["__cuProfilerInitialize"] = <_cyb_intptr_t>__cuProfilerInitialize global __cuProfilerStart - data["__cuProfilerStart"] = __cuProfilerStart + data["__cuProfilerStart"] = <_cyb_intptr_t>__cuProfilerStart global __cuProfilerStop - data["__cuProfilerStop"] = __cuProfilerStop + data["__cuProfilerStop"] = <_cyb_intptr_t>__cuProfilerStop global __cuVDPAUGetDevice - data["__cuVDPAUGetDevice"] = __cuVDPAUGetDevice + data["__cuVDPAUGetDevice"] = <_cyb_intptr_t>__cuVDPAUGetDevice global __cuVDPAUCtxCreate_v2 - data["__cuVDPAUCtxCreate_v2"] = __cuVDPAUCtxCreate_v2 + data["__cuVDPAUCtxCreate_v2"] = <_cyb_intptr_t>__cuVDPAUCtxCreate_v2 global __cuGraphicsVDPAURegisterVideoSurface - data["__cuGraphicsVDPAURegisterVideoSurface"] = __cuGraphicsVDPAURegisterVideoSurface + data["__cuGraphicsVDPAURegisterVideoSurface"] = <_cyb_intptr_t>__cuGraphicsVDPAURegisterVideoSurface global __cuGraphicsVDPAURegisterOutputSurface - data["__cuGraphicsVDPAURegisterOutputSurface"] = __cuGraphicsVDPAURegisterOutputSurface + data["__cuGraphicsVDPAURegisterOutputSurface"] = <_cyb_intptr_t>__cuGraphicsVDPAURegisterOutputSurface global __cuDeviceGetHostAtomicCapabilities - data["__cuDeviceGetHostAtomicCapabilities"] = __cuDeviceGetHostAtomicCapabilities + data["__cuDeviceGetHostAtomicCapabilities"] = <_cyb_intptr_t>__cuDeviceGetHostAtomicCapabilities global __cuCtxGetDevice_v2 - data["__cuCtxGetDevice_v2"] = __cuCtxGetDevice_v2 + data["__cuCtxGetDevice_v2"] = <_cyb_intptr_t>__cuCtxGetDevice_v2 global __cuCtxSynchronize_v2 - data["__cuCtxSynchronize_v2"] = __cuCtxSynchronize_v2 + data["__cuCtxSynchronize_v2"] = <_cyb_intptr_t>__cuCtxSynchronize_v2 global __cuMemcpyBatchAsync_v2 - data["__cuMemcpyBatchAsync_v2"] = __cuMemcpyBatchAsync_v2 + data["__cuMemcpyBatchAsync_v2"] = <_cyb_intptr_t>__cuMemcpyBatchAsync_v2 global __cuMemcpy3DBatchAsync_v2 - data["__cuMemcpy3DBatchAsync_v2"] = __cuMemcpy3DBatchAsync_v2 + data["__cuMemcpy3DBatchAsync_v2"] = <_cyb_intptr_t>__cuMemcpy3DBatchAsync_v2 global __cuMemGetDefaultMemPool - data["__cuMemGetDefaultMemPool"] = __cuMemGetDefaultMemPool + data["__cuMemGetDefaultMemPool"] = <_cyb_intptr_t>__cuMemGetDefaultMemPool global __cuMemGetMemPool - data["__cuMemGetMemPool"] = __cuMemGetMemPool + data["__cuMemGetMemPool"] = <_cyb_intptr_t>__cuMemGetMemPool global __cuMemSetMemPool - data["__cuMemSetMemPool"] = __cuMemSetMemPool + data["__cuMemSetMemPool"] = <_cyb_intptr_t>__cuMemSetMemPool global __cuMemPrefetchBatchAsync - data["__cuMemPrefetchBatchAsync"] = __cuMemPrefetchBatchAsync + data["__cuMemPrefetchBatchAsync"] = <_cyb_intptr_t>__cuMemPrefetchBatchAsync global __cuMemDiscardBatchAsync - data["__cuMemDiscardBatchAsync"] = __cuMemDiscardBatchAsync + data["__cuMemDiscardBatchAsync"] = <_cyb_intptr_t>__cuMemDiscardBatchAsync global __cuMemDiscardAndPrefetchBatchAsync - data["__cuMemDiscardAndPrefetchBatchAsync"] = __cuMemDiscardAndPrefetchBatchAsync + data["__cuMemDiscardAndPrefetchBatchAsync"] = <_cyb_intptr_t>__cuMemDiscardAndPrefetchBatchAsync global __cuDeviceGetP2PAtomicCapabilities - data["__cuDeviceGetP2PAtomicCapabilities"] = __cuDeviceGetP2PAtomicCapabilities + data["__cuDeviceGetP2PAtomicCapabilities"] = <_cyb_intptr_t>__cuDeviceGetP2PAtomicCapabilities global __cuGreenCtxGetId - data["__cuGreenCtxGetId"] = __cuGreenCtxGetId + data["__cuGreenCtxGetId"] = <_cyb_intptr_t>__cuGreenCtxGetId global __cuMulticastBindMem_v2 - data["__cuMulticastBindMem_v2"] = __cuMulticastBindMem_v2 + data["__cuMulticastBindMem_v2"] = <_cyb_intptr_t>__cuMulticastBindMem_v2 global __cuMulticastBindAddr_v2 - data["__cuMulticastBindAddr_v2"] = __cuMulticastBindAddr_v2 + data["__cuMulticastBindAddr_v2"] = <_cyb_intptr_t>__cuMulticastBindAddr_v2 global __cuGraphNodeGetContainingGraph - data["__cuGraphNodeGetContainingGraph"] = __cuGraphNodeGetContainingGraph + data["__cuGraphNodeGetContainingGraph"] = <_cyb_intptr_t>__cuGraphNodeGetContainingGraph global __cuGraphNodeGetLocalId - data["__cuGraphNodeGetLocalId"] = __cuGraphNodeGetLocalId + data["__cuGraphNodeGetLocalId"] = <_cyb_intptr_t>__cuGraphNodeGetLocalId global __cuGraphNodeGetToolsId - data["__cuGraphNodeGetToolsId"] = __cuGraphNodeGetToolsId + data["__cuGraphNodeGetToolsId"] = <_cyb_intptr_t>__cuGraphNodeGetToolsId global __cuGraphGetId - data["__cuGraphGetId"] = __cuGraphGetId + data["__cuGraphGetId"] = <_cyb_intptr_t>__cuGraphGetId global __cuGraphExecGetId - data["__cuGraphExecGetId"] = __cuGraphExecGetId + data["__cuGraphExecGetId"] = <_cyb_intptr_t>__cuGraphExecGetId global __cuDevSmResourceSplit - data["__cuDevSmResourceSplit"] = __cuDevSmResourceSplit + data["__cuDevSmResourceSplit"] = <_cyb_intptr_t>__cuDevSmResourceSplit global __cuStreamGetDevResource - data["__cuStreamGetDevResource"] = __cuStreamGetDevResource + data["__cuStreamGetDevResource"] = <_cyb_intptr_t>__cuStreamGetDevResource global __cuKernelGetParamCount - data["__cuKernelGetParamCount"] = __cuKernelGetParamCount + data["__cuKernelGetParamCount"] = <_cyb_intptr_t>__cuKernelGetParamCount global __cuMemcpyWithAttributesAsync - data["__cuMemcpyWithAttributesAsync"] = __cuMemcpyWithAttributesAsync + data["__cuMemcpyWithAttributesAsync"] = <_cyb_intptr_t>__cuMemcpyWithAttributesAsync global __cuMemcpy3DWithAttributesAsync - data["__cuMemcpy3DWithAttributesAsync"] = __cuMemcpy3DWithAttributesAsync + data["__cuMemcpy3DWithAttributesAsync"] = <_cyb_intptr_t>__cuMemcpy3DWithAttributesAsync global __cuStreamBeginCaptureToCig - data["__cuStreamBeginCaptureToCig"] = __cuStreamBeginCaptureToCig + data["__cuStreamBeginCaptureToCig"] = <_cyb_intptr_t>__cuStreamBeginCaptureToCig global __cuStreamEndCaptureToCig - data["__cuStreamEndCaptureToCig"] = __cuStreamEndCaptureToCig + data["__cuStreamEndCaptureToCig"] = <_cyb_intptr_t>__cuStreamEndCaptureToCig global __cuFuncGetParamCount - data["__cuFuncGetParamCount"] = __cuFuncGetParamCount + data["__cuFuncGetParamCount"] = <_cyb_intptr_t>__cuFuncGetParamCount global __cuLaunchHostFunc_v2 - data["__cuLaunchHostFunc_v2"] = __cuLaunchHostFunc_v2 + data["__cuLaunchHostFunc_v2"] = <_cyb_intptr_t>__cuLaunchHostFunc_v2 global __cuGraphNodeGetParams - data["__cuGraphNodeGetParams"] = __cuGraphNodeGetParams + data["__cuGraphNodeGetParams"] = <_cyb_intptr_t>__cuGraphNodeGetParams global __cuCoredumpRegisterStartCallback - data["__cuCoredumpRegisterStartCallback"] = __cuCoredumpRegisterStartCallback + data["__cuCoredumpRegisterStartCallback"] = <_cyb_intptr_t>__cuCoredumpRegisterStartCallback global __cuCoredumpRegisterCompleteCallback - data["__cuCoredumpRegisterCompleteCallback"] = __cuCoredumpRegisterCompleteCallback + data["__cuCoredumpRegisterCompleteCallback"] = <_cyb_intptr_t>__cuCoredumpRegisterCompleteCallback global __cuCoredumpDeregisterStartCallback - data["__cuCoredumpDeregisterStartCallback"] = __cuCoredumpDeregisterStartCallback + data["__cuCoredumpDeregisterStartCallback"] = <_cyb_intptr_t>__cuCoredumpDeregisterStartCallback global __cuCoredumpDeregisterCompleteCallback - data["__cuCoredumpDeregisterCompleteCallback"] = __cuCoredumpDeregisterCompleteCallback + data["__cuCoredumpDeregisterCompleteCallback"] = <_cyb_intptr_t>__cuCoredumpDeregisterCompleteCallback global __cuLogicalEndpointIdReserve - data["__cuLogicalEndpointIdReserve"] = __cuLogicalEndpointIdReserve + data["__cuLogicalEndpointIdReserve"] = <_cyb_intptr_t>__cuLogicalEndpointIdReserve global __cuLogicalEndpointIdRelease - data["__cuLogicalEndpointIdRelease"] = __cuLogicalEndpointIdRelease + data["__cuLogicalEndpointIdRelease"] = <_cyb_intptr_t>__cuLogicalEndpointIdRelease global __cuLogicalEndpointCreate - data["__cuLogicalEndpointCreate"] = __cuLogicalEndpointCreate + data["__cuLogicalEndpointCreate"] = <_cyb_intptr_t>__cuLogicalEndpointCreate global __cuLogicalEndpointAddDevice - data["__cuLogicalEndpointAddDevice"] = __cuLogicalEndpointAddDevice + data["__cuLogicalEndpointAddDevice"] = <_cyb_intptr_t>__cuLogicalEndpointAddDevice global __cuLogicalEndpointDestroy - data["__cuLogicalEndpointDestroy"] = __cuLogicalEndpointDestroy + data["__cuLogicalEndpointDestroy"] = <_cyb_intptr_t>__cuLogicalEndpointDestroy global __cuLogicalEndpointBindAddr - data["__cuLogicalEndpointBindAddr"] = __cuLogicalEndpointBindAddr + data["__cuLogicalEndpointBindAddr"] = <_cyb_intptr_t>__cuLogicalEndpointBindAddr global __cuLogicalEndpointBindMem - data["__cuLogicalEndpointBindMem"] = __cuLogicalEndpointBindMem + data["__cuLogicalEndpointBindMem"] = <_cyb_intptr_t>__cuLogicalEndpointBindMem global __cuLogicalEndpointUnbind - data["__cuLogicalEndpointUnbind"] = __cuLogicalEndpointUnbind + data["__cuLogicalEndpointUnbind"] = <_cyb_intptr_t>__cuLogicalEndpointUnbind global __cuLogicalEndpointExport - data["__cuLogicalEndpointExport"] = __cuLogicalEndpointExport + data["__cuLogicalEndpointExport"] = <_cyb_intptr_t>__cuLogicalEndpointExport global __cuLogicalEndpointImport - data["__cuLogicalEndpointImport"] = __cuLogicalEndpointImport + data["__cuLogicalEndpointImport"] = <_cyb_intptr_t>__cuLogicalEndpointImport global __cuLogicalEndpointGetLimits - data["__cuLogicalEndpointGetLimits"] = __cuLogicalEndpointGetLimits + data["__cuLogicalEndpointGetLimits"] = <_cyb_intptr_t>__cuLogicalEndpointGetLimits global __cuLogicalEndpointQuery - data["__cuLogicalEndpointQuery"] = __cuLogicalEndpointQuery + data["__cuLogicalEndpointQuery"] = <_cyb_intptr_t>__cuLogicalEndpointQuery global __cuStreamBeginRecaptureToGraph - data["__cuStreamBeginRecaptureToGraph"] = __cuStreamBeginRecaptureToGraph - - func_ptrs = data + data["__cuStreamBeginRecaptureToGraph"] = <_cyb_intptr_t>__cuStreamBeginRecaptureToGraph + _cyb_func_ptrs = data return data cpdef _inspect_function_pointer(str name): - global func_ptrs - if func_ptrs is None: - func_ptrs = _inspect_function_pointers() - return func_ptrs[name] + global _cyb_func_ptrs + if _cyb_func_ptrs is None: + _cyb_func_ptrs = _inspect_function_pointers() + return _cyb_func_ptrs[name] + + + + +cdef uintptr_t load_library() except* with gil: + cdef uintptr_t handle = load_nvidia_dynamic_lib("cuda")._handle_uint + return handle ############################################################################### diff --git a/cuda_bindings/cuda/bindings/_internal/nvfatbin_linux.pyx b/cuda_bindings/cuda/bindings/_internal/nvfatbin_linux.pyx index e30e9ee145d..8cdec7065b3 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvfatbin_linux.pyx +++ b/cuda_bindings/cuda/bindings/_internal/nvfatbin_linux.pyx @@ -3,63 +3,35 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.4.1 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=8a025fac12ad4fa9dc651c68c1ab7948f78cbb4b9450935db8f930c9d44988f4 -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=821fd26991431cd8e528f964b5035e1deafcddf44d2971a267d9ed11d80d5199 -from libc.stdint cimport intptr_t, uintptr_t -import threading -from .utils import FunctionNotFoundError, NotSupportedError - -from cuda.pathfinder import load_nvidia_dynamic_lib - - -############################################################################### -# Extern -############################################################################### - -# You must 'from .utils import NotSupportedError' before using this template +# <<<< PREAMBLE CONTENT >>>> -cdef extern from "" nogil: - void* dlopen(const char*, int) - char* dlerror() - void* dlsym(void*, const char*) - int dlclose(void*) +cdef extern from "": + void* _cyb_dlsym "dlsym"(void*, const char*) nogil + const void * _cyb_RTLD_DEFAULT "RTLD_DEFAULT" - enum: - RTLD_LAZY - RTLD_NOW - RTLD_GLOBAL - RTLD_LOCAL +from libc.stdint cimport intptr_t as _cyb_intptr_t - const void* RTLD_DEFAULT 'RTLD_DEFAULT' +import threading as _cyb_threading -cdef int get_cuda_version(): - cdef void* handle = NULL - cdef int err, driver_ver = 0 +cdef bint _cyb___py_nvfatbin_init = False +cdef dict _cyb_func_ptrs = None +cdef object _cyb_symbol_lock = _cyb_threading.Lock() - # Load driver to check version - handle = dlopen('libcuda.so.1', RTLD_NOW | RTLD_GLOBAL) - if handle == NULL: - err_msg = dlerror() - raise NotSupportedError(f'CUDA driver is not found ({err_msg.decode()})') - cuDriverGetVersion = dlsym(handle, "cuDriverGetVersion") - if cuDriverGetVersion == NULL: - raise RuntimeError('Did not find cuDriverGetVersion symbol in libcuda.so.1') - err = (cuDriverGetVersion)(&driver_ver) - if err != 0: - raise RuntimeError(f'cuDriverGetVersion returned error code {err}') +# <<<< END OF PREAMBLE CONTENT >>>> - return driver_ver +from libc.stdint cimport uintptr_t +from .utils import FunctionNotFoundError, NotSupportedError +from cuda.pathfinder import load_nvidia_dynamic_lib ############################################################################### # Wrapper init ############################################################################### -cdef object __symbol_lock = threading.Lock() -cdef bint __py_nvfatbin_init = False - cdef void* __nvFatbinGetErrorString = NULL cdef void* __nvFatbinCreate = NULL cdef void* __nvFatbinDestroy = NULL @@ -73,173 +45,164 @@ cdef void* __nvFatbinAddIndex = NULL cdef void* __nvFatbinAddReloc = NULL cdef void* __nvFatbinAddTileIR = NULL - -cdef void* load_library() except* with gil: - cdef uintptr_t handle = load_nvidia_dynamic_lib("nvfatbin")._handle_uint - return handle - - cdef int _init_nvfatbin() except -1 nogil: - global __py_nvfatbin_init - + global _cyb___py_nvfatbin_init cdef void* handle = NULL + with gil, _cyb_symbol_lock: + if _cyb___py_nvfatbin_init: return 0 - with gil, __symbol_lock: - # Recheck the flag after obtaining the locks - if __py_nvfatbin_init: - return 0 - - # Load function global __nvFatbinGetErrorString - __nvFatbinGetErrorString = dlsym(RTLD_DEFAULT, 'nvFatbinGetErrorString') + __nvFatbinGetErrorString = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvFatbinGetErrorString') if __nvFatbinGetErrorString == NULL: if handle == NULL: handle = load_library() - __nvFatbinGetErrorString = dlsym(handle, 'nvFatbinGetErrorString') + __nvFatbinGetErrorString = _cyb_dlsym(handle, 'nvFatbinGetErrorString') global __nvFatbinCreate - __nvFatbinCreate = dlsym(RTLD_DEFAULT, 'nvFatbinCreate') + __nvFatbinCreate = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvFatbinCreate') if __nvFatbinCreate == NULL: if handle == NULL: handle = load_library() - __nvFatbinCreate = dlsym(handle, 'nvFatbinCreate') + __nvFatbinCreate = _cyb_dlsym(handle, 'nvFatbinCreate') global __nvFatbinDestroy - __nvFatbinDestroy = dlsym(RTLD_DEFAULT, 'nvFatbinDestroy') + __nvFatbinDestroy = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvFatbinDestroy') if __nvFatbinDestroy == NULL: if handle == NULL: handle = load_library() - __nvFatbinDestroy = dlsym(handle, 'nvFatbinDestroy') + __nvFatbinDestroy = _cyb_dlsym(handle, 'nvFatbinDestroy') global __nvFatbinAddPTX - __nvFatbinAddPTX = dlsym(RTLD_DEFAULT, 'nvFatbinAddPTX') + __nvFatbinAddPTX = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvFatbinAddPTX') if __nvFatbinAddPTX == NULL: if handle == NULL: handle = load_library() - __nvFatbinAddPTX = dlsym(handle, 'nvFatbinAddPTX') + __nvFatbinAddPTX = _cyb_dlsym(handle, 'nvFatbinAddPTX') global __nvFatbinAddCubin - __nvFatbinAddCubin = dlsym(RTLD_DEFAULT, 'nvFatbinAddCubin') + __nvFatbinAddCubin = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvFatbinAddCubin') if __nvFatbinAddCubin == NULL: if handle == NULL: handle = load_library() - __nvFatbinAddCubin = dlsym(handle, 'nvFatbinAddCubin') + __nvFatbinAddCubin = _cyb_dlsym(handle, 'nvFatbinAddCubin') global __nvFatbinAddLTOIR - __nvFatbinAddLTOIR = dlsym(RTLD_DEFAULT, 'nvFatbinAddLTOIR') + __nvFatbinAddLTOIR = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvFatbinAddLTOIR') if __nvFatbinAddLTOIR == NULL: if handle == NULL: handle = load_library() - __nvFatbinAddLTOIR = dlsym(handle, 'nvFatbinAddLTOIR') + __nvFatbinAddLTOIR = _cyb_dlsym(handle, 'nvFatbinAddLTOIR') global __nvFatbinSize - __nvFatbinSize = dlsym(RTLD_DEFAULT, 'nvFatbinSize') + __nvFatbinSize = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvFatbinSize') if __nvFatbinSize == NULL: if handle == NULL: handle = load_library() - __nvFatbinSize = dlsym(handle, 'nvFatbinSize') + __nvFatbinSize = _cyb_dlsym(handle, 'nvFatbinSize') global __nvFatbinGet - __nvFatbinGet = dlsym(RTLD_DEFAULT, 'nvFatbinGet') + __nvFatbinGet = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvFatbinGet') if __nvFatbinGet == NULL: if handle == NULL: handle = load_library() - __nvFatbinGet = dlsym(handle, 'nvFatbinGet') + __nvFatbinGet = _cyb_dlsym(handle, 'nvFatbinGet') global __nvFatbinVersion - __nvFatbinVersion = dlsym(RTLD_DEFAULT, 'nvFatbinVersion') + __nvFatbinVersion = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvFatbinVersion') if __nvFatbinVersion == NULL: if handle == NULL: handle = load_library() - __nvFatbinVersion = dlsym(handle, 'nvFatbinVersion') + __nvFatbinVersion = _cyb_dlsym(handle, 'nvFatbinVersion') global __nvFatbinAddIndex - __nvFatbinAddIndex = dlsym(RTLD_DEFAULT, 'nvFatbinAddIndex') + __nvFatbinAddIndex = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvFatbinAddIndex') if __nvFatbinAddIndex == NULL: if handle == NULL: handle = load_library() - __nvFatbinAddIndex = dlsym(handle, 'nvFatbinAddIndex') + __nvFatbinAddIndex = _cyb_dlsym(handle, 'nvFatbinAddIndex') global __nvFatbinAddReloc - __nvFatbinAddReloc = dlsym(RTLD_DEFAULT, 'nvFatbinAddReloc') + __nvFatbinAddReloc = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvFatbinAddReloc') if __nvFatbinAddReloc == NULL: if handle == NULL: handle = load_library() - __nvFatbinAddReloc = dlsym(handle, 'nvFatbinAddReloc') + __nvFatbinAddReloc = _cyb_dlsym(handle, 'nvFatbinAddReloc') global __nvFatbinAddTileIR - __nvFatbinAddTileIR = dlsym(RTLD_DEFAULT, 'nvFatbinAddTileIR') + __nvFatbinAddTileIR = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvFatbinAddTileIR') if __nvFatbinAddTileIR == NULL: if handle == NULL: handle = load_library() - __nvFatbinAddTileIR = dlsym(handle, 'nvFatbinAddTileIR') + __nvFatbinAddTileIR = _cyb_dlsym(handle, 'nvFatbinAddTileIR') - __py_nvfatbin_init = True + _cyb___py_nvfatbin_init = True return 0 - cdef inline int _check_or_init_nvfatbin() except -1 nogil: - if __py_nvfatbin_init: + if _cyb___py_nvfatbin_init: return 0 return _init_nvfatbin() -cdef dict func_ptrs = None - cpdef dict _inspect_function_pointers(): - global func_ptrs - if func_ptrs is not None: - return func_ptrs + global _cyb_func_ptrs + if _cyb_func_ptrs is not None: + return _cyb_func_ptrs _check_or_init_nvfatbin() cdef dict data = {} - global __nvFatbinGetErrorString - data["__nvFatbinGetErrorString"] = __nvFatbinGetErrorString + data["__nvFatbinGetErrorString"] = <_cyb_intptr_t>__nvFatbinGetErrorString global __nvFatbinCreate - data["__nvFatbinCreate"] = __nvFatbinCreate + data["__nvFatbinCreate"] = <_cyb_intptr_t>__nvFatbinCreate global __nvFatbinDestroy - data["__nvFatbinDestroy"] = __nvFatbinDestroy + data["__nvFatbinDestroy"] = <_cyb_intptr_t>__nvFatbinDestroy global __nvFatbinAddPTX - data["__nvFatbinAddPTX"] = __nvFatbinAddPTX + data["__nvFatbinAddPTX"] = <_cyb_intptr_t>__nvFatbinAddPTX global __nvFatbinAddCubin - data["__nvFatbinAddCubin"] = __nvFatbinAddCubin + data["__nvFatbinAddCubin"] = <_cyb_intptr_t>__nvFatbinAddCubin global __nvFatbinAddLTOIR - data["__nvFatbinAddLTOIR"] = __nvFatbinAddLTOIR + data["__nvFatbinAddLTOIR"] = <_cyb_intptr_t>__nvFatbinAddLTOIR global __nvFatbinSize - data["__nvFatbinSize"] = __nvFatbinSize + data["__nvFatbinSize"] = <_cyb_intptr_t>__nvFatbinSize global __nvFatbinGet - data["__nvFatbinGet"] = __nvFatbinGet + data["__nvFatbinGet"] = <_cyb_intptr_t>__nvFatbinGet global __nvFatbinVersion - data["__nvFatbinVersion"] = __nvFatbinVersion + data["__nvFatbinVersion"] = <_cyb_intptr_t>__nvFatbinVersion global __nvFatbinAddIndex - data["__nvFatbinAddIndex"] = __nvFatbinAddIndex + data["__nvFatbinAddIndex"] = <_cyb_intptr_t>__nvFatbinAddIndex global __nvFatbinAddReloc - data["__nvFatbinAddReloc"] = __nvFatbinAddReloc + data["__nvFatbinAddReloc"] = <_cyb_intptr_t>__nvFatbinAddReloc global __nvFatbinAddTileIR - data["__nvFatbinAddTileIR"] = __nvFatbinAddTileIR - - func_ptrs = data + data["__nvFatbinAddTileIR"] = <_cyb_intptr_t>__nvFatbinAddTileIR + _cyb_func_ptrs = data return data cpdef _inspect_function_pointer(str name): - global func_ptrs - if func_ptrs is None: - func_ptrs = _inspect_function_pointers() - return func_ptrs[name] + global _cyb_func_ptrs + if _cyb_func_ptrs is None: + _cyb_func_ptrs = _inspect_function_pointers() + return _cyb_func_ptrs[name] + + + + +cdef void* load_library() except* with gil: + cdef uintptr_t handle = load_nvidia_dynamic_lib("nvfatbin")._handle_uint + return handle ############################################################################### diff --git a/cuda_bindings/cuda/bindings/_internal/nvfatbin_windows.pyx b/cuda_bindings/cuda/bindings/_internal/nvfatbin_windows.pyx index b82882cfd76..c9bb82113cb 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvfatbin_windows.pyx +++ b/cuda_bindings/cuda/bindings/_internal/nvfatbin_windows.pyx @@ -3,81 +3,32 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.4.1 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=c44272bf506dcc20b5771a20fb6efc77f920c9b9bb21a89b53e3a9e7d69ce1ef -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=2052c33a9bbfdef36b362c4eedc1284ce8fa2fc905a53ac9c366218ca99f5913 -from libc.stdint cimport intptr_t -import threading -from .utils import FunctionNotFoundError, NotSupportedError - -from cuda.pathfinder import load_nvidia_dynamic_lib +# <<<< PREAMBLE CONTENT >>>> -from libc.stddef cimport wchar_t -from libc.stdint cimport uintptr_t -from cpython cimport PyUnicode_AsWideCharString, PyMem_Free +cdef extern from "": + ctypedef void* HMODULE + void* _cyb_GetProcAddress "GetProcAddress"(HMODULE, const char*) nogil -# You must 'from .utils import NotSupportedError' before using this template +from libc.stdint cimport intptr_t as _cyb_intptr_t -cdef extern from "windows.h" nogil: - ctypedef void* HMODULE - ctypedef void* HANDLE - ctypedef void* FARPROC - ctypedef unsigned long DWORD - ctypedef const wchar_t *LPCWSTR - ctypedef const char *LPCSTR - - cdef DWORD LOAD_LIBRARY_SEARCH_SYSTEM32 = 0x00000800 - cdef DWORD LOAD_LIBRARY_SEARCH_DEFAULT_DIRS = 0x00001000 - cdef DWORD LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR = 0x00000100 - - HMODULE _LoadLibraryExW "LoadLibraryExW"( - LPCWSTR lpLibFileName, - HANDLE hFile, - DWORD dwFlags - ) - - FARPROC _GetProcAddress "GetProcAddress"(HMODULE hModule, LPCSTR lpProcName) - -cdef inline uintptr_t LoadLibraryExW(str path, HANDLE hFile, DWORD dwFlags): - cdef uintptr_t result - cdef wchar_t* wpath = PyUnicode_AsWideCharString(path, NULL) - with nogil: - result = _LoadLibraryExW( - wpath, - hFile, - dwFlags - ) - PyMem_Free(wpath) - return result - -cdef inline void *GetProcAddress(uintptr_t hModule, const char* lpProcName) nogil: - return _GetProcAddress(hModule, lpProcName) - -cdef int get_cuda_version(): - cdef int err, driver_ver = 0 - - # Load driver to check version - handle = LoadLibraryExW("nvcuda.dll", NULL, LOAD_LIBRARY_SEARCH_SYSTEM32) - if handle == 0: - raise NotSupportedError('CUDA driver is not found') - cuDriverGetVersion = GetProcAddress(handle, 'cuDriverGetVersion') - if cuDriverGetVersion == NULL: - raise RuntimeError('Did not find cuDriverGetVersion symbol in nvcuda.dll') - err = (cuDriverGetVersion)(&driver_ver) - if err != 0: - raise RuntimeError(f'cuDriverGetVersion returned error code {err}') - - return driver_ver +import threading as _cyb_threading +cdef bint _cyb___py_nvfatbin_init = False +cdef dict _cyb_func_ptrs = None +cdef object _cyb_symbol_lock = _cyb_threading.Lock() +# <<<< END OF PREAMBLE CONTENT >>>> +from libc.stdint cimport uintptr_t +from cuda.pathfinder import load_nvidia_dynamic_lib +from .utils import FunctionNotFoundError, NotSupportedError ############################################################################### # Wrapper init ############################################################################### -cdef object __symbol_lock = threading.Lock() -cdef bint __py_nvfatbin_init = False - cdef void* __nvFatbinGetErrorString = NULL cdef void* __nvFatbinCreate = NULL cdef void* __nvFatbinDestroy = NULL @@ -91,122 +42,118 @@ cdef void* __nvFatbinAddIndex = NULL cdef void* __nvFatbinAddReloc = NULL cdef void* __nvFatbinAddTileIR = NULL - cdef int _init_nvfatbin() except -1 nogil: - global __py_nvfatbin_init + global _cyb___py_nvfatbin_init - with gil, __symbol_lock: - # Recheck the flag after obtaining the locks - if __py_nvfatbin_init: - return 0 + cdef int err + cdef uintptr_t handle + with gil, _cyb_symbol_lock: + if _cyb___py_nvfatbin_init: return 0 - # Load library - handle = load_nvidia_dynamic_lib("nvfatbin")._handle_uint - - # Load function + handle = load_library() global __nvFatbinGetErrorString - __nvFatbinGetErrorString = GetProcAddress(handle, 'nvFatbinGetErrorString') + __nvFatbinGetErrorString = _cyb_GetProcAddress(handle, 'nvFatbinGetErrorString') global __nvFatbinCreate - __nvFatbinCreate = GetProcAddress(handle, 'nvFatbinCreate') + __nvFatbinCreate = _cyb_GetProcAddress(handle, 'nvFatbinCreate') global __nvFatbinDestroy - __nvFatbinDestroy = GetProcAddress(handle, 'nvFatbinDestroy') + __nvFatbinDestroy = _cyb_GetProcAddress(handle, 'nvFatbinDestroy') global __nvFatbinAddPTX - __nvFatbinAddPTX = GetProcAddress(handle, 'nvFatbinAddPTX') + __nvFatbinAddPTX = _cyb_GetProcAddress(handle, 'nvFatbinAddPTX') global __nvFatbinAddCubin - __nvFatbinAddCubin = GetProcAddress(handle, 'nvFatbinAddCubin') + __nvFatbinAddCubin = _cyb_GetProcAddress(handle, 'nvFatbinAddCubin') global __nvFatbinAddLTOIR - __nvFatbinAddLTOIR = GetProcAddress(handle, 'nvFatbinAddLTOIR') + __nvFatbinAddLTOIR = _cyb_GetProcAddress(handle, 'nvFatbinAddLTOIR') global __nvFatbinSize - __nvFatbinSize = GetProcAddress(handle, 'nvFatbinSize') + __nvFatbinSize = _cyb_GetProcAddress(handle, 'nvFatbinSize') global __nvFatbinGet - __nvFatbinGet = GetProcAddress(handle, 'nvFatbinGet') + __nvFatbinGet = _cyb_GetProcAddress(handle, 'nvFatbinGet') global __nvFatbinVersion - __nvFatbinVersion = GetProcAddress(handle, 'nvFatbinVersion') + __nvFatbinVersion = _cyb_GetProcAddress(handle, 'nvFatbinVersion') global __nvFatbinAddIndex - __nvFatbinAddIndex = GetProcAddress(handle, 'nvFatbinAddIndex') + __nvFatbinAddIndex = _cyb_GetProcAddress(handle, 'nvFatbinAddIndex') global __nvFatbinAddReloc - __nvFatbinAddReloc = GetProcAddress(handle, 'nvFatbinAddReloc') + __nvFatbinAddReloc = _cyb_GetProcAddress(handle, 'nvFatbinAddReloc') global __nvFatbinAddTileIR - __nvFatbinAddTileIR = GetProcAddress(handle, 'nvFatbinAddTileIR') + __nvFatbinAddTileIR = _cyb_GetProcAddress(handle, 'nvFatbinAddTileIR') - __py_nvfatbin_init = True + _cyb___py_nvfatbin_init = True return 0 - cdef inline int _check_or_init_nvfatbin() except -1 nogil: - if __py_nvfatbin_init: + if _cyb___py_nvfatbin_init: return 0 return _init_nvfatbin() -cdef dict func_ptrs = None - - cpdef dict _inspect_function_pointers(): - global func_ptrs - if func_ptrs is not None: - return func_ptrs + global _cyb_func_ptrs + if _cyb_func_ptrs is not None: + return _cyb_func_ptrs _check_or_init_nvfatbin() cdef dict data = {} - global __nvFatbinGetErrorString - data["__nvFatbinGetErrorString"] = __nvFatbinGetErrorString + data["__nvFatbinGetErrorString"] = <_cyb_intptr_t>__nvFatbinGetErrorString global __nvFatbinCreate - data["__nvFatbinCreate"] = __nvFatbinCreate + data["__nvFatbinCreate"] = <_cyb_intptr_t>__nvFatbinCreate global __nvFatbinDestroy - data["__nvFatbinDestroy"] = __nvFatbinDestroy + data["__nvFatbinDestroy"] = <_cyb_intptr_t>__nvFatbinDestroy global __nvFatbinAddPTX - data["__nvFatbinAddPTX"] = __nvFatbinAddPTX + data["__nvFatbinAddPTX"] = <_cyb_intptr_t>__nvFatbinAddPTX global __nvFatbinAddCubin - data["__nvFatbinAddCubin"] = __nvFatbinAddCubin + data["__nvFatbinAddCubin"] = <_cyb_intptr_t>__nvFatbinAddCubin global __nvFatbinAddLTOIR - data["__nvFatbinAddLTOIR"] = __nvFatbinAddLTOIR + data["__nvFatbinAddLTOIR"] = <_cyb_intptr_t>__nvFatbinAddLTOIR global __nvFatbinSize - data["__nvFatbinSize"] = __nvFatbinSize + data["__nvFatbinSize"] = <_cyb_intptr_t>__nvFatbinSize global __nvFatbinGet - data["__nvFatbinGet"] = __nvFatbinGet + data["__nvFatbinGet"] = <_cyb_intptr_t>__nvFatbinGet global __nvFatbinVersion - data["__nvFatbinVersion"] = __nvFatbinVersion + data["__nvFatbinVersion"] = <_cyb_intptr_t>__nvFatbinVersion global __nvFatbinAddIndex - data["__nvFatbinAddIndex"] = __nvFatbinAddIndex + data["__nvFatbinAddIndex"] = <_cyb_intptr_t>__nvFatbinAddIndex global __nvFatbinAddReloc - data["__nvFatbinAddReloc"] = __nvFatbinAddReloc + data["__nvFatbinAddReloc"] = <_cyb_intptr_t>__nvFatbinAddReloc global __nvFatbinAddTileIR - data["__nvFatbinAddTileIR"] = __nvFatbinAddTileIR - - func_ptrs = data + data["__nvFatbinAddTileIR"] = <_cyb_intptr_t>__nvFatbinAddTileIR + _cyb_func_ptrs = data return data cpdef _inspect_function_pointer(str name): - global func_ptrs - if func_ptrs is None: - func_ptrs = _inspect_function_pointers() - return func_ptrs[name] + global _cyb_func_ptrs + if _cyb_func_ptrs is None: + _cyb_func_ptrs = _inspect_function_pointers() + return _cyb_func_ptrs[name] + + + + +cdef uintptr_t load_library() except* with gil: + return load_nvidia_dynamic_lib("nvfatbin")._handle_uint ############################################################################### diff --git a/cuda_bindings/cuda/bindings/_internal/nvjitlink_linux.pyx b/cuda_bindings/cuda/bindings/_internal/nvjitlink_linux.pyx index 33cea546ee4..2ff4282e6c4 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvjitlink_linux.pyx +++ b/cuda_bindings/cuda/bindings/_internal/nvjitlink_linux.pyx @@ -3,63 +3,35 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.0.1 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=2a8907b5ab8df8ecb19b6d0fd3014dea67a9e76e7a2a0ee81fdf23f449402dd6 -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=f6e8c32c0afa43fe218ae5c6f43f402bb85ab1e9898ad6270872c3e546eb4913 -from libc.stdint cimport intptr_t, uintptr_t -import threading -from .utils import FunctionNotFoundError, NotSupportedError - -from cuda.pathfinder import load_nvidia_dynamic_lib - - -############################################################################### -# Extern -############################################################################### - -# You must 'from .utils import NotSupportedError' before using this template +# <<<< PREAMBLE CONTENT >>>> -cdef extern from "" nogil: - void* dlopen(const char*, int) - char* dlerror() - void* dlsym(void*, const char*) - int dlclose(void*) +cdef extern from "": + void* _cyb_dlsym "dlsym"(void*, const char*) nogil + const void * _cyb_RTLD_DEFAULT "RTLD_DEFAULT" - enum: - RTLD_LAZY - RTLD_NOW - RTLD_GLOBAL - RTLD_LOCAL +from libc.stdint cimport intptr_t as _cyb_intptr_t - const void* RTLD_DEFAULT 'RTLD_DEFAULT' +import threading as _cyb_threading -cdef int get_cuda_version(): - cdef void* handle = NULL - cdef int err, driver_ver = 0 +cdef bint _cyb___py_nvjitlink_init = False +cdef dict _cyb_func_ptrs = None +cdef object _cyb_symbol_lock = _cyb_threading.Lock() - # Load driver to check version - handle = dlopen('libcuda.so.1', RTLD_NOW | RTLD_GLOBAL) - if handle == NULL: - err_msg = dlerror() - raise NotSupportedError(f'CUDA driver is not found ({err_msg.decode()})') - cuDriverGetVersion = dlsym(handle, "cuDriverGetVersion") - if cuDriverGetVersion == NULL: - raise RuntimeError('Did not find cuDriverGetVersion symbol in libcuda.so.1') - err = (cuDriverGetVersion)(&driver_ver) - if err != 0: - raise RuntimeError(f'cuDriverGetVersion returned error code {err}') +# <<<< END OF PREAMBLE CONTENT >>>> - return driver_ver +from libc.stdint cimport uintptr_t +from .utils import FunctionNotFoundError, NotSupportedError +from cuda.pathfinder import load_nvidia_dynamic_lib ############################################################################### # Wrapper init ############################################################################### -cdef object __symbol_lock = threading.Lock() -cdef bint __py_nvjitlink_init = False - cdef void* __nvJitLinkCreate = NULL cdef void* __nvJitLinkDestroy = NULL cdef void* __nvJitLinkAddData = NULL @@ -77,213 +49,204 @@ cdef void* __nvJitLinkVersion = NULL cdef void* __nvJitLinkGetLinkedLTOIRSize = NULL cdef void* __nvJitLinkGetLinkedLTOIR = NULL - -cdef void* load_library() except* with gil: - cdef uintptr_t handle = load_nvidia_dynamic_lib("nvJitLink")._handle_uint - return handle - - cdef int _init_nvjitlink() except -1 nogil: - global __py_nvjitlink_init - + global _cyb___py_nvjitlink_init cdef void* handle = NULL + with gil, _cyb_symbol_lock: + if _cyb___py_nvjitlink_init: return 0 - with gil, __symbol_lock: - # Recheck the flag after obtaining the locks - if __py_nvjitlink_init: - return 0 - - # Load function global __nvJitLinkCreate - __nvJitLinkCreate = dlsym(RTLD_DEFAULT, 'nvJitLinkCreate') + __nvJitLinkCreate = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvJitLinkCreate') if __nvJitLinkCreate == NULL: if handle == NULL: handle = load_library() - __nvJitLinkCreate = dlsym(handle, 'nvJitLinkCreate') + __nvJitLinkCreate = _cyb_dlsym(handle, 'nvJitLinkCreate') global __nvJitLinkDestroy - __nvJitLinkDestroy = dlsym(RTLD_DEFAULT, 'nvJitLinkDestroy') + __nvJitLinkDestroy = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvJitLinkDestroy') if __nvJitLinkDestroy == NULL: if handle == NULL: handle = load_library() - __nvJitLinkDestroy = dlsym(handle, 'nvJitLinkDestroy') + __nvJitLinkDestroy = _cyb_dlsym(handle, 'nvJitLinkDestroy') global __nvJitLinkAddData - __nvJitLinkAddData = dlsym(RTLD_DEFAULT, 'nvJitLinkAddData') + __nvJitLinkAddData = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvJitLinkAddData') if __nvJitLinkAddData == NULL: if handle == NULL: handle = load_library() - __nvJitLinkAddData = dlsym(handle, 'nvJitLinkAddData') + __nvJitLinkAddData = _cyb_dlsym(handle, 'nvJitLinkAddData') global __nvJitLinkAddFile - __nvJitLinkAddFile = dlsym(RTLD_DEFAULT, 'nvJitLinkAddFile') + __nvJitLinkAddFile = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvJitLinkAddFile') if __nvJitLinkAddFile == NULL: if handle == NULL: handle = load_library() - __nvJitLinkAddFile = dlsym(handle, 'nvJitLinkAddFile') + __nvJitLinkAddFile = _cyb_dlsym(handle, 'nvJitLinkAddFile') global __nvJitLinkComplete - __nvJitLinkComplete = dlsym(RTLD_DEFAULT, 'nvJitLinkComplete') + __nvJitLinkComplete = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvJitLinkComplete') if __nvJitLinkComplete == NULL: if handle == NULL: handle = load_library() - __nvJitLinkComplete = dlsym(handle, 'nvJitLinkComplete') + __nvJitLinkComplete = _cyb_dlsym(handle, 'nvJitLinkComplete') global __nvJitLinkGetLinkedCubinSize - __nvJitLinkGetLinkedCubinSize = dlsym(RTLD_DEFAULT, 'nvJitLinkGetLinkedCubinSize') + __nvJitLinkGetLinkedCubinSize = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvJitLinkGetLinkedCubinSize') if __nvJitLinkGetLinkedCubinSize == NULL: if handle == NULL: handle = load_library() - __nvJitLinkGetLinkedCubinSize = dlsym(handle, 'nvJitLinkGetLinkedCubinSize') + __nvJitLinkGetLinkedCubinSize = _cyb_dlsym(handle, 'nvJitLinkGetLinkedCubinSize') global __nvJitLinkGetLinkedCubin - __nvJitLinkGetLinkedCubin = dlsym(RTLD_DEFAULT, 'nvJitLinkGetLinkedCubin') + __nvJitLinkGetLinkedCubin = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvJitLinkGetLinkedCubin') if __nvJitLinkGetLinkedCubin == NULL: if handle == NULL: handle = load_library() - __nvJitLinkGetLinkedCubin = dlsym(handle, 'nvJitLinkGetLinkedCubin') + __nvJitLinkGetLinkedCubin = _cyb_dlsym(handle, 'nvJitLinkGetLinkedCubin') global __nvJitLinkGetLinkedPtxSize - __nvJitLinkGetLinkedPtxSize = dlsym(RTLD_DEFAULT, 'nvJitLinkGetLinkedPtxSize') + __nvJitLinkGetLinkedPtxSize = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvJitLinkGetLinkedPtxSize') if __nvJitLinkGetLinkedPtxSize == NULL: if handle == NULL: handle = load_library() - __nvJitLinkGetLinkedPtxSize = dlsym(handle, 'nvJitLinkGetLinkedPtxSize') + __nvJitLinkGetLinkedPtxSize = _cyb_dlsym(handle, 'nvJitLinkGetLinkedPtxSize') global __nvJitLinkGetLinkedPtx - __nvJitLinkGetLinkedPtx = dlsym(RTLD_DEFAULT, 'nvJitLinkGetLinkedPtx') + __nvJitLinkGetLinkedPtx = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvJitLinkGetLinkedPtx') if __nvJitLinkGetLinkedPtx == NULL: if handle == NULL: handle = load_library() - __nvJitLinkGetLinkedPtx = dlsym(handle, 'nvJitLinkGetLinkedPtx') + __nvJitLinkGetLinkedPtx = _cyb_dlsym(handle, 'nvJitLinkGetLinkedPtx') global __nvJitLinkGetErrorLogSize - __nvJitLinkGetErrorLogSize = dlsym(RTLD_DEFAULT, 'nvJitLinkGetErrorLogSize') + __nvJitLinkGetErrorLogSize = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvJitLinkGetErrorLogSize') if __nvJitLinkGetErrorLogSize == NULL: if handle == NULL: handle = load_library() - __nvJitLinkGetErrorLogSize = dlsym(handle, 'nvJitLinkGetErrorLogSize') + __nvJitLinkGetErrorLogSize = _cyb_dlsym(handle, 'nvJitLinkGetErrorLogSize') global __nvJitLinkGetErrorLog - __nvJitLinkGetErrorLog = dlsym(RTLD_DEFAULT, 'nvJitLinkGetErrorLog') + __nvJitLinkGetErrorLog = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvJitLinkGetErrorLog') if __nvJitLinkGetErrorLog == NULL: if handle == NULL: handle = load_library() - __nvJitLinkGetErrorLog = dlsym(handle, 'nvJitLinkGetErrorLog') + __nvJitLinkGetErrorLog = _cyb_dlsym(handle, 'nvJitLinkGetErrorLog') global __nvJitLinkGetInfoLogSize - __nvJitLinkGetInfoLogSize = dlsym(RTLD_DEFAULT, 'nvJitLinkGetInfoLogSize') + __nvJitLinkGetInfoLogSize = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvJitLinkGetInfoLogSize') if __nvJitLinkGetInfoLogSize == NULL: if handle == NULL: handle = load_library() - __nvJitLinkGetInfoLogSize = dlsym(handle, 'nvJitLinkGetInfoLogSize') + __nvJitLinkGetInfoLogSize = _cyb_dlsym(handle, 'nvJitLinkGetInfoLogSize') global __nvJitLinkGetInfoLog - __nvJitLinkGetInfoLog = dlsym(RTLD_DEFAULT, 'nvJitLinkGetInfoLog') + __nvJitLinkGetInfoLog = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvJitLinkGetInfoLog') if __nvJitLinkGetInfoLog == NULL: if handle == NULL: handle = load_library() - __nvJitLinkGetInfoLog = dlsym(handle, 'nvJitLinkGetInfoLog') + __nvJitLinkGetInfoLog = _cyb_dlsym(handle, 'nvJitLinkGetInfoLog') global __nvJitLinkVersion - __nvJitLinkVersion = dlsym(RTLD_DEFAULT, 'nvJitLinkVersion') + __nvJitLinkVersion = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvJitLinkVersion') if __nvJitLinkVersion == NULL: if handle == NULL: handle = load_library() - __nvJitLinkVersion = dlsym(handle, 'nvJitLinkVersion') + __nvJitLinkVersion = _cyb_dlsym(handle, 'nvJitLinkVersion') global __nvJitLinkGetLinkedLTOIRSize - __nvJitLinkGetLinkedLTOIRSize = dlsym(RTLD_DEFAULT, 'nvJitLinkGetLinkedLTOIRSize') + __nvJitLinkGetLinkedLTOIRSize = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvJitLinkGetLinkedLTOIRSize') if __nvJitLinkGetLinkedLTOIRSize == NULL: if handle == NULL: handle = load_library() - __nvJitLinkGetLinkedLTOIRSize = dlsym(handle, 'nvJitLinkGetLinkedLTOIRSize') + __nvJitLinkGetLinkedLTOIRSize = _cyb_dlsym(handle, 'nvJitLinkGetLinkedLTOIRSize') global __nvJitLinkGetLinkedLTOIR - __nvJitLinkGetLinkedLTOIR = dlsym(RTLD_DEFAULT, 'nvJitLinkGetLinkedLTOIR') + __nvJitLinkGetLinkedLTOIR = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvJitLinkGetLinkedLTOIR') if __nvJitLinkGetLinkedLTOIR == NULL: if handle == NULL: handle = load_library() - __nvJitLinkGetLinkedLTOIR = dlsym(handle, 'nvJitLinkGetLinkedLTOIR') + __nvJitLinkGetLinkedLTOIR = _cyb_dlsym(handle, 'nvJitLinkGetLinkedLTOIR') - __py_nvjitlink_init = True + _cyb___py_nvjitlink_init = True return 0 - cdef inline int _check_or_init_nvjitlink() except -1 nogil: - if __py_nvjitlink_init: + if _cyb___py_nvjitlink_init: return 0 return _init_nvjitlink() -cdef dict func_ptrs = None - cpdef dict _inspect_function_pointers(): - global func_ptrs - if func_ptrs is not None: - return func_ptrs + global _cyb_func_ptrs + if _cyb_func_ptrs is not None: + return _cyb_func_ptrs _check_or_init_nvjitlink() cdef dict data = {} - global __nvJitLinkCreate - data["__nvJitLinkCreate"] = __nvJitLinkCreate + data["__nvJitLinkCreate"] = <_cyb_intptr_t>__nvJitLinkCreate global __nvJitLinkDestroy - data["__nvJitLinkDestroy"] = __nvJitLinkDestroy + data["__nvJitLinkDestroy"] = <_cyb_intptr_t>__nvJitLinkDestroy global __nvJitLinkAddData - data["__nvJitLinkAddData"] = __nvJitLinkAddData + data["__nvJitLinkAddData"] = <_cyb_intptr_t>__nvJitLinkAddData global __nvJitLinkAddFile - data["__nvJitLinkAddFile"] = __nvJitLinkAddFile + data["__nvJitLinkAddFile"] = <_cyb_intptr_t>__nvJitLinkAddFile global __nvJitLinkComplete - data["__nvJitLinkComplete"] = __nvJitLinkComplete + data["__nvJitLinkComplete"] = <_cyb_intptr_t>__nvJitLinkComplete global __nvJitLinkGetLinkedCubinSize - data["__nvJitLinkGetLinkedCubinSize"] = __nvJitLinkGetLinkedCubinSize + data["__nvJitLinkGetLinkedCubinSize"] = <_cyb_intptr_t>__nvJitLinkGetLinkedCubinSize global __nvJitLinkGetLinkedCubin - data["__nvJitLinkGetLinkedCubin"] = __nvJitLinkGetLinkedCubin + data["__nvJitLinkGetLinkedCubin"] = <_cyb_intptr_t>__nvJitLinkGetLinkedCubin global __nvJitLinkGetLinkedPtxSize - data["__nvJitLinkGetLinkedPtxSize"] = __nvJitLinkGetLinkedPtxSize + data["__nvJitLinkGetLinkedPtxSize"] = <_cyb_intptr_t>__nvJitLinkGetLinkedPtxSize global __nvJitLinkGetLinkedPtx - data["__nvJitLinkGetLinkedPtx"] = __nvJitLinkGetLinkedPtx + data["__nvJitLinkGetLinkedPtx"] = <_cyb_intptr_t>__nvJitLinkGetLinkedPtx global __nvJitLinkGetErrorLogSize - data["__nvJitLinkGetErrorLogSize"] = __nvJitLinkGetErrorLogSize + data["__nvJitLinkGetErrorLogSize"] = <_cyb_intptr_t>__nvJitLinkGetErrorLogSize global __nvJitLinkGetErrorLog - data["__nvJitLinkGetErrorLog"] = __nvJitLinkGetErrorLog + data["__nvJitLinkGetErrorLog"] = <_cyb_intptr_t>__nvJitLinkGetErrorLog global __nvJitLinkGetInfoLogSize - data["__nvJitLinkGetInfoLogSize"] = __nvJitLinkGetInfoLogSize + data["__nvJitLinkGetInfoLogSize"] = <_cyb_intptr_t>__nvJitLinkGetInfoLogSize global __nvJitLinkGetInfoLog - data["__nvJitLinkGetInfoLog"] = __nvJitLinkGetInfoLog + data["__nvJitLinkGetInfoLog"] = <_cyb_intptr_t>__nvJitLinkGetInfoLog global __nvJitLinkVersion - data["__nvJitLinkVersion"] = __nvJitLinkVersion + data["__nvJitLinkVersion"] = <_cyb_intptr_t>__nvJitLinkVersion global __nvJitLinkGetLinkedLTOIRSize - data["__nvJitLinkGetLinkedLTOIRSize"] = __nvJitLinkGetLinkedLTOIRSize + data["__nvJitLinkGetLinkedLTOIRSize"] = <_cyb_intptr_t>__nvJitLinkGetLinkedLTOIRSize global __nvJitLinkGetLinkedLTOIR - data["__nvJitLinkGetLinkedLTOIR"] = __nvJitLinkGetLinkedLTOIR - - func_ptrs = data + data["__nvJitLinkGetLinkedLTOIR"] = <_cyb_intptr_t>__nvJitLinkGetLinkedLTOIR + _cyb_func_ptrs = data return data cpdef _inspect_function_pointer(str name): - global func_ptrs - if func_ptrs is None: - func_ptrs = _inspect_function_pointers() - return func_ptrs[name] + global _cyb_func_ptrs + if _cyb_func_ptrs is None: + _cyb_func_ptrs = _inspect_function_pointers() + return _cyb_func_ptrs[name] + + + + +cdef void* load_library() except* with gil: + cdef uintptr_t handle = load_nvidia_dynamic_lib("nvJitLink")._handle_uint + return handle ############################################################################### diff --git a/cuda_bindings/cuda/bindings/_internal/nvjitlink_windows.pyx b/cuda_bindings/cuda/bindings/_internal/nvjitlink_windows.pyx index 1385f2df077..680038584a7 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvjitlink_windows.pyx +++ b/cuda_bindings/cuda/bindings/_internal/nvjitlink_windows.pyx @@ -3,81 +3,32 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.0.1 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=8f99393554faa677ab0ab8326185997a183259db6b26b55561ed2ab6250201a6 -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=9043dd9e45a69e2bd6c7984832fca8cc1ccd7c66b605b384e4cff18b0c713027 -from libc.stdint cimport intptr_t -import threading -from .utils import FunctionNotFoundError, NotSupportedError - -from cuda.pathfinder import load_nvidia_dynamic_lib +# <<<< PREAMBLE CONTENT >>>> -from libc.stddef cimport wchar_t -from libc.stdint cimport uintptr_t -from cpython cimport PyUnicode_AsWideCharString, PyMem_Free +cdef extern from "": + ctypedef void* HMODULE + void* _cyb_GetProcAddress "GetProcAddress"(HMODULE, const char*) nogil -# You must 'from .utils import NotSupportedError' before using this template +from libc.stdint cimport intptr_t as _cyb_intptr_t -cdef extern from "windows.h" nogil: - ctypedef void* HMODULE - ctypedef void* HANDLE - ctypedef void* FARPROC - ctypedef unsigned long DWORD - ctypedef const wchar_t *LPCWSTR - ctypedef const char *LPCSTR - - cdef DWORD LOAD_LIBRARY_SEARCH_SYSTEM32 = 0x00000800 - cdef DWORD LOAD_LIBRARY_SEARCH_DEFAULT_DIRS = 0x00001000 - cdef DWORD LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR = 0x00000100 - - HMODULE _LoadLibraryExW "LoadLibraryExW"( - LPCWSTR lpLibFileName, - HANDLE hFile, - DWORD dwFlags - ) - - FARPROC _GetProcAddress "GetProcAddress"(HMODULE hModule, LPCSTR lpProcName) - -cdef inline uintptr_t LoadLibraryExW(str path, HANDLE hFile, DWORD dwFlags): - cdef uintptr_t result - cdef wchar_t* wpath = PyUnicode_AsWideCharString(path, NULL) - with nogil: - result = _LoadLibraryExW( - wpath, - hFile, - dwFlags - ) - PyMem_Free(wpath) - return result - -cdef inline void *GetProcAddress(uintptr_t hModule, const char* lpProcName) nogil: - return _GetProcAddress(hModule, lpProcName) - -cdef int get_cuda_version(): - cdef int err, driver_ver = 0 - - # Load driver to check version - handle = LoadLibraryExW("nvcuda.dll", NULL, LOAD_LIBRARY_SEARCH_SYSTEM32) - if handle == 0: - raise NotSupportedError('CUDA driver is not found') - cuDriverGetVersion = GetProcAddress(handle, 'cuDriverGetVersion') - if cuDriverGetVersion == NULL: - raise RuntimeError('Did not find cuDriverGetVersion symbol in nvcuda.dll') - err = (cuDriverGetVersion)(&driver_ver) - if err != 0: - raise RuntimeError(f'cuDriverGetVersion returned error code {err}') - - return driver_ver +import threading as _cyb_threading +cdef bint _cyb___py_nvjitlink_init = False +cdef dict _cyb_func_ptrs = None +cdef object _cyb_symbol_lock = _cyb_threading.Lock() +# <<<< END OF PREAMBLE CONTENT >>>> +from libc.stdint cimport uintptr_t +from cuda.pathfinder import load_nvidia_dynamic_lib +from .utils import FunctionNotFoundError, NotSupportedError ############################################################################### # Wrapper init ############################################################################### -cdef object __symbol_lock = threading.Lock() -cdef bint __py_nvjitlink_init = False - cdef void* __nvJitLinkCreate = NULL cdef void* __nvJitLinkDestroy = NULL cdef void* __nvJitLinkAddData = NULL @@ -95,146 +46,142 @@ cdef void* __nvJitLinkVersion = NULL cdef void* __nvJitLinkGetLinkedLTOIRSize = NULL cdef void* __nvJitLinkGetLinkedLTOIR = NULL - cdef int _init_nvjitlink() except -1 nogil: - global __py_nvjitlink_init + global _cyb___py_nvjitlink_init - with gil, __symbol_lock: - # Recheck the flag after obtaining the locks - if __py_nvjitlink_init: - return 0 + cdef int err + cdef uintptr_t handle + with gil, _cyb_symbol_lock: + if _cyb___py_nvjitlink_init: return 0 - # Load library - handle = load_nvidia_dynamic_lib("nvJitLink")._handle_uint - - # Load function + handle = load_library() global __nvJitLinkCreate - __nvJitLinkCreate = GetProcAddress(handle, 'nvJitLinkCreate') + __nvJitLinkCreate = _cyb_GetProcAddress(handle, 'nvJitLinkCreate') global __nvJitLinkDestroy - __nvJitLinkDestroy = GetProcAddress(handle, 'nvJitLinkDestroy') + __nvJitLinkDestroy = _cyb_GetProcAddress(handle, 'nvJitLinkDestroy') global __nvJitLinkAddData - __nvJitLinkAddData = GetProcAddress(handle, 'nvJitLinkAddData') + __nvJitLinkAddData = _cyb_GetProcAddress(handle, 'nvJitLinkAddData') global __nvJitLinkAddFile - __nvJitLinkAddFile = GetProcAddress(handle, 'nvJitLinkAddFile') + __nvJitLinkAddFile = _cyb_GetProcAddress(handle, 'nvJitLinkAddFile') global __nvJitLinkComplete - __nvJitLinkComplete = GetProcAddress(handle, 'nvJitLinkComplete') + __nvJitLinkComplete = _cyb_GetProcAddress(handle, 'nvJitLinkComplete') global __nvJitLinkGetLinkedCubinSize - __nvJitLinkGetLinkedCubinSize = GetProcAddress(handle, 'nvJitLinkGetLinkedCubinSize') + __nvJitLinkGetLinkedCubinSize = _cyb_GetProcAddress(handle, 'nvJitLinkGetLinkedCubinSize') global __nvJitLinkGetLinkedCubin - __nvJitLinkGetLinkedCubin = GetProcAddress(handle, 'nvJitLinkGetLinkedCubin') + __nvJitLinkGetLinkedCubin = _cyb_GetProcAddress(handle, 'nvJitLinkGetLinkedCubin') global __nvJitLinkGetLinkedPtxSize - __nvJitLinkGetLinkedPtxSize = GetProcAddress(handle, 'nvJitLinkGetLinkedPtxSize') + __nvJitLinkGetLinkedPtxSize = _cyb_GetProcAddress(handle, 'nvJitLinkGetLinkedPtxSize') global __nvJitLinkGetLinkedPtx - __nvJitLinkGetLinkedPtx = GetProcAddress(handle, 'nvJitLinkGetLinkedPtx') + __nvJitLinkGetLinkedPtx = _cyb_GetProcAddress(handle, 'nvJitLinkGetLinkedPtx') global __nvJitLinkGetErrorLogSize - __nvJitLinkGetErrorLogSize = GetProcAddress(handle, 'nvJitLinkGetErrorLogSize') + __nvJitLinkGetErrorLogSize = _cyb_GetProcAddress(handle, 'nvJitLinkGetErrorLogSize') global __nvJitLinkGetErrorLog - __nvJitLinkGetErrorLog = GetProcAddress(handle, 'nvJitLinkGetErrorLog') + __nvJitLinkGetErrorLog = _cyb_GetProcAddress(handle, 'nvJitLinkGetErrorLog') global __nvJitLinkGetInfoLogSize - __nvJitLinkGetInfoLogSize = GetProcAddress(handle, 'nvJitLinkGetInfoLogSize') + __nvJitLinkGetInfoLogSize = _cyb_GetProcAddress(handle, 'nvJitLinkGetInfoLogSize') global __nvJitLinkGetInfoLog - __nvJitLinkGetInfoLog = GetProcAddress(handle, 'nvJitLinkGetInfoLog') + __nvJitLinkGetInfoLog = _cyb_GetProcAddress(handle, 'nvJitLinkGetInfoLog') global __nvJitLinkVersion - __nvJitLinkVersion = GetProcAddress(handle, 'nvJitLinkVersion') + __nvJitLinkVersion = _cyb_GetProcAddress(handle, 'nvJitLinkVersion') global __nvJitLinkGetLinkedLTOIRSize - __nvJitLinkGetLinkedLTOIRSize = GetProcAddress(handle, 'nvJitLinkGetLinkedLTOIRSize') + __nvJitLinkGetLinkedLTOIRSize = _cyb_GetProcAddress(handle, 'nvJitLinkGetLinkedLTOIRSize') global __nvJitLinkGetLinkedLTOIR - __nvJitLinkGetLinkedLTOIR = GetProcAddress(handle, 'nvJitLinkGetLinkedLTOIR') + __nvJitLinkGetLinkedLTOIR = _cyb_GetProcAddress(handle, 'nvJitLinkGetLinkedLTOIR') - __py_nvjitlink_init = True + _cyb___py_nvjitlink_init = True return 0 - cdef inline int _check_or_init_nvjitlink() except -1 nogil: - if __py_nvjitlink_init: + if _cyb___py_nvjitlink_init: return 0 return _init_nvjitlink() -cdef dict func_ptrs = None - - cpdef dict _inspect_function_pointers(): - global func_ptrs - if func_ptrs is not None: - return func_ptrs + global _cyb_func_ptrs + if _cyb_func_ptrs is not None: + return _cyb_func_ptrs _check_or_init_nvjitlink() cdef dict data = {} - global __nvJitLinkCreate - data["__nvJitLinkCreate"] = __nvJitLinkCreate + data["__nvJitLinkCreate"] = <_cyb_intptr_t>__nvJitLinkCreate global __nvJitLinkDestroy - data["__nvJitLinkDestroy"] = __nvJitLinkDestroy + data["__nvJitLinkDestroy"] = <_cyb_intptr_t>__nvJitLinkDestroy global __nvJitLinkAddData - data["__nvJitLinkAddData"] = __nvJitLinkAddData + data["__nvJitLinkAddData"] = <_cyb_intptr_t>__nvJitLinkAddData global __nvJitLinkAddFile - data["__nvJitLinkAddFile"] = __nvJitLinkAddFile + data["__nvJitLinkAddFile"] = <_cyb_intptr_t>__nvJitLinkAddFile global __nvJitLinkComplete - data["__nvJitLinkComplete"] = __nvJitLinkComplete + data["__nvJitLinkComplete"] = <_cyb_intptr_t>__nvJitLinkComplete global __nvJitLinkGetLinkedCubinSize - data["__nvJitLinkGetLinkedCubinSize"] = __nvJitLinkGetLinkedCubinSize + data["__nvJitLinkGetLinkedCubinSize"] = <_cyb_intptr_t>__nvJitLinkGetLinkedCubinSize global __nvJitLinkGetLinkedCubin - data["__nvJitLinkGetLinkedCubin"] = __nvJitLinkGetLinkedCubin + data["__nvJitLinkGetLinkedCubin"] = <_cyb_intptr_t>__nvJitLinkGetLinkedCubin global __nvJitLinkGetLinkedPtxSize - data["__nvJitLinkGetLinkedPtxSize"] = __nvJitLinkGetLinkedPtxSize + data["__nvJitLinkGetLinkedPtxSize"] = <_cyb_intptr_t>__nvJitLinkGetLinkedPtxSize global __nvJitLinkGetLinkedPtx - data["__nvJitLinkGetLinkedPtx"] = __nvJitLinkGetLinkedPtx + data["__nvJitLinkGetLinkedPtx"] = <_cyb_intptr_t>__nvJitLinkGetLinkedPtx global __nvJitLinkGetErrorLogSize - data["__nvJitLinkGetErrorLogSize"] = __nvJitLinkGetErrorLogSize + data["__nvJitLinkGetErrorLogSize"] = <_cyb_intptr_t>__nvJitLinkGetErrorLogSize global __nvJitLinkGetErrorLog - data["__nvJitLinkGetErrorLog"] = __nvJitLinkGetErrorLog + data["__nvJitLinkGetErrorLog"] = <_cyb_intptr_t>__nvJitLinkGetErrorLog global __nvJitLinkGetInfoLogSize - data["__nvJitLinkGetInfoLogSize"] = __nvJitLinkGetInfoLogSize + data["__nvJitLinkGetInfoLogSize"] = <_cyb_intptr_t>__nvJitLinkGetInfoLogSize global __nvJitLinkGetInfoLog - data["__nvJitLinkGetInfoLog"] = __nvJitLinkGetInfoLog + data["__nvJitLinkGetInfoLog"] = <_cyb_intptr_t>__nvJitLinkGetInfoLog global __nvJitLinkVersion - data["__nvJitLinkVersion"] = __nvJitLinkVersion + data["__nvJitLinkVersion"] = <_cyb_intptr_t>__nvJitLinkVersion global __nvJitLinkGetLinkedLTOIRSize - data["__nvJitLinkGetLinkedLTOIRSize"] = __nvJitLinkGetLinkedLTOIRSize + data["__nvJitLinkGetLinkedLTOIRSize"] = <_cyb_intptr_t>__nvJitLinkGetLinkedLTOIRSize global __nvJitLinkGetLinkedLTOIR - data["__nvJitLinkGetLinkedLTOIR"] = __nvJitLinkGetLinkedLTOIR - - func_ptrs = data + data["__nvJitLinkGetLinkedLTOIR"] = <_cyb_intptr_t>__nvJitLinkGetLinkedLTOIR + _cyb_func_ptrs = data return data cpdef _inspect_function_pointer(str name): - global func_ptrs - if func_ptrs is None: - func_ptrs = _inspect_function_pointers() - return func_ptrs[name] + global _cyb_func_ptrs + if _cyb_func_ptrs is None: + _cyb_func_ptrs = _inspect_function_pointers() + return _cyb_func_ptrs[name] + + + + +cdef uintptr_t load_library() except* with gil: + return load_nvidia_dynamic_lib("nvJitLink")._handle_uint ############################################################################### diff --git a/cuda_bindings/cuda/bindings/_internal/nvml_linux.pyx b/cuda_bindings/cuda/bindings/_internal/nvml_linux.pyx index 05e7ede4929..2cff506e87c 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvml_linux.pyx +++ b/cuda_bindings/cuda/bindings/_internal/nvml_linux.pyx @@ -3,64 +3,35 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.9.1 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=27eba7e4fbbc2bca4f40e906d63b9386cce38cbabfcc50e6a2d7ad5bc0b68e91 -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=bdb56d8618b22dfcdcb3da879bbe276c3caf7c07aae6e5aa2b76de817f4baa39 -from libc.stdint cimport intptr_t, uintptr_t -import threading +# <<<< PREAMBLE CONTENT >>>> -from .utils import FunctionNotFoundError, NotSupportedError - -from cuda.pathfinder import load_nvidia_dynamic_lib - - -############################################################################### -# Extern -############################################################################### - -# You must 'from .utils import NotSupportedError' before using this template +cdef extern from "": + void* _cyb_dlsym "dlsym"(void*, const char*) nogil + const void * _cyb_RTLD_DEFAULT "RTLD_DEFAULT" -cdef extern from "" nogil: - void* dlopen(const char*, int) - char* dlerror() - void* dlsym(void*, const char*) - int dlclose(void*) +from libc.stdint cimport intptr_t as _cyb_intptr_t - enum: - RTLD_LAZY - RTLD_NOW - RTLD_GLOBAL - RTLD_LOCAL +import threading as _cyb_threading - const void* RTLD_DEFAULT 'RTLD_DEFAULT' +cdef bint _cyb___py_nvml_init = False +cdef dict _cyb_func_ptrs = None +cdef object _cyb_symbol_lock = _cyb_threading.Lock() -cdef int get_cuda_version(): - cdef void* handle = NULL - cdef int err, driver_ver = 0 - - # Load driver to check version - handle = dlopen('libcuda.so.1', RTLD_NOW | RTLD_GLOBAL) - if handle == NULL: - err_msg = dlerror() - raise NotSupportedError(f'CUDA driver is not found ({err_msg.decode()})') - cuDriverGetVersion = dlsym(handle, "cuDriverGetVersion") - if cuDriverGetVersion == NULL: - raise RuntimeError('Did not find cuDriverGetVersion symbol in libcuda.so.1') - err = (cuDriverGetVersion)(&driver_ver) - if err != 0: - raise RuntimeError(f'cuDriverGetVersion returned error code {err}') +# <<<< END OF PREAMBLE CONTENT >>>> - return driver_ver +from libc.stdint cimport uintptr_t +from .utils import FunctionNotFoundError, NotSupportedError +from cuda.pathfinder import load_nvidia_dynamic_lib ############################################################################### # Wrapper init ############################################################################### -cdef object __symbol_lock = threading.Lock() -cdef bint __py_nvml_init = False - cdef void* __nvmlInit_v2 = NULL cdef void* __nvmlInitWithFlags = NULL cdef void* __nvmlShutdown = NULL @@ -413,3563 +384,3554 @@ cdef void* __nvmlGpuInstanceGetVgpuSchedulerLog_v2 = NULL cdef void* __nvmlDeviceSetVgpuSchedulerState_v2 = NULL cdef void* __nvmlGpuInstanceSetVgpuSchedulerState_v2 = NULL - -cdef void* load_library() except* with gil: - cdef uintptr_t handle = load_nvidia_dynamic_lib("nvml")._handle_uint - return handle - - cdef int _init_nvml() except -1 nogil: - global __py_nvml_init + global _cyb___py_nvml_init cdef void* handle = NULL + with gil, _cyb_symbol_lock: + if _cyb___py_nvml_init: return 0 - with gil, __symbol_lock: - # Recheck the flag after obtaining the locks - if __py_nvml_init: - return 0 - - # Load function global __nvmlInit_v2 - __nvmlInit_v2 = dlsym(RTLD_DEFAULT, 'nvmlInit_v2') + __nvmlInit_v2 = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlInit_v2') if __nvmlInit_v2 == NULL: if handle == NULL: handle = load_library() - __nvmlInit_v2 = dlsym(handle, 'nvmlInit_v2') + __nvmlInit_v2 = _cyb_dlsym(handle, 'nvmlInit_v2') global __nvmlInitWithFlags - __nvmlInitWithFlags = dlsym(RTLD_DEFAULT, 'nvmlInitWithFlags') + __nvmlInitWithFlags = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlInitWithFlags') if __nvmlInitWithFlags == NULL: if handle == NULL: handle = load_library() - __nvmlInitWithFlags = dlsym(handle, 'nvmlInitWithFlags') + __nvmlInitWithFlags = _cyb_dlsym(handle, 'nvmlInitWithFlags') global __nvmlShutdown - __nvmlShutdown = dlsym(RTLD_DEFAULT, 'nvmlShutdown') + __nvmlShutdown = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlShutdown') if __nvmlShutdown == NULL: if handle == NULL: handle = load_library() - __nvmlShutdown = dlsym(handle, 'nvmlShutdown') + __nvmlShutdown = _cyb_dlsym(handle, 'nvmlShutdown') global __nvmlErrorString - __nvmlErrorString = dlsym(RTLD_DEFAULT, 'nvmlErrorString') + __nvmlErrorString = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlErrorString') if __nvmlErrorString == NULL: if handle == NULL: handle = load_library() - __nvmlErrorString = dlsym(handle, 'nvmlErrorString') + __nvmlErrorString = _cyb_dlsym(handle, 'nvmlErrorString') global __nvmlSystemGetDriverVersion - __nvmlSystemGetDriverVersion = dlsym(RTLD_DEFAULT, 'nvmlSystemGetDriverVersion') + __nvmlSystemGetDriverVersion = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlSystemGetDriverVersion') if __nvmlSystemGetDriverVersion == NULL: if handle == NULL: handle = load_library() - __nvmlSystemGetDriverVersion = dlsym(handle, 'nvmlSystemGetDriverVersion') + __nvmlSystemGetDriverVersion = _cyb_dlsym(handle, 'nvmlSystemGetDriverVersion') global __nvmlSystemGetNVMLVersion - __nvmlSystemGetNVMLVersion = dlsym(RTLD_DEFAULT, 'nvmlSystemGetNVMLVersion') + __nvmlSystemGetNVMLVersion = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlSystemGetNVMLVersion') if __nvmlSystemGetNVMLVersion == NULL: if handle == NULL: handle = load_library() - __nvmlSystemGetNVMLVersion = dlsym(handle, 'nvmlSystemGetNVMLVersion') + __nvmlSystemGetNVMLVersion = _cyb_dlsym(handle, 'nvmlSystemGetNVMLVersion') global __nvmlSystemGetCudaDriverVersion - __nvmlSystemGetCudaDriverVersion = dlsym(RTLD_DEFAULT, 'nvmlSystemGetCudaDriverVersion') + __nvmlSystemGetCudaDriverVersion = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlSystemGetCudaDriverVersion') if __nvmlSystemGetCudaDriverVersion == NULL: if handle == NULL: handle = load_library() - __nvmlSystemGetCudaDriverVersion = dlsym(handle, 'nvmlSystemGetCudaDriverVersion') + __nvmlSystemGetCudaDriverVersion = _cyb_dlsym(handle, 'nvmlSystemGetCudaDriverVersion') global __nvmlSystemGetCudaDriverVersion_v2 - __nvmlSystemGetCudaDriverVersion_v2 = dlsym(RTLD_DEFAULT, 'nvmlSystemGetCudaDriverVersion_v2') + __nvmlSystemGetCudaDriverVersion_v2 = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlSystemGetCudaDriverVersion_v2') if __nvmlSystemGetCudaDriverVersion_v2 == NULL: if handle == NULL: handle = load_library() - __nvmlSystemGetCudaDriverVersion_v2 = dlsym(handle, 'nvmlSystemGetCudaDriverVersion_v2') + __nvmlSystemGetCudaDriverVersion_v2 = _cyb_dlsym(handle, 'nvmlSystemGetCudaDriverVersion_v2') global __nvmlSystemGetProcessName - __nvmlSystemGetProcessName = dlsym(RTLD_DEFAULT, 'nvmlSystemGetProcessName') + __nvmlSystemGetProcessName = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlSystemGetProcessName') if __nvmlSystemGetProcessName == NULL: if handle == NULL: handle = load_library() - __nvmlSystemGetProcessName = dlsym(handle, 'nvmlSystemGetProcessName') + __nvmlSystemGetProcessName = _cyb_dlsym(handle, 'nvmlSystemGetProcessName') global __nvmlSystemGetHicVersion - __nvmlSystemGetHicVersion = dlsym(RTLD_DEFAULT, 'nvmlSystemGetHicVersion') + __nvmlSystemGetHicVersion = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlSystemGetHicVersion') if __nvmlSystemGetHicVersion == NULL: if handle == NULL: handle = load_library() - __nvmlSystemGetHicVersion = dlsym(handle, 'nvmlSystemGetHicVersion') + __nvmlSystemGetHicVersion = _cyb_dlsym(handle, 'nvmlSystemGetHicVersion') global __nvmlSystemGetTopologyGpuSet - __nvmlSystemGetTopologyGpuSet = dlsym(RTLD_DEFAULT, 'nvmlSystemGetTopologyGpuSet') + __nvmlSystemGetTopologyGpuSet = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlSystemGetTopologyGpuSet') if __nvmlSystemGetTopologyGpuSet == NULL: if handle == NULL: handle = load_library() - __nvmlSystemGetTopologyGpuSet = dlsym(handle, 'nvmlSystemGetTopologyGpuSet') + __nvmlSystemGetTopologyGpuSet = _cyb_dlsym(handle, 'nvmlSystemGetTopologyGpuSet') global __nvmlSystemGetDriverBranch - __nvmlSystemGetDriverBranch = dlsym(RTLD_DEFAULT, 'nvmlSystemGetDriverBranch') + __nvmlSystemGetDriverBranch = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlSystemGetDriverBranch') if __nvmlSystemGetDriverBranch == NULL: if handle == NULL: handle = load_library() - __nvmlSystemGetDriverBranch = dlsym(handle, 'nvmlSystemGetDriverBranch') + __nvmlSystemGetDriverBranch = _cyb_dlsym(handle, 'nvmlSystemGetDriverBranch') global __nvmlUnitGetCount - __nvmlUnitGetCount = dlsym(RTLD_DEFAULT, 'nvmlUnitGetCount') + __nvmlUnitGetCount = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlUnitGetCount') if __nvmlUnitGetCount == NULL: if handle == NULL: handle = load_library() - __nvmlUnitGetCount = dlsym(handle, 'nvmlUnitGetCount') + __nvmlUnitGetCount = _cyb_dlsym(handle, 'nvmlUnitGetCount') global __nvmlUnitGetHandleByIndex - __nvmlUnitGetHandleByIndex = dlsym(RTLD_DEFAULT, 'nvmlUnitGetHandleByIndex') + __nvmlUnitGetHandleByIndex = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlUnitGetHandleByIndex') if __nvmlUnitGetHandleByIndex == NULL: if handle == NULL: handle = load_library() - __nvmlUnitGetHandleByIndex = dlsym(handle, 'nvmlUnitGetHandleByIndex') + __nvmlUnitGetHandleByIndex = _cyb_dlsym(handle, 'nvmlUnitGetHandleByIndex') global __nvmlUnitGetUnitInfo - __nvmlUnitGetUnitInfo = dlsym(RTLD_DEFAULT, 'nvmlUnitGetUnitInfo') + __nvmlUnitGetUnitInfo = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlUnitGetUnitInfo') if __nvmlUnitGetUnitInfo == NULL: if handle == NULL: handle = load_library() - __nvmlUnitGetUnitInfo = dlsym(handle, 'nvmlUnitGetUnitInfo') + __nvmlUnitGetUnitInfo = _cyb_dlsym(handle, 'nvmlUnitGetUnitInfo') global __nvmlUnitGetLedState - __nvmlUnitGetLedState = dlsym(RTLD_DEFAULT, 'nvmlUnitGetLedState') + __nvmlUnitGetLedState = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlUnitGetLedState') if __nvmlUnitGetLedState == NULL: if handle == NULL: handle = load_library() - __nvmlUnitGetLedState = dlsym(handle, 'nvmlUnitGetLedState') + __nvmlUnitGetLedState = _cyb_dlsym(handle, 'nvmlUnitGetLedState') global __nvmlUnitGetPsuInfo - __nvmlUnitGetPsuInfo = dlsym(RTLD_DEFAULT, 'nvmlUnitGetPsuInfo') + __nvmlUnitGetPsuInfo = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlUnitGetPsuInfo') if __nvmlUnitGetPsuInfo == NULL: if handle == NULL: handle = load_library() - __nvmlUnitGetPsuInfo = dlsym(handle, 'nvmlUnitGetPsuInfo') + __nvmlUnitGetPsuInfo = _cyb_dlsym(handle, 'nvmlUnitGetPsuInfo') global __nvmlUnitGetTemperature - __nvmlUnitGetTemperature = dlsym(RTLD_DEFAULT, 'nvmlUnitGetTemperature') + __nvmlUnitGetTemperature = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlUnitGetTemperature') if __nvmlUnitGetTemperature == NULL: if handle == NULL: handle = load_library() - __nvmlUnitGetTemperature = dlsym(handle, 'nvmlUnitGetTemperature') + __nvmlUnitGetTemperature = _cyb_dlsym(handle, 'nvmlUnitGetTemperature') global __nvmlUnitGetFanSpeedInfo - __nvmlUnitGetFanSpeedInfo = dlsym(RTLD_DEFAULT, 'nvmlUnitGetFanSpeedInfo') + __nvmlUnitGetFanSpeedInfo = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlUnitGetFanSpeedInfo') if __nvmlUnitGetFanSpeedInfo == NULL: if handle == NULL: handle = load_library() - __nvmlUnitGetFanSpeedInfo = dlsym(handle, 'nvmlUnitGetFanSpeedInfo') + __nvmlUnitGetFanSpeedInfo = _cyb_dlsym(handle, 'nvmlUnitGetFanSpeedInfo') global __nvmlUnitGetDevices - __nvmlUnitGetDevices = dlsym(RTLD_DEFAULT, 'nvmlUnitGetDevices') + __nvmlUnitGetDevices = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlUnitGetDevices') if __nvmlUnitGetDevices == NULL: if handle == NULL: handle = load_library() - __nvmlUnitGetDevices = dlsym(handle, 'nvmlUnitGetDevices') + __nvmlUnitGetDevices = _cyb_dlsym(handle, 'nvmlUnitGetDevices') global __nvmlDeviceGetCount_v2 - __nvmlDeviceGetCount_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCount_v2') + __nvmlDeviceGetCount_v2 = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetCount_v2') if __nvmlDeviceGetCount_v2 == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetCount_v2 = dlsym(handle, 'nvmlDeviceGetCount_v2') + __nvmlDeviceGetCount_v2 = _cyb_dlsym(handle, 'nvmlDeviceGetCount_v2') global __nvmlDeviceGetAttributes_v2 - __nvmlDeviceGetAttributes_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAttributes_v2') + __nvmlDeviceGetAttributes_v2 = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetAttributes_v2') if __nvmlDeviceGetAttributes_v2 == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetAttributes_v2 = dlsym(handle, 'nvmlDeviceGetAttributes_v2') + __nvmlDeviceGetAttributes_v2 = _cyb_dlsym(handle, 'nvmlDeviceGetAttributes_v2') global __nvmlDeviceGetHandleByIndex_v2 - __nvmlDeviceGetHandleByIndex_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetHandleByIndex_v2') + __nvmlDeviceGetHandleByIndex_v2 = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetHandleByIndex_v2') if __nvmlDeviceGetHandleByIndex_v2 == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetHandleByIndex_v2 = dlsym(handle, 'nvmlDeviceGetHandleByIndex_v2') + __nvmlDeviceGetHandleByIndex_v2 = _cyb_dlsym(handle, 'nvmlDeviceGetHandleByIndex_v2') global __nvmlDeviceGetHandleBySerial - __nvmlDeviceGetHandleBySerial = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetHandleBySerial') + __nvmlDeviceGetHandleBySerial = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetHandleBySerial') if __nvmlDeviceGetHandleBySerial == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetHandleBySerial = dlsym(handle, 'nvmlDeviceGetHandleBySerial') + __nvmlDeviceGetHandleBySerial = _cyb_dlsym(handle, 'nvmlDeviceGetHandleBySerial') global __nvmlDeviceGetHandleByUUID - __nvmlDeviceGetHandleByUUID = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetHandleByUUID') + __nvmlDeviceGetHandleByUUID = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetHandleByUUID') if __nvmlDeviceGetHandleByUUID == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetHandleByUUID = dlsym(handle, 'nvmlDeviceGetHandleByUUID') + __nvmlDeviceGetHandleByUUID = _cyb_dlsym(handle, 'nvmlDeviceGetHandleByUUID') global __nvmlDeviceGetHandleByUUIDV - __nvmlDeviceGetHandleByUUIDV = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetHandleByUUIDV') + __nvmlDeviceGetHandleByUUIDV = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetHandleByUUIDV') if __nvmlDeviceGetHandleByUUIDV == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetHandleByUUIDV = dlsym(handle, 'nvmlDeviceGetHandleByUUIDV') + __nvmlDeviceGetHandleByUUIDV = _cyb_dlsym(handle, 'nvmlDeviceGetHandleByUUIDV') global __nvmlDeviceGetHandleByPciBusId_v2 - __nvmlDeviceGetHandleByPciBusId_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetHandleByPciBusId_v2') + __nvmlDeviceGetHandleByPciBusId_v2 = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetHandleByPciBusId_v2') if __nvmlDeviceGetHandleByPciBusId_v2 == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetHandleByPciBusId_v2 = dlsym(handle, 'nvmlDeviceGetHandleByPciBusId_v2') + __nvmlDeviceGetHandleByPciBusId_v2 = _cyb_dlsym(handle, 'nvmlDeviceGetHandleByPciBusId_v2') global __nvmlDeviceGetName - __nvmlDeviceGetName = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetName') + __nvmlDeviceGetName = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetName') if __nvmlDeviceGetName == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetName = dlsym(handle, 'nvmlDeviceGetName') + __nvmlDeviceGetName = _cyb_dlsym(handle, 'nvmlDeviceGetName') global __nvmlDeviceGetBrand - __nvmlDeviceGetBrand = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetBrand') + __nvmlDeviceGetBrand = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetBrand') if __nvmlDeviceGetBrand == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetBrand = dlsym(handle, 'nvmlDeviceGetBrand') + __nvmlDeviceGetBrand = _cyb_dlsym(handle, 'nvmlDeviceGetBrand') global __nvmlDeviceGetIndex - __nvmlDeviceGetIndex = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetIndex') + __nvmlDeviceGetIndex = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetIndex') if __nvmlDeviceGetIndex == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetIndex = dlsym(handle, 'nvmlDeviceGetIndex') + __nvmlDeviceGetIndex = _cyb_dlsym(handle, 'nvmlDeviceGetIndex') global __nvmlDeviceGetSerial - __nvmlDeviceGetSerial = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSerial') + __nvmlDeviceGetSerial = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetSerial') if __nvmlDeviceGetSerial == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetSerial = dlsym(handle, 'nvmlDeviceGetSerial') + __nvmlDeviceGetSerial = _cyb_dlsym(handle, 'nvmlDeviceGetSerial') global __nvmlDeviceGetModuleId - __nvmlDeviceGetModuleId = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetModuleId') + __nvmlDeviceGetModuleId = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetModuleId') if __nvmlDeviceGetModuleId == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetModuleId = dlsym(handle, 'nvmlDeviceGetModuleId') + __nvmlDeviceGetModuleId = _cyb_dlsym(handle, 'nvmlDeviceGetModuleId') global __nvmlDeviceGetC2cModeInfoV - __nvmlDeviceGetC2cModeInfoV = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetC2cModeInfoV') + __nvmlDeviceGetC2cModeInfoV = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetC2cModeInfoV') if __nvmlDeviceGetC2cModeInfoV == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetC2cModeInfoV = dlsym(handle, 'nvmlDeviceGetC2cModeInfoV') + __nvmlDeviceGetC2cModeInfoV = _cyb_dlsym(handle, 'nvmlDeviceGetC2cModeInfoV') global __nvmlDeviceGetMemoryAffinity - __nvmlDeviceGetMemoryAffinity = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMemoryAffinity') + __nvmlDeviceGetMemoryAffinity = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetMemoryAffinity') if __nvmlDeviceGetMemoryAffinity == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetMemoryAffinity = dlsym(handle, 'nvmlDeviceGetMemoryAffinity') + __nvmlDeviceGetMemoryAffinity = _cyb_dlsym(handle, 'nvmlDeviceGetMemoryAffinity') global __nvmlDeviceGetCpuAffinityWithinScope - __nvmlDeviceGetCpuAffinityWithinScope = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCpuAffinityWithinScope') + __nvmlDeviceGetCpuAffinityWithinScope = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetCpuAffinityWithinScope') if __nvmlDeviceGetCpuAffinityWithinScope == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetCpuAffinityWithinScope = dlsym(handle, 'nvmlDeviceGetCpuAffinityWithinScope') + __nvmlDeviceGetCpuAffinityWithinScope = _cyb_dlsym(handle, 'nvmlDeviceGetCpuAffinityWithinScope') global __nvmlDeviceGetCpuAffinity - __nvmlDeviceGetCpuAffinity = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCpuAffinity') + __nvmlDeviceGetCpuAffinity = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetCpuAffinity') if __nvmlDeviceGetCpuAffinity == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetCpuAffinity = dlsym(handle, 'nvmlDeviceGetCpuAffinity') + __nvmlDeviceGetCpuAffinity = _cyb_dlsym(handle, 'nvmlDeviceGetCpuAffinity') global __nvmlDeviceSetCpuAffinity - __nvmlDeviceSetCpuAffinity = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetCpuAffinity') + __nvmlDeviceSetCpuAffinity = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceSetCpuAffinity') if __nvmlDeviceSetCpuAffinity == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceSetCpuAffinity = dlsym(handle, 'nvmlDeviceSetCpuAffinity') + __nvmlDeviceSetCpuAffinity = _cyb_dlsym(handle, 'nvmlDeviceSetCpuAffinity') global __nvmlDeviceClearCpuAffinity - __nvmlDeviceClearCpuAffinity = dlsym(RTLD_DEFAULT, 'nvmlDeviceClearCpuAffinity') + __nvmlDeviceClearCpuAffinity = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceClearCpuAffinity') if __nvmlDeviceClearCpuAffinity == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceClearCpuAffinity = dlsym(handle, 'nvmlDeviceClearCpuAffinity') + __nvmlDeviceClearCpuAffinity = _cyb_dlsym(handle, 'nvmlDeviceClearCpuAffinity') global __nvmlDeviceGetNumaNodeId - __nvmlDeviceGetNumaNodeId = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNumaNodeId') + __nvmlDeviceGetNumaNodeId = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetNumaNodeId') if __nvmlDeviceGetNumaNodeId == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetNumaNodeId = dlsym(handle, 'nvmlDeviceGetNumaNodeId') + __nvmlDeviceGetNumaNodeId = _cyb_dlsym(handle, 'nvmlDeviceGetNumaNodeId') global __nvmlDeviceGetTopologyCommonAncestor - __nvmlDeviceGetTopologyCommonAncestor = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetTopologyCommonAncestor') + __nvmlDeviceGetTopologyCommonAncestor = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetTopologyCommonAncestor') if __nvmlDeviceGetTopologyCommonAncestor == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetTopologyCommonAncestor = dlsym(handle, 'nvmlDeviceGetTopologyCommonAncestor') + __nvmlDeviceGetTopologyCommonAncestor = _cyb_dlsym(handle, 'nvmlDeviceGetTopologyCommonAncestor') global __nvmlDeviceGetTopologyNearestGpus - __nvmlDeviceGetTopologyNearestGpus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetTopologyNearestGpus') + __nvmlDeviceGetTopologyNearestGpus = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetTopologyNearestGpus') if __nvmlDeviceGetTopologyNearestGpus == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetTopologyNearestGpus = dlsym(handle, 'nvmlDeviceGetTopologyNearestGpus') + __nvmlDeviceGetTopologyNearestGpus = _cyb_dlsym(handle, 'nvmlDeviceGetTopologyNearestGpus') global __nvmlDeviceGetP2PStatus - __nvmlDeviceGetP2PStatus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetP2PStatus') + __nvmlDeviceGetP2PStatus = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetP2PStatus') if __nvmlDeviceGetP2PStatus == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetP2PStatus = dlsym(handle, 'nvmlDeviceGetP2PStatus') + __nvmlDeviceGetP2PStatus = _cyb_dlsym(handle, 'nvmlDeviceGetP2PStatus') global __nvmlDeviceGetUUID - __nvmlDeviceGetUUID = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetUUID') + __nvmlDeviceGetUUID = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetUUID') if __nvmlDeviceGetUUID == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetUUID = dlsym(handle, 'nvmlDeviceGetUUID') + __nvmlDeviceGetUUID = _cyb_dlsym(handle, 'nvmlDeviceGetUUID') global __nvmlDeviceGetMinorNumber - __nvmlDeviceGetMinorNumber = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMinorNumber') + __nvmlDeviceGetMinorNumber = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetMinorNumber') if __nvmlDeviceGetMinorNumber == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetMinorNumber = dlsym(handle, 'nvmlDeviceGetMinorNumber') + __nvmlDeviceGetMinorNumber = _cyb_dlsym(handle, 'nvmlDeviceGetMinorNumber') global __nvmlDeviceGetBoardPartNumber - __nvmlDeviceGetBoardPartNumber = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetBoardPartNumber') + __nvmlDeviceGetBoardPartNumber = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetBoardPartNumber') if __nvmlDeviceGetBoardPartNumber == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetBoardPartNumber = dlsym(handle, 'nvmlDeviceGetBoardPartNumber') + __nvmlDeviceGetBoardPartNumber = _cyb_dlsym(handle, 'nvmlDeviceGetBoardPartNumber') global __nvmlDeviceGetInforomVersion - __nvmlDeviceGetInforomVersion = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetInforomVersion') + __nvmlDeviceGetInforomVersion = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetInforomVersion') if __nvmlDeviceGetInforomVersion == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetInforomVersion = dlsym(handle, 'nvmlDeviceGetInforomVersion') + __nvmlDeviceGetInforomVersion = _cyb_dlsym(handle, 'nvmlDeviceGetInforomVersion') global __nvmlDeviceGetInforomImageVersion - __nvmlDeviceGetInforomImageVersion = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetInforomImageVersion') + __nvmlDeviceGetInforomImageVersion = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetInforomImageVersion') if __nvmlDeviceGetInforomImageVersion == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetInforomImageVersion = dlsym(handle, 'nvmlDeviceGetInforomImageVersion') + __nvmlDeviceGetInforomImageVersion = _cyb_dlsym(handle, 'nvmlDeviceGetInforomImageVersion') global __nvmlDeviceGetInforomConfigurationChecksum - __nvmlDeviceGetInforomConfigurationChecksum = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetInforomConfigurationChecksum') + __nvmlDeviceGetInforomConfigurationChecksum = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetInforomConfigurationChecksum') if __nvmlDeviceGetInforomConfigurationChecksum == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetInforomConfigurationChecksum = dlsym(handle, 'nvmlDeviceGetInforomConfigurationChecksum') + __nvmlDeviceGetInforomConfigurationChecksum = _cyb_dlsym(handle, 'nvmlDeviceGetInforomConfigurationChecksum') global __nvmlDeviceValidateInforom - __nvmlDeviceValidateInforom = dlsym(RTLD_DEFAULT, 'nvmlDeviceValidateInforom') + __nvmlDeviceValidateInforom = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceValidateInforom') if __nvmlDeviceValidateInforom == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceValidateInforom = dlsym(handle, 'nvmlDeviceValidateInforom') + __nvmlDeviceValidateInforom = _cyb_dlsym(handle, 'nvmlDeviceValidateInforom') global __nvmlDeviceGetLastBBXFlushTime - __nvmlDeviceGetLastBBXFlushTime = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetLastBBXFlushTime') + __nvmlDeviceGetLastBBXFlushTime = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetLastBBXFlushTime') if __nvmlDeviceGetLastBBXFlushTime == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetLastBBXFlushTime = dlsym(handle, 'nvmlDeviceGetLastBBXFlushTime') + __nvmlDeviceGetLastBBXFlushTime = _cyb_dlsym(handle, 'nvmlDeviceGetLastBBXFlushTime') global __nvmlDeviceGetDisplayMode - __nvmlDeviceGetDisplayMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDisplayMode') + __nvmlDeviceGetDisplayMode = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetDisplayMode') if __nvmlDeviceGetDisplayMode == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetDisplayMode = dlsym(handle, 'nvmlDeviceGetDisplayMode') + __nvmlDeviceGetDisplayMode = _cyb_dlsym(handle, 'nvmlDeviceGetDisplayMode') global __nvmlDeviceGetDisplayActive - __nvmlDeviceGetDisplayActive = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDisplayActive') + __nvmlDeviceGetDisplayActive = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetDisplayActive') if __nvmlDeviceGetDisplayActive == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetDisplayActive = dlsym(handle, 'nvmlDeviceGetDisplayActive') + __nvmlDeviceGetDisplayActive = _cyb_dlsym(handle, 'nvmlDeviceGetDisplayActive') global __nvmlDeviceGetPersistenceMode - __nvmlDeviceGetPersistenceMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPersistenceMode') + __nvmlDeviceGetPersistenceMode = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetPersistenceMode') if __nvmlDeviceGetPersistenceMode == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetPersistenceMode = dlsym(handle, 'nvmlDeviceGetPersistenceMode') + __nvmlDeviceGetPersistenceMode = _cyb_dlsym(handle, 'nvmlDeviceGetPersistenceMode') global __nvmlDeviceGetPciInfoExt - __nvmlDeviceGetPciInfoExt = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPciInfoExt') + __nvmlDeviceGetPciInfoExt = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetPciInfoExt') if __nvmlDeviceGetPciInfoExt == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetPciInfoExt = dlsym(handle, 'nvmlDeviceGetPciInfoExt') + __nvmlDeviceGetPciInfoExt = _cyb_dlsym(handle, 'nvmlDeviceGetPciInfoExt') global __nvmlDeviceGetPciInfo_v3 - __nvmlDeviceGetPciInfo_v3 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPciInfo_v3') + __nvmlDeviceGetPciInfo_v3 = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetPciInfo_v3') if __nvmlDeviceGetPciInfo_v3 == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetPciInfo_v3 = dlsym(handle, 'nvmlDeviceGetPciInfo_v3') + __nvmlDeviceGetPciInfo_v3 = _cyb_dlsym(handle, 'nvmlDeviceGetPciInfo_v3') global __nvmlDeviceGetMaxPcieLinkGeneration - __nvmlDeviceGetMaxPcieLinkGeneration = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMaxPcieLinkGeneration') + __nvmlDeviceGetMaxPcieLinkGeneration = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetMaxPcieLinkGeneration') if __nvmlDeviceGetMaxPcieLinkGeneration == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetMaxPcieLinkGeneration = dlsym(handle, 'nvmlDeviceGetMaxPcieLinkGeneration') + __nvmlDeviceGetMaxPcieLinkGeneration = _cyb_dlsym(handle, 'nvmlDeviceGetMaxPcieLinkGeneration') global __nvmlDeviceGetGpuMaxPcieLinkGeneration - __nvmlDeviceGetGpuMaxPcieLinkGeneration = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuMaxPcieLinkGeneration') + __nvmlDeviceGetGpuMaxPcieLinkGeneration = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetGpuMaxPcieLinkGeneration') if __nvmlDeviceGetGpuMaxPcieLinkGeneration == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetGpuMaxPcieLinkGeneration = dlsym(handle, 'nvmlDeviceGetGpuMaxPcieLinkGeneration') + __nvmlDeviceGetGpuMaxPcieLinkGeneration = _cyb_dlsym(handle, 'nvmlDeviceGetGpuMaxPcieLinkGeneration') global __nvmlDeviceGetMaxPcieLinkWidth - __nvmlDeviceGetMaxPcieLinkWidth = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMaxPcieLinkWidth') + __nvmlDeviceGetMaxPcieLinkWidth = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetMaxPcieLinkWidth') if __nvmlDeviceGetMaxPcieLinkWidth == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetMaxPcieLinkWidth = dlsym(handle, 'nvmlDeviceGetMaxPcieLinkWidth') + __nvmlDeviceGetMaxPcieLinkWidth = _cyb_dlsym(handle, 'nvmlDeviceGetMaxPcieLinkWidth') global __nvmlDeviceGetCurrPcieLinkGeneration - __nvmlDeviceGetCurrPcieLinkGeneration = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCurrPcieLinkGeneration') + __nvmlDeviceGetCurrPcieLinkGeneration = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetCurrPcieLinkGeneration') if __nvmlDeviceGetCurrPcieLinkGeneration == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetCurrPcieLinkGeneration = dlsym(handle, 'nvmlDeviceGetCurrPcieLinkGeneration') + __nvmlDeviceGetCurrPcieLinkGeneration = _cyb_dlsym(handle, 'nvmlDeviceGetCurrPcieLinkGeneration') global __nvmlDeviceGetCurrPcieLinkWidth - __nvmlDeviceGetCurrPcieLinkWidth = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCurrPcieLinkWidth') + __nvmlDeviceGetCurrPcieLinkWidth = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetCurrPcieLinkWidth') if __nvmlDeviceGetCurrPcieLinkWidth == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetCurrPcieLinkWidth = dlsym(handle, 'nvmlDeviceGetCurrPcieLinkWidth') + __nvmlDeviceGetCurrPcieLinkWidth = _cyb_dlsym(handle, 'nvmlDeviceGetCurrPcieLinkWidth') global __nvmlDeviceGetPcieThroughput - __nvmlDeviceGetPcieThroughput = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPcieThroughput') + __nvmlDeviceGetPcieThroughput = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetPcieThroughput') if __nvmlDeviceGetPcieThroughput == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetPcieThroughput = dlsym(handle, 'nvmlDeviceGetPcieThroughput') + __nvmlDeviceGetPcieThroughput = _cyb_dlsym(handle, 'nvmlDeviceGetPcieThroughput') global __nvmlDeviceGetPcieReplayCounter - __nvmlDeviceGetPcieReplayCounter = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPcieReplayCounter') + __nvmlDeviceGetPcieReplayCounter = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetPcieReplayCounter') if __nvmlDeviceGetPcieReplayCounter == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetPcieReplayCounter = dlsym(handle, 'nvmlDeviceGetPcieReplayCounter') + __nvmlDeviceGetPcieReplayCounter = _cyb_dlsym(handle, 'nvmlDeviceGetPcieReplayCounter') global __nvmlDeviceGetClockInfo - __nvmlDeviceGetClockInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetClockInfo') + __nvmlDeviceGetClockInfo = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetClockInfo') if __nvmlDeviceGetClockInfo == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetClockInfo = dlsym(handle, 'nvmlDeviceGetClockInfo') + __nvmlDeviceGetClockInfo = _cyb_dlsym(handle, 'nvmlDeviceGetClockInfo') global __nvmlDeviceGetMaxClockInfo - __nvmlDeviceGetMaxClockInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMaxClockInfo') + __nvmlDeviceGetMaxClockInfo = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetMaxClockInfo') if __nvmlDeviceGetMaxClockInfo == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetMaxClockInfo = dlsym(handle, 'nvmlDeviceGetMaxClockInfo') + __nvmlDeviceGetMaxClockInfo = _cyb_dlsym(handle, 'nvmlDeviceGetMaxClockInfo') global __nvmlDeviceGetGpcClkVfOffset - __nvmlDeviceGetGpcClkVfOffset = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpcClkVfOffset') + __nvmlDeviceGetGpcClkVfOffset = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetGpcClkVfOffset') if __nvmlDeviceGetGpcClkVfOffset == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetGpcClkVfOffset = dlsym(handle, 'nvmlDeviceGetGpcClkVfOffset') + __nvmlDeviceGetGpcClkVfOffset = _cyb_dlsym(handle, 'nvmlDeviceGetGpcClkVfOffset') global __nvmlDeviceGetClock - __nvmlDeviceGetClock = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetClock') + __nvmlDeviceGetClock = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetClock') if __nvmlDeviceGetClock == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetClock = dlsym(handle, 'nvmlDeviceGetClock') + __nvmlDeviceGetClock = _cyb_dlsym(handle, 'nvmlDeviceGetClock') global __nvmlDeviceGetMaxCustomerBoostClock - __nvmlDeviceGetMaxCustomerBoostClock = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMaxCustomerBoostClock') + __nvmlDeviceGetMaxCustomerBoostClock = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetMaxCustomerBoostClock') if __nvmlDeviceGetMaxCustomerBoostClock == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetMaxCustomerBoostClock = dlsym(handle, 'nvmlDeviceGetMaxCustomerBoostClock') + __nvmlDeviceGetMaxCustomerBoostClock = _cyb_dlsym(handle, 'nvmlDeviceGetMaxCustomerBoostClock') global __nvmlDeviceGetSupportedMemoryClocks - __nvmlDeviceGetSupportedMemoryClocks = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSupportedMemoryClocks') + __nvmlDeviceGetSupportedMemoryClocks = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetSupportedMemoryClocks') if __nvmlDeviceGetSupportedMemoryClocks == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetSupportedMemoryClocks = dlsym(handle, 'nvmlDeviceGetSupportedMemoryClocks') + __nvmlDeviceGetSupportedMemoryClocks = _cyb_dlsym(handle, 'nvmlDeviceGetSupportedMemoryClocks') global __nvmlDeviceGetSupportedGraphicsClocks - __nvmlDeviceGetSupportedGraphicsClocks = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSupportedGraphicsClocks') + __nvmlDeviceGetSupportedGraphicsClocks = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetSupportedGraphicsClocks') if __nvmlDeviceGetSupportedGraphicsClocks == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetSupportedGraphicsClocks = dlsym(handle, 'nvmlDeviceGetSupportedGraphicsClocks') + __nvmlDeviceGetSupportedGraphicsClocks = _cyb_dlsym(handle, 'nvmlDeviceGetSupportedGraphicsClocks') global __nvmlDeviceGetAutoBoostedClocksEnabled - __nvmlDeviceGetAutoBoostedClocksEnabled = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAutoBoostedClocksEnabled') + __nvmlDeviceGetAutoBoostedClocksEnabled = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetAutoBoostedClocksEnabled') if __nvmlDeviceGetAutoBoostedClocksEnabled == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetAutoBoostedClocksEnabled = dlsym(handle, 'nvmlDeviceGetAutoBoostedClocksEnabled') + __nvmlDeviceGetAutoBoostedClocksEnabled = _cyb_dlsym(handle, 'nvmlDeviceGetAutoBoostedClocksEnabled') global __nvmlDeviceGetFanSpeed - __nvmlDeviceGetFanSpeed = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetFanSpeed') + __nvmlDeviceGetFanSpeed = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetFanSpeed') if __nvmlDeviceGetFanSpeed == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetFanSpeed = dlsym(handle, 'nvmlDeviceGetFanSpeed') + __nvmlDeviceGetFanSpeed = _cyb_dlsym(handle, 'nvmlDeviceGetFanSpeed') global __nvmlDeviceGetFanSpeed_v2 - __nvmlDeviceGetFanSpeed_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetFanSpeed_v2') + __nvmlDeviceGetFanSpeed_v2 = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetFanSpeed_v2') if __nvmlDeviceGetFanSpeed_v2 == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetFanSpeed_v2 = dlsym(handle, 'nvmlDeviceGetFanSpeed_v2') + __nvmlDeviceGetFanSpeed_v2 = _cyb_dlsym(handle, 'nvmlDeviceGetFanSpeed_v2') global __nvmlDeviceGetFanSpeedRPM - __nvmlDeviceGetFanSpeedRPM = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetFanSpeedRPM') + __nvmlDeviceGetFanSpeedRPM = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetFanSpeedRPM') if __nvmlDeviceGetFanSpeedRPM == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetFanSpeedRPM = dlsym(handle, 'nvmlDeviceGetFanSpeedRPM') + __nvmlDeviceGetFanSpeedRPM = _cyb_dlsym(handle, 'nvmlDeviceGetFanSpeedRPM') global __nvmlDeviceGetTargetFanSpeed - __nvmlDeviceGetTargetFanSpeed = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetTargetFanSpeed') + __nvmlDeviceGetTargetFanSpeed = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetTargetFanSpeed') if __nvmlDeviceGetTargetFanSpeed == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetTargetFanSpeed = dlsym(handle, 'nvmlDeviceGetTargetFanSpeed') + __nvmlDeviceGetTargetFanSpeed = _cyb_dlsym(handle, 'nvmlDeviceGetTargetFanSpeed') global __nvmlDeviceGetMinMaxFanSpeed - __nvmlDeviceGetMinMaxFanSpeed = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMinMaxFanSpeed') + __nvmlDeviceGetMinMaxFanSpeed = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetMinMaxFanSpeed') if __nvmlDeviceGetMinMaxFanSpeed == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetMinMaxFanSpeed = dlsym(handle, 'nvmlDeviceGetMinMaxFanSpeed') + __nvmlDeviceGetMinMaxFanSpeed = _cyb_dlsym(handle, 'nvmlDeviceGetMinMaxFanSpeed') global __nvmlDeviceGetFanControlPolicy_v2 - __nvmlDeviceGetFanControlPolicy_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetFanControlPolicy_v2') + __nvmlDeviceGetFanControlPolicy_v2 = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetFanControlPolicy_v2') if __nvmlDeviceGetFanControlPolicy_v2 == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetFanControlPolicy_v2 = dlsym(handle, 'nvmlDeviceGetFanControlPolicy_v2') + __nvmlDeviceGetFanControlPolicy_v2 = _cyb_dlsym(handle, 'nvmlDeviceGetFanControlPolicy_v2') global __nvmlDeviceGetNumFans - __nvmlDeviceGetNumFans = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNumFans') + __nvmlDeviceGetNumFans = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetNumFans') if __nvmlDeviceGetNumFans == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetNumFans = dlsym(handle, 'nvmlDeviceGetNumFans') + __nvmlDeviceGetNumFans = _cyb_dlsym(handle, 'nvmlDeviceGetNumFans') global __nvmlDeviceGetCoolerInfo - __nvmlDeviceGetCoolerInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCoolerInfo') + __nvmlDeviceGetCoolerInfo = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetCoolerInfo') if __nvmlDeviceGetCoolerInfo == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetCoolerInfo = dlsym(handle, 'nvmlDeviceGetCoolerInfo') + __nvmlDeviceGetCoolerInfo = _cyb_dlsym(handle, 'nvmlDeviceGetCoolerInfo') global __nvmlDeviceGetTemperatureV - __nvmlDeviceGetTemperatureV = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetTemperatureV') + __nvmlDeviceGetTemperatureV = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetTemperatureV') if __nvmlDeviceGetTemperatureV == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetTemperatureV = dlsym(handle, 'nvmlDeviceGetTemperatureV') + __nvmlDeviceGetTemperatureV = _cyb_dlsym(handle, 'nvmlDeviceGetTemperatureV') global __nvmlDeviceGetTemperatureThreshold - __nvmlDeviceGetTemperatureThreshold = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetTemperatureThreshold') + __nvmlDeviceGetTemperatureThreshold = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetTemperatureThreshold') if __nvmlDeviceGetTemperatureThreshold == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetTemperatureThreshold = dlsym(handle, 'nvmlDeviceGetTemperatureThreshold') + __nvmlDeviceGetTemperatureThreshold = _cyb_dlsym(handle, 'nvmlDeviceGetTemperatureThreshold') global __nvmlDeviceGetMarginTemperature - __nvmlDeviceGetMarginTemperature = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMarginTemperature') + __nvmlDeviceGetMarginTemperature = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetMarginTemperature') if __nvmlDeviceGetMarginTemperature == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetMarginTemperature = dlsym(handle, 'nvmlDeviceGetMarginTemperature') + __nvmlDeviceGetMarginTemperature = _cyb_dlsym(handle, 'nvmlDeviceGetMarginTemperature') global __nvmlDeviceGetThermalSettings - __nvmlDeviceGetThermalSettings = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetThermalSettings') + __nvmlDeviceGetThermalSettings = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetThermalSettings') if __nvmlDeviceGetThermalSettings == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetThermalSettings = dlsym(handle, 'nvmlDeviceGetThermalSettings') + __nvmlDeviceGetThermalSettings = _cyb_dlsym(handle, 'nvmlDeviceGetThermalSettings') global __nvmlDeviceGetPerformanceState - __nvmlDeviceGetPerformanceState = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPerformanceState') + __nvmlDeviceGetPerformanceState = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetPerformanceState') if __nvmlDeviceGetPerformanceState == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetPerformanceState = dlsym(handle, 'nvmlDeviceGetPerformanceState') + __nvmlDeviceGetPerformanceState = _cyb_dlsym(handle, 'nvmlDeviceGetPerformanceState') global __nvmlDeviceGetCurrentClocksEventReasons - __nvmlDeviceGetCurrentClocksEventReasons = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCurrentClocksEventReasons') + __nvmlDeviceGetCurrentClocksEventReasons = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetCurrentClocksEventReasons') if __nvmlDeviceGetCurrentClocksEventReasons == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetCurrentClocksEventReasons = dlsym(handle, 'nvmlDeviceGetCurrentClocksEventReasons') + __nvmlDeviceGetCurrentClocksEventReasons = _cyb_dlsym(handle, 'nvmlDeviceGetCurrentClocksEventReasons') global __nvmlDeviceGetSupportedClocksEventReasons - __nvmlDeviceGetSupportedClocksEventReasons = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSupportedClocksEventReasons') + __nvmlDeviceGetSupportedClocksEventReasons = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetSupportedClocksEventReasons') if __nvmlDeviceGetSupportedClocksEventReasons == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetSupportedClocksEventReasons = dlsym(handle, 'nvmlDeviceGetSupportedClocksEventReasons') + __nvmlDeviceGetSupportedClocksEventReasons = _cyb_dlsym(handle, 'nvmlDeviceGetSupportedClocksEventReasons') global __nvmlDeviceGetPowerState - __nvmlDeviceGetPowerState = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPowerState') + __nvmlDeviceGetPowerState = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetPowerState') if __nvmlDeviceGetPowerState == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetPowerState = dlsym(handle, 'nvmlDeviceGetPowerState') + __nvmlDeviceGetPowerState = _cyb_dlsym(handle, 'nvmlDeviceGetPowerState') global __nvmlDeviceGetDynamicPstatesInfo - __nvmlDeviceGetDynamicPstatesInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDynamicPstatesInfo') + __nvmlDeviceGetDynamicPstatesInfo = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetDynamicPstatesInfo') if __nvmlDeviceGetDynamicPstatesInfo == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetDynamicPstatesInfo = dlsym(handle, 'nvmlDeviceGetDynamicPstatesInfo') + __nvmlDeviceGetDynamicPstatesInfo = _cyb_dlsym(handle, 'nvmlDeviceGetDynamicPstatesInfo') global __nvmlDeviceGetMemClkVfOffset - __nvmlDeviceGetMemClkVfOffset = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMemClkVfOffset') + __nvmlDeviceGetMemClkVfOffset = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetMemClkVfOffset') if __nvmlDeviceGetMemClkVfOffset == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetMemClkVfOffset = dlsym(handle, 'nvmlDeviceGetMemClkVfOffset') + __nvmlDeviceGetMemClkVfOffset = _cyb_dlsym(handle, 'nvmlDeviceGetMemClkVfOffset') global __nvmlDeviceGetMinMaxClockOfPState - __nvmlDeviceGetMinMaxClockOfPState = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMinMaxClockOfPState') + __nvmlDeviceGetMinMaxClockOfPState = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetMinMaxClockOfPState') if __nvmlDeviceGetMinMaxClockOfPState == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetMinMaxClockOfPState = dlsym(handle, 'nvmlDeviceGetMinMaxClockOfPState') + __nvmlDeviceGetMinMaxClockOfPState = _cyb_dlsym(handle, 'nvmlDeviceGetMinMaxClockOfPState') global __nvmlDeviceGetSupportedPerformanceStates - __nvmlDeviceGetSupportedPerformanceStates = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSupportedPerformanceStates') + __nvmlDeviceGetSupportedPerformanceStates = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetSupportedPerformanceStates') if __nvmlDeviceGetSupportedPerformanceStates == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetSupportedPerformanceStates = dlsym(handle, 'nvmlDeviceGetSupportedPerformanceStates') + __nvmlDeviceGetSupportedPerformanceStates = _cyb_dlsym(handle, 'nvmlDeviceGetSupportedPerformanceStates') global __nvmlDeviceGetGpcClkMinMaxVfOffset - __nvmlDeviceGetGpcClkMinMaxVfOffset = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpcClkMinMaxVfOffset') + __nvmlDeviceGetGpcClkMinMaxVfOffset = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetGpcClkMinMaxVfOffset') if __nvmlDeviceGetGpcClkMinMaxVfOffset == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetGpcClkMinMaxVfOffset = dlsym(handle, 'nvmlDeviceGetGpcClkMinMaxVfOffset') + __nvmlDeviceGetGpcClkMinMaxVfOffset = _cyb_dlsym(handle, 'nvmlDeviceGetGpcClkMinMaxVfOffset') global __nvmlDeviceGetMemClkMinMaxVfOffset - __nvmlDeviceGetMemClkMinMaxVfOffset = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMemClkMinMaxVfOffset') + __nvmlDeviceGetMemClkMinMaxVfOffset = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetMemClkMinMaxVfOffset') if __nvmlDeviceGetMemClkMinMaxVfOffset == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetMemClkMinMaxVfOffset = dlsym(handle, 'nvmlDeviceGetMemClkMinMaxVfOffset') + __nvmlDeviceGetMemClkMinMaxVfOffset = _cyb_dlsym(handle, 'nvmlDeviceGetMemClkMinMaxVfOffset') global __nvmlDeviceGetClockOffsets - __nvmlDeviceGetClockOffsets = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetClockOffsets') + __nvmlDeviceGetClockOffsets = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetClockOffsets') if __nvmlDeviceGetClockOffsets == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetClockOffsets = dlsym(handle, 'nvmlDeviceGetClockOffsets') + __nvmlDeviceGetClockOffsets = _cyb_dlsym(handle, 'nvmlDeviceGetClockOffsets') global __nvmlDeviceSetClockOffsets - __nvmlDeviceSetClockOffsets = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetClockOffsets') + __nvmlDeviceSetClockOffsets = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceSetClockOffsets') if __nvmlDeviceSetClockOffsets == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceSetClockOffsets = dlsym(handle, 'nvmlDeviceSetClockOffsets') + __nvmlDeviceSetClockOffsets = _cyb_dlsym(handle, 'nvmlDeviceSetClockOffsets') global __nvmlDeviceGetPerformanceModes - __nvmlDeviceGetPerformanceModes = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPerformanceModes') + __nvmlDeviceGetPerformanceModes = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetPerformanceModes') if __nvmlDeviceGetPerformanceModes == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetPerformanceModes = dlsym(handle, 'nvmlDeviceGetPerformanceModes') + __nvmlDeviceGetPerformanceModes = _cyb_dlsym(handle, 'nvmlDeviceGetPerformanceModes') global __nvmlDeviceGetCurrentClockFreqs - __nvmlDeviceGetCurrentClockFreqs = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCurrentClockFreqs') + __nvmlDeviceGetCurrentClockFreqs = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetCurrentClockFreqs') if __nvmlDeviceGetCurrentClockFreqs == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetCurrentClockFreqs = dlsym(handle, 'nvmlDeviceGetCurrentClockFreqs') + __nvmlDeviceGetCurrentClockFreqs = _cyb_dlsym(handle, 'nvmlDeviceGetCurrentClockFreqs') global __nvmlDeviceGetPowerManagementLimit - __nvmlDeviceGetPowerManagementLimit = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPowerManagementLimit') + __nvmlDeviceGetPowerManagementLimit = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetPowerManagementLimit') if __nvmlDeviceGetPowerManagementLimit == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetPowerManagementLimit = dlsym(handle, 'nvmlDeviceGetPowerManagementLimit') + __nvmlDeviceGetPowerManagementLimit = _cyb_dlsym(handle, 'nvmlDeviceGetPowerManagementLimit') global __nvmlDeviceGetPowerManagementLimitConstraints - __nvmlDeviceGetPowerManagementLimitConstraints = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPowerManagementLimitConstraints') + __nvmlDeviceGetPowerManagementLimitConstraints = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetPowerManagementLimitConstraints') if __nvmlDeviceGetPowerManagementLimitConstraints == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetPowerManagementLimitConstraints = dlsym(handle, 'nvmlDeviceGetPowerManagementLimitConstraints') + __nvmlDeviceGetPowerManagementLimitConstraints = _cyb_dlsym(handle, 'nvmlDeviceGetPowerManagementLimitConstraints') global __nvmlDeviceGetPowerManagementDefaultLimit - __nvmlDeviceGetPowerManagementDefaultLimit = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPowerManagementDefaultLimit') + __nvmlDeviceGetPowerManagementDefaultLimit = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetPowerManagementDefaultLimit') if __nvmlDeviceGetPowerManagementDefaultLimit == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetPowerManagementDefaultLimit = dlsym(handle, 'nvmlDeviceGetPowerManagementDefaultLimit') + __nvmlDeviceGetPowerManagementDefaultLimit = _cyb_dlsym(handle, 'nvmlDeviceGetPowerManagementDefaultLimit') global __nvmlDeviceGetPowerUsage - __nvmlDeviceGetPowerUsage = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPowerUsage') + __nvmlDeviceGetPowerUsage = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetPowerUsage') if __nvmlDeviceGetPowerUsage == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetPowerUsage = dlsym(handle, 'nvmlDeviceGetPowerUsage') + __nvmlDeviceGetPowerUsage = _cyb_dlsym(handle, 'nvmlDeviceGetPowerUsage') global __nvmlDeviceGetTotalEnergyConsumption - __nvmlDeviceGetTotalEnergyConsumption = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetTotalEnergyConsumption') + __nvmlDeviceGetTotalEnergyConsumption = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetTotalEnergyConsumption') if __nvmlDeviceGetTotalEnergyConsumption == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetTotalEnergyConsumption = dlsym(handle, 'nvmlDeviceGetTotalEnergyConsumption') + __nvmlDeviceGetTotalEnergyConsumption = _cyb_dlsym(handle, 'nvmlDeviceGetTotalEnergyConsumption') global __nvmlDeviceGetEnforcedPowerLimit - __nvmlDeviceGetEnforcedPowerLimit = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetEnforcedPowerLimit') + __nvmlDeviceGetEnforcedPowerLimit = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetEnforcedPowerLimit') if __nvmlDeviceGetEnforcedPowerLimit == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetEnforcedPowerLimit = dlsym(handle, 'nvmlDeviceGetEnforcedPowerLimit') + __nvmlDeviceGetEnforcedPowerLimit = _cyb_dlsym(handle, 'nvmlDeviceGetEnforcedPowerLimit') global __nvmlDeviceGetGpuOperationMode - __nvmlDeviceGetGpuOperationMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuOperationMode') + __nvmlDeviceGetGpuOperationMode = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetGpuOperationMode') if __nvmlDeviceGetGpuOperationMode == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetGpuOperationMode = dlsym(handle, 'nvmlDeviceGetGpuOperationMode') + __nvmlDeviceGetGpuOperationMode = _cyb_dlsym(handle, 'nvmlDeviceGetGpuOperationMode') global __nvmlDeviceGetMemoryInfo_v2 - __nvmlDeviceGetMemoryInfo_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMemoryInfo_v2') + __nvmlDeviceGetMemoryInfo_v2 = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetMemoryInfo_v2') if __nvmlDeviceGetMemoryInfo_v2 == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetMemoryInfo_v2 = dlsym(handle, 'nvmlDeviceGetMemoryInfo_v2') + __nvmlDeviceGetMemoryInfo_v2 = _cyb_dlsym(handle, 'nvmlDeviceGetMemoryInfo_v2') global __nvmlDeviceGetComputeMode - __nvmlDeviceGetComputeMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetComputeMode') + __nvmlDeviceGetComputeMode = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetComputeMode') if __nvmlDeviceGetComputeMode == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetComputeMode = dlsym(handle, 'nvmlDeviceGetComputeMode') + __nvmlDeviceGetComputeMode = _cyb_dlsym(handle, 'nvmlDeviceGetComputeMode') global __nvmlDeviceGetCudaComputeCapability - __nvmlDeviceGetCudaComputeCapability = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCudaComputeCapability') + __nvmlDeviceGetCudaComputeCapability = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetCudaComputeCapability') if __nvmlDeviceGetCudaComputeCapability == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetCudaComputeCapability = dlsym(handle, 'nvmlDeviceGetCudaComputeCapability') + __nvmlDeviceGetCudaComputeCapability = _cyb_dlsym(handle, 'nvmlDeviceGetCudaComputeCapability') global __nvmlDeviceGetDramEncryptionMode - __nvmlDeviceGetDramEncryptionMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDramEncryptionMode') + __nvmlDeviceGetDramEncryptionMode = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetDramEncryptionMode') if __nvmlDeviceGetDramEncryptionMode == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetDramEncryptionMode = dlsym(handle, 'nvmlDeviceGetDramEncryptionMode') + __nvmlDeviceGetDramEncryptionMode = _cyb_dlsym(handle, 'nvmlDeviceGetDramEncryptionMode') global __nvmlDeviceSetDramEncryptionMode - __nvmlDeviceSetDramEncryptionMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetDramEncryptionMode') + __nvmlDeviceSetDramEncryptionMode = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceSetDramEncryptionMode') if __nvmlDeviceSetDramEncryptionMode == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceSetDramEncryptionMode = dlsym(handle, 'nvmlDeviceSetDramEncryptionMode') + __nvmlDeviceSetDramEncryptionMode = _cyb_dlsym(handle, 'nvmlDeviceSetDramEncryptionMode') global __nvmlDeviceGetEccMode - __nvmlDeviceGetEccMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetEccMode') + __nvmlDeviceGetEccMode = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetEccMode') if __nvmlDeviceGetEccMode == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetEccMode = dlsym(handle, 'nvmlDeviceGetEccMode') + __nvmlDeviceGetEccMode = _cyb_dlsym(handle, 'nvmlDeviceGetEccMode') global __nvmlDeviceGetDefaultEccMode - __nvmlDeviceGetDefaultEccMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDefaultEccMode') + __nvmlDeviceGetDefaultEccMode = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetDefaultEccMode') if __nvmlDeviceGetDefaultEccMode == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetDefaultEccMode = dlsym(handle, 'nvmlDeviceGetDefaultEccMode') + __nvmlDeviceGetDefaultEccMode = _cyb_dlsym(handle, 'nvmlDeviceGetDefaultEccMode') global __nvmlDeviceGetBoardId - __nvmlDeviceGetBoardId = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetBoardId') + __nvmlDeviceGetBoardId = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetBoardId') if __nvmlDeviceGetBoardId == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetBoardId = dlsym(handle, 'nvmlDeviceGetBoardId') + __nvmlDeviceGetBoardId = _cyb_dlsym(handle, 'nvmlDeviceGetBoardId') global __nvmlDeviceGetMultiGpuBoard - __nvmlDeviceGetMultiGpuBoard = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMultiGpuBoard') + __nvmlDeviceGetMultiGpuBoard = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetMultiGpuBoard') if __nvmlDeviceGetMultiGpuBoard == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetMultiGpuBoard = dlsym(handle, 'nvmlDeviceGetMultiGpuBoard') + __nvmlDeviceGetMultiGpuBoard = _cyb_dlsym(handle, 'nvmlDeviceGetMultiGpuBoard') global __nvmlDeviceGetTotalEccErrors - __nvmlDeviceGetTotalEccErrors = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetTotalEccErrors') + __nvmlDeviceGetTotalEccErrors = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetTotalEccErrors') if __nvmlDeviceGetTotalEccErrors == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetTotalEccErrors = dlsym(handle, 'nvmlDeviceGetTotalEccErrors') + __nvmlDeviceGetTotalEccErrors = _cyb_dlsym(handle, 'nvmlDeviceGetTotalEccErrors') global __nvmlDeviceGetMemoryErrorCounter - __nvmlDeviceGetMemoryErrorCounter = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMemoryErrorCounter') + __nvmlDeviceGetMemoryErrorCounter = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetMemoryErrorCounter') if __nvmlDeviceGetMemoryErrorCounter == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetMemoryErrorCounter = dlsym(handle, 'nvmlDeviceGetMemoryErrorCounter') + __nvmlDeviceGetMemoryErrorCounter = _cyb_dlsym(handle, 'nvmlDeviceGetMemoryErrorCounter') global __nvmlDeviceGetUtilizationRates - __nvmlDeviceGetUtilizationRates = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetUtilizationRates') + __nvmlDeviceGetUtilizationRates = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetUtilizationRates') if __nvmlDeviceGetUtilizationRates == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetUtilizationRates = dlsym(handle, 'nvmlDeviceGetUtilizationRates') + __nvmlDeviceGetUtilizationRates = _cyb_dlsym(handle, 'nvmlDeviceGetUtilizationRates') global __nvmlDeviceGetEncoderUtilization - __nvmlDeviceGetEncoderUtilization = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetEncoderUtilization') + __nvmlDeviceGetEncoderUtilization = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetEncoderUtilization') if __nvmlDeviceGetEncoderUtilization == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetEncoderUtilization = dlsym(handle, 'nvmlDeviceGetEncoderUtilization') + __nvmlDeviceGetEncoderUtilization = _cyb_dlsym(handle, 'nvmlDeviceGetEncoderUtilization') global __nvmlDeviceGetEncoderCapacity - __nvmlDeviceGetEncoderCapacity = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetEncoderCapacity') + __nvmlDeviceGetEncoderCapacity = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetEncoderCapacity') if __nvmlDeviceGetEncoderCapacity == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetEncoderCapacity = dlsym(handle, 'nvmlDeviceGetEncoderCapacity') + __nvmlDeviceGetEncoderCapacity = _cyb_dlsym(handle, 'nvmlDeviceGetEncoderCapacity') global __nvmlDeviceGetEncoderStats - __nvmlDeviceGetEncoderStats = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetEncoderStats') + __nvmlDeviceGetEncoderStats = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetEncoderStats') if __nvmlDeviceGetEncoderStats == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetEncoderStats = dlsym(handle, 'nvmlDeviceGetEncoderStats') + __nvmlDeviceGetEncoderStats = _cyb_dlsym(handle, 'nvmlDeviceGetEncoderStats') global __nvmlDeviceGetEncoderSessions - __nvmlDeviceGetEncoderSessions = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetEncoderSessions') + __nvmlDeviceGetEncoderSessions = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetEncoderSessions') if __nvmlDeviceGetEncoderSessions == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetEncoderSessions = dlsym(handle, 'nvmlDeviceGetEncoderSessions') + __nvmlDeviceGetEncoderSessions = _cyb_dlsym(handle, 'nvmlDeviceGetEncoderSessions') global __nvmlDeviceGetDecoderUtilization - __nvmlDeviceGetDecoderUtilization = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDecoderUtilization') + __nvmlDeviceGetDecoderUtilization = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetDecoderUtilization') if __nvmlDeviceGetDecoderUtilization == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetDecoderUtilization = dlsym(handle, 'nvmlDeviceGetDecoderUtilization') + __nvmlDeviceGetDecoderUtilization = _cyb_dlsym(handle, 'nvmlDeviceGetDecoderUtilization') global __nvmlDeviceGetJpgUtilization - __nvmlDeviceGetJpgUtilization = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetJpgUtilization') + __nvmlDeviceGetJpgUtilization = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetJpgUtilization') if __nvmlDeviceGetJpgUtilization == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetJpgUtilization = dlsym(handle, 'nvmlDeviceGetJpgUtilization') + __nvmlDeviceGetJpgUtilization = _cyb_dlsym(handle, 'nvmlDeviceGetJpgUtilization') global __nvmlDeviceGetOfaUtilization - __nvmlDeviceGetOfaUtilization = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetOfaUtilization') + __nvmlDeviceGetOfaUtilization = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetOfaUtilization') if __nvmlDeviceGetOfaUtilization == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetOfaUtilization = dlsym(handle, 'nvmlDeviceGetOfaUtilization') + __nvmlDeviceGetOfaUtilization = _cyb_dlsym(handle, 'nvmlDeviceGetOfaUtilization') global __nvmlDeviceGetFBCStats - __nvmlDeviceGetFBCStats = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetFBCStats') + __nvmlDeviceGetFBCStats = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetFBCStats') if __nvmlDeviceGetFBCStats == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetFBCStats = dlsym(handle, 'nvmlDeviceGetFBCStats') + __nvmlDeviceGetFBCStats = _cyb_dlsym(handle, 'nvmlDeviceGetFBCStats') global __nvmlDeviceGetFBCSessions - __nvmlDeviceGetFBCSessions = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetFBCSessions') + __nvmlDeviceGetFBCSessions = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetFBCSessions') if __nvmlDeviceGetFBCSessions == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetFBCSessions = dlsym(handle, 'nvmlDeviceGetFBCSessions') + __nvmlDeviceGetFBCSessions = _cyb_dlsym(handle, 'nvmlDeviceGetFBCSessions') global __nvmlDeviceGetDriverModel_v2 - __nvmlDeviceGetDriverModel_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDriverModel_v2') + __nvmlDeviceGetDriverModel_v2 = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetDriverModel_v2') if __nvmlDeviceGetDriverModel_v2 == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetDriverModel_v2 = dlsym(handle, 'nvmlDeviceGetDriverModel_v2') + __nvmlDeviceGetDriverModel_v2 = _cyb_dlsym(handle, 'nvmlDeviceGetDriverModel_v2') global __nvmlDeviceGetVbiosVersion - __nvmlDeviceGetVbiosVersion = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVbiosVersion') + __nvmlDeviceGetVbiosVersion = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetVbiosVersion') if __nvmlDeviceGetVbiosVersion == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetVbiosVersion = dlsym(handle, 'nvmlDeviceGetVbiosVersion') + __nvmlDeviceGetVbiosVersion = _cyb_dlsym(handle, 'nvmlDeviceGetVbiosVersion') global __nvmlDeviceGetBridgeChipInfo - __nvmlDeviceGetBridgeChipInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetBridgeChipInfo') + __nvmlDeviceGetBridgeChipInfo = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetBridgeChipInfo') if __nvmlDeviceGetBridgeChipInfo == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetBridgeChipInfo = dlsym(handle, 'nvmlDeviceGetBridgeChipInfo') + __nvmlDeviceGetBridgeChipInfo = _cyb_dlsym(handle, 'nvmlDeviceGetBridgeChipInfo') global __nvmlDeviceGetComputeRunningProcesses_v3 - __nvmlDeviceGetComputeRunningProcesses_v3 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetComputeRunningProcesses_v3') + __nvmlDeviceGetComputeRunningProcesses_v3 = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetComputeRunningProcesses_v3') if __nvmlDeviceGetComputeRunningProcesses_v3 == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetComputeRunningProcesses_v3 = dlsym(handle, 'nvmlDeviceGetComputeRunningProcesses_v3') + __nvmlDeviceGetComputeRunningProcesses_v3 = _cyb_dlsym(handle, 'nvmlDeviceGetComputeRunningProcesses_v3') global __nvmlDeviceGetGraphicsRunningProcesses_v3 - __nvmlDeviceGetGraphicsRunningProcesses_v3 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGraphicsRunningProcesses_v3') + __nvmlDeviceGetGraphicsRunningProcesses_v3 = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetGraphicsRunningProcesses_v3') if __nvmlDeviceGetGraphicsRunningProcesses_v3 == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetGraphicsRunningProcesses_v3 = dlsym(handle, 'nvmlDeviceGetGraphicsRunningProcesses_v3') + __nvmlDeviceGetGraphicsRunningProcesses_v3 = _cyb_dlsym(handle, 'nvmlDeviceGetGraphicsRunningProcesses_v3') global __nvmlDeviceGetMPSComputeRunningProcesses_v3 - __nvmlDeviceGetMPSComputeRunningProcesses_v3 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMPSComputeRunningProcesses_v3') + __nvmlDeviceGetMPSComputeRunningProcesses_v3 = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetMPSComputeRunningProcesses_v3') if __nvmlDeviceGetMPSComputeRunningProcesses_v3 == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetMPSComputeRunningProcesses_v3 = dlsym(handle, 'nvmlDeviceGetMPSComputeRunningProcesses_v3') + __nvmlDeviceGetMPSComputeRunningProcesses_v3 = _cyb_dlsym(handle, 'nvmlDeviceGetMPSComputeRunningProcesses_v3') global __nvmlDeviceGetRunningProcessDetailList - __nvmlDeviceGetRunningProcessDetailList = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetRunningProcessDetailList') + __nvmlDeviceGetRunningProcessDetailList = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetRunningProcessDetailList') if __nvmlDeviceGetRunningProcessDetailList == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetRunningProcessDetailList = dlsym(handle, 'nvmlDeviceGetRunningProcessDetailList') + __nvmlDeviceGetRunningProcessDetailList = _cyb_dlsym(handle, 'nvmlDeviceGetRunningProcessDetailList') global __nvmlDeviceOnSameBoard - __nvmlDeviceOnSameBoard = dlsym(RTLD_DEFAULT, 'nvmlDeviceOnSameBoard') + __nvmlDeviceOnSameBoard = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceOnSameBoard') if __nvmlDeviceOnSameBoard == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceOnSameBoard = dlsym(handle, 'nvmlDeviceOnSameBoard') + __nvmlDeviceOnSameBoard = _cyb_dlsym(handle, 'nvmlDeviceOnSameBoard') global __nvmlDeviceGetAPIRestriction - __nvmlDeviceGetAPIRestriction = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAPIRestriction') + __nvmlDeviceGetAPIRestriction = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetAPIRestriction') if __nvmlDeviceGetAPIRestriction == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetAPIRestriction = dlsym(handle, 'nvmlDeviceGetAPIRestriction') + __nvmlDeviceGetAPIRestriction = _cyb_dlsym(handle, 'nvmlDeviceGetAPIRestriction') global __nvmlDeviceGetSamples - __nvmlDeviceGetSamples = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSamples') + __nvmlDeviceGetSamples = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetSamples') if __nvmlDeviceGetSamples == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetSamples = dlsym(handle, 'nvmlDeviceGetSamples') + __nvmlDeviceGetSamples = _cyb_dlsym(handle, 'nvmlDeviceGetSamples') global __nvmlDeviceGetBAR1MemoryInfo - __nvmlDeviceGetBAR1MemoryInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetBAR1MemoryInfo') + __nvmlDeviceGetBAR1MemoryInfo = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetBAR1MemoryInfo') if __nvmlDeviceGetBAR1MemoryInfo == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetBAR1MemoryInfo = dlsym(handle, 'nvmlDeviceGetBAR1MemoryInfo') + __nvmlDeviceGetBAR1MemoryInfo = _cyb_dlsym(handle, 'nvmlDeviceGetBAR1MemoryInfo') global __nvmlDeviceGetIrqNum - __nvmlDeviceGetIrqNum = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetIrqNum') + __nvmlDeviceGetIrqNum = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetIrqNum') if __nvmlDeviceGetIrqNum == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetIrqNum = dlsym(handle, 'nvmlDeviceGetIrqNum') + __nvmlDeviceGetIrqNum = _cyb_dlsym(handle, 'nvmlDeviceGetIrqNum') global __nvmlDeviceGetNumGpuCores - __nvmlDeviceGetNumGpuCores = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNumGpuCores') + __nvmlDeviceGetNumGpuCores = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetNumGpuCores') if __nvmlDeviceGetNumGpuCores == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetNumGpuCores = dlsym(handle, 'nvmlDeviceGetNumGpuCores') + __nvmlDeviceGetNumGpuCores = _cyb_dlsym(handle, 'nvmlDeviceGetNumGpuCores') global __nvmlDeviceGetPowerSource - __nvmlDeviceGetPowerSource = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPowerSource') + __nvmlDeviceGetPowerSource = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetPowerSource') if __nvmlDeviceGetPowerSource == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetPowerSource = dlsym(handle, 'nvmlDeviceGetPowerSource') + __nvmlDeviceGetPowerSource = _cyb_dlsym(handle, 'nvmlDeviceGetPowerSource') global __nvmlDeviceGetMemoryBusWidth - __nvmlDeviceGetMemoryBusWidth = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMemoryBusWidth') + __nvmlDeviceGetMemoryBusWidth = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetMemoryBusWidth') if __nvmlDeviceGetMemoryBusWidth == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetMemoryBusWidth = dlsym(handle, 'nvmlDeviceGetMemoryBusWidth') + __nvmlDeviceGetMemoryBusWidth = _cyb_dlsym(handle, 'nvmlDeviceGetMemoryBusWidth') global __nvmlDeviceGetPcieLinkMaxSpeed - __nvmlDeviceGetPcieLinkMaxSpeed = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPcieLinkMaxSpeed') + __nvmlDeviceGetPcieLinkMaxSpeed = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetPcieLinkMaxSpeed') if __nvmlDeviceGetPcieLinkMaxSpeed == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetPcieLinkMaxSpeed = dlsym(handle, 'nvmlDeviceGetPcieLinkMaxSpeed') + __nvmlDeviceGetPcieLinkMaxSpeed = _cyb_dlsym(handle, 'nvmlDeviceGetPcieLinkMaxSpeed') global __nvmlDeviceGetPcieSpeed - __nvmlDeviceGetPcieSpeed = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPcieSpeed') + __nvmlDeviceGetPcieSpeed = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetPcieSpeed') if __nvmlDeviceGetPcieSpeed == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetPcieSpeed = dlsym(handle, 'nvmlDeviceGetPcieSpeed') + __nvmlDeviceGetPcieSpeed = _cyb_dlsym(handle, 'nvmlDeviceGetPcieSpeed') global __nvmlDeviceGetAdaptiveClockInfoStatus - __nvmlDeviceGetAdaptiveClockInfoStatus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAdaptiveClockInfoStatus') + __nvmlDeviceGetAdaptiveClockInfoStatus = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetAdaptiveClockInfoStatus') if __nvmlDeviceGetAdaptiveClockInfoStatus == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetAdaptiveClockInfoStatus = dlsym(handle, 'nvmlDeviceGetAdaptiveClockInfoStatus') + __nvmlDeviceGetAdaptiveClockInfoStatus = _cyb_dlsym(handle, 'nvmlDeviceGetAdaptiveClockInfoStatus') global __nvmlDeviceGetBusType - __nvmlDeviceGetBusType = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetBusType') + __nvmlDeviceGetBusType = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetBusType') if __nvmlDeviceGetBusType == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetBusType = dlsym(handle, 'nvmlDeviceGetBusType') + __nvmlDeviceGetBusType = _cyb_dlsym(handle, 'nvmlDeviceGetBusType') global __nvmlDeviceGetGpuFabricInfoV - __nvmlDeviceGetGpuFabricInfoV = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuFabricInfoV') + __nvmlDeviceGetGpuFabricInfoV = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetGpuFabricInfoV') if __nvmlDeviceGetGpuFabricInfoV == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetGpuFabricInfoV = dlsym(handle, 'nvmlDeviceGetGpuFabricInfoV') + __nvmlDeviceGetGpuFabricInfoV = _cyb_dlsym(handle, 'nvmlDeviceGetGpuFabricInfoV') global __nvmlSystemGetConfComputeCapabilities - __nvmlSystemGetConfComputeCapabilities = dlsym(RTLD_DEFAULT, 'nvmlSystemGetConfComputeCapabilities') + __nvmlSystemGetConfComputeCapabilities = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlSystemGetConfComputeCapabilities') if __nvmlSystemGetConfComputeCapabilities == NULL: if handle == NULL: handle = load_library() - __nvmlSystemGetConfComputeCapabilities = dlsym(handle, 'nvmlSystemGetConfComputeCapabilities') + __nvmlSystemGetConfComputeCapabilities = _cyb_dlsym(handle, 'nvmlSystemGetConfComputeCapabilities') global __nvmlSystemGetConfComputeState - __nvmlSystemGetConfComputeState = dlsym(RTLD_DEFAULT, 'nvmlSystemGetConfComputeState') + __nvmlSystemGetConfComputeState = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlSystemGetConfComputeState') if __nvmlSystemGetConfComputeState == NULL: if handle == NULL: handle = load_library() - __nvmlSystemGetConfComputeState = dlsym(handle, 'nvmlSystemGetConfComputeState') + __nvmlSystemGetConfComputeState = _cyb_dlsym(handle, 'nvmlSystemGetConfComputeState') global __nvmlDeviceGetConfComputeMemSizeInfo - __nvmlDeviceGetConfComputeMemSizeInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetConfComputeMemSizeInfo') + __nvmlDeviceGetConfComputeMemSizeInfo = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetConfComputeMemSizeInfo') if __nvmlDeviceGetConfComputeMemSizeInfo == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetConfComputeMemSizeInfo = dlsym(handle, 'nvmlDeviceGetConfComputeMemSizeInfo') + __nvmlDeviceGetConfComputeMemSizeInfo = _cyb_dlsym(handle, 'nvmlDeviceGetConfComputeMemSizeInfo') global __nvmlSystemGetConfComputeGpusReadyState - __nvmlSystemGetConfComputeGpusReadyState = dlsym(RTLD_DEFAULT, 'nvmlSystemGetConfComputeGpusReadyState') + __nvmlSystemGetConfComputeGpusReadyState = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlSystemGetConfComputeGpusReadyState') if __nvmlSystemGetConfComputeGpusReadyState == NULL: if handle == NULL: handle = load_library() - __nvmlSystemGetConfComputeGpusReadyState = dlsym(handle, 'nvmlSystemGetConfComputeGpusReadyState') + __nvmlSystemGetConfComputeGpusReadyState = _cyb_dlsym(handle, 'nvmlSystemGetConfComputeGpusReadyState') global __nvmlDeviceGetConfComputeProtectedMemoryUsage - __nvmlDeviceGetConfComputeProtectedMemoryUsage = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetConfComputeProtectedMemoryUsage') + __nvmlDeviceGetConfComputeProtectedMemoryUsage = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetConfComputeProtectedMemoryUsage') if __nvmlDeviceGetConfComputeProtectedMemoryUsage == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetConfComputeProtectedMemoryUsage = dlsym(handle, 'nvmlDeviceGetConfComputeProtectedMemoryUsage') + __nvmlDeviceGetConfComputeProtectedMemoryUsage = _cyb_dlsym(handle, 'nvmlDeviceGetConfComputeProtectedMemoryUsage') global __nvmlDeviceGetConfComputeGpuCertificate - __nvmlDeviceGetConfComputeGpuCertificate = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetConfComputeGpuCertificate') + __nvmlDeviceGetConfComputeGpuCertificate = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetConfComputeGpuCertificate') if __nvmlDeviceGetConfComputeGpuCertificate == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetConfComputeGpuCertificate = dlsym(handle, 'nvmlDeviceGetConfComputeGpuCertificate') + __nvmlDeviceGetConfComputeGpuCertificate = _cyb_dlsym(handle, 'nvmlDeviceGetConfComputeGpuCertificate') global __nvmlDeviceGetConfComputeGpuAttestationReport - __nvmlDeviceGetConfComputeGpuAttestationReport = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetConfComputeGpuAttestationReport') + __nvmlDeviceGetConfComputeGpuAttestationReport = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetConfComputeGpuAttestationReport') if __nvmlDeviceGetConfComputeGpuAttestationReport == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetConfComputeGpuAttestationReport = dlsym(handle, 'nvmlDeviceGetConfComputeGpuAttestationReport') + __nvmlDeviceGetConfComputeGpuAttestationReport = _cyb_dlsym(handle, 'nvmlDeviceGetConfComputeGpuAttestationReport') global __nvmlSystemGetConfComputeKeyRotationThresholdInfo - __nvmlSystemGetConfComputeKeyRotationThresholdInfo = dlsym(RTLD_DEFAULT, 'nvmlSystemGetConfComputeKeyRotationThresholdInfo') + __nvmlSystemGetConfComputeKeyRotationThresholdInfo = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlSystemGetConfComputeKeyRotationThresholdInfo') if __nvmlSystemGetConfComputeKeyRotationThresholdInfo == NULL: if handle == NULL: handle = load_library() - __nvmlSystemGetConfComputeKeyRotationThresholdInfo = dlsym(handle, 'nvmlSystemGetConfComputeKeyRotationThresholdInfo') + __nvmlSystemGetConfComputeKeyRotationThresholdInfo = _cyb_dlsym(handle, 'nvmlSystemGetConfComputeKeyRotationThresholdInfo') global __nvmlDeviceSetConfComputeUnprotectedMemSize - __nvmlDeviceSetConfComputeUnprotectedMemSize = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetConfComputeUnprotectedMemSize') + __nvmlDeviceSetConfComputeUnprotectedMemSize = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceSetConfComputeUnprotectedMemSize') if __nvmlDeviceSetConfComputeUnprotectedMemSize == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceSetConfComputeUnprotectedMemSize = dlsym(handle, 'nvmlDeviceSetConfComputeUnprotectedMemSize') + __nvmlDeviceSetConfComputeUnprotectedMemSize = _cyb_dlsym(handle, 'nvmlDeviceSetConfComputeUnprotectedMemSize') global __nvmlSystemSetConfComputeGpusReadyState - __nvmlSystemSetConfComputeGpusReadyState = dlsym(RTLD_DEFAULT, 'nvmlSystemSetConfComputeGpusReadyState') + __nvmlSystemSetConfComputeGpusReadyState = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlSystemSetConfComputeGpusReadyState') if __nvmlSystemSetConfComputeGpusReadyState == NULL: if handle == NULL: handle = load_library() - __nvmlSystemSetConfComputeGpusReadyState = dlsym(handle, 'nvmlSystemSetConfComputeGpusReadyState') + __nvmlSystemSetConfComputeGpusReadyState = _cyb_dlsym(handle, 'nvmlSystemSetConfComputeGpusReadyState') global __nvmlSystemSetConfComputeKeyRotationThresholdInfo - __nvmlSystemSetConfComputeKeyRotationThresholdInfo = dlsym(RTLD_DEFAULT, 'nvmlSystemSetConfComputeKeyRotationThresholdInfo') + __nvmlSystemSetConfComputeKeyRotationThresholdInfo = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlSystemSetConfComputeKeyRotationThresholdInfo') if __nvmlSystemSetConfComputeKeyRotationThresholdInfo == NULL: if handle == NULL: handle = load_library() - __nvmlSystemSetConfComputeKeyRotationThresholdInfo = dlsym(handle, 'nvmlSystemSetConfComputeKeyRotationThresholdInfo') + __nvmlSystemSetConfComputeKeyRotationThresholdInfo = _cyb_dlsym(handle, 'nvmlSystemSetConfComputeKeyRotationThresholdInfo') global __nvmlSystemGetConfComputeSettings - __nvmlSystemGetConfComputeSettings = dlsym(RTLD_DEFAULT, 'nvmlSystemGetConfComputeSettings') + __nvmlSystemGetConfComputeSettings = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlSystemGetConfComputeSettings') if __nvmlSystemGetConfComputeSettings == NULL: if handle == NULL: handle = load_library() - __nvmlSystemGetConfComputeSettings = dlsym(handle, 'nvmlSystemGetConfComputeSettings') + __nvmlSystemGetConfComputeSettings = _cyb_dlsym(handle, 'nvmlSystemGetConfComputeSettings') global __nvmlDeviceGetGspFirmwareVersion - __nvmlDeviceGetGspFirmwareVersion = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGspFirmwareVersion') + __nvmlDeviceGetGspFirmwareVersion = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetGspFirmwareVersion') if __nvmlDeviceGetGspFirmwareVersion == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetGspFirmwareVersion = dlsym(handle, 'nvmlDeviceGetGspFirmwareVersion') + __nvmlDeviceGetGspFirmwareVersion = _cyb_dlsym(handle, 'nvmlDeviceGetGspFirmwareVersion') global __nvmlDeviceGetGspFirmwareMode - __nvmlDeviceGetGspFirmwareMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGspFirmwareMode') + __nvmlDeviceGetGspFirmwareMode = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetGspFirmwareMode') if __nvmlDeviceGetGspFirmwareMode == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetGspFirmwareMode = dlsym(handle, 'nvmlDeviceGetGspFirmwareMode') + __nvmlDeviceGetGspFirmwareMode = _cyb_dlsym(handle, 'nvmlDeviceGetGspFirmwareMode') global __nvmlDeviceGetSramEccErrorStatus - __nvmlDeviceGetSramEccErrorStatus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSramEccErrorStatus') + __nvmlDeviceGetSramEccErrorStatus = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetSramEccErrorStatus') if __nvmlDeviceGetSramEccErrorStatus == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetSramEccErrorStatus = dlsym(handle, 'nvmlDeviceGetSramEccErrorStatus') + __nvmlDeviceGetSramEccErrorStatus = _cyb_dlsym(handle, 'nvmlDeviceGetSramEccErrorStatus') global __nvmlDeviceGetAccountingMode - __nvmlDeviceGetAccountingMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAccountingMode') + __nvmlDeviceGetAccountingMode = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetAccountingMode') if __nvmlDeviceGetAccountingMode == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetAccountingMode = dlsym(handle, 'nvmlDeviceGetAccountingMode') + __nvmlDeviceGetAccountingMode = _cyb_dlsym(handle, 'nvmlDeviceGetAccountingMode') global __nvmlDeviceGetAccountingStats - __nvmlDeviceGetAccountingStats = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAccountingStats') + __nvmlDeviceGetAccountingStats = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetAccountingStats') if __nvmlDeviceGetAccountingStats == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetAccountingStats = dlsym(handle, 'nvmlDeviceGetAccountingStats') + __nvmlDeviceGetAccountingStats = _cyb_dlsym(handle, 'nvmlDeviceGetAccountingStats') global __nvmlDeviceGetAccountingPids - __nvmlDeviceGetAccountingPids = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAccountingPids') + __nvmlDeviceGetAccountingPids = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetAccountingPids') if __nvmlDeviceGetAccountingPids == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetAccountingPids = dlsym(handle, 'nvmlDeviceGetAccountingPids') + __nvmlDeviceGetAccountingPids = _cyb_dlsym(handle, 'nvmlDeviceGetAccountingPids') global __nvmlDeviceGetAccountingBufferSize - __nvmlDeviceGetAccountingBufferSize = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAccountingBufferSize') + __nvmlDeviceGetAccountingBufferSize = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetAccountingBufferSize') if __nvmlDeviceGetAccountingBufferSize == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetAccountingBufferSize = dlsym(handle, 'nvmlDeviceGetAccountingBufferSize') + __nvmlDeviceGetAccountingBufferSize = _cyb_dlsym(handle, 'nvmlDeviceGetAccountingBufferSize') global __nvmlDeviceGetRetiredPages - __nvmlDeviceGetRetiredPages = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetRetiredPages') + __nvmlDeviceGetRetiredPages = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetRetiredPages') if __nvmlDeviceGetRetiredPages == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetRetiredPages = dlsym(handle, 'nvmlDeviceGetRetiredPages') + __nvmlDeviceGetRetiredPages = _cyb_dlsym(handle, 'nvmlDeviceGetRetiredPages') global __nvmlDeviceGetRetiredPages_v2 - __nvmlDeviceGetRetiredPages_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetRetiredPages_v2') + __nvmlDeviceGetRetiredPages_v2 = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetRetiredPages_v2') if __nvmlDeviceGetRetiredPages_v2 == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetRetiredPages_v2 = dlsym(handle, 'nvmlDeviceGetRetiredPages_v2') + __nvmlDeviceGetRetiredPages_v2 = _cyb_dlsym(handle, 'nvmlDeviceGetRetiredPages_v2') global __nvmlDeviceGetRetiredPagesPendingStatus - __nvmlDeviceGetRetiredPagesPendingStatus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetRetiredPagesPendingStatus') + __nvmlDeviceGetRetiredPagesPendingStatus = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetRetiredPagesPendingStatus') if __nvmlDeviceGetRetiredPagesPendingStatus == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetRetiredPagesPendingStatus = dlsym(handle, 'nvmlDeviceGetRetiredPagesPendingStatus') + __nvmlDeviceGetRetiredPagesPendingStatus = _cyb_dlsym(handle, 'nvmlDeviceGetRetiredPagesPendingStatus') global __nvmlDeviceGetRemappedRows - __nvmlDeviceGetRemappedRows = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetRemappedRows') + __nvmlDeviceGetRemappedRows = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetRemappedRows') if __nvmlDeviceGetRemappedRows == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetRemappedRows = dlsym(handle, 'nvmlDeviceGetRemappedRows') + __nvmlDeviceGetRemappedRows = _cyb_dlsym(handle, 'nvmlDeviceGetRemappedRows') global __nvmlDeviceGetRowRemapperHistogram - __nvmlDeviceGetRowRemapperHistogram = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetRowRemapperHistogram') + __nvmlDeviceGetRowRemapperHistogram = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetRowRemapperHistogram') if __nvmlDeviceGetRowRemapperHistogram == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetRowRemapperHistogram = dlsym(handle, 'nvmlDeviceGetRowRemapperHistogram') + __nvmlDeviceGetRowRemapperHistogram = _cyb_dlsym(handle, 'nvmlDeviceGetRowRemapperHistogram') global __nvmlDeviceGetArchitecture - __nvmlDeviceGetArchitecture = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetArchitecture') + __nvmlDeviceGetArchitecture = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetArchitecture') if __nvmlDeviceGetArchitecture == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetArchitecture = dlsym(handle, 'nvmlDeviceGetArchitecture') + __nvmlDeviceGetArchitecture = _cyb_dlsym(handle, 'nvmlDeviceGetArchitecture') global __nvmlDeviceGetClkMonStatus - __nvmlDeviceGetClkMonStatus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetClkMonStatus') + __nvmlDeviceGetClkMonStatus = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetClkMonStatus') if __nvmlDeviceGetClkMonStatus == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetClkMonStatus = dlsym(handle, 'nvmlDeviceGetClkMonStatus') + __nvmlDeviceGetClkMonStatus = _cyb_dlsym(handle, 'nvmlDeviceGetClkMonStatus') global __nvmlDeviceGetProcessUtilization - __nvmlDeviceGetProcessUtilization = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetProcessUtilization') + __nvmlDeviceGetProcessUtilization = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetProcessUtilization') if __nvmlDeviceGetProcessUtilization == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetProcessUtilization = dlsym(handle, 'nvmlDeviceGetProcessUtilization') + __nvmlDeviceGetProcessUtilization = _cyb_dlsym(handle, 'nvmlDeviceGetProcessUtilization') global __nvmlDeviceGetProcessesUtilizationInfo - __nvmlDeviceGetProcessesUtilizationInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetProcessesUtilizationInfo') + __nvmlDeviceGetProcessesUtilizationInfo = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetProcessesUtilizationInfo') if __nvmlDeviceGetProcessesUtilizationInfo == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetProcessesUtilizationInfo = dlsym(handle, 'nvmlDeviceGetProcessesUtilizationInfo') + __nvmlDeviceGetProcessesUtilizationInfo = _cyb_dlsym(handle, 'nvmlDeviceGetProcessesUtilizationInfo') global __nvmlDeviceGetPlatformInfo - __nvmlDeviceGetPlatformInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPlatformInfo') + __nvmlDeviceGetPlatformInfo = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetPlatformInfo') if __nvmlDeviceGetPlatformInfo == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetPlatformInfo = dlsym(handle, 'nvmlDeviceGetPlatformInfo') + __nvmlDeviceGetPlatformInfo = _cyb_dlsym(handle, 'nvmlDeviceGetPlatformInfo') global __nvmlUnitSetLedState - __nvmlUnitSetLedState = dlsym(RTLD_DEFAULT, 'nvmlUnitSetLedState') + __nvmlUnitSetLedState = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlUnitSetLedState') if __nvmlUnitSetLedState == NULL: if handle == NULL: handle = load_library() - __nvmlUnitSetLedState = dlsym(handle, 'nvmlUnitSetLedState') + __nvmlUnitSetLedState = _cyb_dlsym(handle, 'nvmlUnitSetLedState') global __nvmlDeviceSetPersistenceMode - __nvmlDeviceSetPersistenceMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetPersistenceMode') + __nvmlDeviceSetPersistenceMode = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceSetPersistenceMode') if __nvmlDeviceSetPersistenceMode == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceSetPersistenceMode = dlsym(handle, 'nvmlDeviceSetPersistenceMode') + __nvmlDeviceSetPersistenceMode = _cyb_dlsym(handle, 'nvmlDeviceSetPersistenceMode') global __nvmlDeviceSetComputeMode - __nvmlDeviceSetComputeMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetComputeMode') + __nvmlDeviceSetComputeMode = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceSetComputeMode') if __nvmlDeviceSetComputeMode == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceSetComputeMode = dlsym(handle, 'nvmlDeviceSetComputeMode') + __nvmlDeviceSetComputeMode = _cyb_dlsym(handle, 'nvmlDeviceSetComputeMode') global __nvmlDeviceSetEccMode - __nvmlDeviceSetEccMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetEccMode') + __nvmlDeviceSetEccMode = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceSetEccMode') if __nvmlDeviceSetEccMode == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceSetEccMode = dlsym(handle, 'nvmlDeviceSetEccMode') + __nvmlDeviceSetEccMode = _cyb_dlsym(handle, 'nvmlDeviceSetEccMode') global __nvmlDeviceClearEccErrorCounts - __nvmlDeviceClearEccErrorCounts = dlsym(RTLD_DEFAULT, 'nvmlDeviceClearEccErrorCounts') + __nvmlDeviceClearEccErrorCounts = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceClearEccErrorCounts') if __nvmlDeviceClearEccErrorCounts == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceClearEccErrorCounts = dlsym(handle, 'nvmlDeviceClearEccErrorCounts') + __nvmlDeviceClearEccErrorCounts = _cyb_dlsym(handle, 'nvmlDeviceClearEccErrorCounts') global __nvmlDeviceSetDriverModel - __nvmlDeviceSetDriverModel = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetDriverModel') + __nvmlDeviceSetDriverModel = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceSetDriverModel') if __nvmlDeviceSetDriverModel == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceSetDriverModel = dlsym(handle, 'nvmlDeviceSetDriverModel') + __nvmlDeviceSetDriverModel = _cyb_dlsym(handle, 'nvmlDeviceSetDriverModel') global __nvmlDeviceSetGpuLockedClocks - __nvmlDeviceSetGpuLockedClocks = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetGpuLockedClocks') + __nvmlDeviceSetGpuLockedClocks = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceSetGpuLockedClocks') if __nvmlDeviceSetGpuLockedClocks == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceSetGpuLockedClocks = dlsym(handle, 'nvmlDeviceSetGpuLockedClocks') + __nvmlDeviceSetGpuLockedClocks = _cyb_dlsym(handle, 'nvmlDeviceSetGpuLockedClocks') global __nvmlDeviceResetGpuLockedClocks - __nvmlDeviceResetGpuLockedClocks = dlsym(RTLD_DEFAULT, 'nvmlDeviceResetGpuLockedClocks') + __nvmlDeviceResetGpuLockedClocks = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceResetGpuLockedClocks') if __nvmlDeviceResetGpuLockedClocks == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceResetGpuLockedClocks = dlsym(handle, 'nvmlDeviceResetGpuLockedClocks') + __nvmlDeviceResetGpuLockedClocks = _cyb_dlsym(handle, 'nvmlDeviceResetGpuLockedClocks') global __nvmlDeviceSetMemoryLockedClocks - __nvmlDeviceSetMemoryLockedClocks = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetMemoryLockedClocks') + __nvmlDeviceSetMemoryLockedClocks = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceSetMemoryLockedClocks') if __nvmlDeviceSetMemoryLockedClocks == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceSetMemoryLockedClocks = dlsym(handle, 'nvmlDeviceSetMemoryLockedClocks') + __nvmlDeviceSetMemoryLockedClocks = _cyb_dlsym(handle, 'nvmlDeviceSetMemoryLockedClocks') global __nvmlDeviceResetMemoryLockedClocks - __nvmlDeviceResetMemoryLockedClocks = dlsym(RTLD_DEFAULT, 'nvmlDeviceResetMemoryLockedClocks') + __nvmlDeviceResetMemoryLockedClocks = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceResetMemoryLockedClocks') if __nvmlDeviceResetMemoryLockedClocks == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceResetMemoryLockedClocks = dlsym(handle, 'nvmlDeviceResetMemoryLockedClocks') + __nvmlDeviceResetMemoryLockedClocks = _cyb_dlsym(handle, 'nvmlDeviceResetMemoryLockedClocks') global __nvmlDeviceSetAutoBoostedClocksEnabled - __nvmlDeviceSetAutoBoostedClocksEnabled = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetAutoBoostedClocksEnabled') + __nvmlDeviceSetAutoBoostedClocksEnabled = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceSetAutoBoostedClocksEnabled') if __nvmlDeviceSetAutoBoostedClocksEnabled == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceSetAutoBoostedClocksEnabled = dlsym(handle, 'nvmlDeviceSetAutoBoostedClocksEnabled') + __nvmlDeviceSetAutoBoostedClocksEnabled = _cyb_dlsym(handle, 'nvmlDeviceSetAutoBoostedClocksEnabled') global __nvmlDeviceSetDefaultAutoBoostedClocksEnabled - __nvmlDeviceSetDefaultAutoBoostedClocksEnabled = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetDefaultAutoBoostedClocksEnabled') + __nvmlDeviceSetDefaultAutoBoostedClocksEnabled = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceSetDefaultAutoBoostedClocksEnabled') if __nvmlDeviceSetDefaultAutoBoostedClocksEnabled == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceSetDefaultAutoBoostedClocksEnabled = dlsym(handle, 'nvmlDeviceSetDefaultAutoBoostedClocksEnabled') + __nvmlDeviceSetDefaultAutoBoostedClocksEnabled = _cyb_dlsym(handle, 'nvmlDeviceSetDefaultAutoBoostedClocksEnabled') global __nvmlDeviceSetDefaultFanSpeed_v2 - __nvmlDeviceSetDefaultFanSpeed_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetDefaultFanSpeed_v2') + __nvmlDeviceSetDefaultFanSpeed_v2 = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceSetDefaultFanSpeed_v2') if __nvmlDeviceSetDefaultFanSpeed_v2 == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceSetDefaultFanSpeed_v2 = dlsym(handle, 'nvmlDeviceSetDefaultFanSpeed_v2') + __nvmlDeviceSetDefaultFanSpeed_v2 = _cyb_dlsym(handle, 'nvmlDeviceSetDefaultFanSpeed_v2') global __nvmlDeviceSetFanControlPolicy - __nvmlDeviceSetFanControlPolicy = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetFanControlPolicy') + __nvmlDeviceSetFanControlPolicy = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceSetFanControlPolicy') if __nvmlDeviceSetFanControlPolicy == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceSetFanControlPolicy = dlsym(handle, 'nvmlDeviceSetFanControlPolicy') + __nvmlDeviceSetFanControlPolicy = _cyb_dlsym(handle, 'nvmlDeviceSetFanControlPolicy') global __nvmlDeviceSetTemperatureThreshold - __nvmlDeviceSetTemperatureThreshold = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetTemperatureThreshold') + __nvmlDeviceSetTemperatureThreshold = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceSetTemperatureThreshold') if __nvmlDeviceSetTemperatureThreshold == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceSetTemperatureThreshold = dlsym(handle, 'nvmlDeviceSetTemperatureThreshold') + __nvmlDeviceSetTemperatureThreshold = _cyb_dlsym(handle, 'nvmlDeviceSetTemperatureThreshold') global __nvmlDeviceSetGpuOperationMode - __nvmlDeviceSetGpuOperationMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetGpuOperationMode') + __nvmlDeviceSetGpuOperationMode = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceSetGpuOperationMode') if __nvmlDeviceSetGpuOperationMode == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceSetGpuOperationMode = dlsym(handle, 'nvmlDeviceSetGpuOperationMode') + __nvmlDeviceSetGpuOperationMode = _cyb_dlsym(handle, 'nvmlDeviceSetGpuOperationMode') global __nvmlDeviceSetAPIRestriction - __nvmlDeviceSetAPIRestriction = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetAPIRestriction') + __nvmlDeviceSetAPIRestriction = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceSetAPIRestriction') if __nvmlDeviceSetAPIRestriction == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceSetAPIRestriction = dlsym(handle, 'nvmlDeviceSetAPIRestriction') + __nvmlDeviceSetAPIRestriction = _cyb_dlsym(handle, 'nvmlDeviceSetAPIRestriction') global __nvmlDeviceSetFanSpeed_v2 - __nvmlDeviceSetFanSpeed_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetFanSpeed_v2') + __nvmlDeviceSetFanSpeed_v2 = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceSetFanSpeed_v2') if __nvmlDeviceSetFanSpeed_v2 == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceSetFanSpeed_v2 = dlsym(handle, 'nvmlDeviceSetFanSpeed_v2') + __nvmlDeviceSetFanSpeed_v2 = _cyb_dlsym(handle, 'nvmlDeviceSetFanSpeed_v2') global __nvmlDeviceSetAccountingMode - __nvmlDeviceSetAccountingMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetAccountingMode') + __nvmlDeviceSetAccountingMode = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceSetAccountingMode') if __nvmlDeviceSetAccountingMode == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceSetAccountingMode = dlsym(handle, 'nvmlDeviceSetAccountingMode') + __nvmlDeviceSetAccountingMode = _cyb_dlsym(handle, 'nvmlDeviceSetAccountingMode') global __nvmlDeviceClearAccountingPids - __nvmlDeviceClearAccountingPids = dlsym(RTLD_DEFAULT, 'nvmlDeviceClearAccountingPids') + __nvmlDeviceClearAccountingPids = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceClearAccountingPids') if __nvmlDeviceClearAccountingPids == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceClearAccountingPids = dlsym(handle, 'nvmlDeviceClearAccountingPids') + __nvmlDeviceClearAccountingPids = _cyb_dlsym(handle, 'nvmlDeviceClearAccountingPids') global __nvmlDeviceSetPowerManagementLimit_v2 - __nvmlDeviceSetPowerManagementLimit_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetPowerManagementLimit_v2') + __nvmlDeviceSetPowerManagementLimit_v2 = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceSetPowerManagementLimit_v2') if __nvmlDeviceSetPowerManagementLimit_v2 == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceSetPowerManagementLimit_v2 = dlsym(handle, 'nvmlDeviceSetPowerManagementLimit_v2') + __nvmlDeviceSetPowerManagementLimit_v2 = _cyb_dlsym(handle, 'nvmlDeviceSetPowerManagementLimit_v2') global __nvmlDeviceGetNvLinkState - __nvmlDeviceGetNvLinkState = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvLinkState') + __nvmlDeviceGetNvLinkState = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetNvLinkState') if __nvmlDeviceGetNvLinkState == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetNvLinkState = dlsym(handle, 'nvmlDeviceGetNvLinkState') + __nvmlDeviceGetNvLinkState = _cyb_dlsym(handle, 'nvmlDeviceGetNvLinkState') global __nvmlDeviceGetNvLinkVersion - __nvmlDeviceGetNvLinkVersion = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvLinkVersion') + __nvmlDeviceGetNvLinkVersion = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetNvLinkVersion') if __nvmlDeviceGetNvLinkVersion == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetNvLinkVersion = dlsym(handle, 'nvmlDeviceGetNvLinkVersion') + __nvmlDeviceGetNvLinkVersion = _cyb_dlsym(handle, 'nvmlDeviceGetNvLinkVersion') global __nvmlDeviceGetNvLinkCapability - __nvmlDeviceGetNvLinkCapability = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvLinkCapability') + __nvmlDeviceGetNvLinkCapability = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetNvLinkCapability') if __nvmlDeviceGetNvLinkCapability == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetNvLinkCapability = dlsym(handle, 'nvmlDeviceGetNvLinkCapability') + __nvmlDeviceGetNvLinkCapability = _cyb_dlsym(handle, 'nvmlDeviceGetNvLinkCapability') global __nvmlDeviceGetNvLinkRemotePciInfo_v2 - __nvmlDeviceGetNvLinkRemotePciInfo_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvLinkRemotePciInfo_v2') + __nvmlDeviceGetNvLinkRemotePciInfo_v2 = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetNvLinkRemotePciInfo_v2') if __nvmlDeviceGetNvLinkRemotePciInfo_v2 == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetNvLinkRemotePciInfo_v2 = dlsym(handle, 'nvmlDeviceGetNvLinkRemotePciInfo_v2') + __nvmlDeviceGetNvLinkRemotePciInfo_v2 = _cyb_dlsym(handle, 'nvmlDeviceGetNvLinkRemotePciInfo_v2') global __nvmlDeviceGetNvLinkErrorCounter - __nvmlDeviceGetNvLinkErrorCounter = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvLinkErrorCounter') + __nvmlDeviceGetNvLinkErrorCounter = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetNvLinkErrorCounter') if __nvmlDeviceGetNvLinkErrorCounter == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetNvLinkErrorCounter = dlsym(handle, 'nvmlDeviceGetNvLinkErrorCounter') + __nvmlDeviceGetNvLinkErrorCounter = _cyb_dlsym(handle, 'nvmlDeviceGetNvLinkErrorCounter') global __nvmlDeviceResetNvLinkErrorCounters - __nvmlDeviceResetNvLinkErrorCounters = dlsym(RTLD_DEFAULT, 'nvmlDeviceResetNvLinkErrorCounters') + __nvmlDeviceResetNvLinkErrorCounters = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceResetNvLinkErrorCounters') if __nvmlDeviceResetNvLinkErrorCounters == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceResetNvLinkErrorCounters = dlsym(handle, 'nvmlDeviceResetNvLinkErrorCounters') + __nvmlDeviceResetNvLinkErrorCounters = _cyb_dlsym(handle, 'nvmlDeviceResetNvLinkErrorCounters') global __nvmlDeviceGetNvLinkRemoteDeviceType - __nvmlDeviceGetNvLinkRemoteDeviceType = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvLinkRemoteDeviceType') + __nvmlDeviceGetNvLinkRemoteDeviceType = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetNvLinkRemoteDeviceType') if __nvmlDeviceGetNvLinkRemoteDeviceType == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetNvLinkRemoteDeviceType = dlsym(handle, 'nvmlDeviceGetNvLinkRemoteDeviceType') + __nvmlDeviceGetNvLinkRemoteDeviceType = _cyb_dlsym(handle, 'nvmlDeviceGetNvLinkRemoteDeviceType') global __nvmlDeviceSetNvLinkDeviceLowPowerThreshold - __nvmlDeviceSetNvLinkDeviceLowPowerThreshold = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetNvLinkDeviceLowPowerThreshold') + __nvmlDeviceSetNvLinkDeviceLowPowerThreshold = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceSetNvLinkDeviceLowPowerThreshold') if __nvmlDeviceSetNvLinkDeviceLowPowerThreshold == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceSetNvLinkDeviceLowPowerThreshold = dlsym(handle, 'nvmlDeviceSetNvLinkDeviceLowPowerThreshold') + __nvmlDeviceSetNvLinkDeviceLowPowerThreshold = _cyb_dlsym(handle, 'nvmlDeviceSetNvLinkDeviceLowPowerThreshold') global __nvmlSystemSetNvlinkBwMode - __nvmlSystemSetNvlinkBwMode = dlsym(RTLD_DEFAULT, 'nvmlSystemSetNvlinkBwMode') + __nvmlSystemSetNvlinkBwMode = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlSystemSetNvlinkBwMode') if __nvmlSystemSetNvlinkBwMode == NULL: if handle == NULL: handle = load_library() - __nvmlSystemSetNvlinkBwMode = dlsym(handle, 'nvmlSystemSetNvlinkBwMode') + __nvmlSystemSetNvlinkBwMode = _cyb_dlsym(handle, 'nvmlSystemSetNvlinkBwMode') global __nvmlSystemGetNvlinkBwMode - __nvmlSystemGetNvlinkBwMode = dlsym(RTLD_DEFAULT, 'nvmlSystemGetNvlinkBwMode') + __nvmlSystemGetNvlinkBwMode = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlSystemGetNvlinkBwMode') if __nvmlSystemGetNvlinkBwMode == NULL: if handle == NULL: handle = load_library() - __nvmlSystemGetNvlinkBwMode = dlsym(handle, 'nvmlSystemGetNvlinkBwMode') + __nvmlSystemGetNvlinkBwMode = _cyb_dlsym(handle, 'nvmlSystemGetNvlinkBwMode') global __nvmlDeviceGetNvlinkSupportedBwModes - __nvmlDeviceGetNvlinkSupportedBwModes = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvlinkSupportedBwModes') + __nvmlDeviceGetNvlinkSupportedBwModes = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetNvlinkSupportedBwModes') if __nvmlDeviceGetNvlinkSupportedBwModes == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetNvlinkSupportedBwModes = dlsym(handle, 'nvmlDeviceGetNvlinkSupportedBwModes') + __nvmlDeviceGetNvlinkSupportedBwModes = _cyb_dlsym(handle, 'nvmlDeviceGetNvlinkSupportedBwModes') global __nvmlDeviceGetNvlinkBwMode - __nvmlDeviceGetNvlinkBwMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvlinkBwMode') + __nvmlDeviceGetNvlinkBwMode = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetNvlinkBwMode') if __nvmlDeviceGetNvlinkBwMode == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetNvlinkBwMode = dlsym(handle, 'nvmlDeviceGetNvlinkBwMode') + __nvmlDeviceGetNvlinkBwMode = _cyb_dlsym(handle, 'nvmlDeviceGetNvlinkBwMode') global __nvmlDeviceSetNvlinkBwMode - __nvmlDeviceSetNvlinkBwMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetNvlinkBwMode') + __nvmlDeviceSetNvlinkBwMode = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceSetNvlinkBwMode') if __nvmlDeviceSetNvlinkBwMode == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceSetNvlinkBwMode = dlsym(handle, 'nvmlDeviceSetNvlinkBwMode') + __nvmlDeviceSetNvlinkBwMode = _cyb_dlsym(handle, 'nvmlDeviceSetNvlinkBwMode') global __nvmlEventSetCreate - __nvmlEventSetCreate = dlsym(RTLD_DEFAULT, 'nvmlEventSetCreate') + __nvmlEventSetCreate = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlEventSetCreate') if __nvmlEventSetCreate == NULL: if handle == NULL: handle = load_library() - __nvmlEventSetCreate = dlsym(handle, 'nvmlEventSetCreate') + __nvmlEventSetCreate = _cyb_dlsym(handle, 'nvmlEventSetCreate') global __nvmlDeviceRegisterEvents - __nvmlDeviceRegisterEvents = dlsym(RTLD_DEFAULT, 'nvmlDeviceRegisterEvents') + __nvmlDeviceRegisterEvents = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceRegisterEvents') if __nvmlDeviceRegisterEvents == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceRegisterEvents = dlsym(handle, 'nvmlDeviceRegisterEvents') + __nvmlDeviceRegisterEvents = _cyb_dlsym(handle, 'nvmlDeviceRegisterEvents') global __nvmlDeviceGetSupportedEventTypes - __nvmlDeviceGetSupportedEventTypes = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSupportedEventTypes') + __nvmlDeviceGetSupportedEventTypes = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetSupportedEventTypes') if __nvmlDeviceGetSupportedEventTypes == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetSupportedEventTypes = dlsym(handle, 'nvmlDeviceGetSupportedEventTypes') + __nvmlDeviceGetSupportedEventTypes = _cyb_dlsym(handle, 'nvmlDeviceGetSupportedEventTypes') global __nvmlEventSetWait_v2 - __nvmlEventSetWait_v2 = dlsym(RTLD_DEFAULT, 'nvmlEventSetWait_v2') + __nvmlEventSetWait_v2 = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlEventSetWait_v2') if __nvmlEventSetWait_v2 == NULL: if handle == NULL: handle = load_library() - __nvmlEventSetWait_v2 = dlsym(handle, 'nvmlEventSetWait_v2') + __nvmlEventSetWait_v2 = _cyb_dlsym(handle, 'nvmlEventSetWait_v2') global __nvmlEventSetFree - __nvmlEventSetFree = dlsym(RTLD_DEFAULT, 'nvmlEventSetFree') + __nvmlEventSetFree = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlEventSetFree') if __nvmlEventSetFree == NULL: if handle == NULL: handle = load_library() - __nvmlEventSetFree = dlsym(handle, 'nvmlEventSetFree') + __nvmlEventSetFree = _cyb_dlsym(handle, 'nvmlEventSetFree') global __nvmlSystemEventSetCreate - __nvmlSystemEventSetCreate = dlsym(RTLD_DEFAULT, 'nvmlSystemEventSetCreate') + __nvmlSystemEventSetCreate = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlSystemEventSetCreate') if __nvmlSystemEventSetCreate == NULL: if handle == NULL: handle = load_library() - __nvmlSystemEventSetCreate = dlsym(handle, 'nvmlSystemEventSetCreate') + __nvmlSystemEventSetCreate = _cyb_dlsym(handle, 'nvmlSystemEventSetCreate') global __nvmlSystemEventSetFree - __nvmlSystemEventSetFree = dlsym(RTLD_DEFAULT, 'nvmlSystemEventSetFree') + __nvmlSystemEventSetFree = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlSystemEventSetFree') if __nvmlSystemEventSetFree == NULL: if handle == NULL: handle = load_library() - __nvmlSystemEventSetFree = dlsym(handle, 'nvmlSystemEventSetFree') + __nvmlSystemEventSetFree = _cyb_dlsym(handle, 'nvmlSystemEventSetFree') global __nvmlSystemRegisterEvents - __nvmlSystemRegisterEvents = dlsym(RTLD_DEFAULT, 'nvmlSystemRegisterEvents') + __nvmlSystemRegisterEvents = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlSystemRegisterEvents') if __nvmlSystemRegisterEvents == NULL: if handle == NULL: handle = load_library() - __nvmlSystemRegisterEvents = dlsym(handle, 'nvmlSystemRegisterEvents') + __nvmlSystemRegisterEvents = _cyb_dlsym(handle, 'nvmlSystemRegisterEvents') global __nvmlSystemEventSetWait - __nvmlSystemEventSetWait = dlsym(RTLD_DEFAULT, 'nvmlSystemEventSetWait') + __nvmlSystemEventSetWait = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlSystemEventSetWait') if __nvmlSystemEventSetWait == NULL: if handle == NULL: handle = load_library() - __nvmlSystemEventSetWait = dlsym(handle, 'nvmlSystemEventSetWait') + __nvmlSystemEventSetWait = _cyb_dlsym(handle, 'nvmlSystemEventSetWait') global __nvmlDeviceModifyDrainState - __nvmlDeviceModifyDrainState = dlsym(RTLD_DEFAULT, 'nvmlDeviceModifyDrainState') + __nvmlDeviceModifyDrainState = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceModifyDrainState') if __nvmlDeviceModifyDrainState == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceModifyDrainState = dlsym(handle, 'nvmlDeviceModifyDrainState') + __nvmlDeviceModifyDrainState = _cyb_dlsym(handle, 'nvmlDeviceModifyDrainState') global __nvmlDeviceQueryDrainState - __nvmlDeviceQueryDrainState = dlsym(RTLD_DEFAULT, 'nvmlDeviceQueryDrainState') + __nvmlDeviceQueryDrainState = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceQueryDrainState') if __nvmlDeviceQueryDrainState == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceQueryDrainState = dlsym(handle, 'nvmlDeviceQueryDrainState') + __nvmlDeviceQueryDrainState = _cyb_dlsym(handle, 'nvmlDeviceQueryDrainState') global __nvmlDeviceRemoveGpu_v2 - __nvmlDeviceRemoveGpu_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceRemoveGpu_v2') + __nvmlDeviceRemoveGpu_v2 = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceRemoveGpu_v2') if __nvmlDeviceRemoveGpu_v2 == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceRemoveGpu_v2 = dlsym(handle, 'nvmlDeviceRemoveGpu_v2') + __nvmlDeviceRemoveGpu_v2 = _cyb_dlsym(handle, 'nvmlDeviceRemoveGpu_v2') global __nvmlDeviceDiscoverGpus - __nvmlDeviceDiscoverGpus = dlsym(RTLD_DEFAULT, 'nvmlDeviceDiscoverGpus') + __nvmlDeviceDiscoverGpus = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceDiscoverGpus') if __nvmlDeviceDiscoverGpus == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceDiscoverGpus = dlsym(handle, 'nvmlDeviceDiscoverGpus') + __nvmlDeviceDiscoverGpus = _cyb_dlsym(handle, 'nvmlDeviceDiscoverGpus') global __nvmlDeviceGetFieldValues - __nvmlDeviceGetFieldValues = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetFieldValues') + __nvmlDeviceGetFieldValues = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetFieldValues') if __nvmlDeviceGetFieldValues == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetFieldValues = dlsym(handle, 'nvmlDeviceGetFieldValues') + __nvmlDeviceGetFieldValues = _cyb_dlsym(handle, 'nvmlDeviceGetFieldValues') global __nvmlDeviceClearFieldValues - __nvmlDeviceClearFieldValues = dlsym(RTLD_DEFAULT, 'nvmlDeviceClearFieldValues') + __nvmlDeviceClearFieldValues = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceClearFieldValues') if __nvmlDeviceClearFieldValues == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceClearFieldValues = dlsym(handle, 'nvmlDeviceClearFieldValues') + __nvmlDeviceClearFieldValues = _cyb_dlsym(handle, 'nvmlDeviceClearFieldValues') global __nvmlDeviceGetVirtualizationMode - __nvmlDeviceGetVirtualizationMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVirtualizationMode') + __nvmlDeviceGetVirtualizationMode = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetVirtualizationMode') if __nvmlDeviceGetVirtualizationMode == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetVirtualizationMode = dlsym(handle, 'nvmlDeviceGetVirtualizationMode') + __nvmlDeviceGetVirtualizationMode = _cyb_dlsym(handle, 'nvmlDeviceGetVirtualizationMode') global __nvmlDeviceGetHostVgpuMode - __nvmlDeviceGetHostVgpuMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetHostVgpuMode') + __nvmlDeviceGetHostVgpuMode = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetHostVgpuMode') if __nvmlDeviceGetHostVgpuMode == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetHostVgpuMode = dlsym(handle, 'nvmlDeviceGetHostVgpuMode') + __nvmlDeviceGetHostVgpuMode = _cyb_dlsym(handle, 'nvmlDeviceGetHostVgpuMode') global __nvmlDeviceSetVirtualizationMode - __nvmlDeviceSetVirtualizationMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetVirtualizationMode') + __nvmlDeviceSetVirtualizationMode = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceSetVirtualizationMode') if __nvmlDeviceSetVirtualizationMode == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceSetVirtualizationMode = dlsym(handle, 'nvmlDeviceSetVirtualizationMode') + __nvmlDeviceSetVirtualizationMode = _cyb_dlsym(handle, 'nvmlDeviceSetVirtualizationMode') global __nvmlDeviceGetVgpuHeterogeneousMode - __nvmlDeviceGetVgpuHeterogeneousMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuHeterogeneousMode') + __nvmlDeviceGetVgpuHeterogeneousMode = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetVgpuHeterogeneousMode') if __nvmlDeviceGetVgpuHeterogeneousMode == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetVgpuHeterogeneousMode = dlsym(handle, 'nvmlDeviceGetVgpuHeterogeneousMode') + __nvmlDeviceGetVgpuHeterogeneousMode = _cyb_dlsym(handle, 'nvmlDeviceGetVgpuHeterogeneousMode') global __nvmlDeviceSetVgpuHeterogeneousMode - __nvmlDeviceSetVgpuHeterogeneousMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetVgpuHeterogeneousMode') + __nvmlDeviceSetVgpuHeterogeneousMode = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceSetVgpuHeterogeneousMode') if __nvmlDeviceSetVgpuHeterogeneousMode == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceSetVgpuHeterogeneousMode = dlsym(handle, 'nvmlDeviceSetVgpuHeterogeneousMode') + __nvmlDeviceSetVgpuHeterogeneousMode = _cyb_dlsym(handle, 'nvmlDeviceSetVgpuHeterogeneousMode') global __nvmlVgpuInstanceGetPlacementId - __nvmlVgpuInstanceGetPlacementId = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetPlacementId') + __nvmlVgpuInstanceGetPlacementId = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlVgpuInstanceGetPlacementId') if __nvmlVgpuInstanceGetPlacementId == NULL: if handle == NULL: handle = load_library() - __nvmlVgpuInstanceGetPlacementId = dlsym(handle, 'nvmlVgpuInstanceGetPlacementId') + __nvmlVgpuInstanceGetPlacementId = _cyb_dlsym(handle, 'nvmlVgpuInstanceGetPlacementId') global __nvmlDeviceGetVgpuTypeSupportedPlacements - __nvmlDeviceGetVgpuTypeSupportedPlacements = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuTypeSupportedPlacements') + __nvmlDeviceGetVgpuTypeSupportedPlacements = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetVgpuTypeSupportedPlacements') if __nvmlDeviceGetVgpuTypeSupportedPlacements == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetVgpuTypeSupportedPlacements = dlsym(handle, 'nvmlDeviceGetVgpuTypeSupportedPlacements') + __nvmlDeviceGetVgpuTypeSupportedPlacements = _cyb_dlsym(handle, 'nvmlDeviceGetVgpuTypeSupportedPlacements') global __nvmlDeviceGetVgpuTypeCreatablePlacements - __nvmlDeviceGetVgpuTypeCreatablePlacements = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuTypeCreatablePlacements') + __nvmlDeviceGetVgpuTypeCreatablePlacements = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetVgpuTypeCreatablePlacements') if __nvmlDeviceGetVgpuTypeCreatablePlacements == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetVgpuTypeCreatablePlacements = dlsym(handle, 'nvmlDeviceGetVgpuTypeCreatablePlacements') + __nvmlDeviceGetVgpuTypeCreatablePlacements = _cyb_dlsym(handle, 'nvmlDeviceGetVgpuTypeCreatablePlacements') global __nvmlVgpuTypeGetGspHeapSize - __nvmlVgpuTypeGetGspHeapSize = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetGspHeapSize') + __nvmlVgpuTypeGetGspHeapSize = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlVgpuTypeGetGspHeapSize') if __nvmlVgpuTypeGetGspHeapSize == NULL: if handle == NULL: handle = load_library() - __nvmlVgpuTypeGetGspHeapSize = dlsym(handle, 'nvmlVgpuTypeGetGspHeapSize') + __nvmlVgpuTypeGetGspHeapSize = _cyb_dlsym(handle, 'nvmlVgpuTypeGetGspHeapSize') global __nvmlVgpuTypeGetFbReservation - __nvmlVgpuTypeGetFbReservation = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetFbReservation') + __nvmlVgpuTypeGetFbReservation = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlVgpuTypeGetFbReservation') if __nvmlVgpuTypeGetFbReservation == NULL: if handle == NULL: handle = load_library() - __nvmlVgpuTypeGetFbReservation = dlsym(handle, 'nvmlVgpuTypeGetFbReservation') + __nvmlVgpuTypeGetFbReservation = _cyb_dlsym(handle, 'nvmlVgpuTypeGetFbReservation') global __nvmlVgpuInstanceGetRuntimeStateSize - __nvmlVgpuInstanceGetRuntimeStateSize = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetRuntimeStateSize') + __nvmlVgpuInstanceGetRuntimeStateSize = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlVgpuInstanceGetRuntimeStateSize') if __nvmlVgpuInstanceGetRuntimeStateSize == NULL: if handle == NULL: handle = load_library() - __nvmlVgpuInstanceGetRuntimeStateSize = dlsym(handle, 'nvmlVgpuInstanceGetRuntimeStateSize') + __nvmlVgpuInstanceGetRuntimeStateSize = _cyb_dlsym(handle, 'nvmlVgpuInstanceGetRuntimeStateSize') global __nvmlDeviceSetVgpuCapabilities - __nvmlDeviceSetVgpuCapabilities = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetVgpuCapabilities') + __nvmlDeviceSetVgpuCapabilities = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceSetVgpuCapabilities') if __nvmlDeviceSetVgpuCapabilities == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceSetVgpuCapabilities = dlsym(handle, 'nvmlDeviceSetVgpuCapabilities') + __nvmlDeviceSetVgpuCapabilities = _cyb_dlsym(handle, 'nvmlDeviceSetVgpuCapabilities') global __nvmlDeviceGetGridLicensableFeatures_v4 - __nvmlDeviceGetGridLicensableFeatures_v4 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGridLicensableFeatures_v4') + __nvmlDeviceGetGridLicensableFeatures_v4 = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetGridLicensableFeatures_v4') if __nvmlDeviceGetGridLicensableFeatures_v4 == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetGridLicensableFeatures_v4 = dlsym(handle, 'nvmlDeviceGetGridLicensableFeatures_v4') + __nvmlDeviceGetGridLicensableFeatures_v4 = _cyb_dlsym(handle, 'nvmlDeviceGetGridLicensableFeatures_v4') global __nvmlGetVgpuDriverCapabilities - __nvmlGetVgpuDriverCapabilities = dlsym(RTLD_DEFAULT, 'nvmlGetVgpuDriverCapabilities') + __nvmlGetVgpuDriverCapabilities = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlGetVgpuDriverCapabilities') if __nvmlGetVgpuDriverCapabilities == NULL: if handle == NULL: handle = load_library() - __nvmlGetVgpuDriverCapabilities = dlsym(handle, 'nvmlGetVgpuDriverCapabilities') + __nvmlGetVgpuDriverCapabilities = _cyb_dlsym(handle, 'nvmlGetVgpuDriverCapabilities') global __nvmlDeviceGetVgpuCapabilities - __nvmlDeviceGetVgpuCapabilities = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuCapabilities') + __nvmlDeviceGetVgpuCapabilities = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetVgpuCapabilities') if __nvmlDeviceGetVgpuCapabilities == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetVgpuCapabilities = dlsym(handle, 'nvmlDeviceGetVgpuCapabilities') + __nvmlDeviceGetVgpuCapabilities = _cyb_dlsym(handle, 'nvmlDeviceGetVgpuCapabilities') global __nvmlDeviceGetSupportedVgpus - __nvmlDeviceGetSupportedVgpus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSupportedVgpus') + __nvmlDeviceGetSupportedVgpus = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetSupportedVgpus') if __nvmlDeviceGetSupportedVgpus == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetSupportedVgpus = dlsym(handle, 'nvmlDeviceGetSupportedVgpus') + __nvmlDeviceGetSupportedVgpus = _cyb_dlsym(handle, 'nvmlDeviceGetSupportedVgpus') global __nvmlDeviceGetCreatableVgpus - __nvmlDeviceGetCreatableVgpus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCreatableVgpus') + __nvmlDeviceGetCreatableVgpus = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetCreatableVgpus') if __nvmlDeviceGetCreatableVgpus == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetCreatableVgpus = dlsym(handle, 'nvmlDeviceGetCreatableVgpus') + __nvmlDeviceGetCreatableVgpus = _cyb_dlsym(handle, 'nvmlDeviceGetCreatableVgpus') global __nvmlVgpuTypeGetClass - __nvmlVgpuTypeGetClass = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetClass') + __nvmlVgpuTypeGetClass = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlVgpuTypeGetClass') if __nvmlVgpuTypeGetClass == NULL: if handle == NULL: handle = load_library() - __nvmlVgpuTypeGetClass = dlsym(handle, 'nvmlVgpuTypeGetClass') + __nvmlVgpuTypeGetClass = _cyb_dlsym(handle, 'nvmlVgpuTypeGetClass') global __nvmlVgpuTypeGetName - __nvmlVgpuTypeGetName = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetName') + __nvmlVgpuTypeGetName = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlVgpuTypeGetName') if __nvmlVgpuTypeGetName == NULL: if handle == NULL: handle = load_library() - __nvmlVgpuTypeGetName = dlsym(handle, 'nvmlVgpuTypeGetName') + __nvmlVgpuTypeGetName = _cyb_dlsym(handle, 'nvmlVgpuTypeGetName') global __nvmlVgpuTypeGetGpuInstanceProfileId - __nvmlVgpuTypeGetGpuInstanceProfileId = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetGpuInstanceProfileId') + __nvmlVgpuTypeGetGpuInstanceProfileId = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlVgpuTypeGetGpuInstanceProfileId') if __nvmlVgpuTypeGetGpuInstanceProfileId == NULL: if handle == NULL: handle = load_library() - __nvmlVgpuTypeGetGpuInstanceProfileId = dlsym(handle, 'nvmlVgpuTypeGetGpuInstanceProfileId') + __nvmlVgpuTypeGetGpuInstanceProfileId = _cyb_dlsym(handle, 'nvmlVgpuTypeGetGpuInstanceProfileId') global __nvmlVgpuTypeGetDeviceID - __nvmlVgpuTypeGetDeviceID = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetDeviceID') + __nvmlVgpuTypeGetDeviceID = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlVgpuTypeGetDeviceID') if __nvmlVgpuTypeGetDeviceID == NULL: if handle == NULL: handle = load_library() - __nvmlVgpuTypeGetDeviceID = dlsym(handle, 'nvmlVgpuTypeGetDeviceID') + __nvmlVgpuTypeGetDeviceID = _cyb_dlsym(handle, 'nvmlVgpuTypeGetDeviceID') global __nvmlVgpuTypeGetFramebufferSize - __nvmlVgpuTypeGetFramebufferSize = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetFramebufferSize') + __nvmlVgpuTypeGetFramebufferSize = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlVgpuTypeGetFramebufferSize') if __nvmlVgpuTypeGetFramebufferSize == NULL: if handle == NULL: handle = load_library() - __nvmlVgpuTypeGetFramebufferSize = dlsym(handle, 'nvmlVgpuTypeGetFramebufferSize') + __nvmlVgpuTypeGetFramebufferSize = _cyb_dlsym(handle, 'nvmlVgpuTypeGetFramebufferSize') global __nvmlVgpuTypeGetNumDisplayHeads - __nvmlVgpuTypeGetNumDisplayHeads = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetNumDisplayHeads') + __nvmlVgpuTypeGetNumDisplayHeads = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlVgpuTypeGetNumDisplayHeads') if __nvmlVgpuTypeGetNumDisplayHeads == NULL: if handle == NULL: handle = load_library() - __nvmlVgpuTypeGetNumDisplayHeads = dlsym(handle, 'nvmlVgpuTypeGetNumDisplayHeads') + __nvmlVgpuTypeGetNumDisplayHeads = _cyb_dlsym(handle, 'nvmlVgpuTypeGetNumDisplayHeads') global __nvmlVgpuTypeGetResolution - __nvmlVgpuTypeGetResolution = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetResolution') + __nvmlVgpuTypeGetResolution = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlVgpuTypeGetResolution') if __nvmlVgpuTypeGetResolution == NULL: if handle == NULL: handle = load_library() - __nvmlVgpuTypeGetResolution = dlsym(handle, 'nvmlVgpuTypeGetResolution') + __nvmlVgpuTypeGetResolution = _cyb_dlsym(handle, 'nvmlVgpuTypeGetResolution') global __nvmlVgpuTypeGetLicense - __nvmlVgpuTypeGetLicense = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetLicense') + __nvmlVgpuTypeGetLicense = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlVgpuTypeGetLicense') if __nvmlVgpuTypeGetLicense == NULL: if handle == NULL: handle = load_library() - __nvmlVgpuTypeGetLicense = dlsym(handle, 'nvmlVgpuTypeGetLicense') + __nvmlVgpuTypeGetLicense = _cyb_dlsym(handle, 'nvmlVgpuTypeGetLicense') global __nvmlVgpuTypeGetFrameRateLimit - __nvmlVgpuTypeGetFrameRateLimit = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetFrameRateLimit') + __nvmlVgpuTypeGetFrameRateLimit = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlVgpuTypeGetFrameRateLimit') if __nvmlVgpuTypeGetFrameRateLimit == NULL: if handle == NULL: handle = load_library() - __nvmlVgpuTypeGetFrameRateLimit = dlsym(handle, 'nvmlVgpuTypeGetFrameRateLimit') + __nvmlVgpuTypeGetFrameRateLimit = _cyb_dlsym(handle, 'nvmlVgpuTypeGetFrameRateLimit') global __nvmlVgpuTypeGetMaxInstances - __nvmlVgpuTypeGetMaxInstances = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetMaxInstances') + __nvmlVgpuTypeGetMaxInstances = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlVgpuTypeGetMaxInstances') if __nvmlVgpuTypeGetMaxInstances == NULL: if handle == NULL: handle = load_library() - __nvmlVgpuTypeGetMaxInstances = dlsym(handle, 'nvmlVgpuTypeGetMaxInstances') + __nvmlVgpuTypeGetMaxInstances = _cyb_dlsym(handle, 'nvmlVgpuTypeGetMaxInstances') global __nvmlVgpuTypeGetMaxInstancesPerVm - __nvmlVgpuTypeGetMaxInstancesPerVm = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetMaxInstancesPerVm') + __nvmlVgpuTypeGetMaxInstancesPerVm = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlVgpuTypeGetMaxInstancesPerVm') if __nvmlVgpuTypeGetMaxInstancesPerVm == NULL: if handle == NULL: handle = load_library() - __nvmlVgpuTypeGetMaxInstancesPerVm = dlsym(handle, 'nvmlVgpuTypeGetMaxInstancesPerVm') + __nvmlVgpuTypeGetMaxInstancesPerVm = _cyb_dlsym(handle, 'nvmlVgpuTypeGetMaxInstancesPerVm') global __nvmlVgpuTypeGetBAR1Info - __nvmlVgpuTypeGetBAR1Info = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetBAR1Info') + __nvmlVgpuTypeGetBAR1Info = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlVgpuTypeGetBAR1Info') if __nvmlVgpuTypeGetBAR1Info == NULL: if handle == NULL: handle = load_library() - __nvmlVgpuTypeGetBAR1Info = dlsym(handle, 'nvmlVgpuTypeGetBAR1Info') + __nvmlVgpuTypeGetBAR1Info = _cyb_dlsym(handle, 'nvmlVgpuTypeGetBAR1Info') global __nvmlDeviceGetActiveVgpus - __nvmlDeviceGetActiveVgpus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetActiveVgpus') + __nvmlDeviceGetActiveVgpus = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetActiveVgpus') if __nvmlDeviceGetActiveVgpus == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetActiveVgpus = dlsym(handle, 'nvmlDeviceGetActiveVgpus') + __nvmlDeviceGetActiveVgpus = _cyb_dlsym(handle, 'nvmlDeviceGetActiveVgpus') global __nvmlVgpuInstanceGetVmID - __nvmlVgpuInstanceGetVmID = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetVmID') + __nvmlVgpuInstanceGetVmID = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlVgpuInstanceGetVmID') if __nvmlVgpuInstanceGetVmID == NULL: if handle == NULL: handle = load_library() - __nvmlVgpuInstanceGetVmID = dlsym(handle, 'nvmlVgpuInstanceGetVmID') + __nvmlVgpuInstanceGetVmID = _cyb_dlsym(handle, 'nvmlVgpuInstanceGetVmID') global __nvmlVgpuInstanceGetUUID - __nvmlVgpuInstanceGetUUID = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetUUID') + __nvmlVgpuInstanceGetUUID = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlVgpuInstanceGetUUID') if __nvmlVgpuInstanceGetUUID == NULL: if handle == NULL: handle = load_library() - __nvmlVgpuInstanceGetUUID = dlsym(handle, 'nvmlVgpuInstanceGetUUID') + __nvmlVgpuInstanceGetUUID = _cyb_dlsym(handle, 'nvmlVgpuInstanceGetUUID') global __nvmlVgpuInstanceGetVmDriverVersion - __nvmlVgpuInstanceGetVmDriverVersion = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetVmDriverVersion') + __nvmlVgpuInstanceGetVmDriverVersion = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlVgpuInstanceGetVmDriverVersion') if __nvmlVgpuInstanceGetVmDriverVersion == NULL: if handle == NULL: handle = load_library() - __nvmlVgpuInstanceGetVmDriverVersion = dlsym(handle, 'nvmlVgpuInstanceGetVmDriverVersion') + __nvmlVgpuInstanceGetVmDriverVersion = _cyb_dlsym(handle, 'nvmlVgpuInstanceGetVmDriverVersion') global __nvmlVgpuInstanceGetFbUsage - __nvmlVgpuInstanceGetFbUsage = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetFbUsage') + __nvmlVgpuInstanceGetFbUsage = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlVgpuInstanceGetFbUsage') if __nvmlVgpuInstanceGetFbUsage == NULL: if handle == NULL: handle = load_library() - __nvmlVgpuInstanceGetFbUsage = dlsym(handle, 'nvmlVgpuInstanceGetFbUsage') + __nvmlVgpuInstanceGetFbUsage = _cyb_dlsym(handle, 'nvmlVgpuInstanceGetFbUsage') global __nvmlVgpuInstanceGetLicenseStatus - __nvmlVgpuInstanceGetLicenseStatus = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetLicenseStatus') + __nvmlVgpuInstanceGetLicenseStatus = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlVgpuInstanceGetLicenseStatus') if __nvmlVgpuInstanceGetLicenseStatus == NULL: if handle == NULL: handle = load_library() - __nvmlVgpuInstanceGetLicenseStatus = dlsym(handle, 'nvmlVgpuInstanceGetLicenseStatus') + __nvmlVgpuInstanceGetLicenseStatus = _cyb_dlsym(handle, 'nvmlVgpuInstanceGetLicenseStatus') global __nvmlVgpuInstanceGetType - __nvmlVgpuInstanceGetType = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetType') + __nvmlVgpuInstanceGetType = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlVgpuInstanceGetType') if __nvmlVgpuInstanceGetType == NULL: if handle == NULL: handle = load_library() - __nvmlVgpuInstanceGetType = dlsym(handle, 'nvmlVgpuInstanceGetType') + __nvmlVgpuInstanceGetType = _cyb_dlsym(handle, 'nvmlVgpuInstanceGetType') global __nvmlVgpuInstanceGetFrameRateLimit - __nvmlVgpuInstanceGetFrameRateLimit = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetFrameRateLimit') + __nvmlVgpuInstanceGetFrameRateLimit = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlVgpuInstanceGetFrameRateLimit') if __nvmlVgpuInstanceGetFrameRateLimit == NULL: if handle == NULL: handle = load_library() - __nvmlVgpuInstanceGetFrameRateLimit = dlsym(handle, 'nvmlVgpuInstanceGetFrameRateLimit') + __nvmlVgpuInstanceGetFrameRateLimit = _cyb_dlsym(handle, 'nvmlVgpuInstanceGetFrameRateLimit') global __nvmlVgpuInstanceGetEccMode - __nvmlVgpuInstanceGetEccMode = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetEccMode') + __nvmlVgpuInstanceGetEccMode = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlVgpuInstanceGetEccMode') if __nvmlVgpuInstanceGetEccMode == NULL: if handle == NULL: handle = load_library() - __nvmlVgpuInstanceGetEccMode = dlsym(handle, 'nvmlVgpuInstanceGetEccMode') + __nvmlVgpuInstanceGetEccMode = _cyb_dlsym(handle, 'nvmlVgpuInstanceGetEccMode') global __nvmlVgpuInstanceGetEncoderCapacity - __nvmlVgpuInstanceGetEncoderCapacity = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetEncoderCapacity') + __nvmlVgpuInstanceGetEncoderCapacity = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlVgpuInstanceGetEncoderCapacity') if __nvmlVgpuInstanceGetEncoderCapacity == NULL: if handle == NULL: handle = load_library() - __nvmlVgpuInstanceGetEncoderCapacity = dlsym(handle, 'nvmlVgpuInstanceGetEncoderCapacity') + __nvmlVgpuInstanceGetEncoderCapacity = _cyb_dlsym(handle, 'nvmlVgpuInstanceGetEncoderCapacity') global __nvmlVgpuInstanceSetEncoderCapacity - __nvmlVgpuInstanceSetEncoderCapacity = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceSetEncoderCapacity') + __nvmlVgpuInstanceSetEncoderCapacity = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlVgpuInstanceSetEncoderCapacity') if __nvmlVgpuInstanceSetEncoderCapacity == NULL: if handle == NULL: handle = load_library() - __nvmlVgpuInstanceSetEncoderCapacity = dlsym(handle, 'nvmlVgpuInstanceSetEncoderCapacity') + __nvmlVgpuInstanceSetEncoderCapacity = _cyb_dlsym(handle, 'nvmlVgpuInstanceSetEncoderCapacity') global __nvmlVgpuInstanceGetEncoderStats - __nvmlVgpuInstanceGetEncoderStats = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetEncoderStats') + __nvmlVgpuInstanceGetEncoderStats = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlVgpuInstanceGetEncoderStats') if __nvmlVgpuInstanceGetEncoderStats == NULL: if handle == NULL: handle = load_library() - __nvmlVgpuInstanceGetEncoderStats = dlsym(handle, 'nvmlVgpuInstanceGetEncoderStats') + __nvmlVgpuInstanceGetEncoderStats = _cyb_dlsym(handle, 'nvmlVgpuInstanceGetEncoderStats') global __nvmlVgpuInstanceGetEncoderSessions - __nvmlVgpuInstanceGetEncoderSessions = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetEncoderSessions') + __nvmlVgpuInstanceGetEncoderSessions = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlVgpuInstanceGetEncoderSessions') if __nvmlVgpuInstanceGetEncoderSessions == NULL: if handle == NULL: handle = load_library() - __nvmlVgpuInstanceGetEncoderSessions = dlsym(handle, 'nvmlVgpuInstanceGetEncoderSessions') + __nvmlVgpuInstanceGetEncoderSessions = _cyb_dlsym(handle, 'nvmlVgpuInstanceGetEncoderSessions') global __nvmlVgpuInstanceGetFBCStats - __nvmlVgpuInstanceGetFBCStats = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetFBCStats') + __nvmlVgpuInstanceGetFBCStats = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlVgpuInstanceGetFBCStats') if __nvmlVgpuInstanceGetFBCStats == NULL: if handle == NULL: handle = load_library() - __nvmlVgpuInstanceGetFBCStats = dlsym(handle, 'nvmlVgpuInstanceGetFBCStats') + __nvmlVgpuInstanceGetFBCStats = _cyb_dlsym(handle, 'nvmlVgpuInstanceGetFBCStats') global __nvmlVgpuInstanceGetFBCSessions - __nvmlVgpuInstanceGetFBCSessions = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetFBCSessions') + __nvmlVgpuInstanceGetFBCSessions = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlVgpuInstanceGetFBCSessions') if __nvmlVgpuInstanceGetFBCSessions == NULL: if handle == NULL: handle = load_library() - __nvmlVgpuInstanceGetFBCSessions = dlsym(handle, 'nvmlVgpuInstanceGetFBCSessions') + __nvmlVgpuInstanceGetFBCSessions = _cyb_dlsym(handle, 'nvmlVgpuInstanceGetFBCSessions') global __nvmlVgpuInstanceGetGpuInstanceId - __nvmlVgpuInstanceGetGpuInstanceId = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetGpuInstanceId') + __nvmlVgpuInstanceGetGpuInstanceId = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlVgpuInstanceGetGpuInstanceId') if __nvmlVgpuInstanceGetGpuInstanceId == NULL: if handle == NULL: handle = load_library() - __nvmlVgpuInstanceGetGpuInstanceId = dlsym(handle, 'nvmlVgpuInstanceGetGpuInstanceId') + __nvmlVgpuInstanceGetGpuInstanceId = _cyb_dlsym(handle, 'nvmlVgpuInstanceGetGpuInstanceId') global __nvmlVgpuInstanceGetGpuPciId - __nvmlVgpuInstanceGetGpuPciId = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetGpuPciId') + __nvmlVgpuInstanceGetGpuPciId = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlVgpuInstanceGetGpuPciId') if __nvmlVgpuInstanceGetGpuPciId == NULL: if handle == NULL: handle = load_library() - __nvmlVgpuInstanceGetGpuPciId = dlsym(handle, 'nvmlVgpuInstanceGetGpuPciId') + __nvmlVgpuInstanceGetGpuPciId = _cyb_dlsym(handle, 'nvmlVgpuInstanceGetGpuPciId') global __nvmlVgpuTypeGetCapabilities - __nvmlVgpuTypeGetCapabilities = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetCapabilities') + __nvmlVgpuTypeGetCapabilities = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlVgpuTypeGetCapabilities') if __nvmlVgpuTypeGetCapabilities == NULL: if handle == NULL: handle = load_library() - __nvmlVgpuTypeGetCapabilities = dlsym(handle, 'nvmlVgpuTypeGetCapabilities') + __nvmlVgpuTypeGetCapabilities = _cyb_dlsym(handle, 'nvmlVgpuTypeGetCapabilities') global __nvmlVgpuInstanceGetMdevUUID - __nvmlVgpuInstanceGetMdevUUID = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetMdevUUID') + __nvmlVgpuInstanceGetMdevUUID = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlVgpuInstanceGetMdevUUID') if __nvmlVgpuInstanceGetMdevUUID == NULL: if handle == NULL: handle = load_library() - __nvmlVgpuInstanceGetMdevUUID = dlsym(handle, 'nvmlVgpuInstanceGetMdevUUID') + __nvmlVgpuInstanceGetMdevUUID = _cyb_dlsym(handle, 'nvmlVgpuInstanceGetMdevUUID') global __nvmlGpuInstanceGetCreatableVgpus - __nvmlGpuInstanceGetCreatableVgpus = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetCreatableVgpus') + __nvmlGpuInstanceGetCreatableVgpus = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlGpuInstanceGetCreatableVgpus') if __nvmlGpuInstanceGetCreatableVgpus == NULL: if handle == NULL: handle = load_library() - __nvmlGpuInstanceGetCreatableVgpus = dlsym(handle, 'nvmlGpuInstanceGetCreatableVgpus') + __nvmlGpuInstanceGetCreatableVgpus = _cyb_dlsym(handle, 'nvmlGpuInstanceGetCreatableVgpus') global __nvmlVgpuTypeGetMaxInstancesPerGpuInstance - __nvmlVgpuTypeGetMaxInstancesPerGpuInstance = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetMaxInstancesPerGpuInstance') + __nvmlVgpuTypeGetMaxInstancesPerGpuInstance = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlVgpuTypeGetMaxInstancesPerGpuInstance') if __nvmlVgpuTypeGetMaxInstancesPerGpuInstance == NULL: if handle == NULL: handle = load_library() - __nvmlVgpuTypeGetMaxInstancesPerGpuInstance = dlsym(handle, 'nvmlVgpuTypeGetMaxInstancesPerGpuInstance') + __nvmlVgpuTypeGetMaxInstancesPerGpuInstance = _cyb_dlsym(handle, 'nvmlVgpuTypeGetMaxInstancesPerGpuInstance') global __nvmlGpuInstanceGetActiveVgpus - __nvmlGpuInstanceGetActiveVgpus = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetActiveVgpus') + __nvmlGpuInstanceGetActiveVgpus = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlGpuInstanceGetActiveVgpus') if __nvmlGpuInstanceGetActiveVgpus == NULL: if handle == NULL: handle = load_library() - __nvmlGpuInstanceGetActiveVgpus = dlsym(handle, 'nvmlGpuInstanceGetActiveVgpus') + __nvmlGpuInstanceGetActiveVgpus = _cyb_dlsym(handle, 'nvmlGpuInstanceGetActiveVgpus') global __nvmlGpuInstanceSetVgpuSchedulerState - __nvmlGpuInstanceSetVgpuSchedulerState = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceSetVgpuSchedulerState') + __nvmlGpuInstanceSetVgpuSchedulerState = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlGpuInstanceSetVgpuSchedulerState') if __nvmlGpuInstanceSetVgpuSchedulerState == NULL: if handle == NULL: handle = load_library() - __nvmlGpuInstanceSetVgpuSchedulerState = dlsym(handle, 'nvmlGpuInstanceSetVgpuSchedulerState') + __nvmlGpuInstanceSetVgpuSchedulerState = _cyb_dlsym(handle, 'nvmlGpuInstanceSetVgpuSchedulerState') global __nvmlGpuInstanceGetVgpuSchedulerState - __nvmlGpuInstanceGetVgpuSchedulerState = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetVgpuSchedulerState') + __nvmlGpuInstanceGetVgpuSchedulerState = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlGpuInstanceGetVgpuSchedulerState') if __nvmlGpuInstanceGetVgpuSchedulerState == NULL: if handle == NULL: handle = load_library() - __nvmlGpuInstanceGetVgpuSchedulerState = dlsym(handle, 'nvmlGpuInstanceGetVgpuSchedulerState') + __nvmlGpuInstanceGetVgpuSchedulerState = _cyb_dlsym(handle, 'nvmlGpuInstanceGetVgpuSchedulerState') global __nvmlGpuInstanceGetVgpuSchedulerLog - __nvmlGpuInstanceGetVgpuSchedulerLog = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetVgpuSchedulerLog') + __nvmlGpuInstanceGetVgpuSchedulerLog = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlGpuInstanceGetVgpuSchedulerLog') if __nvmlGpuInstanceGetVgpuSchedulerLog == NULL: if handle == NULL: handle = load_library() - __nvmlGpuInstanceGetVgpuSchedulerLog = dlsym(handle, 'nvmlGpuInstanceGetVgpuSchedulerLog') + __nvmlGpuInstanceGetVgpuSchedulerLog = _cyb_dlsym(handle, 'nvmlGpuInstanceGetVgpuSchedulerLog') global __nvmlGpuInstanceGetVgpuTypeCreatablePlacements - __nvmlGpuInstanceGetVgpuTypeCreatablePlacements = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetVgpuTypeCreatablePlacements') + __nvmlGpuInstanceGetVgpuTypeCreatablePlacements = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlGpuInstanceGetVgpuTypeCreatablePlacements') if __nvmlGpuInstanceGetVgpuTypeCreatablePlacements == NULL: if handle == NULL: handle = load_library() - __nvmlGpuInstanceGetVgpuTypeCreatablePlacements = dlsym(handle, 'nvmlGpuInstanceGetVgpuTypeCreatablePlacements') + __nvmlGpuInstanceGetVgpuTypeCreatablePlacements = _cyb_dlsym(handle, 'nvmlGpuInstanceGetVgpuTypeCreatablePlacements') global __nvmlGpuInstanceGetVgpuHeterogeneousMode - __nvmlGpuInstanceGetVgpuHeterogeneousMode = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetVgpuHeterogeneousMode') + __nvmlGpuInstanceGetVgpuHeterogeneousMode = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlGpuInstanceGetVgpuHeterogeneousMode') if __nvmlGpuInstanceGetVgpuHeterogeneousMode == NULL: if handle == NULL: handle = load_library() - __nvmlGpuInstanceGetVgpuHeterogeneousMode = dlsym(handle, 'nvmlGpuInstanceGetVgpuHeterogeneousMode') + __nvmlGpuInstanceGetVgpuHeterogeneousMode = _cyb_dlsym(handle, 'nvmlGpuInstanceGetVgpuHeterogeneousMode') global __nvmlGpuInstanceSetVgpuHeterogeneousMode - __nvmlGpuInstanceSetVgpuHeterogeneousMode = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceSetVgpuHeterogeneousMode') + __nvmlGpuInstanceSetVgpuHeterogeneousMode = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlGpuInstanceSetVgpuHeterogeneousMode') if __nvmlGpuInstanceSetVgpuHeterogeneousMode == NULL: if handle == NULL: handle = load_library() - __nvmlGpuInstanceSetVgpuHeterogeneousMode = dlsym(handle, 'nvmlGpuInstanceSetVgpuHeterogeneousMode') + __nvmlGpuInstanceSetVgpuHeterogeneousMode = _cyb_dlsym(handle, 'nvmlGpuInstanceSetVgpuHeterogeneousMode') global __nvmlVgpuInstanceGetMetadata - __nvmlVgpuInstanceGetMetadata = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetMetadata') + __nvmlVgpuInstanceGetMetadata = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlVgpuInstanceGetMetadata') if __nvmlVgpuInstanceGetMetadata == NULL: if handle == NULL: handle = load_library() - __nvmlVgpuInstanceGetMetadata = dlsym(handle, 'nvmlVgpuInstanceGetMetadata') + __nvmlVgpuInstanceGetMetadata = _cyb_dlsym(handle, 'nvmlVgpuInstanceGetMetadata') global __nvmlDeviceGetVgpuMetadata - __nvmlDeviceGetVgpuMetadata = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuMetadata') + __nvmlDeviceGetVgpuMetadata = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetVgpuMetadata') if __nvmlDeviceGetVgpuMetadata == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetVgpuMetadata = dlsym(handle, 'nvmlDeviceGetVgpuMetadata') + __nvmlDeviceGetVgpuMetadata = _cyb_dlsym(handle, 'nvmlDeviceGetVgpuMetadata') global __nvmlGetVgpuCompatibility - __nvmlGetVgpuCompatibility = dlsym(RTLD_DEFAULT, 'nvmlGetVgpuCompatibility') + __nvmlGetVgpuCompatibility = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlGetVgpuCompatibility') if __nvmlGetVgpuCompatibility == NULL: if handle == NULL: handle = load_library() - __nvmlGetVgpuCompatibility = dlsym(handle, 'nvmlGetVgpuCompatibility') + __nvmlGetVgpuCompatibility = _cyb_dlsym(handle, 'nvmlGetVgpuCompatibility') global __nvmlDeviceGetPgpuMetadataString - __nvmlDeviceGetPgpuMetadataString = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPgpuMetadataString') + __nvmlDeviceGetPgpuMetadataString = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetPgpuMetadataString') if __nvmlDeviceGetPgpuMetadataString == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetPgpuMetadataString = dlsym(handle, 'nvmlDeviceGetPgpuMetadataString') + __nvmlDeviceGetPgpuMetadataString = _cyb_dlsym(handle, 'nvmlDeviceGetPgpuMetadataString') global __nvmlDeviceGetVgpuSchedulerLog - __nvmlDeviceGetVgpuSchedulerLog = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuSchedulerLog') + __nvmlDeviceGetVgpuSchedulerLog = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetVgpuSchedulerLog') if __nvmlDeviceGetVgpuSchedulerLog == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetVgpuSchedulerLog = dlsym(handle, 'nvmlDeviceGetVgpuSchedulerLog') + __nvmlDeviceGetVgpuSchedulerLog = _cyb_dlsym(handle, 'nvmlDeviceGetVgpuSchedulerLog') global __nvmlDeviceGetVgpuSchedulerState - __nvmlDeviceGetVgpuSchedulerState = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuSchedulerState') + __nvmlDeviceGetVgpuSchedulerState = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetVgpuSchedulerState') if __nvmlDeviceGetVgpuSchedulerState == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetVgpuSchedulerState = dlsym(handle, 'nvmlDeviceGetVgpuSchedulerState') + __nvmlDeviceGetVgpuSchedulerState = _cyb_dlsym(handle, 'nvmlDeviceGetVgpuSchedulerState') global __nvmlDeviceGetVgpuSchedulerCapabilities - __nvmlDeviceGetVgpuSchedulerCapabilities = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuSchedulerCapabilities') + __nvmlDeviceGetVgpuSchedulerCapabilities = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetVgpuSchedulerCapabilities') if __nvmlDeviceGetVgpuSchedulerCapabilities == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetVgpuSchedulerCapabilities = dlsym(handle, 'nvmlDeviceGetVgpuSchedulerCapabilities') + __nvmlDeviceGetVgpuSchedulerCapabilities = _cyb_dlsym(handle, 'nvmlDeviceGetVgpuSchedulerCapabilities') global __nvmlDeviceSetVgpuSchedulerState - __nvmlDeviceSetVgpuSchedulerState = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetVgpuSchedulerState') + __nvmlDeviceSetVgpuSchedulerState = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceSetVgpuSchedulerState') if __nvmlDeviceSetVgpuSchedulerState == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceSetVgpuSchedulerState = dlsym(handle, 'nvmlDeviceSetVgpuSchedulerState') + __nvmlDeviceSetVgpuSchedulerState = _cyb_dlsym(handle, 'nvmlDeviceSetVgpuSchedulerState') global __nvmlGetVgpuVersion - __nvmlGetVgpuVersion = dlsym(RTLD_DEFAULT, 'nvmlGetVgpuVersion') + __nvmlGetVgpuVersion = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlGetVgpuVersion') if __nvmlGetVgpuVersion == NULL: if handle == NULL: handle = load_library() - __nvmlGetVgpuVersion = dlsym(handle, 'nvmlGetVgpuVersion') + __nvmlGetVgpuVersion = _cyb_dlsym(handle, 'nvmlGetVgpuVersion') global __nvmlSetVgpuVersion - __nvmlSetVgpuVersion = dlsym(RTLD_DEFAULT, 'nvmlSetVgpuVersion') + __nvmlSetVgpuVersion = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlSetVgpuVersion') if __nvmlSetVgpuVersion == NULL: if handle == NULL: handle = load_library() - __nvmlSetVgpuVersion = dlsym(handle, 'nvmlSetVgpuVersion') + __nvmlSetVgpuVersion = _cyb_dlsym(handle, 'nvmlSetVgpuVersion') global __nvmlDeviceGetVgpuUtilization - __nvmlDeviceGetVgpuUtilization = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuUtilization') + __nvmlDeviceGetVgpuUtilization = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetVgpuUtilization') if __nvmlDeviceGetVgpuUtilization == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetVgpuUtilization = dlsym(handle, 'nvmlDeviceGetVgpuUtilization') + __nvmlDeviceGetVgpuUtilization = _cyb_dlsym(handle, 'nvmlDeviceGetVgpuUtilization') global __nvmlDeviceGetVgpuInstancesUtilizationInfo - __nvmlDeviceGetVgpuInstancesUtilizationInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuInstancesUtilizationInfo') + __nvmlDeviceGetVgpuInstancesUtilizationInfo = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetVgpuInstancesUtilizationInfo') if __nvmlDeviceGetVgpuInstancesUtilizationInfo == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetVgpuInstancesUtilizationInfo = dlsym(handle, 'nvmlDeviceGetVgpuInstancesUtilizationInfo') + __nvmlDeviceGetVgpuInstancesUtilizationInfo = _cyb_dlsym(handle, 'nvmlDeviceGetVgpuInstancesUtilizationInfo') global __nvmlDeviceGetVgpuProcessUtilization - __nvmlDeviceGetVgpuProcessUtilization = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuProcessUtilization') + __nvmlDeviceGetVgpuProcessUtilization = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetVgpuProcessUtilization') if __nvmlDeviceGetVgpuProcessUtilization == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetVgpuProcessUtilization = dlsym(handle, 'nvmlDeviceGetVgpuProcessUtilization') + __nvmlDeviceGetVgpuProcessUtilization = _cyb_dlsym(handle, 'nvmlDeviceGetVgpuProcessUtilization') global __nvmlDeviceGetVgpuProcessesUtilizationInfo - __nvmlDeviceGetVgpuProcessesUtilizationInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuProcessesUtilizationInfo') + __nvmlDeviceGetVgpuProcessesUtilizationInfo = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetVgpuProcessesUtilizationInfo') if __nvmlDeviceGetVgpuProcessesUtilizationInfo == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetVgpuProcessesUtilizationInfo = dlsym(handle, 'nvmlDeviceGetVgpuProcessesUtilizationInfo') + __nvmlDeviceGetVgpuProcessesUtilizationInfo = _cyb_dlsym(handle, 'nvmlDeviceGetVgpuProcessesUtilizationInfo') global __nvmlVgpuInstanceGetAccountingMode - __nvmlVgpuInstanceGetAccountingMode = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetAccountingMode') + __nvmlVgpuInstanceGetAccountingMode = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlVgpuInstanceGetAccountingMode') if __nvmlVgpuInstanceGetAccountingMode == NULL: if handle == NULL: handle = load_library() - __nvmlVgpuInstanceGetAccountingMode = dlsym(handle, 'nvmlVgpuInstanceGetAccountingMode') + __nvmlVgpuInstanceGetAccountingMode = _cyb_dlsym(handle, 'nvmlVgpuInstanceGetAccountingMode') global __nvmlVgpuInstanceGetAccountingPids - __nvmlVgpuInstanceGetAccountingPids = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetAccountingPids') + __nvmlVgpuInstanceGetAccountingPids = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlVgpuInstanceGetAccountingPids') if __nvmlVgpuInstanceGetAccountingPids == NULL: if handle == NULL: handle = load_library() - __nvmlVgpuInstanceGetAccountingPids = dlsym(handle, 'nvmlVgpuInstanceGetAccountingPids') + __nvmlVgpuInstanceGetAccountingPids = _cyb_dlsym(handle, 'nvmlVgpuInstanceGetAccountingPids') global __nvmlVgpuInstanceGetAccountingStats - __nvmlVgpuInstanceGetAccountingStats = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetAccountingStats') + __nvmlVgpuInstanceGetAccountingStats = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlVgpuInstanceGetAccountingStats') if __nvmlVgpuInstanceGetAccountingStats == NULL: if handle == NULL: handle = load_library() - __nvmlVgpuInstanceGetAccountingStats = dlsym(handle, 'nvmlVgpuInstanceGetAccountingStats') + __nvmlVgpuInstanceGetAccountingStats = _cyb_dlsym(handle, 'nvmlVgpuInstanceGetAccountingStats') global __nvmlVgpuInstanceClearAccountingPids - __nvmlVgpuInstanceClearAccountingPids = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceClearAccountingPids') + __nvmlVgpuInstanceClearAccountingPids = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlVgpuInstanceClearAccountingPids') if __nvmlVgpuInstanceClearAccountingPids == NULL: if handle == NULL: handle = load_library() - __nvmlVgpuInstanceClearAccountingPids = dlsym(handle, 'nvmlVgpuInstanceClearAccountingPids') + __nvmlVgpuInstanceClearAccountingPids = _cyb_dlsym(handle, 'nvmlVgpuInstanceClearAccountingPids') global __nvmlVgpuInstanceGetLicenseInfo_v2 - __nvmlVgpuInstanceGetLicenseInfo_v2 = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetLicenseInfo_v2') + __nvmlVgpuInstanceGetLicenseInfo_v2 = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlVgpuInstanceGetLicenseInfo_v2') if __nvmlVgpuInstanceGetLicenseInfo_v2 == NULL: if handle == NULL: handle = load_library() - __nvmlVgpuInstanceGetLicenseInfo_v2 = dlsym(handle, 'nvmlVgpuInstanceGetLicenseInfo_v2') + __nvmlVgpuInstanceGetLicenseInfo_v2 = _cyb_dlsym(handle, 'nvmlVgpuInstanceGetLicenseInfo_v2') global __nvmlGetExcludedDeviceCount - __nvmlGetExcludedDeviceCount = dlsym(RTLD_DEFAULT, 'nvmlGetExcludedDeviceCount') + __nvmlGetExcludedDeviceCount = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlGetExcludedDeviceCount') if __nvmlGetExcludedDeviceCount == NULL: if handle == NULL: handle = load_library() - __nvmlGetExcludedDeviceCount = dlsym(handle, 'nvmlGetExcludedDeviceCount') + __nvmlGetExcludedDeviceCount = _cyb_dlsym(handle, 'nvmlGetExcludedDeviceCount') global __nvmlGetExcludedDeviceInfoByIndex - __nvmlGetExcludedDeviceInfoByIndex = dlsym(RTLD_DEFAULT, 'nvmlGetExcludedDeviceInfoByIndex') + __nvmlGetExcludedDeviceInfoByIndex = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlGetExcludedDeviceInfoByIndex') if __nvmlGetExcludedDeviceInfoByIndex == NULL: if handle == NULL: handle = load_library() - __nvmlGetExcludedDeviceInfoByIndex = dlsym(handle, 'nvmlGetExcludedDeviceInfoByIndex') + __nvmlGetExcludedDeviceInfoByIndex = _cyb_dlsym(handle, 'nvmlGetExcludedDeviceInfoByIndex') global __nvmlDeviceSetMigMode - __nvmlDeviceSetMigMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetMigMode') + __nvmlDeviceSetMigMode = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceSetMigMode') if __nvmlDeviceSetMigMode == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceSetMigMode = dlsym(handle, 'nvmlDeviceSetMigMode') + __nvmlDeviceSetMigMode = _cyb_dlsym(handle, 'nvmlDeviceSetMigMode') global __nvmlDeviceGetMigMode - __nvmlDeviceGetMigMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMigMode') + __nvmlDeviceGetMigMode = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetMigMode') if __nvmlDeviceGetMigMode == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetMigMode = dlsym(handle, 'nvmlDeviceGetMigMode') + __nvmlDeviceGetMigMode = _cyb_dlsym(handle, 'nvmlDeviceGetMigMode') global __nvmlDeviceGetGpuInstanceProfileInfoV - __nvmlDeviceGetGpuInstanceProfileInfoV = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuInstanceProfileInfoV') + __nvmlDeviceGetGpuInstanceProfileInfoV = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetGpuInstanceProfileInfoV') if __nvmlDeviceGetGpuInstanceProfileInfoV == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetGpuInstanceProfileInfoV = dlsym(handle, 'nvmlDeviceGetGpuInstanceProfileInfoV') + __nvmlDeviceGetGpuInstanceProfileInfoV = _cyb_dlsym(handle, 'nvmlDeviceGetGpuInstanceProfileInfoV') global __nvmlDeviceGetGpuInstancePossiblePlacements_v2 - __nvmlDeviceGetGpuInstancePossiblePlacements_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuInstancePossiblePlacements_v2') + __nvmlDeviceGetGpuInstancePossiblePlacements_v2 = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetGpuInstancePossiblePlacements_v2') if __nvmlDeviceGetGpuInstancePossiblePlacements_v2 == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetGpuInstancePossiblePlacements_v2 = dlsym(handle, 'nvmlDeviceGetGpuInstancePossiblePlacements_v2') + __nvmlDeviceGetGpuInstancePossiblePlacements_v2 = _cyb_dlsym(handle, 'nvmlDeviceGetGpuInstancePossiblePlacements_v2') global __nvmlDeviceGetGpuInstanceRemainingCapacity - __nvmlDeviceGetGpuInstanceRemainingCapacity = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuInstanceRemainingCapacity') + __nvmlDeviceGetGpuInstanceRemainingCapacity = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetGpuInstanceRemainingCapacity') if __nvmlDeviceGetGpuInstanceRemainingCapacity == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetGpuInstanceRemainingCapacity = dlsym(handle, 'nvmlDeviceGetGpuInstanceRemainingCapacity') + __nvmlDeviceGetGpuInstanceRemainingCapacity = _cyb_dlsym(handle, 'nvmlDeviceGetGpuInstanceRemainingCapacity') global __nvmlDeviceCreateGpuInstance - __nvmlDeviceCreateGpuInstance = dlsym(RTLD_DEFAULT, 'nvmlDeviceCreateGpuInstance') + __nvmlDeviceCreateGpuInstance = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceCreateGpuInstance') if __nvmlDeviceCreateGpuInstance == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceCreateGpuInstance = dlsym(handle, 'nvmlDeviceCreateGpuInstance') + __nvmlDeviceCreateGpuInstance = _cyb_dlsym(handle, 'nvmlDeviceCreateGpuInstance') global __nvmlDeviceCreateGpuInstanceWithPlacement - __nvmlDeviceCreateGpuInstanceWithPlacement = dlsym(RTLD_DEFAULT, 'nvmlDeviceCreateGpuInstanceWithPlacement') + __nvmlDeviceCreateGpuInstanceWithPlacement = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceCreateGpuInstanceWithPlacement') if __nvmlDeviceCreateGpuInstanceWithPlacement == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceCreateGpuInstanceWithPlacement = dlsym(handle, 'nvmlDeviceCreateGpuInstanceWithPlacement') + __nvmlDeviceCreateGpuInstanceWithPlacement = _cyb_dlsym(handle, 'nvmlDeviceCreateGpuInstanceWithPlacement') global __nvmlGpuInstanceDestroy - __nvmlGpuInstanceDestroy = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceDestroy') + __nvmlGpuInstanceDestroy = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlGpuInstanceDestroy') if __nvmlGpuInstanceDestroy == NULL: if handle == NULL: handle = load_library() - __nvmlGpuInstanceDestroy = dlsym(handle, 'nvmlGpuInstanceDestroy') + __nvmlGpuInstanceDestroy = _cyb_dlsym(handle, 'nvmlGpuInstanceDestroy') global __nvmlDeviceGetGpuInstances - __nvmlDeviceGetGpuInstances = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuInstances') + __nvmlDeviceGetGpuInstances = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetGpuInstances') if __nvmlDeviceGetGpuInstances == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetGpuInstances = dlsym(handle, 'nvmlDeviceGetGpuInstances') + __nvmlDeviceGetGpuInstances = _cyb_dlsym(handle, 'nvmlDeviceGetGpuInstances') global __nvmlDeviceGetGpuInstanceById - __nvmlDeviceGetGpuInstanceById = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuInstanceById') + __nvmlDeviceGetGpuInstanceById = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetGpuInstanceById') if __nvmlDeviceGetGpuInstanceById == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetGpuInstanceById = dlsym(handle, 'nvmlDeviceGetGpuInstanceById') + __nvmlDeviceGetGpuInstanceById = _cyb_dlsym(handle, 'nvmlDeviceGetGpuInstanceById') global __nvmlGpuInstanceGetInfo - __nvmlGpuInstanceGetInfo = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetInfo') + __nvmlGpuInstanceGetInfo = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlGpuInstanceGetInfo') if __nvmlGpuInstanceGetInfo == NULL: if handle == NULL: handle = load_library() - __nvmlGpuInstanceGetInfo = dlsym(handle, 'nvmlGpuInstanceGetInfo') + __nvmlGpuInstanceGetInfo = _cyb_dlsym(handle, 'nvmlGpuInstanceGetInfo') global __nvmlGpuInstanceGetComputeInstanceProfileInfoV - __nvmlGpuInstanceGetComputeInstanceProfileInfoV = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetComputeInstanceProfileInfoV') + __nvmlGpuInstanceGetComputeInstanceProfileInfoV = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlGpuInstanceGetComputeInstanceProfileInfoV') if __nvmlGpuInstanceGetComputeInstanceProfileInfoV == NULL: if handle == NULL: handle = load_library() - __nvmlGpuInstanceGetComputeInstanceProfileInfoV = dlsym(handle, 'nvmlGpuInstanceGetComputeInstanceProfileInfoV') + __nvmlGpuInstanceGetComputeInstanceProfileInfoV = _cyb_dlsym(handle, 'nvmlGpuInstanceGetComputeInstanceProfileInfoV') global __nvmlGpuInstanceGetComputeInstanceRemainingCapacity - __nvmlGpuInstanceGetComputeInstanceRemainingCapacity = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetComputeInstanceRemainingCapacity') + __nvmlGpuInstanceGetComputeInstanceRemainingCapacity = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlGpuInstanceGetComputeInstanceRemainingCapacity') if __nvmlGpuInstanceGetComputeInstanceRemainingCapacity == NULL: if handle == NULL: handle = load_library() - __nvmlGpuInstanceGetComputeInstanceRemainingCapacity = dlsym(handle, 'nvmlGpuInstanceGetComputeInstanceRemainingCapacity') + __nvmlGpuInstanceGetComputeInstanceRemainingCapacity = _cyb_dlsym(handle, 'nvmlGpuInstanceGetComputeInstanceRemainingCapacity') global __nvmlGpuInstanceGetComputeInstancePossiblePlacements - __nvmlGpuInstanceGetComputeInstancePossiblePlacements = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetComputeInstancePossiblePlacements') + __nvmlGpuInstanceGetComputeInstancePossiblePlacements = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlGpuInstanceGetComputeInstancePossiblePlacements') if __nvmlGpuInstanceGetComputeInstancePossiblePlacements == NULL: if handle == NULL: handle = load_library() - __nvmlGpuInstanceGetComputeInstancePossiblePlacements = dlsym(handle, 'nvmlGpuInstanceGetComputeInstancePossiblePlacements') + __nvmlGpuInstanceGetComputeInstancePossiblePlacements = _cyb_dlsym(handle, 'nvmlGpuInstanceGetComputeInstancePossiblePlacements') global __nvmlGpuInstanceCreateComputeInstance - __nvmlGpuInstanceCreateComputeInstance = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceCreateComputeInstance') + __nvmlGpuInstanceCreateComputeInstance = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlGpuInstanceCreateComputeInstance') if __nvmlGpuInstanceCreateComputeInstance == NULL: if handle == NULL: handle = load_library() - __nvmlGpuInstanceCreateComputeInstance = dlsym(handle, 'nvmlGpuInstanceCreateComputeInstance') + __nvmlGpuInstanceCreateComputeInstance = _cyb_dlsym(handle, 'nvmlGpuInstanceCreateComputeInstance') global __nvmlGpuInstanceCreateComputeInstanceWithPlacement - __nvmlGpuInstanceCreateComputeInstanceWithPlacement = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceCreateComputeInstanceWithPlacement') + __nvmlGpuInstanceCreateComputeInstanceWithPlacement = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlGpuInstanceCreateComputeInstanceWithPlacement') if __nvmlGpuInstanceCreateComputeInstanceWithPlacement == NULL: if handle == NULL: handle = load_library() - __nvmlGpuInstanceCreateComputeInstanceWithPlacement = dlsym(handle, 'nvmlGpuInstanceCreateComputeInstanceWithPlacement') + __nvmlGpuInstanceCreateComputeInstanceWithPlacement = _cyb_dlsym(handle, 'nvmlGpuInstanceCreateComputeInstanceWithPlacement') global __nvmlComputeInstanceDestroy - __nvmlComputeInstanceDestroy = dlsym(RTLD_DEFAULT, 'nvmlComputeInstanceDestroy') + __nvmlComputeInstanceDestroy = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlComputeInstanceDestroy') if __nvmlComputeInstanceDestroy == NULL: if handle == NULL: handle = load_library() - __nvmlComputeInstanceDestroy = dlsym(handle, 'nvmlComputeInstanceDestroy') + __nvmlComputeInstanceDestroy = _cyb_dlsym(handle, 'nvmlComputeInstanceDestroy') global __nvmlGpuInstanceGetComputeInstances - __nvmlGpuInstanceGetComputeInstances = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetComputeInstances') + __nvmlGpuInstanceGetComputeInstances = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlGpuInstanceGetComputeInstances') if __nvmlGpuInstanceGetComputeInstances == NULL: if handle == NULL: handle = load_library() - __nvmlGpuInstanceGetComputeInstances = dlsym(handle, 'nvmlGpuInstanceGetComputeInstances') + __nvmlGpuInstanceGetComputeInstances = _cyb_dlsym(handle, 'nvmlGpuInstanceGetComputeInstances') global __nvmlGpuInstanceGetComputeInstanceById - __nvmlGpuInstanceGetComputeInstanceById = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetComputeInstanceById') + __nvmlGpuInstanceGetComputeInstanceById = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlGpuInstanceGetComputeInstanceById') if __nvmlGpuInstanceGetComputeInstanceById == NULL: if handle == NULL: handle = load_library() - __nvmlGpuInstanceGetComputeInstanceById = dlsym(handle, 'nvmlGpuInstanceGetComputeInstanceById') + __nvmlGpuInstanceGetComputeInstanceById = _cyb_dlsym(handle, 'nvmlGpuInstanceGetComputeInstanceById') global __nvmlComputeInstanceGetInfo_v2 - __nvmlComputeInstanceGetInfo_v2 = dlsym(RTLD_DEFAULT, 'nvmlComputeInstanceGetInfo_v2') + __nvmlComputeInstanceGetInfo_v2 = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlComputeInstanceGetInfo_v2') if __nvmlComputeInstanceGetInfo_v2 == NULL: if handle == NULL: handle = load_library() - __nvmlComputeInstanceGetInfo_v2 = dlsym(handle, 'nvmlComputeInstanceGetInfo_v2') + __nvmlComputeInstanceGetInfo_v2 = _cyb_dlsym(handle, 'nvmlComputeInstanceGetInfo_v2') global __nvmlDeviceIsMigDeviceHandle - __nvmlDeviceIsMigDeviceHandle = dlsym(RTLD_DEFAULT, 'nvmlDeviceIsMigDeviceHandle') + __nvmlDeviceIsMigDeviceHandle = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceIsMigDeviceHandle') if __nvmlDeviceIsMigDeviceHandle == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceIsMigDeviceHandle = dlsym(handle, 'nvmlDeviceIsMigDeviceHandle') + __nvmlDeviceIsMigDeviceHandle = _cyb_dlsym(handle, 'nvmlDeviceIsMigDeviceHandle') global __nvmlDeviceGetGpuInstanceId - __nvmlDeviceGetGpuInstanceId = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuInstanceId') + __nvmlDeviceGetGpuInstanceId = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetGpuInstanceId') if __nvmlDeviceGetGpuInstanceId == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetGpuInstanceId = dlsym(handle, 'nvmlDeviceGetGpuInstanceId') + __nvmlDeviceGetGpuInstanceId = _cyb_dlsym(handle, 'nvmlDeviceGetGpuInstanceId') global __nvmlDeviceGetComputeInstanceId - __nvmlDeviceGetComputeInstanceId = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetComputeInstanceId') + __nvmlDeviceGetComputeInstanceId = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetComputeInstanceId') if __nvmlDeviceGetComputeInstanceId == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetComputeInstanceId = dlsym(handle, 'nvmlDeviceGetComputeInstanceId') + __nvmlDeviceGetComputeInstanceId = _cyb_dlsym(handle, 'nvmlDeviceGetComputeInstanceId') global __nvmlDeviceGetMaxMigDeviceCount - __nvmlDeviceGetMaxMigDeviceCount = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMaxMigDeviceCount') + __nvmlDeviceGetMaxMigDeviceCount = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetMaxMigDeviceCount') if __nvmlDeviceGetMaxMigDeviceCount == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetMaxMigDeviceCount = dlsym(handle, 'nvmlDeviceGetMaxMigDeviceCount') + __nvmlDeviceGetMaxMigDeviceCount = _cyb_dlsym(handle, 'nvmlDeviceGetMaxMigDeviceCount') global __nvmlDeviceGetMigDeviceHandleByIndex - __nvmlDeviceGetMigDeviceHandleByIndex = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMigDeviceHandleByIndex') + __nvmlDeviceGetMigDeviceHandleByIndex = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetMigDeviceHandleByIndex') if __nvmlDeviceGetMigDeviceHandleByIndex == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetMigDeviceHandleByIndex = dlsym(handle, 'nvmlDeviceGetMigDeviceHandleByIndex') + __nvmlDeviceGetMigDeviceHandleByIndex = _cyb_dlsym(handle, 'nvmlDeviceGetMigDeviceHandleByIndex') global __nvmlDeviceGetDeviceHandleFromMigDeviceHandle - __nvmlDeviceGetDeviceHandleFromMigDeviceHandle = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDeviceHandleFromMigDeviceHandle') + __nvmlDeviceGetDeviceHandleFromMigDeviceHandle = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetDeviceHandleFromMigDeviceHandle') if __nvmlDeviceGetDeviceHandleFromMigDeviceHandle == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetDeviceHandleFromMigDeviceHandle = dlsym(handle, 'nvmlDeviceGetDeviceHandleFromMigDeviceHandle') + __nvmlDeviceGetDeviceHandleFromMigDeviceHandle = _cyb_dlsym(handle, 'nvmlDeviceGetDeviceHandleFromMigDeviceHandle') global __nvmlDeviceGetCapabilities - __nvmlDeviceGetCapabilities = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCapabilities') + __nvmlDeviceGetCapabilities = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetCapabilities') if __nvmlDeviceGetCapabilities == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetCapabilities = dlsym(handle, 'nvmlDeviceGetCapabilities') + __nvmlDeviceGetCapabilities = _cyb_dlsym(handle, 'nvmlDeviceGetCapabilities') global __nvmlDevicePowerSmoothingActivatePresetProfile - __nvmlDevicePowerSmoothingActivatePresetProfile = dlsym(RTLD_DEFAULT, 'nvmlDevicePowerSmoothingActivatePresetProfile') + __nvmlDevicePowerSmoothingActivatePresetProfile = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDevicePowerSmoothingActivatePresetProfile') if __nvmlDevicePowerSmoothingActivatePresetProfile == NULL: if handle == NULL: handle = load_library() - __nvmlDevicePowerSmoothingActivatePresetProfile = dlsym(handle, 'nvmlDevicePowerSmoothingActivatePresetProfile') + __nvmlDevicePowerSmoothingActivatePresetProfile = _cyb_dlsym(handle, 'nvmlDevicePowerSmoothingActivatePresetProfile') global __nvmlDevicePowerSmoothingUpdatePresetProfileParam - __nvmlDevicePowerSmoothingUpdatePresetProfileParam = dlsym(RTLD_DEFAULT, 'nvmlDevicePowerSmoothingUpdatePresetProfileParam') + __nvmlDevicePowerSmoothingUpdatePresetProfileParam = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDevicePowerSmoothingUpdatePresetProfileParam') if __nvmlDevicePowerSmoothingUpdatePresetProfileParam == NULL: if handle == NULL: handle = load_library() - __nvmlDevicePowerSmoothingUpdatePresetProfileParam = dlsym(handle, 'nvmlDevicePowerSmoothingUpdatePresetProfileParam') + __nvmlDevicePowerSmoothingUpdatePresetProfileParam = _cyb_dlsym(handle, 'nvmlDevicePowerSmoothingUpdatePresetProfileParam') global __nvmlDevicePowerSmoothingSetState - __nvmlDevicePowerSmoothingSetState = dlsym(RTLD_DEFAULT, 'nvmlDevicePowerSmoothingSetState') + __nvmlDevicePowerSmoothingSetState = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDevicePowerSmoothingSetState') if __nvmlDevicePowerSmoothingSetState == NULL: if handle == NULL: handle = load_library() - __nvmlDevicePowerSmoothingSetState = dlsym(handle, 'nvmlDevicePowerSmoothingSetState') + __nvmlDevicePowerSmoothingSetState = _cyb_dlsym(handle, 'nvmlDevicePowerSmoothingSetState') global __nvmlDeviceGetAddressingMode - __nvmlDeviceGetAddressingMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAddressingMode') + __nvmlDeviceGetAddressingMode = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetAddressingMode') if __nvmlDeviceGetAddressingMode == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetAddressingMode = dlsym(handle, 'nvmlDeviceGetAddressingMode') + __nvmlDeviceGetAddressingMode = _cyb_dlsym(handle, 'nvmlDeviceGetAddressingMode') global __nvmlDeviceGetRepairStatus - __nvmlDeviceGetRepairStatus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetRepairStatus') + __nvmlDeviceGetRepairStatus = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetRepairStatus') if __nvmlDeviceGetRepairStatus == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetRepairStatus = dlsym(handle, 'nvmlDeviceGetRepairStatus') + __nvmlDeviceGetRepairStatus = _cyb_dlsym(handle, 'nvmlDeviceGetRepairStatus') global __nvmlDeviceGetPowerMizerMode_v1 - __nvmlDeviceGetPowerMizerMode_v1 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPowerMizerMode_v1') + __nvmlDeviceGetPowerMizerMode_v1 = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetPowerMizerMode_v1') if __nvmlDeviceGetPowerMizerMode_v1 == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetPowerMizerMode_v1 = dlsym(handle, 'nvmlDeviceGetPowerMizerMode_v1') + __nvmlDeviceGetPowerMizerMode_v1 = _cyb_dlsym(handle, 'nvmlDeviceGetPowerMizerMode_v1') global __nvmlDeviceSetPowerMizerMode_v1 - __nvmlDeviceSetPowerMizerMode_v1 = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetPowerMizerMode_v1') + __nvmlDeviceSetPowerMizerMode_v1 = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceSetPowerMizerMode_v1') if __nvmlDeviceSetPowerMizerMode_v1 == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceSetPowerMizerMode_v1 = dlsym(handle, 'nvmlDeviceSetPowerMizerMode_v1') + __nvmlDeviceSetPowerMizerMode_v1 = _cyb_dlsym(handle, 'nvmlDeviceSetPowerMizerMode_v1') global __nvmlDeviceGetPdi - __nvmlDeviceGetPdi = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPdi') + __nvmlDeviceGetPdi = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetPdi') if __nvmlDeviceGetPdi == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetPdi = dlsym(handle, 'nvmlDeviceGetPdi') + __nvmlDeviceGetPdi = _cyb_dlsym(handle, 'nvmlDeviceGetPdi') global __nvmlDeviceSetHostname_v1 - __nvmlDeviceSetHostname_v1 = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetHostname_v1') + __nvmlDeviceSetHostname_v1 = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceSetHostname_v1') if __nvmlDeviceSetHostname_v1 == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceSetHostname_v1 = dlsym(handle, 'nvmlDeviceSetHostname_v1') + __nvmlDeviceSetHostname_v1 = _cyb_dlsym(handle, 'nvmlDeviceSetHostname_v1') global __nvmlDeviceGetHostname_v1 - __nvmlDeviceGetHostname_v1 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetHostname_v1') + __nvmlDeviceGetHostname_v1 = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetHostname_v1') if __nvmlDeviceGetHostname_v1 == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetHostname_v1 = dlsym(handle, 'nvmlDeviceGetHostname_v1') + __nvmlDeviceGetHostname_v1 = _cyb_dlsym(handle, 'nvmlDeviceGetHostname_v1') global __nvmlDeviceGetNvLinkInfo - __nvmlDeviceGetNvLinkInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvLinkInfo') + __nvmlDeviceGetNvLinkInfo = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetNvLinkInfo') if __nvmlDeviceGetNvLinkInfo == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetNvLinkInfo = dlsym(handle, 'nvmlDeviceGetNvLinkInfo') + __nvmlDeviceGetNvLinkInfo = _cyb_dlsym(handle, 'nvmlDeviceGetNvLinkInfo') global __nvmlDeviceReadWritePRM_v1 - __nvmlDeviceReadWritePRM_v1 = dlsym(RTLD_DEFAULT, 'nvmlDeviceReadWritePRM_v1') + __nvmlDeviceReadWritePRM_v1 = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceReadWritePRM_v1') if __nvmlDeviceReadWritePRM_v1 == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceReadWritePRM_v1 = dlsym(handle, 'nvmlDeviceReadWritePRM_v1') + __nvmlDeviceReadWritePRM_v1 = _cyb_dlsym(handle, 'nvmlDeviceReadWritePRM_v1') global __nvmlDeviceGetGpuInstanceProfileInfoByIdV - __nvmlDeviceGetGpuInstanceProfileInfoByIdV = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuInstanceProfileInfoByIdV') + __nvmlDeviceGetGpuInstanceProfileInfoByIdV = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetGpuInstanceProfileInfoByIdV') if __nvmlDeviceGetGpuInstanceProfileInfoByIdV == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetGpuInstanceProfileInfoByIdV = dlsym(handle, 'nvmlDeviceGetGpuInstanceProfileInfoByIdV') + __nvmlDeviceGetGpuInstanceProfileInfoByIdV = _cyb_dlsym(handle, 'nvmlDeviceGetGpuInstanceProfileInfoByIdV') global __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts - __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts') + __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts') if __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts = dlsym(handle, 'nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts') + __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts = _cyb_dlsym(handle, 'nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts') global __nvmlDeviceGetUnrepairableMemoryFlag_v1 - __nvmlDeviceGetUnrepairableMemoryFlag_v1 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetUnrepairableMemoryFlag_v1') + __nvmlDeviceGetUnrepairableMemoryFlag_v1 = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetUnrepairableMemoryFlag_v1') if __nvmlDeviceGetUnrepairableMemoryFlag_v1 == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetUnrepairableMemoryFlag_v1 = dlsym(handle, 'nvmlDeviceGetUnrepairableMemoryFlag_v1') + __nvmlDeviceGetUnrepairableMemoryFlag_v1 = _cyb_dlsym(handle, 'nvmlDeviceGetUnrepairableMemoryFlag_v1') global __nvmlDeviceReadPRMCounters_v1 - __nvmlDeviceReadPRMCounters_v1 = dlsym(RTLD_DEFAULT, 'nvmlDeviceReadPRMCounters_v1') + __nvmlDeviceReadPRMCounters_v1 = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceReadPRMCounters_v1') if __nvmlDeviceReadPRMCounters_v1 == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceReadPRMCounters_v1 = dlsym(handle, 'nvmlDeviceReadPRMCounters_v1') + __nvmlDeviceReadPRMCounters_v1 = _cyb_dlsym(handle, 'nvmlDeviceReadPRMCounters_v1') global __nvmlDeviceSetRusdSettings_v1 - __nvmlDeviceSetRusdSettings_v1 = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetRusdSettings_v1') + __nvmlDeviceSetRusdSettings_v1 = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceSetRusdSettings_v1') if __nvmlDeviceSetRusdSettings_v1 == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceSetRusdSettings_v1 = dlsym(handle, 'nvmlDeviceSetRusdSettings_v1') + __nvmlDeviceSetRusdSettings_v1 = _cyb_dlsym(handle, 'nvmlDeviceSetRusdSettings_v1') global __nvmlDeviceVgpuForceGspUnload - __nvmlDeviceVgpuForceGspUnload = dlsym(RTLD_DEFAULT, 'nvmlDeviceVgpuForceGspUnload') + __nvmlDeviceVgpuForceGspUnload = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceVgpuForceGspUnload') if __nvmlDeviceVgpuForceGspUnload == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceVgpuForceGspUnload = dlsym(handle, 'nvmlDeviceVgpuForceGspUnload') + __nvmlDeviceVgpuForceGspUnload = _cyb_dlsym(handle, 'nvmlDeviceVgpuForceGspUnload') global __nvmlDeviceGetVgpuSchedulerState_v2 - __nvmlDeviceGetVgpuSchedulerState_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuSchedulerState_v2') + __nvmlDeviceGetVgpuSchedulerState_v2 = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetVgpuSchedulerState_v2') if __nvmlDeviceGetVgpuSchedulerState_v2 == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetVgpuSchedulerState_v2 = dlsym(handle, 'nvmlDeviceGetVgpuSchedulerState_v2') + __nvmlDeviceGetVgpuSchedulerState_v2 = _cyb_dlsym(handle, 'nvmlDeviceGetVgpuSchedulerState_v2') global __nvmlGpuInstanceGetVgpuSchedulerState_v2 - __nvmlGpuInstanceGetVgpuSchedulerState_v2 = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetVgpuSchedulerState_v2') + __nvmlGpuInstanceGetVgpuSchedulerState_v2 = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlGpuInstanceGetVgpuSchedulerState_v2') if __nvmlGpuInstanceGetVgpuSchedulerState_v2 == NULL: if handle == NULL: handle = load_library() - __nvmlGpuInstanceGetVgpuSchedulerState_v2 = dlsym(handle, 'nvmlGpuInstanceGetVgpuSchedulerState_v2') + __nvmlGpuInstanceGetVgpuSchedulerState_v2 = _cyb_dlsym(handle, 'nvmlGpuInstanceGetVgpuSchedulerState_v2') global __nvmlDeviceGetVgpuSchedulerLog_v2 - __nvmlDeviceGetVgpuSchedulerLog_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuSchedulerLog_v2') + __nvmlDeviceGetVgpuSchedulerLog_v2 = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceGetVgpuSchedulerLog_v2') if __nvmlDeviceGetVgpuSchedulerLog_v2 == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceGetVgpuSchedulerLog_v2 = dlsym(handle, 'nvmlDeviceGetVgpuSchedulerLog_v2') + __nvmlDeviceGetVgpuSchedulerLog_v2 = _cyb_dlsym(handle, 'nvmlDeviceGetVgpuSchedulerLog_v2') global __nvmlGpuInstanceGetVgpuSchedulerLog_v2 - __nvmlGpuInstanceGetVgpuSchedulerLog_v2 = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetVgpuSchedulerLog_v2') + __nvmlGpuInstanceGetVgpuSchedulerLog_v2 = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlGpuInstanceGetVgpuSchedulerLog_v2') if __nvmlGpuInstanceGetVgpuSchedulerLog_v2 == NULL: if handle == NULL: handle = load_library() - __nvmlGpuInstanceGetVgpuSchedulerLog_v2 = dlsym(handle, 'nvmlGpuInstanceGetVgpuSchedulerLog_v2') + __nvmlGpuInstanceGetVgpuSchedulerLog_v2 = _cyb_dlsym(handle, 'nvmlGpuInstanceGetVgpuSchedulerLog_v2') global __nvmlDeviceSetVgpuSchedulerState_v2 - __nvmlDeviceSetVgpuSchedulerState_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetVgpuSchedulerState_v2') + __nvmlDeviceSetVgpuSchedulerState_v2 = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlDeviceSetVgpuSchedulerState_v2') if __nvmlDeviceSetVgpuSchedulerState_v2 == NULL: if handle == NULL: handle = load_library() - __nvmlDeviceSetVgpuSchedulerState_v2 = dlsym(handle, 'nvmlDeviceSetVgpuSchedulerState_v2') + __nvmlDeviceSetVgpuSchedulerState_v2 = _cyb_dlsym(handle, 'nvmlDeviceSetVgpuSchedulerState_v2') global __nvmlGpuInstanceSetVgpuSchedulerState_v2 - __nvmlGpuInstanceSetVgpuSchedulerState_v2 = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceSetVgpuSchedulerState_v2') + __nvmlGpuInstanceSetVgpuSchedulerState_v2 = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvmlGpuInstanceSetVgpuSchedulerState_v2') if __nvmlGpuInstanceSetVgpuSchedulerState_v2 == NULL: if handle == NULL: handle = load_library() - __nvmlGpuInstanceSetVgpuSchedulerState_v2 = dlsym(handle, 'nvmlGpuInstanceSetVgpuSchedulerState_v2') + __nvmlGpuInstanceSetVgpuSchedulerState_v2 = _cyb_dlsym(handle, 'nvmlGpuInstanceSetVgpuSchedulerState_v2') - __py_nvml_init = True + _cyb___py_nvml_init = True return 0 - cdef inline int _check_or_init_nvml() except -1 nogil: - if __py_nvml_init: + if _cyb___py_nvml_init: return 0 return _init_nvml() -cdef dict func_ptrs = None - - cpdef dict _inspect_function_pointers(): - global func_ptrs - if func_ptrs is not None: - return func_ptrs + global _cyb_func_ptrs + if _cyb_func_ptrs is not None: + return _cyb_func_ptrs _check_or_init_nvml() cdef dict data = {} - global __nvmlInit_v2 - data["__nvmlInit_v2"] = __nvmlInit_v2 + data["__nvmlInit_v2"] = <_cyb_intptr_t>__nvmlInit_v2 global __nvmlInitWithFlags - data["__nvmlInitWithFlags"] = __nvmlInitWithFlags + data["__nvmlInitWithFlags"] = <_cyb_intptr_t>__nvmlInitWithFlags global __nvmlShutdown - data["__nvmlShutdown"] = __nvmlShutdown + data["__nvmlShutdown"] = <_cyb_intptr_t>__nvmlShutdown global __nvmlErrorString - data["__nvmlErrorString"] = __nvmlErrorString + data["__nvmlErrorString"] = <_cyb_intptr_t>__nvmlErrorString global __nvmlSystemGetDriverVersion - data["__nvmlSystemGetDriverVersion"] = __nvmlSystemGetDriverVersion + data["__nvmlSystemGetDriverVersion"] = <_cyb_intptr_t>__nvmlSystemGetDriverVersion global __nvmlSystemGetNVMLVersion - data["__nvmlSystemGetNVMLVersion"] = __nvmlSystemGetNVMLVersion + data["__nvmlSystemGetNVMLVersion"] = <_cyb_intptr_t>__nvmlSystemGetNVMLVersion global __nvmlSystemGetCudaDriverVersion - data["__nvmlSystemGetCudaDriverVersion"] = __nvmlSystemGetCudaDriverVersion + data["__nvmlSystemGetCudaDriverVersion"] = <_cyb_intptr_t>__nvmlSystemGetCudaDriverVersion global __nvmlSystemGetCudaDriverVersion_v2 - data["__nvmlSystemGetCudaDriverVersion_v2"] = __nvmlSystemGetCudaDriverVersion_v2 + data["__nvmlSystemGetCudaDriverVersion_v2"] = <_cyb_intptr_t>__nvmlSystemGetCudaDriverVersion_v2 global __nvmlSystemGetProcessName - data["__nvmlSystemGetProcessName"] = __nvmlSystemGetProcessName + data["__nvmlSystemGetProcessName"] = <_cyb_intptr_t>__nvmlSystemGetProcessName global __nvmlSystemGetHicVersion - data["__nvmlSystemGetHicVersion"] = __nvmlSystemGetHicVersion + data["__nvmlSystemGetHicVersion"] = <_cyb_intptr_t>__nvmlSystemGetHicVersion global __nvmlSystemGetTopologyGpuSet - data["__nvmlSystemGetTopologyGpuSet"] = __nvmlSystemGetTopologyGpuSet + data["__nvmlSystemGetTopologyGpuSet"] = <_cyb_intptr_t>__nvmlSystemGetTopologyGpuSet global __nvmlSystemGetDriverBranch - data["__nvmlSystemGetDriverBranch"] = __nvmlSystemGetDriverBranch + data["__nvmlSystemGetDriverBranch"] = <_cyb_intptr_t>__nvmlSystemGetDriverBranch global __nvmlUnitGetCount - data["__nvmlUnitGetCount"] = __nvmlUnitGetCount + data["__nvmlUnitGetCount"] = <_cyb_intptr_t>__nvmlUnitGetCount global __nvmlUnitGetHandleByIndex - data["__nvmlUnitGetHandleByIndex"] = __nvmlUnitGetHandleByIndex + data["__nvmlUnitGetHandleByIndex"] = <_cyb_intptr_t>__nvmlUnitGetHandleByIndex global __nvmlUnitGetUnitInfo - data["__nvmlUnitGetUnitInfo"] = __nvmlUnitGetUnitInfo + data["__nvmlUnitGetUnitInfo"] = <_cyb_intptr_t>__nvmlUnitGetUnitInfo global __nvmlUnitGetLedState - data["__nvmlUnitGetLedState"] = __nvmlUnitGetLedState + data["__nvmlUnitGetLedState"] = <_cyb_intptr_t>__nvmlUnitGetLedState global __nvmlUnitGetPsuInfo - data["__nvmlUnitGetPsuInfo"] = __nvmlUnitGetPsuInfo + data["__nvmlUnitGetPsuInfo"] = <_cyb_intptr_t>__nvmlUnitGetPsuInfo global __nvmlUnitGetTemperature - data["__nvmlUnitGetTemperature"] = __nvmlUnitGetTemperature + data["__nvmlUnitGetTemperature"] = <_cyb_intptr_t>__nvmlUnitGetTemperature global __nvmlUnitGetFanSpeedInfo - data["__nvmlUnitGetFanSpeedInfo"] = __nvmlUnitGetFanSpeedInfo + data["__nvmlUnitGetFanSpeedInfo"] = <_cyb_intptr_t>__nvmlUnitGetFanSpeedInfo global __nvmlUnitGetDevices - data["__nvmlUnitGetDevices"] = __nvmlUnitGetDevices + data["__nvmlUnitGetDevices"] = <_cyb_intptr_t>__nvmlUnitGetDevices global __nvmlDeviceGetCount_v2 - data["__nvmlDeviceGetCount_v2"] = __nvmlDeviceGetCount_v2 + data["__nvmlDeviceGetCount_v2"] = <_cyb_intptr_t>__nvmlDeviceGetCount_v2 global __nvmlDeviceGetAttributes_v2 - data["__nvmlDeviceGetAttributes_v2"] = __nvmlDeviceGetAttributes_v2 + data["__nvmlDeviceGetAttributes_v2"] = <_cyb_intptr_t>__nvmlDeviceGetAttributes_v2 global __nvmlDeviceGetHandleByIndex_v2 - data["__nvmlDeviceGetHandleByIndex_v2"] = __nvmlDeviceGetHandleByIndex_v2 + data["__nvmlDeviceGetHandleByIndex_v2"] = <_cyb_intptr_t>__nvmlDeviceGetHandleByIndex_v2 global __nvmlDeviceGetHandleBySerial - data["__nvmlDeviceGetHandleBySerial"] = __nvmlDeviceGetHandleBySerial + data["__nvmlDeviceGetHandleBySerial"] = <_cyb_intptr_t>__nvmlDeviceGetHandleBySerial global __nvmlDeviceGetHandleByUUID - data["__nvmlDeviceGetHandleByUUID"] = __nvmlDeviceGetHandleByUUID + data["__nvmlDeviceGetHandleByUUID"] = <_cyb_intptr_t>__nvmlDeviceGetHandleByUUID global __nvmlDeviceGetHandleByUUIDV - data["__nvmlDeviceGetHandleByUUIDV"] = __nvmlDeviceGetHandleByUUIDV + data["__nvmlDeviceGetHandleByUUIDV"] = <_cyb_intptr_t>__nvmlDeviceGetHandleByUUIDV global __nvmlDeviceGetHandleByPciBusId_v2 - data["__nvmlDeviceGetHandleByPciBusId_v2"] = __nvmlDeviceGetHandleByPciBusId_v2 + data["__nvmlDeviceGetHandleByPciBusId_v2"] = <_cyb_intptr_t>__nvmlDeviceGetHandleByPciBusId_v2 global __nvmlDeviceGetName - data["__nvmlDeviceGetName"] = __nvmlDeviceGetName + data["__nvmlDeviceGetName"] = <_cyb_intptr_t>__nvmlDeviceGetName global __nvmlDeviceGetBrand - data["__nvmlDeviceGetBrand"] = __nvmlDeviceGetBrand + data["__nvmlDeviceGetBrand"] = <_cyb_intptr_t>__nvmlDeviceGetBrand global __nvmlDeviceGetIndex - data["__nvmlDeviceGetIndex"] = __nvmlDeviceGetIndex + data["__nvmlDeviceGetIndex"] = <_cyb_intptr_t>__nvmlDeviceGetIndex global __nvmlDeviceGetSerial - data["__nvmlDeviceGetSerial"] = __nvmlDeviceGetSerial + data["__nvmlDeviceGetSerial"] = <_cyb_intptr_t>__nvmlDeviceGetSerial global __nvmlDeviceGetModuleId - data["__nvmlDeviceGetModuleId"] = __nvmlDeviceGetModuleId + data["__nvmlDeviceGetModuleId"] = <_cyb_intptr_t>__nvmlDeviceGetModuleId global __nvmlDeviceGetC2cModeInfoV - data["__nvmlDeviceGetC2cModeInfoV"] = __nvmlDeviceGetC2cModeInfoV + data["__nvmlDeviceGetC2cModeInfoV"] = <_cyb_intptr_t>__nvmlDeviceGetC2cModeInfoV global __nvmlDeviceGetMemoryAffinity - data["__nvmlDeviceGetMemoryAffinity"] = __nvmlDeviceGetMemoryAffinity + data["__nvmlDeviceGetMemoryAffinity"] = <_cyb_intptr_t>__nvmlDeviceGetMemoryAffinity global __nvmlDeviceGetCpuAffinityWithinScope - data["__nvmlDeviceGetCpuAffinityWithinScope"] = __nvmlDeviceGetCpuAffinityWithinScope + data["__nvmlDeviceGetCpuAffinityWithinScope"] = <_cyb_intptr_t>__nvmlDeviceGetCpuAffinityWithinScope global __nvmlDeviceGetCpuAffinity - data["__nvmlDeviceGetCpuAffinity"] = __nvmlDeviceGetCpuAffinity + data["__nvmlDeviceGetCpuAffinity"] = <_cyb_intptr_t>__nvmlDeviceGetCpuAffinity global __nvmlDeviceSetCpuAffinity - data["__nvmlDeviceSetCpuAffinity"] = __nvmlDeviceSetCpuAffinity + data["__nvmlDeviceSetCpuAffinity"] = <_cyb_intptr_t>__nvmlDeviceSetCpuAffinity global __nvmlDeviceClearCpuAffinity - data["__nvmlDeviceClearCpuAffinity"] = __nvmlDeviceClearCpuAffinity + data["__nvmlDeviceClearCpuAffinity"] = <_cyb_intptr_t>__nvmlDeviceClearCpuAffinity global __nvmlDeviceGetNumaNodeId - data["__nvmlDeviceGetNumaNodeId"] = __nvmlDeviceGetNumaNodeId + data["__nvmlDeviceGetNumaNodeId"] = <_cyb_intptr_t>__nvmlDeviceGetNumaNodeId global __nvmlDeviceGetTopologyCommonAncestor - data["__nvmlDeviceGetTopologyCommonAncestor"] = __nvmlDeviceGetTopologyCommonAncestor + data["__nvmlDeviceGetTopologyCommonAncestor"] = <_cyb_intptr_t>__nvmlDeviceGetTopologyCommonAncestor global __nvmlDeviceGetTopologyNearestGpus - data["__nvmlDeviceGetTopologyNearestGpus"] = __nvmlDeviceGetTopologyNearestGpus + data["__nvmlDeviceGetTopologyNearestGpus"] = <_cyb_intptr_t>__nvmlDeviceGetTopologyNearestGpus global __nvmlDeviceGetP2PStatus - data["__nvmlDeviceGetP2PStatus"] = __nvmlDeviceGetP2PStatus + data["__nvmlDeviceGetP2PStatus"] = <_cyb_intptr_t>__nvmlDeviceGetP2PStatus global __nvmlDeviceGetUUID - data["__nvmlDeviceGetUUID"] = __nvmlDeviceGetUUID + data["__nvmlDeviceGetUUID"] = <_cyb_intptr_t>__nvmlDeviceGetUUID global __nvmlDeviceGetMinorNumber - data["__nvmlDeviceGetMinorNumber"] = __nvmlDeviceGetMinorNumber + data["__nvmlDeviceGetMinorNumber"] = <_cyb_intptr_t>__nvmlDeviceGetMinorNumber global __nvmlDeviceGetBoardPartNumber - data["__nvmlDeviceGetBoardPartNumber"] = __nvmlDeviceGetBoardPartNumber + data["__nvmlDeviceGetBoardPartNumber"] = <_cyb_intptr_t>__nvmlDeviceGetBoardPartNumber global __nvmlDeviceGetInforomVersion - data["__nvmlDeviceGetInforomVersion"] = __nvmlDeviceGetInforomVersion + data["__nvmlDeviceGetInforomVersion"] = <_cyb_intptr_t>__nvmlDeviceGetInforomVersion global __nvmlDeviceGetInforomImageVersion - data["__nvmlDeviceGetInforomImageVersion"] = __nvmlDeviceGetInforomImageVersion + data["__nvmlDeviceGetInforomImageVersion"] = <_cyb_intptr_t>__nvmlDeviceGetInforomImageVersion global __nvmlDeviceGetInforomConfigurationChecksum - data["__nvmlDeviceGetInforomConfigurationChecksum"] = __nvmlDeviceGetInforomConfigurationChecksum + data["__nvmlDeviceGetInforomConfigurationChecksum"] = <_cyb_intptr_t>__nvmlDeviceGetInforomConfigurationChecksum global __nvmlDeviceValidateInforom - data["__nvmlDeviceValidateInforom"] = __nvmlDeviceValidateInforom + data["__nvmlDeviceValidateInforom"] = <_cyb_intptr_t>__nvmlDeviceValidateInforom global __nvmlDeviceGetLastBBXFlushTime - data["__nvmlDeviceGetLastBBXFlushTime"] = __nvmlDeviceGetLastBBXFlushTime + data["__nvmlDeviceGetLastBBXFlushTime"] = <_cyb_intptr_t>__nvmlDeviceGetLastBBXFlushTime global __nvmlDeviceGetDisplayMode - data["__nvmlDeviceGetDisplayMode"] = __nvmlDeviceGetDisplayMode + data["__nvmlDeviceGetDisplayMode"] = <_cyb_intptr_t>__nvmlDeviceGetDisplayMode global __nvmlDeviceGetDisplayActive - data["__nvmlDeviceGetDisplayActive"] = __nvmlDeviceGetDisplayActive + data["__nvmlDeviceGetDisplayActive"] = <_cyb_intptr_t>__nvmlDeviceGetDisplayActive global __nvmlDeviceGetPersistenceMode - data["__nvmlDeviceGetPersistenceMode"] = __nvmlDeviceGetPersistenceMode + data["__nvmlDeviceGetPersistenceMode"] = <_cyb_intptr_t>__nvmlDeviceGetPersistenceMode global __nvmlDeviceGetPciInfoExt - data["__nvmlDeviceGetPciInfoExt"] = __nvmlDeviceGetPciInfoExt + data["__nvmlDeviceGetPciInfoExt"] = <_cyb_intptr_t>__nvmlDeviceGetPciInfoExt global __nvmlDeviceGetPciInfo_v3 - data["__nvmlDeviceGetPciInfo_v3"] = __nvmlDeviceGetPciInfo_v3 + data["__nvmlDeviceGetPciInfo_v3"] = <_cyb_intptr_t>__nvmlDeviceGetPciInfo_v3 global __nvmlDeviceGetMaxPcieLinkGeneration - data["__nvmlDeviceGetMaxPcieLinkGeneration"] = __nvmlDeviceGetMaxPcieLinkGeneration + data["__nvmlDeviceGetMaxPcieLinkGeneration"] = <_cyb_intptr_t>__nvmlDeviceGetMaxPcieLinkGeneration global __nvmlDeviceGetGpuMaxPcieLinkGeneration - data["__nvmlDeviceGetGpuMaxPcieLinkGeneration"] = __nvmlDeviceGetGpuMaxPcieLinkGeneration + data["__nvmlDeviceGetGpuMaxPcieLinkGeneration"] = <_cyb_intptr_t>__nvmlDeviceGetGpuMaxPcieLinkGeneration global __nvmlDeviceGetMaxPcieLinkWidth - data["__nvmlDeviceGetMaxPcieLinkWidth"] = __nvmlDeviceGetMaxPcieLinkWidth + data["__nvmlDeviceGetMaxPcieLinkWidth"] = <_cyb_intptr_t>__nvmlDeviceGetMaxPcieLinkWidth global __nvmlDeviceGetCurrPcieLinkGeneration - data["__nvmlDeviceGetCurrPcieLinkGeneration"] = __nvmlDeviceGetCurrPcieLinkGeneration + data["__nvmlDeviceGetCurrPcieLinkGeneration"] = <_cyb_intptr_t>__nvmlDeviceGetCurrPcieLinkGeneration global __nvmlDeviceGetCurrPcieLinkWidth - data["__nvmlDeviceGetCurrPcieLinkWidth"] = __nvmlDeviceGetCurrPcieLinkWidth + data["__nvmlDeviceGetCurrPcieLinkWidth"] = <_cyb_intptr_t>__nvmlDeviceGetCurrPcieLinkWidth global __nvmlDeviceGetPcieThroughput - data["__nvmlDeviceGetPcieThroughput"] = __nvmlDeviceGetPcieThroughput + data["__nvmlDeviceGetPcieThroughput"] = <_cyb_intptr_t>__nvmlDeviceGetPcieThroughput global __nvmlDeviceGetPcieReplayCounter - data["__nvmlDeviceGetPcieReplayCounter"] = __nvmlDeviceGetPcieReplayCounter + data["__nvmlDeviceGetPcieReplayCounter"] = <_cyb_intptr_t>__nvmlDeviceGetPcieReplayCounter global __nvmlDeviceGetClockInfo - data["__nvmlDeviceGetClockInfo"] = __nvmlDeviceGetClockInfo + data["__nvmlDeviceGetClockInfo"] = <_cyb_intptr_t>__nvmlDeviceGetClockInfo global __nvmlDeviceGetMaxClockInfo - data["__nvmlDeviceGetMaxClockInfo"] = __nvmlDeviceGetMaxClockInfo + data["__nvmlDeviceGetMaxClockInfo"] = <_cyb_intptr_t>__nvmlDeviceGetMaxClockInfo global __nvmlDeviceGetGpcClkVfOffset - data["__nvmlDeviceGetGpcClkVfOffset"] = __nvmlDeviceGetGpcClkVfOffset + data["__nvmlDeviceGetGpcClkVfOffset"] = <_cyb_intptr_t>__nvmlDeviceGetGpcClkVfOffset global __nvmlDeviceGetClock - data["__nvmlDeviceGetClock"] = __nvmlDeviceGetClock + data["__nvmlDeviceGetClock"] = <_cyb_intptr_t>__nvmlDeviceGetClock global __nvmlDeviceGetMaxCustomerBoostClock - data["__nvmlDeviceGetMaxCustomerBoostClock"] = __nvmlDeviceGetMaxCustomerBoostClock + data["__nvmlDeviceGetMaxCustomerBoostClock"] = <_cyb_intptr_t>__nvmlDeviceGetMaxCustomerBoostClock global __nvmlDeviceGetSupportedMemoryClocks - data["__nvmlDeviceGetSupportedMemoryClocks"] = __nvmlDeviceGetSupportedMemoryClocks + data["__nvmlDeviceGetSupportedMemoryClocks"] = <_cyb_intptr_t>__nvmlDeviceGetSupportedMemoryClocks global __nvmlDeviceGetSupportedGraphicsClocks - data["__nvmlDeviceGetSupportedGraphicsClocks"] = __nvmlDeviceGetSupportedGraphicsClocks + data["__nvmlDeviceGetSupportedGraphicsClocks"] = <_cyb_intptr_t>__nvmlDeviceGetSupportedGraphicsClocks global __nvmlDeviceGetAutoBoostedClocksEnabled - data["__nvmlDeviceGetAutoBoostedClocksEnabled"] = __nvmlDeviceGetAutoBoostedClocksEnabled + data["__nvmlDeviceGetAutoBoostedClocksEnabled"] = <_cyb_intptr_t>__nvmlDeviceGetAutoBoostedClocksEnabled global __nvmlDeviceGetFanSpeed - data["__nvmlDeviceGetFanSpeed"] = __nvmlDeviceGetFanSpeed + data["__nvmlDeviceGetFanSpeed"] = <_cyb_intptr_t>__nvmlDeviceGetFanSpeed global __nvmlDeviceGetFanSpeed_v2 - data["__nvmlDeviceGetFanSpeed_v2"] = __nvmlDeviceGetFanSpeed_v2 + data["__nvmlDeviceGetFanSpeed_v2"] = <_cyb_intptr_t>__nvmlDeviceGetFanSpeed_v2 global __nvmlDeviceGetFanSpeedRPM - data["__nvmlDeviceGetFanSpeedRPM"] = __nvmlDeviceGetFanSpeedRPM + data["__nvmlDeviceGetFanSpeedRPM"] = <_cyb_intptr_t>__nvmlDeviceGetFanSpeedRPM global __nvmlDeviceGetTargetFanSpeed - data["__nvmlDeviceGetTargetFanSpeed"] = __nvmlDeviceGetTargetFanSpeed + data["__nvmlDeviceGetTargetFanSpeed"] = <_cyb_intptr_t>__nvmlDeviceGetTargetFanSpeed global __nvmlDeviceGetMinMaxFanSpeed - data["__nvmlDeviceGetMinMaxFanSpeed"] = __nvmlDeviceGetMinMaxFanSpeed + data["__nvmlDeviceGetMinMaxFanSpeed"] = <_cyb_intptr_t>__nvmlDeviceGetMinMaxFanSpeed global __nvmlDeviceGetFanControlPolicy_v2 - data["__nvmlDeviceGetFanControlPolicy_v2"] = __nvmlDeviceGetFanControlPolicy_v2 + data["__nvmlDeviceGetFanControlPolicy_v2"] = <_cyb_intptr_t>__nvmlDeviceGetFanControlPolicy_v2 global __nvmlDeviceGetNumFans - data["__nvmlDeviceGetNumFans"] = __nvmlDeviceGetNumFans + data["__nvmlDeviceGetNumFans"] = <_cyb_intptr_t>__nvmlDeviceGetNumFans global __nvmlDeviceGetCoolerInfo - data["__nvmlDeviceGetCoolerInfo"] = __nvmlDeviceGetCoolerInfo + data["__nvmlDeviceGetCoolerInfo"] = <_cyb_intptr_t>__nvmlDeviceGetCoolerInfo global __nvmlDeviceGetTemperatureV - data["__nvmlDeviceGetTemperatureV"] = __nvmlDeviceGetTemperatureV + data["__nvmlDeviceGetTemperatureV"] = <_cyb_intptr_t>__nvmlDeviceGetTemperatureV global __nvmlDeviceGetTemperatureThreshold - data["__nvmlDeviceGetTemperatureThreshold"] = __nvmlDeviceGetTemperatureThreshold + data["__nvmlDeviceGetTemperatureThreshold"] = <_cyb_intptr_t>__nvmlDeviceGetTemperatureThreshold global __nvmlDeviceGetMarginTemperature - data["__nvmlDeviceGetMarginTemperature"] = __nvmlDeviceGetMarginTemperature + data["__nvmlDeviceGetMarginTemperature"] = <_cyb_intptr_t>__nvmlDeviceGetMarginTemperature global __nvmlDeviceGetThermalSettings - data["__nvmlDeviceGetThermalSettings"] = __nvmlDeviceGetThermalSettings + data["__nvmlDeviceGetThermalSettings"] = <_cyb_intptr_t>__nvmlDeviceGetThermalSettings global __nvmlDeviceGetPerformanceState - data["__nvmlDeviceGetPerformanceState"] = __nvmlDeviceGetPerformanceState + data["__nvmlDeviceGetPerformanceState"] = <_cyb_intptr_t>__nvmlDeviceGetPerformanceState global __nvmlDeviceGetCurrentClocksEventReasons - data["__nvmlDeviceGetCurrentClocksEventReasons"] = __nvmlDeviceGetCurrentClocksEventReasons + data["__nvmlDeviceGetCurrentClocksEventReasons"] = <_cyb_intptr_t>__nvmlDeviceGetCurrentClocksEventReasons global __nvmlDeviceGetSupportedClocksEventReasons - data["__nvmlDeviceGetSupportedClocksEventReasons"] = __nvmlDeviceGetSupportedClocksEventReasons + data["__nvmlDeviceGetSupportedClocksEventReasons"] = <_cyb_intptr_t>__nvmlDeviceGetSupportedClocksEventReasons global __nvmlDeviceGetPowerState - data["__nvmlDeviceGetPowerState"] = __nvmlDeviceGetPowerState + data["__nvmlDeviceGetPowerState"] = <_cyb_intptr_t>__nvmlDeviceGetPowerState global __nvmlDeviceGetDynamicPstatesInfo - data["__nvmlDeviceGetDynamicPstatesInfo"] = __nvmlDeviceGetDynamicPstatesInfo + data["__nvmlDeviceGetDynamicPstatesInfo"] = <_cyb_intptr_t>__nvmlDeviceGetDynamicPstatesInfo global __nvmlDeviceGetMemClkVfOffset - data["__nvmlDeviceGetMemClkVfOffset"] = __nvmlDeviceGetMemClkVfOffset + data["__nvmlDeviceGetMemClkVfOffset"] = <_cyb_intptr_t>__nvmlDeviceGetMemClkVfOffset global __nvmlDeviceGetMinMaxClockOfPState - data["__nvmlDeviceGetMinMaxClockOfPState"] = __nvmlDeviceGetMinMaxClockOfPState + data["__nvmlDeviceGetMinMaxClockOfPState"] = <_cyb_intptr_t>__nvmlDeviceGetMinMaxClockOfPState global __nvmlDeviceGetSupportedPerformanceStates - data["__nvmlDeviceGetSupportedPerformanceStates"] = __nvmlDeviceGetSupportedPerformanceStates + data["__nvmlDeviceGetSupportedPerformanceStates"] = <_cyb_intptr_t>__nvmlDeviceGetSupportedPerformanceStates global __nvmlDeviceGetGpcClkMinMaxVfOffset - data["__nvmlDeviceGetGpcClkMinMaxVfOffset"] = __nvmlDeviceGetGpcClkMinMaxVfOffset + data["__nvmlDeviceGetGpcClkMinMaxVfOffset"] = <_cyb_intptr_t>__nvmlDeviceGetGpcClkMinMaxVfOffset global __nvmlDeviceGetMemClkMinMaxVfOffset - data["__nvmlDeviceGetMemClkMinMaxVfOffset"] = __nvmlDeviceGetMemClkMinMaxVfOffset + data["__nvmlDeviceGetMemClkMinMaxVfOffset"] = <_cyb_intptr_t>__nvmlDeviceGetMemClkMinMaxVfOffset global __nvmlDeviceGetClockOffsets - data["__nvmlDeviceGetClockOffsets"] = __nvmlDeviceGetClockOffsets + data["__nvmlDeviceGetClockOffsets"] = <_cyb_intptr_t>__nvmlDeviceGetClockOffsets global __nvmlDeviceSetClockOffsets - data["__nvmlDeviceSetClockOffsets"] = __nvmlDeviceSetClockOffsets + data["__nvmlDeviceSetClockOffsets"] = <_cyb_intptr_t>__nvmlDeviceSetClockOffsets global __nvmlDeviceGetPerformanceModes - data["__nvmlDeviceGetPerformanceModes"] = __nvmlDeviceGetPerformanceModes + data["__nvmlDeviceGetPerformanceModes"] = <_cyb_intptr_t>__nvmlDeviceGetPerformanceModes global __nvmlDeviceGetCurrentClockFreqs - data["__nvmlDeviceGetCurrentClockFreqs"] = __nvmlDeviceGetCurrentClockFreqs + data["__nvmlDeviceGetCurrentClockFreqs"] = <_cyb_intptr_t>__nvmlDeviceGetCurrentClockFreqs global __nvmlDeviceGetPowerManagementLimit - data["__nvmlDeviceGetPowerManagementLimit"] = __nvmlDeviceGetPowerManagementLimit + data["__nvmlDeviceGetPowerManagementLimit"] = <_cyb_intptr_t>__nvmlDeviceGetPowerManagementLimit global __nvmlDeviceGetPowerManagementLimitConstraints - data["__nvmlDeviceGetPowerManagementLimitConstraints"] = __nvmlDeviceGetPowerManagementLimitConstraints + data["__nvmlDeviceGetPowerManagementLimitConstraints"] = <_cyb_intptr_t>__nvmlDeviceGetPowerManagementLimitConstraints global __nvmlDeviceGetPowerManagementDefaultLimit - data["__nvmlDeviceGetPowerManagementDefaultLimit"] = __nvmlDeviceGetPowerManagementDefaultLimit + data["__nvmlDeviceGetPowerManagementDefaultLimit"] = <_cyb_intptr_t>__nvmlDeviceGetPowerManagementDefaultLimit global __nvmlDeviceGetPowerUsage - data["__nvmlDeviceGetPowerUsage"] = __nvmlDeviceGetPowerUsage + data["__nvmlDeviceGetPowerUsage"] = <_cyb_intptr_t>__nvmlDeviceGetPowerUsage global __nvmlDeviceGetTotalEnergyConsumption - data["__nvmlDeviceGetTotalEnergyConsumption"] = __nvmlDeviceGetTotalEnergyConsumption + data["__nvmlDeviceGetTotalEnergyConsumption"] = <_cyb_intptr_t>__nvmlDeviceGetTotalEnergyConsumption global __nvmlDeviceGetEnforcedPowerLimit - data["__nvmlDeviceGetEnforcedPowerLimit"] = __nvmlDeviceGetEnforcedPowerLimit + data["__nvmlDeviceGetEnforcedPowerLimit"] = <_cyb_intptr_t>__nvmlDeviceGetEnforcedPowerLimit global __nvmlDeviceGetGpuOperationMode - data["__nvmlDeviceGetGpuOperationMode"] = __nvmlDeviceGetGpuOperationMode + data["__nvmlDeviceGetGpuOperationMode"] = <_cyb_intptr_t>__nvmlDeviceGetGpuOperationMode global __nvmlDeviceGetMemoryInfo_v2 - data["__nvmlDeviceGetMemoryInfo_v2"] = __nvmlDeviceGetMemoryInfo_v2 + data["__nvmlDeviceGetMemoryInfo_v2"] = <_cyb_intptr_t>__nvmlDeviceGetMemoryInfo_v2 global __nvmlDeviceGetComputeMode - data["__nvmlDeviceGetComputeMode"] = __nvmlDeviceGetComputeMode + data["__nvmlDeviceGetComputeMode"] = <_cyb_intptr_t>__nvmlDeviceGetComputeMode global __nvmlDeviceGetCudaComputeCapability - data["__nvmlDeviceGetCudaComputeCapability"] = __nvmlDeviceGetCudaComputeCapability + data["__nvmlDeviceGetCudaComputeCapability"] = <_cyb_intptr_t>__nvmlDeviceGetCudaComputeCapability global __nvmlDeviceGetDramEncryptionMode - data["__nvmlDeviceGetDramEncryptionMode"] = __nvmlDeviceGetDramEncryptionMode + data["__nvmlDeviceGetDramEncryptionMode"] = <_cyb_intptr_t>__nvmlDeviceGetDramEncryptionMode global __nvmlDeviceSetDramEncryptionMode - data["__nvmlDeviceSetDramEncryptionMode"] = __nvmlDeviceSetDramEncryptionMode + data["__nvmlDeviceSetDramEncryptionMode"] = <_cyb_intptr_t>__nvmlDeviceSetDramEncryptionMode global __nvmlDeviceGetEccMode - data["__nvmlDeviceGetEccMode"] = __nvmlDeviceGetEccMode + data["__nvmlDeviceGetEccMode"] = <_cyb_intptr_t>__nvmlDeviceGetEccMode global __nvmlDeviceGetDefaultEccMode - data["__nvmlDeviceGetDefaultEccMode"] = __nvmlDeviceGetDefaultEccMode + data["__nvmlDeviceGetDefaultEccMode"] = <_cyb_intptr_t>__nvmlDeviceGetDefaultEccMode global __nvmlDeviceGetBoardId - data["__nvmlDeviceGetBoardId"] = __nvmlDeviceGetBoardId + data["__nvmlDeviceGetBoardId"] = <_cyb_intptr_t>__nvmlDeviceGetBoardId global __nvmlDeviceGetMultiGpuBoard - data["__nvmlDeviceGetMultiGpuBoard"] = __nvmlDeviceGetMultiGpuBoard + data["__nvmlDeviceGetMultiGpuBoard"] = <_cyb_intptr_t>__nvmlDeviceGetMultiGpuBoard global __nvmlDeviceGetTotalEccErrors - data["__nvmlDeviceGetTotalEccErrors"] = __nvmlDeviceGetTotalEccErrors + data["__nvmlDeviceGetTotalEccErrors"] = <_cyb_intptr_t>__nvmlDeviceGetTotalEccErrors global __nvmlDeviceGetMemoryErrorCounter - data["__nvmlDeviceGetMemoryErrorCounter"] = __nvmlDeviceGetMemoryErrorCounter + data["__nvmlDeviceGetMemoryErrorCounter"] = <_cyb_intptr_t>__nvmlDeviceGetMemoryErrorCounter global __nvmlDeviceGetUtilizationRates - data["__nvmlDeviceGetUtilizationRates"] = __nvmlDeviceGetUtilizationRates + data["__nvmlDeviceGetUtilizationRates"] = <_cyb_intptr_t>__nvmlDeviceGetUtilizationRates global __nvmlDeviceGetEncoderUtilization - data["__nvmlDeviceGetEncoderUtilization"] = __nvmlDeviceGetEncoderUtilization + data["__nvmlDeviceGetEncoderUtilization"] = <_cyb_intptr_t>__nvmlDeviceGetEncoderUtilization global __nvmlDeviceGetEncoderCapacity - data["__nvmlDeviceGetEncoderCapacity"] = __nvmlDeviceGetEncoderCapacity + data["__nvmlDeviceGetEncoderCapacity"] = <_cyb_intptr_t>__nvmlDeviceGetEncoderCapacity global __nvmlDeviceGetEncoderStats - data["__nvmlDeviceGetEncoderStats"] = __nvmlDeviceGetEncoderStats + data["__nvmlDeviceGetEncoderStats"] = <_cyb_intptr_t>__nvmlDeviceGetEncoderStats global __nvmlDeviceGetEncoderSessions - data["__nvmlDeviceGetEncoderSessions"] = __nvmlDeviceGetEncoderSessions + data["__nvmlDeviceGetEncoderSessions"] = <_cyb_intptr_t>__nvmlDeviceGetEncoderSessions global __nvmlDeviceGetDecoderUtilization - data["__nvmlDeviceGetDecoderUtilization"] = __nvmlDeviceGetDecoderUtilization + data["__nvmlDeviceGetDecoderUtilization"] = <_cyb_intptr_t>__nvmlDeviceGetDecoderUtilization global __nvmlDeviceGetJpgUtilization - data["__nvmlDeviceGetJpgUtilization"] = __nvmlDeviceGetJpgUtilization + data["__nvmlDeviceGetJpgUtilization"] = <_cyb_intptr_t>__nvmlDeviceGetJpgUtilization global __nvmlDeviceGetOfaUtilization - data["__nvmlDeviceGetOfaUtilization"] = __nvmlDeviceGetOfaUtilization + data["__nvmlDeviceGetOfaUtilization"] = <_cyb_intptr_t>__nvmlDeviceGetOfaUtilization global __nvmlDeviceGetFBCStats - data["__nvmlDeviceGetFBCStats"] = __nvmlDeviceGetFBCStats + data["__nvmlDeviceGetFBCStats"] = <_cyb_intptr_t>__nvmlDeviceGetFBCStats global __nvmlDeviceGetFBCSessions - data["__nvmlDeviceGetFBCSessions"] = __nvmlDeviceGetFBCSessions + data["__nvmlDeviceGetFBCSessions"] = <_cyb_intptr_t>__nvmlDeviceGetFBCSessions global __nvmlDeviceGetDriverModel_v2 - data["__nvmlDeviceGetDriverModel_v2"] = __nvmlDeviceGetDriverModel_v2 + data["__nvmlDeviceGetDriverModel_v2"] = <_cyb_intptr_t>__nvmlDeviceGetDriverModel_v2 global __nvmlDeviceGetVbiosVersion - data["__nvmlDeviceGetVbiosVersion"] = __nvmlDeviceGetVbiosVersion + data["__nvmlDeviceGetVbiosVersion"] = <_cyb_intptr_t>__nvmlDeviceGetVbiosVersion global __nvmlDeviceGetBridgeChipInfo - data["__nvmlDeviceGetBridgeChipInfo"] = __nvmlDeviceGetBridgeChipInfo + data["__nvmlDeviceGetBridgeChipInfo"] = <_cyb_intptr_t>__nvmlDeviceGetBridgeChipInfo global __nvmlDeviceGetComputeRunningProcesses_v3 - data["__nvmlDeviceGetComputeRunningProcesses_v3"] = __nvmlDeviceGetComputeRunningProcesses_v3 + data["__nvmlDeviceGetComputeRunningProcesses_v3"] = <_cyb_intptr_t>__nvmlDeviceGetComputeRunningProcesses_v3 global __nvmlDeviceGetGraphicsRunningProcesses_v3 - data["__nvmlDeviceGetGraphicsRunningProcesses_v3"] = __nvmlDeviceGetGraphicsRunningProcesses_v3 + data["__nvmlDeviceGetGraphicsRunningProcesses_v3"] = <_cyb_intptr_t>__nvmlDeviceGetGraphicsRunningProcesses_v3 global __nvmlDeviceGetMPSComputeRunningProcesses_v3 - data["__nvmlDeviceGetMPSComputeRunningProcesses_v3"] = __nvmlDeviceGetMPSComputeRunningProcesses_v3 + data["__nvmlDeviceGetMPSComputeRunningProcesses_v3"] = <_cyb_intptr_t>__nvmlDeviceGetMPSComputeRunningProcesses_v3 global __nvmlDeviceGetRunningProcessDetailList - data["__nvmlDeviceGetRunningProcessDetailList"] = __nvmlDeviceGetRunningProcessDetailList + data["__nvmlDeviceGetRunningProcessDetailList"] = <_cyb_intptr_t>__nvmlDeviceGetRunningProcessDetailList global __nvmlDeviceOnSameBoard - data["__nvmlDeviceOnSameBoard"] = __nvmlDeviceOnSameBoard + data["__nvmlDeviceOnSameBoard"] = <_cyb_intptr_t>__nvmlDeviceOnSameBoard global __nvmlDeviceGetAPIRestriction - data["__nvmlDeviceGetAPIRestriction"] = __nvmlDeviceGetAPIRestriction + data["__nvmlDeviceGetAPIRestriction"] = <_cyb_intptr_t>__nvmlDeviceGetAPIRestriction global __nvmlDeviceGetSamples - data["__nvmlDeviceGetSamples"] = __nvmlDeviceGetSamples + data["__nvmlDeviceGetSamples"] = <_cyb_intptr_t>__nvmlDeviceGetSamples global __nvmlDeviceGetBAR1MemoryInfo - data["__nvmlDeviceGetBAR1MemoryInfo"] = __nvmlDeviceGetBAR1MemoryInfo + data["__nvmlDeviceGetBAR1MemoryInfo"] = <_cyb_intptr_t>__nvmlDeviceGetBAR1MemoryInfo global __nvmlDeviceGetIrqNum - data["__nvmlDeviceGetIrqNum"] = __nvmlDeviceGetIrqNum + data["__nvmlDeviceGetIrqNum"] = <_cyb_intptr_t>__nvmlDeviceGetIrqNum global __nvmlDeviceGetNumGpuCores - data["__nvmlDeviceGetNumGpuCores"] = __nvmlDeviceGetNumGpuCores + data["__nvmlDeviceGetNumGpuCores"] = <_cyb_intptr_t>__nvmlDeviceGetNumGpuCores global __nvmlDeviceGetPowerSource - data["__nvmlDeviceGetPowerSource"] = __nvmlDeviceGetPowerSource + data["__nvmlDeviceGetPowerSource"] = <_cyb_intptr_t>__nvmlDeviceGetPowerSource global __nvmlDeviceGetMemoryBusWidth - data["__nvmlDeviceGetMemoryBusWidth"] = __nvmlDeviceGetMemoryBusWidth + data["__nvmlDeviceGetMemoryBusWidth"] = <_cyb_intptr_t>__nvmlDeviceGetMemoryBusWidth global __nvmlDeviceGetPcieLinkMaxSpeed - data["__nvmlDeviceGetPcieLinkMaxSpeed"] = __nvmlDeviceGetPcieLinkMaxSpeed + data["__nvmlDeviceGetPcieLinkMaxSpeed"] = <_cyb_intptr_t>__nvmlDeviceGetPcieLinkMaxSpeed global __nvmlDeviceGetPcieSpeed - data["__nvmlDeviceGetPcieSpeed"] = __nvmlDeviceGetPcieSpeed + data["__nvmlDeviceGetPcieSpeed"] = <_cyb_intptr_t>__nvmlDeviceGetPcieSpeed global __nvmlDeviceGetAdaptiveClockInfoStatus - data["__nvmlDeviceGetAdaptiveClockInfoStatus"] = __nvmlDeviceGetAdaptiveClockInfoStatus + data["__nvmlDeviceGetAdaptiveClockInfoStatus"] = <_cyb_intptr_t>__nvmlDeviceGetAdaptiveClockInfoStatus global __nvmlDeviceGetBusType - data["__nvmlDeviceGetBusType"] = __nvmlDeviceGetBusType + data["__nvmlDeviceGetBusType"] = <_cyb_intptr_t>__nvmlDeviceGetBusType global __nvmlDeviceGetGpuFabricInfoV - data["__nvmlDeviceGetGpuFabricInfoV"] = __nvmlDeviceGetGpuFabricInfoV + data["__nvmlDeviceGetGpuFabricInfoV"] = <_cyb_intptr_t>__nvmlDeviceGetGpuFabricInfoV global __nvmlSystemGetConfComputeCapabilities - data["__nvmlSystemGetConfComputeCapabilities"] = __nvmlSystemGetConfComputeCapabilities + data["__nvmlSystemGetConfComputeCapabilities"] = <_cyb_intptr_t>__nvmlSystemGetConfComputeCapabilities global __nvmlSystemGetConfComputeState - data["__nvmlSystemGetConfComputeState"] = __nvmlSystemGetConfComputeState + data["__nvmlSystemGetConfComputeState"] = <_cyb_intptr_t>__nvmlSystemGetConfComputeState global __nvmlDeviceGetConfComputeMemSizeInfo - data["__nvmlDeviceGetConfComputeMemSizeInfo"] = __nvmlDeviceGetConfComputeMemSizeInfo + data["__nvmlDeviceGetConfComputeMemSizeInfo"] = <_cyb_intptr_t>__nvmlDeviceGetConfComputeMemSizeInfo global __nvmlSystemGetConfComputeGpusReadyState - data["__nvmlSystemGetConfComputeGpusReadyState"] = __nvmlSystemGetConfComputeGpusReadyState + data["__nvmlSystemGetConfComputeGpusReadyState"] = <_cyb_intptr_t>__nvmlSystemGetConfComputeGpusReadyState global __nvmlDeviceGetConfComputeProtectedMemoryUsage - data["__nvmlDeviceGetConfComputeProtectedMemoryUsage"] = __nvmlDeviceGetConfComputeProtectedMemoryUsage + data["__nvmlDeviceGetConfComputeProtectedMemoryUsage"] = <_cyb_intptr_t>__nvmlDeviceGetConfComputeProtectedMemoryUsage global __nvmlDeviceGetConfComputeGpuCertificate - data["__nvmlDeviceGetConfComputeGpuCertificate"] = __nvmlDeviceGetConfComputeGpuCertificate + data["__nvmlDeviceGetConfComputeGpuCertificate"] = <_cyb_intptr_t>__nvmlDeviceGetConfComputeGpuCertificate global __nvmlDeviceGetConfComputeGpuAttestationReport - data["__nvmlDeviceGetConfComputeGpuAttestationReport"] = __nvmlDeviceGetConfComputeGpuAttestationReport + data["__nvmlDeviceGetConfComputeGpuAttestationReport"] = <_cyb_intptr_t>__nvmlDeviceGetConfComputeGpuAttestationReport global __nvmlSystemGetConfComputeKeyRotationThresholdInfo - data["__nvmlSystemGetConfComputeKeyRotationThresholdInfo"] = __nvmlSystemGetConfComputeKeyRotationThresholdInfo + data["__nvmlSystemGetConfComputeKeyRotationThresholdInfo"] = <_cyb_intptr_t>__nvmlSystemGetConfComputeKeyRotationThresholdInfo global __nvmlDeviceSetConfComputeUnprotectedMemSize - data["__nvmlDeviceSetConfComputeUnprotectedMemSize"] = __nvmlDeviceSetConfComputeUnprotectedMemSize + data["__nvmlDeviceSetConfComputeUnprotectedMemSize"] = <_cyb_intptr_t>__nvmlDeviceSetConfComputeUnprotectedMemSize global __nvmlSystemSetConfComputeGpusReadyState - data["__nvmlSystemSetConfComputeGpusReadyState"] = __nvmlSystemSetConfComputeGpusReadyState + data["__nvmlSystemSetConfComputeGpusReadyState"] = <_cyb_intptr_t>__nvmlSystemSetConfComputeGpusReadyState global __nvmlSystemSetConfComputeKeyRotationThresholdInfo - data["__nvmlSystemSetConfComputeKeyRotationThresholdInfo"] = __nvmlSystemSetConfComputeKeyRotationThresholdInfo + data["__nvmlSystemSetConfComputeKeyRotationThresholdInfo"] = <_cyb_intptr_t>__nvmlSystemSetConfComputeKeyRotationThresholdInfo global __nvmlSystemGetConfComputeSettings - data["__nvmlSystemGetConfComputeSettings"] = __nvmlSystemGetConfComputeSettings + data["__nvmlSystemGetConfComputeSettings"] = <_cyb_intptr_t>__nvmlSystemGetConfComputeSettings global __nvmlDeviceGetGspFirmwareVersion - data["__nvmlDeviceGetGspFirmwareVersion"] = __nvmlDeviceGetGspFirmwareVersion + data["__nvmlDeviceGetGspFirmwareVersion"] = <_cyb_intptr_t>__nvmlDeviceGetGspFirmwareVersion global __nvmlDeviceGetGspFirmwareMode - data["__nvmlDeviceGetGspFirmwareMode"] = __nvmlDeviceGetGspFirmwareMode + data["__nvmlDeviceGetGspFirmwareMode"] = <_cyb_intptr_t>__nvmlDeviceGetGspFirmwareMode global __nvmlDeviceGetSramEccErrorStatus - data["__nvmlDeviceGetSramEccErrorStatus"] = __nvmlDeviceGetSramEccErrorStatus + data["__nvmlDeviceGetSramEccErrorStatus"] = <_cyb_intptr_t>__nvmlDeviceGetSramEccErrorStatus global __nvmlDeviceGetAccountingMode - data["__nvmlDeviceGetAccountingMode"] = __nvmlDeviceGetAccountingMode + data["__nvmlDeviceGetAccountingMode"] = <_cyb_intptr_t>__nvmlDeviceGetAccountingMode global __nvmlDeviceGetAccountingStats - data["__nvmlDeviceGetAccountingStats"] = __nvmlDeviceGetAccountingStats + data["__nvmlDeviceGetAccountingStats"] = <_cyb_intptr_t>__nvmlDeviceGetAccountingStats global __nvmlDeviceGetAccountingPids - data["__nvmlDeviceGetAccountingPids"] = __nvmlDeviceGetAccountingPids + data["__nvmlDeviceGetAccountingPids"] = <_cyb_intptr_t>__nvmlDeviceGetAccountingPids global __nvmlDeviceGetAccountingBufferSize - data["__nvmlDeviceGetAccountingBufferSize"] = __nvmlDeviceGetAccountingBufferSize + data["__nvmlDeviceGetAccountingBufferSize"] = <_cyb_intptr_t>__nvmlDeviceGetAccountingBufferSize global __nvmlDeviceGetRetiredPages - data["__nvmlDeviceGetRetiredPages"] = __nvmlDeviceGetRetiredPages + data["__nvmlDeviceGetRetiredPages"] = <_cyb_intptr_t>__nvmlDeviceGetRetiredPages global __nvmlDeviceGetRetiredPages_v2 - data["__nvmlDeviceGetRetiredPages_v2"] = __nvmlDeviceGetRetiredPages_v2 + data["__nvmlDeviceGetRetiredPages_v2"] = <_cyb_intptr_t>__nvmlDeviceGetRetiredPages_v2 global __nvmlDeviceGetRetiredPagesPendingStatus - data["__nvmlDeviceGetRetiredPagesPendingStatus"] = __nvmlDeviceGetRetiredPagesPendingStatus + data["__nvmlDeviceGetRetiredPagesPendingStatus"] = <_cyb_intptr_t>__nvmlDeviceGetRetiredPagesPendingStatus global __nvmlDeviceGetRemappedRows - data["__nvmlDeviceGetRemappedRows"] = __nvmlDeviceGetRemappedRows + data["__nvmlDeviceGetRemappedRows"] = <_cyb_intptr_t>__nvmlDeviceGetRemappedRows global __nvmlDeviceGetRowRemapperHistogram - data["__nvmlDeviceGetRowRemapperHistogram"] = __nvmlDeviceGetRowRemapperHistogram + data["__nvmlDeviceGetRowRemapperHistogram"] = <_cyb_intptr_t>__nvmlDeviceGetRowRemapperHistogram global __nvmlDeviceGetArchitecture - data["__nvmlDeviceGetArchitecture"] = __nvmlDeviceGetArchitecture + data["__nvmlDeviceGetArchitecture"] = <_cyb_intptr_t>__nvmlDeviceGetArchitecture global __nvmlDeviceGetClkMonStatus - data["__nvmlDeviceGetClkMonStatus"] = __nvmlDeviceGetClkMonStatus + data["__nvmlDeviceGetClkMonStatus"] = <_cyb_intptr_t>__nvmlDeviceGetClkMonStatus global __nvmlDeviceGetProcessUtilization - data["__nvmlDeviceGetProcessUtilization"] = __nvmlDeviceGetProcessUtilization + data["__nvmlDeviceGetProcessUtilization"] = <_cyb_intptr_t>__nvmlDeviceGetProcessUtilization global __nvmlDeviceGetProcessesUtilizationInfo - data["__nvmlDeviceGetProcessesUtilizationInfo"] = __nvmlDeviceGetProcessesUtilizationInfo + data["__nvmlDeviceGetProcessesUtilizationInfo"] = <_cyb_intptr_t>__nvmlDeviceGetProcessesUtilizationInfo global __nvmlDeviceGetPlatformInfo - data["__nvmlDeviceGetPlatformInfo"] = __nvmlDeviceGetPlatformInfo + data["__nvmlDeviceGetPlatformInfo"] = <_cyb_intptr_t>__nvmlDeviceGetPlatformInfo global __nvmlUnitSetLedState - data["__nvmlUnitSetLedState"] = __nvmlUnitSetLedState + data["__nvmlUnitSetLedState"] = <_cyb_intptr_t>__nvmlUnitSetLedState global __nvmlDeviceSetPersistenceMode - data["__nvmlDeviceSetPersistenceMode"] = __nvmlDeviceSetPersistenceMode + data["__nvmlDeviceSetPersistenceMode"] = <_cyb_intptr_t>__nvmlDeviceSetPersistenceMode global __nvmlDeviceSetComputeMode - data["__nvmlDeviceSetComputeMode"] = __nvmlDeviceSetComputeMode + data["__nvmlDeviceSetComputeMode"] = <_cyb_intptr_t>__nvmlDeviceSetComputeMode global __nvmlDeviceSetEccMode - data["__nvmlDeviceSetEccMode"] = __nvmlDeviceSetEccMode + data["__nvmlDeviceSetEccMode"] = <_cyb_intptr_t>__nvmlDeviceSetEccMode global __nvmlDeviceClearEccErrorCounts - data["__nvmlDeviceClearEccErrorCounts"] = __nvmlDeviceClearEccErrorCounts + data["__nvmlDeviceClearEccErrorCounts"] = <_cyb_intptr_t>__nvmlDeviceClearEccErrorCounts global __nvmlDeviceSetDriverModel - data["__nvmlDeviceSetDriverModel"] = __nvmlDeviceSetDriverModel + data["__nvmlDeviceSetDriverModel"] = <_cyb_intptr_t>__nvmlDeviceSetDriverModel global __nvmlDeviceSetGpuLockedClocks - data["__nvmlDeviceSetGpuLockedClocks"] = __nvmlDeviceSetGpuLockedClocks + data["__nvmlDeviceSetGpuLockedClocks"] = <_cyb_intptr_t>__nvmlDeviceSetGpuLockedClocks global __nvmlDeviceResetGpuLockedClocks - data["__nvmlDeviceResetGpuLockedClocks"] = __nvmlDeviceResetGpuLockedClocks + data["__nvmlDeviceResetGpuLockedClocks"] = <_cyb_intptr_t>__nvmlDeviceResetGpuLockedClocks global __nvmlDeviceSetMemoryLockedClocks - data["__nvmlDeviceSetMemoryLockedClocks"] = __nvmlDeviceSetMemoryLockedClocks + data["__nvmlDeviceSetMemoryLockedClocks"] = <_cyb_intptr_t>__nvmlDeviceSetMemoryLockedClocks global __nvmlDeviceResetMemoryLockedClocks - data["__nvmlDeviceResetMemoryLockedClocks"] = __nvmlDeviceResetMemoryLockedClocks + data["__nvmlDeviceResetMemoryLockedClocks"] = <_cyb_intptr_t>__nvmlDeviceResetMemoryLockedClocks global __nvmlDeviceSetAutoBoostedClocksEnabled - data["__nvmlDeviceSetAutoBoostedClocksEnabled"] = __nvmlDeviceSetAutoBoostedClocksEnabled + data["__nvmlDeviceSetAutoBoostedClocksEnabled"] = <_cyb_intptr_t>__nvmlDeviceSetAutoBoostedClocksEnabled global __nvmlDeviceSetDefaultAutoBoostedClocksEnabled - data["__nvmlDeviceSetDefaultAutoBoostedClocksEnabled"] = __nvmlDeviceSetDefaultAutoBoostedClocksEnabled + data["__nvmlDeviceSetDefaultAutoBoostedClocksEnabled"] = <_cyb_intptr_t>__nvmlDeviceSetDefaultAutoBoostedClocksEnabled global __nvmlDeviceSetDefaultFanSpeed_v2 - data["__nvmlDeviceSetDefaultFanSpeed_v2"] = __nvmlDeviceSetDefaultFanSpeed_v2 + data["__nvmlDeviceSetDefaultFanSpeed_v2"] = <_cyb_intptr_t>__nvmlDeviceSetDefaultFanSpeed_v2 global __nvmlDeviceSetFanControlPolicy - data["__nvmlDeviceSetFanControlPolicy"] = __nvmlDeviceSetFanControlPolicy + data["__nvmlDeviceSetFanControlPolicy"] = <_cyb_intptr_t>__nvmlDeviceSetFanControlPolicy global __nvmlDeviceSetTemperatureThreshold - data["__nvmlDeviceSetTemperatureThreshold"] = __nvmlDeviceSetTemperatureThreshold + data["__nvmlDeviceSetTemperatureThreshold"] = <_cyb_intptr_t>__nvmlDeviceSetTemperatureThreshold global __nvmlDeviceSetGpuOperationMode - data["__nvmlDeviceSetGpuOperationMode"] = __nvmlDeviceSetGpuOperationMode + data["__nvmlDeviceSetGpuOperationMode"] = <_cyb_intptr_t>__nvmlDeviceSetGpuOperationMode global __nvmlDeviceSetAPIRestriction - data["__nvmlDeviceSetAPIRestriction"] = __nvmlDeviceSetAPIRestriction + data["__nvmlDeviceSetAPIRestriction"] = <_cyb_intptr_t>__nvmlDeviceSetAPIRestriction global __nvmlDeviceSetFanSpeed_v2 - data["__nvmlDeviceSetFanSpeed_v2"] = __nvmlDeviceSetFanSpeed_v2 + data["__nvmlDeviceSetFanSpeed_v2"] = <_cyb_intptr_t>__nvmlDeviceSetFanSpeed_v2 global __nvmlDeviceSetAccountingMode - data["__nvmlDeviceSetAccountingMode"] = __nvmlDeviceSetAccountingMode + data["__nvmlDeviceSetAccountingMode"] = <_cyb_intptr_t>__nvmlDeviceSetAccountingMode global __nvmlDeviceClearAccountingPids - data["__nvmlDeviceClearAccountingPids"] = __nvmlDeviceClearAccountingPids + data["__nvmlDeviceClearAccountingPids"] = <_cyb_intptr_t>__nvmlDeviceClearAccountingPids global __nvmlDeviceSetPowerManagementLimit_v2 - data["__nvmlDeviceSetPowerManagementLimit_v2"] = __nvmlDeviceSetPowerManagementLimit_v2 + data["__nvmlDeviceSetPowerManagementLimit_v2"] = <_cyb_intptr_t>__nvmlDeviceSetPowerManagementLimit_v2 global __nvmlDeviceGetNvLinkState - data["__nvmlDeviceGetNvLinkState"] = __nvmlDeviceGetNvLinkState + data["__nvmlDeviceGetNvLinkState"] = <_cyb_intptr_t>__nvmlDeviceGetNvLinkState global __nvmlDeviceGetNvLinkVersion - data["__nvmlDeviceGetNvLinkVersion"] = __nvmlDeviceGetNvLinkVersion + data["__nvmlDeviceGetNvLinkVersion"] = <_cyb_intptr_t>__nvmlDeviceGetNvLinkVersion global __nvmlDeviceGetNvLinkCapability - data["__nvmlDeviceGetNvLinkCapability"] = __nvmlDeviceGetNvLinkCapability + data["__nvmlDeviceGetNvLinkCapability"] = <_cyb_intptr_t>__nvmlDeviceGetNvLinkCapability global __nvmlDeviceGetNvLinkRemotePciInfo_v2 - data["__nvmlDeviceGetNvLinkRemotePciInfo_v2"] = __nvmlDeviceGetNvLinkRemotePciInfo_v2 + data["__nvmlDeviceGetNvLinkRemotePciInfo_v2"] = <_cyb_intptr_t>__nvmlDeviceGetNvLinkRemotePciInfo_v2 global __nvmlDeviceGetNvLinkErrorCounter - data["__nvmlDeviceGetNvLinkErrorCounter"] = __nvmlDeviceGetNvLinkErrorCounter + data["__nvmlDeviceGetNvLinkErrorCounter"] = <_cyb_intptr_t>__nvmlDeviceGetNvLinkErrorCounter global __nvmlDeviceResetNvLinkErrorCounters - data["__nvmlDeviceResetNvLinkErrorCounters"] = __nvmlDeviceResetNvLinkErrorCounters + data["__nvmlDeviceResetNvLinkErrorCounters"] = <_cyb_intptr_t>__nvmlDeviceResetNvLinkErrorCounters global __nvmlDeviceGetNvLinkRemoteDeviceType - data["__nvmlDeviceGetNvLinkRemoteDeviceType"] = __nvmlDeviceGetNvLinkRemoteDeviceType + data["__nvmlDeviceGetNvLinkRemoteDeviceType"] = <_cyb_intptr_t>__nvmlDeviceGetNvLinkRemoteDeviceType global __nvmlDeviceSetNvLinkDeviceLowPowerThreshold - data["__nvmlDeviceSetNvLinkDeviceLowPowerThreshold"] = __nvmlDeviceSetNvLinkDeviceLowPowerThreshold + data["__nvmlDeviceSetNvLinkDeviceLowPowerThreshold"] = <_cyb_intptr_t>__nvmlDeviceSetNvLinkDeviceLowPowerThreshold global __nvmlSystemSetNvlinkBwMode - data["__nvmlSystemSetNvlinkBwMode"] = __nvmlSystemSetNvlinkBwMode + data["__nvmlSystemSetNvlinkBwMode"] = <_cyb_intptr_t>__nvmlSystemSetNvlinkBwMode global __nvmlSystemGetNvlinkBwMode - data["__nvmlSystemGetNvlinkBwMode"] = __nvmlSystemGetNvlinkBwMode + data["__nvmlSystemGetNvlinkBwMode"] = <_cyb_intptr_t>__nvmlSystemGetNvlinkBwMode global __nvmlDeviceGetNvlinkSupportedBwModes - data["__nvmlDeviceGetNvlinkSupportedBwModes"] = __nvmlDeviceGetNvlinkSupportedBwModes + data["__nvmlDeviceGetNvlinkSupportedBwModes"] = <_cyb_intptr_t>__nvmlDeviceGetNvlinkSupportedBwModes global __nvmlDeviceGetNvlinkBwMode - data["__nvmlDeviceGetNvlinkBwMode"] = __nvmlDeviceGetNvlinkBwMode + data["__nvmlDeviceGetNvlinkBwMode"] = <_cyb_intptr_t>__nvmlDeviceGetNvlinkBwMode global __nvmlDeviceSetNvlinkBwMode - data["__nvmlDeviceSetNvlinkBwMode"] = __nvmlDeviceSetNvlinkBwMode + data["__nvmlDeviceSetNvlinkBwMode"] = <_cyb_intptr_t>__nvmlDeviceSetNvlinkBwMode global __nvmlEventSetCreate - data["__nvmlEventSetCreate"] = __nvmlEventSetCreate + data["__nvmlEventSetCreate"] = <_cyb_intptr_t>__nvmlEventSetCreate global __nvmlDeviceRegisterEvents - data["__nvmlDeviceRegisterEvents"] = __nvmlDeviceRegisterEvents + data["__nvmlDeviceRegisterEvents"] = <_cyb_intptr_t>__nvmlDeviceRegisterEvents global __nvmlDeviceGetSupportedEventTypes - data["__nvmlDeviceGetSupportedEventTypes"] = __nvmlDeviceGetSupportedEventTypes + data["__nvmlDeviceGetSupportedEventTypes"] = <_cyb_intptr_t>__nvmlDeviceGetSupportedEventTypes global __nvmlEventSetWait_v2 - data["__nvmlEventSetWait_v2"] = __nvmlEventSetWait_v2 + data["__nvmlEventSetWait_v2"] = <_cyb_intptr_t>__nvmlEventSetWait_v2 global __nvmlEventSetFree - data["__nvmlEventSetFree"] = __nvmlEventSetFree + data["__nvmlEventSetFree"] = <_cyb_intptr_t>__nvmlEventSetFree global __nvmlSystemEventSetCreate - data["__nvmlSystemEventSetCreate"] = __nvmlSystemEventSetCreate + data["__nvmlSystemEventSetCreate"] = <_cyb_intptr_t>__nvmlSystemEventSetCreate global __nvmlSystemEventSetFree - data["__nvmlSystemEventSetFree"] = __nvmlSystemEventSetFree + data["__nvmlSystemEventSetFree"] = <_cyb_intptr_t>__nvmlSystemEventSetFree global __nvmlSystemRegisterEvents - data["__nvmlSystemRegisterEvents"] = __nvmlSystemRegisterEvents + data["__nvmlSystemRegisterEvents"] = <_cyb_intptr_t>__nvmlSystemRegisterEvents global __nvmlSystemEventSetWait - data["__nvmlSystemEventSetWait"] = __nvmlSystemEventSetWait + data["__nvmlSystemEventSetWait"] = <_cyb_intptr_t>__nvmlSystemEventSetWait global __nvmlDeviceModifyDrainState - data["__nvmlDeviceModifyDrainState"] = __nvmlDeviceModifyDrainState + data["__nvmlDeviceModifyDrainState"] = <_cyb_intptr_t>__nvmlDeviceModifyDrainState global __nvmlDeviceQueryDrainState - data["__nvmlDeviceQueryDrainState"] = __nvmlDeviceQueryDrainState + data["__nvmlDeviceQueryDrainState"] = <_cyb_intptr_t>__nvmlDeviceQueryDrainState global __nvmlDeviceRemoveGpu_v2 - data["__nvmlDeviceRemoveGpu_v2"] = __nvmlDeviceRemoveGpu_v2 + data["__nvmlDeviceRemoveGpu_v2"] = <_cyb_intptr_t>__nvmlDeviceRemoveGpu_v2 global __nvmlDeviceDiscoverGpus - data["__nvmlDeviceDiscoverGpus"] = __nvmlDeviceDiscoverGpus + data["__nvmlDeviceDiscoverGpus"] = <_cyb_intptr_t>__nvmlDeviceDiscoverGpus global __nvmlDeviceGetFieldValues - data["__nvmlDeviceGetFieldValues"] = __nvmlDeviceGetFieldValues + data["__nvmlDeviceGetFieldValues"] = <_cyb_intptr_t>__nvmlDeviceGetFieldValues global __nvmlDeviceClearFieldValues - data["__nvmlDeviceClearFieldValues"] = __nvmlDeviceClearFieldValues + data["__nvmlDeviceClearFieldValues"] = <_cyb_intptr_t>__nvmlDeviceClearFieldValues global __nvmlDeviceGetVirtualizationMode - data["__nvmlDeviceGetVirtualizationMode"] = __nvmlDeviceGetVirtualizationMode + data["__nvmlDeviceGetVirtualizationMode"] = <_cyb_intptr_t>__nvmlDeviceGetVirtualizationMode global __nvmlDeviceGetHostVgpuMode - data["__nvmlDeviceGetHostVgpuMode"] = __nvmlDeviceGetHostVgpuMode + data["__nvmlDeviceGetHostVgpuMode"] = <_cyb_intptr_t>__nvmlDeviceGetHostVgpuMode global __nvmlDeviceSetVirtualizationMode - data["__nvmlDeviceSetVirtualizationMode"] = __nvmlDeviceSetVirtualizationMode + data["__nvmlDeviceSetVirtualizationMode"] = <_cyb_intptr_t>__nvmlDeviceSetVirtualizationMode global __nvmlDeviceGetVgpuHeterogeneousMode - data["__nvmlDeviceGetVgpuHeterogeneousMode"] = __nvmlDeviceGetVgpuHeterogeneousMode + data["__nvmlDeviceGetVgpuHeterogeneousMode"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuHeterogeneousMode global __nvmlDeviceSetVgpuHeterogeneousMode - data["__nvmlDeviceSetVgpuHeterogeneousMode"] = __nvmlDeviceSetVgpuHeterogeneousMode + data["__nvmlDeviceSetVgpuHeterogeneousMode"] = <_cyb_intptr_t>__nvmlDeviceSetVgpuHeterogeneousMode global __nvmlVgpuInstanceGetPlacementId - data["__nvmlVgpuInstanceGetPlacementId"] = __nvmlVgpuInstanceGetPlacementId + data["__nvmlVgpuInstanceGetPlacementId"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetPlacementId global __nvmlDeviceGetVgpuTypeSupportedPlacements - data["__nvmlDeviceGetVgpuTypeSupportedPlacements"] = __nvmlDeviceGetVgpuTypeSupportedPlacements + data["__nvmlDeviceGetVgpuTypeSupportedPlacements"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuTypeSupportedPlacements global __nvmlDeviceGetVgpuTypeCreatablePlacements - data["__nvmlDeviceGetVgpuTypeCreatablePlacements"] = __nvmlDeviceGetVgpuTypeCreatablePlacements + data["__nvmlDeviceGetVgpuTypeCreatablePlacements"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuTypeCreatablePlacements global __nvmlVgpuTypeGetGspHeapSize - data["__nvmlVgpuTypeGetGspHeapSize"] = __nvmlVgpuTypeGetGspHeapSize + data["__nvmlVgpuTypeGetGspHeapSize"] = <_cyb_intptr_t>__nvmlVgpuTypeGetGspHeapSize global __nvmlVgpuTypeGetFbReservation - data["__nvmlVgpuTypeGetFbReservation"] = __nvmlVgpuTypeGetFbReservation + data["__nvmlVgpuTypeGetFbReservation"] = <_cyb_intptr_t>__nvmlVgpuTypeGetFbReservation global __nvmlVgpuInstanceGetRuntimeStateSize - data["__nvmlVgpuInstanceGetRuntimeStateSize"] = __nvmlVgpuInstanceGetRuntimeStateSize + data["__nvmlVgpuInstanceGetRuntimeStateSize"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetRuntimeStateSize global __nvmlDeviceSetVgpuCapabilities - data["__nvmlDeviceSetVgpuCapabilities"] = __nvmlDeviceSetVgpuCapabilities + data["__nvmlDeviceSetVgpuCapabilities"] = <_cyb_intptr_t>__nvmlDeviceSetVgpuCapabilities global __nvmlDeviceGetGridLicensableFeatures_v4 - data["__nvmlDeviceGetGridLicensableFeatures_v4"] = __nvmlDeviceGetGridLicensableFeatures_v4 + data["__nvmlDeviceGetGridLicensableFeatures_v4"] = <_cyb_intptr_t>__nvmlDeviceGetGridLicensableFeatures_v4 global __nvmlGetVgpuDriverCapabilities - data["__nvmlGetVgpuDriverCapabilities"] = __nvmlGetVgpuDriverCapabilities + data["__nvmlGetVgpuDriverCapabilities"] = <_cyb_intptr_t>__nvmlGetVgpuDriverCapabilities global __nvmlDeviceGetVgpuCapabilities - data["__nvmlDeviceGetVgpuCapabilities"] = __nvmlDeviceGetVgpuCapabilities + data["__nvmlDeviceGetVgpuCapabilities"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuCapabilities global __nvmlDeviceGetSupportedVgpus - data["__nvmlDeviceGetSupportedVgpus"] = __nvmlDeviceGetSupportedVgpus + data["__nvmlDeviceGetSupportedVgpus"] = <_cyb_intptr_t>__nvmlDeviceGetSupportedVgpus global __nvmlDeviceGetCreatableVgpus - data["__nvmlDeviceGetCreatableVgpus"] = __nvmlDeviceGetCreatableVgpus + data["__nvmlDeviceGetCreatableVgpus"] = <_cyb_intptr_t>__nvmlDeviceGetCreatableVgpus global __nvmlVgpuTypeGetClass - data["__nvmlVgpuTypeGetClass"] = __nvmlVgpuTypeGetClass + data["__nvmlVgpuTypeGetClass"] = <_cyb_intptr_t>__nvmlVgpuTypeGetClass global __nvmlVgpuTypeGetName - data["__nvmlVgpuTypeGetName"] = __nvmlVgpuTypeGetName + data["__nvmlVgpuTypeGetName"] = <_cyb_intptr_t>__nvmlVgpuTypeGetName global __nvmlVgpuTypeGetGpuInstanceProfileId - data["__nvmlVgpuTypeGetGpuInstanceProfileId"] = __nvmlVgpuTypeGetGpuInstanceProfileId + data["__nvmlVgpuTypeGetGpuInstanceProfileId"] = <_cyb_intptr_t>__nvmlVgpuTypeGetGpuInstanceProfileId global __nvmlVgpuTypeGetDeviceID - data["__nvmlVgpuTypeGetDeviceID"] = __nvmlVgpuTypeGetDeviceID + data["__nvmlVgpuTypeGetDeviceID"] = <_cyb_intptr_t>__nvmlVgpuTypeGetDeviceID global __nvmlVgpuTypeGetFramebufferSize - data["__nvmlVgpuTypeGetFramebufferSize"] = __nvmlVgpuTypeGetFramebufferSize + data["__nvmlVgpuTypeGetFramebufferSize"] = <_cyb_intptr_t>__nvmlVgpuTypeGetFramebufferSize global __nvmlVgpuTypeGetNumDisplayHeads - data["__nvmlVgpuTypeGetNumDisplayHeads"] = __nvmlVgpuTypeGetNumDisplayHeads + data["__nvmlVgpuTypeGetNumDisplayHeads"] = <_cyb_intptr_t>__nvmlVgpuTypeGetNumDisplayHeads global __nvmlVgpuTypeGetResolution - data["__nvmlVgpuTypeGetResolution"] = __nvmlVgpuTypeGetResolution + data["__nvmlVgpuTypeGetResolution"] = <_cyb_intptr_t>__nvmlVgpuTypeGetResolution global __nvmlVgpuTypeGetLicense - data["__nvmlVgpuTypeGetLicense"] = __nvmlVgpuTypeGetLicense + data["__nvmlVgpuTypeGetLicense"] = <_cyb_intptr_t>__nvmlVgpuTypeGetLicense global __nvmlVgpuTypeGetFrameRateLimit - data["__nvmlVgpuTypeGetFrameRateLimit"] = __nvmlVgpuTypeGetFrameRateLimit + data["__nvmlVgpuTypeGetFrameRateLimit"] = <_cyb_intptr_t>__nvmlVgpuTypeGetFrameRateLimit global __nvmlVgpuTypeGetMaxInstances - data["__nvmlVgpuTypeGetMaxInstances"] = __nvmlVgpuTypeGetMaxInstances + data["__nvmlVgpuTypeGetMaxInstances"] = <_cyb_intptr_t>__nvmlVgpuTypeGetMaxInstances global __nvmlVgpuTypeGetMaxInstancesPerVm - data["__nvmlVgpuTypeGetMaxInstancesPerVm"] = __nvmlVgpuTypeGetMaxInstancesPerVm + data["__nvmlVgpuTypeGetMaxInstancesPerVm"] = <_cyb_intptr_t>__nvmlVgpuTypeGetMaxInstancesPerVm global __nvmlVgpuTypeGetBAR1Info - data["__nvmlVgpuTypeGetBAR1Info"] = __nvmlVgpuTypeGetBAR1Info + data["__nvmlVgpuTypeGetBAR1Info"] = <_cyb_intptr_t>__nvmlVgpuTypeGetBAR1Info global __nvmlDeviceGetActiveVgpus - data["__nvmlDeviceGetActiveVgpus"] = __nvmlDeviceGetActiveVgpus + data["__nvmlDeviceGetActiveVgpus"] = <_cyb_intptr_t>__nvmlDeviceGetActiveVgpus global __nvmlVgpuInstanceGetVmID - data["__nvmlVgpuInstanceGetVmID"] = __nvmlVgpuInstanceGetVmID + data["__nvmlVgpuInstanceGetVmID"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetVmID global __nvmlVgpuInstanceGetUUID - data["__nvmlVgpuInstanceGetUUID"] = __nvmlVgpuInstanceGetUUID + data["__nvmlVgpuInstanceGetUUID"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetUUID global __nvmlVgpuInstanceGetVmDriverVersion - data["__nvmlVgpuInstanceGetVmDriverVersion"] = __nvmlVgpuInstanceGetVmDriverVersion + data["__nvmlVgpuInstanceGetVmDriverVersion"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetVmDriverVersion global __nvmlVgpuInstanceGetFbUsage - data["__nvmlVgpuInstanceGetFbUsage"] = __nvmlVgpuInstanceGetFbUsage + data["__nvmlVgpuInstanceGetFbUsage"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetFbUsage global __nvmlVgpuInstanceGetLicenseStatus - data["__nvmlVgpuInstanceGetLicenseStatus"] = __nvmlVgpuInstanceGetLicenseStatus + data["__nvmlVgpuInstanceGetLicenseStatus"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetLicenseStatus global __nvmlVgpuInstanceGetType - data["__nvmlVgpuInstanceGetType"] = __nvmlVgpuInstanceGetType + data["__nvmlVgpuInstanceGetType"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetType global __nvmlVgpuInstanceGetFrameRateLimit - data["__nvmlVgpuInstanceGetFrameRateLimit"] = __nvmlVgpuInstanceGetFrameRateLimit + data["__nvmlVgpuInstanceGetFrameRateLimit"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetFrameRateLimit global __nvmlVgpuInstanceGetEccMode - data["__nvmlVgpuInstanceGetEccMode"] = __nvmlVgpuInstanceGetEccMode + data["__nvmlVgpuInstanceGetEccMode"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetEccMode global __nvmlVgpuInstanceGetEncoderCapacity - data["__nvmlVgpuInstanceGetEncoderCapacity"] = __nvmlVgpuInstanceGetEncoderCapacity + data["__nvmlVgpuInstanceGetEncoderCapacity"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetEncoderCapacity global __nvmlVgpuInstanceSetEncoderCapacity - data["__nvmlVgpuInstanceSetEncoderCapacity"] = __nvmlVgpuInstanceSetEncoderCapacity + data["__nvmlVgpuInstanceSetEncoderCapacity"] = <_cyb_intptr_t>__nvmlVgpuInstanceSetEncoderCapacity global __nvmlVgpuInstanceGetEncoderStats - data["__nvmlVgpuInstanceGetEncoderStats"] = __nvmlVgpuInstanceGetEncoderStats + data["__nvmlVgpuInstanceGetEncoderStats"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetEncoderStats global __nvmlVgpuInstanceGetEncoderSessions - data["__nvmlVgpuInstanceGetEncoderSessions"] = __nvmlVgpuInstanceGetEncoderSessions + data["__nvmlVgpuInstanceGetEncoderSessions"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetEncoderSessions global __nvmlVgpuInstanceGetFBCStats - data["__nvmlVgpuInstanceGetFBCStats"] = __nvmlVgpuInstanceGetFBCStats + data["__nvmlVgpuInstanceGetFBCStats"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetFBCStats global __nvmlVgpuInstanceGetFBCSessions - data["__nvmlVgpuInstanceGetFBCSessions"] = __nvmlVgpuInstanceGetFBCSessions + data["__nvmlVgpuInstanceGetFBCSessions"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetFBCSessions global __nvmlVgpuInstanceGetGpuInstanceId - data["__nvmlVgpuInstanceGetGpuInstanceId"] = __nvmlVgpuInstanceGetGpuInstanceId + data["__nvmlVgpuInstanceGetGpuInstanceId"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetGpuInstanceId global __nvmlVgpuInstanceGetGpuPciId - data["__nvmlVgpuInstanceGetGpuPciId"] = __nvmlVgpuInstanceGetGpuPciId + data["__nvmlVgpuInstanceGetGpuPciId"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetGpuPciId global __nvmlVgpuTypeGetCapabilities - data["__nvmlVgpuTypeGetCapabilities"] = __nvmlVgpuTypeGetCapabilities + data["__nvmlVgpuTypeGetCapabilities"] = <_cyb_intptr_t>__nvmlVgpuTypeGetCapabilities global __nvmlVgpuInstanceGetMdevUUID - data["__nvmlVgpuInstanceGetMdevUUID"] = __nvmlVgpuInstanceGetMdevUUID + data["__nvmlVgpuInstanceGetMdevUUID"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetMdevUUID global __nvmlGpuInstanceGetCreatableVgpus - data["__nvmlGpuInstanceGetCreatableVgpus"] = __nvmlGpuInstanceGetCreatableVgpus + data["__nvmlGpuInstanceGetCreatableVgpus"] = <_cyb_intptr_t>__nvmlGpuInstanceGetCreatableVgpus global __nvmlVgpuTypeGetMaxInstancesPerGpuInstance - data["__nvmlVgpuTypeGetMaxInstancesPerGpuInstance"] = __nvmlVgpuTypeGetMaxInstancesPerGpuInstance + data["__nvmlVgpuTypeGetMaxInstancesPerGpuInstance"] = <_cyb_intptr_t>__nvmlVgpuTypeGetMaxInstancesPerGpuInstance global __nvmlGpuInstanceGetActiveVgpus - data["__nvmlGpuInstanceGetActiveVgpus"] = __nvmlGpuInstanceGetActiveVgpus + data["__nvmlGpuInstanceGetActiveVgpus"] = <_cyb_intptr_t>__nvmlGpuInstanceGetActiveVgpus global __nvmlGpuInstanceSetVgpuSchedulerState - data["__nvmlGpuInstanceSetVgpuSchedulerState"] = __nvmlGpuInstanceSetVgpuSchedulerState + data["__nvmlGpuInstanceSetVgpuSchedulerState"] = <_cyb_intptr_t>__nvmlGpuInstanceSetVgpuSchedulerState global __nvmlGpuInstanceGetVgpuSchedulerState - data["__nvmlGpuInstanceGetVgpuSchedulerState"] = __nvmlGpuInstanceGetVgpuSchedulerState + data["__nvmlGpuInstanceGetVgpuSchedulerState"] = <_cyb_intptr_t>__nvmlGpuInstanceGetVgpuSchedulerState global __nvmlGpuInstanceGetVgpuSchedulerLog - data["__nvmlGpuInstanceGetVgpuSchedulerLog"] = __nvmlGpuInstanceGetVgpuSchedulerLog + data["__nvmlGpuInstanceGetVgpuSchedulerLog"] = <_cyb_intptr_t>__nvmlGpuInstanceGetVgpuSchedulerLog global __nvmlGpuInstanceGetVgpuTypeCreatablePlacements - data["__nvmlGpuInstanceGetVgpuTypeCreatablePlacements"] = __nvmlGpuInstanceGetVgpuTypeCreatablePlacements + data["__nvmlGpuInstanceGetVgpuTypeCreatablePlacements"] = <_cyb_intptr_t>__nvmlGpuInstanceGetVgpuTypeCreatablePlacements global __nvmlGpuInstanceGetVgpuHeterogeneousMode - data["__nvmlGpuInstanceGetVgpuHeterogeneousMode"] = __nvmlGpuInstanceGetVgpuHeterogeneousMode + data["__nvmlGpuInstanceGetVgpuHeterogeneousMode"] = <_cyb_intptr_t>__nvmlGpuInstanceGetVgpuHeterogeneousMode global __nvmlGpuInstanceSetVgpuHeterogeneousMode - data["__nvmlGpuInstanceSetVgpuHeterogeneousMode"] = __nvmlGpuInstanceSetVgpuHeterogeneousMode + data["__nvmlGpuInstanceSetVgpuHeterogeneousMode"] = <_cyb_intptr_t>__nvmlGpuInstanceSetVgpuHeterogeneousMode global __nvmlVgpuInstanceGetMetadata - data["__nvmlVgpuInstanceGetMetadata"] = __nvmlVgpuInstanceGetMetadata + data["__nvmlVgpuInstanceGetMetadata"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetMetadata global __nvmlDeviceGetVgpuMetadata - data["__nvmlDeviceGetVgpuMetadata"] = __nvmlDeviceGetVgpuMetadata + data["__nvmlDeviceGetVgpuMetadata"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuMetadata global __nvmlGetVgpuCompatibility - data["__nvmlGetVgpuCompatibility"] = __nvmlGetVgpuCompatibility + data["__nvmlGetVgpuCompatibility"] = <_cyb_intptr_t>__nvmlGetVgpuCompatibility global __nvmlDeviceGetPgpuMetadataString - data["__nvmlDeviceGetPgpuMetadataString"] = __nvmlDeviceGetPgpuMetadataString + data["__nvmlDeviceGetPgpuMetadataString"] = <_cyb_intptr_t>__nvmlDeviceGetPgpuMetadataString global __nvmlDeviceGetVgpuSchedulerLog - data["__nvmlDeviceGetVgpuSchedulerLog"] = __nvmlDeviceGetVgpuSchedulerLog + data["__nvmlDeviceGetVgpuSchedulerLog"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuSchedulerLog global __nvmlDeviceGetVgpuSchedulerState - data["__nvmlDeviceGetVgpuSchedulerState"] = __nvmlDeviceGetVgpuSchedulerState + data["__nvmlDeviceGetVgpuSchedulerState"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuSchedulerState global __nvmlDeviceGetVgpuSchedulerCapabilities - data["__nvmlDeviceGetVgpuSchedulerCapabilities"] = __nvmlDeviceGetVgpuSchedulerCapabilities + data["__nvmlDeviceGetVgpuSchedulerCapabilities"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuSchedulerCapabilities global __nvmlDeviceSetVgpuSchedulerState - data["__nvmlDeviceSetVgpuSchedulerState"] = __nvmlDeviceSetVgpuSchedulerState + data["__nvmlDeviceSetVgpuSchedulerState"] = <_cyb_intptr_t>__nvmlDeviceSetVgpuSchedulerState global __nvmlGetVgpuVersion - data["__nvmlGetVgpuVersion"] = __nvmlGetVgpuVersion + data["__nvmlGetVgpuVersion"] = <_cyb_intptr_t>__nvmlGetVgpuVersion global __nvmlSetVgpuVersion - data["__nvmlSetVgpuVersion"] = __nvmlSetVgpuVersion + data["__nvmlSetVgpuVersion"] = <_cyb_intptr_t>__nvmlSetVgpuVersion global __nvmlDeviceGetVgpuUtilization - data["__nvmlDeviceGetVgpuUtilization"] = __nvmlDeviceGetVgpuUtilization + data["__nvmlDeviceGetVgpuUtilization"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuUtilization global __nvmlDeviceGetVgpuInstancesUtilizationInfo - data["__nvmlDeviceGetVgpuInstancesUtilizationInfo"] = __nvmlDeviceGetVgpuInstancesUtilizationInfo + data["__nvmlDeviceGetVgpuInstancesUtilizationInfo"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuInstancesUtilizationInfo global __nvmlDeviceGetVgpuProcessUtilization - data["__nvmlDeviceGetVgpuProcessUtilization"] = __nvmlDeviceGetVgpuProcessUtilization + data["__nvmlDeviceGetVgpuProcessUtilization"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuProcessUtilization global __nvmlDeviceGetVgpuProcessesUtilizationInfo - data["__nvmlDeviceGetVgpuProcessesUtilizationInfo"] = __nvmlDeviceGetVgpuProcessesUtilizationInfo + data["__nvmlDeviceGetVgpuProcessesUtilizationInfo"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuProcessesUtilizationInfo global __nvmlVgpuInstanceGetAccountingMode - data["__nvmlVgpuInstanceGetAccountingMode"] = __nvmlVgpuInstanceGetAccountingMode + data["__nvmlVgpuInstanceGetAccountingMode"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetAccountingMode global __nvmlVgpuInstanceGetAccountingPids - data["__nvmlVgpuInstanceGetAccountingPids"] = __nvmlVgpuInstanceGetAccountingPids + data["__nvmlVgpuInstanceGetAccountingPids"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetAccountingPids global __nvmlVgpuInstanceGetAccountingStats - data["__nvmlVgpuInstanceGetAccountingStats"] = __nvmlVgpuInstanceGetAccountingStats + data["__nvmlVgpuInstanceGetAccountingStats"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetAccountingStats global __nvmlVgpuInstanceClearAccountingPids - data["__nvmlVgpuInstanceClearAccountingPids"] = __nvmlVgpuInstanceClearAccountingPids + data["__nvmlVgpuInstanceClearAccountingPids"] = <_cyb_intptr_t>__nvmlVgpuInstanceClearAccountingPids global __nvmlVgpuInstanceGetLicenseInfo_v2 - data["__nvmlVgpuInstanceGetLicenseInfo_v2"] = __nvmlVgpuInstanceGetLicenseInfo_v2 + data["__nvmlVgpuInstanceGetLicenseInfo_v2"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetLicenseInfo_v2 global __nvmlGetExcludedDeviceCount - data["__nvmlGetExcludedDeviceCount"] = __nvmlGetExcludedDeviceCount + data["__nvmlGetExcludedDeviceCount"] = <_cyb_intptr_t>__nvmlGetExcludedDeviceCount global __nvmlGetExcludedDeviceInfoByIndex - data["__nvmlGetExcludedDeviceInfoByIndex"] = __nvmlGetExcludedDeviceInfoByIndex + data["__nvmlGetExcludedDeviceInfoByIndex"] = <_cyb_intptr_t>__nvmlGetExcludedDeviceInfoByIndex global __nvmlDeviceSetMigMode - data["__nvmlDeviceSetMigMode"] = __nvmlDeviceSetMigMode + data["__nvmlDeviceSetMigMode"] = <_cyb_intptr_t>__nvmlDeviceSetMigMode global __nvmlDeviceGetMigMode - data["__nvmlDeviceGetMigMode"] = __nvmlDeviceGetMigMode + data["__nvmlDeviceGetMigMode"] = <_cyb_intptr_t>__nvmlDeviceGetMigMode global __nvmlDeviceGetGpuInstanceProfileInfoV - data["__nvmlDeviceGetGpuInstanceProfileInfoV"] = __nvmlDeviceGetGpuInstanceProfileInfoV + data["__nvmlDeviceGetGpuInstanceProfileInfoV"] = <_cyb_intptr_t>__nvmlDeviceGetGpuInstanceProfileInfoV global __nvmlDeviceGetGpuInstancePossiblePlacements_v2 - data["__nvmlDeviceGetGpuInstancePossiblePlacements_v2"] = __nvmlDeviceGetGpuInstancePossiblePlacements_v2 + data["__nvmlDeviceGetGpuInstancePossiblePlacements_v2"] = <_cyb_intptr_t>__nvmlDeviceGetGpuInstancePossiblePlacements_v2 global __nvmlDeviceGetGpuInstanceRemainingCapacity - data["__nvmlDeviceGetGpuInstanceRemainingCapacity"] = __nvmlDeviceGetGpuInstanceRemainingCapacity + data["__nvmlDeviceGetGpuInstanceRemainingCapacity"] = <_cyb_intptr_t>__nvmlDeviceGetGpuInstanceRemainingCapacity global __nvmlDeviceCreateGpuInstance - data["__nvmlDeviceCreateGpuInstance"] = __nvmlDeviceCreateGpuInstance + data["__nvmlDeviceCreateGpuInstance"] = <_cyb_intptr_t>__nvmlDeviceCreateGpuInstance global __nvmlDeviceCreateGpuInstanceWithPlacement - data["__nvmlDeviceCreateGpuInstanceWithPlacement"] = __nvmlDeviceCreateGpuInstanceWithPlacement + data["__nvmlDeviceCreateGpuInstanceWithPlacement"] = <_cyb_intptr_t>__nvmlDeviceCreateGpuInstanceWithPlacement global __nvmlGpuInstanceDestroy - data["__nvmlGpuInstanceDestroy"] = __nvmlGpuInstanceDestroy + data["__nvmlGpuInstanceDestroy"] = <_cyb_intptr_t>__nvmlGpuInstanceDestroy global __nvmlDeviceGetGpuInstances - data["__nvmlDeviceGetGpuInstances"] = __nvmlDeviceGetGpuInstances + data["__nvmlDeviceGetGpuInstances"] = <_cyb_intptr_t>__nvmlDeviceGetGpuInstances global __nvmlDeviceGetGpuInstanceById - data["__nvmlDeviceGetGpuInstanceById"] = __nvmlDeviceGetGpuInstanceById + data["__nvmlDeviceGetGpuInstanceById"] = <_cyb_intptr_t>__nvmlDeviceGetGpuInstanceById global __nvmlGpuInstanceGetInfo - data["__nvmlGpuInstanceGetInfo"] = __nvmlGpuInstanceGetInfo + data["__nvmlGpuInstanceGetInfo"] = <_cyb_intptr_t>__nvmlGpuInstanceGetInfo global __nvmlGpuInstanceGetComputeInstanceProfileInfoV - data["__nvmlGpuInstanceGetComputeInstanceProfileInfoV"] = __nvmlGpuInstanceGetComputeInstanceProfileInfoV + data["__nvmlGpuInstanceGetComputeInstanceProfileInfoV"] = <_cyb_intptr_t>__nvmlGpuInstanceGetComputeInstanceProfileInfoV global __nvmlGpuInstanceGetComputeInstanceRemainingCapacity - data["__nvmlGpuInstanceGetComputeInstanceRemainingCapacity"] = __nvmlGpuInstanceGetComputeInstanceRemainingCapacity + data["__nvmlGpuInstanceGetComputeInstanceRemainingCapacity"] = <_cyb_intptr_t>__nvmlGpuInstanceGetComputeInstanceRemainingCapacity global __nvmlGpuInstanceGetComputeInstancePossiblePlacements - data["__nvmlGpuInstanceGetComputeInstancePossiblePlacements"] = __nvmlGpuInstanceGetComputeInstancePossiblePlacements + data["__nvmlGpuInstanceGetComputeInstancePossiblePlacements"] = <_cyb_intptr_t>__nvmlGpuInstanceGetComputeInstancePossiblePlacements global __nvmlGpuInstanceCreateComputeInstance - data["__nvmlGpuInstanceCreateComputeInstance"] = __nvmlGpuInstanceCreateComputeInstance + data["__nvmlGpuInstanceCreateComputeInstance"] = <_cyb_intptr_t>__nvmlGpuInstanceCreateComputeInstance global __nvmlGpuInstanceCreateComputeInstanceWithPlacement - data["__nvmlGpuInstanceCreateComputeInstanceWithPlacement"] = __nvmlGpuInstanceCreateComputeInstanceWithPlacement + data["__nvmlGpuInstanceCreateComputeInstanceWithPlacement"] = <_cyb_intptr_t>__nvmlGpuInstanceCreateComputeInstanceWithPlacement global __nvmlComputeInstanceDestroy - data["__nvmlComputeInstanceDestroy"] = __nvmlComputeInstanceDestroy + data["__nvmlComputeInstanceDestroy"] = <_cyb_intptr_t>__nvmlComputeInstanceDestroy global __nvmlGpuInstanceGetComputeInstances - data["__nvmlGpuInstanceGetComputeInstances"] = __nvmlGpuInstanceGetComputeInstances + data["__nvmlGpuInstanceGetComputeInstances"] = <_cyb_intptr_t>__nvmlGpuInstanceGetComputeInstances global __nvmlGpuInstanceGetComputeInstanceById - data["__nvmlGpuInstanceGetComputeInstanceById"] = __nvmlGpuInstanceGetComputeInstanceById + data["__nvmlGpuInstanceGetComputeInstanceById"] = <_cyb_intptr_t>__nvmlGpuInstanceGetComputeInstanceById global __nvmlComputeInstanceGetInfo_v2 - data["__nvmlComputeInstanceGetInfo_v2"] = __nvmlComputeInstanceGetInfo_v2 + data["__nvmlComputeInstanceGetInfo_v2"] = <_cyb_intptr_t>__nvmlComputeInstanceGetInfo_v2 global __nvmlDeviceIsMigDeviceHandle - data["__nvmlDeviceIsMigDeviceHandle"] = __nvmlDeviceIsMigDeviceHandle + data["__nvmlDeviceIsMigDeviceHandle"] = <_cyb_intptr_t>__nvmlDeviceIsMigDeviceHandle global __nvmlDeviceGetGpuInstanceId - data["__nvmlDeviceGetGpuInstanceId"] = __nvmlDeviceGetGpuInstanceId + data["__nvmlDeviceGetGpuInstanceId"] = <_cyb_intptr_t>__nvmlDeviceGetGpuInstanceId global __nvmlDeviceGetComputeInstanceId - data["__nvmlDeviceGetComputeInstanceId"] = __nvmlDeviceGetComputeInstanceId + data["__nvmlDeviceGetComputeInstanceId"] = <_cyb_intptr_t>__nvmlDeviceGetComputeInstanceId global __nvmlDeviceGetMaxMigDeviceCount - data["__nvmlDeviceGetMaxMigDeviceCount"] = __nvmlDeviceGetMaxMigDeviceCount + data["__nvmlDeviceGetMaxMigDeviceCount"] = <_cyb_intptr_t>__nvmlDeviceGetMaxMigDeviceCount global __nvmlDeviceGetMigDeviceHandleByIndex - data["__nvmlDeviceGetMigDeviceHandleByIndex"] = __nvmlDeviceGetMigDeviceHandleByIndex + data["__nvmlDeviceGetMigDeviceHandleByIndex"] = <_cyb_intptr_t>__nvmlDeviceGetMigDeviceHandleByIndex global __nvmlDeviceGetDeviceHandleFromMigDeviceHandle - data["__nvmlDeviceGetDeviceHandleFromMigDeviceHandle"] = __nvmlDeviceGetDeviceHandleFromMigDeviceHandle + data["__nvmlDeviceGetDeviceHandleFromMigDeviceHandle"] = <_cyb_intptr_t>__nvmlDeviceGetDeviceHandleFromMigDeviceHandle global __nvmlDeviceGetCapabilities - data["__nvmlDeviceGetCapabilities"] = __nvmlDeviceGetCapabilities + data["__nvmlDeviceGetCapabilities"] = <_cyb_intptr_t>__nvmlDeviceGetCapabilities global __nvmlDevicePowerSmoothingActivatePresetProfile - data["__nvmlDevicePowerSmoothingActivatePresetProfile"] = __nvmlDevicePowerSmoothingActivatePresetProfile + data["__nvmlDevicePowerSmoothingActivatePresetProfile"] = <_cyb_intptr_t>__nvmlDevicePowerSmoothingActivatePresetProfile global __nvmlDevicePowerSmoothingUpdatePresetProfileParam - data["__nvmlDevicePowerSmoothingUpdatePresetProfileParam"] = __nvmlDevicePowerSmoothingUpdatePresetProfileParam + data["__nvmlDevicePowerSmoothingUpdatePresetProfileParam"] = <_cyb_intptr_t>__nvmlDevicePowerSmoothingUpdatePresetProfileParam global __nvmlDevicePowerSmoothingSetState - data["__nvmlDevicePowerSmoothingSetState"] = __nvmlDevicePowerSmoothingSetState + data["__nvmlDevicePowerSmoothingSetState"] = <_cyb_intptr_t>__nvmlDevicePowerSmoothingSetState global __nvmlDeviceGetAddressingMode - data["__nvmlDeviceGetAddressingMode"] = __nvmlDeviceGetAddressingMode + data["__nvmlDeviceGetAddressingMode"] = <_cyb_intptr_t>__nvmlDeviceGetAddressingMode global __nvmlDeviceGetRepairStatus - data["__nvmlDeviceGetRepairStatus"] = __nvmlDeviceGetRepairStatus + data["__nvmlDeviceGetRepairStatus"] = <_cyb_intptr_t>__nvmlDeviceGetRepairStatus global __nvmlDeviceGetPowerMizerMode_v1 - data["__nvmlDeviceGetPowerMizerMode_v1"] = __nvmlDeviceGetPowerMizerMode_v1 + data["__nvmlDeviceGetPowerMizerMode_v1"] = <_cyb_intptr_t>__nvmlDeviceGetPowerMizerMode_v1 global __nvmlDeviceSetPowerMizerMode_v1 - data["__nvmlDeviceSetPowerMizerMode_v1"] = __nvmlDeviceSetPowerMizerMode_v1 + data["__nvmlDeviceSetPowerMizerMode_v1"] = <_cyb_intptr_t>__nvmlDeviceSetPowerMizerMode_v1 global __nvmlDeviceGetPdi - data["__nvmlDeviceGetPdi"] = __nvmlDeviceGetPdi + data["__nvmlDeviceGetPdi"] = <_cyb_intptr_t>__nvmlDeviceGetPdi global __nvmlDeviceSetHostname_v1 - data["__nvmlDeviceSetHostname_v1"] = __nvmlDeviceSetHostname_v1 + data["__nvmlDeviceSetHostname_v1"] = <_cyb_intptr_t>__nvmlDeviceSetHostname_v1 global __nvmlDeviceGetHostname_v1 - data["__nvmlDeviceGetHostname_v1"] = __nvmlDeviceGetHostname_v1 + data["__nvmlDeviceGetHostname_v1"] = <_cyb_intptr_t>__nvmlDeviceGetHostname_v1 global __nvmlDeviceGetNvLinkInfo - data["__nvmlDeviceGetNvLinkInfo"] = __nvmlDeviceGetNvLinkInfo + data["__nvmlDeviceGetNvLinkInfo"] = <_cyb_intptr_t>__nvmlDeviceGetNvLinkInfo global __nvmlDeviceReadWritePRM_v1 - data["__nvmlDeviceReadWritePRM_v1"] = __nvmlDeviceReadWritePRM_v1 + data["__nvmlDeviceReadWritePRM_v1"] = <_cyb_intptr_t>__nvmlDeviceReadWritePRM_v1 global __nvmlDeviceGetGpuInstanceProfileInfoByIdV - data["__nvmlDeviceGetGpuInstanceProfileInfoByIdV"] = __nvmlDeviceGetGpuInstanceProfileInfoByIdV + data["__nvmlDeviceGetGpuInstanceProfileInfoByIdV"] = <_cyb_intptr_t>__nvmlDeviceGetGpuInstanceProfileInfoByIdV global __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts - data["__nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts"] = __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts + data["__nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts"] = <_cyb_intptr_t>__nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts global __nvmlDeviceGetUnrepairableMemoryFlag_v1 - data["__nvmlDeviceGetUnrepairableMemoryFlag_v1"] = __nvmlDeviceGetUnrepairableMemoryFlag_v1 + data["__nvmlDeviceGetUnrepairableMemoryFlag_v1"] = <_cyb_intptr_t>__nvmlDeviceGetUnrepairableMemoryFlag_v1 global __nvmlDeviceReadPRMCounters_v1 - data["__nvmlDeviceReadPRMCounters_v1"] = __nvmlDeviceReadPRMCounters_v1 + data["__nvmlDeviceReadPRMCounters_v1"] = <_cyb_intptr_t>__nvmlDeviceReadPRMCounters_v1 global __nvmlDeviceSetRusdSettings_v1 - data["__nvmlDeviceSetRusdSettings_v1"] = __nvmlDeviceSetRusdSettings_v1 + data["__nvmlDeviceSetRusdSettings_v1"] = <_cyb_intptr_t>__nvmlDeviceSetRusdSettings_v1 global __nvmlDeviceVgpuForceGspUnload - data["__nvmlDeviceVgpuForceGspUnload"] = __nvmlDeviceVgpuForceGspUnload + data["__nvmlDeviceVgpuForceGspUnload"] = <_cyb_intptr_t>__nvmlDeviceVgpuForceGspUnload global __nvmlDeviceGetVgpuSchedulerState_v2 - data["__nvmlDeviceGetVgpuSchedulerState_v2"] = __nvmlDeviceGetVgpuSchedulerState_v2 + data["__nvmlDeviceGetVgpuSchedulerState_v2"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuSchedulerState_v2 global __nvmlGpuInstanceGetVgpuSchedulerState_v2 - data["__nvmlGpuInstanceGetVgpuSchedulerState_v2"] = __nvmlGpuInstanceGetVgpuSchedulerState_v2 + data["__nvmlGpuInstanceGetVgpuSchedulerState_v2"] = <_cyb_intptr_t>__nvmlGpuInstanceGetVgpuSchedulerState_v2 global __nvmlDeviceGetVgpuSchedulerLog_v2 - data["__nvmlDeviceGetVgpuSchedulerLog_v2"] = __nvmlDeviceGetVgpuSchedulerLog_v2 + data["__nvmlDeviceGetVgpuSchedulerLog_v2"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuSchedulerLog_v2 global __nvmlGpuInstanceGetVgpuSchedulerLog_v2 - data["__nvmlGpuInstanceGetVgpuSchedulerLog_v2"] = __nvmlGpuInstanceGetVgpuSchedulerLog_v2 + data["__nvmlGpuInstanceGetVgpuSchedulerLog_v2"] = <_cyb_intptr_t>__nvmlGpuInstanceGetVgpuSchedulerLog_v2 global __nvmlDeviceSetVgpuSchedulerState_v2 - data["__nvmlDeviceSetVgpuSchedulerState_v2"] = __nvmlDeviceSetVgpuSchedulerState_v2 + data["__nvmlDeviceSetVgpuSchedulerState_v2"] = <_cyb_intptr_t>__nvmlDeviceSetVgpuSchedulerState_v2 global __nvmlGpuInstanceSetVgpuSchedulerState_v2 - data["__nvmlGpuInstanceSetVgpuSchedulerState_v2"] = __nvmlGpuInstanceSetVgpuSchedulerState_v2 - - func_ptrs = data + data["__nvmlGpuInstanceSetVgpuSchedulerState_v2"] = <_cyb_intptr_t>__nvmlGpuInstanceSetVgpuSchedulerState_v2 + _cyb_func_ptrs = data return data cpdef _inspect_function_pointer(str name): - global func_ptrs - if func_ptrs is None: - func_ptrs = _inspect_function_pointers() - return func_ptrs[name] + global _cyb_func_ptrs + if _cyb_func_ptrs is None: + _cyb_func_ptrs = _inspect_function_pointers() + return _cyb_func_ptrs[name] + + + + +cdef void* load_library() except* with gil: + cdef uintptr_t handle = load_nvidia_dynamic_lib("nvml")._handle_uint + return handle ############################################################################### diff --git a/cuda_bindings/cuda/bindings/_internal/nvml_windows.pyx b/cuda_bindings/cuda/bindings/_internal/nvml_windows.pyx index 6de3a0e8671..e0e38c1913e 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvml_windows.pyx +++ b/cuda_bindings/cuda/bindings/_internal/nvml_windows.pyx @@ -3,83 +3,32 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.9.1 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=71acdbf6d477ea00af29faeca397fad7352eec03aca08accffa76af57f2234f9 -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=56d9b790c493aea94da4c2c52e78dea025da7c698edc614c374767038d40869c -from libc.stdint cimport intptr_t -import os -import threading +# <<<< PREAMBLE CONTENT >>>> -from cuda.pathfinder import load_nvidia_dynamic_lib - -from .utils import FunctionNotFoundError, NotSupportedError - -from libc.stddef cimport wchar_t -from libc.stdint cimport uintptr_t -from cpython cimport PyUnicode_AsWideCharString, PyMem_Free - -# You must 'from .utils import NotSupportedError' before using this template - -cdef extern from "windows.h" nogil: +cdef extern from "": ctypedef void* HMODULE - ctypedef void* HANDLE - ctypedef void* FARPROC - ctypedef unsigned long DWORD - ctypedef const wchar_t *LPCWSTR - ctypedef const char *LPCSTR - - cdef DWORD LOAD_LIBRARY_SEARCH_SYSTEM32 = 0x00000800 - cdef DWORD LOAD_LIBRARY_SEARCH_DEFAULT_DIRS = 0x00001000 - cdef DWORD LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR = 0x00000100 - - HMODULE _LoadLibraryExW "LoadLibraryExW"( - LPCWSTR lpLibFileName, - HANDLE hFile, - DWORD dwFlags - ) - - FARPROC _GetProcAddress "GetProcAddress"(HMODULE hModule, LPCSTR lpProcName) - -cdef inline uintptr_t LoadLibraryExW(str path, HANDLE hFile, DWORD dwFlags): - cdef uintptr_t result - cdef wchar_t* wpath = PyUnicode_AsWideCharString(path, NULL) - with nogil: - result = _LoadLibraryExW( - wpath, - hFile, - dwFlags - ) - PyMem_Free(wpath) - return result + void* _cyb_GetProcAddress "GetProcAddress"(HMODULE, const char*) nogil -cdef inline void *GetProcAddress(uintptr_t hModule, const char* lpProcName) nogil: - return _GetProcAddress(hModule, lpProcName) +from libc.stdint cimport intptr_t as _cyb_intptr_t -cdef int get_cuda_version(): - cdef int err, driver_ver = 0 - - # Load driver to check version - handle = LoadLibraryExW("nvcuda.dll", NULL, LOAD_LIBRARY_SEARCH_SYSTEM32) - if handle == 0: - raise NotSupportedError('CUDA driver is not found') - cuDriverGetVersion = GetProcAddress(handle, 'cuDriverGetVersion') - if cuDriverGetVersion == NULL: - raise RuntimeError('Did not find cuDriverGetVersion symbol in nvcuda.dll') - err = (cuDriverGetVersion)(&driver_ver) - if err != 0: - raise RuntimeError(f'cuDriverGetVersion returned error code {err}') - - return driver_ver +import threading as _cyb_threading +cdef bint _cyb___py_nvml_init = False +cdef dict _cyb_func_ptrs = None +cdef object _cyb_symbol_lock = _cyb_threading.Lock() +# <<<< END OF PREAMBLE CONTENT >>>> +from libc.stdint cimport uintptr_t +from cuda.pathfinder import load_nvidia_dynamic_lib +from .utils import FunctionNotFoundError, NotSupportedError ############################################################################### # Wrapper init ############################################################################### -cdef object __symbol_lock = threading.Lock() -cdef bint __py_nvml_init = False - cdef void* __nvmlInit_v2 = NULL cdef void* __nvmlInitWithFlags = NULL cdef void* __nvmlShutdown = NULL @@ -432,2158 +381,2152 @@ cdef void* __nvmlGpuInstanceGetVgpuSchedulerLog_v2 = NULL cdef void* __nvmlDeviceSetVgpuSchedulerState_v2 = NULL cdef void* __nvmlGpuInstanceSetVgpuSchedulerState_v2 = NULL - -cdef uintptr_t load_library() except* with gil: - return load_nvidia_dynamic_lib("nvml")._handle_uint - - cdef int _init_nvml() except -1 nogil: - global __py_nvml_init + global _cyb___py_nvml_init - cdef int err, driver_ver = 0 + cdef int err cdef uintptr_t handle + with gil, _cyb_symbol_lock: + if _cyb___py_nvml_init: return 0 - with gil, __symbol_lock: handle = load_library() - - # Load function global __nvmlInit_v2 - __nvmlInit_v2 = GetProcAddress(handle, 'nvmlInit_v2') + __nvmlInit_v2 = _cyb_GetProcAddress(handle, 'nvmlInit_v2') global __nvmlInitWithFlags - __nvmlInitWithFlags = GetProcAddress(handle, 'nvmlInitWithFlags') + __nvmlInitWithFlags = _cyb_GetProcAddress(handle, 'nvmlInitWithFlags') global __nvmlShutdown - __nvmlShutdown = GetProcAddress(handle, 'nvmlShutdown') + __nvmlShutdown = _cyb_GetProcAddress(handle, 'nvmlShutdown') global __nvmlErrorString - __nvmlErrorString = GetProcAddress(handle, 'nvmlErrorString') + __nvmlErrorString = _cyb_GetProcAddress(handle, 'nvmlErrorString') global __nvmlSystemGetDriverVersion - __nvmlSystemGetDriverVersion = GetProcAddress(handle, 'nvmlSystemGetDriverVersion') + __nvmlSystemGetDriverVersion = _cyb_GetProcAddress(handle, 'nvmlSystemGetDriverVersion') global __nvmlSystemGetNVMLVersion - __nvmlSystemGetNVMLVersion = GetProcAddress(handle, 'nvmlSystemGetNVMLVersion') + __nvmlSystemGetNVMLVersion = _cyb_GetProcAddress(handle, 'nvmlSystemGetNVMLVersion') global __nvmlSystemGetCudaDriverVersion - __nvmlSystemGetCudaDriverVersion = GetProcAddress(handle, 'nvmlSystemGetCudaDriverVersion') + __nvmlSystemGetCudaDriverVersion = _cyb_GetProcAddress(handle, 'nvmlSystemGetCudaDriverVersion') global __nvmlSystemGetCudaDriverVersion_v2 - __nvmlSystemGetCudaDriverVersion_v2 = GetProcAddress(handle, 'nvmlSystemGetCudaDriverVersion_v2') + __nvmlSystemGetCudaDriverVersion_v2 = _cyb_GetProcAddress(handle, 'nvmlSystemGetCudaDriverVersion_v2') global __nvmlSystemGetProcessName - __nvmlSystemGetProcessName = GetProcAddress(handle, 'nvmlSystemGetProcessName') + __nvmlSystemGetProcessName = _cyb_GetProcAddress(handle, 'nvmlSystemGetProcessName') global __nvmlSystemGetHicVersion - __nvmlSystemGetHicVersion = GetProcAddress(handle, 'nvmlSystemGetHicVersion') + __nvmlSystemGetHicVersion = _cyb_GetProcAddress(handle, 'nvmlSystemGetHicVersion') global __nvmlSystemGetTopologyGpuSet - __nvmlSystemGetTopologyGpuSet = GetProcAddress(handle, 'nvmlSystemGetTopologyGpuSet') + __nvmlSystemGetTopologyGpuSet = _cyb_GetProcAddress(handle, 'nvmlSystemGetTopologyGpuSet') global __nvmlSystemGetDriverBranch - __nvmlSystemGetDriverBranch = GetProcAddress(handle, 'nvmlSystemGetDriverBranch') + __nvmlSystemGetDriverBranch = _cyb_GetProcAddress(handle, 'nvmlSystemGetDriverBranch') global __nvmlUnitGetCount - __nvmlUnitGetCount = GetProcAddress(handle, 'nvmlUnitGetCount') + __nvmlUnitGetCount = _cyb_GetProcAddress(handle, 'nvmlUnitGetCount') global __nvmlUnitGetHandleByIndex - __nvmlUnitGetHandleByIndex = GetProcAddress(handle, 'nvmlUnitGetHandleByIndex') + __nvmlUnitGetHandleByIndex = _cyb_GetProcAddress(handle, 'nvmlUnitGetHandleByIndex') global __nvmlUnitGetUnitInfo - __nvmlUnitGetUnitInfo = GetProcAddress(handle, 'nvmlUnitGetUnitInfo') + __nvmlUnitGetUnitInfo = _cyb_GetProcAddress(handle, 'nvmlUnitGetUnitInfo') global __nvmlUnitGetLedState - __nvmlUnitGetLedState = GetProcAddress(handle, 'nvmlUnitGetLedState') + __nvmlUnitGetLedState = _cyb_GetProcAddress(handle, 'nvmlUnitGetLedState') global __nvmlUnitGetPsuInfo - __nvmlUnitGetPsuInfo = GetProcAddress(handle, 'nvmlUnitGetPsuInfo') + __nvmlUnitGetPsuInfo = _cyb_GetProcAddress(handle, 'nvmlUnitGetPsuInfo') global __nvmlUnitGetTemperature - __nvmlUnitGetTemperature = GetProcAddress(handle, 'nvmlUnitGetTemperature') + __nvmlUnitGetTemperature = _cyb_GetProcAddress(handle, 'nvmlUnitGetTemperature') global __nvmlUnitGetFanSpeedInfo - __nvmlUnitGetFanSpeedInfo = GetProcAddress(handle, 'nvmlUnitGetFanSpeedInfo') + __nvmlUnitGetFanSpeedInfo = _cyb_GetProcAddress(handle, 'nvmlUnitGetFanSpeedInfo') global __nvmlUnitGetDevices - __nvmlUnitGetDevices = GetProcAddress(handle, 'nvmlUnitGetDevices') + __nvmlUnitGetDevices = _cyb_GetProcAddress(handle, 'nvmlUnitGetDevices') global __nvmlDeviceGetCount_v2 - __nvmlDeviceGetCount_v2 = GetProcAddress(handle, 'nvmlDeviceGetCount_v2') + __nvmlDeviceGetCount_v2 = _cyb_GetProcAddress(handle, 'nvmlDeviceGetCount_v2') global __nvmlDeviceGetAttributes_v2 - __nvmlDeviceGetAttributes_v2 = GetProcAddress(handle, 'nvmlDeviceGetAttributes_v2') + __nvmlDeviceGetAttributes_v2 = _cyb_GetProcAddress(handle, 'nvmlDeviceGetAttributes_v2') global __nvmlDeviceGetHandleByIndex_v2 - __nvmlDeviceGetHandleByIndex_v2 = GetProcAddress(handle, 'nvmlDeviceGetHandleByIndex_v2') + __nvmlDeviceGetHandleByIndex_v2 = _cyb_GetProcAddress(handle, 'nvmlDeviceGetHandleByIndex_v2') global __nvmlDeviceGetHandleBySerial - __nvmlDeviceGetHandleBySerial = GetProcAddress(handle, 'nvmlDeviceGetHandleBySerial') + __nvmlDeviceGetHandleBySerial = _cyb_GetProcAddress(handle, 'nvmlDeviceGetHandleBySerial') global __nvmlDeviceGetHandleByUUID - __nvmlDeviceGetHandleByUUID = GetProcAddress(handle, 'nvmlDeviceGetHandleByUUID') + __nvmlDeviceGetHandleByUUID = _cyb_GetProcAddress(handle, 'nvmlDeviceGetHandleByUUID') global __nvmlDeviceGetHandleByUUIDV - __nvmlDeviceGetHandleByUUIDV = GetProcAddress(handle, 'nvmlDeviceGetHandleByUUIDV') + __nvmlDeviceGetHandleByUUIDV = _cyb_GetProcAddress(handle, 'nvmlDeviceGetHandleByUUIDV') global __nvmlDeviceGetHandleByPciBusId_v2 - __nvmlDeviceGetHandleByPciBusId_v2 = GetProcAddress(handle, 'nvmlDeviceGetHandleByPciBusId_v2') + __nvmlDeviceGetHandleByPciBusId_v2 = _cyb_GetProcAddress(handle, 'nvmlDeviceGetHandleByPciBusId_v2') global __nvmlDeviceGetName - __nvmlDeviceGetName = GetProcAddress(handle, 'nvmlDeviceGetName') + __nvmlDeviceGetName = _cyb_GetProcAddress(handle, 'nvmlDeviceGetName') global __nvmlDeviceGetBrand - __nvmlDeviceGetBrand = GetProcAddress(handle, 'nvmlDeviceGetBrand') + __nvmlDeviceGetBrand = _cyb_GetProcAddress(handle, 'nvmlDeviceGetBrand') global __nvmlDeviceGetIndex - __nvmlDeviceGetIndex = GetProcAddress(handle, 'nvmlDeviceGetIndex') + __nvmlDeviceGetIndex = _cyb_GetProcAddress(handle, 'nvmlDeviceGetIndex') global __nvmlDeviceGetSerial - __nvmlDeviceGetSerial = GetProcAddress(handle, 'nvmlDeviceGetSerial') + __nvmlDeviceGetSerial = _cyb_GetProcAddress(handle, 'nvmlDeviceGetSerial') global __nvmlDeviceGetModuleId - __nvmlDeviceGetModuleId = GetProcAddress(handle, 'nvmlDeviceGetModuleId') + __nvmlDeviceGetModuleId = _cyb_GetProcAddress(handle, 'nvmlDeviceGetModuleId') global __nvmlDeviceGetC2cModeInfoV - __nvmlDeviceGetC2cModeInfoV = GetProcAddress(handle, 'nvmlDeviceGetC2cModeInfoV') + __nvmlDeviceGetC2cModeInfoV = _cyb_GetProcAddress(handle, 'nvmlDeviceGetC2cModeInfoV') global __nvmlDeviceGetMemoryAffinity - __nvmlDeviceGetMemoryAffinity = GetProcAddress(handle, 'nvmlDeviceGetMemoryAffinity') + __nvmlDeviceGetMemoryAffinity = _cyb_GetProcAddress(handle, 'nvmlDeviceGetMemoryAffinity') global __nvmlDeviceGetCpuAffinityWithinScope - __nvmlDeviceGetCpuAffinityWithinScope = GetProcAddress(handle, 'nvmlDeviceGetCpuAffinityWithinScope') + __nvmlDeviceGetCpuAffinityWithinScope = _cyb_GetProcAddress(handle, 'nvmlDeviceGetCpuAffinityWithinScope') global __nvmlDeviceGetCpuAffinity - __nvmlDeviceGetCpuAffinity = GetProcAddress(handle, 'nvmlDeviceGetCpuAffinity') + __nvmlDeviceGetCpuAffinity = _cyb_GetProcAddress(handle, 'nvmlDeviceGetCpuAffinity') global __nvmlDeviceSetCpuAffinity - __nvmlDeviceSetCpuAffinity = GetProcAddress(handle, 'nvmlDeviceSetCpuAffinity') + __nvmlDeviceSetCpuAffinity = _cyb_GetProcAddress(handle, 'nvmlDeviceSetCpuAffinity') global __nvmlDeviceClearCpuAffinity - __nvmlDeviceClearCpuAffinity = GetProcAddress(handle, 'nvmlDeviceClearCpuAffinity') + __nvmlDeviceClearCpuAffinity = _cyb_GetProcAddress(handle, 'nvmlDeviceClearCpuAffinity') global __nvmlDeviceGetNumaNodeId - __nvmlDeviceGetNumaNodeId = GetProcAddress(handle, 'nvmlDeviceGetNumaNodeId') + __nvmlDeviceGetNumaNodeId = _cyb_GetProcAddress(handle, 'nvmlDeviceGetNumaNodeId') global __nvmlDeviceGetTopologyCommonAncestor - __nvmlDeviceGetTopologyCommonAncestor = GetProcAddress(handle, 'nvmlDeviceGetTopologyCommonAncestor') + __nvmlDeviceGetTopologyCommonAncestor = _cyb_GetProcAddress(handle, 'nvmlDeviceGetTopologyCommonAncestor') global __nvmlDeviceGetTopologyNearestGpus - __nvmlDeviceGetTopologyNearestGpus = GetProcAddress(handle, 'nvmlDeviceGetTopologyNearestGpus') + __nvmlDeviceGetTopologyNearestGpus = _cyb_GetProcAddress(handle, 'nvmlDeviceGetTopologyNearestGpus') global __nvmlDeviceGetP2PStatus - __nvmlDeviceGetP2PStatus = GetProcAddress(handle, 'nvmlDeviceGetP2PStatus') + __nvmlDeviceGetP2PStatus = _cyb_GetProcAddress(handle, 'nvmlDeviceGetP2PStatus') global __nvmlDeviceGetUUID - __nvmlDeviceGetUUID = GetProcAddress(handle, 'nvmlDeviceGetUUID') + __nvmlDeviceGetUUID = _cyb_GetProcAddress(handle, 'nvmlDeviceGetUUID') global __nvmlDeviceGetMinorNumber - __nvmlDeviceGetMinorNumber = GetProcAddress(handle, 'nvmlDeviceGetMinorNumber') + __nvmlDeviceGetMinorNumber = _cyb_GetProcAddress(handle, 'nvmlDeviceGetMinorNumber') global __nvmlDeviceGetBoardPartNumber - __nvmlDeviceGetBoardPartNumber = GetProcAddress(handle, 'nvmlDeviceGetBoardPartNumber') + __nvmlDeviceGetBoardPartNumber = _cyb_GetProcAddress(handle, 'nvmlDeviceGetBoardPartNumber') global __nvmlDeviceGetInforomVersion - __nvmlDeviceGetInforomVersion = GetProcAddress(handle, 'nvmlDeviceGetInforomVersion') + __nvmlDeviceGetInforomVersion = _cyb_GetProcAddress(handle, 'nvmlDeviceGetInforomVersion') global __nvmlDeviceGetInforomImageVersion - __nvmlDeviceGetInforomImageVersion = GetProcAddress(handle, 'nvmlDeviceGetInforomImageVersion') + __nvmlDeviceGetInforomImageVersion = _cyb_GetProcAddress(handle, 'nvmlDeviceGetInforomImageVersion') global __nvmlDeviceGetInforomConfigurationChecksum - __nvmlDeviceGetInforomConfigurationChecksum = GetProcAddress(handle, 'nvmlDeviceGetInforomConfigurationChecksum') + __nvmlDeviceGetInforomConfigurationChecksum = _cyb_GetProcAddress(handle, 'nvmlDeviceGetInforomConfigurationChecksum') global __nvmlDeviceValidateInforom - __nvmlDeviceValidateInforom = GetProcAddress(handle, 'nvmlDeviceValidateInforom') + __nvmlDeviceValidateInforom = _cyb_GetProcAddress(handle, 'nvmlDeviceValidateInforom') global __nvmlDeviceGetLastBBXFlushTime - __nvmlDeviceGetLastBBXFlushTime = GetProcAddress(handle, 'nvmlDeviceGetLastBBXFlushTime') + __nvmlDeviceGetLastBBXFlushTime = _cyb_GetProcAddress(handle, 'nvmlDeviceGetLastBBXFlushTime') global __nvmlDeviceGetDisplayMode - __nvmlDeviceGetDisplayMode = GetProcAddress(handle, 'nvmlDeviceGetDisplayMode') + __nvmlDeviceGetDisplayMode = _cyb_GetProcAddress(handle, 'nvmlDeviceGetDisplayMode') global __nvmlDeviceGetDisplayActive - __nvmlDeviceGetDisplayActive = GetProcAddress(handle, 'nvmlDeviceGetDisplayActive') + __nvmlDeviceGetDisplayActive = _cyb_GetProcAddress(handle, 'nvmlDeviceGetDisplayActive') global __nvmlDeviceGetPersistenceMode - __nvmlDeviceGetPersistenceMode = GetProcAddress(handle, 'nvmlDeviceGetPersistenceMode') + __nvmlDeviceGetPersistenceMode = _cyb_GetProcAddress(handle, 'nvmlDeviceGetPersistenceMode') global __nvmlDeviceGetPciInfoExt - __nvmlDeviceGetPciInfoExt = GetProcAddress(handle, 'nvmlDeviceGetPciInfoExt') + __nvmlDeviceGetPciInfoExt = _cyb_GetProcAddress(handle, 'nvmlDeviceGetPciInfoExt') global __nvmlDeviceGetPciInfo_v3 - __nvmlDeviceGetPciInfo_v3 = GetProcAddress(handle, 'nvmlDeviceGetPciInfo_v3') + __nvmlDeviceGetPciInfo_v3 = _cyb_GetProcAddress(handle, 'nvmlDeviceGetPciInfo_v3') global __nvmlDeviceGetMaxPcieLinkGeneration - __nvmlDeviceGetMaxPcieLinkGeneration = GetProcAddress(handle, 'nvmlDeviceGetMaxPcieLinkGeneration') + __nvmlDeviceGetMaxPcieLinkGeneration = _cyb_GetProcAddress(handle, 'nvmlDeviceGetMaxPcieLinkGeneration') global __nvmlDeviceGetGpuMaxPcieLinkGeneration - __nvmlDeviceGetGpuMaxPcieLinkGeneration = GetProcAddress(handle, 'nvmlDeviceGetGpuMaxPcieLinkGeneration') + __nvmlDeviceGetGpuMaxPcieLinkGeneration = _cyb_GetProcAddress(handle, 'nvmlDeviceGetGpuMaxPcieLinkGeneration') global __nvmlDeviceGetMaxPcieLinkWidth - __nvmlDeviceGetMaxPcieLinkWidth = GetProcAddress(handle, 'nvmlDeviceGetMaxPcieLinkWidth') + __nvmlDeviceGetMaxPcieLinkWidth = _cyb_GetProcAddress(handle, 'nvmlDeviceGetMaxPcieLinkWidth') global __nvmlDeviceGetCurrPcieLinkGeneration - __nvmlDeviceGetCurrPcieLinkGeneration = GetProcAddress(handle, 'nvmlDeviceGetCurrPcieLinkGeneration') + __nvmlDeviceGetCurrPcieLinkGeneration = _cyb_GetProcAddress(handle, 'nvmlDeviceGetCurrPcieLinkGeneration') global __nvmlDeviceGetCurrPcieLinkWidth - __nvmlDeviceGetCurrPcieLinkWidth = GetProcAddress(handle, 'nvmlDeviceGetCurrPcieLinkWidth') + __nvmlDeviceGetCurrPcieLinkWidth = _cyb_GetProcAddress(handle, 'nvmlDeviceGetCurrPcieLinkWidth') global __nvmlDeviceGetPcieThroughput - __nvmlDeviceGetPcieThroughput = GetProcAddress(handle, 'nvmlDeviceGetPcieThroughput') + __nvmlDeviceGetPcieThroughput = _cyb_GetProcAddress(handle, 'nvmlDeviceGetPcieThroughput') global __nvmlDeviceGetPcieReplayCounter - __nvmlDeviceGetPcieReplayCounter = GetProcAddress(handle, 'nvmlDeviceGetPcieReplayCounter') + __nvmlDeviceGetPcieReplayCounter = _cyb_GetProcAddress(handle, 'nvmlDeviceGetPcieReplayCounter') global __nvmlDeviceGetClockInfo - __nvmlDeviceGetClockInfo = GetProcAddress(handle, 'nvmlDeviceGetClockInfo') + __nvmlDeviceGetClockInfo = _cyb_GetProcAddress(handle, 'nvmlDeviceGetClockInfo') global __nvmlDeviceGetMaxClockInfo - __nvmlDeviceGetMaxClockInfo = GetProcAddress(handle, 'nvmlDeviceGetMaxClockInfo') + __nvmlDeviceGetMaxClockInfo = _cyb_GetProcAddress(handle, 'nvmlDeviceGetMaxClockInfo') global __nvmlDeviceGetGpcClkVfOffset - __nvmlDeviceGetGpcClkVfOffset = GetProcAddress(handle, 'nvmlDeviceGetGpcClkVfOffset') + __nvmlDeviceGetGpcClkVfOffset = _cyb_GetProcAddress(handle, 'nvmlDeviceGetGpcClkVfOffset') global __nvmlDeviceGetClock - __nvmlDeviceGetClock = GetProcAddress(handle, 'nvmlDeviceGetClock') + __nvmlDeviceGetClock = _cyb_GetProcAddress(handle, 'nvmlDeviceGetClock') global __nvmlDeviceGetMaxCustomerBoostClock - __nvmlDeviceGetMaxCustomerBoostClock = GetProcAddress(handle, 'nvmlDeviceGetMaxCustomerBoostClock') + __nvmlDeviceGetMaxCustomerBoostClock = _cyb_GetProcAddress(handle, 'nvmlDeviceGetMaxCustomerBoostClock') global __nvmlDeviceGetSupportedMemoryClocks - __nvmlDeviceGetSupportedMemoryClocks = GetProcAddress(handle, 'nvmlDeviceGetSupportedMemoryClocks') + __nvmlDeviceGetSupportedMemoryClocks = _cyb_GetProcAddress(handle, 'nvmlDeviceGetSupportedMemoryClocks') global __nvmlDeviceGetSupportedGraphicsClocks - __nvmlDeviceGetSupportedGraphicsClocks = GetProcAddress(handle, 'nvmlDeviceGetSupportedGraphicsClocks') + __nvmlDeviceGetSupportedGraphicsClocks = _cyb_GetProcAddress(handle, 'nvmlDeviceGetSupportedGraphicsClocks') global __nvmlDeviceGetAutoBoostedClocksEnabled - __nvmlDeviceGetAutoBoostedClocksEnabled = GetProcAddress(handle, 'nvmlDeviceGetAutoBoostedClocksEnabled') + __nvmlDeviceGetAutoBoostedClocksEnabled = _cyb_GetProcAddress(handle, 'nvmlDeviceGetAutoBoostedClocksEnabled') global __nvmlDeviceGetFanSpeed - __nvmlDeviceGetFanSpeed = GetProcAddress(handle, 'nvmlDeviceGetFanSpeed') + __nvmlDeviceGetFanSpeed = _cyb_GetProcAddress(handle, 'nvmlDeviceGetFanSpeed') global __nvmlDeviceGetFanSpeed_v2 - __nvmlDeviceGetFanSpeed_v2 = GetProcAddress(handle, 'nvmlDeviceGetFanSpeed_v2') + __nvmlDeviceGetFanSpeed_v2 = _cyb_GetProcAddress(handle, 'nvmlDeviceGetFanSpeed_v2') global __nvmlDeviceGetFanSpeedRPM - __nvmlDeviceGetFanSpeedRPM = GetProcAddress(handle, 'nvmlDeviceGetFanSpeedRPM') + __nvmlDeviceGetFanSpeedRPM = _cyb_GetProcAddress(handle, 'nvmlDeviceGetFanSpeedRPM') global __nvmlDeviceGetTargetFanSpeed - __nvmlDeviceGetTargetFanSpeed = GetProcAddress(handle, 'nvmlDeviceGetTargetFanSpeed') + __nvmlDeviceGetTargetFanSpeed = _cyb_GetProcAddress(handle, 'nvmlDeviceGetTargetFanSpeed') global __nvmlDeviceGetMinMaxFanSpeed - __nvmlDeviceGetMinMaxFanSpeed = GetProcAddress(handle, 'nvmlDeviceGetMinMaxFanSpeed') + __nvmlDeviceGetMinMaxFanSpeed = _cyb_GetProcAddress(handle, 'nvmlDeviceGetMinMaxFanSpeed') global __nvmlDeviceGetFanControlPolicy_v2 - __nvmlDeviceGetFanControlPolicy_v2 = GetProcAddress(handle, 'nvmlDeviceGetFanControlPolicy_v2') + __nvmlDeviceGetFanControlPolicy_v2 = _cyb_GetProcAddress(handle, 'nvmlDeviceGetFanControlPolicy_v2') global __nvmlDeviceGetNumFans - __nvmlDeviceGetNumFans = GetProcAddress(handle, 'nvmlDeviceGetNumFans') + __nvmlDeviceGetNumFans = _cyb_GetProcAddress(handle, 'nvmlDeviceGetNumFans') global __nvmlDeviceGetCoolerInfo - __nvmlDeviceGetCoolerInfo = GetProcAddress(handle, 'nvmlDeviceGetCoolerInfo') + __nvmlDeviceGetCoolerInfo = _cyb_GetProcAddress(handle, 'nvmlDeviceGetCoolerInfo') global __nvmlDeviceGetTemperatureV - __nvmlDeviceGetTemperatureV = GetProcAddress(handle, 'nvmlDeviceGetTemperatureV') + __nvmlDeviceGetTemperatureV = _cyb_GetProcAddress(handle, 'nvmlDeviceGetTemperatureV') global __nvmlDeviceGetTemperatureThreshold - __nvmlDeviceGetTemperatureThreshold = GetProcAddress(handle, 'nvmlDeviceGetTemperatureThreshold') + __nvmlDeviceGetTemperatureThreshold = _cyb_GetProcAddress(handle, 'nvmlDeviceGetTemperatureThreshold') global __nvmlDeviceGetMarginTemperature - __nvmlDeviceGetMarginTemperature = GetProcAddress(handle, 'nvmlDeviceGetMarginTemperature') + __nvmlDeviceGetMarginTemperature = _cyb_GetProcAddress(handle, 'nvmlDeviceGetMarginTemperature') global __nvmlDeviceGetThermalSettings - __nvmlDeviceGetThermalSettings = GetProcAddress(handle, 'nvmlDeviceGetThermalSettings') + __nvmlDeviceGetThermalSettings = _cyb_GetProcAddress(handle, 'nvmlDeviceGetThermalSettings') global __nvmlDeviceGetPerformanceState - __nvmlDeviceGetPerformanceState = GetProcAddress(handle, 'nvmlDeviceGetPerformanceState') + __nvmlDeviceGetPerformanceState = _cyb_GetProcAddress(handle, 'nvmlDeviceGetPerformanceState') global __nvmlDeviceGetCurrentClocksEventReasons - __nvmlDeviceGetCurrentClocksEventReasons = GetProcAddress(handle, 'nvmlDeviceGetCurrentClocksEventReasons') + __nvmlDeviceGetCurrentClocksEventReasons = _cyb_GetProcAddress(handle, 'nvmlDeviceGetCurrentClocksEventReasons') global __nvmlDeviceGetSupportedClocksEventReasons - __nvmlDeviceGetSupportedClocksEventReasons = GetProcAddress(handle, 'nvmlDeviceGetSupportedClocksEventReasons') + __nvmlDeviceGetSupportedClocksEventReasons = _cyb_GetProcAddress(handle, 'nvmlDeviceGetSupportedClocksEventReasons') global __nvmlDeviceGetPowerState - __nvmlDeviceGetPowerState = GetProcAddress(handle, 'nvmlDeviceGetPowerState') + __nvmlDeviceGetPowerState = _cyb_GetProcAddress(handle, 'nvmlDeviceGetPowerState') global __nvmlDeviceGetDynamicPstatesInfo - __nvmlDeviceGetDynamicPstatesInfo = GetProcAddress(handle, 'nvmlDeviceGetDynamicPstatesInfo') + __nvmlDeviceGetDynamicPstatesInfo = _cyb_GetProcAddress(handle, 'nvmlDeviceGetDynamicPstatesInfo') global __nvmlDeviceGetMemClkVfOffset - __nvmlDeviceGetMemClkVfOffset = GetProcAddress(handle, 'nvmlDeviceGetMemClkVfOffset') + __nvmlDeviceGetMemClkVfOffset = _cyb_GetProcAddress(handle, 'nvmlDeviceGetMemClkVfOffset') global __nvmlDeviceGetMinMaxClockOfPState - __nvmlDeviceGetMinMaxClockOfPState = GetProcAddress(handle, 'nvmlDeviceGetMinMaxClockOfPState') + __nvmlDeviceGetMinMaxClockOfPState = _cyb_GetProcAddress(handle, 'nvmlDeviceGetMinMaxClockOfPState') global __nvmlDeviceGetSupportedPerformanceStates - __nvmlDeviceGetSupportedPerformanceStates = GetProcAddress(handle, 'nvmlDeviceGetSupportedPerformanceStates') + __nvmlDeviceGetSupportedPerformanceStates = _cyb_GetProcAddress(handle, 'nvmlDeviceGetSupportedPerformanceStates') global __nvmlDeviceGetGpcClkMinMaxVfOffset - __nvmlDeviceGetGpcClkMinMaxVfOffset = GetProcAddress(handle, 'nvmlDeviceGetGpcClkMinMaxVfOffset') + __nvmlDeviceGetGpcClkMinMaxVfOffset = _cyb_GetProcAddress(handle, 'nvmlDeviceGetGpcClkMinMaxVfOffset') global __nvmlDeviceGetMemClkMinMaxVfOffset - __nvmlDeviceGetMemClkMinMaxVfOffset = GetProcAddress(handle, 'nvmlDeviceGetMemClkMinMaxVfOffset') + __nvmlDeviceGetMemClkMinMaxVfOffset = _cyb_GetProcAddress(handle, 'nvmlDeviceGetMemClkMinMaxVfOffset') global __nvmlDeviceGetClockOffsets - __nvmlDeviceGetClockOffsets = GetProcAddress(handle, 'nvmlDeviceGetClockOffsets') + __nvmlDeviceGetClockOffsets = _cyb_GetProcAddress(handle, 'nvmlDeviceGetClockOffsets') global __nvmlDeviceSetClockOffsets - __nvmlDeviceSetClockOffsets = GetProcAddress(handle, 'nvmlDeviceSetClockOffsets') + __nvmlDeviceSetClockOffsets = _cyb_GetProcAddress(handle, 'nvmlDeviceSetClockOffsets') global __nvmlDeviceGetPerformanceModes - __nvmlDeviceGetPerformanceModes = GetProcAddress(handle, 'nvmlDeviceGetPerformanceModes') + __nvmlDeviceGetPerformanceModes = _cyb_GetProcAddress(handle, 'nvmlDeviceGetPerformanceModes') global __nvmlDeviceGetCurrentClockFreqs - __nvmlDeviceGetCurrentClockFreqs = GetProcAddress(handle, 'nvmlDeviceGetCurrentClockFreqs') + __nvmlDeviceGetCurrentClockFreqs = _cyb_GetProcAddress(handle, 'nvmlDeviceGetCurrentClockFreqs') global __nvmlDeviceGetPowerManagementLimit - __nvmlDeviceGetPowerManagementLimit = GetProcAddress(handle, 'nvmlDeviceGetPowerManagementLimit') + __nvmlDeviceGetPowerManagementLimit = _cyb_GetProcAddress(handle, 'nvmlDeviceGetPowerManagementLimit') global __nvmlDeviceGetPowerManagementLimitConstraints - __nvmlDeviceGetPowerManagementLimitConstraints = GetProcAddress(handle, 'nvmlDeviceGetPowerManagementLimitConstraints') + __nvmlDeviceGetPowerManagementLimitConstraints = _cyb_GetProcAddress(handle, 'nvmlDeviceGetPowerManagementLimitConstraints') global __nvmlDeviceGetPowerManagementDefaultLimit - __nvmlDeviceGetPowerManagementDefaultLimit = GetProcAddress(handle, 'nvmlDeviceGetPowerManagementDefaultLimit') + __nvmlDeviceGetPowerManagementDefaultLimit = _cyb_GetProcAddress(handle, 'nvmlDeviceGetPowerManagementDefaultLimit') global __nvmlDeviceGetPowerUsage - __nvmlDeviceGetPowerUsage = GetProcAddress(handle, 'nvmlDeviceGetPowerUsage') + __nvmlDeviceGetPowerUsage = _cyb_GetProcAddress(handle, 'nvmlDeviceGetPowerUsage') global __nvmlDeviceGetTotalEnergyConsumption - __nvmlDeviceGetTotalEnergyConsumption = GetProcAddress(handle, 'nvmlDeviceGetTotalEnergyConsumption') + __nvmlDeviceGetTotalEnergyConsumption = _cyb_GetProcAddress(handle, 'nvmlDeviceGetTotalEnergyConsumption') global __nvmlDeviceGetEnforcedPowerLimit - __nvmlDeviceGetEnforcedPowerLimit = GetProcAddress(handle, 'nvmlDeviceGetEnforcedPowerLimit') + __nvmlDeviceGetEnforcedPowerLimit = _cyb_GetProcAddress(handle, 'nvmlDeviceGetEnforcedPowerLimit') global __nvmlDeviceGetGpuOperationMode - __nvmlDeviceGetGpuOperationMode = GetProcAddress(handle, 'nvmlDeviceGetGpuOperationMode') + __nvmlDeviceGetGpuOperationMode = _cyb_GetProcAddress(handle, 'nvmlDeviceGetGpuOperationMode') global __nvmlDeviceGetMemoryInfo_v2 - __nvmlDeviceGetMemoryInfo_v2 = GetProcAddress(handle, 'nvmlDeviceGetMemoryInfo_v2') + __nvmlDeviceGetMemoryInfo_v2 = _cyb_GetProcAddress(handle, 'nvmlDeviceGetMemoryInfo_v2') global __nvmlDeviceGetComputeMode - __nvmlDeviceGetComputeMode = GetProcAddress(handle, 'nvmlDeviceGetComputeMode') + __nvmlDeviceGetComputeMode = _cyb_GetProcAddress(handle, 'nvmlDeviceGetComputeMode') global __nvmlDeviceGetCudaComputeCapability - __nvmlDeviceGetCudaComputeCapability = GetProcAddress(handle, 'nvmlDeviceGetCudaComputeCapability') + __nvmlDeviceGetCudaComputeCapability = _cyb_GetProcAddress(handle, 'nvmlDeviceGetCudaComputeCapability') global __nvmlDeviceGetDramEncryptionMode - __nvmlDeviceGetDramEncryptionMode = GetProcAddress(handle, 'nvmlDeviceGetDramEncryptionMode') + __nvmlDeviceGetDramEncryptionMode = _cyb_GetProcAddress(handle, 'nvmlDeviceGetDramEncryptionMode') global __nvmlDeviceSetDramEncryptionMode - __nvmlDeviceSetDramEncryptionMode = GetProcAddress(handle, 'nvmlDeviceSetDramEncryptionMode') + __nvmlDeviceSetDramEncryptionMode = _cyb_GetProcAddress(handle, 'nvmlDeviceSetDramEncryptionMode') global __nvmlDeviceGetEccMode - __nvmlDeviceGetEccMode = GetProcAddress(handle, 'nvmlDeviceGetEccMode') + __nvmlDeviceGetEccMode = _cyb_GetProcAddress(handle, 'nvmlDeviceGetEccMode') global __nvmlDeviceGetDefaultEccMode - __nvmlDeviceGetDefaultEccMode = GetProcAddress(handle, 'nvmlDeviceGetDefaultEccMode') + __nvmlDeviceGetDefaultEccMode = _cyb_GetProcAddress(handle, 'nvmlDeviceGetDefaultEccMode') global __nvmlDeviceGetBoardId - __nvmlDeviceGetBoardId = GetProcAddress(handle, 'nvmlDeviceGetBoardId') + __nvmlDeviceGetBoardId = _cyb_GetProcAddress(handle, 'nvmlDeviceGetBoardId') global __nvmlDeviceGetMultiGpuBoard - __nvmlDeviceGetMultiGpuBoard = GetProcAddress(handle, 'nvmlDeviceGetMultiGpuBoard') + __nvmlDeviceGetMultiGpuBoard = _cyb_GetProcAddress(handle, 'nvmlDeviceGetMultiGpuBoard') global __nvmlDeviceGetTotalEccErrors - __nvmlDeviceGetTotalEccErrors = GetProcAddress(handle, 'nvmlDeviceGetTotalEccErrors') + __nvmlDeviceGetTotalEccErrors = _cyb_GetProcAddress(handle, 'nvmlDeviceGetTotalEccErrors') global __nvmlDeviceGetMemoryErrorCounter - __nvmlDeviceGetMemoryErrorCounter = GetProcAddress(handle, 'nvmlDeviceGetMemoryErrorCounter') + __nvmlDeviceGetMemoryErrorCounter = _cyb_GetProcAddress(handle, 'nvmlDeviceGetMemoryErrorCounter') global __nvmlDeviceGetUtilizationRates - __nvmlDeviceGetUtilizationRates = GetProcAddress(handle, 'nvmlDeviceGetUtilizationRates') + __nvmlDeviceGetUtilizationRates = _cyb_GetProcAddress(handle, 'nvmlDeviceGetUtilizationRates') global __nvmlDeviceGetEncoderUtilization - __nvmlDeviceGetEncoderUtilization = GetProcAddress(handle, 'nvmlDeviceGetEncoderUtilization') + __nvmlDeviceGetEncoderUtilization = _cyb_GetProcAddress(handle, 'nvmlDeviceGetEncoderUtilization') global __nvmlDeviceGetEncoderCapacity - __nvmlDeviceGetEncoderCapacity = GetProcAddress(handle, 'nvmlDeviceGetEncoderCapacity') + __nvmlDeviceGetEncoderCapacity = _cyb_GetProcAddress(handle, 'nvmlDeviceGetEncoderCapacity') global __nvmlDeviceGetEncoderStats - __nvmlDeviceGetEncoderStats = GetProcAddress(handle, 'nvmlDeviceGetEncoderStats') + __nvmlDeviceGetEncoderStats = _cyb_GetProcAddress(handle, 'nvmlDeviceGetEncoderStats') global __nvmlDeviceGetEncoderSessions - __nvmlDeviceGetEncoderSessions = GetProcAddress(handle, 'nvmlDeviceGetEncoderSessions') + __nvmlDeviceGetEncoderSessions = _cyb_GetProcAddress(handle, 'nvmlDeviceGetEncoderSessions') global __nvmlDeviceGetDecoderUtilization - __nvmlDeviceGetDecoderUtilization = GetProcAddress(handle, 'nvmlDeviceGetDecoderUtilization') + __nvmlDeviceGetDecoderUtilization = _cyb_GetProcAddress(handle, 'nvmlDeviceGetDecoderUtilization') global __nvmlDeviceGetJpgUtilization - __nvmlDeviceGetJpgUtilization = GetProcAddress(handle, 'nvmlDeviceGetJpgUtilization') + __nvmlDeviceGetJpgUtilization = _cyb_GetProcAddress(handle, 'nvmlDeviceGetJpgUtilization') global __nvmlDeviceGetOfaUtilization - __nvmlDeviceGetOfaUtilization = GetProcAddress(handle, 'nvmlDeviceGetOfaUtilization') + __nvmlDeviceGetOfaUtilization = _cyb_GetProcAddress(handle, 'nvmlDeviceGetOfaUtilization') global __nvmlDeviceGetFBCStats - __nvmlDeviceGetFBCStats = GetProcAddress(handle, 'nvmlDeviceGetFBCStats') + __nvmlDeviceGetFBCStats = _cyb_GetProcAddress(handle, 'nvmlDeviceGetFBCStats') global __nvmlDeviceGetFBCSessions - __nvmlDeviceGetFBCSessions = GetProcAddress(handle, 'nvmlDeviceGetFBCSessions') + __nvmlDeviceGetFBCSessions = _cyb_GetProcAddress(handle, 'nvmlDeviceGetFBCSessions') global __nvmlDeviceGetDriverModel_v2 - __nvmlDeviceGetDriverModel_v2 = GetProcAddress(handle, 'nvmlDeviceGetDriverModel_v2') + __nvmlDeviceGetDriverModel_v2 = _cyb_GetProcAddress(handle, 'nvmlDeviceGetDriverModel_v2') global __nvmlDeviceGetVbiosVersion - __nvmlDeviceGetVbiosVersion = GetProcAddress(handle, 'nvmlDeviceGetVbiosVersion') + __nvmlDeviceGetVbiosVersion = _cyb_GetProcAddress(handle, 'nvmlDeviceGetVbiosVersion') global __nvmlDeviceGetBridgeChipInfo - __nvmlDeviceGetBridgeChipInfo = GetProcAddress(handle, 'nvmlDeviceGetBridgeChipInfo') + __nvmlDeviceGetBridgeChipInfo = _cyb_GetProcAddress(handle, 'nvmlDeviceGetBridgeChipInfo') global __nvmlDeviceGetComputeRunningProcesses_v3 - __nvmlDeviceGetComputeRunningProcesses_v3 = GetProcAddress(handle, 'nvmlDeviceGetComputeRunningProcesses_v3') + __nvmlDeviceGetComputeRunningProcesses_v3 = _cyb_GetProcAddress(handle, 'nvmlDeviceGetComputeRunningProcesses_v3') global __nvmlDeviceGetGraphicsRunningProcesses_v3 - __nvmlDeviceGetGraphicsRunningProcesses_v3 = GetProcAddress(handle, 'nvmlDeviceGetGraphicsRunningProcesses_v3') + __nvmlDeviceGetGraphicsRunningProcesses_v3 = _cyb_GetProcAddress(handle, 'nvmlDeviceGetGraphicsRunningProcesses_v3') global __nvmlDeviceGetMPSComputeRunningProcesses_v3 - __nvmlDeviceGetMPSComputeRunningProcesses_v3 = GetProcAddress(handle, 'nvmlDeviceGetMPSComputeRunningProcesses_v3') + __nvmlDeviceGetMPSComputeRunningProcesses_v3 = _cyb_GetProcAddress(handle, 'nvmlDeviceGetMPSComputeRunningProcesses_v3') global __nvmlDeviceGetRunningProcessDetailList - __nvmlDeviceGetRunningProcessDetailList = GetProcAddress(handle, 'nvmlDeviceGetRunningProcessDetailList') + __nvmlDeviceGetRunningProcessDetailList = _cyb_GetProcAddress(handle, 'nvmlDeviceGetRunningProcessDetailList') global __nvmlDeviceOnSameBoard - __nvmlDeviceOnSameBoard = GetProcAddress(handle, 'nvmlDeviceOnSameBoard') + __nvmlDeviceOnSameBoard = _cyb_GetProcAddress(handle, 'nvmlDeviceOnSameBoard') global __nvmlDeviceGetAPIRestriction - __nvmlDeviceGetAPIRestriction = GetProcAddress(handle, 'nvmlDeviceGetAPIRestriction') + __nvmlDeviceGetAPIRestriction = _cyb_GetProcAddress(handle, 'nvmlDeviceGetAPIRestriction') global __nvmlDeviceGetSamples - __nvmlDeviceGetSamples = GetProcAddress(handle, 'nvmlDeviceGetSamples') + __nvmlDeviceGetSamples = _cyb_GetProcAddress(handle, 'nvmlDeviceGetSamples') global __nvmlDeviceGetBAR1MemoryInfo - __nvmlDeviceGetBAR1MemoryInfo = GetProcAddress(handle, 'nvmlDeviceGetBAR1MemoryInfo') + __nvmlDeviceGetBAR1MemoryInfo = _cyb_GetProcAddress(handle, 'nvmlDeviceGetBAR1MemoryInfo') global __nvmlDeviceGetIrqNum - __nvmlDeviceGetIrqNum = GetProcAddress(handle, 'nvmlDeviceGetIrqNum') + __nvmlDeviceGetIrqNum = _cyb_GetProcAddress(handle, 'nvmlDeviceGetIrqNum') global __nvmlDeviceGetNumGpuCores - __nvmlDeviceGetNumGpuCores = GetProcAddress(handle, 'nvmlDeviceGetNumGpuCores') + __nvmlDeviceGetNumGpuCores = _cyb_GetProcAddress(handle, 'nvmlDeviceGetNumGpuCores') global __nvmlDeviceGetPowerSource - __nvmlDeviceGetPowerSource = GetProcAddress(handle, 'nvmlDeviceGetPowerSource') + __nvmlDeviceGetPowerSource = _cyb_GetProcAddress(handle, 'nvmlDeviceGetPowerSource') global __nvmlDeviceGetMemoryBusWidth - __nvmlDeviceGetMemoryBusWidth = GetProcAddress(handle, 'nvmlDeviceGetMemoryBusWidth') + __nvmlDeviceGetMemoryBusWidth = _cyb_GetProcAddress(handle, 'nvmlDeviceGetMemoryBusWidth') global __nvmlDeviceGetPcieLinkMaxSpeed - __nvmlDeviceGetPcieLinkMaxSpeed = GetProcAddress(handle, 'nvmlDeviceGetPcieLinkMaxSpeed') + __nvmlDeviceGetPcieLinkMaxSpeed = _cyb_GetProcAddress(handle, 'nvmlDeviceGetPcieLinkMaxSpeed') global __nvmlDeviceGetPcieSpeed - __nvmlDeviceGetPcieSpeed = GetProcAddress(handle, 'nvmlDeviceGetPcieSpeed') + __nvmlDeviceGetPcieSpeed = _cyb_GetProcAddress(handle, 'nvmlDeviceGetPcieSpeed') global __nvmlDeviceGetAdaptiveClockInfoStatus - __nvmlDeviceGetAdaptiveClockInfoStatus = GetProcAddress(handle, 'nvmlDeviceGetAdaptiveClockInfoStatus') + __nvmlDeviceGetAdaptiveClockInfoStatus = _cyb_GetProcAddress(handle, 'nvmlDeviceGetAdaptiveClockInfoStatus') global __nvmlDeviceGetBusType - __nvmlDeviceGetBusType = GetProcAddress(handle, 'nvmlDeviceGetBusType') + __nvmlDeviceGetBusType = _cyb_GetProcAddress(handle, 'nvmlDeviceGetBusType') global __nvmlDeviceGetGpuFabricInfoV - __nvmlDeviceGetGpuFabricInfoV = GetProcAddress(handle, 'nvmlDeviceGetGpuFabricInfoV') + __nvmlDeviceGetGpuFabricInfoV = _cyb_GetProcAddress(handle, 'nvmlDeviceGetGpuFabricInfoV') global __nvmlSystemGetConfComputeCapabilities - __nvmlSystemGetConfComputeCapabilities = GetProcAddress(handle, 'nvmlSystemGetConfComputeCapabilities') + __nvmlSystemGetConfComputeCapabilities = _cyb_GetProcAddress(handle, 'nvmlSystemGetConfComputeCapabilities') global __nvmlSystemGetConfComputeState - __nvmlSystemGetConfComputeState = GetProcAddress(handle, 'nvmlSystemGetConfComputeState') + __nvmlSystemGetConfComputeState = _cyb_GetProcAddress(handle, 'nvmlSystemGetConfComputeState') global __nvmlDeviceGetConfComputeMemSizeInfo - __nvmlDeviceGetConfComputeMemSizeInfo = GetProcAddress(handle, 'nvmlDeviceGetConfComputeMemSizeInfo') + __nvmlDeviceGetConfComputeMemSizeInfo = _cyb_GetProcAddress(handle, 'nvmlDeviceGetConfComputeMemSizeInfo') global __nvmlSystemGetConfComputeGpusReadyState - __nvmlSystemGetConfComputeGpusReadyState = GetProcAddress(handle, 'nvmlSystemGetConfComputeGpusReadyState') + __nvmlSystemGetConfComputeGpusReadyState = _cyb_GetProcAddress(handle, 'nvmlSystemGetConfComputeGpusReadyState') global __nvmlDeviceGetConfComputeProtectedMemoryUsage - __nvmlDeviceGetConfComputeProtectedMemoryUsage = GetProcAddress(handle, 'nvmlDeviceGetConfComputeProtectedMemoryUsage') + __nvmlDeviceGetConfComputeProtectedMemoryUsage = _cyb_GetProcAddress(handle, 'nvmlDeviceGetConfComputeProtectedMemoryUsage') global __nvmlDeviceGetConfComputeGpuCertificate - __nvmlDeviceGetConfComputeGpuCertificate = GetProcAddress(handle, 'nvmlDeviceGetConfComputeGpuCertificate') + __nvmlDeviceGetConfComputeGpuCertificate = _cyb_GetProcAddress(handle, 'nvmlDeviceGetConfComputeGpuCertificate') global __nvmlDeviceGetConfComputeGpuAttestationReport - __nvmlDeviceGetConfComputeGpuAttestationReport = GetProcAddress(handle, 'nvmlDeviceGetConfComputeGpuAttestationReport') + __nvmlDeviceGetConfComputeGpuAttestationReport = _cyb_GetProcAddress(handle, 'nvmlDeviceGetConfComputeGpuAttestationReport') global __nvmlSystemGetConfComputeKeyRotationThresholdInfo - __nvmlSystemGetConfComputeKeyRotationThresholdInfo = GetProcAddress(handle, 'nvmlSystemGetConfComputeKeyRotationThresholdInfo') + __nvmlSystemGetConfComputeKeyRotationThresholdInfo = _cyb_GetProcAddress(handle, 'nvmlSystemGetConfComputeKeyRotationThresholdInfo') global __nvmlDeviceSetConfComputeUnprotectedMemSize - __nvmlDeviceSetConfComputeUnprotectedMemSize = GetProcAddress(handle, 'nvmlDeviceSetConfComputeUnprotectedMemSize') + __nvmlDeviceSetConfComputeUnprotectedMemSize = _cyb_GetProcAddress(handle, 'nvmlDeviceSetConfComputeUnprotectedMemSize') global __nvmlSystemSetConfComputeGpusReadyState - __nvmlSystemSetConfComputeGpusReadyState = GetProcAddress(handle, 'nvmlSystemSetConfComputeGpusReadyState') + __nvmlSystemSetConfComputeGpusReadyState = _cyb_GetProcAddress(handle, 'nvmlSystemSetConfComputeGpusReadyState') global __nvmlSystemSetConfComputeKeyRotationThresholdInfo - __nvmlSystemSetConfComputeKeyRotationThresholdInfo = GetProcAddress(handle, 'nvmlSystemSetConfComputeKeyRotationThresholdInfo') + __nvmlSystemSetConfComputeKeyRotationThresholdInfo = _cyb_GetProcAddress(handle, 'nvmlSystemSetConfComputeKeyRotationThresholdInfo') global __nvmlSystemGetConfComputeSettings - __nvmlSystemGetConfComputeSettings = GetProcAddress(handle, 'nvmlSystemGetConfComputeSettings') + __nvmlSystemGetConfComputeSettings = _cyb_GetProcAddress(handle, 'nvmlSystemGetConfComputeSettings') global __nvmlDeviceGetGspFirmwareVersion - __nvmlDeviceGetGspFirmwareVersion = GetProcAddress(handle, 'nvmlDeviceGetGspFirmwareVersion') + __nvmlDeviceGetGspFirmwareVersion = _cyb_GetProcAddress(handle, 'nvmlDeviceGetGspFirmwareVersion') global __nvmlDeviceGetGspFirmwareMode - __nvmlDeviceGetGspFirmwareMode = GetProcAddress(handle, 'nvmlDeviceGetGspFirmwareMode') + __nvmlDeviceGetGspFirmwareMode = _cyb_GetProcAddress(handle, 'nvmlDeviceGetGspFirmwareMode') global __nvmlDeviceGetSramEccErrorStatus - __nvmlDeviceGetSramEccErrorStatus = GetProcAddress(handle, 'nvmlDeviceGetSramEccErrorStatus') + __nvmlDeviceGetSramEccErrorStatus = _cyb_GetProcAddress(handle, 'nvmlDeviceGetSramEccErrorStatus') global __nvmlDeviceGetAccountingMode - __nvmlDeviceGetAccountingMode = GetProcAddress(handle, 'nvmlDeviceGetAccountingMode') + __nvmlDeviceGetAccountingMode = _cyb_GetProcAddress(handle, 'nvmlDeviceGetAccountingMode') global __nvmlDeviceGetAccountingStats - __nvmlDeviceGetAccountingStats = GetProcAddress(handle, 'nvmlDeviceGetAccountingStats') + __nvmlDeviceGetAccountingStats = _cyb_GetProcAddress(handle, 'nvmlDeviceGetAccountingStats') global __nvmlDeviceGetAccountingPids - __nvmlDeviceGetAccountingPids = GetProcAddress(handle, 'nvmlDeviceGetAccountingPids') + __nvmlDeviceGetAccountingPids = _cyb_GetProcAddress(handle, 'nvmlDeviceGetAccountingPids') global __nvmlDeviceGetAccountingBufferSize - __nvmlDeviceGetAccountingBufferSize = GetProcAddress(handle, 'nvmlDeviceGetAccountingBufferSize') + __nvmlDeviceGetAccountingBufferSize = _cyb_GetProcAddress(handle, 'nvmlDeviceGetAccountingBufferSize') global __nvmlDeviceGetRetiredPages - __nvmlDeviceGetRetiredPages = GetProcAddress(handle, 'nvmlDeviceGetRetiredPages') + __nvmlDeviceGetRetiredPages = _cyb_GetProcAddress(handle, 'nvmlDeviceGetRetiredPages') global __nvmlDeviceGetRetiredPages_v2 - __nvmlDeviceGetRetiredPages_v2 = GetProcAddress(handle, 'nvmlDeviceGetRetiredPages_v2') + __nvmlDeviceGetRetiredPages_v2 = _cyb_GetProcAddress(handle, 'nvmlDeviceGetRetiredPages_v2') global __nvmlDeviceGetRetiredPagesPendingStatus - __nvmlDeviceGetRetiredPagesPendingStatus = GetProcAddress(handle, 'nvmlDeviceGetRetiredPagesPendingStatus') + __nvmlDeviceGetRetiredPagesPendingStatus = _cyb_GetProcAddress(handle, 'nvmlDeviceGetRetiredPagesPendingStatus') global __nvmlDeviceGetRemappedRows - __nvmlDeviceGetRemappedRows = GetProcAddress(handle, 'nvmlDeviceGetRemappedRows') + __nvmlDeviceGetRemappedRows = _cyb_GetProcAddress(handle, 'nvmlDeviceGetRemappedRows') global __nvmlDeviceGetRowRemapperHistogram - __nvmlDeviceGetRowRemapperHistogram = GetProcAddress(handle, 'nvmlDeviceGetRowRemapperHistogram') + __nvmlDeviceGetRowRemapperHistogram = _cyb_GetProcAddress(handle, 'nvmlDeviceGetRowRemapperHistogram') global __nvmlDeviceGetArchitecture - __nvmlDeviceGetArchitecture = GetProcAddress(handle, 'nvmlDeviceGetArchitecture') + __nvmlDeviceGetArchitecture = _cyb_GetProcAddress(handle, 'nvmlDeviceGetArchitecture') global __nvmlDeviceGetClkMonStatus - __nvmlDeviceGetClkMonStatus = GetProcAddress(handle, 'nvmlDeviceGetClkMonStatus') + __nvmlDeviceGetClkMonStatus = _cyb_GetProcAddress(handle, 'nvmlDeviceGetClkMonStatus') global __nvmlDeviceGetProcessUtilization - __nvmlDeviceGetProcessUtilization = GetProcAddress(handle, 'nvmlDeviceGetProcessUtilization') + __nvmlDeviceGetProcessUtilization = _cyb_GetProcAddress(handle, 'nvmlDeviceGetProcessUtilization') global __nvmlDeviceGetProcessesUtilizationInfo - __nvmlDeviceGetProcessesUtilizationInfo = GetProcAddress(handle, 'nvmlDeviceGetProcessesUtilizationInfo') + __nvmlDeviceGetProcessesUtilizationInfo = _cyb_GetProcAddress(handle, 'nvmlDeviceGetProcessesUtilizationInfo') global __nvmlDeviceGetPlatformInfo - __nvmlDeviceGetPlatformInfo = GetProcAddress(handle, 'nvmlDeviceGetPlatformInfo') + __nvmlDeviceGetPlatformInfo = _cyb_GetProcAddress(handle, 'nvmlDeviceGetPlatformInfo') global __nvmlUnitSetLedState - __nvmlUnitSetLedState = GetProcAddress(handle, 'nvmlUnitSetLedState') + __nvmlUnitSetLedState = _cyb_GetProcAddress(handle, 'nvmlUnitSetLedState') global __nvmlDeviceSetPersistenceMode - __nvmlDeviceSetPersistenceMode = GetProcAddress(handle, 'nvmlDeviceSetPersistenceMode') + __nvmlDeviceSetPersistenceMode = _cyb_GetProcAddress(handle, 'nvmlDeviceSetPersistenceMode') global __nvmlDeviceSetComputeMode - __nvmlDeviceSetComputeMode = GetProcAddress(handle, 'nvmlDeviceSetComputeMode') + __nvmlDeviceSetComputeMode = _cyb_GetProcAddress(handle, 'nvmlDeviceSetComputeMode') global __nvmlDeviceSetEccMode - __nvmlDeviceSetEccMode = GetProcAddress(handle, 'nvmlDeviceSetEccMode') + __nvmlDeviceSetEccMode = _cyb_GetProcAddress(handle, 'nvmlDeviceSetEccMode') global __nvmlDeviceClearEccErrorCounts - __nvmlDeviceClearEccErrorCounts = GetProcAddress(handle, 'nvmlDeviceClearEccErrorCounts') + __nvmlDeviceClearEccErrorCounts = _cyb_GetProcAddress(handle, 'nvmlDeviceClearEccErrorCounts') global __nvmlDeviceSetDriverModel - __nvmlDeviceSetDriverModel = GetProcAddress(handle, 'nvmlDeviceSetDriverModel') + __nvmlDeviceSetDriverModel = _cyb_GetProcAddress(handle, 'nvmlDeviceSetDriverModel') global __nvmlDeviceSetGpuLockedClocks - __nvmlDeviceSetGpuLockedClocks = GetProcAddress(handle, 'nvmlDeviceSetGpuLockedClocks') + __nvmlDeviceSetGpuLockedClocks = _cyb_GetProcAddress(handle, 'nvmlDeviceSetGpuLockedClocks') global __nvmlDeviceResetGpuLockedClocks - __nvmlDeviceResetGpuLockedClocks = GetProcAddress(handle, 'nvmlDeviceResetGpuLockedClocks') + __nvmlDeviceResetGpuLockedClocks = _cyb_GetProcAddress(handle, 'nvmlDeviceResetGpuLockedClocks') global __nvmlDeviceSetMemoryLockedClocks - __nvmlDeviceSetMemoryLockedClocks = GetProcAddress(handle, 'nvmlDeviceSetMemoryLockedClocks') + __nvmlDeviceSetMemoryLockedClocks = _cyb_GetProcAddress(handle, 'nvmlDeviceSetMemoryLockedClocks') global __nvmlDeviceResetMemoryLockedClocks - __nvmlDeviceResetMemoryLockedClocks = GetProcAddress(handle, 'nvmlDeviceResetMemoryLockedClocks') + __nvmlDeviceResetMemoryLockedClocks = _cyb_GetProcAddress(handle, 'nvmlDeviceResetMemoryLockedClocks') global __nvmlDeviceSetAutoBoostedClocksEnabled - __nvmlDeviceSetAutoBoostedClocksEnabled = GetProcAddress(handle, 'nvmlDeviceSetAutoBoostedClocksEnabled') + __nvmlDeviceSetAutoBoostedClocksEnabled = _cyb_GetProcAddress(handle, 'nvmlDeviceSetAutoBoostedClocksEnabled') global __nvmlDeviceSetDefaultAutoBoostedClocksEnabled - __nvmlDeviceSetDefaultAutoBoostedClocksEnabled = GetProcAddress(handle, 'nvmlDeviceSetDefaultAutoBoostedClocksEnabled') + __nvmlDeviceSetDefaultAutoBoostedClocksEnabled = _cyb_GetProcAddress(handle, 'nvmlDeviceSetDefaultAutoBoostedClocksEnabled') global __nvmlDeviceSetDefaultFanSpeed_v2 - __nvmlDeviceSetDefaultFanSpeed_v2 = GetProcAddress(handle, 'nvmlDeviceSetDefaultFanSpeed_v2') + __nvmlDeviceSetDefaultFanSpeed_v2 = _cyb_GetProcAddress(handle, 'nvmlDeviceSetDefaultFanSpeed_v2') global __nvmlDeviceSetFanControlPolicy - __nvmlDeviceSetFanControlPolicy = GetProcAddress(handle, 'nvmlDeviceSetFanControlPolicy') + __nvmlDeviceSetFanControlPolicy = _cyb_GetProcAddress(handle, 'nvmlDeviceSetFanControlPolicy') global __nvmlDeviceSetTemperatureThreshold - __nvmlDeviceSetTemperatureThreshold = GetProcAddress(handle, 'nvmlDeviceSetTemperatureThreshold') + __nvmlDeviceSetTemperatureThreshold = _cyb_GetProcAddress(handle, 'nvmlDeviceSetTemperatureThreshold') global __nvmlDeviceSetGpuOperationMode - __nvmlDeviceSetGpuOperationMode = GetProcAddress(handle, 'nvmlDeviceSetGpuOperationMode') + __nvmlDeviceSetGpuOperationMode = _cyb_GetProcAddress(handle, 'nvmlDeviceSetGpuOperationMode') global __nvmlDeviceSetAPIRestriction - __nvmlDeviceSetAPIRestriction = GetProcAddress(handle, 'nvmlDeviceSetAPIRestriction') + __nvmlDeviceSetAPIRestriction = _cyb_GetProcAddress(handle, 'nvmlDeviceSetAPIRestriction') global __nvmlDeviceSetFanSpeed_v2 - __nvmlDeviceSetFanSpeed_v2 = GetProcAddress(handle, 'nvmlDeviceSetFanSpeed_v2') + __nvmlDeviceSetFanSpeed_v2 = _cyb_GetProcAddress(handle, 'nvmlDeviceSetFanSpeed_v2') global __nvmlDeviceSetAccountingMode - __nvmlDeviceSetAccountingMode = GetProcAddress(handle, 'nvmlDeviceSetAccountingMode') + __nvmlDeviceSetAccountingMode = _cyb_GetProcAddress(handle, 'nvmlDeviceSetAccountingMode') global __nvmlDeviceClearAccountingPids - __nvmlDeviceClearAccountingPids = GetProcAddress(handle, 'nvmlDeviceClearAccountingPids') + __nvmlDeviceClearAccountingPids = _cyb_GetProcAddress(handle, 'nvmlDeviceClearAccountingPids') global __nvmlDeviceSetPowerManagementLimit_v2 - __nvmlDeviceSetPowerManagementLimit_v2 = GetProcAddress(handle, 'nvmlDeviceSetPowerManagementLimit_v2') + __nvmlDeviceSetPowerManagementLimit_v2 = _cyb_GetProcAddress(handle, 'nvmlDeviceSetPowerManagementLimit_v2') global __nvmlDeviceGetNvLinkState - __nvmlDeviceGetNvLinkState = GetProcAddress(handle, 'nvmlDeviceGetNvLinkState') + __nvmlDeviceGetNvLinkState = _cyb_GetProcAddress(handle, 'nvmlDeviceGetNvLinkState') global __nvmlDeviceGetNvLinkVersion - __nvmlDeviceGetNvLinkVersion = GetProcAddress(handle, 'nvmlDeviceGetNvLinkVersion') + __nvmlDeviceGetNvLinkVersion = _cyb_GetProcAddress(handle, 'nvmlDeviceGetNvLinkVersion') global __nvmlDeviceGetNvLinkCapability - __nvmlDeviceGetNvLinkCapability = GetProcAddress(handle, 'nvmlDeviceGetNvLinkCapability') + __nvmlDeviceGetNvLinkCapability = _cyb_GetProcAddress(handle, 'nvmlDeviceGetNvLinkCapability') global __nvmlDeviceGetNvLinkRemotePciInfo_v2 - __nvmlDeviceGetNvLinkRemotePciInfo_v2 = GetProcAddress(handle, 'nvmlDeviceGetNvLinkRemotePciInfo_v2') + __nvmlDeviceGetNvLinkRemotePciInfo_v2 = _cyb_GetProcAddress(handle, 'nvmlDeviceGetNvLinkRemotePciInfo_v2') global __nvmlDeviceGetNvLinkErrorCounter - __nvmlDeviceGetNvLinkErrorCounter = GetProcAddress(handle, 'nvmlDeviceGetNvLinkErrorCounter') + __nvmlDeviceGetNvLinkErrorCounter = _cyb_GetProcAddress(handle, 'nvmlDeviceGetNvLinkErrorCounter') global __nvmlDeviceResetNvLinkErrorCounters - __nvmlDeviceResetNvLinkErrorCounters = GetProcAddress(handle, 'nvmlDeviceResetNvLinkErrorCounters') + __nvmlDeviceResetNvLinkErrorCounters = _cyb_GetProcAddress(handle, 'nvmlDeviceResetNvLinkErrorCounters') global __nvmlDeviceGetNvLinkRemoteDeviceType - __nvmlDeviceGetNvLinkRemoteDeviceType = GetProcAddress(handle, 'nvmlDeviceGetNvLinkRemoteDeviceType') + __nvmlDeviceGetNvLinkRemoteDeviceType = _cyb_GetProcAddress(handle, 'nvmlDeviceGetNvLinkRemoteDeviceType') global __nvmlDeviceSetNvLinkDeviceLowPowerThreshold - __nvmlDeviceSetNvLinkDeviceLowPowerThreshold = GetProcAddress(handle, 'nvmlDeviceSetNvLinkDeviceLowPowerThreshold') + __nvmlDeviceSetNvLinkDeviceLowPowerThreshold = _cyb_GetProcAddress(handle, 'nvmlDeviceSetNvLinkDeviceLowPowerThreshold') global __nvmlSystemSetNvlinkBwMode - __nvmlSystemSetNvlinkBwMode = GetProcAddress(handle, 'nvmlSystemSetNvlinkBwMode') + __nvmlSystemSetNvlinkBwMode = _cyb_GetProcAddress(handle, 'nvmlSystemSetNvlinkBwMode') global __nvmlSystemGetNvlinkBwMode - __nvmlSystemGetNvlinkBwMode = GetProcAddress(handle, 'nvmlSystemGetNvlinkBwMode') + __nvmlSystemGetNvlinkBwMode = _cyb_GetProcAddress(handle, 'nvmlSystemGetNvlinkBwMode') global __nvmlDeviceGetNvlinkSupportedBwModes - __nvmlDeviceGetNvlinkSupportedBwModes = GetProcAddress(handle, 'nvmlDeviceGetNvlinkSupportedBwModes') + __nvmlDeviceGetNvlinkSupportedBwModes = _cyb_GetProcAddress(handle, 'nvmlDeviceGetNvlinkSupportedBwModes') global __nvmlDeviceGetNvlinkBwMode - __nvmlDeviceGetNvlinkBwMode = GetProcAddress(handle, 'nvmlDeviceGetNvlinkBwMode') + __nvmlDeviceGetNvlinkBwMode = _cyb_GetProcAddress(handle, 'nvmlDeviceGetNvlinkBwMode') global __nvmlDeviceSetNvlinkBwMode - __nvmlDeviceSetNvlinkBwMode = GetProcAddress(handle, 'nvmlDeviceSetNvlinkBwMode') + __nvmlDeviceSetNvlinkBwMode = _cyb_GetProcAddress(handle, 'nvmlDeviceSetNvlinkBwMode') global __nvmlEventSetCreate - __nvmlEventSetCreate = GetProcAddress(handle, 'nvmlEventSetCreate') + __nvmlEventSetCreate = _cyb_GetProcAddress(handle, 'nvmlEventSetCreate') global __nvmlDeviceRegisterEvents - __nvmlDeviceRegisterEvents = GetProcAddress(handle, 'nvmlDeviceRegisterEvents') + __nvmlDeviceRegisterEvents = _cyb_GetProcAddress(handle, 'nvmlDeviceRegisterEvents') global __nvmlDeviceGetSupportedEventTypes - __nvmlDeviceGetSupportedEventTypes = GetProcAddress(handle, 'nvmlDeviceGetSupportedEventTypes') + __nvmlDeviceGetSupportedEventTypes = _cyb_GetProcAddress(handle, 'nvmlDeviceGetSupportedEventTypes') global __nvmlEventSetWait_v2 - __nvmlEventSetWait_v2 = GetProcAddress(handle, 'nvmlEventSetWait_v2') + __nvmlEventSetWait_v2 = _cyb_GetProcAddress(handle, 'nvmlEventSetWait_v2') global __nvmlEventSetFree - __nvmlEventSetFree = GetProcAddress(handle, 'nvmlEventSetFree') + __nvmlEventSetFree = _cyb_GetProcAddress(handle, 'nvmlEventSetFree') global __nvmlSystemEventSetCreate - __nvmlSystemEventSetCreate = GetProcAddress(handle, 'nvmlSystemEventSetCreate') + __nvmlSystemEventSetCreate = _cyb_GetProcAddress(handle, 'nvmlSystemEventSetCreate') global __nvmlSystemEventSetFree - __nvmlSystemEventSetFree = GetProcAddress(handle, 'nvmlSystemEventSetFree') + __nvmlSystemEventSetFree = _cyb_GetProcAddress(handle, 'nvmlSystemEventSetFree') global __nvmlSystemRegisterEvents - __nvmlSystemRegisterEvents = GetProcAddress(handle, 'nvmlSystemRegisterEvents') + __nvmlSystemRegisterEvents = _cyb_GetProcAddress(handle, 'nvmlSystemRegisterEvents') global __nvmlSystemEventSetWait - __nvmlSystemEventSetWait = GetProcAddress(handle, 'nvmlSystemEventSetWait') + __nvmlSystemEventSetWait = _cyb_GetProcAddress(handle, 'nvmlSystemEventSetWait') global __nvmlDeviceModifyDrainState - __nvmlDeviceModifyDrainState = GetProcAddress(handle, 'nvmlDeviceModifyDrainState') + __nvmlDeviceModifyDrainState = _cyb_GetProcAddress(handle, 'nvmlDeviceModifyDrainState') global __nvmlDeviceQueryDrainState - __nvmlDeviceQueryDrainState = GetProcAddress(handle, 'nvmlDeviceQueryDrainState') + __nvmlDeviceQueryDrainState = _cyb_GetProcAddress(handle, 'nvmlDeviceQueryDrainState') global __nvmlDeviceRemoveGpu_v2 - __nvmlDeviceRemoveGpu_v2 = GetProcAddress(handle, 'nvmlDeviceRemoveGpu_v2') + __nvmlDeviceRemoveGpu_v2 = _cyb_GetProcAddress(handle, 'nvmlDeviceRemoveGpu_v2') global __nvmlDeviceDiscoverGpus - __nvmlDeviceDiscoverGpus = GetProcAddress(handle, 'nvmlDeviceDiscoverGpus') + __nvmlDeviceDiscoverGpus = _cyb_GetProcAddress(handle, 'nvmlDeviceDiscoverGpus') global __nvmlDeviceGetFieldValues - __nvmlDeviceGetFieldValues = GetProcAddress(handle, 'nvmlDeviceGetFieldValues') + __nvmlDeviceGetFieldValues = _cyb_GetProcAddress(handle, 'nvmlDeviceGetFieldValues') global __nvmlDeviceClearFieldValues - __nvmlDeviceClearFieldValues = GetProcAddress(handle, 'nvmlDeviceClearFieldValues') + __nvmlDeviceClearFieldValues = _cyb_GetProcAddress(handle, 'nvmlDeviceClearFieldValues') global __nvmlDeviceGetVirtualizationMode - __nvmlDeviceGetVirtualizationMode = GetProcAddress(handle, 'nvmlDeviceGetVirtualizationMode') + __nvmlDeviceGetVirtualizationMode = _cyb_GetProcAddress(handle, 'nvmlDeviceGetVirtualizationMode') global __nvmlDeviceGetHostVgpuMode - __nvmlDeviceGetHostVgpuMode = GetProcAddress(handle, 'nvmlDeviceGetHostVgpuMode') + __nvmlDeviceGetHostVgpuMode = _cyb_GetProcAddress(handle, 'nvmlDeviceGetHostVgpuMode') global __nvmlDeviceSetVirtualizationMode - __nvmlDeviceSetVirtualizationMode = GetProcAddress(handle, 'nvmlDeviceSetVirtualizationMode') + __nvmlDeviceSetVirtualizationMode = _cyb_GetProcAddress(handle, 'nvmlDeviceSetVirtualizationMode') global __nvmlDeviceGetVgpuHeterogeneousMode - __nvmlDeviceGetVgpuHeterogeneousMode = GetProcAddress(handle, 'nvmlDeviceGetVgpuHeterogeneousMode') + __nvmlDeviceGetVgpuHeterogeneousMode = _cyb_GetProcAddress(handle, 'nvmlDeviceGetVgpuHeterogeneousMode') global __nvmlDeviceSetVgpuHeterogeneousMode - __nvmlDeviceSetVgpuHeterogeneousMode = GetProcAddress(handle, 'nvmlDeviceSetVgpuHeterogeneousMode') + __nvmlDeviceSetVgpuHeterogeneousMode = _cyb_GetProcAddress(handle, 'nvmlDeviceSetVgpuHeterogeneousMode') global __nvmlVgpuInstanceGetPlacementId - __nvmlVgpuInstanceGetPlacementId = GetProcAddress(handle, 'nvmlVgpuInstanceGetPlacementId') + __nvmlVgpuInstanceGetPlacementId = _cyb_GetProcAddress(handle, 'nvmlVgpuInstanceGetPlacementId') global __nvmlDeviceGetVgpuTypeSupportedPlacements - __nvmlDeviceGetVgpuTypeSupportedPlacements = GetProcAddress(handle, 'nvmlDeviceGetVgpuTypeSupportedPlacements') + __nvmlDeviceGetVgpuTypeSupportedPlacements = _cyb_GetProcAddress(handle, 'nvmlDeviceGetVgpuTypeSupportedPlacements') global __nvmlDeviceGetVgpuTypeCreatablePlacements - __nvmlDeviceGetVgpuTypeCreatablePlacements = GetProcAddress(handle, 'nvmlDeviceGetVgpuTypeCreatablePlacements') + __nvmlDeviceGetVgpuTypeCreatablePlacements = _cyb_GetProcAddress(handle, 'nvmlDeviceGetVgpuTypeCreatablePlacements') global __nvmlVgpuTypeGetGspHeapSize - __nvmlVgpuTypeGetGspHeapSize = GetProcAddress(handle, 'nvmlVgpuTypeGetGspHeapSize') + __nvmlVgpuTypeGetGspHeapSize = _cyb_GetProcAddress(handle, 'nvmlVgpuTypeGetGspHeapSize') global __nvmlVgpuTypeGetFbReservation - __nvmlVgpuTypeGetFbReservation = GetProcAddress(handle, 'nvmlVgpuTypeGetFbReservation') + __nvmlVgpuTypeGetFbReservation = _cyb_GetProcAddress(handle, 'nvmlVgpuTypeGetFbReservation') global __nvmlVgpuInstanceGetRuntimeStateSize - __nvmlVgpuInstanceGetRuntimeStateSize = GetProcAddress(handle, 'nvmlVgpuInstanceGetRuntimeStateSize') + __nvmlVgpuInstanceGetRuntimeStateSize = _cyb_GetProcAddress(handle, 'nvmlVgpuInstanceGetRuntimeStateSize') global __nvmlDeviceSetVgpuCapabilities - __nvmlDeviceSetVgpuCapabilities = GetProcAddress(handle, 'nvmlDeviceSetVgpuCapabilities') + __nvmlDeviceSetVgpuCapabilities = _cyb_GetProcAddress(handle, 'nvmlDeviceSetVgpuCapabilities') global __nvmlDeviceGetGridLicensableFeatures_v4 - __nvmlDeviceGetGridLicensableFeatures_v4 = GetProcAddress(handle, 'nvmlDeviceGetGridLicensableFeatures_v4') + __nvmlDeviceGetGridLicensableFeatures_v4 = _cyb_GetProcAddress(handle, 'nvmlDeviceGetGridLicensableFeatures_v4') global __nvmlGetVgpuDriverCapabilities - __nvmlGetVgpuDriverCapabilities = GetProcAddress(handle, 'nvmlGetVgpuDriverCapabilities') + __nvmlGetVgpuDriverCapabilities = _cyb_GetProcAddress(handle, 'nvmlGetVgpuDriverCapabilities') global __nvmlDeviceGetVgpuCapabilities - __nvmlDeviceGetVgpuCapabilities = GetProcAddress(handle, 'nvmlDeviceGetVgpuCapabilities') + __nvmlDeviceGetVgpuCapabilities = _cyb_GetProcAddress(handle, 'nvmlDeviceGetVgpuCapabilities') global __nvmlDeviceGetSupportedVgpus - __nvmlDeviceGetSupportedVgpus = GetProcAddress(handle, 'nvmlDeviceGetSupportedVgpus') + __nvmlDeviceGetSupportedVgpus = _cyb_GetProcAddress(handle, 'nvmlDeviceGetSupportedVgpus') global __nvmlDeviceGetCreatableVgpus - __nvmlDeviceGetCreatableVgpus = GetProcAddress(handle, 'nvmlDeviceGetCreatableVgpus') + __nvmlDeviceGetCreatableVgpus = _cyb_GetProcAddress(handle, 'nvmlDeviceGetCreatableVgpus') global __nvmlVgpuTypeGetClass - __nvmlVgpuTypeGetClass = GetProcAddress(handle, 'nvmlVgpuTypeGetClass') + __nvmlVgpuTypeGetClass = _cyb_GetProcAddress(handle, 'nvmlVgpuTypeGetClass') global __nvmlVgpuTypeGetName - __nvmlVgpuTypeGetName = GetProcAddress(handle, 'nvmlVgpuTypeGetName') + __nvmlVgpuTypeGetName = _cyb_GetProcAddress(handle, 'nvmlVgpuTypeGetName') global __nvmlVgpuTypeGetGpuInstanceProfileId - __nvmlVgpuTypeGetGpuInstanceProfileId = GetProcAddress(handle, 'nvmlVgpuTypeGetGpuInstanceProfileId') + __nvmlVgpuTypeGetGpuInstanceProfileId = _cyb_GetProcAddress(handle, 'nvmlVgpuTypeGetGpuInstanceProfileId') global __nvmlVgpuTypeGetDeviceID - __nvmlVgpuTypeGetDeviceID = GetProcAddress(handle, 'nvmlVgpuTypeGetDeviceID') + __nvmlVgpuTypeGetDeviceID = _cyb_GetProcAddress(handle, 'nvmlVgpuTypeGetDeviceID') global __nvmlVgpuTypeGetFramebufferSize - __nvmlVgpuTypeGetFramebufferSize = GetProcAddress(handle, 'nvmlVgpuTypeGetFramebufferSize') + __nvmlVgpuTypeGetFramebufferSize = _cyb_GetProcAddress(handle, 'nvmlVgpuTypeGetFramebufferSize') global __nvmlVgpuTypeGetNumDisplayHeads - __nvmlVgpuTypeGetNumDisplayHeads = GetProcAddress(handle, 'nvmlVgpuTypeGetNumDisplayHeads') + __nvmlVgpuTypeGetNumDisplayHeads = _cyb_GetProcAddress(handle, 'nvmlVgpuTypeGetNumDisplayHeads') global __nvmlVgpuTypeGetResolution - __nvmlVgpuTypeGetResolution = GetProcAddress(handle, 'nvmlVgpuTypeGetResolution') + __nvmlVgpuTypeGetResolution = _cyb_GetProcAddress(handle, 'nvmlVgpuTypeGetResolution') global __nvmlVgpuTypeGetLicense - __nvmlVgpuTypeGetLicense = GetProcAddress(handle, 'nvmlVgpuTypeGetLicense') + __nvmlVgpuTypeGetLicense = _cyb_GetProcAddress(handle, 'nvmlVgpuTypeGetLicense') global __nvmlVgpuTypeGetFrameRateLimit - __nvmlVgpuTypeGetFrameRateLimit = GetProcAddress(handle, 'nvmlVgpuTypeGetFrameRateLimit') + __nvmlVgpuTypeGetFrameRateLimit = _cyb_GetProcAddress(handle, 'nvmlVgpuTypeGetFrameRateLimit') global __nvmlVgpuTypeGetMaxInstances - __nvmlVgpuTypeGetMaxInstances = GetProcAddress(handle, 'nvmlVgpuTypeGetMaxInstances') + __nvmlVgpuTypeGetMaxInstances = _cyb_GetProcAddress(handle, 'nvmlVgpuTypeGetMaxInstances') global __nvmlVgpuTypeGetMaxInstancesPerVm - __nvmlVgpuTypeGetMaxInstancesPerVm = GetProcAddress(handle, 'nvmlVgpuTypeGetMaxInstancesPerVm') + __nvmlVgpuTypeGetMaxInstancesPerVm = _cyb_GetProcAddress(handle, 'nvmlVgpuTypeGetMaxInstancesPerVm') global __nvmlVgpuTypeGetBAR1Info - __nvmlVgpuTypeGetBAR1Info = GetProcAddress(handle, 'nvmlVgpuTypeGetBAR1Info') + __nvmlVgpuTypeGetBAR1Info = _cyb_GetProcAddress(handle, 'nvmlVgpuTypeGetBAR1Info') global __nvmlDeviceGetActiveVgpus - __nvmlDeviceGetActiveVgpus = GetProcAddress(handle, 'nvmlDeviceGetActiveVgpus') + __nvmlDeviceGetActiveVgpus = _cyb_GetProcAddress(handle, 'nvmlDeviceGetActiveVgpus') global __nvmlVgpuInstanceGetVmID - __nvmlVgpuInstanceGetVmID = GetProcAddress(handle, 'nvmlVgpuInstanceGetVmID') + __nvmlVgpuInstanceGetVmID = _cyb_GetProcAddress(handle, 'nvmlVgpuInstanceGetVmID') global __nvmlVgpuInstanceGetUUID - __nvmlVgpuInstanceGetUUID = GetProcAddress(handle, 'nvmlVgpuInstanceGetUUID') + __nvmlVgpuInstanceGetUUID = _cyb_GetProcAddress(handle, 'nvmlVgpuInstanceGetUUID') global __nvmlVgpuInstanceGetVmDriverVersion - __nvmlVgpuInstanceGetVmDriverVersion = GetProcAddress(handle, 'nvmlVgpuInstanceGetVmDriverVersion') + __nvmlVgpuInstanceGetVmDriverVersion = _cyb_GetProcAddress(handle, 'nvmlVgpuInstanceGetVmDriverVersion') global __nvmlVgpuInstanceGetFbUsage - __nvmlVgpuInstanceGetFbUsage = GetProcAddress(handle, 'nvmlVgpuInstanceGetFbUsage') + __nvmlVgpuInstanceGetFbUsage = _cyb_GetProcAddress(handle, 'nvmlVgpuInstanceGetFbUsage') global __nvmlVgpuInstanceGetLicenseStatus - __nvmlVgpuInstanceGetLicenseStatus = GetProcAddress(handle, 'nvmlVgpuInstanceGetLicenseStatus') + __nvmlVgpuInstanceGetLicenseStatus = _cyb_GetProcAddress(handle, 'nvmlVgpuInstanceGetLicenseStatus') global __nvmlVgpuInstanceGetType - __nvmlVgpuInstanceGetType = GetProcAddress(handle, 'nvmlVgpuInstanceGetType') + __nvmlVgpuInstanceGetType = _cyb_GetProcAddress(handle, 'nvmlVgpuInstanceGetType') global __nvmlVgpuInstanceGetFrameRateLimit - __nvmlVgpuInstanceGetFrameRateLimit = GetProcAddress(handle, 'nvmlVgpuInstanceGetFrameRateLimit') + __nvmlVgpuInstanceGetFrameRateLimit = _cyb_GetProcAddress(handle, 'nvmlVgpuInstanceGetFrameRateLimit') global __nvmlVgpuInstanceGetEccMode - __nvmlVgpuInstanceGetEccMode = GetProcAddress(handle, 'nvmlVgpuInstanceGetEccMode') + __nvmlVgpuInstanceGetEccMode = _cyb_GetProcAddress(handle, 'nvmlVgpuInstanceGetEccMode') global __nvmlVgpuInstanceGetEncoderCapacity - __nvmlVgpuInstanceGetEncoderCapacity = GetProcAddress(handle, 'nvmlVgpuInstanceGetEncoderCapacity') + __nvmlVgpuInstanceGetEncoderCapacity = _cyb_GetProcAddress(handle, 'nvmlVgpuInstanceGetEncoderCapacity') global __nvmlVgpuInstanceSetEncoderCapacity - __nvmlVgpuInstanceSetEncoderCapacity = GetProcAddress(handle, 'nvmlVgpuInstanceSetEncoderCapacity') + __nvmlVgpuInstanceSetEncoderCapacity = _cyb_GetProcAddress(handle, 'nvmlVgpuInstanceSetEncoderCapacity') global __nvmlVgpuInstanceGetEncoderStats - __nvmlVgpuInstanceGetEncoderStats = GetProcAddress(handle, 'nvmlVgpuInstanceGetEncoderStats') + __nvmlVgpuInstanceGetEncoderStats = _cyb_GetProcAddress(handle, 'nvmlVgpuInstanceGetEncoderStats') global __nvmlVgpuInstanceGetEncoderSessions - __nvmlVgpuInstanceGetEncoderSessions = GetProcAddress(handle, 'nvmlVgpuInstanceGetEncoderSessions') + __nvmlVgpuInstanceGetEncoderSessions = _cyb_GetProcAddress(handle, 'nvmlVgpuInstanceGetEncoderSessions') global __nvmlVgpuInstanceGetFBCStats - __nvmlVgpuInstanceGetFBCStats = GetProcAddress(handle, 'nvmlVgpuInstanceGetFBCStats') + __nvmlVgpuInstanceGetFBCStats = _cyb_GetProcAddress(handle, 'nvmlVgpuInstanceGetFBCStats') global __nvmlVgpuInstanceGetFBCSessions - __nvmlVgpuInstanceGetFBCSessions = GetProcAddress(handle, 'nvmlVgpuInstanceGetFBCSessions') + __nvmlVgpuInstanceGetFBCSessions = _cyb_GetProcAddress(handle, 'nvmlVgpuInstanceGetFBCSessions') global __nvmlVgpuInstanceGetGpuInstanceId - __nvmlVgpuInstanceGetGpuInstanceId = GetProcAddress(handle, 'nvmlVgpuInstanceGetGpuInstanceId') + __nvmlVgpuInstanceGetGpuInstanceId = _cyb_GetProcAddress(handle, 'nvmlVgpuInstanceGetGpuInstanceId') global __nvmlVgpuInstanceGetGpuPciId - __nvmlVgpuInstanceGetGpuPciId = GetProcAddress(handle, 'nvmlVgpuInstanceGetGpuPciId') + __nvmlVgpuInstanceGetGpuPciId = _cyb_GetProcAddress(handle, 'nvmlVgpuInstanceGetGpuPciId') global __nvmlVgpuTypeGetCapabilities - __nvmlVgpuTypeGetCapabilities = GetProcAddress(handle, 'nvmlVgpuTypeGetCapabilities') + __nvmlVgpuTypeGetCapabilities = _cyb_GetProcAddress(handle, 'nvmlVgpuTypeGetCapabilities') global __nvmlVgpuInstanceGetMdevUUID - __nvmlVgpuInstanceGetMdevUUID = GetProcAddress(handle, 'nvmlVgpuInstanceGetMdevUUID') + __nvmlVgpuInstanceGetMdevUUID = _cyb_GetProcAddress(handle, 'nvmlVgpuInstanceGetMdevUUID') global __nvmlGpuInstanceGetCreatableVgpus - __nvmlGpuInstanceGetCreatableVgpus = GetProcAddress(handle, 'nvmlGpuInstanceGetCreatableVgpus') + __nvmlGpuInstanceGetCreatableVgpus = _cyb_GetProcAddress(handle, 'nvmlGpuInstanceGetCreatableVgpus') global __nvmlVgpuTypeGetMaxInstancesPerGpuInstance - __nvmlVgpuTypeGetMaxInstancesPerGpuInstance = GetProcAddress(handle, 'nvmlVgpuTypeGetMaxInstancesPerGpuInstance') + __nvmlVgpuTypeGetMaxInstancesPerGpuInstance = _cyb_GetProcAddress(handle, 'nvmlVgpuTypeGetMaxInstancesPerGpuInstance') global __nvmlGpuInstanceGetActiveVgpus - __nvmlGpuInstanceGetActiveVgpus = GetProcAddress(handle, 'nvmlGpuInstanceGetActiveVgpus') + __nvmlGpuInstanceGetActiveVgpus = _cyb_GetProcAddress(handle, 'nvmlGpuInstanceGetActiveVgpus') global __nvmlGpuInstanceSetVgpuSchedulerState - __nvmlGpuInstanceSetVgpuSchedulerState = GetProcAddress(handle, 'nvmlGpuInstanceSetVgpuSchedulerState') + __nvmlGpuInstanceSetVgpuSchedulerState = _cyb_GetProcAddress(handle, 'nvmlGpuInstanceSetVgpuSchedulerState') global __nvmlGpuInstanceGetVgpuSchedulerState - __nvmlGpuInstanceGetVgpuSchedulerState = GetProcAddress(handle, 'nvmlGpuInstanceGetVgpuSchedulerState') + __nvmlGpuInstanceGetVgpuSchedulerState = _cyb_GetProcAddress(handle, 'nvmlGpuInstanceGetVgpuSchedulerState') global __nvmlGpuInstanceGetVgpuSchedulerLog - __nvmlGpuInstanceGetVgpuSchedulerLog = GetProcAddress(handle, 'nvmlGpuInstanceGetVgpuSchedulerLog') + __nvmlGpuInstanceGetVgpuSchedulerLog = _cyb_GetProcAddress(handle, 'nvmlGpuInstanceGetVgpuSchedulerLog') global __nvmlGpuInstanceGetVgpuTypeCreatablePlacements - __nvmlGpuInstanceGetVgpuTypeCreatablePlacements = GetProcAddress(handle, 'nvmlGpuInstanceGetVgpuTypeCreatablePlacements') + __nvmlGpuInstanceGetVgpuTypeCreatablePlacements = _cyb_GetProcAddress(handle, 'nvmlGpuInstanceGetVgpuTypeCreatablePlacements') global __nvmlGpuInstanceGetVgpuHeterogeneousMode - __nvmlGpuInstanceGetVgpuHeterogeneousMode = GetProcAddress(handle, 'nvmlGpuInstanceGetVgpuHeterogeneousMode') + __nvmlGpuInstanceGetVgpuHeterogeneousMode = _cyb_GetProcAddress(handle, 'nvmlGpuInstanceGetVgpuHeterogeneousMode') global __nvmlGpuInstanceSetVgpuHeterogeneousMode - __nvmlGpuInstanceSetVgpuHeterogeneousMode = GetProcAddress(handle, 'nvmlGpuInstanceSetVgpuHeterogeneousMode') + __nvmlGpuInstanceSetVgpuHeterogeneousMode = _cyb_GetProcAddress(handle, 'nvmlGpuInstanceSetVgpuHeterogeneousMode') global __nvmlVgpuInstanceGetMetadata - __nvmlVgpuInstanceGetMetadata = GetProcAddress(handle, 'nvmlVgpuInstanceGetMetadata') + __nvmlVgpuInstanceGetMetadata = _cyb_GetProcAddress(handle, 'nvmlVgpuInstanceGetMetadata') global __nvmlDeviceGetVgpuMetadata - __nvmlDeviceGetVgpuMetadata = GetProcAddress(handle, 'nvmlDeviceGetVgpuMetadata') + __nvmlDeviceGetVgpuMetadata = _cyb_GetProcAddress(handle, 'nvmlDeviceGetVgpuMetadata') global __nvmlGetVgpuCompatibility - __nvmlGetVgpuCompatibility = GetProcAddress(handle, 'nvmlGetVgpuCompatibility') + __nvmlGetVgpuCompatibility = _cyb_GetProcAddress(handle, 'nvmlGetVgpuCompatibility') global __nvmlDeviceGetPgpuMetadataString - __nvmlDeviceGetPgpuMetadataString = GetProcAddress(handle, 'nvmlDeviceGetPgpuMetadataString') + __nvmlDeviceGetPgpuMetadataString = _cyb_GetProcAddress(handle, 'nvmlDeviceGetPgpuMetadataString') global __nvmlDeviceGetVgpuSchedulerLog - __nvmlDeviceGetVgpuSchedulerLog = GetProcAddress(handle, 'nvmlDeviceGetVgpuSchedulerLog') + __nvmlDeviceGetVgpuSchedulerLog = _cyb_GetProcAddress(handle, 'nvmlDeviceGetVgpuSchedulerLog') global __nvmlDeviceGetVgpuSchedulerState - __nvmlDeviceGetVgpuSchedulerState = GetProcAddress(handle, 'nvmlDeviceGetVgpuSchedulerState') + __nvmlDeviceGetVgpuSchedulerState = _cyb_GetProcAddress(handle, 'nvmlDeviceGetVgpuSchedulerState') global __nvmlDeviceGetVgpuSchedulerCapabilities - __nvmlDeviceGetVgpuSchedulerCapabilities = GetProcAddress(handle, 'nvmlDeviceGetVgpuSchedulerCapabilities') + __nvmlDeviceGetVgpuSchedulerCapabilities = _cyb_GetProcAddress(handle, 'nvmlDeviceGetVgpuSchedulerCapabilities') global __nvmlDeviceSetVgpuSchedulerState - __nvmlDeviceSetVgpuSchedulerState = GetProcAddress(handle, 'nvmlDeviceSetVgpuSchedulerState') + __nvmlDeviceSetVgpuSchedulerState = _cyb_GetProcAddress(handle, 'nvmlDeviceSetVgpuSchedulerState') global __nvmlGetVgpuVersion - __nvmlGetVgpuVersion = GetProcAddress(handle, 'nvmlGetVgpuVersion') + __nvmlGetVgpuVersion = _cyb_GetProcAddress(handle, 'nvmlGetVgpuVersion') global __nvmlSetVgpuVersion - __nvmlSetVgpuVersion = GetProcAddress(handle, 'nvmlSetVgpuVersion') + __nvmlSetVgpuVersion = _cyb_GetProcAddress(handle, 'nvmlSetVgpuVersion') global __nvmlDeviceGetVgpuUtilization - __nvmlDeviceGetVgpuUtilization = GetProcAddress(handle, 'nvmlDeviceGetVgpuUtilization') + __nvmlDeviceGetVgpuUtilization = _cyb_GetProcAddress(handle, 'nvmlDeviceGetVgpuUtilization') global __nvmlDeviceGetVgpuInstancesUtilizationInfo - __nvmlDeviceGetVgpuInstancesUtilizationInfo = GetProcAddress(handle, 'nvmlDeviceGetVgpuInstancesUtilizationInfo') + __nvmlDeviceGetVgpuInstancesUtilizationInfo = _cyb_GetProcAddress(handle, 'nvmlDeviceGetVgpuInstancesUtilizationInfo') global __nvmlDeviceGetVgpuProcessUtilization - __nvmlDeviceGetVgpuProcessUtilization = GetProcAddress(handle, 'nvmlDeviceGetVgpuProcessUtilization') + __nvmlDeviceGetVgpuProcessUtilization = _cyb_GetProcAddress(handle, 'nvmlDeviceGetVgpuProcessUtilization') global __nvmlDeviceGetVgpuProcessesUtilizationInfo - __nvmlDeviceGetVgpuProcessesUtilizationInfo = GetProcAddress(handle, 'nvmlDeviceGetVgpuProcessesUtilizationInfo') + __nvmlDeviceGetVgpuProcessesUtilizationInfo = _cyb_GetProcAddress(handle, 'nvmlDeviceGetVgpuProcessesUtilizationInfo') global __nvmlVgpuInstanceGetAccountingMode - __nvmlVgpuInstanceGetAccountingMode = GetProcAddress(handle, 'nvmlVgpuInstanceGetAccountingMode') + __nvmlVgpuInstanceGetAccountingMode = _cyb_GetProcAddress(handle, 'nvmlVgpuInstanceGetAccountingMode') global __nvmlVgpuInstanceGetAccountingPids - __nvmlVgpuInstanceGetAccountingPids = GetProcAddress(handle, 'nvmlVgpuInstanceGetAccountingPids') + __nvmlVgpuInstanceGetAccountingPids = _cyb_GetProcAddress(handle, 'nvmlVgpuInstanceGetAccountingPids') global __nvmlVgpuInstanceGetAccountingStats - __nvmlVgpuInstanceGetAccountingStats = GetProcAddress(handle, 'nvmlVgpuInstanceGetAccountingStats') + __nvmlVgpuInstanceGetAccountingStats = _cyb_GetProcAddress(handle, 'nvmlVgpuInstanceGetAccountingStats') global __nvmlVgpuInstanceClearAccountingPids - __nvmlVgpuInstanceClearAccountingPids = GetProcAddress(handle, 'nvmlVgpuInstanceClearAccountingPids') + __nvmlVgpuInstanceClearAccountingPids = _cyb_GetProcAddress(handle, 'nvmlVgpuInstanceClearAccountingPids') global __nvmlVgpuInstanceGetLicenseInfo_v2 - __nvmlVgpuInstanceGetLicenseInfo_v2 = GetProcAddress(handle, 'nvmlVgpuInstanceGetLicenseInfo_v2') + __nvmlVgpuInstanceGetLicenseInfo_v2 = _cyb_GetProcAddress(handle, 'nvmlVgpuInstanceGetLicenseInfo_v2') global __nvmlGetExcludedDeviceCount - __nvmlGetExcludedDeviceCount = GetProcAddress(handle, 'nvmlGetExcludedDeviceCount') + __nvmlGetExcludedDeviceCount = _cyb_GetProcAddress(handle, 'nvmlGetExcludedDeviceCount') global __nvmlGetExcludedDeviceInfoByIndex - __nvmlGetExcludedDeviceInfoByIndex = GetProcAddress(handle, 'nvmlGetExcludedDeviceInfoByIndex') + __nvmlGetExcludedDeviceInfoByIndex = _cyb_GetProcAddress(handle, 'nvmlGetExcludedDeviceInfoByIndex') global __nvmlDeviceSetMigMode - __nvmlDeviceSetMigMode = GetProcAddress(handle, 'nvmlDeviceSetMigMode') + __nvmlDeviceSetMigMode = _cyb_GetProcAddress(handle, 'nvmlDeviceSetMigMode') global __nvmlDeviceGetMigMode - __nvmlDeviceGetMigMode = GetProcAddress(handle, 'nvmlDeviceGetMigMode') + __nvmlDeviceGetMigMode = _cyb_GetProcAddress(handle, 'nvmlDeviceGetMigMode') global __nvmlDeviceGetGpuInstanceProfileInfoV - __nvmlDeviceGetGpuInstanceProfileInfoV = GetProcAddress(handle, 'nvmlDeviceGetGpuInstanceProfileInfoV') + __nvmlDeviceGetGpuInstanceProfileInfoV = _cyb_GetProcAddress(handle, 'nvmlDeviceGetGpuInstanceProfileInfoV') global __nvmlDeviceGetGpuInstancePossiblePlacements_v2 - __nvmlDeviceGetGpuInstancePossiblePlacements_v2 = GetProcAddress(handle, 'nvmlDeviceGetGpuInstancePossiblePlacements_v2') + __nvmlDeviceGetGpuInstancePossiblePlacements_v2 = _cyb_GetProcAddress(handle, 'nvmlDeviceGetGpuInstancePossiblePlacements_v2') global __nvmlDeviceGetGpuInstanceRemainingCapacity - __nvmlDeviceGetGpuInstanceRemainingCapacity = GetProcAddress(handle, 'nvmlDeviceGetGpuInstanceRemainingCapacity') + __nvmlDeviceGetGpuInstanceRemainingCapacity = _cyb_GetProcAddress(handle, 'nvmlDeviceGetGpuInstanceRemainingCapacity') global __nvmlDeviceCreateGpuInstance - __nvmlDeviceCreateGpuInstance = GetProcAddress(handle, 'nvmlDeviceCreateGpuInstance') + __nvmlDeviceCreateGpuInstance = _cyb_GetProcAddress(handle, 'nvmlDeviceCreateGpuInstance') global __nvmlDeviceCreateGpuInstanceWithPlacement - __nvmlDeviceCreateGpuInstanceWithPlacement = GetProcAddress(handle, 'nvmlDeviceCreateGpuInstanceWithPlacement') + __nvmlDeviceCreateGpuInstanceWithPlacement = _cyb_GetProcAddress(handle, 'nvmlDeviceCreateGpuInstanceWithPlacement') global __nvmlGpuInstanceDestroy - __nvmlGpuInstanceDestroy = GetProcAddress(handle, 'nvmlGpuInstanceDestroy') + __nvmlGpuInstanceDestroy = _cyb_GetProcAddress(handle, 'nvmlGpuInstanceDestroy') global __nvmlDeviceGetGpuInstances - __nvmlDeviceGetGpuInstances = GetProcAddress(handle, 'nvmlDeviceGetGpuInstances') + __nvmlDeviceGetGpuInstances = _cyb_GetProcAddress(handle, 'nvmlDeviceGetGpuInstances') global __nvmlDeviceGetGpuInstanceById - __nvmlDeviceGetGpuInstanceById = GetProcAddress(handle, 'nvmlDeviceGetGpuInstanceById') + __nvmlDeviceGetGpuInstanceById = _cyb_GetProcAddress(handle, 'nvmlDeviceGetGpuInstanceById') global __nvmlGpuInstanceGetInfo - __nvmlGpuInstanceGetInfo = GetProcAddress(handle, 'nvmlGpuInstanceGetInfo') + __nvmlGpuInstanceGetInfo = _cyb_GetProcAddress(handle, 'nvmlGpuInstanceGetInfo') global __nvmlGpuInstanceGetComputeInstanceProfileInfoV - __nvmlGpuInstanceGetComputeInstanceProfileInfoV = GetProcAddress(handle, 'nvmlGpuInstanceGetComputeInstanceProfileInfoV') + __nvmlGpuInstanceGetComputeInstanceProfileInfoV = _cyb_GetProcAddress(handle, 'nvmlGpuInstanceGetComputeInstanceProfileInfoV') global __nvmlGpuInstanceGetComputeInstanceRemainingCapacity - __nvmlGpuInstanceGetComputeInstanceRemainingCapacity = GetProcAddress(handle, 'nvmlGpuInstanceGetComputeInstanceRemainingCapacity') + __nvmlGpuInstanceGetComputeInstanceRemainingCapacity = _cyb_GetProcAddress(handle, 'nvmlGpuInstanceGetComputeInstanceRemainingCapacity') global __nvmlGpuInstanceGetComputeInstancePossiblePlacements - __nvmlGpuInstanceGetComputeInstancePossiblePlacements = GetProcAddress(handle, 'nvmlGpuInstanceGetComputeInstancePossiblePlacements') + __nvmlGpuInstanceGetComputeInstancePossiblePlacements = _cyb_GetProcAddress(handle, 'nvmlGpuInstanceGetComputeInstancePossiblePlacements') global __nvmlGpuInstanceCreateComputeInstance - __nvmlGpuInstanceCreateComputeInstance = GetProcAddress(handle, 'nvmlGpuInstanceCreateComputeInstance') + __nvmlGpuInstanceCreateComputeInstance = _cyb_GetProcAddress(handle, 'nvmlGpuInstanceCreateComputeInstance') global __nvmlGpuInstanceCreateComputeInstanceWithPlacement - __nvmlGpuInstanceCreateComputeInstanceWithPlacement = GetProcAddress(handle, 'nvmlGpuInstanceCreateComputeInstanceWithPlacement') + __nvmlGpuInstanceCreateComputeInstanceWithPlacement = _cyb_GetProcAddress(handle, 'nvmlGpuInstanceCreateComputeInstanceWithPlacement') global __nvmlComputeInstanceDestroy - __nvmlComputeInstanceDestroy = GetProcAddress(handle, 'nvmlComputeInstanceDestroy') + __nvmlComputeInstanceDestroy = _cyb_GetProcAddress(handle, 'nvmlComputeInstanceDestroy') global __nvmlGpuInstanceGetComputeInstances - __nvmlGpuInstanceGetComputeInstances = GetProcAddress(handle, 'nvmlGpuInstanceGetComputeInstances') + __nvmlGpuInstanceGetComputeInstances = _cyb_GetProcAddress(handle, 'nvmlGpuInstanceGetComputeInstances') global __nvmlGpuInstanceGetComputeInstanceById - __nvmlGpuInstanceGetComputeInstanceById = GetProcAddress(handle, 'nvmlGpuInstanceGetComputeInstanceById') + __nvmlGpuInstanceGetComputeInstanceById = _cyb_GetProcAddress(handle, 'nvmlGpuInstanceGetComputeInstanceById') global __nvmlComputeInstanceGetInfo_v2 - __nvmlComputeInstanceGetInfo_v2 = GetProcAddress(handle, 'nvmlComputeInstanceGetInfo_v2') + __nvmlComputeInstanceGetInfo_v2 = _cyb_GetProcAddress(handle, 'nvmlComputeInstanceGetInfo_v2') global __nvmlDeviceIsMigDeviceHandle - __nvmlDeviceIsMigDeviceHandle = GetProcAddress(handle, 'nvmlDeviceIsMigDeviceHandle') + __nvmlDeviceIsMigDeviceHandle = _cyb_GetProcAddress(handle, 'nvmlDeviceIsMigDeviceHandle') global __nvmlDeviceGetGpuInstanceId - __nvmlDeviceGetGpuInstanceId = GetProcAddress(handle, 'nvmlDeviceGetGpuInstanceId') + __nvmlDeviceGetGpuInstanceId = _cyb_GetProcAddress(handle, 'nvmlDeviceGetGpuInstanceId') global __nvmlDeviceGetComputeInstanceId - __nvmlDeviceGetComputeInstanceId = GetProcAddress(handle, 'nvmlDeviceGetComputeInstanceId') + __nvmlDeviceGetComputeInstanceId = _cyb_GetProcAddress(handle, 'nvmlDeviceGetComputeInstanceId') global __nvmlDeviceGetMaxMigDeviceCount - __nvmlDeviceGetMaxMigDeviceCount = GetProcAddress(handle, 'nvmlDeviceGetMaxMigDeviceCount') + __nvmlDeviceGetMaxMigDeviceCount = _cyb_GetProcAddress(handle, 'nvmlDeviceGetMaxMigDeviceCount') global __nvmlDeviceGetMigDeviceHandleByIndex - __nvmlDeviceGetMigDeviceHandleByIndex = GetProcAddress(handle, 'nvmlDeviceGetMigDeviceHandleByIndex') + __nvmlDeviceGetMigDeviceHandleByIndex = _cyb_GetProcAddress(handle, 'nvmlDeviceGetMigDeviceHandleByIndex') global __nvmlDeviceGetDeviceHandleFromMigDeviceHandle - __nvmlDeviceGetDeviceHandleFromMigDeviceHandle = GetProcAddress(handle, 'nvmlDeviceGetDeviceHandleFromMigDeviceHandle') + __nvmlDeviceGetDeviceHandleFromMigDeviceHandle = _cyb_GetProcAddress(handle, 'nvmlDeviceGetDeviceHandleFromMigDeviceHandle') global __nvmlDeviceGetCapabilities - __nvmlDeviceGetCapabilities = GetProcAddress(handle, 'nvmlDeviceGetCapabilities') + __nvmlDeviceGetCapabilities = _cyb_GetProcAddress(handle, 'nvmlDeviceGetCapabilities') global __nvmlDevicePowerSmoothingActivatePresetProfile - __nvmlDevicePowerSmoothingActivatePresetProfile = GetProcAddress(handle, 'nvmlDevicePowerSmoothingActivatePresetProfile') + __nvmlDevicePowerSmoothingActivatePresetProfile = _cyb_GetProcAddress(handle, 'nvmlDevicePowerSmoothingActivatePresetProfile') global __nvmlDevicePowerSmoothingUpdatePresetProfileParam - __nvmlDevicePowerSmoothingUpdatePresetProfileParam = GetProcAddress(handle, 'nvmlDevicePowerSmoothingUpdatePresetProfileParam') + __nvmlDevicePowerSmoothingUpdatePresetProfileParam = _cyb_GetProcAddress(handle, 'nvmlDevicePowerSmoothingUpdatePresetProfileParam') global __nvmlDevicePowerSmoothingSetState - __nvmlDevicePowerSmoothingSetState = GetProcAddress(handle, 'nvmlDevicePowerSmoothingSetState') + __nvmlDevicePowerSmoothingSetState = _cyb_GetProcAddress(handle, 'nvmlDevicePowerSmoothingSetState') global __nvmlDeviceGetAddressingMode - __nvmlDeviceGetAddressingMode = GetProcAddress(handle, 'nvmlDeviceGetAddressingMode') + __nvmlDeviceGetAddressingMode = _cyb_GetProcAddress(handle, 'nvmlDeviceGetAddressingMode') global __nvmlDeviceGetRepairStatus - __nvmlDeviceGetRepairStatus = GetProcAddress(handle, 'nvmlDeviceGetRepairStatus') + __nvmlDeviceGetRepairStatus = _cyb_GetProcAddress(handle, 'nvmlDeviceGetRepairStatus') global __nvmlDeviceGetPowerMizerMode_v1 - __nvmlDeviceGetPowerMizerMode_v1 = GetProcAddress(handle, 'nvmlDeviceGetPowerMizerMode_v1') + __nvmlDeviceGetPowerMizerMode_v1 = _cyb_GetProcAddress(handle, 'nvmlDeviceGetPowerMizerMode_v1') global __nvmlDeviceSetPowerMizerMode_v1 - __nvmlDeviceSetPowerMizerMode_v1 = GetProcAddress(handle, 'nvmlDeviceSetPowerMizerMode_v1') + __nvmlDeviceSetPowerMizerMode_v1 = _cyb_GetProcAddress(handle, 'nvmlDeviceSetPowerMizerMode_v1') global __nvmlDeviceGetPdi - __nvmlDeviceGetPdi = GetProcAddress(handle, 'nvmlDeviceGetPdi') + __nvmlDeviceGetPdi = _cyb_GetProcAddress(handle, 'nvmlDeviceGetPdi') global __nvmlDeviceSetHostname_v1 - __nvmlDeviceSetHostname_v1 = GetProcAddress(handle, 'nvmlDeviceSetHostname_v1') + __nvmlDeviceSetHostname_v1 = _cyb_GetProcAddress(handle, 'nvmlDeviceSetHostname_v1') global __nvmlDeviceGetHostname_v1 - __nvmlDeviceGetHostname_v1 = GetProcAddress(handle, 'nvmlDeviceGetHostname_v1') + __nvmlDeviceGetHostname_v1 = _cyb_GetProcAddress(handle, 'nvmlDeviceGetHostname_v1') global __nvmlDeviceGetNvLinkInfo - __nvmlDeviceGetNvLinkInfo = GetProcAddress(handle, 'nvmlDeviceGetNvLinkInfo') + __nvmlDeviceGetNvLinkInfo = _cyb_GetProcAddress(handle, 'nvmlDeviceGetNvLinkInfo') global __nvmlDeviceReadWritePRM_v1 - __nvmlDeviceReadWritePRM_v1 = GetProcAddress(handle, 'nvmlDeviceReadWritePRM_v1') + __nvmlDeviceReadWritePRM_v1 = _cyb_GetProcAddress(handle, 'nvmlDeviceReadWritePRM_v1') global __nvmlDeviceGetGpuInstanceProfileInfoByIdV - __nvmlDeviceGetGpuInstanceProfileInfoByIdV = GetProcAddress(handle, 'nvmlDeviceGetGpuInstanceProfileInfoByIdV') + __nvmlDeviceGetGpuInstanceProfileInfoByIdV = _cyb_GetProcAddress(handle, 'nvmlDeviceGetGpuInstanceProfileInfoByIdV') global __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts - __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts = GetProcAddress(handle, 'nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts') + __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts = _cyb_GetProcAddress(handle, 'nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts') global __nvmlDeviceGetUnrepairableMemoryFlag_v1 - __nvmlDeviceGetUnrepairableMemoryFlag_v1 = GetProcAddress(handle, 'nvmlDeviceGetUnrepairableMemoryFlag_v1') + __nvmlDeviceGetUnrepairableMemoryFlag_v1 = _cyb_GetProcAddress(handle, 'nvmlDeviceGetUnrepairableMemoryFlag_v1') global __nvmlDeviceReadPRMCounters_v1 - __nvmlDeviceReadPRMCounters_v1 = GetProcAddress(handle, 'nvmlDeviceReadPRMCounters_v1') + __nvmlDeviceReadPRMCounters_v1 = _cyb_GetProcAddress(handle, 'nvmlDeviceReadPRMCounters_v1') global __nvmlDeviceSetRusdSettings_v1 - __nvmlDeviceSetRusdSettings_v1 = GetProcAddress(handle, 'nvmlDeviceSetRusdSettings_v1') + __nvmlDeviceSetRusdSettings_v1 = _cyb_GetProcAddress(handle, 'nvmlDeviceSetRusdSettings_v1') global __nvmlDeviceVgpuForceGspUnload - __nvmlDeviceVgpuForceGspUnload = GetProcAddress(handle, 'nvmlDeviceVgpuForceGspUnload') + __nvmlDeviceVgpuForceGspUnload = _cyb_GetProcAddress(handle, 'nvmlDeviceVgpuForceGspUnload') global __nvmlDeviceGetVgpuSchedulerState_v2 - __nvmlDeviceGetVgpuSchedulerState_v2 = GetProcAddress(handle, 'nvmlDeviceGetVgpuSchedulerState_v2') + __nvmlDeviceGetVgpuSchedulerState_v2 = _cyb_GetProcAddress(handle, 'nvmlDeviceGetVgpuSchedulerState_v2') global __nvmlGpuInstanceGetVgpuSchedulerState_v2 - __nvmlGpuInstanceGetVgpuSchedulerState_v2 = GetProcAddress(handle, 'nvmlGpuInstanceGetVgpuSchedulerState_v2') + __nvmlGpuInstanceGetVgpuSchedulerState_v2 = _cyb_GetProcAddress(handle, 'nvmlGpuInstanceGetVgpuSchedulerState_v2') global __nvmlDeviceGetVgpuSchedulerLog_v2 - __nvmlDeviceGetVgpuSchedulerLog_v2 = GetProcAddress(handle, 'nvmlDeviceGetVgpuSchedulerLog_v2') + __nvmlDeviceGetVgpuSchedulerLog_v2 = _cyb_GetProcAddress(handle, 'nvmlDeviceGetVgpuSchedulerLog_v2') global __nvmlGpuInstanceGetVgpuSchedulerLog_v2 - __nvmlGpuInstanceGetVgpuSchedulerLog_v2 = GetProcAddress(handle, 'nvmlGpuInstanceGetVgpuSchedulerLog_v2') + __nvmlGpuInstanceGetVgpuSchedulerLog_v2 = _cyb_GetProcAddress(handle, 'nvmlGpuInstanceGetVgpuSchedulerLog_v2') global __nvmlDeviceSetVgpuSchedulerState_v2 - __nvmlDeviceSetVgpuSchedulerState_v2 = GetProcAddress(handle, 'nvmlDeviceSetVgpuSchedulerState_v2') + __nvmlDeviceSetVgpuSchedulerState_v2 = _cyb_GetProcAddress(handle, 'nvmlDeviceSetVgpuSchedulerState_v2') global __nvmlGpuInstanceSetVgpuSchedulerState_v2 - __nvmlGpuInstanceSetVgpuSchedulerState_v2 = GetProcAddress(handle, 'nvmlGpuInstanceSetVgpuSchedulerState_v2') + __nvmlGpuInstanceSetVgpuSchedulerState_v2 = _cyb_GetProcAddress(handle, 'nvmlGpuInstanceSetVgpuSchedulerState_v2') - __py_nvml_init = True + _cyb___py_nvml_init = True return 0 - cdef inline int _check_or_init_nvml() except -1 nogil: - if __py_nvml_init: + if _cyb___py_nvml_init: return 0 return _init_nvml() -cdef dict func_ptrs = None - - cpdef dict _inspect_function_pointers(): - global func_ptrs - if func_ptrs is not None: - return func_ptrs + global _cyb_func_ptrs + if _cyb_func_ptrs is not None: + return _cyb_func_ptrs _check_or_init_nvml() cdef dict data = {} - global __nvmlInit_v2 - data["__nvmlInit_v2"] = __nvmlInit_v2 + data["__nvmlInit_v2"] = <_cyb_intptr_t>__nvmlInit_v2 global __nvmlInitWithFlags - data["__nvmlInitWithFlags"] = __nvmlInitWithFlags + data["__nvmlInitWithFlags"] = <_cyb_intptr_t>__nvmlInitWithFlags global __nvmlShutdown - data["__nvmlShutdown"] = __nvmlShutdown + data["__nvmlShutdown"] = <_cyb_intptr_t>__nvmlShutdown global __nvmlErrorString - data["__nvmlErrorString"] = __nvmlErrorString + data["__nvmlErrorString"] = <_cyb_intptr_t>__nvmlErrorString global __nvmlSystemGetDriverVersion - data["__nvmlSystemGetDriverVersion"] = __nvmlSystemGetDriverVersion + data["__nvmlSystemGetDriverVersion"] = <_cyb_intptr_t>__nvmlSystemGetDriverVersion global __nvmlSystemGetNVMLVersion - data["__nvmlSystemGetNVMLVersion"] = __nvmlSystemGetNVMLVersion + data["__nvmlSystemGetNVMLVersion"] = <_cyb_intptr_t>__nvmlSystemGetNVMLVersion global __nvmlSystemGetCudaDriverVersion - data["__nvmlSystemGetCudaDriverVersion"] = __nvmlSystemGetCudaDriverVersion + data["__nvmlSystemGetCudaDriverVersion"] = <_cyb_intptr_t>__nvmlSystemGetCudaDriverVersion global __nvmlSystemGetCudaDriverVersion_v2 - data["__nvmlSystemGetCudaDriverVersion_v2"] = __nvmlSystemGetCudaDriverVersion_v2 + data["__nvmlSystemGetCudaDriverVersion_v2"] = <_cyb_intptr_t>__nvmlSystemGetCudaDriverVersion_v2 global __nvmlSystemGetProcessName - data["__nvmlSystemGetProcessName"] = __nvmlSystemGetProcessName + data["__nvmlSystemGetProcessName"] = <_cyb_intptr_t>__nvmlSystemGetProcessName global __nvmlSystemGetHicVersion - data["__nvmlSystemGetHicVersion"] = __nvmlSystemGetHicVersion + data["__nvmlSystemGetHicVersion"] = <_cyb_intptr_t>__nvmlSystemGetHicVersion global __nvmlSystemGetTopologyGpuSet - data["__nvmlSystemGetTopologyGpuSet"] = __nvmlSystemGetTopologyGpuSet + data["__nvmlSystemGetTopologyGpuSet"] = <_cyb_intptr_t>__nvmlSystemGetTopologyGpuSet global __nvmlSystemGetDriverBranch - data["__nvmlSystemGetDriverBranch"] = __nvmlSystemGetDriverBranch + data["__nvmlSystemGetDriverBranch"] = <_cyb_intptr_t>__nvmlSystemGetDriverBranch global __nvmlUnitGetCount - data["__nvmlUnitGetCount"] = __nvmlUnitGetCount + data["__nvmlUnitGetCount"] = <_cyb_intptr_t>__nvmlUnitGetCount global __nvmlUnitGetHandleByIndex - data["__nvmlUnitGetHandleByIndex"] = __nvmlUnitGetHandleByIndex + data["__nvmlUnitGetHandleByIndex"] = <_cyb_intptr_t>__nvmlUnitGetHandleByIndex global __nvmlUnitGetUnitInfo - data["__nvmlUnitGetUnitInfo"] = __nvmlUnitGetUnitInfo + data["__nvmlUnitGetUnitInfo"] = <_cyb_intptr_t>__nvmlUnitGetUnitInfo global __nvmlUnitGetLedState - data["__nvmlUnitGetLedState"] = __nvmlUnitGetLedState + data["__nvmlUnitGetLedState"] = <_cyb_intptr_t>__nvmlUnitGetLedState global __nvmlUnitGetPsuInfo - data["__nvmlUnitGetPsuInfo"] = __nvmlUnitGetPsuInfo + data["__nvmlUnitGetPsuInfo"] = <_cyb_intptr_t>__nvmlUnitGetPsuInfo global __nvmlUnitGetTemperature - data["__nvmlUnitGetTemperature"] = __nvmlUnitGetTemperature + data["__nvmlUnitGetTemperature"] = <_cyb_intptr_t>__nvmlUnitGetTemperature global __nvmlUnitGetFanSpeedInfo - data["__nvmlUnitGetFanSpeedInfo"] = __nvmlUnitGetFanSpeedInfo + data["__nvmlUnitGetFanSpeedInfo"] = <_cyb_intptr_t>__nvmlUnitGetFanSpeedInfo global __nvmlUnitGetDevices - data["__nvmlUnitGetDevices"] = __nvmlUnitGetDevices + data["__nvmlUnitGetDevices"] = <_cyb_intptr_t>__nvmlUnitGetDevices global __nvmlDeviceGetCount_v2 - data["__nvmlDeviceGetCount_v2"] = __nvmlDeviceGetCount_v2 + data["__nvmlDeviceGetCount_v2"] = <_cyb_intptr_t>__nvmlDeviceGetCount_v2 global __nvmlDeviceGetAttributes_v2 - data["__nvmlDeviceGetAttributes_v2"] = __nvmlDeviceGetAttributes_v2 + data["__nvmlDeviceGetAttributes_v2"] = <_cyb_intptr_t>__nvmlDeviceGetAttributes_v2 global __nvmlDeviceGetHandleByIndex_v2 - data["__nvmlDeviceGetHandleByIndex_v2"] = __nvmlDeviceGetHandleByIndex_v2 + data["__nvmlDeviceGetHandleByIndex_v2"] = <_cyb_intptr_t>__nvmlDeviceGetHandleByIndex_v2 global __nvmlDeviceGetHandleBySerial - data["__nvmlDeviceGetHandleBySerial"] = __nvmlDeviceGetHandleBySerial + data["__nvmlDeviceGetHandleBySerial"] = <_cyb_intptr_t>__nvmlDeviceGetHandleBySerial global __nvmlDeviceGetHandleByUUID - data["__nvmlDeviceGetHandleByUUID"] = __nvmlDeviceGetHandleByUUID + data["__nvmlDeviceGetHandleByUUID"] = <_cyb_intptr_t>__nvmlDeviceGetHandleByUUID global __nvmlDeviceGetHandleByUUIDV - data["__nvmlDeviceGetHandleByUUIDV"] = __nvmlDeviceGetHandleByUUIDV + data["__nvmlDeviceGetHandleByUUIDV"] = <_cyb_intptr_t>__nvmlDeviceGetHandleByUUIDV global __nvmlDeviceGetHandleByPciBusId_v2 - data["__nvmlDeviceGetHandleByPciBusId_v2"] = __nvmlDeviceGetHandleByPciBusId_v2 + data["__nvmlDeviceGetHandleByPciBusId_v2"] = <_cyb_intptr_t>__nvmlDeviceGetHandleByPciBusId_v2 global __nvmlDeviceGetName - data["__nvmlDeviceGetName"] = __nvmlDeviceGetName + data["__nvmlDeviceGetName"] = <_cyb_intptr_t>__nvmlDeviceGetName global __nvmlDeviceGetBrand - data["__nvmlDeviceGetBrand"] = __nvmlDeviceGetBrand + data["__nvmlDeviceGetBrand"] = <_cyb_intptr_t>__nvmlDeviceGetBrand global __nvmlDeviceGetIndex - data["__nvmlDeviceGetIndex"] = __nvmlDeviceGetIndex + data["__nvmlDeviceGetIndex"] = <_cyb_intptr_t>__nvmlDeviceGetIndex global __nvmlDeviceGetSerial - data["__nvmlDeviceGetSerial"] = __nvmlDeviceGetSerial + data["__nvmlDeviceGetSerial"] = <_cyb_intptr_t>__nvmlDeviceGetSerial global __nvmlDeviceGetModuleId - data["__nvmlDeviceGetModuleId"] = __nvmlDeviceGetModuleId + data["__nvmlDeviceGetModuleId"] = <_cyb_intptr_t>__nvmlDeviceGetModuleId global __nvmlDeviceGetC2cModeInfoV - data["__nvmlDeviceGetC2cModeInfoV"] = __nvmlDeviceGetC2cModeInfoV + data["__nvmlDeviceGetC2cModeInfoV"] = <_cyb_intptr_t>__nvmlDeviceGetC2cModeInfoV global __nvmlDeviceGetMemoryAffinity - data["__nvmlDeviceGetMemoryAffinity"] = __nvmlDeviceGetMemoryAffinity + data["__nvmlDeviceGetMemoryAffinity"] = <_cyb_intptr_t>__nvmlDeviceGetMemoryAffinity global __nvmlDeviceGetCpuAffinityWithinScope - data["__nvmlDeviceGetCpuAffinityWithinScope"] = __nvmlDeviceGetCpuAffinityWithinScope + data["__nvmlDeviceGetCpuAffinityWithinScope"] = <_cyb_intptr_t>__nvmlDeviceGetCpuAffinityWithinScope global __nvmlDeviceGetCpuAffinity - data["__nvmlDeviceGetCpuAffinity"] = __nvmlDeviceGetCpuAffinity + data["__nvmlDeviceGetCpuAffinity"] = <_cyb_intptr_t>__nvmlDeviceGetCpuAffinity global __nvmlDeviceSetCpuAffinity - data["__nvmlDeviceSetCpuAffinity"] = __nvmlDeviceSetCpuAffinity + data["__nvmlDeviceSetCpuAffinity"] = <_cyb_intptr_t>__nvmlDeviceSetCpuAffinity global __nvmlDeviceClearCpuAffinity - data["__nvmlDeviceClearCpuAffinity"] = __nvmlDeviceClearCpuAffinity + data["__nvmlDeviceClearCpuAffinity"] = <_cyb_intptr_t>__nvmlDeviceClearCpuAffinity global __nvmlDeviceGetNumaNodeId - data["__nvmlDeviceGetNumaNodeId"] = __nvmlDeviceGetNumaNodeId + data["__nvmlDeviceGetNumaNodeId"] = <_cyb_intptr_t>__nvmlDeviceGetNumaNodeId global __nvmlDeviceGetTopologyCommonAncestor - data["__nvmlDeviceGetTopologyCommonAncestor"] = __nvmlDeviceGetTopologyCommonAncestor + data["__nvmlDeviceGetTopologyCommonAncestor"] = <_cyb_intptr_t>__nvmlDeviceGetTopologyCommonAncestor global __nvmlDeviceGetTopologyNearestGpus - data["__nvmlDeviceGetTopologyNearestGpus"] = __nvmlDeviceGetTopologyNearestGpus + data["__nvmlDeviceGetTopologyNearestGpus"] = <_cyb_intptr_t>__nvmlDeviceGetTopologyNearestGpus global __nvmlDeviceGetP2PStatus - data["__nvmlDeviceGetP2PStatus"] = __nvmlDeviceGetP2PStatus + data["__nvmlDeviceGetP2PStatus"] = <_cyb_intptr_t>__nvmlDeviceGetP2PStatus global __nvmlDeviceGetUUID - data["__nvmlDeviceGetUUID"] = __nvmlDeviceGetUUID + data["__nvmlDeviceGetUUID"] = <_cyb_intptr_t>__nvmlDeviceGetUUID global __nvmlDeviceGetMinorNumber - data["__nvmlDeviceGetMinorNumber"] = __nvmlDeviceGetMinorNumber + data["__nvmlDeviceGetMinorNumber"] = <_cyb_intptr_t>__nvmlDeviceGetMinorNumber global __nvmlDeviceGetBoardPartNumber - data["__nvmlDeviceGetBoardPartNumber"] = __nvmlDeviceGetBoardPartNumber + data["__nvmlDeviceGetBoardPartNumber"] = <_cyb_intptr_t>__nvmlDeviceGetBoardPartNumber global __nvmlDeviceGetInforomVersion - data["__nvmlDeviceGetInforomVersion"] = __nvmlDeviceGetInforomVersion + data["__nvmlDeviceGetInforomVersion"] = <_cyb_intptr_t>__nvmlDeviceGetInforomVersion global __nvmlDeviceGetInforomImageVersion - data["__nvmlDeviceGetInforomImageVersion"] = __nvmlDeviceGetInforomImageVersion + data["__nvmlDeviceGetInforomImageVersion"] = <_cyb_intptr_t>__nvmlDeviceGetInforomImageVersion global __nvmlDeviceGetInforomConfigurationChecksum - data["__nvmlDeviceGetInforomConfigurationChecksum"] = __nvmlDeviceGetInforomConfigurationChecksum + data["__nvmlDeviceGetInforomConfigurationChecksum"] = <_cyb_intptr_t>__nvmlDeviceGetInforomConfigurationChecksum global __nvmlDeviceValidateInforom - data["__nvmlDeviceValidateInforom"] = __nvmlDeviceValidateInforom + data["__nvmlDeviceValidateInforom"] = <_cyb_intptr_t>__nvmlDeviceValidateInforom global __nvmlDeviceGetLastBBXFlushTime - data["__nvmlDeviceGetLastBBXFlushTime"] = __nvmlDeviceGetLastBBXFlushTime + data["__nvmlDeviceGetLastBBXFlushTime"] = <_cyb_intptr_t>__nvmlDeviceGetLastBBXFlushTime global __nvmlDeviceGetDisplayMode - data["__nvmlDeviceGetDisplayMode"] = __nvmlDeviceGetDisplayMode + data["__nvmlDeviceGetDisplayMode"] = <_cyb_intptr_t>__nvmlDeviceGetDisplayMode global __nvmlDeviceGetDisplayActive - data["__nvmlDeviceGetDisplayActive"] = __nvmlDeviceGetDisplayActive + data["__nvmlDeviceGetDisplayActive"] = <_cyb_intptr_t>__nvmlDeviceGetDisplayActive global __nvmlDeviceGetPersistenceMode - data["__nvmlDeviceGetPersistenceMode"] = __nvmlDeviceGetPersistenceMode + data["__nvmlDeviceGetPersistenceMode"] = <_cyb_intptr_t>__nvmlDeviceGetPersistenceMode global __nvmlDeviceGetPciInfoExt - data["__nvmlDeviceGetPciInfoExt"] = __nvmlDeviceGetPciInfoExt + data["__nvmlDeviceGetPciInfoExt"] = <_cyb_intptr_t>__nvmlDeviceGetPciInfoExt global __nvmlDeviceGetPciInfo_v3 - data["__nvmlDeviceGetPciInfo_v3"] = __nvmlDeviceGetPciInfo_v3 + data["__nvmlDeviceGetPciInfo_v3"] = <_cyb_intptr_t>__nvmlDeviceGetPciInfo_v3 global __nvmlDeviceGetMaxPcieLinkGeneration - data["__nvmlDeviceGetMaxPcieLinkGeneration"] = __nvmlDeviceGetMaxPcieLinkGeneration + data["__nvmlDeviceGetMaxPcieLinkGeneration"] = <_cyb_intptr_t>__nvmlDeviceGetMaxPcieLinkGeneration global __nvmlDeviceGetGpuMaxPcieLinkGeneration - data["__nvmlDeviceGetGpuMaxPcieLinkGeneration"] = __nvmlDeviceGetGpuMaxPcieLinkGeneration + data["__nvmlDeviceGetGpuMaxPcieLinkGeneration"] = <_cyb_intptr_t>__nvmlDeviceGetGpuMaxPcieLinkGeneration global __nvmlDeviceGetMaxPcieLinkWidth - data["__nvmlDeviceGetMaxPcieLinkWidth"] = __nvmlDeviceGetMaxPcieLinkWidth + data["__nvmlDeviceGetMaxPcieLinkWidth"] = <_cyb_intptr_t>__nvmlDeviceGetMaxPcieLinkWidth global __nvmlDeviceGetCurrPcieLinkGeneration - data["__nvmlDeviceGetCurrPcieLinkGeneration"] = __nvmlDeviceGetCurrPcieLinkGeneration + data["__nvmlDeviceGetCurrPcieLinkGeneration"] = <_cyb_intptr_t>__nvmlDeviceGetCurrPcieLinkGeneration global __nvmlDeviceGetCurrPcieLinkWidth - data["__nvmlDeviceGetCurrPcieLinkWidth"] = __nvmlDeviceGetCurrPcieLinkWidth + data["__nvmlDeviceGetCurrPcieLinkWidth"] = <_cyb_intptr_t>__nvmlDeviceGetCurrPcieLinkWidth global __nvmlDeviceGetPcieThroughput - data["__nvmlDeviceGetPcieThroughput"] = __nvmlDeviceGetPcieThroughput + data["__nvmlDeviceGetPcieThroughput"] = <_cyb_intptr_t>__nvmlDeviceGetPcieThroughput global __nvmlDeviceGetPcieReplayCounter - data["__nvmlDeviceGetPcieReplayCounter"] = __nvmlDeviceGetPcieReplayCounter + data["__nvmlDeviceGetPcieReplayCounter"] = <_cyb_intptr_t>__nvmlDeviceGetPcieReplayCounter global __nvmlDeviceGetClockInfo - data["__nvmlDeviceGetClockInfo"] = __nvmlDeviceGetClockInfo + data["__nvmlDeviceGetClockInfo"] = <_cyb_intptr_t>__nvmlDeviceGetClockInfo global __nvmlDeviceGetMaxClockInfo - data["__nvmlDeviceGetMaxClockInfo"] = __nvmlDeviceGetMaxClockInfo + data["__nvmlDeviceGetMaxClockInfo"] = <_cyb_intptr_t>__nvmlDeviceGetMaxClockInfo global __nvmlDeviceGetGpcClkVfOffset - data["__nvmlDeviceGetGpcClkVfOffset"] = __nvmlDeviceGetGpcClkVfOffset + data["__nvmlDeviceGetGpcClkVfOffset"] = <_cyb_intptr_t>__nvmlDeviceGetGpcClkVfOffset global __nvmlDeviceGetClock - data["__nvmlDeviceGetClock"] = __nvmlDeviceGetClock + data["__nvmlDeviceGetClock"] = <_cyb_intptr_t>__nvmlDeviceGetClock global __nvmlDeviceGetMaxCustomerBoostClock - data["__nvmlDeviceGetMaxCustomerBoostClock"] = __nvmlDeviceGetMaxCustomerBoostClock + data["__nvmlDeviceGetMaxCustomerBoostClock"] = <_cyb_intptr_t>__nvmlDeviceGetMaxCustomerBoostClock global __nvmlDeviceGetSupportedMemoryClocks - data["__nvmlDeviceGetSupportedMemoryClocks"] = __nvmlDeviceGetSupportedMemoryClocks + data["__nvmlDeviceGetSupportedMemoryClocks"] = <_cyb_intptr_t>__nvmlDeviceGetSupportedMemoryClocks global __nvmlDeviceGetSupportedGraphicsClocks - data["__nvmlDeviceGetSupportedGraphicsClocks"] = __nvmlDeviceGetSupportedGraphicsClocks + data["__nvmlDeviceGetSupportedGraphicsClocks"] = <_cyb_intptr_t>__nvmlDeviceGetSupportedGraphicsClocks global __nvmlDeviceGetAutoBoostedClocksEnabled - data["__nvmlDeviceGetAutoBoostedClocksEnabled"] = __nvmlDeviceGetAutoBoostedClocksEnabled + data["__nvmlDeviceGetAutoBoostedClocksEnabled"] = <_cyb_intptr_t>__nvmlDeviceGetAutoBoostedClocksEnabled global __nvmlDeviceGetFanSpeed - data["__nvmlDeviceGetFanSpeed"] = __nvmlDeviceGetFanSpeed + data["__nvmlDeviceGetFanSpeed"] = <_cyb_intptr_t>__nvmlDeviceGetFanSpeed global __nvmlDeviceGetFanSpeed_v2 - data["__nvmlDeviceGetFanSpeed_v2"] = __nvmlDeviceGetFanSpeed_v2 + data["__nvmlDeviceGetFanSpeed_v2"] = <_cyb_intptr_t>__nvmlDeviceGetFanSpeed_v2 global __nvmlDeviceGetFanSpeedRPM - data["__nvmlDeviceGetFanSpeedRPM"] = __nvmlDeviceGetFanSpeedRPM + data["__nvmlDeviceGetFanSpeedRPM"] = <_cyb_intptr_t>__nvmlDeviceGetFanSpeedRPM global __nvmlDeviceGetTargetFanSpeed - data["__nvmlDeviceGetTargetFanSpeed"] = __nvmlDeviceGetTargetFanSpeed + data["__nvmlDeviceGetTargetFanSpeed"] = <_cyb_intptr_t>__nvmlDeviceGetTargetFanSpeed global __nvmlDeviceGetMinMaxFanSpeed - data["__nvmlDeviceGetMinMaxFanSpeed"] = __nvmlDeviceGetMinMaxFanSpeed + data["__nvmlDeviceGetMinMaxFanSpeed"] = <_cyb_intptr_t>__nvmlDeviceGetMinMaxFanSpeed global __nvmlDeviceGetFanControlPolicy_v2 - data["__nvmlDeviceGetFanControlPolicy_v2"] = __nvmlDeviceGetFanControlPolicy_v2 + data["__nvmlDeviceGetFanControlPolicy_v2"] = <_cyb_intptr_t>__nvmlDeviceGetFanControlPolicy_v2 global __nvmlDeviceGetNumFans - data["__nvmlDeviceGetNumFans"] = __nvmlDeviceGetNumFans + data["__nvmlDeviceGetNumFans"] = <_cyb_intptr_t>__nvmlDeviceGetNumFans global __nvmlDeviceGetCoolerInfo - data["__nvmlDeviceGetCoolerInfo"] = __nvmlDeviceGetCoolerInfo + data["__nvmlDeviceGetCoolerInfo"] = <_cyb_intptr_t>__nvmlDeviceGetCoolerInfo global __nvmlDeviceGetTemperatureV - data["__nvmlDeviceGetTemperatureV"] = __nvmlDeviceGetTemperatureV + data["__nvmlDeviceGetTemperatureV"] = <_cyb_intptr_t>__nvmlDeviceGetTemperatureV global __nvmlDeviceGetTemperatureThreshold - data["__nvmlDeviceGetTemperatureThreshold"] = __nvmlDeviceGetTemperatureThreshold + data["__nvmlDeviceGetTemperatureThreshold"] = <_cyb_intptr_t>__nvmlDeviceGetTemperatureThreshold global __nvmlDeviceGetMarginTemperature - data["__nvmlDeviceGetMarginTemperature"] = __nvmlDeviceGetMarginTemperature + data["__nvmlDeviceGetMarginTemperature"] = <_cyb_intptr_t>__nvmlDeviceGetMarginTemperature global __nvmlDeviceGetThermalSettings - data["__nvmlDeviceGetThermalSettings"] = __nvmlDeviceGetThermalSettings + data["__nvmlDeviceGetThermalSettings"] = <_cyb_intptr_t>__nvmlDeviceGetThermalSettings global __nvmlDeviceGetPerformanceState - data["__nvmlDeviceGetPerformanceState"] = __nvmlDeviceGetPerformanceState + data["__nvmlDeviceGetPerformanceState"] = <_cyb_intptr_t>__nvmlDeviceGetPerformanceState global __nvmlDeviceGetCurrentClocksEventReasons - data["__nvmlDeviceGetCurrentClocksEventReasons"] = __nvmlDeviceGetCurrentClocksEventReasons + data["__nvmlDeviceGetCurrentClocksEventReasons"] = <_cyb_intptr_t>__nvmlDeviceGetCurrentClocksEventReasons global __nvmlDeviceGetSupportedClocksEventReasons - data["__nvmlDeviceGetSupportedClocksEventReasons"] = __nvmlDeviceGetSupportedClocksEventReasons + data["__nvmlDeviceGetSupportedClocksEventReasons"] = <_cyb_intptr_t>__nvmlDeviceGetSupportedClocksEventReasons global __nvmlDeviceGetPowerState - data["__nvmlDeviceGetPowerState"] = __nvmlDeviceGetPowerState + data["__nvmlDeviceGetPowerState"] = <_cyb_intptr_t>__nvmlDeviceGetPowerState global __nvmlDeviceGetDynamicPstatesInfo - data["__nvmlDeviceGetDynamicPstatesInfo"] = __nvmlDeviceGetDynamicPstatesInfo + data["__nvmlDeviceGetDynamicPstatesInfo"] = <_cyb_intptr_t>__nvmlDeviceGetDynamicPstatesInfo global __nvmlDeviceGetMemClkVfOffset - data["__nvmlDeviceGetMemClkVfOffset"] = __nvmlDeviceGetMemClkVfOffset + data["__nvmlDeviceGetMemClkVfOffset"] = <_cyb_intptr_t>__nvmlDeviceGetMemClkVfOffset global __nvmlDeviceGetMinMaxClockOfPState - data["__nvmlDeviceGetMinMaxClockOfPState"] = __nvmlDeviceGetMinMaxClockOfPState + data["__nvmlDeviceGetMinMaxClockOfPState"] = <_cyb_intptr_t>__nvmlDeviceGetMinMaxClockOfPState global __nvmlDeviceGetSupportedPerformanceStates - data["__nvmlDeviceGetSupportedPerformanceStates"] = __nvmlDeviceGetSupportedPerformanceStates + data["__nvmlDeviceGetSupportedPerformanceStates"] = <_cyb_intptr_t>__nvmlDeviceGetSupportedPerformanceStates global __nvmlDeviceGetGpcClkMinMaxVfOffset - data["__nvmlDeviceGetGpcClkMinMaxVfOffset"] = __nvmlDeviceGetGpcClkMinMaxVfOffset + data["__nvmlDeviceGetGpcClkMinMaxVfOffset"] = <_cyb_intptr_t>__nvmlDeviceGetGpcClkMinMaxVfOffset global __nvmlDeviceGetMemClkMinMaxVfOffset - data["__nvmlDeviceGetMemClkMinMaxVfOffset"] = __nvmlDeviceGetMemClkMinMaxVfOffset + data["__nvmlDeviceGetMemClkMinMaxVfOffset"] = <_cyb_intptr_t>__nvmlDeviceGetMemClkMinMaxVfOffset global __nvmlDeviceGetClockOffsets - data["__nvmlDeviceGetClockOffsets"] = __nvmlDeviceGetClockOffsets + data["__nvmlDeviceGetClockOffsets"] = <_cyb_intptr_t>__nvmlDeviceGetClockOffsets global __nvmlDeviceSetClockOffsets - data["__nvmlDeviceSetClockOffsets"] = __nvmlDeviceSetClockOffsets + data["__nvmlDeviceSetClockOffsets"] = <_cyb_intptr_t>__nvmlDeviceSetClockOffsets global __nvmlDeviceGetPerformanceModes - data["__nvmlDeviceGetPerformanceModes"] = __nvmlDeviceGetPerformanceModes + data["__nvmlDeviceGetPerformanceModes"] = <_cyb_intptr_t>__nvmlDeviceGetPerformanceModes global __nvmlDeviceGetCurrentClockFreqs - data["__nvmlDeviceGetCurrentClockFreqs"] = __nvmlDeviceGetCurrentClockFreqs + data["__nvmlDeviceGetCurrentClockFreqs"] = <_cyb_intptr_t>__nvmlDeviceGetCurrentClockFreqs global __nvmlDeviceGetPowerManagementLimit - data["__nvmlDeviceGetPowerManagementLimit"] = __nvmlDeviceGetPowerManagementLimit + data["__nvmlDeviceGetPowerManagementLimit"] = <_cyb_intptr_t>__nvmlDeviceGetPowerManagementLimit global __nvmlDeviceGetPowerManagementLimitConstraints - data["__nvmlDeviceGetPowerManagementLimitConstraints"] = __nvmlDeviceGetPowerManagementLimitConstraints + data["__nvmlDeviceGetPowerManagementLimitConstraints"] = <_cyb_intptr_t>__nvmlDeviceGetPowerManagementLimitConstraints global __nvmlDeviceGetPowerManagementDefaultLimit - data["__nvmlDeviceGetPowerManagementDefaultLimit"] = __nvmlDeviceGetPowerManagementDefaultLimit + data["__nvmlDeviceGetPowerManagementDefaultLimit"] = <_cyb_intptr_t>__nvmlDeviceGetPowerManagementDefaultLimit global __nvmlDeviceGetPowerUsage - data["__nvmlDeviceGetPowerUsage"] = __nvmlDeviceGetPowerUsage + data["__nvmlDeviceGetPowerUsage"] = <_cyb_intptr_t>__nvmlDeviceGetPowerUsage global __nvmlDeviceGetTotalEnergyConsumption - data["__nvmlDeviceGetTotalEnergyConsumption"] = __nvmlDeviceGetTotalEnergyConsumption + data["__nvmlDeviceGetTotalEnergyConsumption"] = <_cyb_intptr_t>__nvmlDeviceGetTotalEnergyConsumption global __nvmlDeviceGetEnforcedPowerLimit - data["__nvmlDeviceGetEnforcedPowerLimit"] = __nvmlDeviceGetEnforcedPowerLimit + data["__nvmlDeviceGetEnforcedPowerLimit"] = <_cyb_intptr_t>__nvmlDeviceGetEnforcedPowerLimit global __nvmlDeviceGetGpuOperationMode - data["__nvmlDeviceGetGpuOperationMode"] = __nvmlDeviceGetGpuOperationMode + data["__nvmlDeviceGetGpuOperationMode"] = <_cyb_intptr_t>__nvmlDeviceGetGpuOperationMode global __nvmlDeviceGetMemoryInfo_v2 - data["__nvmlDeviceGetMemoryInfo_v2"] = __nvmlDeviceGetMemoryInfo_v2 + data["__nvmlDeviceGetMemoryInfo_v2"] = <_cyb_intptr_t>__nvmlDeviceGetMemoryInfo_v2 global __nvmlDeviceGetComputeMode - data["__nvmlDeviceGetComputeMode"] = __nvmlDeviceGetComputeMode + data["__nvmlDeviceGetComputeMode"] = <_cyb_intptr_t>__nvmlDeviceGetComputeMode global __nvmlDeviceGetCudaComputeCapability - data["__nvmlDeviceGetCudaComputeCapability"] = __nvmlDeviceGetCudaComputeCapability + data["__nvmlDeviceGetCudaComputeCapability"] = <_cyb_intptr_t>__nvmlDeviceGetCudaComputeCapability global __nvmlDeviceGetDramEncryptionMode - data["__nvmlDeviceGetDramEncryptionMode"] = __nvmlDeviceGetDramEncryptionMode + data["__nvmlDeviceGetDramEncryptionMode"] = <_cyb_intptr_t>__nvmlDeviceGetDramEncryptionMode global __nvmlDeviceSetDramEncryptionMode - data["__nvmlDeviceSetDramEncryptionMode"] = __nvmlDeviceSetDramEncryptionMode + data["__nvmlDeviceSetDramEncryptionMode"] = <_cyb_intptr_t>__nvmlDeviceSetDramEncryptionMode global __nvmlDeviceGetEccMode - data["__nvmlDeviceGetEccMode"] = __nvmlDeviceGetEccMode + data["__nvmlDeviceGetEccMode"] = <_cyb_intptr_t>__nvmlDeviceGetEccMode global __nvmlDeviceGetDefaultEccMode - data["__nvmlDeviceGetDefaultEccMode"] = __nvmlDeviceGetDefaultEccMode + data["__nvmlDeviceGetDefaultEccMode"] = <_cyb_intptr_t>__nvmlDeviceGetDefaultEccMode global __nvmlDeviceGetBoardId - data["__nvmlDeviceGetBoardId"] = __nvmlDeviceGetBoardId + data["__nvmlDeviceGetBoardId"] = <_cyb_intptr_t>__nvmlDeviceGetBoardId global __nvmlDeviceGetMultiGpuBoard - data["__nvmlDeviceGetMultiGpuBoard"] = __nvmlDeviceGetMultiGpuBoard + data["__nvmlDeviceGetMultiGpuBoard"] = <_cyb_intptr_t>__nvmlDeviceGetMultiGpuBoard global __nvmlDeviceGetTotalEccErrors - data["__nvmlDeviceGetTotalEccErrors"] = __nvmlDeviceGetTotalEccErrors + data["__nvmlDeviceGetTotalEccErrors"] = <_cyb_intptr_t>__nvmlDeviceGetTotalEccErrors global __nvmlDeviceGetMemoryErrorCounter - data["__nvmlDeviceGetMemoryErrorCounter"] = __nvmlDeviceGetMemoryErrorCounter + data["__nvmlDeviceGetMemoryErrorCounter"] = <_cyb_intptr_t>__nvmlDeviceGetMemoryErrorCounter global __nvmlDeviceGetUtilizationRates - data["__nvmlDeviceGetUtilizationRates"] = __nvmlDeviceGetUtilizationRates + data["__nvmlDeviceGetUtilizationRates"] = <_cyb_intptr_t>__nvmlDeviceGetUtilizationRates global __nvmlDeviceGetEncoderUtilization - data["__nvmlDeviceGetEncoderUtilization"] = __nvmlDeviceGetEncoderUtilization + data["__nvmlDeviceGetEncoderUtilization"] = <_cyb_intptr_t>__nvmlDeviceGetEncoderUtilization global __nvmlDeviceGetEncoderCapacity - data["__nvmlDeviceGetEncoderCapacity"] = __nvmlDeviceGetEncoderCapacity + data["__nvmlDeviceGetEncoderCapacity"] = <_cyb_intptr_t>__nvmlDeviceGetEncoderCapacity global __nvmlDeviceGetEncoderStats - data["__nvmlDeviceGetEncoderStats"] = __nvmlDeviceGetEncoderStats + data["__nvmlDeviceGetEncoderStats"] = <_cyb_intptr_t>__nvmlDeviceGetEncoderStats global __nvmlDeviceGetEncoderSessions - data["__nvmlDeviceGetEncoderSessions"] = __nvmlDeviceGetEncoderSessions + data["__nvmlDeviceGetEncoderSessions"] = <_cyb_intptr_t>__nvmlDeviceGetEncoderSessions global __nvmlDeviceGetDecoderUtilization - data["__nvmlDeviceGetDecoderUtilization"] = __nvmlDeviceGetDecoderUtilization + data["__nvmlDeviceGetDecoderUtilization"] = <_cyb_intptr_t>__nvmlDeviceGetDecoderUtilization global __nvmlDeviceGetJpgUtilization - data["__nvmlDeviceGetJpgUtilization"] = __nvmlDeviceGetJpgUtilization + data["__nvmlDeviceGetJpgUtilization"] = <_cyb_intptr_t>__nvmlDeviceGetJpgUtilization global __nvmlDeviceGetOfaUtilization - data["__nvmlDeviceGetOfaUtilization"] = __nvmlDeviceGetOfaUtilization + data["__nvmlDeviceGetOfaUtilization"] = <_cyb_intptr_t>__nvmlDeviceGetOfaUtilization global __nvmlDeviceGetFBCStats - data["__nvmlDeviceGetFBCStats"] = __nvmlDeviceGetFBCStats + data["__nvmlDeviceGetFBCStats"] = <_cyb_intptr_t>__nvmlDeviceGetFBCStats global __nvmlDeviceGetFBCSessions - data["__nvmlDeviceGetFBCSessions"] = __nvmlDeviceGetFBCSessions + data["__nvmlDeviceGetFBCSessions"] = <_cyb_intptr_t>__nvmlDeviceGetFBCSessions global __nvmlDeviceGetDriverModel_v2 - data["__nvmlDeviceGetDriverModel_v2"] = __nvmlDeviceGetDriverModel_v2 + data["__nvmlDeviceGetDriverModel_v2"] = <_cyb_intptr_t>__nvmlDeviceGetDriverModel_v2 global __nvmlDeviceGetVbiosVersion - data["__nvmlDeviceGetVbiosVersion"] = __nvmlDeviceGetVbiosVersion + data["__nvmlDeviceGetVbiosVersion"] = <_cyb_intptr_t>__nvmlDeviceGetVbiosVersion global __nvmlDeviceGetBridgeChipInfo - data["__nvmlDeviceGetBridgeChipInfo"] = __nvmlDeviceGetBridgeChipInfo + data["__nvmlDeviceGetBridgeChipInfo"] = <_cyb_intptr_t>__nvmlDeviceGetBridgeChipInfo global __nvmlDeviceGetComputeRunningProcesses_v3 - data["__nvmlDeviceGetComputeRunningProcesses_v3"] = __nvmlDeviceGetComputeRunningProcesses_v3 + data["__nvmlDeviceGetComputeRunningProcesses_v3"] = <_cyb_intptr_t>__nvmlDeviceGetComputeRunningProcesses_v3 global __nvmlDeviceGetGraphicsRunningProcesses_v3 - data["__nvmlDeviceGetGraphicsRunningProcesses_v3"] = __nvmlDeviceGetGraphicsRunningProcesses_v3 + data["__nvmlDeviceGetGraphicsRunningProcesses_v3"] = <_cyb_intptr_t>__nvmlDeviceGetGraphicsRunningProcesses_v3 global __nvmlDeviceGetMPSComputeRunningProcesses_v3 - data["__nvmlDeviceGetMPSComputeRunningProcesses_v3"] = __nvmlDeviceGetMPSComputeRunningProcesses_v3 + data["__nvmlDeviceGetMPSComputeRunningProcesses_v3"] = <_cyb_intptr_t>__nvmlDeviceGetMPSComputeRunningProcesses_v3 global __nvmlDeviceGetRunningProcessDetailList - data["__nvmlDeviceGetRunningProcessDetailList"] = __nvmlDeviceGetRunningProcessDetailList + data["__nvmlDeviceGetRunningProcessDetailList"] = <_cyb_intptr_t>__nvmlDeviceGetRunningProcessDetailList global __nvmlDeviceOnSameBoard - data["__nvmlDeviceOnSameBoard"] = __nvmlDeviceOnSameBoard + data["__nvmlDeviceOnSameBoard"] = <_cyb_intptr_t>__nvmlDeviceOnSameBoard global __nvmlDeviceGetAPIRestriction - data["__nvmlDeviceGetAPIRestriction"] = __nvmlDeviceGetAPIRestriction + data["__nvmlDeviceGetAPIRestriction"] = <_cyb_intptr_t>__nvmlDeviceGetAPIRestriction global __nvmlDeviceGetSamples - data["__nvmlDeviceGetSamples"] = __nvmlDeviceGetSamples + data["__nvmlDeviceGetSamples"] = <_cyb_intptr_t>__nvmlDeviceGetSamples global __nvmlDeviceGetBAR1MemoryInfo - data["__nvmlDeviceGetBAR1MemoryInfo"] = __nvmlDeviceGetBAR1MemoryInfo + data["__nvmlDeviceGetBAR1MemoryInfo"] = <_cyb_intptr_t>__nvmlDeviceGetBAR1MemoryInfo global __nvmlDeviceGetIrqNum - data["__nvmlDeviceGetIrqNum"] = __nvmlDeviceGetIrqNum + data["__nvmlDeviceGetIrqNum"] = <_cyb_intptr_t>__nvmlDeviceGetIrqNum global __nvmlDeviceGetNumGpuCores - data["__nvmlDeviceGetNumGpuCores"] = __nvmlDeviceGetNumGpuCores + data["__nvmlDeviceGetNumGpuCores"] = <_cyb_intptr_t>__nvmlDeviceGetNumGpuCores global __nvmlDeviceGetPowerSource - data["__nvmlDeviceGetPowerSource"] = __nvmlDeviceGetPowerSource + data["__nvmlDeviceGetPowerSource"] = <_cyb_intptr_t>__nvmlDeviceGetPowerSource global __nvmlDeviceGetMemoryBusWidth - data["__nvmlDeviceGetMemoryBusWidth"] = __nvmlDeviceGetMemoryBusWidth + data["__nvmlDeviceGetMemoryBusWidth"] = <_cyb_intptr_t>__nvmlDeviceGetMemoryBusWidth global __nvmlDeviceGetPcieLinkMaxSpeed - data["__nvmlDeviceGetPcieLinkMaxSpeed"] = __nvmlDeviceGetPcieLinkMaxSpeed + data["__nvmlDeviceGetPcieLinkMaxSpeed"] = <_cyb_intptr_t>__nvmlDeviceGetPcieLinkMaxSpeed global __nvmlDeviceGetPcieSpeed - data["__nvmlDeviceGetPcieSpeed"] = __nvmlDeviceGetPcieSpeed + data["__nvmlDeviceGetPcieSpeed"] = <_cyb_intptr_t>__nvmlDeviceGetPcieSpeed global __nvmlDeviceGetAdaptiveClockInfoStatus - data["__nvmlDeviceGetAdaptiveClockInfoStatus"] = __nvmlDeviceGetAdaptiveClockInfoStatus + data["__nvmlDeviceGetAdaptiveClockInfoStatus"] = <_cyb_intptr_t>__nvmlDeviceGetAdaptiveClockInfoStatus global __nvmlDeviceGetBusType - data["__nvmlDeviceGetBusType"] = __nvmlDeviceGetBusType + data["__nvmlDeviceGetBusType"] = <_cyb_intptr_t>__nvmlDeviceGetBusType global __nvmlDeviceGetGpuFabricInfoV - data["__nvmlDeviceGetGpuFabricInfoV"] = __nvmlDeviceGetGpuFabricInfoV + data["__nvmlDeviceGetGpuFabricInfoV"] = <_cyb_intptr_t>__nvmlDeviceGetGpuFabricInfoV global __nvmlSystemGetConfComputeCapabilities - data["__nvmlSystemGetConfComputeCapabilities"] = __nvmlSystemGetConfComputeCapabilities + data["__nvmlSystemGetConfComputeCapabilities"] = <_cyb_intptr_t>__nvmlSystemGetConfComputeCapabilities global __nvmlSystemGetConfComputeState - data["__nvmlSystemGetConfComputeState"] = __nvmlSystemGetConfComputeState + data["__nvmlSystemGetConfComputeState"] = <_cyb_intptr_t>__nvmlSystemGetConfComputeState global __nvmlDeviceGetConfComputeMemSizeInfo - data["__nvmlDeviceGetConfComputeMemSizeInfo"] = __nvmlDeviceGetConfComputeMemSizeInfo + data["__nvmlDeviceGetConfComputeMemSizeInfo"] = <_cyb_intptr_t>__nvmlDeviceGetConfComputeMemSizeInfo global __nvmlSystemGetConfComputeGpusReadyState - data["__nvmlSystemGetConfComputeGpusReadyState"] = __nvmlSystemGetConfComputeGpusReadyState + data["__nvmlSystemGetConfComputeGpusReadyState"] = <_cyb_intptr_t>__nvmlSystemGetConfComputeGpusReadyState global __nvmlDeviceGetConfComputeProtectedMemoryUsage - data["__nvmlDeviceGetConfComputeProtectedMemoryUsage"] = __nvmlDeviceGetConfComputeProtectedMemoryUsage + data["__nvmlDeviceGetConfComputeProtectedMemoryUsage"] = <_cyb_intptr_t>__nvmlDeviceGetConfComputeProtectedMemoryUsage global __nvmlDeviceGetConfComputeGpuCertificate - data["__nvmlDeviceGetConfComputeGpuCertificate"] = __nvmlDeviceGetConfComputeGpuCertificate + data["__nvmlDeviceGetConfComputeGpuCertificate"] = <_cyb_intptr_t>__nvmlDeviceGetConfComputeGpuCertificate global __nvmlDeviceGetConfComputeGpuAttestationReport - data["__nvmlDeviceGetConfComputeGpuAttestationReport"] = __nvmlDeviceGetConfComputeGpuAttestationReport + data["__nvmlDeviceGetConfComputeGpuAttestationReport"] = <_cyb_intptr_t>__nvmlDeviceGetConfComputeGpuAttestationReport global __nvmlSystemGetConfComputeKeyRotationThresholdInfo - data["__nvmlSystemGetConfComputeKeyRotationThresholdInfo"] = __nvmlSystemGetConfComputeKeyRotationThresholdInfo + data["__nvmlSystemGetConfComputeKeyRotationThresholdInfo"] = <_cyb_intptr_t>__nvmlSystemGetConfComputeKeyRotationThresholdInfo global __nvmlDeviceSetConfComputeUnprotectedMemSize - data["__nvmlDeviceSetConfComputeUnprotectedMemSize"] = __nvmlDeviceSetConfComputeUnprotectedMemSize + data["__nvmlDeviceSetConfComputeUnprotectedMemSize"] = <_cyb_intptr_t>__nvmlDeviceSetConfComputeUnprotectedMemSize global __nvmlSystemSetConfComputeGpusReadyState - data["__nvmlSystemSetConfComputeGpusReadyState"] = __nvmlSystemSetConfComputeGpusReadyState + data["__nvmlSystemSetConfComputeGpusReadyState"] = <_cyb_intptr_t>__nvmlSystemSetConfComputeGpusReadyState global __nvmlSystemSetConfComputeKeyRotationThresholdInfo - data["__nvmlSystemSetConfComputeKeyRotationThresholdInfo"] = __nvmlSystemSetConfComputeKeyRotationThresholdInfo + data["__nvmlSystemSetConfComputeKeyRotationThresholdInfo"] = <_cyb_intptr_t>__nvmlSystemSetConfComputeKeyRotationThresholdInfo global __nvmlSystemGetConfComputeSettings - data["__nvmlSystemGetConfComputeSettings"] = __nvmlSystemGetConfComputeSettings + data["__nvmlSystemGetConfComputeSettings"] = <_cyb_intptr_t>__nvmlSystemGetConfComputeSettings global __nvmlDeviceGetGspFirmwareVersion - data["__nvmlDeviceGetGspFirmwareVersion"] = __nvmlDeviceGetGspFirmwareVersion + data["__nvmlDeviceGetGspFirmwareVersion"] = <_cyb_intptr_t>__nvmlDeviceGetGspFirmwareVersion global __nvmlDeviceGetGspFirmwareMode - data["__nvmlDeviceGetGspFirmwareMode"] = __nvmlDeviceGetGspFirmwareMode + data["__nvmlDeviceGetGspFirmwareMode"] = <_cyb_intptr_t>__nvmlDeviceGetGspFirmwareMode global __nvmlDeviceGetSramEccErrorStatus - data["__nvmlDeviceGetSramEccErrorStatus"] = __nvmlDeviceGetSramEccErrorStatus + data["__nvmlDeviceGetSramEccErrorStatus"] = <_cyb_intptr_t>__nvmlDeviceGetSramEccErrorStatus global __nvmlDeviceGetAccountingMode - data["__nvmlDeviceGetAccountingMode"] = __nvmlDeviceGetAccountingMode + data["__nvmlDeviceGetAccountingMode"] = <_cyb_intptr_t>__nvmlDeviceGetAccountingMode global __nvmlDeviceGetAccountingStats - data["__nvmlDeviceGetAccountingStats"] = __nvmlDeviceGetAccountingStats + data["__nvmlDeviceGetAccountingStats"] = <_cyb_intptr_t>__nvmlDeviceGetAccountingStats global __nvmlDeviceGetAccountingPids - data["__nvmlDeviceGetAccountingPids"] = __nvmlDeviceGetAccountingPids + data["__nvmlDeviceGetAccountingPids"] = <_cyb_intptr_t>__nvmlDeviceGetAccountingPids global __nvmlDeviceGetAccountingBufferSize - data["__nvmlDeviceGetAccountingBufferSize"] = __nvmlDeviceGetAccountingBufferSize + data["__nvmlDeviceGetAccountingBufferSize"] = <_cyb_intptr_t>__nvmlDeviceGetAccountingBufferSize global __nvmlDeviceGetRetiredPages - data["__nvmlDeviceGetRetiredPages"] = __nvmlDeviceGetRetiredPages + data["__nvmlDeviceGetRetiredPages"] = <_cyb_intptr_t>__nvmlDeviceGetRetiredPages global __nvmlDeviceGetRetiredPages_v2 - data["__nvmlDeviceGetRetiredPages_v2"] = __nvmlDeviceGetRetiredPages_v2 + data["__nvmlDeviceGetRetiredPages_v2"] = <_cyb_intptr_t>__nvmlDeviceGetRetiredPages_v2 global __nvmlDeviceGetRetiredPagesPendingStatus - data["__nvmlDeviceGetRetiredPagesPendingStatus"] = __nvmlDeviceGetRetiredPagesPendingStatus + data["__nvmlDeviceGetRetiredPagesPendingStatus"] = <_cyb_intptr_t>__nvmlDeviceGetRetiredPagesPendingStatus global __nvmlDeviceGetRemappedRows - data["__nvmlDeviceGetRemappedRows"] = __nvmlDeviceGetRemappedRows + data["__nvmlDeviceGetRemappedRows"] = <_cyb_intptr_t>__nvmlDeviceGetRemappedRows global __nvmlDeviceGetRowRemapperHistogram - data["__nvmlDeviceGetRowRemapperHistogram"] = __nvmlDeviceGetRowRemapperHistogram + data["__nvmlDeviceGetRowRemapperHistogram"] = <_cyb_intptr_t>__nvmlDeviceGetRowRemapperHistogram global __nvmlDeviceGetArchitecture - data["__nvmlDeviceGetArchitecture"] = __nvmlDeviceGetArchitecture + data["__nvmlDeviceGetArchitecture"] = <_cyb_intptr_t>__nvmlDeviceGetArchitecture global __nvmlDeviceGetClkMonStatus - data["__nvmlDeviceGetClkMonStatus"] = __nvmlDeviceGetClkMonStatus + data["__nvmlDeviceGetClkMonStatus"] = <_cyb_intptr_t>__nvmlDeviceGetClkMonStatus global __nvmlDeviceGetProcessUtilization - data["__nvmlDeviceGetProcessUtilization"] = __nvmlDeviceGetProcessUtilization + data["__nvmlDeviceGetProcessUtilization"] = <_cyb_intptr_t>__nvmlDeviceGetProcessUtilization global __nvmlDeviceGetProcessesUtilizationInfo - data["__nvmlDeviceGetProcessesUtilizationInfo"] = __nvmlDeviceGetProcessesUtilizationInfo + data["__nvmlDeviceGetProcessesUtilizationInfo"] = <_cyb_intptr_t>__nvmlDeviceGetProcessesUtilizationInfo global __nvmlDeviceGetPlatformInfo - data["__nvmlDeviceGetPlatformInfo"] = __nvmlDeviceGetPlatformInfo + data["__nvmlDeviceGetPlatformInfo"] = <_cyb_intptr_t>__nvmlDeviceGetPlatformInfo global __nvmlUnitSetLedState - data["__nvmlUnitSetLedState"] = __nvmlUnitSetLedState + data["__nvmlUnitSetLedState"] = <_cyb_intptr_t>__nvmlUnitSetLedState global __nvmlDeviceSetPersistenceMode - data["__nvmlDeviceSetPersistenceMode"] = __nvmlDeviceSetPersistenceMode + data["__nvmlDeviceSetPersistenceMode"] = <_cyb_intptr_t>__nvmlDeviceSetPersistenceMode global __nvmlDeviceSetComputeMode - data["__nvmlDeviceSetComputeMode"] = __nvmlDeviceSetComputeMode + data["__nvmlDeviceSetComputeMode"] = <_cyb_intptr_t>__nvmlDeviceSetComputeMode global __nvmlDeviceSetEccMode - data["__nvmlDeviceSetEccMode"] = __nvmlDeviceSetEccMode + data["__nvmlDeviceSetEccMode"] = <_cyb_intptr_t>__nvmlDeviceSetEccMode global __nvmlDeviceClearEccErrorCounts - data["__nvmlDeviceClearEccErrorCounts"] = __nvmlDeviceClearEccErrorCounts + data["__nvmlDeviceClearEccErrorCounts"] = <_cyb_intptr_t>__nvmlDeviceClearEccErrorCounts global __nvmlDeviceSetDriverModel - data["__nvmlDeviceSetDriverModel"] = __nvmlDeviceSetDriverModel + data["__nvmlDeviceSetDriverModel"] = <_cyb_intptr_t>__nvmlDeviceSetDriverModel global __nvmlDeviceSetGpuLockedClocks - data["__nvmlDeviceSetGpuLockedClocks"] = __nvmlDeviceSetGpuLockedClocks + data["__nvmlDeviceSetGpuLockedClocks"] = <_cyb_intptr_t>__nvmlDeviceSetGpuLockedClocks global __nvmlDeviceResetGpuLockedClocks - data["__nvmlDeviceResetGpuLockedClocks"] = __nvmlDeviceResetGpuLockedClocks + data["__nvmlDeviceResetGpuLockedClocks"] = <_cyb_intptr_t>__nvmlDeviceResetGpuLockedClocks global __nvmlDeviceSetMemoryLockedClocks - data["__nvmlDeviceSetMemoryLockedClocks"] = __nvmlDeviceSetMemoryLockedClocks + data["__nvmlDeviceSetMemoryLockedClocks"] = <_cyb_intptr_t>__nvmlDeviceSetMemoryLockedClocks global __nvmlDeviceResetMemoryLockedClocks - data["__nvmlDeviceResetMemoryLockedClocks"] = __nvmlDeviceResetMemoryLockedClocks + data["__nvmlDeviceResetMemoryLockedClocks"] = <_cyb_intptr_t>__nvmlDeviceResetMemoryLockedClocks global __nvmlDeviceSetAutoBoostedClocksEnabled - data["__nvmlDeviceSetAutoBoostedClocksEnabled"] = __nvmlDeviceSetAutoBoostedClocksEnabled + data["__nvmlDeviceSetAutoBoostedClocksEnabled"] = <_cyb_intptr_t>__nvmlDeviceSetAutoBoostedClocksEnabled global __nvmlDeviceSetDefaultAutoBoostedClocksEnabled - data["__nvmlDeviceSetDefaultAutoBoostedClocksEnabled"] = __nvmlDeviceSetDefaultAutoBoostedClocksEnabled + data["__nvmlDeviceSetDefaultAutoBoostedClocksEnabled"] = <_cyb_intptr_t>__nvmlDeviceSetDefaultAutoBoostedClocksEnabled global __nvmlDeviceSetDefaultFanSpeed_v2 - data["__nvmlDeviceSetDefaultFanSpeed_v2"] = __nvmlDeviceSetDefaultFanSpeed_v2 + data["__nvmlDeviceSetDefaultFanSpeed_v2"] = <_cyb_intptr_t>__nvmlDeviceSetDefaultFanSpeed_v2 global __nvmlDeviceSetFanControlPolicy - data["__nvmlDeviceSetFanControlPolicy"] = __nvmlDeviceSetFanControlPolicy + data["__nvmlDeviceSetFanControlPolicy"] = <_cyb_intptr_t>__nvmlDeviceSetFanControlPolicy global __nvmlDeviceSetTemperatureThreshold - data["__nvmlDeviceSetTemperatureThreshold"] = __nvmlDeviceSetTemperatureThreshold + data["__nvmlDeviceSetTemperatureThreshold"] = <_cyb_intptr_t>__nvmlDeviceSetTemperatureThreshold global __nvmlDeviceSetGpuOperationMode - data["__nvmlDeviceSetGpuOperationMode"] = __nvmlDeviceSetGpuOperationMode + data["__nvmlDeviceSetGpuOperationMode"] = <_cyb_intptr_t>__nvmlDeviceSetGpuOperationMode global __nvmlDeviceSetAPIRestriction - data["__nvmlDeviceSetAPIRestriction"] = __nvmlDeviceSetAPIRestriction + data["__nvmlDeviceSetAPIRestriction"] = <_cyb_intptr_t>__nvmlDeviceSetAPIRestriction global __nvmlDeviceSetFanSpeed_v2 - data["__nvmlDeviceSetFanSpeed_v2"] = __nvmlDeviceSetFanSpeed_v2 + data["__nvmlDeviceSetFanSpeed_v2"] = <_cyb_intptr_t>__nvmlDeviceSetFanSpeed_v2 global __nvmlDeviceSetAccountingMode - data["__nvmlDeviceSetAccountingMode"] = __nvmlDeviceSetAccountingMode + data["__nvmlDeviceSetAccountingMode"] = <_cyb_intptr_t>__nvmlDeviceSetAccountingMode global __nvmlDeviceClearAccountingPids - data["__nvmlDeviceClearAccountingPids"] = __nvmlDeviceClearAccountingPids + data["__nvmlDeviceClearAccountingPids"] = <_cyb_intptr_t>__nvmlDeviceClearAccountingPids global __nvmlDeviceSetPowerManagementLimit_v2 - data["__nvmlDeviceSetPowerManagementLimit_v2"] = __nvmlDeviceSetPowerManagementLimit_v2 + data["__nvmlDeviceSetPowerManagementLimit_v2"] = <_cyb_intptr_t>__nvmlDeviceSetPowerManagementLimit_v2 global __nvmlDeviceGetNvLinkState - data["__nvmlDeviceGetNvLinkState"] = __nvmlDeviceGetNvLinkState + data["__nvmlDeviceGetNvLinkState"] = <_cyb_intptr_t>__nvmlDeviceGetNvLinkState global __nvmlDeviceGetNvLinkVersion - data["__nvmlDeviceGetNvLinkVersion"] = __nvmlDeviceGetNvLinkVersion + data["__nvmlDeviceGetNvLinkVersion"] = <_cyb_intptr_t>__nvmlDeviceGetNvLinkVersion global __nvmlDeviceGetNvLinkCapability - data["__nvmlDeviceGetNvLinkCapability"] = __nvmlDeviceGetNvLinkCapability + data["__nvmlDeviceGetNvLinkCapability"] = <_cyb_intptr_t>__nvmlDeviceGetNvLinkCapability global __nvmlDeviceGetNvLinkRemotePciInfo_v2 - data["__nvmlDeviceGetNvLinkRemotePciInfo_v2"] = __nvmlDeviceGetNvLinkRemotePciInfo_v2 + data["__nvmlDeviceGetNvLinkRemotePciInfo_v2"] = <_cyb_intptr_t>__nvmlDeviceGetNvLinkRemotePciInfo_v2 global __nvmlDeviceGetNvLinkErrorCounter - data["__nvmlDeviceGetNvLinkErrorCounter"] = __nvmlDeviceGetNvLinkErrorCounter + data["__nvmlDeviceGetNvLinkErrorCounter"] = <_cyb_intptr_t>__nvmlDeviceGetNvLinkErrorCounter global __nvmlDeviceResetNvLinkErrorCounters - data["__nvmlDeviceResetNvLinkErrorCounters"] = __nvmlDeviceResetNvLinkErrorCounters + data["__nvmlDeviceResetNvLinkErrorCounters"] = <_cyb_intptr_t>__nvmlDeviceResetNvLinkErrorCounters global __nvmlDeviceGetNvLinkRemoteDeviceType - data["__nvmlDeviceGetNvLinkRemoteDeviceType"] = __nvmlDeviceGetNvLinkRemoteDeviceType + data["__nvmlDeviceGetNvLinkRemoteDeviceType"] = <_cyb_intptr_t>__nvmlDeviceGetNvLinkRemoteDeviceType global __nvmlDeviceSetNvLinkDeviceLowPowerThreshold - data["__nvmlDeviceSetNvLinkDeviceLowPowerThreshold"] = __nvmlDeviceSetNvLinkDeviceLowPowerThreshold + data["__nvmlDeviceSetNvLinkDeviceLowPowerThreshold"] = <_cyb_intptr_t>__nvmlDeviceSetNvLinkDeviceLowPowerThreshold global __nvmlSystemSetNvlinkBwMode - data["__nvmlSystemSetNvlinkBwMode"] = __nvmlSystemSetNvlinkBwMode + data["__nvmlSystemSetNvlinkBwMode"] = <_cyb_intptr_t>__nvmlSystemSetNvlinkBwMode global __nvmlSystemGetNvlinkBwMode - data["__nvmlSystemGetNvlinkBwMode"] = __nvmlSystemGetNvlinkBwMode + data["__nvmlSystemGetNvlinkBwMode"] = <_cyb_intptr_t>__nvmlSystemGetNvlinkBwMode global __nvmlDeviceGetNvlinkSupportedBwModes - data["__nvmlDeviceGetNvlinkSupportedBwModes"] = __nvmlDeviceGetNvlinkSupportedBwModes + data["__nvmlDeviceGetNvlinkSupportedBwModes"] = <_cyb_intptr_t>__nvmlDeviceGetNvlinkSupportedBwModes global __nvmlDeviceGetNvlinkBwMode - data["__nvmlDeviceGetNvlinkBwMode"] = __nvmlDeviceGetNvlinkBwMode + data["__nvmlDeviceGetNvlinkBwMode"] = <_cyb_intptr_t>__nvmlDeviceGetNvlinkBwMode global __nvmlDeviceSetNvlinkBwMode - data["__nvmlDeviceSetNvlinkBwMode"] = __nvmlDeviceSetNvlinkBwMode + data["__nvmlDeviceSetNvlinkBwMode"] = <_cyb_intptr_t>__nvmlDeviceSetNvlinkBwMode global __nvmlEventSetCreate - data["__nvmlEventSetCreate"] = __nvmlEventSetCreate + data["__nvmlEventSetCreate"] = <_cyb_intptr_t>__nvmlEventSetCreate global __nvmlDeviceRegisterEvents - data["__nvmlDeviceRegisterEvents"] = __nvmlDeviceRegisterEvents + data["__nvmlDeviceRegisterEvents"] = <_cyb_intptr_t>__nvmlDeviceRegisterEvents global __nvmlDeviceGetSupportedEventTypes - data["__nvmlDeviceGetSupportedEventTypes"] = __nvmlDeviceGetSupportedEventTypes + data["__nvmlDeviceGetSupportedEventTypes"] = <_cyb_intptr_t>__nvmlDeviceGetSupportedEventTypes global __nvmlEventSetWait_v2 - data["__nvmlEventSetWait_v2"] = __nvmlEventSetWait_v2 + data["__nvmlEventSetWait_v2"] = <_cyb_intptr_t>__nvmlEventSetWait_v2 global __nvmlEventSetFree - data["__nvmlEventSetFree"] = __nvmlEventSetFree + data["__nvmlEventSetFree"] = <_cyb_intptr_t>__nvmlEventSetFree global __nvmlSystemEventSetCreate - data["__nvmlSystemEventSetCreate"] = __nvmlSystemEventSetCreate + data["__nvmlSystemEventSetCreate"] = <_cyb_intptr_t>__nvmlSystemEventSetCreate global __nvmlSystemEventSetFree - data["__nvmlSystemEventSetFree"] = __nvmlSystemEventSetFree + data["__nvmlSystemEventSetFree"] = <_cyb_intptr_t>__nvmlSystemEventSetFree global __nvmlSystemRegisterEvents - data["__nvmlSystemRegisterEvents"] = __nvmlSystemRegisterEvents + data["__nvmlSystemRegisterEvents"] = <_cyb_intptr_t>__nvmlSystemRegisterEvents global __nvmlSystemEventSetWait - data["__nvmlSystemEventSetWait"] = __nvmlSystemEventSetWait + data["__nvmlSystemEventSetWait"] = <_cyb_intptr_t>__nvmlSystemEventSetWait global __nvmlDeviceModifyDrainState - data["__nvmlDeviceModifyDrainState"] = __nvmlDeviceModifyDrainState + data["__nvmlDeviceModifyDrainState"] = <_cyb_intptr_t>__nvmlDeviceModifyDrainState global __nvmlDeviceQueryDrainState - data["__nvmlDeviceQueryDrainState"] = __nvmlDeviceQueryDrainState + data["__nvmlDeviceQueryDrainState"] = <_cyb_intptr_t>__nvmlDeviceQueryDrainState global __nvmlDeviceRemoveGpu_v2 - data["__nvmlDeviceRemoveGpu_v2"] = __nvmlDeviceRemoveGpu_v2 + data["__nvmlDeviceRemoveGpu_v2"] = <_cyb_intptr_t>__nvmlDeviceRemoveGpu_v2 global __nvmlDeviceDiscoverGpus - data["__nvmlDeviceDiscoverGpus"] = __nvmlDeviceDiscoverGpus + data["__nvmlDeviceDiscoverGpus"] = <_cyb_intptr_t>__nvmlDeviceDiscoverGpus global __nvmlDeviceGetFieldValues - data["__nvmlDeviceGetFieldValues"] = __nvmlDeviceGetFieldValues + data["__nvmlDeviceGetFieldValues"] = <_cyb_intptr_t>__nvmlDeviceGetFieldValues global __nvmlDeviceClearFieldValues - data["__nvmlDeviceClearFieldValues"] = __nvmlDeviceClearFieldValues + data["__nvmlDeviceClearFieldValues"] = <_cyb_intptr_t>__nvmlDeviceClearFieldValues global __nvmlDeviceGetVirtualizationMode - data["__nvmlDeviceGetVirtualizationMode"] = __nvmlDeviceGetVirtualizationMode + data["__nvmlDeviceGetVirtualizationMode"] = <_cyb_intptr_t>__nvmlDeviceGetVirtualizationMode global __nvmlDeviceGetHostVgpuMode - data["__nvmlDeviceGetHostVgpuMode"] = __nvmlDeviceGetHostVgpuMode + data["__nvmlDeviceGetHostVgpuMode"] = <_cyb_intptr_t>__nvmlDeviceGetHostVgpuMode global __nvmlDeviceSetVirtualizationMode - data["__nvmlDeviceSetVirtualizationMode"] = __nvmlDeviceSetVirtualizationMode + data["__nvmlDeviceSetVirtualizationMode"] = <_cyb_intptr_t>__nvmlDeviceSetVirtualizationMode global __nvmlDeviceGetVgpuHeterogeneousMode - data["__nvmlDeviceGetVgpuHeterogeneousMode"] = __nvmlDeviceGetVgpuHeterogeneousMode + data["__nvmlDeviceGetVgpuHeterogeneousMode"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuHeterogeneousMode global __nvmlDeviceSetVgpuHeterogeneousMode - data["__nvmlDeviceSetVgpuHeterogeneousMode"] = __nvmlDeviceSetVgpuHeterogeneousMode + data["__nvmlDeviceSetVgpuHeterogeneousMode"] = <_cyb_intptr_t>__nvmlDeviceSetVgpuHeterogeneousMode global __nvmlVgpuInstanceGetPlacementId - data["__nvmlVgpuInstanceGetPlacementId"] = __nvmlVgpuInstanceGetPlacementId + data["__nvmlVgpuInstanceGetPlacementId"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetPlacementId global __nvmlDeviceGetVgpuTypeSupportedPlacements - data["__nvmlDeviceGetVgpuTypeSupportedPlacements"] = __nvmlDeviceGetVgpuTypeSupportedPlacements + data["__nvmlDeviceGetVgpuTypeSupportedPlacements"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuTypeSupportedPlacements global __nvmlDeviceGetVgpuTypeCreatablePlacements - data["__nvmlDeviceGetVgpuTypeCreatablePlacements"] = __nvmlDeviceGetVgpuTypeCreatablePlacements + data["__nvmlDeviceGetVgpuTypeCreatablePlacements"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuTypeCreatablePlacements global __nvmlVgpuTypeGetGspHeapSize - data["__nvmlVgpuTypeGetGspHeapSize"] = __nvmlVgpuTypeGetGspHeapSize + data["__nvmlVgpuTypeGetGspHeapSize"] = <_cyb_intptr_t>__nvmlVgpuTypeGetGspHeapSize global __nvmlVgpuTypeGetFbReservation - data["__nvmlVgpuTypeGetFbReservation"] = __nvmlVgpuTypeGetFbReservation + data["__nvmlVgpuTypeGetFbReservation"] = <_cyb_intptr_t>__nvmlVgpuTypeGetFbReservation global __nvmlVgpuInstanceGetRuntimeStateSize - data["__nvmlVgpuInstanceGetRuntimeStateSize"] = __nvmlVgpuInstanceGetRuntimeStateSize + data["__nvmlVgpuInstanceGetRuntimeStateSize"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetRuntimeStateSize global __nvmlDeviceSetVgpuCapabilities - data["__nvmlDeviceSetVgpuCapabilities"] = __nvmlDeviceSetVgpuCapabilities + data["__nvmlDeviceSetVgpuCapabilities"] = <_cyb_intptr_t>__nvmlDeviceSetVgpuCapabilities global __nvmlDeviceGetGridLicensableFeatures_v4 - data["__nvmlDeviceGetGridLicensableFeatures_v4"] = __nvmlDeviceGetGridLicensableFeatures_v4 + data["__nvmlDeviceGetGridLicensableFeatures_v4"] = <_cyb_intptr_t>__nvmlDeviceGetGridLicensableFeatures_v4 global __nvmlGetVgpuDriverCapabilities - data["__nvmlGetVgpuDriverCapabilities"] = __nvmlGetVgpuDriverCapabilities + data["__nvmlGetVgpuDriverCapabilities"] = <_cyb_intptr_t>__nvmlGetVgpuDriverCapabilities global __nvmlDeviceGetVgpuCapabilities - data["__nvmlDeviceGetVgpuCapabilities"] = __nvmlDeviceGetVgpuCapabilities + data["__nvmlDeviceGetVgpuCapabilities"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuCapabilities global __nvmlDeviceGetSupportedVgpus - data["__nvmlDeviceGetSupportedVgpus"] = __nvmlDeviceGetSupportedVgpus + data["__nvmlDeviceGetSupportedVgpus"] = <_cyb_intptr_t>__nvmlDeviceGetSupportedVgpus global __nvmlDeviceGetCreatableVgpus - data["__nvmlDeviceGetCreatableVgpus"] = __nvmlDeviceGetCreatableVgpus + data["__nvmlDeviceGetCreatableVgpus"] = <_cyb_intptr_t>__nvmlDeviceGetCreatableVgpus global __nvmlVgpuTypeGetClass - data["__nvmlVgpuTypeGetClass"] = __nvmlVgpuTypeGetClass + data["__nvmlVgpuTypeGetClass"] = <_cyb_intptr_t>__nvmlVgpuTypeGetClass global __nvmlVgpuTypeGetName - data["__nvmlVgpuTypeGetName"] = __nvmlVgpuTypeGetName + data["__nvmlVgpuTypeGetName"] = <_cyb_intptr_t>__nvmlVgpuTypeGetName global __nvmlVgpuTypeGetGpuInstanceProfileId - data["__nvmlVgpuTypeGetGpuInstanceProfileId"] = __nvmlVgpuTypeGetGpuInstanceProfileId + data["__nvmlVgpuTypeGetGpuInstanceProfileId"] = <_cyb_intptr_t>__nvmlVgpuTypeGetGpuInstanceProfileId global __nvmlVgpuTypeGetDeviceID - data["__nvmlVgpuTypeGetDeviceID"] = __nvmlVgpuTypeGetDeviceID + data["__nvmlVgpuTypeGetDeviceID"] = <_cyb_intptr_t>__nvmlVgpuTypeGetDeviceID global __nvmlVgpuTypeGetFramebufferSize - data["__nvmlVgpuTypeGetFramebufferSize"] = __nvmlVgpuTypeGetFramebufferSize + data["__nvmlVgpuTypeGetFramebufferSize"] = <_cyb_intptr_t>__nvmlVgpuTypeGetFramebufferSize global __nvmlVgpuTypeGetNumDisplayHeads - data["__nvmlVgpuTypeGetNumDisplayHeads"] = __nvmlVgpuTypeGetNumDisplayHeads + data["__nvmlVgpuTypeGetNumDisplayHeads"] = <_cyb_intptr_t>__nvmlVgpuTypeGetNumDisplayHeads global __nvmlVgpuTypeGetResolution - data["__nvmlVgpuTypeGetResolution"] = __nvmlVgpuTypeGetResolution + data["__nvmlVgpuTypeGetResolution"] = <_cyb_intptr_t>__nvmlVgpuTypeGetResolution global __nvmlVgpuTypeGetLicense - data["__nvmlVgpuTypeGetLicense"] = __nvmlVgpuTypeGetLicense + data["__nvmlVgpuTypeGetLicense"] = <_cyb_intptr_t>__nvmlVgpuTypeGetLicense global __nvmlVgpuTypeGetFrameRateLimit - data["__nvmlVgpuTypeGetFrameRateLimit"] = __nvmlVgpuTypeGetFrameRateLimit + data["__nvmlVgpuTypeGetFrameRateLimit"] = <_cyb_intptr_t>__nvmlVgpuTypeGetFrameRateLimit global __nvmlVgpuTypeGetMaxInstances - data["__nvmlVgpuTypeGetMaxInstances"] = __nvmlVgpuTypeGetMaxInstances + data["__nvmlVgpuTypeGetMaxInstances"] = <_cyb_intptr_t>__nvmlVgpuTypeGetMaxInstances global __nvmlVgpuTypeGetMaxInstancesPerVm - data["__nvmlVgpuTypeGetMaxInstancesPerVm"] = __nvmlVgpuTypeGetMaxInstancesPerVm + data["__nvmlVgpuTypeGetMaxInstancesPerVm"] = <_cyb_intptr_t>__nvmlVgpuTypeGetMaxInstancesPerVm global __nvmlVgpuTypeGetBAR1Info - data["__nvmlVgpuTypeGetBAR1Info"] = __nvmlVgpuTypeGetBAR1Info + data["__nvmlVgpuTypeGetBAR1Info"] = <_cyb_intptr_t>__nvmlVgpuTypeGetBAR1Info global __nvmlDeviceGetActiveVgpus - data["__nvmlDeviceGetActiveVgpus"] = __nvmlDeviceGetActiveVgpus + data["__nvmlDeviceGetActiveVgpus"] = <_cyb_intptr_t>__nvmlDeviceGetActiveVgpus global __nvmlVgpuInstanceGetVmID - data["__nvmlVgpuInstanceGetVmID"] = __nvmlVgpuInstanceGetVmID + data["__nvmlVgpuInstanceGetVmID"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetVmID global __nvmlVgpuInstanceGetUUID - data["__nvmlVgpuInstanceGetUUID"] = __nvmlVgpuInstanceGetUUID + data["__nvmlVgpuInstanceGetUUID"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetUUID global __nvmlVgpuInstanceGetVmDriverVersion - data["__nvmlVgpuInstanceGetVmDriverVersion"] = __nvmlVgpuInstanceGetVmDriverVersion + data["__nvmlVgpuInstanceGetVmDriverVersion"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetVmDriverVersion global __nvmlVgpuInstanceGetFbUsage - data["__nvmlVgpuInstanceGetFbUsage"] = __nvmlVgpuInstanceGetFbUsage + data["__nvmlVgpuInstanceGetFbUsage"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetFbUsage global __nvmlVgpuInstanceGetLicenseStatus - data["__nvmlVgpuInstanceGetLicenseStatus"] = __nvmlVgpuInstanceGetLicenseStatus + data["__nvmlVgpuInstanceGetLicenseStatus"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetLicenseStatus global __nvmlVgpuInstanceGetType - data["__nvmlVgpuInstanceGetType"] = __nvmlVgpuInstanceGetType + data["__nvmlVgpuInstanceGetType"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetType global __nvmlVgpuInstanceGetFrameRateLimit - data["__nvmlVgpuInstanceGetFrameRateLimit"] = __nvmlVgpuInstanceGetFrameRateLimit + data["__nvmlVgpuInstanceGetFrameRateLimit"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetFrameRateLimit global __nvmlVgpuInstanceGetEccMode - data["__nvmlVgpuInstanceGetEccMode"] = __nvmlVgpuInstanceGetEccMode + data["__nvmlVgpuInstanceGetEccMode"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetEccMode global __nvmlVgpuInstanceGetEncoderCapacity - data["__nvmlVgpuInstanceGetEncoderCapacity"] = __nvmlVgpuInstanceGetEncoderCapacity + data["__nvmlVgpuInstanceGetEncoderCapacity"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetEncoderCapacity global __nvmlVgpuInstanceSetEncoderCapacity - data["__nvmlVgpuInstanceSetEncoderCapacity"] = __nvmlVgpuInstanceSetEncoderCapacity + data["__nvmlVgpuInstanceSetEncoderCapacity"] = <_cyb_intptr_t>__nvmlVgpuInstanceSetEncoderCapacity global __nvmlVgpuInstanceGetEncoderStats - data["__nvmlVgpuInstanceGetEncoderStats"] = __nvmlVgpuInstanceGetEncoderStats + data["__nvmlVgpuInstanceGetEncoderStats"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetEncoderStats global __nvmlVgpuInstanceGetEncoderSessions - data["__nvmlVgpuInstanceGetEncoderSessions"] = __nvmlVgpuInstanceGetEncoderSessions + data["__nvmlVgpuInstanceGetEncoderSessions"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetEncoderSessions global __nvmlVgpuInstanceGetFBCStats - data["__nvmlVgpuInstanceGetFBCStats"] = __nvmlVgpuInstanceGetFBCStats + data["__nvmlVgpuInstanceGetFBCStats"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetFBCStats global __nvmlVgpuInstanceGetFBCSessions - data["__nvmlVgpuInstanceGetFBCSessions"] = __nvmlVgpuInstanceGetFBCSessions + data["__nvmlVgpuInstanceGetFBCSessions"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetFBCSessions global __nvmlVgpuInstanceGetGpuInstanceId - data["__nvmlVgpuInstanceGetGpuInstanceId"] = __nvmlVgpuInstanceGetGpuInstanceId + data["__nvmlVgpuInstanceGetGpuInstanceId"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetGpuInstanceId global __nvmlVgpuInstanceGetGpuPciId - data["__nvmlVgpuInstanceGetGpuPciId"] = __nvmlVgpuInstanceGetGpuPciId + data["__nvmlVgpuInstanceGetGpuPciId"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetGpuPciId global __nvmlVgpuTypeGetCapabilities - data["__nvmlVgpuTypeGetCapabilities"] = __nvmlVgpuTypeGetCapabilities + data["__nvmlVgpuTypeGetCapabilities"] = <_cyb_intptr_t>__nvmlVgpuTypeGetCapabilities global __nvmlVgpuInstanceGetMdevUUID - data["__nvmlVgpuInstanceGetMdevUUID"] = __nvmlVgpuInstanceGetMdevUUID + data["__nvmlVgpuInstanceGetMdevUUID"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetMdevUUID global __nvmlGpuInstanceGetCreatableVgpus - data["__nvmlGpuInstanceGetCreatableVgpus"] = __nvmlGpuInstanceGetCreatableVgpus + data["__nvmlGpuInstanceGetCreatableVgpus"] = <_cyb_intptr_t>__nvmlGpuInstanceGetCreatableVgpus global __nvmlVgpuTypeGetMaxInstancesPerGpuInstance - data["__nvmlVgpuTypeGetMaxInstancesPerGpuInstance"] = __nvmlVgpuTypeGetMaxInstancesPerGpuInstance + data["__nvmlVgpuTypeGetMaxInstancesPerGpuInstance"] = <_cyb_intptr_t>__nvmlVgpuTypeGetMaxInstancesPerGpuInstance global __nvmlGpuInstanceGetActiveVgpus - data["__nvmlGpuInstanceGetActiveVgpus"] = __nvmlGpuInstanceGetActiveVgpus + data["__nvmlGpuInstanceGetActiveVgpus"] = <_cyb_intptr_t>__nvmlGpuInstanceGetActiveVgpus global __nvmlGpuInstanceSetVgpuSchedulerState - data["__nvmlGpuInstanceSetVgpuSchedulerState"] = __nvmlGpuInstanceSetVgpuSchedulerState + data["__nvmlGpuInstanceSetVgpuSchedulerState"] = <_cyb_intptr_t>__nvmlGpuInstanceSetVgpuSchedulerState global __nvmlGpuInstanceGetVgpuSchedulerState - data["__nvmlGpuInstanceGetVgpuSchedulerState"] = __nvmlGpuInstanceGetVgpuSchedulerState + data["__nvmlGpuInstanceGetVgpuSchedulerState"] = <_cyb_intptr_t>__nvmlGpuInstanceGetVgpuSchedulerState global __nvmlGpuInstanceGetVgpuSchedulerLog - data["__nvmlGpuInstanceGetVgpuSchedulerLog"] = __nvmlGpuInstanceGetVgpuSchedulerLog + data["__nvmlGpuInstanceGetVgpuSchedulerLog"] = <_cyb_intptr_t>__nvmlGpuInstanceGetVgpuSchedulerLog global __nvmlGpuInstanceGetVgpuTypeCreatablePlacements - data["__nvmlGpuInstanceGetVgpuTypeCreatablePlacements"] = __nvmlGpuInstanceGetVgpuTypeCreatablePlacements + data["__nvmlGpuInstanceGetVgpuTypeCreatablePlacements"] = <_cyb_intptr_t>__nvmlGpuInstanceGetVgpuTypeCreatablePlacements global __nvmlGpuInstanceGetVgpuHeterogeneousMode - data["__nvmlGpuInstanceGetVgpuHeterogeneousMode"] = __nvmlGpuInstanceGetVgpuHeterogeneousMode + data["__nvmlGpuInstanceGetVgpuHeterogeneousMode"] = <_cyb_intptr_t>__nvmlGpuInstanceGetVgpuHeterogeneousMode global __nvmlGpuInstanceSetVgpuHeterogeneousMode - data["__nvmlGpuInstanceSetVgpuHeterogeneousMode"] = __nvmlGpuInstanceSetVgpuHeterogeneousMode + data["__nvmlGpuInstanceSetVgpuHeterogeneousMode"] = <_cyb_intptr_t>__nvmlGpuInstanceSetVgpuHeterogeneousMode global __nvmlVgpuInstanceGetMetadata - data["__nvmlVgpuInstanceGetMetadata"] = __nvmlVgpuInstanceGetMetadata + data["__nvmlVgpuInstanceGetMetadata"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetMetadata global __nvmlDeviceGetVgpuMetadata - data["__nvmlDeviceGetVgpuMetadata"] = __nvmlDeviceGetVgpuMetadata + data["__nvmlDeviceGetVgpuMetadata"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuMetadata global __nvmlGetVgpuCompatibility - data["__nvmlGetVgpuCompatibility"] = __nvmlGetVgpuCompatibility + data["__nvmlGetVgpuCompatibility"] = <_cyb_intptr_t>__nvmlGetVgpuCompatibility global __nvmlDeviceGetPgpuMetadataString - data["__nvmlDeviceGetPgpuMetadataString"] = __nvmlDeviceGetPgpuMetadataString + data["__nvmlDeviceGetPgpuMetadataString"] = <_cyb_intptr_t>__nvmlDeviceGetPgpuMetadataString global __nvmlDeviceGetVgpuSchedulerLog - data["__nvmlDeviceGetVgpuSchedulerLog"] = __nvmlDeviceGetVgpuSchedulerLog + data["__nvmlDeviceGetVgpuSchedulerLog"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuSchedulerLog global __nvmlDeviceGetVgpuSchedulerState - data["__nvmlDeviceGetVgpuSchedulerState"] = __nvmlDeviceGetVgpuSchedulerState + data["__nvmlDeviceGetVgpuSchedulerState"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuSchedulerState global __nvmlDeviceGetVgpuSchedulerCapabilities - data["__nvmlDeviceGetVgpuSchedulerCapabilities"] = __nvmlDeviceGetVgpuSchedulerCapabilities + data["__nvmlDeviceGetVgpuSchedulerCapabilities"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuSchedulerCapabilities global __nvmlDeviceSetVgpuSchedulerState - data["__nvmlDeviceSetVgpuSchedulerState"] = __nvmlDeviceSetVgpuSchedulerState + data["__nvmlDeviceSetVgpuSchedulerState"] = <_cyb_intptr_t>__nvmlDeviceSetVgpuSchedulerState global __nvmlGetVgpuVersion - data["__nvmlGetVgpuVersion"] = __nvmlGetVgpuVersion + data["__nvmlGetVgpuVersion"] = <_cyb_intptr_t>__nvmlGetVgpuVersion global __nvmlSetVgpuVersion - data["__nvmlSetVgpuVersion"] = __nvmlSetVgpuVersion + data["__nvmlSetVgpuVersion"] = <_cyb_intptr_t>__nvmlSetVgpuVersion global __nvmlDeviceGetVgpuUtilization - data["__nvmlDeviceGetVgpuUtilization"] = __nvmlDeviceGetVgpuUtilization + data["__nvmlDeviceGetVgpuUtilization"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuUtilization global __nvmlDeviceGetVgpuInstancesUtilizationInfo - data["__nvmlDeviceGetVgpuInstancesUtilizationInfo"] = __nvmlDeviceGetVgpuInstancesUtilizationInfo + data["__nvmlDeviceGetVgpuInstancesUtilizationInfo"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuInstancesUtilizationInfo global __nvmlDeviceGetVgpuProcessUtilization - data["__nvmlDeviceGetVgpuProcessUtilization"] = __nvmlDeviceGetVgpuProcessUtilization + data["__nvmlDeviceGetVgpuProcessUtilization"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuProcessUtilization global __nvmlDeviceGetVgpuProcessesUtilizationInfo - data["__nvmlDeviceGetVgpuProcessesUtilizationInfo"] = __nvmlDeviceGetVgpuProcessesUtilizationInfo + data["__nvmlDeviceGetVgpuProcessesUtilizationInfo"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuProcessesUtilizationInfo global __nvmlVgpuInstanceGetAccountingMode - data["__nvmlVgpuInstanceGetAccountingMode"] = __nvmlVgpuInstanceGetAccountingMode + data["__nvmlVgpuInstanceGetAccountingMode"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetAccountingMode global __nvmlVgpuInstanceGetAccountingPids - data["__nvmlVgpuInstanceGetAccountingPids"] = __nvmlVgpuInstanceGetAccountingPids + data["__nvmlVgpuInstanceGetAccountingPids"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetAccountingPids global __nvmlVgpuInstanceGetAccountingStats - data["__nvmlVgpuInstanceGetAccountingStats"] = __nvmlVgpuInstanceGetAccountingStats + data["__nvmlVgpuInstanceGetAccountingStats"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetAccountingStats global __nvmlVgpuInstanceClearAccountingPids - data["__nvmlVgpuInstanceClearAccountingPids"] = __nvmlVgpuInstanceClearAccountingPids + data["__nvmlVgpuInstanceClearAccountingPids"] = <_cyb_intptr_t>__nvmlVgpuInstanceClearAccountingPids global __nvmlVgpuInstanceGetLicenseInfo_v2 - data["__nvmlVgpuInstanceGetLicenseInfo_v2"] = __nvmlVgpuInstanceGetLicenseInfo_v2 + data["__nvmlVgpuInstanceGetLicenseInfo_v2"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetLicenseInfo_v2 global __nvmlGetExcludedDeviceCount - data["__nvmlGetExcludedDeviceCount"] = __nvmlGetExcludedDeviceCount + data["__nvmlGetExcludedDeviceCount"] = <_cyb_intptr_t>__nvmlGetExcludedDeviceCount global __nvmlGetExcludedDeviceInfoByIndex - data["__nvmlGetExcludedDeviceInfoByIndex"] = __nvmlGetExcludedDeviceInfoByIndex + data["__nvmlGetExcludedDeviceInfoByIndex"] = <_cyb_intptr_t>__nvmlGetExcludedDeviceInfoByIndex global __nvmlDeviceSetMigMode - data["__nvmlDeviceSetMigMode"] = __nvmlDeviceSetMigMode + data["__nvmlDeviceSetMigMode"] = <_cyb_intptr_t>__nvmlDeviceSetMigMode global __nvmlDeviceGetMigMode - data["__nvmlDeviceGetMigMode"] = __nvmlDeviceGetMigMode + data["__nvmlDeviceGetMigMode"] = <_cyb_intptr_t>__nvmlDeviceGetMigMode global __nvmlDeviceGetGpuInstanceProfileInfoV - data["__nvmlDeviceGetGpuInstanceProfileInfoV"] = __nvmlDeviceGetGpuInstanceProfileInfoV + data["__nvmlDeviceGetGpuInstanceProfileInfoV"] = <_cyb_intptr_t>__nvmlDeviceGetGpuInstanceProfileInfoV global __nvmlDeviceGetGpuInstancePossiblePlacements_v2 - data["__nvmlDeviceGetGpuInstancePossiblePlacements_v2"] = __nvmlDeviceGetGpuInstancePossiblePlacements_v2 + data["__nvmlDeviceGetGpuInstancePossiblePlacements_v2"] = <_cyb_intptr_t>__nvmlDeviceGetGpuInstancePossiblePlacements_v2 global __nvmlDeviceGetGpuInstanceRemainingCapacity - data["__nvmlDeviceGetGpuInstanceRemainingCapacity"] = __nvmlDeviceGetGpuInstanceRemainingCapacity + data["__nvmlDeviceGetGpuInstanceRemainingCapacity"] = <_cyb_intptr_t>__nvmlDeviceGetGpuInstanceRemainingCapacity global __nvmlDeviceCreateGpuInstance - data["__nvmlDeviceCreateGpuInstance"] = __nvmlDeviceCreateGpuInstance + data["__nvmlDeviceCreateGpuInstance"] = <_cyb_intptr_t>__nvmlDeviceCreateGpuInstance global __nvmlDeviceCreateGpuInstanceWithPlacement - data["__nvmlDeviceCreateGpuInstanceWithPlacement"] = __nvmlDeviceCreateGpuInstanceWithPlacement + data["__nvmlDeviceCreateGpuInstanceWithPlacement"] = <_cyb_intptr_t>__nvmlDeviceCreateGpuInstanceWithPlacement global __nvmlGpuInstanceDestroy - data["__nvmlGpuInstanceDestroy"] = __nvmlGpuInstanceDestroy + data["__nvmlGpuInstanceDestroy"] = <_cyb_intptr_t>__nvmlGpuInstanceDestroy global __nvmlDeviceGetGpuInstances - data["__nvmlDeviceGetGpuInstances"] = __nvmlDeviceGetGpuInstances + data["__nvmlDeviceGetGpuInstances"] = <_cyb_intptr_t>__nvmlDeviceGetGpuInstances global __nvmlDeviceGetGpuInstanceById - data["__nvmlDeviceGetGpuInstanceById"] = __nvmlDeviceGetGpuInstanceById + data["__nvmlDeviceGetGpuInstanceById"] = <_cyb_intptr_t>__nvmlDeviceGetGpuInstanceById global __nvmlGpuInstanceGetInfo - data["__nvmlGpuInstanceGetInfo"] = __nvmlGpuInstanceGetInfo + data["__nvmlGpuInstanceGetInfo"] = <_cyb_intptr_t>__nvmlGpuInstanceGetInfo global __nvmlGpuInstanceGetComputeInstanceProfileInfoV - data["__nvmlGpuInstanceGetComputeInstanceProfileInfoV"] = __nvmlGpuInstanceGetComputeInstanceProfileInfoV + data["__nvmlGpuInstanceGetComputeInstanceProfileInfoV"] = <_cyb_intptr_t>__nvmlGpuInstanceGetComputeInstanceProfileInfoV global __nvmlGpuInstanceGetComputeInstanceRemainingCapacity - data["__nvmlGpuInstanceGetComputeInstanceRemainingCapacity"] = __nvmlGpuInstanceGetComputeInstanceRemainingCapacity + data["__nvmlGpuInstanceGetComputeInstanceRemainingCapacity"] = <_cyb_intptr_t>__nvmlGpuInstanceGetComputeInstanceRemainingCapacity global __nvmlGpuInstanceGetComputeInstancePossiblePlacements - data["__nvmlGpuInstanceGetComputeInstancePossiblePlacements"] = __nvmlGpuInstanceGetComputeInstancePossiblePlacements + data["__nvmlGpuInstanceGetComputeInstancePossiblePlacements"] = <_cyb_intptr_t>__nvmlGpuInstanceGetComputeInstancePossiblePlacements global __nvmlGpuInstanceCreateComputeInstance - data["__nvmlGpuInstanceCreateComputeInstance"] = __nvmlGpuInstanceCreateComputeInstance + data["__nvmlGpuInstanceCreateComputeInstance"] = <_cyb_intptr_t>__nvmlGpuInstanceCreateComputeInstance global __nvmlGpuInstanceCreateComputeInstanceWithPlacement - data["__nvmlGpuInstanceCreateComputeInstanceWithPlacement"] = __nvmlGpuInstanceCreateComputeInstanceWithPlacement + data["__nvmlGpuInstanceCreateComputeInstanceWithPlacement"] = <_cyb_intptr_t>__nvmlGpuInstanceCreateComputeInstanceWithPlacement global __nvmlComputeInstanceDestroy - data["__nvmlComputeInstanceDestroy"] = __nvmlComputeInstanceDestroy + data["__nvmlComputeInstanceDestroy"] = <_cyb_intptr_t>__nvmlComputeInstanceDestroy global __nvmlGpuInstanceGetComputeInstances - data["__nvmlGpuInstanceGetComputeInstances"] = __nvmlGpuInstanceGetComputeInstances + data["__nvmlGpuInstanceGetComputeInstances"] = <_cyb_intptr_t>__nvmlGpuInstanceGetComputeInstances global __nvmlGpuInstanceGetComputeInstanceById - data["__nvmlGpuInstanceGetComputeInstanceById"] = __nvmlGpuInstanceGetComputeInstanceById + data["__nvmlGpuInstanceGetComputeInstanceById"] = <_cyb_intptr_t>__nvmlGpuInstanceGetComputeInstanceById global __nvmlComputeInstanceGetInfo_v2 - data["__nvmlComputeInstanceGetInfo_v2"] = __nvmlComputeInstanceGetInfo_v2 + data["__nvmlComputeInstanceGetInfo_v2"] = <_cyb_intptr_t>__nvmlComputeInstanceGetInfo_v2 global __nvmlDeviceIsMigDeviceHandle - data["__nvmlDeviceIsMigDeviceHandle"] = __nvmlDeviceIsMigDeviceHandle + data["__nvmlDeviceIsMigDeviceHandle"] = <_cyb_intptr_t>__nvmlDeviceIsMigDeviceHandle global __nvmlDeviceGetGpuInstanceId - data["__nvmlDeviceGetGpuInstanceId"] = __nvmlDeviceGetGpuInstanceId + data["__nvmlDeviceGetGpuInstanceId"] = <_cyb_intptr_t>__nvmlDeviceGetGpuInstanceId global __nvmlDeviceGetComputeInstanceId - data["__nvmlDeviceGetComputeInstanceId"] = __nvmlDeviceGetComputeInstanceId + data["__nvmlDeviceGetComputeInstanceId"] = <_cyb_intptr_t>__nvmlDeviceGetComputeInstanceId global __nvmlDeviceGetMaxMigDeviceCount - data["__nvmlDeviceGetMaxMigDeviceCount"] = __nvmlDeviceGetMaxMigDeviceCount + data["__nvmlDeviceGetMaxMigDeviceCount"] = <_cyb_intptr_t>__nvmlDeviceGetMaxMigDeviceCount global __nvmlDeviceGetMigDeviceHandleByIndex - data["__nvmlDeviceGetMigDeviceHandleByIndex"] = __nvmlDeviceGetMigDeviceHandleByIndex + data["__nvmlDeviceGetMigDeviceHandleByIndex"] = <_cyb_intptr_t>__nvmlDeviceGetMigDeviceHandleByIndex global __nvmlDeviceGetDeviceHandleFromMigDeviceHandle - data["__nvmlDeviceGetDeviceHandleFromMigDeviceHandle"] = __nvmlDeviceGetDeviceHandleFromMigDeviceHandle + data["__nvmlDeviceGetDeviceHandleFromMigDeviceHandle"] = <_cyb_intptr_t>__nvmlDeviceGetDeviceHandleFromMigDeviceHandle global __nvmlDeviceGetCapabilities - data["__nvmlDeviceGetCapabilities"] = __nvmlDeviceGetCapabilities + data["__nvmlDeviceGetCapabilities"] = <_cyb_intptr_t>__nvmlDeviceGetCapabilities global __nvmlDevicePowerSmoothingActivatePresetProfile - data["__nvmlDevicePowerSmoothingActivatePresetProfile"] = __nvmlDevicePowerSmoothingActivatePresetProfile + data["__nvmlDevicePowerSmoothingActivatePresetProfile"] = <_cyb_intptr_t>__nvmlDevicePowerSmoothingActivatePresetProfile global __nvmlDevicePowerSmoothingUpdatePresetProfileParam - data["__nvmlDevicePowerSmoothingUpdatePresetProfileParam"] = __nvmlDevicePowerSmoothingUpdatePresetProfileParam + data["__nvmlDevicePowerSmoothingUpdatePresetProfileParam"] = <_cyb_intptr_t>__nvmlDevicePowerSmoothingUpdatePresetProfileParam global __nvmlDevicePowerSmoothingSetState - data["__nvmlDevicePowerSmoothingSetState"] = __nvmlDevicePowerSmoothingSetState + data["__nvmlDevicePowerSmoothingSetState"] = <_cyb_intptr_t>__nvmlDevicePowerSmoothingSetState global __nvmlDeviceGetAddressingMode - data["__nvmlDeviceGetAddressingMode"] = __nvmlDeviceGetAddressingMode + data["__nvmlDeviceGetAddressingMode"] = <_cyb_intptr_t>__nvmlDeviceGetAddressingMode global __nvmlDeviceGetRepairStatus - data["__nvmlDeviceGetRepairStatus"] = __nvmlDeviceGetRepairStatus + data["__nvmlDeviceGetRepairStatus"] = <_cyb_intptr_t>__nvmlDeviceGetRepairStatus global __nvmlDeviceGetPowerMizerMode_v1 - data["__nvmlDeviceGetPowerMizerMode_v1"] = __nvmlDeviceGetPowerMizerMode_v1 + data["__nvmlDeviceGetPowerMizerMode_v1"] = <_cyb_intptr_t>__nvmlDeviceGetPowerMizerMode_v1 global __nvmlDeviceSetPowerMizerMode_v1 - data["__nvmlDeviceSetPowerMizerMode_v1"] = __nvmlDeviceSetPowerMizerMode_v1 + data["__nvmlDeviceSetPowerMizerMode_v1"] = <_cyb_intptr_t>__nvmlDeviceSetPowerMizerMode_v1 global __nvmlDeviceGetPdi - data["__nvmlDeviceGetPdi"] = __nvmlDeviceGetPdi + data["__nvmlDeviceGetPdi"] = <_cyb_intptr_t>__nvmlDeviceGetPdi global __nvmlDeviceSetHostname_v1 - data["__nvmlDeviceSetHostname_v1"] = __nvmlDeviceSetHostname_v1 + data["__nvmlDeviceSetHostname_v1"] = <_cyb_intptr_t>__nvmlDeviceSetHostname_v1 global __nvmlDeviceGetHostname_v1 - data["__nvmlDeviceGetHostname_v1"] = __nvmlDeviceGetHostname_v1 + data["__nvmlDeviceGetHostname_v1"] = <_cyb_intptr_t>__nvmlDeviceGetHostname_v1 global __nvmlDeviceGetNvLinkInfo - data["__nvmlDeviceGetNvLinkInfo"] = __nvmlDeviceGetNvLinkInfo + data["__nvmlDeviceGetNvLinkInfo"] = <_cyb_intptr_t>__nvmlDeviceGetNvLinkInfo global __nvmlDeviceReadWritePRM_v1 - data["__nvmlDeviceReadWritePRM_v1"] = __nvmlDeviceReadWritePRM_v1 + data["__nvmlDeviceReadWritePRM_v1"] = <_cyb_intptr_t>__nvmlDeviceReadWritePRM_v1 global __nvmlDeviceGetGpuInstanceProfileInfoByIdV - data["__nvmlDeviceGetGpuInstanceProfileInfoByIdV"] = __nvmlDeviceGetGpuInstanceProfileInfoByIdV + data["__nvmlDeviceGetGpuInstanceProfileInfoByIdV"] = <_cyb_intptr_t>__nvmlDeviceGetGpuInstanceProfileInfoByIdV global __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts - data["__nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts"] = __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts + data["__nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts"] = <_cyb_intptr_t>__nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts global __nvmlDeviceGetUnrepairableMemoryFlag_v1 - data["__nvmlDeviceGetUnrepairableMemoryFlag_v1"] = __nvmlDeviceGetUnrepairableMemoryFlag_v1 + data["__nvmlDeviceGetUnrepairableMemoryFlag_v1"] = <_cyb_intptr_t>__nvmlDeviceGetUnrepairableMemoryFlag_v1 global __nvmlDeviceReadPRMCounters_v1 - data["__nvmlDeviceReadPRMCounters_v1"] = __nvmlDeviceReadPRMCounters_v1 + data["__nvmlDeviceReadPRMCounters_v1"] = <_cyb_intptr_t>__nvmlDeviceReadPRMCounters_v1 global __nvmlDeviceSetRusdSettings_v1 - data["__nvmlDeviceSetRusdSettings_v1"] = __nvmlDeviceSetRusdSettings_v1 + data["__nvmlDeviceSetRusdSettings_v1"] = <_cyb_intptr_t>__nvmlDeviceSetRusdSettings_v1 global __nvmlDeviceVgpuForceGspUnload - data["__nvmlDeviceVgpuForceGspUnload"] = __nvmlDeviceVgpuForceGspUnload + data["__nvmlDeviceVgpuForceGspUnload"] = <_cyb_intptr_t>__nvmlDeviceVgpuForceGspUnload global __nvmlDeviceGetVgpuSchedulerState_v2 - data["__nvmlDeviceGetVgpuSchedulerState_v2"] = __nvmlDeviceGetVgpuSchedulerState_v2 + data["__nvmlDeviceGetVgpuSchedulerState_v2"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuSchedulerState_v2 global __nvmlGpuInstanceGetVgpuSchedulerState_v2 - data["__nvmlGpuInstanceGetVgpuSchedulerState_v2"] = __nvmlGpuInstanceGetVgpuSchedulerState_v2 + data["__nvmlGpuInstanceGetVgpuSchedulerState_v2"] = <_cyb_intptr_t>__nvmlGpuInstanceGetVgpuSchedulerState_v2 global __nvmlDeviceGetVgpuSchedulerLog_v2 - data["__nvmlDeviceGetVgpuSchedulerLog_v2"] = __nvmlDeviceGetVgpuSchedulerLog_v2 + data["__nvmlDeviceGetVgpuSchedulerLog_v2"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuSchedulerLog_v2 global __nvmlGpuInstanceGetVgpuSchedulerLog_v2 - data["__nvmlGpuInstanceGetVgpuSchedulerLog_v2"] = __nvmlGpuInstanceGetVgpuSchedulerLog_v2 + data["__nvmlGpuInstanceGetVgpuSchedulerLog_v2"] = <_cyb_intptr_t>__nvmlGpuInstanceGetVgpuSchedulerLog_v2 global __nvmlDeviceSetVgpuSchedulerState_v2 - data["__nvmlDeviceSetVgpuSchedulerState_v2"] = __nvmlDeviceSetVgpuSchedulerState_v2 + data["__nvmlDeviceSetVgpuSchedulerState_v2"] = <_cyb_intptr_t>__nvmlDeviceSetVgpuSchedulerState_v2 global __nvmlGpuInstanceSetVgpuSchedulerState_v2 - data["__nvmlGpuInstanceSetVgpuSchedulerState_v2"] = __nvmlGpuInstanceSetVgpuSchedulerState_v2 - - func_ptrs = data + data["__nvmlGpuInstanceSetVgpuSchedulerState_v2"] = <_cyb_intptr_t>__nvmlGpuInstanceSetVgpuSchedulerState_v2 + _cyb_func_ptrs = data return data cpdef _inspect_function_pointer(str name): - global func_ptrs - if func_ptrs is None: - func_ptrs = _inspect_function_pointers() - return func_ptrs[name] + global _cyb_func_ptrs + if _cyb_func_ptrs is None: + _cyb_func_ptrs = _inspect_function_pointers() + return _cyb_func_ptrs[name] + + + + +cdef uintptr_t load_library() except* with gil: + return load_nvidia_dynamic_lib("nvml")._handle_uint ############################################################################### diff --git a/cuda_bindings/cuda/bindings/_internal/nvrtc_linux.pyx b/cuda_bindings/cuda/bindings/_internal/nvrtc_linux.pyx index 43efa40e4d8..bc635a3ca95 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvrtc_linux.pyx +++ b/cuda_bindings/cuda/bindings/_internal/nvrtc_linux.pyx @@ -3,63 +3,35 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.9.0 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=0ca6f301335e0e0a3b70c6fddc4f54b7930b547f18e05f0ede5a9e0f437c79f8 -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=6e54cb56384256b65cc962fbb478f7fac87523f222a141785b66881d8f554c64 -from libc.stdint cimport intptr_t, uintptr_t -import threading -from .utils import FunctionNotFoundError, NotSupportedError - -from cuda.pathfinder import load_nvidia_dynamic_lib - - -############################################################################### -# Extern -############################################################################### - -# You must 'from .utils import NotSupportedError' before using this template +# <<<< PREAMBLE CONTENT >>>> -cdef extern from "" nogil: - void* dlopen(const char*, int) - char* dlerror() - void* dlsym(void*, const char*) - int dlclose(void*) +cdef extern from "": + void* _cyb_dlsym "dlsym"(void*, const char*) nogil + const void * _cyb_RTLD_DEFAULT "RTLD_DEFAULT" - enum: - RTLD_LAZY - RTLD_NOW - RTLD_GLOBAL - RTLD_LOCAL +from libc.stdint cimport intptr_t as _cyb_intptr_t - const void* RTLD_DEFAULT 'RTLD_DEFAULT' +import threading as _cyb_threading -cdef int get_cuda_version(): - cdef void* handle = NULL - cdef int err, driver_ver = 0 +cdef bint _cyb___py_nvrtc_init = False +cdef dict _cyb_func_ptrs = None +cdef object _cyb_symbol_lock = _cyb_threading.Lock() - # Load driver to check version - handle = dlopen('libcuda.so.1', RTLD_NOW | RTLD_GLOBAL) - if handle == NULL: - err_msg = dlerror() - raise NotSupportedError(f'CUDA driver is not found ({err_msg.decode()})') - cuDriverGetVersion = dlsym(handle, "cuDriverGetVersion") - if cuDriverGetVersion == NULL: - raise RuntimeError('Did not find cuDriverGetVersion symbol in libcuda.so.1') - err = (cuDriverGetVersion)(&driver_ver) - if err != 0: - raise RuntimeError(f'cuDriverGetVersion returned error code {err}') +# <<<< END OF PREAMBLE CONTENT >>>> - return driver_ver +from libc.stdint cimport uintptr_t +from .utils import FunctionNotFoundError, NotSupportedError +from cuda.pathfinder import load_nvidia_dynamic_lib ############################################################################### # Wrapper init ############################################################################### -cdef object __symbol_lock = threading.Lock() -cdef bint __py_nvrtc_init = False - cdef void* __nvrtcGetErrorString = NULL cdef void* __nvrtcVersion = NULL cdef void* __nvrtcGetNumSupportedArchs = NULL @@ -90,343 +62,334 @@ cdef void* __nvrtcInstallBundledHeaders = NULL cdef void* __nvrtcGetBundledHeadersInfo = NULL cdef void* __nvrtcRemoveBundledHeaders = NULL - -cdef void* load_library() except* with gil: - cdef uintptr_t handle = load_nvidia_dynamic_lib("nvrtc")._handle_uint - return handle - - cdef int _init_nvrtc() except -1 nogil: - global __py_nvrtc_init - + global _cyb___py_nvrtc_init cdef void* handle = NULL + with gil, _cyb_symbol_lock: + if _cyb___py_nvrtc_init: return 0 - with gil, __symbol_lock: - # Recheck the flag after obtaining the locks - if __py_nvrtc_init: - return 0 - - # Load function global __nvrtcGetErrorString - __nvrtcGetErrorString = dlsym(RTLD_DEFAULT, 'nvrtcGetErrorString') + __nvrtcGetErrorString = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvrtcGetErrorString') if __nvrtcGetErrorString == NULL: if handle == NULL: handle = load_library() - __nvrtcGetErrorString = dlsym(handle, 'nvrtcGetErrorString') + __nvrtcGetErrorString = _cyb_dlsym(handle, 'nvrtcGetErrorString') global __nvrtcVersion - __nvrtcVersion = dlsym(RTLD_DEFAULT, 'nvrtcVersion') + __nvrtcVersion = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvrtcVersion') if __nvrtcVersion == NULL: if handle == NULL: handle = load_library() - __nvrtcVersion = dlsym(handle, 'nvrtcVersion') + __nvrtcVersion = _cyb_dlsym(handle, 'nvrtcVersion') global __nvrtcGetNumSupportedArchs - __nvrtcGetNumSupportedArchs = dlsym(RTLD_DEFAULT, 'nvrtcGetNumSupportedArchs') + __nvrtcGetNumSupportedArchs = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvrtcGetNumSupportedArchs') if __nvrtcGetNumSupportedArchs == NULL: if handle == NULL: handle = load_library() - __nvrtcGetNumSupportedArchs = dlsym(handle, 'nvrtcGetNumSupportedArchs') + __nvrtcGetNumSupportedArchs = _cyb_dlsym(handle, 'nvrtcGetNumSupportedArchs') global __nvrtcGetSupportedArchs - __nvrtcGetSupportedArchs = dlsym(RTLD_DEFAULT, 'nvrtcGetSupportedArchs') + __nvrtcGetSupportedArchs = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvrtcGetSupportedArchs') if __nvrtcGetSupportedArchs == NULL: if handle == NULL: handle = load_library() - __nvrtcGetSupportedArchs = dlsym(handle, 'nvrtcGetSupportedArchs') + __nvrtcGetSupportedArchs = _cyb_dlsym(handle, 'nvrtcGetSupportedArchs') global __nvrtcCreateProgram - __nvrtcCreateProgram = dlsym(RTLD_DEFAULT, 'nvrtcCreateProgram') + __nvrtcCreateProgram = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvrtcCreateProgram') if __nvrtcCreateProgram == NULL: if handle == NULL: handle = load_library() - __nvrtcCreateProgram = dlsym(handle, 'nvrtcCreateProgram') + __nvrtcCreateProgram = _cyb_dlsym(handle, 'nvrtcCreateProgram') global __nvrtcDestroyProgram - __nvrtcDestroyProgram = dlsym(RTLD_DEFAULT, 'nvrtcDestroyProgram') + __nvrtcDestroyProgram = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvrtcDestroyProgram') if __nvrtcDestroyProgram == NULL: if handle == NULL: handle = load_library() - __nvrtcDestroyProgram = dlsym(handle, 'nvrtcDestroyProgram') + __nvrtcDestroyProgram = _cyb_dlsym(handle, 'nvrtcDestroyProgram') global __nvrtcCompileProgram - __nvrtcCompileProgram = dlsym(RTLD_DEFAULT, 'nvrtcCompileProgram') + __nvrtcCompileProgram = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvrtcCompileProgram') if __nvrtcCompileProgram == NULL: if handle == NULL: handle = load_library() - __nvrtcCompileProgram = dlsym(handle, 'nvrtcCompileProgram') + __nvrtcCompileProgram = _cyb_dlsym(handle, 'nvrtcCompileProgram') global __nvrtcGetPTXSize - __nvrtcGetPTXSize = dlsym(RTLD_DEFAULT, 'nvrtcGetPTXSize') + __nvrtcGetPTXSize = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvrtcGetPTXSize') if __nvrtcGetPTXSize == NULL: if handle == NULL: handle = load_library() - __nvrtcGetPTXSize = dlsym(handle, 'nvrtcGetPTXSize') + __nvrtcGetPTXSize = _cyb_dlsym(handle, 'nvrtcGetPTXSize') global __nvrtcGetPTX - __nvrtcGetPTX = dlsym(RTLD_DEFAULT, 'nvrtcGetPTX') + __nvrtcGetPTX = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvrtcGetPTX') if __nvrtcGetPTX == NULL: if handle == NULL: handle = load_library() - __nvrtcGetPTX = dlsym(handle, 'nvrtcGetPTX') + __nvrtcGetPTX = _cyb_dlsym(handle, 'nvrtcGetPTX') global __nvrtcGetCUBINSize - __nvrtcGetCUBINSize = dlsym(RTLD_DEFAULT, 'nvrtcGetCUBINSize') + __nvrtcGetCUBINSize = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvrtcGetCUBINSize') if __nvrtcGetCUBINSize == NULL: if handle == NULL: handle = load_library() - __nvrtcGetCUBINSize = dlsym(handle, 'nvrtcGetCUBINSize') + __nvrtcGetCUBINSize = _cyb_dlsym(handle, 'nvrtcGetCUBINSize') global __nvrtcGetCUBIN - __nvrtcGetCUBIN = dlsym(RTLD_DEFAULT, 'nvrtcGetCUBIN') + __nvrtcGetCUBIN = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvrtcGetCUBIN') if __nvrtcGetCUBIN == NULL: if handle == NULL: handle = load_library() - __nvrtcGetCUBIN = dlsym(handle, 'nvrtcGetCUBIN') + __nvrtcGetCUBIN = _cyb_dlsym(handle, 'nvrtcGetCUBIN') global __nvrtcGetLTOIRSize - __nvrtcGetLTOIRSize = dlsym(RTLD_DEFAULT, 'nvrtcGetLTOIRSize') + __nvrtcGetLTOIRSize = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvrtcGetLTOIRSize') if __nvrtcGetLTOIRSize == NULL: if handle == NULL: handle = load_library() - __nvrtcGetLTOIRSize = dlsym(handle, 'nvrtcGetLTOIRSize') + __nvrtcGetLTOIRSize = _cyb_dlsym(handle, 'nvrtcGetLTOIRSize') global __nvrtcGetLTOIR - __nvrtcGetLTOIR = dlsym(RTLD_DEFAULT, 'nvrtcGetLTOIR') + __nvrtcGetLTOIR = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvrtcGetLTOIR') if __nvrtcGetLTOIR == NULL: if handle == NULL: handle = load_library() - __nvrtcGetLTOIR = dlsym(handle, 'nvrtcGetLTOIR') + __nvrtcGetLTOIR = _cyb_dlsym(handle, 'nvrtcGetLTOIR') global __nvrtcGetOptiXIRSize - __nvrtcGetOptiXIRSize = dlsym(RTLD_DEFAULT, 'nvrtcGetOptiXIRSize') + __nvrtcGetOptiXIRSize = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvrtcGetOptiXIRSize') if __nvrtcGetOptiXIRSize == NULL: if handle == NULL: handle = load_library() - __nvrtcGetOptiXIRSize = dlsym(handle, 'nvrtcGetOptiXIRSize') + __nvrtcGetOptiXIRSize = _cyb_dlsym(handle, 'nvrtcGetOptiXIRSize') global __nvrtcGetOptiXIR - __nvrtcGetOptiXIR = dlsym(RTLD_DEFAULT, 'nvrtcGetOptiXIR') + __nvrtcGetOptiXIR = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvrtcGetOptiXIR') if __nvrtcGetOptiXIR == NULL: if handle == NULL: handle = load_library() - __nvrtcGetOptiXIR = dlsym(handle, 'nvrtcGetOptiXIR') + __nvrtcGetOptiXIR = _cyb_dlsym(handle, 'nvrtcGetOptiXIR') global __nvrtcGetProgramLogSize - __nvrtcGetProgramLogSize = dlsym(RTLD_DEFAULT, 'nvrtcGetProgramLogSize') + __nvrtcGetProgramLogSize = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvrtcGetProgramLogSize') if __nvrtcGetProgramLogSize == NULL: if handle == NULL: handle = load_library() - __nvrtcGetProgramLogSize = dlsym(handle, 'nvrtcGetProgramLogSize') + __nvrtcGetProgramLogSize = _cyb_dlsym(handle, 'nvrtcGetProgramLogSize') global __nvrtcGetProgramLog - __nvrtcGetProgramLog = dlsym(RTLD_DEFAULT, 'nvrtcGetProgramLog') + __nvrtcGetProgramLog = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvrtcGetProgramLog') if __nvrtcGetProgramLog == NULL: if handle == NULL: handle = load_library() - __nvrtcGetProgramLog = dlsym(handle, 'nvrtcGetProgramLog') + __nvrtcGetProgramLog = _cyb_dlsym(handle, 'nvrtcGetProgramLog') global __nvrtcAddNameExpression - __nvrtcAddNameExpression = dlsym(RTLD_DEFAULT, 'nvrtcAddNameExpression') + __nvrtcAddNameExpression = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvrtcAddNameExpression') if __nvrtcAddNameExpression == NULL: if handle == NULL: handle = load_library() - __nvrtcAddNameExpression = dlsym(handle, 'nvrtcAddNameExpression') + __nvrtcAddNameExpression = _cyb_dlsym(handle, 'nvrtcAddNameExpression') global __nvrtcGetLoweredName - __nvrtcGetLoweredName = dlsym(RTLD_DEFAULT, 'nvrtcGetLoweredName') + __nvrtcGetLoweredName = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvrtcGetLoweredName') if __nvrtcGetLoweredName == NULL: if handle == NULL: handle = load_library() - __nvrtcGetLoweredName = dlsym(handle, 'nvrtcGetLoweredName') + __nvrtcGetLoweredName = _cyb_dlsym(handle, 'nvrtcGetLoweredName') global __nvrtcGetPCHHeapSize - __nvrtcGetPCHHeapSize = dlsym(RTLD_DEFAULT, 'nvrtcGetPCHHeapSize') + __nvrtcGetPCHHeapSize = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvrtcGetPCHHeapSize') if __nvrtcGetPCHHeapSize == NULL: if handle == NULL: handle = load_library() - __nvrtcGetPCHHeapSize = dlsym(handle, 'nvrtcGetPCHHeapSize') + __nvrtcGetPCHHeapSize = _cyb_dlsym(handle, 'nvrtcGetPCHHeapSize') global __nvrtcSetPCHHeapSize - __nvrtcSetPCHHeapSize = dlsym(RTLD_DEFAULT, 'nvrtcSetPCHHeapSize') + __nvrtcSetPCHHeapSize = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvrtcSetPCHHeapSize') if __nvrtcSetPCHHeapSize == NULL: if handle == NULL: handle = load_library() - __nvrtcSetPCHHeapSize = dlsym(handle, 'nvrtcSetPCHHeapSize') + __nvrtcSetPCHHeapSize = _cyb_dlsym(handle, 'nvrtcSetPCHHeapSize') global __nvrtcGetPCHCreateStatus - __nvrtcGetPCHCreateStatus = dlsym(RTLD_DEFAULT, 'nvrtcGetPCHCreateStatus') + __nvrtcGetPCHCreateStatus = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvrtcGetPCHCreateStatus') if __nvrtcGetPCHCreateStatus == NULL: if handle == NULL: handle = load_library() - __nvrtcGetPCHCreateStatus = dlsym(handle, 'nvrtcGetPCHCreateStatus') + __nvrtcGetPCHCreateStatus = _cyb_dlsym(handle, 'nvrtcGetPCHCreateStatus') global __nvrtcGetPCHHeapSizeRequired - __nvrtcGetPCHHeapSizeRequired = dlsym(RTLD_DEFAULT, 'nvrtcGetPCHHeapSizeRequired') + __nvrtcGetPCHHeapSizeRequired = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvrtcGetPCHHeapSizeRequired') if __nvrtcGetPCHHeapSizeRequired == NULL: if handle == NULL: handle = load_library() - __nvrtcGetPCHHeapSizeRequired = dlsym(handle, 'nvrtcGetPCHHeapSizeRequired') + __nvrtcGetPCHHeapSizeRequired = _cyb_dlsym(handle, 'nvrtcGetPCHHeapSizeRequired') global __nvrtcSetFlowCallback - __nvrtcSetFlowCallback = dlsym(RTLD_DEFAULT, 'nvrtcSetFlowCallback') + __nvrtcSetFlowCallback = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvrtcSetFlowCallback') if __nvrtcSetFlowCallback == NULL: if handle == NULL: handle = load_library() - __nvrtcSetFlowCallback = dlsym(handle, 'nvrtcSetFlowCallback') + __nvrtcSetFlowCallback = _cyb_dlsym(handle, 'nvrtcSetFlowCallback') global __nvrtcGetTileIRSize - __nvrtcGetTileIRSize = dlsym(RTLD_DEFAULT, 'nvrtcGetTileIRSize') + __nvrtcGetTileIRSize = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvrtcGetTileIRSize') if __nvrtcGetTileIRSize == NULL: if handle == NULL: handle = load_library() - __nvrtcGetTileIRSize = dlsym(handle, 'nvrtcGetTileIRSize') + __nvrtcGetTileIRSize = _cyb_dlsym(handle, 'nvrtcGetTileIRSize') global __nvrtcGetTileIR - __nvrtcGetTileIR = dlsym(RTLD_DEFAULT, 'nvrtcGetTileIR') + __nvrtcGetTileIR = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvrtcGetTileIR') if __nvrtcGetTileIR == NULL: if handle == NULL: handle = load_library() - __nvrtcGetTileIR = dlsym(handle, 'nvrtcGetTileIR') + __nvrtcGetTileIR = _cyb_dlsym(handle, 'nvrtcGetTileIR') global __nvrtcInstallBundledHeaders - __nvrtcInstallBundledHeaders = dlsym(RTLD_DEFAULT, 'nvrtcInstallBundledHeaders') + __nvrtcInstallBundledHeaders = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvrtcInstallBundledHeaders') if __nvrtcInstallBundledHeaders == NULL: if handle == NULL: handle = load_library() - __nvrtcInstallBundledHeaders = dlsym(handle, 'nvrtcInstallBundledHeaders') + __nvrtcInstallBundledHeaders = _cyb_dlsym(handle, 'nvrtcInstallBundledHeaders') global __nvrtcGetBundledHeadersInfo - __nvrtcGetBundledHeadersInfo = dlsym(RTLD_DEFAULT, 'nvrtcGetBundledHeadersInfo') + __nvrtcGetBundledHeadersInfo = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvrtcGetBundledHeadersInfo') if __nvrtcGetBundledHeadersInfo == NULL: if handle == NULL: handle = load_library() - __nvrtcGetBundledHeadersInfo = dlsym(handle, 'nvrtcGetBundledHeadersInfo') + __nvrtcGetBundledHeadersInfo = _cyb_dlsym(handle, 'nvrtcGetBundledHeadersInfo') global __nvrtcRemoveBundledHeaders - __nvrtcRemoveBundledHeaders = dlsym(RTLD_DEFAULT, 'nvrtcRemoveBundledHeaders') + __nvrtcRemoveBundledHeaders = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvrtcRemoveBundledHeaders') if __nvrtcRemoveBundledHeaders == NULL: if handle == NULL: handle = load_library() - __nvrtcRemoveBundledHeaders = dlsym(handle, 'nvrtcRemoveBundledHeaders') + __nvrtcRemoveBundledHeaders = _cyb_dlsym(handle, 'nvrtcRemoveBundledHeaders') - __py_nvrtc_init = True + _cyb___py_nvrtc_init = True return 0 - cdef inline int _check_or_init_nvrtc() except -1 nogil: - if __py_nvrtc_init: + if _cyb___py_nvrtc_init: return 0 return _init_nvrtc() -cdef dict func_ptrs = None - cpdef dict _inspect_function_pointers(): - global func_ptrs - if func_ptrs is not None: - return func_ptrs + global _cyb_func_ptrs + if _cyb_func_ptrs is not None: + return _cyb_func_ptrs _check_or_init_nvrtc() cdef dict data = {} - global __nvrtcGetErrorString - data["__nvrtcGetErrorString"] = __nvrtcGetErrorString + data["__nvrtcGetErrorString"] = <_cyb_intptr_t>__nvrtcGetErrorString global __nvrtcVersion - data["__nvrtcVersion"] = __nvrtcVersion + data["__nvrtcVersion"] = <_cyb_intptr_t>__nvrtcVersion global __nvrtcGetNumSupportedArchs - data["__nvrtcGetNumSupportedArchs"] = __nvrtcGetNumSupportedArchs + data["__nvrtcGetNumSupportedArchs"] = <_cyb_intptr_t>__nvrtcGetNumSupportedArchs global __nvrtcGetSupportedArchs - data["__nvrtcGetSupportedArchs"] = __nvrtcGetSupportedArchs + data["__nvrtcGetSupportedArchs"] = <_cyb_intptr_t>__nvrtcGetSupportedArchs global __nvrtcCreateProgram - data["__nvrtcCreateProgram"] = __nvrtcCreateProgram + data["__nvrtcCreateProgram"] = <_cyb_intptr_t>__nvrtcCreateProgram global __nvrtcDestroyProgram - data["__nvrtcDestroyProgram"] = __nvrtcDestroyProgram + data["__nvrtcDestroyProgram"] = <_cyb_intptr_t>__nvrtcDestroyProgram global __nvrtcCompileProgram - data["__nvrtcCompileProgram"] = __nvrtcCompileProgram + data["__nvrtcCompileProgram"] = <_cyb_intptr_t>__nvrtcCompileProgram global __nvrtcGetPTXSize - data["__nvrtcGetPTXSize"] = __nvrtcGetPTXSize + data["__nvrtcGetPTXSize"] = <_cyb_intptr_t>__nvrtcGetPTXSize global __nvrtcGetPTX - data["__nvrtcGetPTX"] = __nvrtcGetPTX + data["__nvrtcGetPTX"] = <_cyb_intptr_t>__nvrtcGetPTX global __nvrtcGetCUBINSize - data["__nvrtcGetCUBINSize"] = __nvrtcGetCUBINSize + data["__nvrtcGetCUBINSize"] = <_cyb_intptr_t>__nvrtcGetCUBINSize global __nvrtcGetCUBIN - data["__nvrtcGetCUBIN"] = __nvrtcGetCUBIN + data["__nvrtcGetCUBIN"] = <_cyb_intptr_t>__nvrtcGetCUBIN global __nvrtcGetLTOIRSize - data["__nvrtcGetLTOIRSize"] = __nvrtcGetLTOIRSize + data["__nvrtcGetLTOIRSize"] = <_cyb_intptr_t>__nvrtcGetLTOIRSize global __nvrtcGetLTOIR - data["__nvrtcGetLTOIR"] = __nvrtcGetLTOIR + data["__nvrtcGetLTOIR"] = <_cyb_intptr_t>__nvrtcGetLTOIR global __nvrtcGetOptiXIRSize - data["__nvrtcGetOptiXIRSize"] = __nvrtcGetOptiXIRSize + data["__nvrtcGetOptiXIRSize"] = <_cyb_intptr_t>__nvrtcGetOptiXIRSize global __nvrtcGetOptiXIR - data["__nvrtcGetOptiXIR"] = __nvrtcGetOptiXIR + data["__nvrtcGetOptiXIR"] = <_cyb_intptr_t>__nvrtcGetOptiXIR global __nvrtcGetProgramLogSize - data["__nvrtcGetProgramLogSize"] = __nvrtcGetProgramLogSize + data["__nvrtcGetProgramLogSize"] = <_cyb_intptr_t>__nvrtcGetProgramLogSize global __nvrtcGetProgramLog - data["__nvrtcGetProgramLog"] = __nvrtcGetProgramLog + data["__nvrtcGetProgramLog"] = <_cyb_intptr_t>__nvrtcGetProgramLog global __nvrtcAddNameExpression - data["__nvrtcAddNameExpression"] = __nvrtcAddNameExpression + data["__nvrtcAddNameExpression"] = <_cyb_intptr_t>__nvrtcAddNameExpression global __nvrtcGetLoweredName - data["__nvrtcGetLoweredName"] = __nvrtcGetLoweredName + data["__nvrtcGetLoweredName"] = <_cyb_intptr_t>__nvrtcGetLoweredName global __nvrtcGetPCHHeapSize - data["__nvrtcGetPCHHeapSize"] = __nvrtcGetPCHHeapSize + data["__nvrtcGetPCHHeapSize"] = <_cyb_intptr_t>__nvrtcGetPCHHeapSize global __nvrtcSetPCHHeapSize - data["__nvrtcSetPCHHeapSize"] = __nvrtcSetPCHHeapSize + data["__nvrtcSetPCHHeapSize"] = <_cyb_intptr_t>__nvrtcSetPCHHeapSize global __nvrtcGetPCHCreateStatus - data["__nvrtcGetPCHCreateStatus"] = __nvrtcGetPCHCreateStatus + data["__nvrtcGetPCHCreateStatus"] = <_cyb_intptr_t>__nvrtcGetPCHCreateStatus global __nvrtcGetPCHHeapSizeRequired - data["__nvrtcGetPCHHeapSizeRequired"] = __nvrtcGetPCHHeapSizeRequired + data["__nvrtcGetPCHHeapSizeRequired"] = <_cyb_intptr_t>__nvrtcGetPCHHeapSizeRequired global __nvrtcSetFlowCallback - data["__nvrtcSetFlowCallback"] = __nvrtcSetFlowCallback + data["__nvrtcSetFlowCallback"] = <_cyb_intptr_t>__nvrtcSetFlowCallback global __nvrtcGetTileIRSize - data["__nvrtcGetTileIRSize"] = __nvrtcGetTileIRSize + data["__nvrtcGetTileIRSize"] = <_cyb_intptr_t>__nvrtcGetTileIRSize global __nvrtcGetTileIR - data["__nvrtcGetTileIR"] = __nvrtcGetTileIR + data["__nvrtcGetTileIR"] = <_cyb_intptr_t>__nvrtcGetTileIR global __nvrtcInstallBundledHeaders - data["__nvrtcInstallBundledHeaders"] = __nvrtcInstallBundledHeaders + data["__nvrtcInstallBundledHeaders"] = <_cyb_intptr_t>__nvrtcInstallBundledHeaders global __nvrtcGetBundledHeadersInfo - data["__nvrtcGetBundledHeadersInfo"] = __nvrtcGetBundledHeadersInfo + data["__nvrtcGetBundledHeadersInfo"] = <_cyb_intptr_t>__nvrtcGetBundledHeadersInfo global __nvrtcRemoveBundledHeaders - data["__nvrtcRemoveBundledHeaders"] = __nvrtcRemoveBundledHeaders - - func_ptrs = data + data["__nvrtcRemoveBundledHeaders"] = <_cyb_intptr_t>__nvrtcRemoveBundledHeaders + _cyb_func_ptrs = data return data cpdef _inspect_function_pointer(str name): - global func_ptrs - if func_ptrs is None: - func_ptrs = _inspect_function_pointers() - return func_ptrs[name] + global _cyb_func_ptrs + if _cyb_func_ptrs is None: + _cyb_func_ptrs = _inspect_function_pointers() + return _cyb_func_ptrs[name] + + + + +cdef void* load_library() except* with gil: + cdef uintptr_t handle = load_nvidia_dynamic_lib("nvrtc")._handle_uint + return handle ############################################################################### diff --git a/cuda_bindings/cuda/bindings/_internal/nvrtc_windows.pyx b/cuda_bindings/cuda/bindings/_internal/nvrtc_windows.pyx index 2aef3b145d4..bb295d8faec 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvrtc_windows.pyx +++ b/cuda_bindings/cuda/bindings/_internal/nvrtc_windows.pyx @@ -3,81 +3,32 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.9.0 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=fb8577d2b93fb2a36b8f02f62b920524ff9c191b2f4d8203ee3105820bc6f28c -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=7e496ceaaaf75ed29455bb670e3b3af9ab7d4ba1ea155a129088c04aab9b3c16 -from libc.stdint cimport intptr_t -import threading -from .utils import FunctionNotFoundError, NotSupportedError - -from cuda.pathfinder import load_nvidia_dynamic_lib +# <<<< PREAMBLE CONTENT >>>> -from libc.stddef cimport wchar_t -from libc.stdint cimport uintptr_t -from cpython cimport PyUnicode_AsWideCharString, PyMem_Free +cdef extern from "": + ctypedef void* HMODULE + void* _cyb_GetProcAddress "GetProcAddress"(HMODULE, const char*) nogil -# You must 'from .utils import NotSupportedError' before using this template +from libc.stdint cimport intptr_t as _cyb_intptr_t -cdef extern from "windows.h" nogil: - ctypedef void* HMODULE - ctypedef void* HANDLE - ctypedef void* FARPROC - ctypedef unsigned long DWORD - ctypedef const wchar_t *LPCWSTR - ctypedef const char *LPCSTR - - cdef DWORD LOAD_LIBRARY_SEARCH_SYSTEM32 = 0x00000800 - cdef DWORD LOAD_LIBRARY_SEARCH_DEFAULT_DIRS = 0x00001000 - cdef DWORD LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR = 0x00000100 - - HMODULE _LoadLibraryExW "LoadLibraryExW"( - LPCWSTR lpLibFileName, - HANDLE hFile, - DWORD dwFlags - ) - - FARPROC _GetProcAddress "GetProcAddress"(HMODULE hModule, LPCSTR lpProcName) - -cdef inline uintptr_t LoadLibraryExW(str path, HANDLE hFile, DWORD dwFlags): - cdef uintptr_t result - cdef wchar_t* wpath = PyUnicode_AsWideCharString(path, NULL) - with nogil: - result = _LoadLibraryExW( - wpath, - hFile, - dwFlags - ) - PyMem_Free(wpath) - return result - -cdef inline void *GetProcAddress(uintptr_t hModule, const char* lpProcName) nogil: - return _GetProcAddress(hModule, lpProcName) - -cdef int get_cuda_version(): - cdef int err, driver_ver = 0 - - # Load driver to check version - handle = LoadLibraryExW("nvcuda.dll", NULL, LOAD_LIBRARY_SEARCH_SYSTEM32) - if handle == 0: - raise NotSupportedError('CUDA driver is not found') - cuDriverGetVersion = GetProcAddress(handle, 'cuDriverGetVersion') - if cuDriverGetVersion == NULL: - raise RuntimeError('Did not find cuDriverGetVersion symbol in nvcuda.dll') - err = (cuDriverGetVersion)(&driver_ver) - if err != 0: - raise RuntimeError(f'cuDriverGetVersion returned error code {err}') - - return driver_ver +import threading as _cyb_threading +cdef bint _cyb___py_nvrtc_init = False +cdef dict _cyb_func_ptrs = None +cdef object _cyb_symbol_lock = _cyb_threading.Lock() +# <<<< END OF PREAMBLE CONTENT >>>> +from libc.stdint cimport uintptr_t +from cuda.pathfinder import load_nvidia_dynamic_lib +from .utils import FunctionNotFoundError, NotSupportedError ############################################################################### # Wrapper init ############################################################################### -cdef object __symbol_lock = threading.Lock() -cdef bint __py_nvrtc_init = False - cdef void* __nvrtcGetErrorString = NULL cdef void* __nvrtcVersion = NULL cdef void* __nvrtcGetNumSupportedArchs = NULL @@ -108,223 +59,220 @@ cdef void* __nvrtcInstallBundledHeaders = NULL cdef void* __nvrtcGetBundledHeadersInfo = NULL cdef void* __nvrtcRemoveBundledHeaders = NULL - cdef int _init_nvrtc() except -1 nogil: - global __py_nvrtc_init - - with gil, __symbol_lock: - # Recheck the flag after obtaining the locks - if __py_nvrtc_init: - return 0 + global _cyb___py_nvrtc_init - # Load library - handle = load_nvidia_dynamic_lib("nvrtc")._handle_uint + cdef int err + cdef uintptr_t handle + with gil, _cyb_symbol_lock: + if _cyb___py_nvrtc_init: return 0 - # Load function + handle = load_library() global __nvrtcGetErrorString - __nvrtcGetErrorString = GetProcAddress(handle, 'nvrtcGetErrorString') + __nvrtcGetErrorString = _cyb_GetProcAddress(handle, 'nvrtcGetErrorString') global __nvrtcVersion - __nvrtcVersion = GetProcAddress(handle, 'nvrtcVersion') + __nvrtcVersion = _cyb_GetProcAddress(handle, 'nvrtcVersion') global __nvrtcGetNumSupportedArchs - __nvrtcGetNumSupportedArchs = GetProcAddress(handle, 'nvrtcGetNumSupportedArchs') + __nvrtcGetNumSupportedArchs = _cyb_GetProcAddress(handle, 'nvrtcGetNumSupportedArchs') global __nvrtcGetSupportedArchs - __nvrtcGetSupportedArchs = GetProcAddress(handle, 'nvrtcGetSupportedArchs') + __nvrtcGetSupportedArchs = _cyb_GetProcAddress(handle, 'nvrtcGetSupportedArchs') global __nvrtcCreateProgram - __nvrtcCreateProgram = GetProcAddress(handle, 'nvrtcCreateProgram') + __nvrtcCreateProgram = _cyb_GetProcAddress(handle, 'nvrtcCreateProgram') global __nvrtcDestroyProgram - __nvrtcDestroyProgram = GetProcAddress(handle, 'nvrtcDestroyProgram') + __nvrtcDestroyProgram = _cyb_GetProcAddress(handle, 'nvrtcDestroyProgram') global __nvrtcCompileProgram - __nvrtcCompileProgram = GetProcAddress(handle, 'nvrtcCompileProgram') + __nvrtcCompileProgram = _cyb_GetProcAddress(handle, 'nvrtcCompileProgram') global __nvrtcGetPTXSize - __nvrtcGetPTXSize = GetProcAddress(handle, 'nvrtcGetPTXSize') + __nvrtcGetPTXSize = _cyb_GetProcAddress(handle, 'nvrtcGetPTXSize') global __nvrtcGetPTX - __nvrtcGetPTX = GetProcAddress(handle, 'nvrtcGetPTX') + __nvrtcGetPTX = _cyb_GetProcAddress(handle, 'nvrtcGetPTX') global __nvrtcGetCUBINSize - __nvrtcGetCUBINSize = GetProcAddress(handle, 'nvrtcGetCUBINSize') + __nvrtcGetCUBINSize = _cyb_GetProcAddress(handle, 'nvrtcGetCUBINSize') global __nvrtcGetCUBIN - __nvrtcGetCUBIN = GetProcAddress(handle, 'nvrtcGetCUBIN') + __nvrtcGetCUBIN = _cyb_GetProcAddress(handle, 'nvrtcGetCUBIN') global __nvrtcGetLTOIRSize - __nvrtcGetLTOIRSize = GetProcAddress(handle, 'nvrtcGetLTOIRSize') + __nvrtcGetLTOIRSize = _cyb_GetProcAddress(handle, 'nvrtcGetLTOIRSize') global __nvrtcGetLTOIR - __nvrtcGetLTOIR = GetProcAddress(handle, 'nvrtcGetLTOIR') + __nvrtcGetLTOIR = _cyb_GetProcAddress(handle, 'nvrtcGetLTOIR') global __nvrtcGetOptiXIRSize - __nvrtcGetOptiXIRSize = GetProcAddress(handle, 'nvrtcGetOptiXIRSize') + __nvrtcGetOptiXIRSize = _cyb_GetProcAddress(handle, 'nvrtcGetOptiXIRSize') global __nvrtcGetOptiXIR - __nvrtcGetOptiXIR = GetProcAddress(handle, 'nvrtcGetOptiXIR') + __nvrtcGetOptiXIR = _cyb_GetProcAddress(handle, 'nvrtcGetOptiXIR') global __nvrtcGetProgramLogSize - __nvrtcGetProgramLogSize = GetProcAddress(handle, 'nvrtcGetProgramLogSize') + __nvrtcGetProgramLogSize = _cyb_GetProcAddress(handle, 'nvrtcGetProgramLogSize') global __nvrtcGetProgramLog - __nvrtcGetProgramLog = GetProcAddress(handle, 'nvrtcGetProgramLog') + __nvrtcGetProgramLog = _cyb_GetProcAddress(handle, 'nvrtcGetProgramLog') global __nvrtcAddNameExpression - __nvrtcAddNameExpression = GetProcAddress(handle, 'nvrtcAddNameExpression') + __nvrtcAddNameExpression = _cyb_GetProcAddress(handle, 'nvrtcAddNameExpression') global __nvrtcGetLoweredName - __nvrtcGetLoweredName = GetProcAddress(handle, 'nvrtcGetLoweredName') + __nvrtcGetLoweredName = _cyb_GetProcAddress(handle, 'nvrtcGetLoweredName') global __nvrtcGetPCHHeapSize - __nvrtcGetPCHHeapSize = GetProcAddress(handle, 'nvrtcGetPCHHeapSize') + __nvrtcGetPCHHeapSize = _cyb_GetProcAddress(handle, 'nvrtcGetPCHHeapSize') global __nvrtcSetPCHHeapSize - __nvrtcSetPCHHeapSize = GetProcAddress(handle, 'nvrtcSetPCHHeapSize') + __nvrtcSetPCHHeapSize = _cyb_GetProcAddress(handle, 'nvrtcSetPCHHeapSize') global __nvrtcGetPCHCreateStatus - __nvrtcGetPCHCreateStatus = GetProcAddress(handle, 'nvrtcGetPCHCreateStatus') + __nvrtcGetPCHCreateStatus = _cyb_GetProcAddress(handle, 'nvrtcGetPCHCreateStatus') global __nvrtcGetPCHHeapSizeRequired - __nvrtcGetPCHHeapSizeRequired = GetProcAddress(handle, 'nvrtcGetPCHHeapSizeRequired') + __nvrtcGetPCHHeapSizeRequired = _cyb_GetProcAddress(handle, 'nvrtcGetPCHHeapSizeRequired') global __nvrtcSetFlowCallback - __nvrtcSetFlowCallback = GetProcAddress(handle, 'nvrtcSetFlowCallback') + __nvrtcSetFlowCallback = _cyb_GetProcAddress(handle, 'nvrtcSetFlowCallback') global __nvrtcGetTileIRSize - __nvrtcGetTileIRSize = GetProcAddress(handle, 'nvrtcGetTileIRSize') + __nvrtcGetTileIRSize = _cyb_GetProcAddress(handle, 'nvrtcGetTileIRSize') global __nvrtcGetTileIR - __nvrtcGetTileIR = GetProcAddress(handle, 'nvrtcGetTileIR') + __nvrtcGetTileIR = _cyb_GetProcAddress(handle, 'nvrtcGetTileIR') global __nvrtcInstallBundledHeaders - __nvrtcInstallBundledHeaders = GetProcAddress(handle, 'nvrtcInstallBundledHeaders') + __nvrtcInstallBundledHeaders = _cyb_GetProcAddress(handle, 'nvrtcInstallBundledHeaders') global __nvrtcGetBundledHeadersInfo - __nvrtcGetBundledHeadersInfo = GetProcAddress(handle, 'nvrtcGetBundledHeadersInfo') + __nvrtcGetBundledHeadersInfo = _cyb_GetProcAddress(handle, 'nvrtcGetBundledHeadersInfo') global __nvrtcRemoveBundledHeaders - __nvrtcRemoveBundledHeaders = GetProcAddress(handle, 'nvrtcRemoveBundledHeaders') + __nvrtcRemoveBundledHeaders = _cyb_GetProcAddress(handle, 'nvrtcRemoveBundledHeaders') - __py_nvrtc_init = True + _cyb___py_nvrtc_init = True return 0 - cdef inline int _check_or_init_nvrtc() except -1 nogil: - if __py_nvrtc_init: + if _cyb___py_nvrtc_init: return 0 return _init_nvrtc() -cdef dict func_ptrs = None - cpdef dict _inspect_function_pointers(): - global func_ptrs - if func_ptrs is not None: - return func_ptrs + global _cyb_func_ptrs + if _cyb_func_ptrs is not None: + return _cyb_func_ptrs _check_or_init_nvrtc() cdef dict data = {} - global __nvrtcGetErrorString - data["__nvrtcGetErrorString"] = __nvrtcGetErrorString + data["__nvrtcGetErrorString"] = <_cyb_intptr_t>__nvrtcGetErrorString global __nvrtcVersion - data["__nvrtcVersion"] = __nvrtcVersion + data["__nvrtcVersion"] = <_cyb_intptr_t>__nvrtcVersion global __nvrtcGetNumSupportedArchs - data["__nvrtcGetNumSupportedArchs"] = __nvrtcGetNumSupportedArchs + data["__nvrtcGetNumSupportedArchs"] = <_cyb_intptr_t>__nvrtcGetNumSupportedArchs global __nvrtcGetSupportedArchs - data["__nvrtcGetSupportedArchs"] = __nvrtcGetSupportedArchs + data["__nvrtcGetSupportedArchs"] = <_cyb_intptr_t>__nvrtcGetSupportedArchs global __nvrtcCreateProgram - data["__nvrtcCreateProgram"] = __nvrtcCreateProgram + data["__nvrtcCreateProgram"] = <_cyb_intptr_t>__nvrtcCreateProgram global __nvrtcDestroyProgram - data["__nvrtcDestroyProgram"] = __nvrtcDestroyProgram + data["__nvrtcDestroyProgram"] = <_cyb_intptr_t>__nvrtcDestroyProgram global __nvrtcCompileProgram - data["__nvrtcCompileProgram"] = __nvrtcCompileProgram + data["__nvrtcCompileProgram"] = <_cyb_intptr_t>__nvrtcCompileProgram global __nvrtcGetPTXSize - data["__nvrtcGetPTXSize"] = __nvrtcGetPTXSize + data["__nvrtcGetPTXSize"] = <_cyb_intptr_t>__nvrtcGetPTXSize global __nvrtcGetPTX - data["__nvrtcGetPTX"] = __nvrtcGetPTX + data["__nvrtcGetPTX"] = <_cyb_intptr_t>__nvrtcGetPTX global __nvrtcGetCUBINSize - data["__nvrtcGetCUBINSize"] = __nvrtcGetCUBINSize + data["__nvrtcGetCUBINSize"] = <_cyb_intptr_t>__nvrtcGetCUBINSize global __nvrtcGetCUBIN - data["__nvrtcGetCUBIN"] = __nvrtcGetCUBIN + data["__nvrtcGetCUBIN"] = <_cyb_intptr_t>__nvrtcGetCUBIN global __nvrtcGetLTOIRSize - data["__nvrtcGetLTOIRSize"] = __nvrtcGetLTOIRSize + data["__nvrtcGetLTOIRSize"] = <_cyb_intptr_t>__nvrtcGetLTOIRSize global __nvrtcGetLTOIR - data["__nvrtcGetLTOIR"] = __nvrtcGetLTOIR + data["__nvrtcGetLTOIR"] = <_cyb_intptr_t>__nvrtcGetLTOIR global __nvrtcGetOptiXIRSize - data["__nvrtcGetOptiXIRSize"] = __nvrtcGetOptiXIRSize + data["__nvrtcGetOptiXIRSize"] = <_cyb_intptr_t>__nvrtcGetOptiXIRSize global __nvrtcGetOptiXIR - data["__nvrtcGetOptiXIR"] = __nvrtcGetOptiXIR + data["__nvrtcGetOptiXIR"] = <_cyb_intptr_t>__nvrtcGetOptiXIR global __nvrtcGetProgramLogSize - data["__nvrtcGetProgramLogSize"] = __nvrtcGetProgramLogSize + data["__nvrtcGetProgramLogSize"] = <_cyb_intptr_t>__nvrtcGetProgramLogSize global __nvrtcGetProgramLog - data["__nvrtcGetProgramLog"] = __nvrtcGetProgramLog + data["__nvrtcGetProgramLog"] = <_cyb_intptr_t>__nvrtcGetProgramLog global __nvrtcAddNameExpression - data["__nvrtcAddNameExpression"] = __nvrtcAddNameExpression + data["__nvrtcAddNameExpression"] = <_cyb_intptr_t>__nvrtcAddNameExpression global __nvrtcGetLoweredName - data["__nvrtcGetLoweredName"] = __nvrtcGetLoweredName + data["__nvrtcGetLoweredName"] = <_cyb_intptr_t>__nvrtcGetLoweredName global __nvrtcGetPCHHeapSize - data["__nvrtcGetPCHHeapSize"] = __nvrtcGetPCHHeapSize + data["__nvrtcGetPCHHeapSize"] = <_cyb_intptr_t>__nvrtcGetPCHHeapSize global __nvrtcSetPCHHeapSize - data["__nvrtcSetPCHHeapSize"] = __nvrtcSetPCHHeapSize + data["__nvrtcSetPCHHeapSize"] = <_cyb_intptr_t>__nvrtcSetPCHHeapSize global __nvrtcGetPCHCreateStatus - data["__nvrtcGetPCHCreateStatus"] = __nvrtcGetPCHCreateStatus + data["__nvrtcGetPCHCreateStatus"] = <_cyb_intptr_t>__nvrtcGetPCHCreateStatus global __nvrtcGetPCHHeapSizeRequired - data["__nvrtcGetPCHHeapSizeRequired"] = __nvrtcGetPCHHeapSizeRequired + data["__nvrtcGetPCHHeapSizeRequired"] = <_cyb_intptr_t>__nvrtcGetPCHHeapSizeRequired global __nvrtcSetFlowCallback - data["__nvrtcSetFlowCallback"] = __nvrtcSetFlowCallback + data["__nvrtcSetFlowCallback"] = <_cyb_intptr_t>__nvrtcSetFlowCallback global __nvrtcGetTileIRSize - data["__nvrtcGetTileIRSize"] = __nvrtcGetTileIRSize + data["__nvrtcGetTileIRSize"] = <_cyb_intptr_t>__nvrtcGetTileIRSize global __nvrtcGetTileIR - data["__nvrtcGetTileIR"] = __nvrtcGetTileIR + data["__nvrtcGetTileIR"] = <_cyb_intptr_t>__nvrtcGetTileIR global __nvrtcInstallBundledHeaders - data["__nvrtcInstallBundledHeaders"] = __nvrtcInstallBundledHeaders + data["__nvrtcInstallBundledHeaders"] = <_cyb_intptr_t>__nvrtcInstallBundledHeaders global __nvrtcGetBundledHeadersInfo - data["__nvrtcGetBundledHeadersInfo"] = __nvrtcGetBundledHeadersInfo + data["__nvrtcGetBundledHeadersInfo"] = <_cyb_intptr_t>__nvrtcGetBundledHeadersInfo global __nvrtcRemoveBundledHeaders - data["__nvrtcRemoveBundledHeaders"] = __nvrtcRemoveBundledHeaders - - func_ptrs = data + data["__nvrtcRemoveBundledHeaders"] = <_cyb_intptr_t>__nvrtcRemoveBundledHeaders + _cyb_func_ptrs = data return data cpdef _inspect_function_pointer(str name): - global func_ptrs - if func_ptrs is None: - func_ptrs = _inspect_function_pointers() - return func_ptrs[name] + global _cyb_func_ptrs + if _cyb_func_ptrs is None: + _cyb_func_ptrs = _inspect_function_pointers() + return _cyb_func_ptrs[name] + + + + +cdef uintptr_t load_library() except* with gil: + return load_nvidia_dynamic_lib("nvrtc")._handle_uint ############################################################################### diff --git a/cuda_bindings/cuda/bindings/_internal/nvvm_linux.pyx b/cuda_bindings/cuda/bindings/_internal/nvvm_linux.pyx index d4cd73399a4..0aba7664f8b 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvvm_linux.pyx +++ b/cuda_bindings/cuda/bindings/_internal/nvvm_linux.pyx @@ -3,63 +3,35 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.0.1 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=786a789c534d0bdda803be738a4f76f2db47bf188708dac946b41aec6c6aa4a4 -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=3c31adc68b8220439ea196a56ea63cf670aff0f85c0a67c8f554e1af4d07f456 -from libc.stdint cimport intptr_t, uintptr_t -import threading -from .utils import FunctionNotFoundError, NotSupportedError - -from cuda.pathfinder import load_nvidia_dynamic_lib - - -############################################################################### -# Extern -############################################################################### - -# You must 'from .utils import NotSupportedError' before using this template +# <<<< PREAMBLE CONTENT >>>> -cdef extern from "" nogil: - void* dlopen(const char*, int) - char* dlerror() - void* dlsym(void*, const char*) - int dlclose(void*) +cdef extern from "": + void* _cyb_dlsym "dlsym"(void*, const char*) nogil + const void * _cyb_RTLD_DEFAULT "RTLD_DEFAULT" - enum: - RTLD_LAZY - RTLD_NOW - RTLD_GLOBAL - RTLD_LOCAL +from libc.stdint cimport intptr_t as _cyb_intptr_t - const void* RTLD_DEFAULT 'RTLD_DEFAULT' +import threading as _cyb_threading -cdef int get_cuda_version(): - cdef void* handle = NULL - cdef int err, driver_ver = 0 +cdef bint _cyb___py_nvvm_init = False +cdef dict _cyb_func_ptrs = None +cdef object _cyb_symbol_lock = _cyb_threading.Lock() - # Load driver to check version - handle = dlopen('libcuda.so.1', RTLD_NOW | RTLD_GLOBAL) - if handle == NULL: - err_msg = dlerror() - raise NotSupportedError(f'CUDA driver is not found ({err_msg.decode()})') - cuDriverGetVersion = dlsym(handle, "cuDriverGetVersion") - if cuDriverGetVersion == NULL: - raise RuntimeError('Did not find cuDriverGetVersion symbol in libcuda.so.1') - err = (cuDriverGetVersion)(&driver_ver) - if err != 0: - raise RuntimeError(f'cuDriverGetVersion returned error code {err}') +# <<<< END OF PREAMBLE CONTENT >>>> - return driver_ver +from libc.stdint cimport uintptr_t +from .utils import FunctionNotFoundError, NotSupportedError +from cuda.pathfinder import load_nvidia_dynamic_lib ############################################################################### # Wrapper init ############################################################################### -cdef object __symbol_lock = threading.Lock() -cdef bint __py_nvvm_init = False - cdef void* __nvvmGetErrorString = NULL cdef void* __nvvmVersion = NULL cdef void* __nvvmIRVersion = NULL @@ -75,194 +47,184 @@ cdef void* __nvvmGetProgramLogSize = NULL cdef void* __nvvmGetProgramLog = NULL cdef void* __nvvmLLVMVersion = NULL - -cdef void* load_library() except* with gil: - cdef uintptr_t handle = load_nvidia_dynamic_lib("nvvm")._handle_uint - return handle - - cdef int _init_nvvm() except -1 nogil: - global __py_nvvm_init - + global _cyb___py_nvvm_init cdef void* handle = NULL + with gil, _cyb_symbol_lock: + if _cyb___py_nvvm_init: return 0 - with gil, __symbol_lock: - # Recheck the flag after obtaining the locks - if __py_nvvm_init: - return 0 - - # Load function global __nvvmGetErrorString - __nvvmGetErrorString = dlsym(RTLD_DEFAULT, 'nvvmGetErrorString') + __nvvmGetErrorString = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvvmGetErrorString') if __nvvmGetErrorString == NULL: if handle == NULL: handle = load_library() - __nvvmGetErrorString = dlsym(handle, 'nvvmGetErrorString') + __nvvmGetErrorString = _cyb_dlsym(handle, 'nvvmGetErrorString') global __nvvmVersion - __nvvmVersion = dlsym(RTLD_DEFAULT, 'nvvmVersion') + __nvvmVersion = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvvmVersion') if __nvvmVersion == NULL: if handle == NULL: handle = load_library() - __nvvmVersion = dlsym(handle, 'nvvmVersion') + __nvvmVersion = _cyb_dlsym(handle, 'nvvmVersion') global __nvvmIRVersion - __nvvmIRVersion = dlsym(RTLD_DEFAULT, 'nvvmIRVersion') + __nvvmIRVersion = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvvmIRVersion') if __nvvmIRVersion == NULL: if handle == NULL: handle = load_library() - __nvvmIRVersion = dlsym(handle, 'nvvmIRVersion') + __nvvmIRVersion = _cyb_dlsym(handle, 'nvvmIRVersion') global __nvvmCreateProgram - __nvvmCreateProgram = dlsym(RTLD_DEFAULT, 'nvvmCreateProgram') + __nvvmCreateProgram = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvvmCreateProgram') if __nvvmCreateProgram == NULL: if handle == NULL: handle = load_library() - __nvvmCreateProgram = dlsym(handle, 'nvvmCreateProgram') + __nvvmCreateProgram = _cyb_dlsym(handle, 'nvvmCreateProgram') global __nvvmDestroyProgram - __nvvmDestroyProgram = dlsym(RTLD_DEFAULT, 'nvvmDestroyProgram') + __nvvmDestroyProgram = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvvmDestroyProgram') if __nvvmDestroyProgram == NULL: if handle == NULL: handle = load_library() - __nvvmDestroyProgram = dlsym(handle, 'nvvmDestroyProgram') + __nvvmDestroyProgram = _cyb_dlsym(handle, 'nvvmDestroyProgram') global __nvvmAddModuleToProgram - __nvvmAddModuleToProgram = dlsym(RTLD_DEFAULT, 'nvvmAddModuleToProgram') + __nvvmAddModuleToProgram = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvvmAddModuleToProgram') if __nvvmAddModuleToProgram == NULL: if handle == NULL: handle = load_library() - __nvvmAddModuleToProgram = dlsym(handle, 'nvvmAddModuleToProgram') + __nvvmAddModuleToProgram = _cyb_dlsym(handle, 'nvvmAddModuleToProgram') global __nvvmLazyAddModuleToProgram - __nvvmLazyAddModuleToProgram = dlsym(RTLD_DEFAULT, 'nvvmLazyAddModuleToProgram') + __nvvmLazyAddModuleToProgram = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvvmLazyAddModuleToProgram') if __nvvmLazyAddModuleToProgram == NULL: if handle == NULL: handle = load_library() - __nvvmLazyAddModuleToProgram = dlsym(handle, 'nvvmLazyAddModuleToProgram') + __nvvmLazyAddModuleToProgram = _cyb_dlsym(handle, 'nvvmLazyAddModuleToProgram') global __nvvmCompileProgram - __nvvmCompileProgram = dlsym(RTLD_DEFAULT, 'nvvmCompileProgram') + __nvvmCompileProgram = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvvmCompileProgram') if __nvvmCompileProgram == NULL: if handle == NULL: handle = load_library() - __nvvmCompileProgram = dlsym(handle, 'nvvmCompileProgram') + __nvvmCompileProgram = _cyb_dlsym(handle, 'nvvmCompileProgram') global __nvvmVerifyProgram - __nvvmVerifyProgram = dlsym(RTLD_DEFAULT, 'nvvmVerifyProgram') + __nvvmVerifyProgram = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvvmVerifyProgram') if __nvvmVerifyProgram == NULL: if handle == NULL: handle = load_library() - __nvvmVerifyProgram = dlsym(handle, 'nvvmVerifyProgram') + __nvvmVerifyProgram = _cyb_dlsym(handle, 'nvvmVerifyProgram') global __nvvmGetCompiledResultSize - __nvvmGetCompiledResultSize = dlsym(RTLD_DEFAULT, 'nvvmGetCompiledResultSize') + __nvvmGetCompiledResultSize = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvvmGetCompiledResultSize') if __nvvmGetCompiledResultSize == NULL: if handle == NULL: handle = load_library() - __nvvmGetCompiledResultSize = dlsym(handle, 'nvvmGetCompiledResultSize') + __nvvmGetCompiledResultSize = _cyb_dlsym(handle, 'nvvmGetCompiledResultSize') global __nvvmGetCompiledResult - __nvvmGetCompiledResult = dlsym(RTLD_DEFAULT, 'nvvmGetCompiledResult') + __nvvmGetCompiledResult = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvvmGetCompiledResult') if __nvvmGetCompiledResult == NULL: if handle == NULL: handle = load_library() - __nvvmGetCompiledResult = dlsym(handle, 'nvvmGetCompiledResult') + __nvvmGetCompiledResult = _cyb_dlsym(handle, 'nvvmGetCompiledResult') global __nvvmGetProgramLogSize - __nvvmGetProgramLogSize = dlsym(RTLD_DEFAULT, 'nvvmGetProgramLogSize') + __nvvmGetProgramLogSize = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvvmGetProgramLogSize') if __nvvmGetProgramLogSize == NULL: if handle == NULL: handle = load_library() - __nvvmGetProgramLogSize = dlsym(handle, 'nvvmGetProgramLogSize') + __nvvmGetProgramLogSize = _cyb_dlsym(handle, 'nvvmGetProgramLogSize') global __nvvmGetProgramLog - __nvvmGetProgramLog = dlsym(RTLD_DEFAULT, 'nvvmGetProgramLog') + __nvvmGetProgramLog = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvvmGetProgramLog') if __nvvmGetProgramLog == NULL: if handle == NULL: handle = load_library() - __nvvmGetProgramLog = dlsym(handle, 'nvvmGetProgramLog') + __nvvmGetProgramLog = _cyb_dlsym(handle, 'nvvmGetProgramLog') global __nvvmLLVMVersion - __nvvmLLVMVersion = dlsym(RTLD_DEFAULT, 'nvvmLLVMVersion') + __nvvmLLVMVersion = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvvmLLVMVersion') if __nvvmLLVMVersion == NULL: if handle == NULL: handle = load_library() - __nvvmLLVMVersion = dlsym(handle, 'nvvmLLVMVersion') + __nvvmLLVMVersion = _cyb_dlsym(handle, 'nvvmLLVMVersion') - __py_nvvm_init = True + _cyb___py_nvvm_init = True return 0 - cdef inline int _check_or_init_nvvm() except -1 nogil: - if __py_nvvm_init: + if _cyb___py_nvvm_init: return 0 return _init_nvvm() -cdef dict func_ptrs = None - - cpdef dict _inspect_function_pointers(): - global func_ptrs - if func_ptrs is not None: - return func_ptrs + global _cyb_func_ptrs + if _cyb_func_ptrs is not None: + return _cyb_func_ptrs _check_or_init_nvvm() cdef dict data = {} - global __nvvmGetErrorString - data["__nvvmGetErrorString"] = __nvvmGetErrorString + data["__nvvmGetErrorString"] = <_cyb_intptr_t>__nvvmGetErrorString global __nvvmVersion - data["__nvvmVersion"] = __nvvmVersion + data["__nvvmVersion"] = <_cyb_intptr_t>__nvvmVersion global __nvvmIRVersion - data["__nvvmIRVersion"] = __nvvmIRVersion + data["__nvvmIRVersion"] = <_cyb_intptr_t>__nvvmIRVersion global __nvvmCreateProgram - data["__nvvmCreateProgram"] = __nvvmCreateProgram + data["__nvvmCreateProgram"] = <_cyb_intptr_t>__nvvmCreateProgram global __nvvmDestroyProgram - data["__nvvmDestroyProgram"] = __nvvmDestroyProgram + data["__nvvmDestroyProgram"] = <_cyb_intptr_t>__nvvmDestroyProgram global __nvvmAddModuleToProgram - data["__nvvmAddModuleToProgram"] = __nvvmAddModuleToProgram + data["__nvvmAddModuleToProgram"] = <_cyb_intptr_t>__nvvmAddModuleToProgram global __nvvmLazyAddModuleToProgram - data["__nvvmLazyAddModuleToProgram"] = __nvvmLazyAddModuleToProgram + data["__nvvmLazyAddModuleToProgram"] = <_cyb_intptr_t>__nvvmLazyAddModuleToProgram global __nvvmCompileProgram - data["__nvvmCompileProgram"] = __nvvmCompileProgram + data["__nvvmCompileProgram"] = <_cyb_intptr_t>__nvvmCompileProgram global __nvvmVerifyProgram - data["__nvvmVerifyProgram"] = __nvvmVerifyProgram + data["__nvvmVerifyProgram"] = <_cyb_intptr_t>__nvvmVerifyProgram global __nvvmGetCompiledResultSize - data["__nvvmGetCompiledResultSize"] = __nvvmGetCompiledResultSize + data["__nvvmGetCompiledResultSize"] = <_cyb_intptr_t>__nvvmGetCompiledResultSize global __nvvmGetCompiledResult - data["__nvvmGetCompiledResult"] = __nvvmGetCompiledResult + data["__nvvmGetCompiledResult"] = <_cyb_intptr_t>__nvvmGetCompiledResult global __nvvmGetProgramLogSize - data["__nvvmGetProgramLogSize"] = __nvvmGetProgramLogSize + data["__nvvmGetProgramLogSize"] = <_cyb_intptr_t>__nvvmGetProgramLogSize global __nvvmGetProgramLog - data["__nvvmGetProgramLog"] = __nvvmGetProgramLog + data["__nvvmGetProgramLog"] = <_cyb_intptr_t>__nvvmGetProgramLog global __nvvmLLVMVersion - data["__nvvmLLVMVersion"] = __nvvmLLVMVersion - - func_ptrs = data + data["__nvvmLLVMVersion"] = <_cyb_intptr_t>__nvvmLLVMVersion + _cyb_func_ptrs = data return data cpdef _inspect_function_pointer(str name): - global func_ptrs - if func_ptrs is None: - func_ptrs = _inspect_function_pointers() - return func_ptrs[name] + global _cyb_func_ptrs + if _cyb_func_ptrs is None: + _cyb_func_ptrs = _inspect_function_pointers() + return _cyb_func_ptrs[name] + + + + +cdef void* load_library() except* with gil: + cdef uintptr_t handle = load_nvidia_dynamic_lib("nvvm")._handle_uint + return handle ############################################################################### diff --git a/cuda_bindings/cuda/bindings/_internal/nvvm_windows.pyx b/cuda_bindings/cuda/bindings/_internal/nvvm_windows.pyx index 25b9d1cc674..72262266fac 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvvm_windows.pyx +++ b/cuda_bindings/cuda/bindings/_internal/nvvm_windows.pyx @@ -3,81 +3,32 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.0.1 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=cd105988425e21a30e32255acbc5654de835d0c09b5dd1c4598b09146fa590c5 -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=49ccc5908d39ebb526fee704591480550b5f780c05f14366531360e3ec2ac17a -from libc.stdint cimport intptr_t -import threading -from .utils import FunctionNotFoundError, NotSupportedError - -from cuda.pathfinder import load_nvidia_dynamic_lib +# <<<< PREAMBLE CONTENT >>>> -from libc.stddef cimport wchar_t -from libc.stdint cimport uintptr_t -from cpython cimport PyUnicode_AsWideCharString, PyMem_Free +cdef extern from "": + ctypedef void* HMODULE + void* _cyb_GetProcAddress "GetProcAddress"(HMODULE, const char*) nogil -# You must 'from .utils import NotSupportedError' before using this template +from libc.stdint cimport intptr_t as _cyb_intptr_t -cdef extern from "windows.h" nogil: - ctypedef void* HMODULE - ctypedef void* HANDLE - ctypedef void* FARPROC - ctypedef unsigned long DWORD - ctypedef const wchar_t *LPCWSTR - ctypedef const char *LPCSTR - - cdef DWORD LOAD_LIBRARY_SEARCH_SYSTEM32 = 0x00000800 - cdef DWORD LOAD_LIBRARY_SEARCH_DEFAULT_DIRS = 0x00001000 - cdef DWORD LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR = 0x00000100 - - HMODULE _LoadLibraryExW "LoadLibraryExW"( - LPCWSTR lpLibFileName, - HANDLE hFile, - DWORD dwFlags - ) - - FARPROC _GetProcAddress "GetProcAddress"(HMODULE hModule, LPCSTR lpProcName) - -cdef inline uintptr_t LoadLibraryExW(str path, HANDLE hFile, DWORD dwFlags): - cdef uintptr_t result - cdef wchar_t* wpath = PyUnicode_AsWideCharString(path, NULL) - with nogil: - result = _LoadLibraryExW( - wpath, - hFile, - dwFlags - ) - PyMem_Free(wpath) - return result - -cdef inline void *GetProcAddress(uintptr_t hModule, const char* lpProcName) nogil: - return _GetProcAddress(hModule, lpProcName) - -cdef int get_cuda_version(): - cdef int err, driver_ver = 0 - - # Load driver to check version - handle = LoadLibraryExW("nvcuda.dll", NULL, LOAD_LIBRARY_SEARCH_SYSTEM32) - if handle == 0: - raise NotSupportedError('CUDA driver is not found') - cuDriverGetVersion = GetProcAddress(handle, 'cuDriverGetVersion') - if cuDriverGetVersion == NULL: - raise RuntimeError('Did not find cuDriverGetVersion symbol in nvcuda.dll') - err = (cuDriverGetVersion)(&driver_ver) - if err != 0: - raise RuntimeError(f'cuDriverGetVersion returned error code {err}') - - return driver_ver +import threading as _cyb_threading +cdef bint _cyb___py_nvvm_init = False +cdef dict _cyb_func_ptrs = None +cdef object _cyb_symbol_lock = _cyb_threading.Lock() +# <<<< END OF PREAMBLE CONTENT >>>> +from libc.stdint cimport uintptr_t +from cuda.pathfinder import load_nvidia_dynamic_lib +from .utils import FunctionNotFoundError, NotSupportedError ############################################################################### # Wrapper init ############################################################################### -cdef object __symbol_lock = threading.Lock() -cdef bint __py_nvvm_init = False - cdef void* __nvvmGetErrorString = NULL cdef void* __nvvmVersion = NULL cdef void* __nvvmIRVersion = NULL @@ -93,134 +44,130 @@ cdef void* __nvvmGetProgramLogSize = NULL cdef void* __nvvmGetProgramLog = NULL cdef void* __nvvmLLVMVersion = NULL - cdef int _init_nvvm() except -1 nogil: - global __py_nvvm_init + global _cyb___py_nvvm_init - with gil, __symbol_lock: - # Recheck the flag after obtaining the locks - if __py_nvvm_init: - return 0 + cdef int err + cdef uintptr_t handle + with gil, _cyb_symbol_lock: + if _cyb___py_nvvm_init: return 0 - # Load library - handle = load_nvidia_dynamic_lib("nvvm")._handle_uint - - # Load function + handle = load_library() global __nvvmGetErrorString - __nvvmGetErrorString = GetProcAddress(handle, 'nvvmGetErrorString') + __nvvmGetErrorString = _cyb_GetProcAddress(handle, 'nvvmGetErrorString') global __nvvmVersion - __nvvmVersion = GetProcAddress(handle, 'nvvmVersion') + __nvvmVersion = _cyb_GetProcAddress(handle, 'nvvmVersion') global __nvvmIRVersion - __nvvmIRVersion = GetProcAddress(handle, 'nvvmIRVersion') + __nvvmIRVersion = _cyb_GetProcAddress(handle, 'nvvmIRVersion') global __nvvmCreateProgram - __nvvmCreateProgram = GetProcAddress(handle, 'nvvmCreateProgram') + __nvvmCreateProgram = _cyb_GetProcAddress(handle, 'nvvmCreateProgram') global __nvvmDestroyProgram - __nvvmDestroyProgram = GetProcAddress(handle, 'nvvmDestroyProgram') + __nvvmDestroyProgram = _cyb_GetProcAddress(handle, 'nvvmDestroyProgram') global __nvvmAddModuleToProgram - __nvvmAddModuleToProgram = GetProcAddress(handle, 'nvvmAddModuleToProgram') + __nvvmAddModuleToProgram = _cyb_GetProcAddress(handle, 'nvvmAddModuleToProgram') global __nvvmLazyAddModuleToProgram - __nvvmLazyAddModuleToProgram = GetProcAddress(handle, 'nvvmLazyAddModuleToProgram') + __nvvmLazyAddModuleToProgram = _cyb_GetProcAddress(handle, 'nvvmLazyAddModuleToProgram') global __nvvmCompileProgram - __nvvmCompileProgram = GetProcAddress(handle, 'nvvmCompileProgram') + __nvvmCompileProgram = _cyb_GetProcAddress(handle, 'nvvmCompileProgram') global __nvvmVerifyProgram - __nvvmVerifyProgram = GetProcAddress(handle, 'nvvmVerifyProgram') + __nvvmVerifyProgram = _cyb_GetProcAddress(handle, 'nvvmVerifyProgram') global __nvvmGetCompiledResultSize - __nvvmGetCompiledResultSize = GetProcAddress(handle, 'nvvmGetCompiledResultSize') + __nvvmGetCompiledResultSize = _cyb_GetProcAddress(handle, 'nvvmGetCompiledResultSize') global __nvvmGetCompiledResult - __nvvmGetCompiledResult = GetProcAddress(handle, 'nvvmGetCompiledResult') + __nvvmGetCompiledResult = _cyb_GetProcAddress(handle, 'nvvmGetCompiledResult') global __nvvmGetProgramLogSize - __nvvmGetProgramLogSize = GetProcAddress(handle, 'nvvmGetProgramLogSize') + __nvvmGetProgramLogSize = _cyb_GetProcAddress(handle, 'nvvmGetProgramLogSize') global __nvvmGetProgramLog - __nvvmGetProgramLog = GetProcAddress(handle, 'nvvmGetProgramLog') + __nvvmGetProgramLog = _cyb_GetProcAddress(handle, 'nvvmGetProgramLog') global __nvvmLLVMVersion - __nvvmLLVMVersion = GetProcAddress(handle, 'nvvmLLVMVersion') + __nvvmLLVMVersion = _cyb_GetProcAddress(handle, 'nvvmLLVMVersion') - __py_nvvm_init = True + _cyb___py_nvvm_init = True return 0 - cdef inline int _check_or_init_nvvm() except -1 nogil: - if __py_nvvm_init: + if _cyb___py_nvvm_init: return 0 return _init_nvvm() -cdef dict func_ptrs = None - - cpdef dict _inspect_function_pointers(): - global func_ptrs - if func_ptrs is not None: - return func_ptrs + global _cyb_func_ptrs + if _cyb_func_ptrs is not None: + return _cyb_func_ptrs _check_or_init_nvvm() cdef dict data = {} - global __nvvmGetErrorString - data["__nvvmGetErrorString"] = __nvvmGetErrorString + data["__nvvmGetErrorString"] = <_cyb_intptr_t>__nvvmGetErrorString global __nvvmVersion - data["__nvvmVersion"] = __nvvmVersion + data["__nvvmVersion"] = <_cyb_intptr_t>__nvvmVersion global __nvvmIRVersion - data["__nvvmIRVersion"] = __nvvmIRVersion + data["__nvvmIRVersion"] = <_cyb_intptr_t>__nvvmIRVersion global __nvvmCreateProgram - data["__nvvmCreateProgram"] = __nvvmCreateProgram + data["__nvvmCreateProgram"] = <_cyb_intptr_t>__nvvmCreateProgram global __nvvmDestroyProgram - data["__nvvmDestroyProgram"] = __nvvmDestroyProgram + data["__nvvmDestroyProgram"] = <_cyb_intptr_t>__nvvmDestroyProgram global __nvvmAddModuleToProgram - data["__nvvmAddModuleToProgram"] = __nvvmAddModuleToProgram + data["__nvvmAddModuleToProgram"] = <_cyb_intptr_t>__nvvmAddModuleToProgram global __nvvmLazyAddModuleToProgram - data["__nvvmLazyAddModuleToProgram"] = __nvvmLazyAddModuleToProgram + data["__nvvmLazyAddModuleToProgram"] = <_cyb_intptr_t>__nvvmLazyAddModuleToProgram global __nvvmCompileProgram - data["__nvvmCompileProgram"] = __nvvmCompileProgram + data["__nvvmCompileProgram"] = <_cyb_intptr_t>__nvvmCompileProgram global __nvvmVerifyProgram - data["__nvvmVerifyProgram"] = __nvvmVerifyProgram + data["__nvvmVerifyProgram"] = <_cyb_intptr_t>__nvvmVerifyProgram global __nvvmGetCompiledResultSize - data["__nvvmGetCompiledResultSize"] = __nvvmGetCompiledResultSize + data["__nvvmGetCompiledResultSize"] = <_cyb_intptr_t>__nvvmGetCompiledResultSize global __nvvmGetCompiledResult - data["__nvvmGetCompiledResult"] = __nvvmGetCompiledResult + data["__nvvmGetCompiledResult"] = <_cyb_intptr_t>__nvvmGetCompiledResult global __nvvmGetProgramLogSize - data["__nvvmGetProgramLogSize"] = __nvvmGetProgramLogSize + data["__nvvmGetProgramLogSize"] = <_cyb_intptr_t>__nvvmGetProgramLogSize global __nvvmGetProgramLog - data["__nvvmGetProgramLog"] = __nvvmGetProgramLog + data["__nvvmGetProgramLog"] = <_cyb_intptr_t>__nvvmGetProgramLog global __nvvmLLVMVersion - data["__nvvmLLVMVersion"] = __nvvmLLVMVersion - - func_ptrs = data + data["__nvvmLLVMVersion"] = <_cyb_intptr_t>__nvvmLLVMVersion + _cyb_func_ptrs = data return data cpdef _inspect_function_pointer(str name): - global func_ptrs - if func_ptrs is None: - func_ptrs = _inspect_function_pointers() - return func_ptrs[name] + global _cyb_func_ptrs + if _cyb_func_ptrs is None: + _cyb_func_ptrs = _inspect_function_pointers() + return _cyb_func_ptrs[name] + + + + +cdef uintptr_t load_library() except* with gil: + return load_nvidia_dynamic_lib("nvvm")._handle_uint ############################################################################### diff --git a/cuda_bindings/cuda/bindings/cudla.pyx b/cuda_bindings/cuda/bindings/cudla.pyx index ce92c2deef9..175a6ba0d22 100644 --- a/cuda_bindings/cuda/bindings/cudla.pyx +++ b/cuda_bindings/cuda/bindings/cudla.pyx @@ -1,6 +1,9 @@ # SPDX-FileCopyrightText: Copyright (c) 2024-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: Apache-2.0 -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=6e7ac86c22e602c08df8250f3b50c135945378aa8ae4ddb4e10174fd979c4aa5 + +# This code was automatically generated across versions from 1.5.0 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=3ee237ed16e651bae93e2bc6d4d63dcf99b309ad7a74cb3e2bd5b9e540e714f4 + # <<<< PREAMBLE CONTENT >>>> @@ -16,7 +19,9 @@ from libc.string cimport ( memcmp as _cyb_memcmp, memcpy as _cyb_memcpy, ) + from enum import IntEnum as _cyb_IntEnum + import numpy as _numpy cdef _cyb___getbuffer(object self, _cyb_cpython.Py_buffer *buffer, void *ptr, int size, bint readonly): @@ -57,10 +62,8 @@ cdef _cyb_from_data(data, dtype_name, expected_dtype, lowpp_type): raise ValueError(f"data array must be of dtype {dtype_name}") return lowpp_type.from_ptr(data.ctypes.data, not data.flags.writeable, data) -# <<<< END OF PREAMBLE CONTENT >>>> - -# This code was automatically generated across versions from 1.5.0 to 13.3.0. Do not modify it directly. +# <<<< END OF PREAMBLE CONTENT >>>> cimport cython # NOQA from libc.stdint cimport intptr_t, uintptr_t @@ -1767,7 +1770,10 @@ cpdef mem_unregister(intptr_t dev_handle, intptr_t dev_ptr): cpdef int get_last_error(intptr_t dev_handle) except? 0: - return cudlaGetLastError(dev_handle) + cdef int ret + with nogil: + ret = cudlaGetLastError(dev_handle) + return ret cpdef destroy_device(intptr_t dev_handle): diff --git a/cuda_bindings/cuda/bindings/cufile.pyx b/cuda_bindings/cuda/bindings/cufile.pyx index b3b875d2018..fbc9c20dc47 100644 --- a/cuda_bindings/cuda/bindings/cufile.pyx +++ b/cuda_bindings/cuda/bindings/cufile.pyx @@ -3,7 +3,8 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.9.1 to 13.3.0. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=359f9b42f4f97b9a74570e1f7d20eb6f5faae2df194a6161f4d5a9512c3ffbe3 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=4567ca64d02631fc8d6ed11af8164d72c86b4686c105fd733d186e6c92512749 + # <<<< PREAMBLE CONTENT >>>> @@ -20,7 +21,9 @@ from libc.string cimport ( memcmp as _cyb_memcmp, memcpy as _cyb_memcpy, ) + from cuda.bindings._internal._fast_enum import FastEnum as _cyb_FastEnum + import numpy as _numpy cdef _cyb___getbuffer(object self, _cyb_cpython.Py_buffer *buffer, void *ptr, int size, bint readonly): @@ -61,8 +64,8 @@ cdef _cyb_from_data(data, dtype_name, expected_dtype, lowpp_type): raise ValueError(f"data array must be of dtype {dtype_name}") return lowpp_type.from_ptr(data.ctypes.data, not data.flags.writeable, data) -# <<<< END OF PREAMBLE CONTENT >>>> +# <<<< END OF PREAMBLE CONTENT >>>> cimport cython # NOQA from libc cimport errno @@ -2895,7 +2898,8 @@ cpdef void handle_deregister(intptr_t fh) except*: .. seealso:: `cuFileHandleDeregister` """ - cuFileHandleDeregister(fh) + with nogil: + cuFileHandleDeregister(fh) cpdef buf_register(intptr_t buf_ptr_base, size_t length, int flags): @@ -3039,7 +3043,8 @@ cpdef batch_io_cancel(intptr_t batch_idp): cpdef void batch_io_destroy(intptr_t batch_idp) except*: - cuFileBatchIODestroy(batch_idp) + with nogil: + cuFileBatchIODestroy(batch_idp) cpdef read_async(intptr_t fh, intptr_t buf_ptr_base, intptr_t size_p, intptr_t file_offset_p, intptr_t buf_ptr_offset_p, intptr_t bytes_read_p, intptr_t stream): diff --git a/cuda_bindings/cuda/bindings/cycufile.pyx b/cuda_bindings/cuda/bindings/cycufile.pyx index e457aa2c63b..c8d240560b0 100644 --- a/cuda_bindings/cuda/bindings/cycufile.pyx +++ b/cuda_bindings/cuda/bindings/cycufile.pyx @@ -3,8 +3,16 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.9.1 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=a68ff13250f4b5131f4b4adf8a37a4283b27749e8429b5f6e57bfc68bf656b00 + + +# <<<< PREAMBLE CONTENT >>>> + +cimport cython as _cyb_cython + + +# <<<< END OF PREAMBLE CONTENT >>>> -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=74f1f9c9443af66fdadbfeeb01e5c15c2d8f1b9b0b20eafa2a279583bcf7df00 from ._internal cimport cufile as _cufile import cython @@ -17,7 +25,7 @@ cdef CUfileError_t cuFileHandleRegister(CUfileHandle_t* fh, CUfileDescr_t* descr return _cufile._cuFileHandleRegister(fh, descr) -@cython.show_performance_hints(False) +@_cyb_cython.show_performance_hints(False) cdef void cuFileHandleDeregister(CUfileHandle_t fh) except* nogil: _cufile._cuFileHandleDeregister(fh) @@ -90,7 +98,7 @@ cdef CUfileError_t cuFileBatchIOCancel(CUfileBatchHandle_t batch_idp) except?>>> from cuda.bindings._internal._fast_enum import FastEnum as _cyb_FastEnum -# <<<< END OF PREAMBLE CONTENT >>>> +# <<<< END OF PREAMBLE CONTENT >>>> cimport cython # NOQA diff --git a/cuda_bindings/cuda/bindings/nvjitlink.pyx b/cuda_bindings/cuda/bindings/nvjitlink.pyx index 89dea49e4ad..eee6cc33923 100644 --- a/cuda_bindings/cuda/bindings/nvjitlink.pyx +++ b/cuda_bindings/cuda/bindings/nvjitlink.pyx @@ -3,14 +3,15 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.0.1 to 13.3.0. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=18cc1af125a513c3867c6f2bd8e97f4b0b2d2e58565a8980223a419ae5f23b74 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=85275f1596953f034c156776f8fe4f6e518dbb89ffedda994d8e78bfd9284246 + # <<<< PREAMBLE CONTENT >>>> from cuda.bindings._internal._fast_enum import FastEnum as _cyb_FastEnum -# <<<< END OF PREAMBLE CONTENT >>>> +# <<<< END OF PREAMBLE CONTENT >>>> cimport cython # NOQA diff --git a/cuda_bindings/cuda/bindings/nvml.pyx b/cuda_bindings/cuda/bindings/nvml.pyx index 26b63f1f6a7..a51d4264363 100644 --- a/cuda_bindings/cuda/bindings/nvml.pyx +++ b/cuda_bindings/cuda/bindings/nvml.pyx @@ -3,7 +3,8 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.9.1 to 13.3.0. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=52642c2c289dbd93191f019468630c0c7935bf99bc15c9c7c0de3797a109e8b0 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=e47a16bd9956de14a991ded5d1aef667cdd26a141e27db5b2015b91be6918d3c + # <<<< PREAMBLE CONTENT >>>> @@ -20,7 +21,9 @@ from libc.string cimport ( memcmp as _cyb_memcmp, memcpy as _cyb_memcpy, ) + from cuda.bindings._internal._fast_enum import FastEnum as _cyb_FastEnum + import numpy as _numpy cdef _cyb___getbuffer(object self, _cyb_cpython.Py_buffer *buffer, void *ptr, int size, bint readonly): @@ -61,8 +64,8 @@ cdef _cyb_from_data(data, dtype_name, expected_dtype, lowpp_type): raise ValueError(f"data array must be of dtype {dtype_name}") return lowpp_type.from_ptr(data.ctypes.data, not data.flags.writeable, data) -# <<<< END OF PREAMBLE CONTENT >>>> +# <<<< END OF PREAMBLE CONTENT >>>> cimport cython # NOQA from cython cimport view @@ -21629,8 +21632,11 @@ cpdef str error_string(int result): .. seealso:: `nvmlErrorString` """ + cdef const char *_output_cstr_ cdef bytes _output_ - _output_ = nvmlErrorString(<_Return>result) + with nogil: + _output_cstr_ = nvmlErrorString(<_Return>result) + _output_ = _output_cstr_ return _output_.decode() diff --git a/cuda_bindings/cuda/bindings/nvvm.pyx b/cuda_bindings/cuda/bindings/nvvm.pyx index eec2fd8556a..6d18a50f24c 100644 --- a/cuda_bindings/cuda/bindings/nvvm.pyx +++ b/cuda_bindings/cuda/bindings/nvvm.pyx @@ -3,14 +3,15 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.0.1 to 13.3.0. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=663773bbe4ae03ad1e170d44b06d5a924b5e4a3a0bd901c2f276976b82943bcb +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=82dc56ccc695031faa515d1971c9841131d5aadc60c6d6e6cc223580fc544d16 + # <<<< PREAMBLE CONTENT >>>> from cuda.bindings._internal._fast_enum import FastEnum as _cyb_FastEnum -# <<<< END OF PREAMBLE CONTENT >>>> +# <<<< END OF PREAMBLE CONTENT >>>> cimport cython # NOQA @@ -91,8 +92,11 @@ cpdef str get_error_string(int result): .. seealso:: `nvvmGetErrorString` """ + cdef const char *_output_cstr_ cdef bytes _output_ - _output_ = nvvmGetErrorString(<_Result>result) + with nogil: + _output_cstr_ = nvvmGetErrorString(<_Result>result) + _output_ = _output_cstr_ return _output_.decode() From 046cefad41f6da127d1e41571672972d4027bb38 Mon Sep 17 00:00:00 2001 From: Leo Fang Date: Mon, 13 Jul 2026 19:47:42 -0700 Subject: [PATCH 22/25] CI: retry arm64 GH200 nightly-standard row + add GB300 (#2296) * ci/test-matrix.yml: re-enable arm64 gh200 nightly-standard row Reverts the disable in 4c70cfac05 now that the runner team has fixed the pool-side hang on stream-ordered memory allocator calls. * Temporarily add push trigger to ci-nightly.yml for testing Remove before merging. * CI: deselect test_get_bar_size_in_kb on gh200 runners The cufile BAR-size query returns CUDA_ERROR_NOT_SUPPORTED on Grace+Hopper (unified memory, no discrete PCIe BAR). Tracked in #2299; remove this deselect once the test skipif is fixed upstream. Uses PYTEST_ADDOPTS so no changes to run-tests are needed. * also add GB300 * cuda.core tests: build saxpy RDC fixture with -arch=all (covers sm_103 / GB300) -arch=all-major only emits X.0 cubins (sm_100, sm_90, ...), so nvJitLink returns ERROR_INVALID_INPUT when the RDC saxpy fixture is linked on GB300 (sm_103): Blackwell no longer serves an sm_10x cubin from the sm_100 image. -arch=all additionally emits sm_103 (and other minor archs) so the linker finds a usable input. The fixture is built in-job by build_test_binaries.py, so there is no committed artifact to regenerate. * CI: install curand/cublas + cupy for numba-cuda-mlir nightly; extend deselect gate to 0.4.1 test_fortran_contiguous calls cp.random, which dlopens libcurand at runtime; the mlir nightly install didn't provide it, unlike the numba-cuda branch (which installs cuda-toolkit[curand,cublas] + cupy). Mirror that here. Bump the version-gated mlir deselect from <=0.4.0 to <=0.4.1: 0.4.1 still fails the cuobjdump-invoking nvjitlink test (wheel envs lack cuobjdump) and the #135 pytest-contamination tests, so keep them deselected. cu12 rows remain red due to the separate #2320 LTO-IR regression (not in the deselect list). * nit: align columns * Revert "Temporarily add push trigger to ci-nightly.yml for testing" This reverts commit 8d51cf761dda86fc29eeb3e68aba8860e366ef19. * rename variable --- .github/workflows/test-wheel-linux.yml | 5 +- .github/workflows/test-wheel-windows.yml | 2 +- ci/test-matrix.yml | 59 +++++++++---------- ci/tools/run-tests | 20 +++++-- .../test_binaries/build_test_binaries.py | 2 +- 5 files changed, 49 insertions(+), 39 deletions(-) diff --git a/.github/workflows/test-wheel-linux.yml b/.github/workflows/test-wheel-linux.yml index ae1e2e5dafc..4971d56f832 100644 --- a/.github/workflows/test-wheel-linux.yml +++ b/.github/workflows/test-wheel-linux.yml @@ -352,6 +352,9 @@ jobs: env: CUDA_VER: ${{ matrix.CUDA_VER }} LOCAL_CTK: ${{ matrix.LOCAL_CTK }} + # #2299: BAR-size query returns CUDA_ERROR_NOT_SUPPORTED on G+H; + # skip the test on gh200 runners until upstream cufile guards it. + PYTEST_ADDOPTS: ${{ matrix.GPU == 'gh200' && '--deselect tests/test_cufile.py::test_get_bar_size_in_kb' || '' }} run: run-tests bindings - name: Run cuda.bindings benchmarks (smoke test) @@ -462,7 +465,7 @@ jobs: # tests get run automatically. If they still fail on the newer # version we hear about it loudly (rather than silently masking). DESELECTS=() - if python -c "from packaging.version import Version; import sys; sys.exit(0 if Version('${NUMBA_CUDA_MLIR_VER}') <= Version('0.4.0') else 1)"; then + if python -c "from packaging.version import Version; import sys; sys.exit(0 if Version('${NUMBA_CUDA_MLIR_VER}') <= Version('0.4.1') else 1)"; then # NVIDIA/numba-cuda-mlir#135: serial-pytest contamination of # numba_cuda_mlir.cuda.cudadrv from an xfailed test in # test_nrt_comprehensive.py contaminates any later test that diff --git a/.github/workflows/test-wheel-windows.yml b/.github/workflows/test-wheel-windows.yml index 46937cbd12d..e2ff59f39e5 100644 --- a/.github/workflows/test-wheel-windows.yml +++ b/.github/workflows/test-wheel-windows.yml @@ -443,7 +443,7 @@ jobs: # the full union rather than trying to enumerate what happened # to fail on the most recent nightly. DESELECTS=() - if python -c "from packaging.version import Version; import sys; sys.exit(0 if Version('${NUMBA_CUDA_MLIR_VER}') <= Version('0.4.0') else 1)"; then + if python -c "from packaging.version import Version; import sys; sys.exit(0 if Version('${NUMBA_CUDA_MLIR_VER}') <= Version('0.4.1') else 1)"; then DESELECTS+=( --deselect 'tests/numba_cuda_tests/cudadrv/test_cuda_array_slicing.py::CudaArraySetting::test_no_sync_default_stream' --deselect 'tests/numba_cuda_tests/cudadrv/test_cuda_array_slicing.py::CudaArraySetting::test_no_sync_supplied_stream' diff --git a/ci/test-matrix.yml b/ci/test-matrix.yml index cd0944f2000..0adb0142ae7 100644 --- a/ci/test-matrix.yml +++ b/ci/test-matrix.yml @@ -93,7 +93,7 @@ linux: - { ARCH: 'arm64', PY_VER: '3.12', CUDA_VER: '13.0.2', LOCAL_CTK: '0', GPU: 'l4', GPU_COUNT: '1', DRIVER: 'latest', ENV: { MODE: 'nightly-pytorch', TORCH_VER: '2.9.1', TORCH_CUDA: 'cu130' } } # nightly-numba-cuda - { ARCH: 'amd64', PY_VER: '3.12', CUDA_VER: '12.9.1', LOCAL_CTK: '0', GPU: 'l4', GPU_COUNT: '1', DRIVER: 'latest', ENV: { MODE: 'nightly-numba-cuda' } } - - { ARCH: 'amd64', PY_VER: '3.12', CUDA_VER: '13.3.0', LOCAL_CTK: '0', GPU: 'l4', GPU_COUNT: '1', DRIVER: '580.65.06', ENV: { MODE: 'nightly-numba-cuda' } } + - { ARCH: 'amd64', PY_VER: '3.12', CUDA_VER: '13.3.0', LOCAL_CTK: '0', GPU: 'l4', GPU_COUNT: '1', DRIVER: '580.65.06', ENV: { MODE: 'nightly-numba-cuda' } } - { ARCH: 'arm64', PY_VER: '3.12', CUDA_VER: '12.9.1', LOCAL_CTK: '0', GPU: 'l4', GPU_COUNT: '1', DRIVER: 'latest', ENV: { MODE: 'nightly-numba-cuda' } } - { ARCH: 'arm64', PY_VER: '3.12', CUDA_VER: '13.3.0', LOCAL_CTK: '0', GPU: 'l4', GPU_COUNT: '1', DRIVER: 'latest', ENV: { MODE: 'nightly-numba-cuda' } } # nightly-numba-cuda-mlir (MLIR backend, linux-64 only) @@ -102,45 +102,44 @@ linux: # nightly-cuda-core (released cuda-core from PyPI against main pathfinder/bindings) - { ARCH: 'amd64', PY_VER: '3.12', CUDA_VER: '13.3.0', LOCAL_CTK: '0', GPU: 'a100', GPU_COUNT: '1', DRIVER: 'latest', ENV: { MODE: 'nightly-cuda-core' } } # nightly-standard (arm64 nightly-only runners — per runner team request) - # TODO: gh200 row disabled — currently hangs on stream-ordered memory - # allocator (cudaMallocAsync); runner pool needs fixing first. - # - { ARCH: 'arm64', PY_VER: '3.14', CUDA_VER: '13.3.0', LOCAL_CTK: '1', GPU: 'gh200', GPU_COUNT: '1', DRIVER: 'latest', ENV: { MODE: 'nightly-standard' } } + - { ARCH: 'arm64', PY_VER: '3.13', CUDA_VER: '13.3.0', LOCAL_CTK: '1', GPU: 'gh200', GPU_COUNT: '1', DRIVER: 'latest', ENV: { MODE: 'nightly-standard' } } + - { ARCH: 'arm64', PY_VER: '3.14', CUDA_VER: '13.3.0', LOCAL_CTK: '1', GPU: 'gb300', GPU_COUNT: '1', DRIVER: 'latest', ENV: { MODE: 'nightly-standard' } } - { ARCH: 'arm64', PY_VER: '3.14', CUDA_VER: '13.3.0', LOCAL_CTK: '1', GPU: 'l4', GPU_COUNT: '2', DRIVER: 'latest', ENV: { MODE: 'nightly-standard' } } - { ARCH: 'arm64', PY_VER: '3.14t', CUDA_VER: '13.3.0', LOCAL_CTK: '1', GPU: 'l4', GPU_COUNT: '2', DRIVER: 'latest', ENV: { MODE: 'nightly-standard' } } windows: pull-request: # win-64 - - { ARCH: 'amd64', PY_VER: '3.10', CUDA_VER: '12.9.1', LOCAL_CTK: '0', GPU: 'rtx2080', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'WDDM' } - - { ARCH: 'amd64', PY_VER: '3.10', CUDA_VER: '13.0.2', LOCAL_CTK: '1', GPU: 'rtxpro6000', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'TCC' } - - { ARCH: 'amd64', PY_VER: '3.10', CUDA_VER: '13.3.0', LOCAL_CTK: '1', GPU: 'rtxpro6000', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'TCC' } - - { ARCH: 'amd64', PY_VER: '3.11', CUDA_VER: '12.9.1', LOCAL_CTK: '1', GPU: 'v100', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'MCDM' } - - { ARCH: 'amd64', PY_VER: '3.11', CUDA_VER: '13.0.2', LOCAL_CTK: '0', GPU: 'rtx4090', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'WDDM' } - - { ARCH: 'amd64', PY_VER: '3.11', CUDA_VER: '13.3.0', LOCAL_CTK: '0', GPU: 'rtx4090', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'WDDM' } - - { ARCH: 'amd64', PY_VER: '3.12', CUDA_VER: '12.9.1', LOCAL_CTK: '0', GPU: 'l4', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'MCDM' } - - { ARCH: 'amd64', PY_VER: '3.12', CUDA_VER: '13.0.2', LOCAL_CTK: '1', GPU: 'a100', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'TCC' } - - { ARCH: 'amd64', PY_VER: '3.12', CUDA_VER: '13.3.0', LOCAL_CTK: '1', GPU: 'a100', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'TCC' } - - { ARCH: 'amd64', PY_VER: '3.13', CUDA_VER: '12.9.1', LOCAL_CTK: '1', GPU: 'l4', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'TCC' } - - { ARCH: 'amd64', PY_VER: '3.13', CUDA_VER: '13.0.2', LOCAL_CTK: '0', GPU: 'rtxpro6000', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'MCDM' } - - { ARCH: 'amd64', PY_VER: '3.13', CUDA_VER: '13.3.0', LOCAL_CTK: '0', GPU: 'rtxpro6000', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'MCDM', ENV: { CUDA_PYTHON_CUDA_PER_THREAD_DEFAULT_STREAM: '1' } } - - { ARCH: 'amd64', PY_VER: '3.14', CUDA_VER: '12.9.1', LOCAL_CTK: '0', GPU: 'v100', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'TCC' } - - { ARCH: 'amd64', PY_VER: '3.14', CUDA_VER: '13.0.2', LOCAL_CTK: '1', GPU: 'l4', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'MCDM' } - - { ARCH: 'amd64', PY_VER: '3.14', CUDA_VER: '13.3.0', LOCAL_CTK: '1', GPU: 'l4', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'MCDM' } - - { ARCH: 'amd64', PY_VER: '3.14t', CUDA_VER: '12.9.1', LOCAL_CTK: '1', GPU: 'l4', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'TCC' } - - { ARCH: 'amd64', PY_VER: '3.14t', CUDA_VER: '13.0.2', LOCAL_CTK: '0', GPU: 'a100', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'MCDM' } - - { ARCH: 'amd64', PY_VER: '3.14t', CUDA_VER: '13.3.0', LOCAL_CTK: '0', GPU: 'a100', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'MCDM' } + - { ARCH: 'amd64', PY_VER: '3.10', CUDA_VER: '12.9.1', LOCAL_CTK: '0', GPU: 'rtx2080', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'WDDM' } + - { ARCH: 'amd64', PY_VER: '3.10', CUDA_VER: '13.0.2', LOCAL_CTK: '1', GPU: 'rtxpro6000', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'TCC' } + - { ARCH: 'amd64', PY_VER: '3.10', CUDA_VER: '13.3.0', LOCAL_CTK: '1', GPU: 'rtxpro6000', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'TCC' } + - { ARCH: 'amd64', PY_VER: '3.11', CUDA_VER: '12.9.1', LOCAL_CTK: '1', GPU: 'v100', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'MCDM' } + - { ARCH: 'amd64', PY_VER: '3.11', CUDA_VER: '13.0.2', LOCAL_CTK: '0', GPU: 'rtx4090', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'WDDM' } + - { ARCH: 'amd64', PY_VER: '3.11', CUDA_VER: '13.3.0', LOCAL_CTK: '0', GPU: 'rtx4090', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'WDDM' } + - { ARCH: 'amd64', PY_VER: '3.12', CUDA_VER: '12.9.1', LOCAL_CTK: '0', GPU: 'l4', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'MCDM' } + - { ARCH: 'amd64', PY_VER: '3.12', CUDA_VER: '13.0.2', LOCAL_CTK: '1', GPU: 'a100', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'TCC' } + - { ARCH: 'amd64', PY_VER: '3.12', CUDA_VER: '13.3.0', LOCAL_CTK: '1', GPU: 'a100', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'TCC' } + - { ARCH: 'amd64', PY_VER: '3.13', CUDA_VER: '12.9.1', LOCAL_CTK: '1', GPU: 'l4', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'TCC' } + - { ARCH: 'amd64', PY_VER: '3.13', CUDA_VER: '13.0.2', LOCAL_CTK: '0', GPU: 'rtxpro6000', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'MCDM' } + - { ARCH: 'amd64', PY_VER: '3.13', CUDA_VER: '13.3.0', LOCAL_CTK: '0', GPU: 'rtxpro6000', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'MCDM', ENV: { CUDA_PYTHON_CUDA_PER_THREAD_DEFAULT_STREAM: '1' } } + - { ARCH: 'amd64', PY_VER: '3.14', CUDA_VER: '12.9.1', LOCAL_CTK: '0', GPU: 'v100', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'TCC' } + - { ARCH: 'amd64', PY_VER: '3.14', CUDA_VER: '13.0.2', LOCAL_CTK: '1', GPU: 'l4', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'MCDM' } + - { ARCH: 'amd64', PY_VER: '3.14', CUDA_VER: '13.3.0', LOCAL_CTK: '1', GPU: 'l4', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'MCDM' } + - { ARCH: 'amd64', PY_VER: '3.14t', CUDA_VER: '12.9.1', LOCAL_CTK: '1', GPU: 'l4', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'TCC' } + - { ARCH: 'amd64', PY_VER: '3.14t', CUDA_VER: '13.0.2', LOCAL_CTK: '0', GPU: 'a100', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'MCDM' } + - { ARCH: 'amd64', PY_VER: '3.14t', CUDA_VER: '13.3.0', LOCAL_CTK: '0', GPU: 'a100', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'MCDM' } # special runners - - { ARCH: 'amd64', PY_VER: '3.14', CUDA_VER: '13.3.0', LOCAL_CTK: '1', GPU: 't4', GPU_COUNT: '2', DRIVER: 'latest', DRIVER_MODE: 'TCC' } - - { ARCH: 'amd64', PY_VER: '3.14', CUDA_VER: '13.3.0', LOCAL_CTK: '0', GPU: 'h100', GPU_COUNT: '2', DRIVER: 'latest', DRIVER_MODE: 'MCDM' } + - { ARCH: 'amd64', PY_VER: '3.14', CUDA_VER: '13.3.0', LOCAL_CTK: '1', GPU: 't4', GPU_COUNT: '2', DRIVER: 'latest', DRIVER_MODE: 'TCC' } + - { ARCH: 'amd64', PY_VER: '3.14', CUDA_VER: '13.3.0', LOCAL_CTK: '0', GPU: 'h100', GPU_COUNT: '2', DRIVER: 'latest', DRIVER_MODE: 'MCDM' } nightly: # nightly-pytorch - - { ARCH: 'amd64', PY_VER: '3.12', CUDA_VER: '12.6.3', LOCAL_CTK: '0', GPU: 'l4', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'TCC', ENV: { MODE: 'nightly-pytorch', TORCH_VER: '2.12.1', TORCH_CUDA: 'cu126' } } - - { ARCH: 'amd64', PY_VER: '3.12', CUDA_VER: '13.0.2', LOCAL_CTK: '0', GPU: 'l4', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'TCC', ENV: { MODE: 'nightly-pytorch', TORCH_VER: '2.12.1', TORCH_CUDA: 'cu130' } } - - { ARCH: 'amd64', PY_VER: '3.12', CUDA_VER: '12.6.3', LOCAL_CTK: '0', GPU: 'l4', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'TCC', ENV: { MODE: 'nightly-pytorch', TORCH_VER: '2.9.1', TORCH_CUDA: 'cu126' } } - - { ARCH: 'amd64', PY_VER: '3.12', CUDA_VER: '13.0.2', LOCAL_CTK: '0', GPU: 'l4', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'TCC', ENV: { MODE: 'nightly-pytorch', TORCH_VER: '2.9.1', TORCH_CUDA: 'cu130' } } + - { ARCH: 'amd64', PY_VER: '3.12', CUDA_VER: '12.6.3', LOCAL_CTK: '0', GPU: 'l4', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'TCC', ENV: { MODE: 'nightly-pytorch', TORCH_VER: '2.12.1', TORCH_CUDA: 'cu126' } } + - { ARCH: 'amd64', PY_VER: '3.12', CUDA_VER: '13.0.2', LOCAL_CTK: '0', GPU: 'l4', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'TCC', ENV: { MODE: 'nightly-pytorch', TORCH_VER: '2.12.1', TORCH_CUDA: 'cu130' } } + - { ARCH: 'amd64', PY_VER: '3.12', CUDA_VER: '12.6.3', LOCAL_CTK: '0', GPU: 'l4', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'TCC', ENV: { MODE: 'nightly-pytorch', TORCH_VER: '2.9.1', TORCH_CUDA: 'cu126' } } + - { ARCH: 'amd64', PY_VER: '3.12', CUDA_VER: '13.0.2', LOCAL_CTK: '0', GPU: 'l4', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'TCC', ENV: { MODE: 'nightly-pytorch', TORCH_VER: '2.9.1', TORCH_CUDA: 'cu130' } } # nightly-numba-cuda - - { ARCH: 'amd64', PY_VER: '3.12', CUDA_VER: '12.9.1', LOCAL_CTK: '0', GPU: 'l4', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'TCC', ENV: { MODE: 'nightly-numba-cuda' } } - - { ARCH: 'amd64', PY_VER: '3.12', CUDA_VER: '13.3.0', LOCAL_CTK: '0', GPU: 'l4', GPU_COUNT: '1', DRIVER: '596.36', DRIVER_MODE: 'TCC', ENV: { MODE: 'nightly-numba-cuda' } } + - { ARCH: 'amd64', PY_VER: '3.12', CUDA_VER: '12.9.1', LOCAL_CTK: '0', GPU: 'l4', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'TCC', ENV: { MODE: 'nightly-numba-cuda' } } + - { ARCH: 'amd64', PY_VER: '3.12', CUDA_VER: '13.3.0', LOCAL_CTK: '0', GPU: 'l4', GPU_COUNT: '1', DRIVER: '596.36', DRIVER_MODE: 'TCC', ENV: { MODE: 'nightly-numba-cuda' } } # nightly-numba-cuda-mlir (MLIR backend, win-64) - { ARCH: 'amd64', PY_VER: '3.12', CUDA_VER: '12.9.1', LOCAL_CTK: '0', GPU: 'rtxpro6000', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'MCDM', ENV: { MODE: 'nightly-numba-cuda-mlir' } } - { ARCH: 'amd64', PY_VER: '3.12', CUDA_VER: '13.3.0', LOCAL_CTK: '0', GPU: 'rtxpro6000', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'MCDM', ENV: { MODE: 'nightly-numba-cuda-mlir' } } diff --git a/ci/tools/run-tests b/ci/tools/run-tests index c5c0cc12336..c093ed9e4d2 100755 --- a/ci/tools/run-tests +++ b/ci/tools/run-tests @@ -59,7 +59,7 @@ elif [[ "${test_module}" == "bindings" ]]; then elif [[ "${test_module}" == "core" || "${test_module}" == nightly-* ]]; then # Shared setup for core and nightly modes. TEST_CUDA_MAJOR="$(cut -d '.' -f 1 <<< ${CUDA_VER})" - CUDA_VER_MINOR="$(cut -d '.' -f 1-2 <<< "${CUDA_VER}")" + TEST_CUDA_MAJOR_MINOR="$(cut -d '.' -f 1-2 <<< "${CUDA_VER}")" FREE_THREADING="" if python -c 'import sys; assert not sys._is_gil_enabled()' 2> /dev/null; then @@ -101,7 +101,7 @@ elif [[ "${test_module}" == "core" || "${test_module}" == nightly-* ]]; then echo "Installing core wheel" # Constrain cuda-toolkit to the requested CTK version to avoid # pip pulling in a newer nvidia-cuda-runtime that conflicts with it. - pip install "${CORE_WHL[@]}" --group "test-cu${TEST_CUDA_MAJOR}${FREE_THREADING}" "cuda-toolkit==${CUDA_VER_MINOR}.*" + pip install "${CORE_WHL[@]}" --group "test-cu${TEST_CUDA_MAJOR}${FREE_THREADING}" "cuda-toolkit==${TEST_CUDA_MAJOR_MINOR}.*" echo "Installed packages before core tests:" pip list echo "Running core tests" @@ -145,7 +145,7 @@ elif [[ "${test_module}" == "core" || "${test_module}" == nightly-* ]]; then # Use cuda-toolkit[cudart] only — torch brings its own nvcc/nvrtc/etc. # This avoids version conflicts between our nvidia-* pins and torch's. echo "Installing pathfinder + bindings + core + test deps + PyTorch ${TORCH_VER} (${TORCH_CUDA})" - PIP_ARGS+=("cuda-toolkit[cudart]==${CUDA_VER_MINOR}.*") + PIP_ARGS+=("cuda-toolkit[cudart]==${TEST_CUDA_MAJOR_MINOR}.*") if [[ "${TORCH_VER}" == "latest" ]]; then PIP_ARGS+=(torch) else @@ -156,16 +156,24 @@ elif [[ "${test_module}" == "core" || "${test_module}" == nightly-* ]]; then echo "Installing pathfinder + bindings + core + test deps + numba-cuda" # numba-cuda's test-cuXX group deps (can't use --group for a wheel install): PIP_ARGS+=( - "cuda-toolkit[curand,cublas]==${CUDA_VER_MINOR}.*" + "cuda-toolkit[curand,cublas]==${TEST_CUDA_MAJOR_MINOR}.*" "numba-cuda[cu${TEST_CUDA_MAJOR}]" "cupy-cuda${TEST_CUDA_MAJOR}x" psutil cffi pytest-xdist pytest-benchmark filecheck ml_dtypes statistics ) elif [[ "${test_module}" == "nightly-numba-cuda-mlir" ]]; then - echo "Installing pathfinder + bindings + core + numba-cuda-mlir" + echo "Installing pathfinder + bindings + core + numba-cuda-mlir + cupy" # numpy<2.5: numba-cuda-mlir 0.4.0 registers np.row_stack, which was # removed in NumPy 2.5. See NVIDIA/numba-cuda-mlir#154. - PIP_ARGS+=("numba-cuda-mlir[cu${TEST_CUDA_MAJOR}]" "numpy<2.5") + # curand/cublas + cupy: some numba-cuda-mlir tests (e.g. + # test_fortran_contiguous) call cp.random, which dlopens libcurand at + # runtime. Mirror the numba-cuda branch, which installs the same libs. + PIP_ARGS+=( + "numba-cuda-mlir[cu${TEST_CUDA_MAJOR}]" + "numpy<2.5" + "cuda-toolkit[curand,cublas]==${TEST_CUDA_MAJOR_MINOR}.*" + "cupy-cuda${TEST_CUDA_MAJOR}x" + ) fi pip install "${PIP_ARGS[@]}" diff --git a/cuda_core/tests/test_binaries/build_test_binaries.py b/cuda_core/tests/test_binaries/build_test_binaries.py index 5dfa1fe7f08..ca1ceccb268 100644 --- a/cuda_core/tests/test_binaries/build_test_binaries.py +++ b/cuda_core/tests/test_binaries/build_test_binaries.py @@ -37,7 +37,7 @@ def main() -> None: "nvcc", "-dc", *nvcc_extra_flags, - "-arch=all-major", + "-arch=all", "-o", str(object_path), str(source_path), From 631aca960daba8bf704a1bf475978acb357ee1d5 Mon Sep 17 00:00:00 2001 From: Yevhenii Havrylko Date: Mon, 13 Jul 2026 22:48:19 -0400 Subject: [PATCH 23/25] Add nvjitlink get_linked_ltoir (#2337) --- .../docs/source/module/nvjitlink.rst | 29 +++++++++++++++++++ cuda_bindings/tests/test_nvjitlink.py | 21 ++++++++++++++ 2 files changed, 50 insertions(+) diff --git a/cuda_bindings/docs/source/module/nvjitlink.rst b/cuda_bindings/docs/source/module/nvjitlink.rst index 271fc4424bc..ba1700a8aab 100644 --- a/cuda_bindings/docs/source/module/nvjitlink.rst +++ b/cuda_bindings/docs/source/module/nvjitlink.rst @@ -25,6 +25,8 @@ NvJitLink defines the following functions for linking code objects and querying .. autofunction:: cuda.bindings.nvjitlink.get_linked_cubin .. autofunction:: cuda.bindings.nvjitlink.get_linked_ptx_size .. autofunction:: cuda.bindings.nvjitlink.get_linked_ptx +.. autofunction:: cuda.bindings.nvjitlink.get_linked_ltoir_size +.. autofunction:: cuda.bindings.nvjitlink.get_linked_ltoir .. autofunction:: cuda.bindings.nvjitlink.get_error_log_size .. autofunction:: cuda.bindings.nvjitlink.get_error_log .. autofunction:: cuda.bindings.nvjitlink.get_info_log_size @@ -65,6 +67,33 @@ Types .. autoattribute:: cuda.bindings.nvjitlink.Result.ERROR_FINALIZE + .. autoattribute:: cuda.bindings.nvjitlink.Result.ERROR_NULL_INPUT + + + .. autoattribute:: cuda.bindings.nvjitlink.Result.ERROR_INCOMPATIBLE_OPTIONS + + + .. autoattribute:: cuda.bindings.nvjitlink.Result.ERROR_INCORRECT_INPUT_TYPE + + + .. autoattribute:: cuda.bindings.nvjitlink.Result.ERROR_ARCH_MISMATCH + + + .. autoattribute:: cuda.bindings.nvjitlink.Result.ERROR_OUTDATED_LIBRARY + + + .. autoattribute:: cuda.bindings.nvjitlink.Result.ERROR_MISSING_FATBIN + + + .. autoattribute:: cuda.bindings.nvjitlink.Result.ERROR_UNRECOGNIZED_ARCH + + + .. autoattribute:: cuda.bindings.nvjitlink.Result.ERROR_UNSUPPORTED_ARCH + + + .. autoattribute:: cuda.bindings.nvjitlink.Result.ERROR_LTO_NOT_ENABLED + + .. autoclass:: cuda.bindings.nvjitlink.InputType .. autoattribute:: cuda.bindings.nvjitlink.InputType.NONE diff --git a/cuda_bindings/tests/test_nvjitlink.py b/cuda_bindings/tests/test_nvjitlink.py index a2020f042e4..91d6ace1ce6 100644 --- a/cuda_bindings/tests/test_nvjitlink.py +++ b/cuda_bindings/tests/test_nvjitlink.py @@ -70,6 +70,12 @@ def check_nvjitlink_usable(): return inner_nvjitlink._inspect_function_pointer("__nvJitLinkVersion") != 0 +def check_nvjitlink_get_linked_ltoir_usable(): + from cuda.bindings._internal import nvjitlink as inner_nvjitlink + + return inner_nvjitlink._inspect_function_pointer("__nvJitLinkGetLinkedLTOIR") != 0 + + pytestmark = pytest.mark.skipif( not check_nvjitlink_usable(), reason="nvJitLink not usable, maybe not installed or too old (<12.3)" ) @@ -183,6 +189,21 @@ def test_get_linked_ptx(arch, get_dummy_ltoir): assert len(ptx) == ptx_size +@pytest.mark.parametrize("arch", ARCHITECTURES) +@pytest.mark.skipif( + not check_nvjitlink_get_linked_ltoir_usable(), + reason="nvJitLinkGetLinkedLTOIR not available in installed nvJitLink", +) +def test_get_linked_ltoir(arch, get_dummy_ltoir): + with nvjitlink_session(2, [f"-arch={arch}", "-lto"]) as handle: + nvjitlink.add_data(handle, nvjitlink.InputType.LTOIR, get_dummy_ltoir, len(get_dummy_ltoir), "test_data") + nvjitlink.complete(handle) + ltoir_size = nvjitlink.get_linked_ltoir_size(handle) + ltoir = bytearray(ltoir_size) + nvjitlink.get_linked_ltoir(handle, ltoir) + assert len(ltoir) == ltoir_size + + def test_package_version(): ver = nvjitlink.version() assert len(ver) == 2 From c4a5647a085280c2d5984950dd821197be871321 Mon Sep 17 00:00:00 2001 From: Michael Droettboom Date: Tue, 14 Jul 2026 12:02:46 -0400 Subject: [PATCH 24/25] Move runtime's internal and cython layers to cybind (#2261) * Move runtime's internal and cython layers to cybind * Attempt to fix build * Another attempt to fix the build * Attempt to fix bindings * Fix Windows build * ABI fixes * Fix Windows build (again) * Fixes after merge * Rebuild after merge on the cybind side --- .gitignore | 13 +- cuda_bindings/AGENTS.md | 12 +- cuda_bindings/build_hooks.py | 269 +- .../cuda/bindings/_bindings/__init__.py | 0 .../bindings/_bindings/cyruntime_ptds.pyx.in | 1939 --- .../runtime.pxd} | 1382 +- .../cuda/bindings/_internal/runtime_linux.pyx | 3288 ++++ .../runtime_ptds.pxd} | 1384 +- .../bindings/_internal/runtime_ptds_linux.pyx | 2262 +++ .../_internal/runtime_ptds_windows.pyx | 2262 +++ .../runtime_windows.pyx} | 2722 ++-- .../bindings/_lib/cyruntime/cyruntime.pxd | 43 +- .../bindings/_lib/cyruntime/cyruntime.pxi | 550 +- cuda_bindings/cuda/bindings/cydriver.pxd | 12 +- cuda_bindings/cuda/bindings/cynvrtc.pxd | 4 +- cuda_bindings/cuda/bindings/cyruntime.pxd | 2662 ++++ cuda_bindings/cuda/bindings/cyruntime.pxd.in | 2095 --- .../{cyruntime.pyx.in => cyruntime.pyx} | 1707 +-- .../cuda/bindings/cyruntime_functions.pxi.in | 1619 -- .../cuda/bindings/cyruntime_types.pxi.in | 1778 --- .../bindings/{runtime.pxd.in => runtime.pxd} | 3246 ++-- .../bindings/{runtime.pyx.in => runtime.pyx} | 12350 +++++++--------- .../docs/source/environment_variables.rst | 2 - cuda_bindings/pixi.toml | 5 - cuda_bindings/pyproject.toml | 1 - 25 files changed, 19757 insertions(+), 21850 deletions(-) delete mode 100644 cuda_bindings/cuda/bindings/_bindings/__init__.py delete mode 100644 cuda_bindings/cuda/bindings/_bindings/cyruntime_ptds.pyx.in rename cuda_bindings/cuda/bindings/{_bindings/cyruntime.pxd.in => _internal/runtime.pxd} (69%) create mode 100644 cuda_bindings/cuda/bindings/_internal/runtime_linux.pyx rename cuda_bindings/cuda/bindings/{_bindings/cyruntime_ptds.pxd.in => _internal/runtime_ptds.pxd} (68%) create mode 100644 cuda_bindings/cuda/bindings/_internal/runtime_ptds_linux.pyx create mode 100644 cuda_bindings/cuda/bindings/_internal/runtime_ptds_windows.pyx rename cuda_bindings/cuda/bindings/{_bindings/cyruntime.pyx.in => _internal/runtime_windows.pyx} (50%) create mode 100644 cuda_bindings/cuda/bindings/cyruntime.pxd delete mode 100644 cuda_bindings/cuda/bindings/cyruntime.pxd.in rename cuda_bindings/cuda/bindings/{cyruntime.pyx.in => cyruntime.pyx} (52%) delete mode 100644 cuda_bindings/cuda/bindings/cyruntime_functions.pxi.in delete mode 100644 cuda_bindings/cuda/bindings/cyruntime_types.pxi.in rename cuda_bindings/cuda/bindings/{runtime.pxd.in => runtime.pxd} (63%) rename cuda_bindings/cuda/bindings/{runtime.pyx.in => runtime.pyx} (85%) diff --git a/.gitignore b/.gitignore index a66da355940..6b6a7dfc0b5 100644 --- a/.gitignore +++ b/.gitignore @@ -25,10 +25,7 @@ cuda_core/tests/test_binaries/*.a cuda_core/tests/test_binaries/*.lib # CUDA Python specific (auto-generated) -cuda_bindings/cuda/bindings/_bindings/cyruntime.pxd -cuda_bindings/cuda/bindings/_bindings/cyruntime.pyx -cuda_bindings/cuda/bindings/_bindings/cyruntime_ptds.pxd -cuda_bindings/cuda/bindings/_bindings/cyruntime_ptds.pyx +cuda_bindings/cuda/bindings/_internal/cudla.pyx cuda_bindings/cuda/bindings/_internal/driver.pyx cuda_bindings/cuda/bindings/_internal/nvrtc.pyx cuda_bindings/cuda/bindings/_internal/cufile.pyx @@ -36,12 +33,8 @@ cuda_bindings/cuda/bindings/_internal/nvfatbin.pyx cuda_bindings/cuda/bindings/_internal/nvjitlink.pyx cuda_bindings/cuda/bindings/_internal/nvml.pyx cuda_bindings/cuda/bindings/_internal/nvvm.pyx -cuda_bindings/cuda/bindings/cyruntime.pxd -cuda_bindings/cuda/bindings/cyruntime.pyx -cuda_bindings/cuda/bindings/cyruntime_functions.pxi -cuda_bindings/cuda/bindings/cyruntime_types.pxi -cuda_bindings/cuda/bindings/runtime.pxd -cuda_bindings/cuda/bindings/runtime.pyx +cuda_bindings/cuda/bindings/_internal/runtime.pyx +cuda_bindings/cuda/bindings/_internal/runtime_ptds.pyx cuda_bindings/cuda/bindings/utils/_get_handle.pyx # Version files from setuptools_scm diff --git a/cuda_bindings/AGENTS.md b/cuda_bindings/AGENTS.md index d9324997a9f..12267ad12d0 100644 --- a/cuda_bindings/AGENTS.md +++ b/cuda_bindings/AGENTS.md @@ -18,21 +18,18 @@ subpackage in the `cuda-python` monorepo. glue and loader helpers used by public modules. - **Platform internals**: `cuda/bindings/_internal/` contains platform-specific implementation files and support code. -- **Build/codegen backend**: `build_hooks.py` drives header parsing, template - expansion, extension configuration, and Cythonization. +- **Build backend**: `build_hooks.py` drives extension configuration and + Cythonization. ## Generated-source workflow - **Do not hand-edit generated binding files**: many files under - `cuda/bindings/` (including `*.pyx`, `*.pxd`, `*.pyx.in`, and `*.pxd.in`) - are generated artifacts. + `cuda/bindings/` (including `*.pyx` and `*.pxd`) are generated artifacts. - **Generated files are synchronized from another repository**: changes to these files in this repo are expected to be overwritten by the next sync. - **If generated output must change**: make the change at the generation source and sync the updated artifacts back here, rather than patching generated files directly in this repo. -- **Header-driven generation**: parser behavior and required CUDA headers are - defined in `build_hooks.py`; update those rules when introducing new symbols. - **Platform split files**: keep `_linux.pyx` and `_windows.pyx` variants aligned when behavior should be equivalent. @@ -48,9 +45,8 @@ subpackage in the `cuda-python` monorepo. ## Build and environment notes - `CUDA_HOME` or `CUDA_PATH` must point to a valid CUDA Toolkit for source - builds that parse headers. + builds. - `CUDA_PYTHON_PARALLEL_LEVEL` controls build parallelism. -- `CUDA_PYTHON_PARSER_CACHING` controls parser-cache behavior during generation. - Runtime behavior is affected by `CUDA_PYTHON_CUDA_PER_THREAD_DEFAULT_STREAM` and `CUDA_PYTHON_DISABLE_MAJOR_VERSION_WARNING`. diff --git a/cuda_bindings/build_hooks.py b/cuda_bindings/build_hooks.py index 36ec44416f8..f2a73b07218 100644 --- a/cuda_bindings/build_hooks.py +++ b/cuda_bindings/build_hooks.py @@ -2,7 +2,7 @@ # SPDX-License-Identifier: Apache-2.0 # This module implements basic PEP 517 backend support to defer CUDA-dependent -# logic (header parsing, code generation, cythonization) to build time. See: +# logic (cythonization) to build time. See: # - https://peps.python.org/pep-0517/ # - https://setuptools.pypa.io/en/latest/build_meta.html#dynamic-build-dependencies-and-other-build-meta-tweaks # - https://github.com/NVIDIA/cuda-python/issues/1635 @@ -74,207 +74,6 @@ def _get_cuda_path() -> str: return cuda_path -# ----------------------------------------------------------------------- -# Header parsing helpers (called only from _build_cuda_bindings) - -_REQUIRED_HEADERS = { - "runtime": [ - "driver_types.h", - "vector_types.h", - "cuda_runtime.h", - "surface_types.h", - "texture_types.h", - "library_types.h", - "cuda_runtime_api.h", - "device_types.h", - "driver_functions.h", - "cuda_profiler_api.h", - ], - # nvrtc: headers no longer parsed at build time (pre-generated by cybind). - # During compilation, Cython will reference C headers that are not - # explicitly parsed above. These are the known dependencies: - # - # - crt/host_defines.h - # - builtin_types.h - # - cuda_device_runtime_api.h -} - - -class _Struct: - def __init__(self, name, members): - self._name = name - self._member_names = [] - self._member_types = [] - self._member_declarators = [] - for var_name, var_type, _ in members: - base_type = var_type[0] - base_type = base_type.removeprefix("struct ") - base_type = base_type.removeprefix("union ") - - self._member_names += [var_name] - self._member_types += [base_type] - self._member_declarators += [tuple(var_type[1:])] - - def member_type(self, member_name): - try: - return self._member_types[self._member_names.index(member_name)] - except ValueError: - return None - - def member_array_length(self, member_name): - try: - declarators = self._member_declarators[self._member_names.index(member_name)] - except ValueError: - return None - - for declarator in declarators: - if isinstance(declarator, list) and len(declarator) == 1: - return declarator[0] - return None - - def discoverMembers(self, memberDict, prefix, seen=None): - if seen is None: - seen = set() - elif self._name in seen: - return [] - - discovered = [] - next_seen = set(seen) - next_seen.add(self._name) - - for memberName, memberType in zip(self._member_names, self._member_types): - if memberName: - discovered.append(".".join([prefix, memberName])) - - t = memberType.replace("const ", "").replace("volatile ", "").strip().rstrip(" *") - if t in memberDict and t != self._name: - discovered += memberDict[t].discoverMembers( - memberDict, discovered[-1] if memberName else prefix, next_seen - ) - - return discovered - - def __repr__(self): - return f"{self._name}: {self._member_names} with types {self._member_types}" - - -def _fetch_header_paths(required_headers, include_path_list): - header_dict = {} - missing_headers = [] - for library, header_list in required_headers.items(): - header_paths = [] - for header in header_list: - path_candidate = [os.path.join(path, header) for path in include_path_list] - for path in path_candidate: - if os.path.exists(path): - header_paths += [path] - break - else: - missing_headers += [header] - - header_dict[library] = header_paths - - if missing_headers: - error_message = "Couldn't find required headers: " - error_message += ", ".join(missing_headers) - cuda_path = _get_cuda_path() - raise RuntimeError(f'{error_message}\nIs CUDA_PATH setup correctly? (CUDA_PATH="{cuda_path}")') - - return header_dict - - -def _parse_headers(header_dict, include_path_list, parser_caching): - from pyclibrary import CParser - - found_types = [] - found_functions = [] - found_values = [] - found_struct = [] - struct_list = {} - - replace = { - " __device_builtin__ ": " ", - "CUDARTAPI ": " ", - "typedef __device_builtin__ enum cudaError cudaError_t;": "typedef cudaError cudaError_t;", - "typedef __device_builtin__ enum cudaOutputMode cudaOutputMode_t;": "typedef cudaOutputMode cudaOutputMode_t;", - "typedef enum cudaError cudaError_t;": "typedef cudaError cudaError_t;", - "typedef enum cudaOutputMode cudaOutputMode_t;": "typedef cudaOutputMode cudaOutputMode_t;", - "typedef enum cudaDataType_t cudaDataType_t;": "", - "typedef enum libraryPropertyType_t libraryPropertyType_t;": "", - " enum ": " ", - ", enum ": ", ", - "\\(enum ": "(", - # Since we only support 64 bit architectures, we can inline the sizeof(T*) to 8 and then compute the - # result in Python. The arithmetic expression is preserved to help with clarity and understanding - r"char reserved\[52 - sizeof\(CUcheckpointGpuPair \*\)\];": rf"char reserved[{52 - 8}];", - r"char reserved\[64 - sizeof\(CUcheckpointGpuPair \*\) - sizeof\(unsigned int\)\];": rf"char reserved[{64 - 8 - 4}];", - } - - print(f'Parsing headers in "{include_path_list}" (Caching = {parser_caching})', flush=True) - for library, header_paths in header_dict.items(): - print(f"Parsing {library} headers", flush=True) - parser = CParser( - header_paths, cache="./cache_{}".format(library.split(".")[0]) if parser_caching else None, replace=replace - ) - - if library == "driver": - CUDA_VERSION = parser.defs["macros"].get("CUDA_VERSION", "Unknown") - print(f"Found CUDA_VERSION: {CUDA_VERSION}", flush=True) - - found_types += set(parser.defs["types"]) - found_types += set(parser.defs["structs"]) - found_types += set(parser.defs["unions"]) - found_types += set(parser.defs["enums"]) - found_functions += set(parser.defs["functions"]) - found_values += set(parser.defs["values"]) - - for key, value in parser.defs["structs"].items(): - struct_list[key] = _Struct(key, value["members"]) - for key, value in parser.defs["unions"].items(): - struct_list[key] = _Struct(key, value["members"]) - - for key, value in struct_list.items(): - if key.startswith(("anon_union", "anon_struct")): - continue - - found_struct += [key] - discovered = value.discoverMembers(struct_list, key) - if discovered: - found_struct += discovered - - # TODO(#1312): make this work properly - found_types.append("CUstreamAtomicReductionDataType_enum") - - return found_types, found_functions, found_values, found_struct, struct_list - - -# ----------------------------------------------------------------------- -# Code generation helpers - - -def _fetch_input_files(path): - return [os.path.join(path, f) for f in os.listdir(path) if f.endswith(".in")] - - -def _generate_output(infile, template_vars): - from Cython import Tempita - - assert infile.endswith(".in") - outfile = infile[:-3] - - with open(infile, encoding="utf-8") as f: - pxdcontent = Tempita.Template(f.read()).substitute(template_vars) - - if os.path.exists(outfile): - with open(outfile, encoding="utf-8") as f: - if f.read() == pxdcontent: - print(f"Skipping {infile} (No change)", flush=True) - return - with open(outfile, "w", encoding="utf-8") as f: - print(f"Generating {infile}", flush=True) - f.write(pxdcontent) - - # ----------------------------------------------------------------------- # Extension preparation helpers @@ -328,9 +127,8 @@ def _prep_extensions(sources, libraries, include_dirs, library_dirs, extra_compi def _build_cuda_bindings(debug=False): """Build all cuda-bindings extensions. - All CUDA-dependent logic (header parsing, code generation, cythonization) - is deferred to this function so that metadata queries do not require a - CUDA toolkit installation. + All CUDA-dependent logic (cythonization) is deferred to this function so + that metadata queries do not require a CUDA toolkit installation. """ from Cython.Build import cythonize @@ -348,54 +146,10 @@ def _build_cuda_bindings(debug=False): else: nthreads = int(os.environ.get("CUDA_PYTHON_PARALLEL_LEVEL", "0") or "0") - parser_caching = bool(os.environ.get("CUDA_PYTHON_PARSER_CACHING", False)) compile_for_coverage = bool(int(os.environ.get("CUDA_PYTHON_COVERAGE", "0"))) - # Parse CUDA headers - include_path_list = [os.path.join(cuda_path, "include")] - header_dict = _fetch_header_paths(_REQUIRED_HEADERS, include_path_list) - found_types, found_functions, found_values, found_struct, struct_list = _parse_headers( - header_dict, include_path_list, parser_caching - ) - struct_field_types = {} - struct_field_array_lengths = {} - for struct_name, struct in struct_list.items(): - for member_name in struct._member_names: - key = f"{struct_name}.{member_name}" - struct_field_types[key] = struct.member_type(member_name) - struct_field_array_lengths[key] = struct.member_array_length(member_name) - - # Generate code from .in templates - path_list = [ - os.path.join("cuda"), - os.path.join("cuda", "bindings"), - os.path.join("cuda", "bindings", "_bindings"), - os.path.join("cuda", "bindings", "_internal"), - os.path.join("cuda", "bindings", "_lib"), - os.path.join("cuda", "bindings", "utils"), - ] - input_files = [] - for path in path_list: - input_files += _fetch_input_files(path) - - import platform - - template_vars = { - "found_types": found_types, - "found_functions": found_functions, - "found_values": found_values, - "found_struct": found_struct, - "struct_list": struct_list, - "struct_field_types": struct_field_types, - "struct_field_array_lengths": struct_field_array_lengths, - "os": os, - "sys": sys, - "platform": platform, - } - for file in input_files: - _generate_output(file, template_vars) - # Prepare compile/link arguments + include_path_list = [os.path.join(cuda_path, "include")] include_dirs = [ os.path.dirname(sysconfig.get_path("include")), ] + include_path_list @@ -442,21 +196,26 @@ def _cleanup_dst_files(): # Build extension list extensions = [] - static_runtime_libraries = ["cudart_static", "rt"] if sys.platform == "linux" else ["cudart_static"] cuda_bindings_files = glob.glob("cuda/bindings/*.pyx") if sys.platform == "win32": cuda_bindings_files = [f for f in cuda_bindings_files if "cufile" not in f] + + def get_static_libraries(f): + if os.path.basename(f) in ("runtime.pyx", "runtime_ptds.pyx"): + if sys.platform == "linux": + return ["cudart_static", "rt"] + else: + return ["cudart_static"] + return None + sources_list = [ - # private - (["cuda/bindings/_bindings/cyruntime.pyx"], static_runtime_libraries), - (["cuda/bindings/_bindings/cyruntime_ptds.pyx"], static_runtime_libraries), # utils (["cuda/bindings/utils/*.pyx"], None), # public *(([f], None) for f in cuda_bindings_files), # internal files used by generated bindings (["cuda/bindings/_internal/utils.pyx"], None), - *(([f], None) for f in dst_files if f.endswith(".pyx")), + *(([f], get_static_libraries(f)) for f in dst_files if f.endswith(".pyx")), ] for sources, libraries in sources_list: diff --git a/cuda_bindings/cuda/bindings/_bindings/__init__.py b/cuda_bindings/cuda/bindings/_bindings/__init__.py deleted file mode 100644 index e69de29bb2d..00000000000 diff --git a/cuda_bindings/cuda/bindings/_bindings/cyruntime_ptds.pyx.in b/cuda_bindings/cuda/bindings/_bindings/cyruntime_ptds.pyx.in deleted file mode 100644 index c69f8a4fda2..00000000000 --- a/cuda_bindings/cuda/bindings/_bindings/cyruntime_ptds.pyx.in +++ /dev/null @@ -1,1939 +0,0 @@ -# SPDX-FileCopyrightText: Copyright (c) 2021-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-License-Identifier: Apache-2.0 - -# This code was automatically generated with version 13.3.0. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=1e1b93a907c72767d54e7b740e3e3a1b7b629b111af47d22c94b587b769bab9c -cdef extern from "": - """ - #define CUDA_API_PER_THREAD_DEFAULT_STREAM - """ - -include "../cyruntime_functions.pxi" - -cimport cython - -{{if 'cudaDeviceReset' in found_functions}} - -cdef cudaError_t _cudaDeviceReset() except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaDeviceReset() -{{endif}} - -{{if 'cudaDeviceSynchronize' in found_functions}} - -cdef cudaError_t _cudaDeviceSynchronize() except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaDeviceSynchronize() -{{endif}} - -{{if 'cudaDeviceSetLimit' in found_functions}} - -cdef cudaError_t _cudaDeviceSetLimit(cudaLimit limit, size_t value) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaDeviceSetLimit(limit, value) -{{endif}} - -{{if 'cudaDeviceGetLimit' in found_functions}} - -cdef cudaError_t _cudaDeviceGetLimit(size_t* pValue, cudaLimit limit) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaDeviceGetLimit(pValue, limit) -{{endif}} - -{{if 'cudaDeviceGetTexture1DLinearMaxWidth' in found_functions}} - -cdef cudaError_t _cudaDeviceGetTexture1DLinearMaxWidth(size_t* maxWidthInElements, const cudaChannelFormatDesc* fmtDesc, int device) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaDeviceGetTexture1DLinearMaxWidth(maxWidthInElements, fmtDesc, device) -{{endif}} - -{{if 'cudaDeviceGetCacheConfig' in found_functions}} - -cdef cudaError_t _cudaDeviceGetCacheConfig(cudaFuncCache* pCacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaDeviceGetCacheConfig(pCacheConfig) -{{endif}} - -{{if 'cudaDeviceGetStreamPriorityRange' in found_functions}} - -cdef cudaError_t _cudaDeviceGetStreamPriorityRange(int* leastPriority, int* greatestPriority) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaDeviceGetStreamPriorityRange(leastPriority, greatestPriority) -{{endif}} - -{{if 'cudaDeviceSetCacheConfig' in found_functions}} - -cdef cudaError_t _cudaDeviceSetCacheConfig(cudaFuncCache cacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaDeviceSetCacheConfig(cacheConfig) -{{endif}} - -{{if 'cudaDeviceGetByPCIBusId' in found_functions}} - -cdef cudaError_t _cudaDeviceGetByPCIBusId(int* device, const char* pciBusId) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaDeviceGetByPCIBusId(device, pciBusId) -{{endif}} - -{{if 'cudaDeviceGetPCIBusId' in found_functions}} - -cdef cudaError_t _cudaDeviceGetPCIBusId(char* pciBusId, int length, int device) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaDeviceGetPCIBusId(pciBusId, length, device) -{{endif}} - -{{if 'cudaIpcGetEventHandle' in found_functions}} - -cdef cudaError_t _cudaIpcGetEventHandle(cudaIpcEventHandle_t* handle, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaIpcGetEventHandle(handle, event) -{{endif}} - -{{if 'cudaIpcOpenEventHandle' in found_functions}} - -cdef cudaError_t _cudaIpcOpenEventHandle(cudaEvent_t* event, cudaIpcEventHandle_t handle) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaIpcOpenEventHandle(event, handle) -{{endif}} - -{{if 'cudaIpcGetMemHandle' in found_functions}} - -cdef cudaError_t _cudaIpcGetMemHandle(cudaIpcMemHandle_t* handle, void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaIpcGetMemHandle(handle, devPtr) -{{endif}} - -{{if 'cudaIpcOpenMemHandle' in found_functions}} - -cdef cudaError_t _cudaIpcOpenMemHandle(void** devPtr, cudaIpcMemHandle_t handle, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaIpcOpenMemHandle(devPtr, handle, flags) -{{endif}} - -{{if 'cudaIpcCloseMemHandle' in found_functions}} - -cdef cudaError_t _cudaIpcCloseMemHandle(void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaIpcCloseMemHandle(devPtr) -{{endif}} - -{{if 'cudaDeviceFlushGPUDirectRDMAWrites' in found_functions}} - -cdef cudaError_t _cudaDeviceFlushGPUDirectRDMAWrites(cudaFlushGPUDirectRDMAWritesTarget target, cudaFlushGPUDirectRDMAWritesScope scope) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaDeviceFlushGPUDirectRDMAWrites(target, scope) -{{endif}} - -{{if 'cudaDeviceRegisterAsyncNotification' in found_functions}} - -cdef cudaError_t _cudaDeviceRegisterAsyncNotification(int device, cudaAsyncCallback callbackFunc, void* userData, cudaAsyncCallbackHandle_t* callback) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaDeviceRegisterAsyncNotification(device, callbackFunc, userData, callback) -{{endif}} - -{{if 'cudaDeviceUnregisterAsyncNotification' in found_functions}} - -cdef cudaError_t _cudaDeviceUnregisterAsyncNotification(int device, cudaAsyncCallbackHandle_t callback) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaDeviceUnregisterAsyncNotification(device, callback) -{{endif}} - -{{if 'cudaDeviceGetSharedMemConfig' in found_functions}} - -cdef cudaError_t _cudaDeviceGetSharedMemConfig(cudaSharedMemConfig* pConfig) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaDeviceGetSharedMemConfig(pConfig) -{{endif}} - -{{if 'cudaDeviceSetSharedMemConfig' in found_functions}} - -cdef cudaError_t _cudaDeviceSetSharedMemConfig(cudaSharedMemConfig config) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaDeviceSetSharedMemConfig(config) -{{endif}} - -{{if 'cudaGetLastError' in found_functions}} - -cdef cudaError_t _cudaGetLastError() except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGetLastError() -{{endif}} - -{{if 'cudaPeekAtLastError' in found_functions}} - -cdef cudaError_t _cudaPeekAtLastError() except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaPeekAtLastError() -{{endif}} - -{{if 'cudaGetErrorName' in found_functions}} - -cdef const char* _cudaGetErrorName(cudaError_t error) except ?NULL nogil: - return cudaGetErrorName(error) -{{endif}} - -{{if 'cudaGetErrorString' in found_functions}} - -cdef const char* _cudaGetErrorString(cudaError_t error) except ?NULL nogil: - return cudaGetErrorString(error) -{{endif}} - -{{if 'cudaGetDeviceCount' in found_functions}} - -cdef cudaError_t _cudaGetDeviceCount(int* count) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGetDeviceCount(count) -{{endif}} - -{{if 'cudaGetDeviceProperties' in found_functions}} - -cdef cudaError_t _cudaGetDeviceProperties(cudaDeviceProp* prop, int device) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGetDeviceProperties(prop, device) -{{endif}} - -{{if 'cudaDeviceGetAttribute' in found_functions}} - -cdef cudaError_t _cudaDeviceGetAttribute(int* value, cudaDeviceAttr attr, int device) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaDeviceGetAttribute(value, attr, device) -{{endif}} - -{{if 'cudaDeviceGetHostAtomicCapabilities' in found_functions}} - -cdef cudaError_t _cudaDeviceGetHostAtomicCapabilities(unsigned int* capabilities, const cudaAtomicOperation* operations, unsigned int count, int device) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaDeviceGetHostAtomicCapabilities(capabilities, operations, count, device) -{{endif}} - -{{if 'cudaDeviceGetDefaultMemPool' in found_functions}} - -cdef cudaError_t _cudaDeviceGetDefaultMemPool(cudaMemPool_t* memPool, int device) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaDeviceGetDefaultMemPool(memPool, device) -{{endif}} - -{{if 'cudaDeviceSetMemPool' in found_functions}} - -cdef cudaError_t _cudaDeviceSetMemPool(int device, cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaDeviceSetMemPool(device, memPool) -{{endif}} - -{{if 'cudaDeviceGetMemPool' in found_functions}} - -cdef cudaError_t _cudaDeviceGetMemPool(cudaMemPool_t* memPool, int device) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaDeviceGetMemPool(memPool, device) -{{endif}} - -{{if 'cudaDeviceGetNvSciSyncAttributes' in found_functions}} - -cdef cudaError_t _cudaDeviceGetNvSciSyncAttributes(void* nvSciSyncAttrList, int device, int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaDeviceGetNvSciSyncAttributes(nvSciSyncAttrList, device, flags) -{{endif}} - -{{if 'cudaDeviceGetP2PAttribute' in found_functions}} - -cdef cudaError_t _cudaDeviceGetP2PAttribute(int* value, cudaDeviceP2PAttr attr, int srcDevice, int dstDevice) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaDeviceGetP2PAttribute(value, attr, srcDevice, dstDevice) -{{endif}} - -{{if 'cudaDeviceGetP2PAtomicCapabilities' in found_functions}} - -cdef cudaError_t _cudaDeviceGetP2PAtomicCapabilities(unsigned int* capabilities, const cudaAtomicOperation* operations, unsigned int count, int srcDevice, int dstDevice) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaDeviceGetP2PAtomicCapabilities(capabilities, operations, count, srcDevice, dstDevice) -{{endif}} - -{{if 'cudaChooseDevice' in found_functions}} - -cdef cudaError_t _cudaChooseDevice(int* device, const cudaDeviceProp* prop) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaChooseDevice(device, prop) -{{endif}} - -{{if 'cudaInitDevice' in found_functions}} - -cdef cudaError_t _cudaInitDevice(int device, unsigned int deviceFlags, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaInitDevice(device, deviceFlags, flags) -{{endif}} - -{{if 'cudaSetDevice' in found_functions}} - -cdef cudaError_t _cudaSetDevice(int device) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaSetDevice(device) -{{endif}} - -{{if 'cudaGetDevice' in found_functions}} - -cdef cudaError_t _cudaGetDevice(int* device) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGetDevice(device) -{{endif}} - -{{if 'cudaSetDeviceFlags' in found_functions}} - -cdef cudaError_t _cudaSetDeviceFlags(unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaSetDeviceFlags(flags) -{{endif}} - -{{if 'cudaGetDeviceFlags' in found_functions}} - -cdef cudaError_t _cudaGetDeviceFlags(unsigned int* flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGetDeviceFlags(flags) -{{endif}} - -{{if 'cudaStreamCreate' in found_functions}} - -cdef cudaError_t _cudaStreamCreate(cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaStreamCreate(pStream) -{{endif}} - -{{if 'cudaStreamCreateWithFlags' in found_functions}} - -cdef cudaError_t _cudaStreamCreateWithFlags(cudaStream_t* pStream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaStreamCreateWithFlags(pStream, flags) -{{endif}} - -{{if 'cudaStreamCreateWithPriority' in found_functions}} - -cdef cudaError_t _cudaStreamCreateWithPriority(cudaStream_t* pStream, unsigned int flags, int priority) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaStreamCreateWithPriority(pStream, flags, priority) -{{endif}} - -{{if 'cudaStreamGetPriority' in found_functions}} - -cdef cudaError_t _cudaStreamGetPriority(cudaStream_t hStream, int* priority) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaStreamGetPriority(hStream, priority) -{{endif}} - -{{if 'cudaStreamGetFlags' in found_functions}} - -cdef cudaError_t _cudaStreamGetFlags(cudaStream_t hStream, unsigned int* flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaStreamGetFlags(hStream, flags) -{{endif}} - -{{if 'cudaStreamGetId' in found_functions}} - -cdef cudaError_t _cudaStreamGetId(cudaStream_t hStream, unsigned long long* streamId) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaStreamGetId(hStream, streamId) -{{endif}} - -{{if 'cudaStreamGetDevice' in found_functions}} - -cdef cudaError_t _cudaStreamGetDevice(cudaStream_t hStream, int* device) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaStreamGetDevice(hStream, device) -{{endif}} - -{{if 'cudaCtxResetPersistingL2Cache' in found_functions}} - -cdef cudaError_t _cudaCtxResetPersistingL2Cache() except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaCtxResetPersistingL2Cache() -{{endif}} - -{{if 'cudaStreamCopyAttributes' in found_functions}} - -cdef cudaError_t _cudaStreamCopyAttributes(cudaStream_t dst, cudaStream_t src) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaStreamCopyAttributes(dst, src) -{{endif}} - -{{if 'cudaStreamGetAttribute' in found_functions}} - -cdef cudaError_t _cudaStreamGetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, cudaStreamAttrValue* value_out) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaStreamGetAttribute(hStream, attr, value_out) -{{endif}} - -{{if 'cudaStreamSetAttribute' in found_functions}} - -cdef cudaError_t _cudaStreamSetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, const cudaStreamAttrValue* value) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaStreamSetAttribute(hStream, attr, value) -{{endif}} - -{{if 'cudaStreamDestroy' in found_functions}} - -cdef cudaError_t _cudaStreamDestroy(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaStreamDestroy(stream) -{{endif}} - -{{if 'cudaStreamWaitEvent' in found_functions}} - -cdef cudaError_t _cudaStreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaStreamWaitEvent(stream, event, flags) -{{endif}} - -{{if 'cudaStreamAddCallback' in found_functions}} - -cdef cudaError_t _cudaStreamAddCallback(cudaStream_t stream, cudaStreamCallback_t callback, void* userData, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaStreamAddCallback(stream, callback, userData, flags) -{{endif}} - -{{if 'cudaStreamSynchronize' in found_functions}} - -cdef cudaError_t _cudaStreamSynchronize(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaStreamSynchronize(stream) -{{endif}} - -{{if 'cudaStreamQuery' in found_functions}} - -cdef cudaError_t _cudaStreamQuery(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaStreamQuery(stream) -{{endif}} - -{{if 'cudaStreamAttachMemAsync' in found_functions}} - -cdef cudaError_t _cudaStreamAttachMemAsync(cudaStream_t stream, void* devPtr, size_t length, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaStreamAttachMemAsync(stream, devPtr, length, flags) -{{endif}} - -{{if 'cudaStreamBeginCapture' in found_functions}} - -cdef cudaError_t _cudaStreamBeginCapture(cudaStream_t stream, cudaStreamCaptureMode mode) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaStreamBeginCapture(stream, mode) -{{endif}} - -{{if 'cudaStreamBeginRecaptureToGraph' in found_functions}} - -cdef cudaError_t _cudaStreamBeginRecaptureToGraph(cudaStream_t stream, cudaStreamCaptureMode mode, cudaGraph_t graph, cudaGraphRecaptureCallbackData* callbackData) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaStreamBeginRecaptureToGraph(stream, mode, graph, callbackData) -{{endif}} - -{{if 'cudaStreamBeginCaptureToGraph' in found_functions}} - -cdef cudaError_t _cudaStreamBeginCaptureToGraph(cudaStream_t stream, cudaGraph_t graph, const cudaGraphNode_t* dependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, cudaStreamCaptureMode mode) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaStreamBeginCaptureToGraph(stream, graph, dependencies, dependencyData, numDependencies, mode) -{{endif}} - -{{if 'cudaThreadExchangeStreamCaptureMode' in found_functions}} - -cdef cudaError_t _cudaThreadExchangeStreamCaptureMode(cudaStreamCaptureMode* mode) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaThreadExchangeStreamCaptureMode(mode) -{{endif}} - -{{if 'cudaStreamEndCapture' in found_functions}} - -cdef cudaError_t _cudaStreamEndCapture(cudaStream_t stream, cudaGraph_t* pGraph) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaStreamEndCapture(stream, pGraph) -{{endif}} - -{{if 'cudaStreamIsCapturing' in found_functions}} - -cdef cudaError_t _cudaStreamIsCapturing(cudaStream_t stream, cudaStreamCaptureStatus* pCaptureStatus) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaStreamIsCapturing(stream, pCaptureStatus) -{{endif}} - -{{if 'cudaStreamGetCaptureInfo' in found_functions}} - -cdef cudaError_t _cudaStreamGetCaptureInfo(cudaStream_t stream, cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out, cudaGraph_t* graph_out, const cudaGraphNode_t** dependencies_out, const cudaGraphEdgeData** edgeData_out, size_t* numDependencies_out) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaStreamGetCaptureInfo(stream, captureStatus_out, id_out, graph_out, dependencies_out, edgeData_out, numDependencies_out) -{{endif}} - -{{if 'cudaStreamUpdateCaptureDependencies' in found_functions}} - -cdef cudaError_t _cudaStreamUpdateCaptureDependencies(cudaStream_t stream, cudaGraphNode_t* dependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaStreamUpdateCaptureDependencies(stream, dependencies, dependencyData, numDependencies, flags) -{{endif}} - -{{if 'cudaEventCreate' in found_functions}} - -cdef cudaError_t _cudaEventCreate(cudaEvent_t* event) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaEventCreate(event) -{{endif}} - -{{if 'cudaEventCreateWithFlags' in found_functions}} - -cdef cudaError_t _cudaEventCreateWithFlags(cudaEvent_t* event, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaEventCreateWithFlags(event, flags) -{{endif}} - -{{if 'cudaEventRecord' in found_functions}} - -cdef cudaError_t _cudaEventRecord(cudaEvent_t event, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaEventRecord(event, stream) -{{endif}} - -{{if 'cudaEventRecordWithFlags' in found_functions}} - -cdef cudaError_t _cudaEventRecordWithFlags(cudaEvent_t event, cudaStream_t stream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaEventRecordWithFlags(event, stream, flags) -{{endif}} - -{{if 'cudaEventQuery' in found_functions}} - -cdef cudaError_t _cudaEventQuery(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaEventQuery(event) -{{endif}} - -{{if 'cudaEventSynchronize' in found_functions}} - -cdef cudaError_t _cudaEventSynchronize(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaEventSynchronize(event) -{{endif}} - -{{if 'cudaEventDestroy' in found_functions}} - -cdef cudaError_t _cudaEventDestroy(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaEventDestroy(event) -{{endif}} - -{{if 'cudaEventElapsedTime' in found_functions}} - -cdef cudaError_t _cudaEventElapsedTime(float* ms, cudaEvent_t start, cudaEvent_t end) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaEventElapsedTime(ms, start, end) -{{endif}} - -{{if 'cudaImportExternalMemory' in found_functions}} - -cdef cudaError_t _cudaImportExternalMemory(cudaExternalMemory_t* extMem_out, const cudaExternalMemoryHandleDesc* memHandleDesc) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaImportExternalMemory(extMem_out, memHandleDesc) -{{endif}} - -{{if 'cudaExternalMemoryGetMappedBuffer' in found_functions}} - -cdef cudaError_t _cudaExternalMemoryGetMappedBuffer(void** devPtr, cudaExternalMemory_t extMem, const cudaExternalMemoryBufferDesc* bufferDesc) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaExternalMemoryGetMappedBuffer(devPtr, extMem, bufferDesc) -{{endif}} - -{{if 'cudaExternalMemoryGetMappedMipmappedArray' in found_functions}} - -cdef cudaError_t _cudaExternalMemoryGetMappedMipmappedArray(cudaMipmappedArray_t* mipmap, cudaExternalMemory_t extMem, const cudaExternalMemoryMipmappedArrayDesc* mipmapDesc) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaExternalMemoryGetMappedMipmappedArray(mipmap, extMem, mipmapDesc) -{{endif}} - -{{if 'cudaDestroyExternalMemory' in found_functions}} - -cdef cudaError_t _cudaDestroyExternalMemory(cudaExternalMemory_t extMem) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaDestroyExternalMemory(extMem) -{{endif}} - -{{if 'cudaImportExternalSemaphore' in found_functions}} - -cdef cudaError_t _cudaImportExternalSemaphore(cudaExternalSemaphore_t* extSem_out, const cudaExternalSemaphoreHandleDesc* semHandleDesc) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaImportExternalSemaphore(extSem_out, semHandleDesc) -{{endif}} - -{{if 'cudaSignalExternalSemaphoresAsync' in found_functions}} - -cdef cudaError_t _cudaSignalExternalSemaphoresAsync(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreSignalParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaSignalExternalSemaphoresAsync(extSemArray, paramsArray, numExtSems, stream) -{{endif}} - -{{if 'cudaWaitExternalSemaphoresAsync' in found_functions}} - -cdef cudaError_t _cudaWaitExternalSemaphoresAsync(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreWaitParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaWaitExternalSemaphoresAsync(extSemArray, paramsArray, numExtSems, stream) -{{endif}} - -{{if 'cudaDestroyExternalSemaphore' in found_functions}} - -cdef cudaError_t _cudaDestroyExternalSemaphore(cudaExternalSemaphore_t extSem) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaDestroyExternalSemaphore(extSem) -{{endif}} - -{{if 'cudaFuncSetCacheConfig' in found_functions}} - -cdef cudaError_t _cudaFuncSetCacheConfig(const void* func, cudaFuncCache cacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaFuncSetCacheConfig(func, cacheConfig) -{{endif}} - -{{if 'cudaFuncGetAttributes' in found_functions}} - -cdef cudaError_t _cudaFuncGetAttributes(cudaFuncAttributes* attr, const void* func) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaFuncGetAttributes(attr, func) -{{endif}} - -{{if 'cudaFuncSetAttribute' in found_functions}} - -cdef cudaError_t _cudaFuncSetAttribute(const void* func, cudaFuncAttribute attr, int value) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaFuncSetAttribute(func, attr, value) -{{endif}} - -{{if 'cudaFuncGetParamCount' in found_functions}} - -cdef cudaError_t _cudaFuncGetParamCount(const void* func, size_t* paramCount) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaFuncGetParamCount(func, paramCount) -{{endif}} - -{{if 'cudaLaunchHostFunc' in found_functions}} - -cdef cudaError_t _cudaLaunchHostFunc(cudaStream_t stream, cudaHostFn_t fn, void* userData) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaLaunchHostFunc(stream, fn, userData) -{{endif}} - -{{if 'cudaLaunchHostFunc_v2' in found_functions}} - -cdef cudaError_t _cudaLaunchHostFunc_v2(cudaStream_t stream, cudaHostFn_t fn, void* userData, unsigned int syncMode) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaLaunchHostFunc_v2(stream, fn, userData, syncMode) -{{endif}} - -{{if 'cudaFuncSetSharedMemConfig' in found_functions}} - -cdef cudaError_t _cudaFuncSetSharedMemConfig(const void* func, cudaSharedMemConfig config) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaFuncSetSharedMemConfig(func, config) -{{endif}} - -{{if 'cudaOccupancyMaxActiveBlocksPerMultiprocessor' in found_functions}} - -cdef cudaError_t _cudaOccupancyMaxActiveBlocksPerMultiprocessor(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaOccupancyMaxActiveBlocksPerMultiprocessor(numBlocks, func, blockSize, dynamicSMemSize) -{{endif}} - -{{if 'cudaOccupancyAvailableDynamicSMemPerBlock' in found_functions}} - -cdef cudaError_t _cudaOccupancyAvailableDynamicSMemPerBlock(size_t* dynamicSmemSize, const void* func, int numBlocks, int blockSize) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaOccupancyAvailableDynamicSMemPerBlock(dynamicSmemSize, func, numBlocks, blockSize) -{{endif}} - -{{if 'cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags' in found_functions}} - -cdef cudaError_t _cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(numBlocks, func, blockSize, dynamicSMemSize, flags) -{{endif}} - -{{if 'cudaMallocManaged' in found_functions}} - -cdef cudaError_t _cudaMallocManaged(void** devPtr, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMallocManaged(devPtr, size, flags) -{{endif}} - -{{if 'cudaMalloc' in found_functions}} - -cdef cudaError_t _cudaMalloc(void** devPtr, size_t size) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMalloc(devPtr, size) -{{endif}} - -{{if 'cudaMallocHost' in found_functions}} - -cdef cudaError_t _cudaMallocHost(void** ptr, size_t size) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMallocHost(ptr, size) -{{endif}} - -{{if 'cudaMallocPitch' in found_functions}} - -cdef cudaError_t _cudaMallocPitch(void** devPtr, size_t* pitch, size_t width, size_t height) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMallocPitch(devPtr, pitch, width, height) -{{endif}} - -{{if 'cudaMallocArray' in found_functions}} - -cdef cudaError_t _cudaMallocArray(cudaArray_t* array, const cudaChannelFormatDesc* desc, size_t width, size_t height, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMallocArray(array, desc, width, height, flags) -{{endif}} - -{{if 'cudaFree' in found_functions}} - -cdef cudaError_t _cudaFree(void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaFree(devPtr) -{{endif}} - -{{if 'cudaFreeHost' in found_functions}} - -cdef cudaError_t _cudaFreeHost(void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaFreeHost(ptr) -{{endif}} - -{{if 'cudaFreeArray' in found_functions}} - -cdef cudaError_t _cudaFreeArray(cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaFreeArray(array) -{{endif}} - -{{if 'cudaFreeMipmappedArray' in found_functions}} - -cdef cudaError_t _cudaFreeMipmappedArray(cudaMipmappedArray_t mipmappedArray) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaFreeMipmappedArray(mipmappedArray) -{{endif}} - -{{if 'cudaHostAlloc' in found_functions}} - -cdef cudaError_t _cudaHostAlloc(void** pHost, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaHostAlloc(pHost, size, flags) -{{endif}} - -{{if 'cudaHostRegister' in found_functions}} - -cdef cudaError_t _cudaHostRegister(void* ptr, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaHostRegister(ptr, size, flags) -{{endif}} - -{{if 'cudaHostUnregister' in found_functions}} - -cdef cudaError_t _cudaHostUnregister(void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaHostUnregister(ptr) -{{endif}} - -{{if 'cudaHostGetDevicePointer' in found_functions}} - -cdef cudaError_t _cudaHostGetDevicePointer(void** pDevice, void* pHost, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaHostGetDevicePointer(pDevice, pHost, flags) -{{endif}} - -{{if 'cudaHostGetFlags' in found_functions}} - -cdef cudaError_t _cudaHostGetFlags(unsigned int* pFlags, void* pHost) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaHostGetFlags(pFlags, pHost) -{{endif}} - -{{if 'cudaMalloc3D' in found_functions}} - -cdef cudaError_t _cudaMalloc3D(cudaPitchedPtr* pitchedDevPtr, cudaExtent extent) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMalloc3D(pitchedDevPtr, extent) -{{endif}} - -{{if 'cudaMalloc3DArray' in found_functions}} - -cdef cudaError_t _cudaMalloc3DArray(cudaArray_t* array, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMalloc3DArray(array, desc, extent, flags) -{{endif}} - -{{if 'cudaMallocMipmappedArray' in found_functions}} - -cdef cudaError_t _cudaMallocMipmappedArray(cudaMipmappedArray_t* mipmappedArray, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int numLevels, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMallocMipmappedArray(mipmappedArray, desc, extent, numLevels, flags) -{{endif}} - -{{if 'cudaGetMipmappedArrayLevel' in found_functions}} - -cdef cudaError_t _cudaGetMipmappedArrayLevel(cudaArray_t* levelArray, cudaMipmappedArray_const_t mipmappedArray, unsigned int level) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGetMipmappedArrayLevel(levelArray, mipmappedArray, level) -{{endif}} - -{{if 'cudaMemcpy3D' in found_functions}} - -cdef cudaError_t _cudaMemcpy3D(const cudaMemcpy3DParms* p) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemcpy3D(p) -{{endif}} - -{{if 'cudaMemcpy3DPeer' in found_functions}} - -cdef cudaError_t _cudaMemcpy3DPeer(const cudaMemcpy3DPeerParms* p) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemcpy3DPeer(p) -{{endif}} - -{{if 'cudaMemcpy3DAsync' in found_functions}} - -cdef cudaError_t _cudaMemcpy3DAsync(const cudaMemcpy3DParms* p, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemcpy3DAsync(p, stream) -{{endif}} - -{{if 'cudaMemcpy3DPeerAsync' in found_functions}} - -cdef cudaError_t _cudaMemcpy3DPeerAsync(const cudaMemcpy3DPeerParms* p, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemcpy3DPeerAsync(p, stream) -{{endif}} - -{{if 'cudaMemGetInfo' in found_functions}} - -cdef cudaError_t _cudaMemGetInfo(size_t* free, size_t* total) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemGetInfo(free, total) -{{endif}} - -{{if 'cudaArrayGetInfo' in found_functions}} - -cdef cudaError_t _cudaArrayGetInfo(cudaChannelFormatDesc* desc, cudaExtent* extent, unsigned int* flags, cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaArrayGetInfo(desc, extent, flags, array) -{{endif}} - -{{if 'cudaArrayGetPlane' in found_functions}} - -cdef cudaError_t _cudaArrayGetPlane(cudaArray_t* pPlaneArray, cudaArray_t hArray, unsigned int planeIdx) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaArrayGetPlane(pPlaneArray, hArray, planeIdx) -{{endif}} - -{{if 'cudaArrayGetMemoryRequirements' in found_functions}} - -cdef cudaError_t _cudaArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaArray_t array, int device) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaArrayGetMemoryRequirements(memoryRequirements, array, device) -{{endif}} - -{{if 'cudaMipmappedArrayGetMemoryRequirements' in found_functions}} - -cdef cudaError_t _cudaMipmappedArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaMipmappedArray_t mipmap, int device) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMipmappedArrayGetMemoryRequirements(memoryRequirements, mipmap, device) -{{endif}} - -{{if 'cudaArrayGetSparseProperties' in found_functions}} - -cdef cudaError_t _cudaArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaArrayGetSparseProperties(sparseProperties, array) -{{endif}} - -{{if 'cudaMipmappedArrayGetSparseProperties' in found_functions}} - -cdef cudaError_t _cudaMipmappedArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaMipmappedArray_t mipmap) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMipmappedArrayGetSparseProperties(sparseProperties, mipmap) -{{endif}} - -{{if 'cudaMemcpy' in found_functions}} - -cdef cudaError_t _cudaMemcpy(void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemcpy(dst, src, count, kind) -{{endif}} - -{{if 'cudaMemcpyPeer' in found_functions}} - -cdef cudaError_t _cudaMemcpyPeer(void* dst, int dstDevice, const void* src, int srcDevice, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemcpyPeer(dst, dstDevice, src, srcDevice, count) -{{endif}} - -{{if 'cudaMemcpy2D' in found_functions}} - -cdef cudaError_t _cudaMemcpy2D(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemcpy2D(dst, dpitch, src, spitch, width, height, kind) -{{endif}} - -{{if 'cudaMemcpy2DToArray' in found_functions}} - -cdef cudaError_t _cudaMemcpy2DToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemcpy2DToArray(dst, wOffset, hOffset, src, spitch, width, height, kind) -{{endif}} - -{{if 'cudaMemcpy2DFromArray' in found_functions}} - -cdef cudaError_t _cudaMemcpy2DFromArray(void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemcpy2DFromArray(dst, dpitch, src, wOffset, hOffset, width, height, kind) -{{endif}} - -{{if 'cudaMemcpy2DArrayToArray' in found_functions}} - -cdef cudaError_t _cudaMemcpy2DArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemcpy2DArrayToArray(dst, wOffsetDst, hOffsetDst, src, wOffsetSrc, hOffsetSrc, width, height, kind) -{{endif}} - -{{if 'cudaMemcpyAsync' in found_functions}} - -cdef cudaError_t _cudaMemcpyAsync(void* dst, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemcpyAsync(dst, src, count, kind, stream) -{{endif}} - -{{if 'cudaMemcpyPeerAsync' in found_functions}} - -cdef cudaError_t _cudaMemcpyPeerAsync(void* dst, int dstDevice, const void* src, int srcDevice, size_t count, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemcpyPeerAsync(dst, dstDevice, src, srcDevice, count, stream) -{{endif}} - -{{if 'cudaMemcpyBatchAsync' in found_functions}} - -cdef cudaError_t _cudaMemcpyBatchAsync(const void** dsts, const void** srcs, const size_t* sizes, size_t count, cudaMemcpyAttributes* attrs, size_t* attrsIdxs, size_t numAttrs, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemcpyBatchAsync(dsts, srcs, sizes, count, attrs, attrsIdxs, numAttrs, stream) -{{endif}} - -{{if 'cudaMemcpy3DBatchAsync' in found_functions}} - -cdef cudaError_t _cudaMemcpy3DBatchAsync(size_t numOps, cudaMemcpy3DBatchOp* opList, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemcpy3DBatchAsync(numOps, opList, flags, stream) -{{endif}} - -{{if 'cudaMemcpyWithAttributesAsync' in found_functions}} - -cdef cudaError_t _cudaMemcpyWithAttributesAsync(void* dst, const void* src, size_t size, cudaMemcpyAttributes* attr, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemcpyWithAttributesAsync(dst, src, size, attr, stream) -{{endif}} - -{{if 'cudaMemcpy3DWithAttributesAsync' in found_functions}} - -cdef cudaError_t _cudaMemcpy3DWithAttributesAsync(cudaMemcpy3DBatchOp* op, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemcpy3DWithAttributesAsync(op, flags, stream) -{{endif}} - -{{if 'cudaMemcpy2DAsync' in found_functions}} - -cdef cudaError_t _cudaMemcpy2DAsync(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemcpy2DAsync(dst, dpitch, src, spitch, width, height, kind, stream) -{{endif}} - -{{if 'cudaMemcpy2DToArrayAsync' in found_functions}} - -cdef cudaError_t _cudaMemcpy2DToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemcpy2DToArrayAsync(dst, wOffset, hOffset, src, spitch, width, height, kind, stream) -{{endif}} - -{{if 'cudaMemcpy2DFromArrayAsync' in found_functions}} - -cdef cudaError_t _cudaMemcpy2DFromArrayAsync(void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemcpy2DFromArrayAsync(dst, dpitch, src, wOffset, hOffset, width, height, kind, stream) -{{endif}} - -{{if 'cudaMemset' in found_functions}} - -cdef cudaError_t _cudaMemset(void* devPtr, int value, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemset(devPtr, value, count) -{{endif}} - -{{if 'cudaMemset2D' in found_functions}} - -cdef cudaError_t _cudaMemset2D(void* devPtr, size_t pitch, int value, size_t width, size_t height) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemset2D(devPtr, pitch, value, width, height) -{{endif}} - -{{if 'cudaMemset3D' in found_functions}} - -cdef cudaError_t _cudaMemset3D(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemset3D(pitchedDevPtr, value, extent) -{{endif}} - -{{if 'cudaMemsetAsync' in found_functions}} - -cdef cudaError_t _cudaMemsetAsync(void* devPtr, int value, size_t count, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemsetAsync(devPtr, value, count, stream) -{{endif}} - -{{if 'cudaMemset2DAsync' in found_functions}} - -cdef cudaError_t _cudaMemset2DAsync(void* devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemset2DAsync(devPtr, pitch, value, width, height, stream) -{{endif}} - -{{if 'cudaMemset3DAsync' in found_functions}} - -cdef cudaError_t _cudaMemset3DAsync(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemset3DAsync(pitchedDevPtr, value, extent, stream) -{{endif}} - -{{if 'cudaMemPrefetchAsync' in found_functions}} - -cdef cudaError_t _cudaMemPrefetchAsync(const void* devPtr, size_t count, cudaMemLocation location, unsigned int flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemPrefetchAsync(devPtr, count, location, flags, stream) -{{endif}} - -{{if 'cudaMemPrefetchBatchAsync' in found_functions}} - -cdef cudaError_t _cudaMemPrefetchBatchAsync(void** dptrs, size_t* sizes, size_t count, cudaMemLocation* prefetchLocs, size_t* prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemPrefetchBatchAsync(dptrs, sizes, count, prefetchLocs, prefetchLocIdxs, numPrefetchLocs, flags, stream) -{{endif}} - -{{if 'cudaMemDiscardBatchAsync' in found_functions}} - -cdef cudaError_t _cudaMemDiscardBatchAsync(void** dptrs, size_t* sizes, size_t count, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemDiscardBatchAsync(dptrs, sizes, count, flags, stream) -{{endif}} - -{{if 'cudaMemDiscardAndPrefetchBatchAsync' in found_functions}} - -cdef cudaError_t _cudaMemDiscardAndPrefetchBatchAsync(void** dptrs, size_t* sizes, size_t count, cudaMemLocation* prefetchLocs, size_t* prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemDiscardAndPrefetchBatchAsync(dptrs, sizes, count, prefetchLocs, prefetchLocIdxs, numPrefetchLocs, flags, stream) -{{endif}} - -{{if 'cudaMemAdvise' in found_functions}} - -cdef cudaError_t _cudaMemAdvise(const void* devPtr, size_t count, cudaMemoryAdvise advice, cudaMemLocation location) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemAdvise(devPtr, count, advice, location) -{{endif}} - -{{if 'cudaMemRangeGetAttribute' in found_functions}} - -cdef cudaError_t _cudaMemRangeGetAttribute(void* data, size_t dataSize, cudaMemRangeAttribute attribute, const void* devPtr, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemRangeGetAttribute(data, dataSize, attribute, devPtr, count) -{{endif}} - -{{if 'cudaMemRangeGetAttributes' in found_functions}} - -cdef cudaError_t _cudaMemRangeGetAttributes(void** data, size_t* dataSizes, cudaMemRangeAttribute* attributes, size_t numAttributes, const void* devPtr, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemRangeGetAttributes(data, dataSizes, attributes, numAttributes, devPtr, count) -{{endif}} - -{{if 'cudaMemcpyToArray' in found_functions}} - -cdef cudaError_t _cudaMemcpyToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemcpyToArray(dst, wOffset, hOffset, src, count, kind) -{{endif}} - -{{if 'cudaMemcpyFromArray' in found_functions}} - -cdef cudaError_t _cudaMemcpyFromArray(void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemcpyFromArray(dst, src, wOffset, hOffset, count, kind) -{{endif}} - -{{if 'cudaMemcpyArrayToArray' in found_functions}} - -cdef cudaError_t _cudaMemcpyArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemcpyArrayToArray(dst, wOffsetDst, hOffsetDst, src, wOffsetSrc, hOffsetSrc, count, kind) -{{endif}} - -{{if 'cudaMemcpyToArrayAsync' in found_functions}} - -cdef cudaError_t _cudaMemcpyToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemcpyToArrayAsync(dst, wOffset, hOffset, src, count, kind, stream) -{{endif}} - -{{if 'cudaMemcpyFromArrayAsync' in found_functions}} - -cdef cudaError_t _cudaMemcpyFromArrayAsync(void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemcpyFromArrayAsync(dst, src, wOffset, hOffset, count, kind, stream) -{{endif}} - -{{if 'cudaMallocAsync' in found_functions}} - -cdef cudaError_t _cudaMallocAsync(void** devPtr, size_t size, cudaStream_t hStream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMallocAsync(devPtr, size, hStream) -{{endif}} - -{{if 'cudaFreeAsync' in found_functions}} - -cdef cudaError_t _cudaFreeAsync(void* devPtr, cudaStream_t hStream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaFreeAsync(devPtr, hStream) -{{endif}} - -{{if 'cudaMemPoolTrimTo' in found_functions}} - -cdef cudaError_t _cudaMemPoolTrimTo(cudaMemPool_t memPool, size_t minBytesToKeep) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemPoolTrimTo(memPool, minBytesToKeep) -{{endif}} - -{{if 'cudaMemPoolSetAttribute' in found_functions}} - -cdef cudaError_t _cudaMemPoolSetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemPoolSetAttribute(memPool, attr, value) -{{endif}} - -{{if 'cudaMemPoolGetAttribute' in found_functions}} - -cdef cudaError_t _cudaMemPoolGetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemPoolGetAttribute(memPool, attr, value) -{{endif}} - -{{if 'cudaMemPoolSetAccess' in found_functions}} - -cdef cudaError_t _cudaMemPoolSetAccess(cudaMemPool_t memPool, const cudaMemAccessDesc* descList, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemPoolSetAccess(memPool, descList, count) -{{endif}} - -{{if 'cudaMemPoolGetAccess' in found_functions}} - -cdef cudaError_t _cudaMemPoolGetAccess(cudaMemAccessFlags* flags, cudaMemPool_t memPool, cudaMemLocation* location) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemPoolGetAccess(flags, memPool, location) -{{endif}} - -{{if 'cudaMemPoolCreate' in found_functions}} - -cdef cudaError_t _cudaMemPoolCreate(cudaMemPool_t* memPool, const cudaMemPoolProps* poolProps) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemPoolCreate(memPool, poolProps) -{{endif}} - -{{if 'cudaMemPoolDestroy' in found_functions}} - -cdef cudaError_t _cudaMemPoolDestroy(cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemPoolDestroy(memPool) -{{endif}} - -{{if 'cudaMemGetDefaultMemPool' in found_functions}} - -cdef cudaError_t _cudaMemGetDefaultMemPool(cudaMemPool_t* memPool, cudaMemLocation* location, cudaMemAllocationType typename) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemGetDefaultMemPool(memPool, location, typename) -{{endif}} - -{{if 'cudaMemGetMemPool' in found_functions}} - -cdef cudaError_t _cudaMemGetMemPool(cudaMemPool_t* memPool, cudaMemLocation* location, cudaMemAllocationType typename) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemGetMemPool(memPool, location, typename) -{{endif}} - -{{if 'cudaMemSetMemPool' in found_functions}} - -cdef cudaError_t _cudaMemSetMemPool(cudaMemLocation* location, cudaMemAllocationType typename, cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemSetMemPool(location, typename, memPool) -{{endif}} - -{{if 'cudaMallocFromPoolAsync' in found_functions}} - -cdef cudaError_t _cudaMallocFromPoolAsync(void** ptr, size_t size, cudaMemPool_t memPool, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMallocFromPoolAsync(ptr, size, memPool, stream) -{{endif}} - -{{if 'cudaMemPoolExportToShareableHandle' in found_functions}} - -cdef cudaError_t _cudaMemPoolExportToShareableHandle(void* shareableHandle, cudaMemPool_t memPool, cudaMemAllocationHandleType handleType, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemPoolExportToShareableHandle(shareableHandle, memPool, handleType, flags) -{{endif}} - -{{if 'cudaMemPoolImportFromShareableHandle' in found_functions}} - -cdef cudaError_t _cudaMemPoolImportFromShareableHandle(cudaMemPool_t* memPool, void* shareableHandle, cudaMemAllocationHandleType handleType, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemPoolImportFromShareableHandle(memPool, shareableHandle, handleType, flags) -{{endif}} - -{{if 'cudaMemPoolExportPointer' in found_functions}} - -cdef cudaError_t _cudaMemPoolExportPointer(cudaMemPoolPtrExportData* exportData, void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemPoolExportPointer(exportData, ptr) -{{endif}} - -{{if 'cudaMemPoolImportPointer' in found_functions}} - -cdef cudaError_t _cudaMemPoolImportPointer(void** ptr, cudaMemPool_t memPool, cudaMemPoolPtrExportData* exportData) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaMemPoolImportPointer(ptr, memPool, exportData) -{{endif}} - -{{if 'cudaPointerGetAttributes' in found_functions}} - -cdef cudaError_t _cudaPointerGetAttributes(cudaPointerAttributes* attributes, const void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaPointerGetAttributes(attributes, ptr) -{{endif}} - -{{if 'cudaDeviceCanAccessPeer' in found_functions}} - -cdef cudaError_t _cudaDeviceCanAccessPeer(int* canAccessPeer, int device, int peerDevice) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaDeviceCanAccessPeer(canAccessPeer, device, peerDevice) -{{endif}} - -{{if 'cudaDeviceEnablePeerAccess' in found_functions}} - -cdef cudaError_t _cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaDeviceEnablePeerAccess(peerDevice, flags) -{{endif}} - -{{if 'cudaDeviceDisablePeerAccess' in found_functions}} - -cdef cudaError_t _cudaDeviceDisablePeerAccess(int peerDevice) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaDeviceDisablePeerAccess(peerDevice) -{{endif}} - -{{if 'cudaGraphicsUnregisterResource' in found_functions}} - -cdef cudaError_t _cudaGraphicsUnregisterResource(cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphicsUnregisterResource(resource) -{{endif}} - -{{if 'cudaGraphicsResourceSetMapFlags' in found_functions}} - -cdef cudaError_t _cudaGraphicsResourceSetMapFlags(cudaGraphicsResource_t resource, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphicsResourceSetMapFlags(resource, flags) -{{endif}} - -{{if 'cudaGraphicsMapResources' in found_functions}} - -cdef cudaError_t _cudaGraphicsMapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphicsMapResources(count, resources, stream) -{{endif}} - -{{if 'cudaGraphicsUnmapResources' in found_functions}} - -cdef cudaError_t _cudaGraphicsUnmapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphicsUnmapResources(count, resources, stream) -{{endif}} - -{{if 'cudaGraphicsResourceGetMappedPointer' in found_functions}} - -cdef cudaError_t _cudaGraphicsResourceGetMappedPointer(void** devPtr, size_t* size, cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphicsResourceGetMappedPointer(devPtr, size, resource) -{{endif}} - -{{if 'cudaGraphicsSubResourceGetMappedArray' in found_functions}} - -cdef cudaError_t _cudaGraphicsSubResourceGetMappedArray(cudaArray_t* array, cudaGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphicsSubResourceGetMappedArray(array, resource, arrayIndex, mipLevel) -{{endif}} - -{{if 'cudaGraphicsResourceGetMappedMipmappedArray' in found_functions}} - -cdef cudaError_t _cudaGraphicsResourceGetMappedMipmappedArray(cudaMipmappedArray_t* mipmappedArray, cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphicsResourceGetMappedMipmappedArray(mipmappedArray, resource) -{{endif}} - -{{if 'cudaGetChannelDesc' in found_functions}} - -cdef cudaError_t _cudaGetChannelDesc(cudaChannelFormatDesc* desc, cudaArray_const_t array) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGetChannelDesc(desc, array) -{{endif}} - -{{if 'cudaCreateChannelDesc' in found_functions}} -@cython.show_performance_hints(False) -cdef cudaChannelFormatDesc _cudaCreateChannelDesc(int x, int y, int z, int w, cudaChannelFormatKind f) except* nogil: - return cudaCreateChannelDesc(x, y, z, w, f) -{{endif}} - -{{if 'cudaCreateTextureObject' in found_functions}} - -cdef cudaError_t _cudaCreateTextureObject(cudaTextureObject_t* pTexObject, const cudaResourceDesc* pResDesc, const cudaTextureDesc* pTexDesc, const cudaResourceViewDesc* pResViewDesc) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaCreateTextureObject(pTexObject, pResDesc, pTexDesc, pResViewDesc) -{{endif}} - -{{if 'cudaDestroyTextureObject' in found_functions}} - -cdef cudaError_t _cudaDestroyTextureObject(cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaDestroyTextureObject(texObject) -{{endif}} - -{{if 'cudaGetTextureObjectResourceDesc' in found_functions}} - -cdef cudaError_t _cudaGetTextureObjectResourceDesc(cudaResourceDesc* pResDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGetTextureObjectResourceDesc(pResDesc, texObject) -{{endif}} - -{{if 'cudaGetTextureObjectTextureDesc' in found_functions}} - -cdef cudaError_t _cudaGetTextureObjectTextureDesc(cudaTextureDesc* pTexDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGetTextureObjectTextureDesc(pTexDesc, texObject) -{{endif}} - -{{if 'cudaGetTextureObjectResourceViewDesc' in found_functions}} - -cdef cudaError_t _cudaGetTextureObjectResourceViewDesc(cudaResourceViewDesc* pResViewDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGetTextureObjectResourceViewDesc(pResViewDesc, texObject) -{{endif}} - -{{if 'cudaCreateSurfaceObject' in found_functions}} - -cdef cudaError_t _cudaCreateSurfaceObject(cudaSurfaceObject_t* pSurfObject, const cudaResourceDesc* pResDesc) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaCreateSurfaceObject(pSurfObject, pResDesc) -{{endif}} - -{{if 'cudaDestroySurfaceObject' in found_functions}} - -cdef cudaError_t _cudaDestroySurfaceObject(cudaSurfaceObject_t surfObject) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaDestroySurfaceObject(surfObject) -{{endif}} - -{{if 'cudaGetSurfaceObjectResourceDesc' in found_functions}} - -cdef cudaError_t _cudaGetSurfaceObjectResourceDesc(cudaResourceDesc* pResDesc, cudaSurfaceObject_t surfObject) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGetSurfaceObjectResourceDesc(pResDesc, surfObject) -{{endif}} - -{{if 'cudaDriverGetVersion' in found_functions}} - -cdef cudaError_t _cudaDriverGetVersion(int* driverVersion) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaDriverGetVersion(driverVersion) -{{endif}} - -{{if 'cudaRuntimeGetVersion' in found_functions}} - -cdef cudaError_t _cudaRuntimeGetVersion(int* runtimeVersion) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaRuntimeGetVersion(runtimeVersion) -{{endif}} - -{{if 'cudaLogsRegisterCallback' in found_functions}} - -cdef cudaError_t _cudaLogsRegisterCallback(cudaLogsCallback_t callbackFunc, void* userData, cudaLogsCallbackHandle* callback_out) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaLogsRegisterCallback(callbackFunc, userData, callback_out) -{{endif}} - -{{if 'cudaLogsUnregisterCallback' in found_functions}} - -cdef cudaError_t _cudaLogsUnregisterCallback(cudaLogsCallbackHandle callback) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaLogsUnregisterCallback(callback) -{{endif}} - -{{if 'cudaLogsCurrent' in found_functions}} - -cdef cudaError_t _cudaLogsCurrent(cudaLogIterator* iterator_out, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaLogsCurrent(iterator_out, flags) -{{endif}} - -{{if 'cudaLogsDumpToFile' in found_functions}} - -cdef cudaError_t _cudaLogsDumpToFile(cudaLogIterator* iterator, const char* pathToFile, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaLogsDumpToFile(iterator, pathToFile, flags) -{{endif}} - -{{if 'cudaLogsDumpToMemory' in found_functions}} - -cdef cudaError_t _cudaLogsDumpToMemory(cudaLogIterator* iterator, char* buffer, size_t* size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaLogsDumpToMemory(iterator, buffer, size, flags) -{{endif}} - -{{if 'cudaGraphCreate' in found_functions}} - -cdef cudaError_t _cudaGraphCreate(cudaGraph_t* pGraph, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphCreate(pGraph, flags) -{{endif}} - -{{if 'cudaGraphAddKernelNode' in found_functions}} - -cdef cudaError_t _cudaGraphAddKernelNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphAddKernelNode(pGraphNode, graph, pDependencies, numDependencies, pNodeParams) -{{endif}} - -{{if 'cudaGraphKernelNodeGetParams' in found_functions}} - -cdef cudaError_t _cudaGraphKernelNodeGetParams(cudaGraphNode_t node, cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphKernelNodeGetParams(node, pNodeParams) -{{endif}} - -{{if 'cudaGraphKernelNodeSetParams' in found_functions}} - -cdef cudaError_t _cudaGraphKernelNodeSetParams(cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphKernelNodeSetParams(node, pNodeParams) -{{endif}} - -{{if 'cudaGraphKernelNodeCopyAttributes' in found_functions}} - -cdef cudaError_t _cudaGraphKernelNodeCopyAttributes(cudaGraphNode_t hDst, cudaGraphNode_t hSrc) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphKernelNodeCopyAttributes(hDst, hSrc) -{{endif}} - -{{if 'cudaGraphKernelNodeGetAttribute' in found_functions}} - -cdef cudaError_t _cudaGraphKernelNodeGetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, cudaKernelNodeAttrValue* value_out) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphKernelNodeGetAttribute(hNode, attr, value_out) -{{endif}} - -{{if 'cudaGraphKernelNodeSetAttribute' in found_functions}} - -cdef cudaError_t _cudaGraphKernelNodeSetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, const cudaKernelNodeAttrValue* value) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphKernelNodeSetAttribute(hNode, attr, value) -{{endif}} - -{{if 'cudaGraphAddMemcpyNode' in found_functions}} - -cdef cudaError_t _cudaGraphAddMemcpyNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemcpy3DParms* pCopyParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphAddMemcpyNode(pGraphNode, graph, pDependencies, numDependencies, pCopyParams) -{{endif}} - -{{if 'cudaGraphAddMemcpyNode1D' in found_functions}} - -cdef cudaError_t _cudaGraphAddMemcpyNode1D(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphAddMemcpyNode1D(pGraphNode, graph, pDependencies, numDependencies, dst, src, count, kind) -{{endif}} - -{{if 'cudaGraphMemcpyNodeGetParams' in found_functions}} - -cdef cudaError_t _cudaGraphMemcpyNodeGetParams(cudaGraphNode_t node, cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphMemcpyNodeGetParams(node, pNodeParams) -{{endif}} - -{{if 'cudaGraphMemcpyNodeSetParams' in found_functions}} - -cdef cudaError_t _cudaGraphMemcpyNodeSetParams(cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphMemcpyNodeSetParams(node, pNodeParams) -{{endif}} - -{{if 'cudaGraphMemcpyNodeSetParams1D' in found_functions}} - -cdef cudaError_t _cudaGraphMemcpyNodeSetParams1D(cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphMemcpyNodeSetParams1D(node, dst, src, count, kind) -{{endif}} - -{{if 'cudaGraphAddMemsetNode' in found_functions}} - -cdef cudaError_t _cudaGraphAddMemsetNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemsetParams* pMemsetParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphAddMemsetNode(pGraphNode, graph, pDependencies, numDependencies, pMemsetParams) -{{endif}} - -{{if 'cudaGraphMemsetNodeGetParams' in found_functions}} - -cdef cudaError_t _cudaGraphMemsetNodeGetParams(cudaGraphNode_t node, cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphMemsetNodeGetParams(node, pNodeParams) -{{endif}} - -{{if 'cudaGraphMemsetNodeSetParams' in found_functions}} - -cdef cudaError_t _cudaGraphMemsetNodeSetParams(cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphMemsetNodeSetParams(node, pNodeParams) -{{endif}} - -{{if 'cudaGraphAddHostNode' in found_functions}} - -cdef cudaError_t _cudaGraphAddHostNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphAddHostNode(pGraphNode, graph, pDependencies, numDependencies, pNodeParams) -{{endif}} - -{{if 'cudaGraphHostNodeGetParams' in found_functions}} - -cdef cudaError_t _cudaGraphHostNodeGetParams(cudaGraphNode_t node, cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphHostNodeGetParams(node, pNodeParams) -{{endif}} - -{{if 'cudaGraphHostNodeSetParams' in found_functions}} - -cdef cudaError_t _cudaGraphHostNodeSetParams(cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphHostNodeSetParams(node, pNodeParams) -{{endif}} - -{{if 'cudaGraphAddChildGraphNode' in found_functions}} - -cdef cudaError_t _cudaGraphAddChildGraphNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaGraph_t childGraph) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphAddChildGraphNode(pGraphNode, graph, pDependencies, numDependencies, childGraph) -{{endif}} - -{{if 'cudaGraphChildGraphNodeGetGraph' in found_functions}} - -cdef cudaError_t _cudaGraphChildGraphNodeGetGraph(cudaGraphNode_t node, cudaGraph_t* pGraph) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphChildGraphNodeGetGraph(node, pGraph) -{{endif}} - -{{if 'cudaGraphAddEmptyNode' in found_functions}} - -cdef cudaError_t _cudaGraphAddEmptyNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphAddEmptyNode(pGraphNode, graph, pDependencies, numDependencies) -{{endif}} - -{{if 'cudaGraphAddEventRecordNode' in found_functions}} - -cdef cudaError_t _cudaGraphAddEventRecordNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphAddEventRecordNode(pGraphNode, graph, pDependencies, numDependencies, event) -{{endif}} - -{{if 'cudaGraphEventRecordNodeGetEvent' in found_functions}} - -cdef cudaError_t _cudaGraphEventRecordNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphEventRecordNodeGetEvent(node, event_out) -{{endif}} - -{{if 'cudaGraphEventRecordNodeSetEvent' in found_functions}} - -cdef cudaError_t _cudaGraphEventRecordNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphEventRecordNodeSetEvent(node, event) -{{endif}} - -{{if 'cudaGraphAddEventWaitNode' in found_functions}} - -cdef cudaError_t _cudaGraphAddEventWaitNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphAddEventWaitNode(pGraphNode, graph, pDependencies, numDependencies, event) -{{endif}} - -{{if 'cudaGraphEventWaitNodeGetEvent' in found_functions}} - -cdef cudaError_t _cudaGraphEventWaitNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphEventWaitNodeGetEvent(node, event_out) -{{endif}} - -{{if 'cudaGraphEventWaitNodeSetEvent' in found_functions}} - -cdef cudaError_t _cudaGraphEventWaitNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphEventWaitNodeSetEvent(node, event) -{{endif}} - -{{if 'cudaGraphAddExternalSemaphoresSignalNode' in found_functions}} - -cdef cudaError_t _cudaGraphAddExternalSemaphoresSignalNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphAddExternalSemaphoresSignalNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams) -{{endif}} - -{{if 'cudaGraphExternalSemaphoresSignalNodeGetParams' in found_functions}} - -cdef cudaError_t _cudaGraphExternalSemaphoresSignalNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreSignalNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphExternalSemaphoresSignalNodeGetParams(hNode, params_out) -{{endif}} - -{{if 'cudaGraphExternalSemaphoresSignalNodeSetParams' in found_functions}} - -cdef cudaError_t _cudaGraphExternalSemaphoresSignalNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphExternalSemaphoresSignalNodeSetParams(hNode, nodeParams) -{{endif}} - -{{if 'cudaGraphAddExternalSemaphoresWaitNode' in found_functions}} - -cdef cudaError_t _cudaGraphAddExternalSemaphoresWaitNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphAddExternalSemaphoresWaitNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams) -{{endif}} - -{{if 'cudaGraphExternalSemaphoresWaitNodeGetParams' in found_functions}} - -cdef cudaError_t _cudaGraphExternalSemaphoresWaitNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreWaitNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphExternalSemaphoresWaitNodeGetParams(hNode, params_out) -{{endif}} - -{{if 'cudaGraphExternalSemaphoresWaitNodeSetParams' in found_functions}} - -cdef cudaError_t _cudaGraphExternalSemaphoresWaitNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphExternalSemaphoresWaitNodeSetParams(hNode, nodeParams) -{{endif}} - -{{if 'cudaGraphAddMemAllocNode' in found_functions}} - -cdef cudaError_t _cudaGraphAddMemAllocNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaMemAllocNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphAddMemAllocNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams) -{{endif}} - -{{if 'cudaGraphMemAllocNodeGetParams' in found_functions}} - -cdef cudaError_t _cudaGraphMemAllocNodeGetParams(cudaGraphNode_t node, cudaMemAllocNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphMemAllocNodeGetParams(node, params_out) -{{endif}} - -{{if 'cudaGraphAddMemFreeNode' in found_functions}} - -cdef cudaError_t _cudaGraphAddMemFreeNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dptr) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphAddMemFreeNode(pGraphNode, graph, pDependencies, numDependencies, dptr) -{{endif}} - -{{if 'cudaGraphMemFreeNodeGetParams' in found_functions}} - -cdef cudaError_t _cudaGraphMemFreeNodeGetParams(cudaGraphNode_t node, void* dptr_out) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphMemFreeNodeGetParams(node, dptr_out) -{{endif}} - -{{if 'cudaDeviceGraphMemTrim' in found_functions}} - -cdef cudaError_t _cudaDeviceGraphMemTrim(int device) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaDeviceGraphMemTrim(device) -{{endif}} - -{{if 'cudaDeviceGetGraphMemAttribute' in found_functions}} - -cdef cudaError_t _cudaDeviceGetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaDeviceGetGraphMemAttribute(device, attr, value) -{{endif}} - -{{if 'cudaDeviceSetGraphMemAttribute' in found_functions}} - -cdef cudaError_t _cudaDeviceSetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaDeviceSetGraphMemAttribute(device, attr, value) -{{endif}} - -{{if 'cudaGraphClone' in found_functions}} - -cdef cudaError_t _cudaGraphClone(cudaGraph_t* pGraphClone, cudaGraph_t originalGraph) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphClone(pGraphClone, originalGraph) -{{endif}} - -{{if 'cudaGraphNodeFindInClone' in found_functions}} - -cdef cudaError_t _cudaGraphNodeFindInClone(cudaGraphNode_t* pNode, cudaGraphNode_t originalNode, cudaGraph_t clonedGraph) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphNodeFindInClone(pNode, originalNode, clonedGraph) -{{endif}} - -{{if 'cudaGraphNodeGetType' in found_functions}} - -cdef cudaError_t _cudaGraphNodeGetType(cudaGraphNode_t node, cudaGraphNodeType* pType) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphNodeGetType(node, pType) -{{endif}} - -{{if 'cudaGraphNodeGetContainingGraph' in found_functions}} - -cdef cudaError_t _cudaGraphNodeGetContainingGraph(cudaGraphNode_t hNode, cudaGraph_t* phGraph) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphNodeGetContainingGraph(hNode, phGraph) -{{endif}} - -{{if 'cudaGraphNodeGetLocalId' in found_functions}} - -cdef cudaError_t _cudaGraphNodeGetLocalId(cudaGraphNode_t hNode, unsigned int* nodeId) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphNodeGetLocalId(hNode, nodeId) -{{endif}} - -{{if 'cudaGraphNodeGetToolsId' in found_functions}} - -cdef cudaError_t _cudaGraphNodeGetToolsId(cudaGraphNode_t hNode, unsigned long long* toolsNodeId) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphNodeGetToolsId(hNode, toolsNodeId) -{{endif}} - -{{if 'cudaGraphGetId' in found_functions}} - -cdef cudaError_t _cudaGraphGetId(cudaGraph_t hGraph, unsigned int* graphID) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphGetId(hGraph, graphID) -{{endif}} - -{{if 'cudaGraphExecGetId' in found_functions}} - -cdef cudaError_t _cudaGraphExecGetId(cudaGraphExec_t hGraphExec, unsigned int* graphID) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphExecGetId(hGraphExec, graphID) -{{endif}} - -{{if 'cudaGraphGetNodes' in found_functions}} - -cdef cudaError_t _cudaGraphGetNodes(cudaGraph_t graph, cudaGraphNode_t* nodes, size_t* numNodes) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphGetNodes(graph, nodes, numNodes) -{{endif}} - -{{if 'cudaGraphGetRootNodes' in found_functions}} - -cdef cudaError_t _cudaGraphGetRootNodes(cudaGraph_t graph, cudaGraphNode_t* pRootNodes, size_t* pNumRootNodes) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphGetRootNodes(graph, pRootNodes, pNumRootNodes) -{{endif}} - -{{if 'cudaGraphGetEdges' in found_functions}} - -cdef cudaError_t _cudaGraphGetEdges(cudaGraph_t graph, cudaGraphNode_t* from_, cudaGraphNode_t* to, cudaGraphEdgeData* edgeData, size_t* numEdges) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphGetEdges(graph, from_, to, edgeData, numEdges) -{{endif}} - -{{if 'cudaGraphNodeGetDependencies' in found_functions}} - -cdef cudaError_t _cudaGraphNodeGetDependencies(cudaGraphNode_t node, cudaGraphNode_t* pDependencies, cudaGraphEdgeData* edgeData, size_t* pNumDependencies) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphNodeGetDependencies(node, pDependencies, edgeData, pNumDependencies) -{{endif}} - -{{if 'cudaGraphNodeGetDependentNodes' in found_functions}} - -cdef cudaError_t _cudaGraphNodeGetDependentNodes(cudaGraphNode_t node, cudaGraphNode_t* pDependentNodes, cudaGraphEdgeData* edgeData, size_t* pNumDependentNodes) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphNodeGetDependentNodes(node, pDependentNodes, edgeData, pNumDependentNodes) -{{endif}} - -{{if 'cudaGraphAddDependencies' in found_functions}} - -cdef cudaError_t _cudaGraphAddDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, const cudaGraphEdgeData* edgeData, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphAddDependencies(graph, from_, to, edgeData, numDependencies) -{{endif}} - -{{if 'cudaGraphRemoveDependencies' in found_functions}} - -cdef cudaError_t _cudaGraphRemoveDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, const cudaGraphEdgeData* edgeData, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphRemoveDependencies(graph, from_, to, edgeData, numDependencies) -{{endif}} - -{{if 'cudaGraphDestroyNode' in found_functions}} - -cdef cudaError_t _cudaGraphDestroyNode(cudaGraphNode_t node) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphDestroyNode(node) -{{endif}} - -{{if 'cudaGraphInstantiate' in found_functions}} - -cdef cudaError_t _cudaGraphInstantiate(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphInstantiate(pGraphExec, graph, flags) -{{endif}} - -{{if 'cudaGraphInstantiateWithFlags' in found_functions}} - -cdef cudaError_t _cudaGraphInstantiateWithFlags(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphInstantiateWithFlags(pGraphExec, graph, flags) -{{endif}} - -{{if 'cudaGraphInstantiateWithParams' in found_functions}} - -cdef cudaError_t _cudaGraphInstantiateWithParams(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, cudaGraphInstantiateParams* instantiateParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphInstantiateWithParams(pGraphExec, graph, instantiateParams) -{{endif}} - -{{if 'cudaGraphExecGetFlags' in found_functions}} - -cdef cudaError_t _cudaGraphExecGetFlags(cudaGraphExec_t graphExec, unsigned long long* flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphExecGetFlags(graphExec, flags) -{{endif}} - -{{if 'cudaGraphExecKernelNodeSetParams' in found_functions}} - -cdef cudaError_t _cudaGraphExecKernelNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphExecKernelNodeSetParams(hGraphExec, node, pNodeParams) -{{endif}} - -{{if 'cudaGraphExecMemcpyNodeSetParams' in found_functions}} - -cdef cudaError_t _cudaGraphExecMemcpyNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphExecMemcpyNodeSetParams(hGraphExec, node, pNodeParams) -{{endif}} - -{{if 'cudaGraphExecMemcpyNodeSetParams1D' in found_functions}} - -cdef cudaError_t _cudaGraphExecMemcpyNodeSetParams1D(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphExecMemcpyNodeSetParams1D(hGraphExec, node, dst, src, count, kind) -{{endif}} - -{{if 'cudaGraphExecMemsetNodeSetParams' in found_functions}} - -cdef cudaError_t _cudaGraphExecMemsetNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphExecMemsetNodeSetParams(hGraphExec, node, pNodeParams) -{{endif}} - -{{if 'cudaGraphExecHostNodeSetParams' in found_functions}} - -cdef cudaError_t _cudaGraphExecHostNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphExecHostNodeSetParams(hGraphExec, node, pNodeParams) -{{endif}} - -{{if 'cudaGraphExecChildGraphNodeSetParams' in found_functions}} - -cdef cudaError_t _cudaGraphExecChildGraphNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, cudaGraph_t childGraph) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphExecChildGraphNodeSetParams(hGraphExec, node, childGraph) -{{endif}} - -{{if 'cudaGraphExecEventRecordNodeSetEvent' in found_functions}} - -cdef cudaError_t _cudaGraphExecEventRecordNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphExecEventRecordNodeSetEvent(hGraphExec, hNode, event) -{{endif}} - -{{if 'cudaGraphExecEventWaitNodeSetEvent' in found_functions}} - -cdef cudaError_t _cudaGraphExecEventWaitNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphExecEventWaitNodeSetEvent(hGraphExec, hNode, event) -{{endif}} - -{{if 'cudaGraphExecExternalSemaphoresSignalNodeSetParams' in found_functions}} - -cdef cudaError_t _cudaGraphExecExternalSemaphoresSignalNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphExecExternalSemaphoresSignalNodeSetParams(hGraphExec, hNode, nodeParams) -{{endif}} - -{{if 'cudaGraphExecExternalSemaphoresWaitNodeSetParams' in found_functions}} - -cdef cudaError_t _cudaGraphExecExternalSemaphoresWaitNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphExecExternalSemaphoresWaitNodeSetParams(hGraphExec, hNode, nodeParams) -{{endif}} - -{{if 'cudaGraphNodeSetEnabled' in found_functions}} - -cdef cudaError_t _cudaGraphNodeSetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int isEnabled) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphNodeSetEnabled(hGraphExec, hNode, isEnabled) -{{endif}} - -{{if 'cudaGraphNodeGetEnabled' in found_functions}} - -cdef cudaError_t _cudaGraphNodeGetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int* isEnabled) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphNodeGetEnabled(hGraphExec, hNode, isEnabled) -{{endif}} - -{{if 'cudaGraphExecUpdate' in found_functions}} - -cdef cudaError_t _cudaGraphExecUpdate(cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphExecUpdateResultInfo* resultInfo) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphExecUpdate(hGraphExec, hGraph, resultInfo) -{{endif}} - -{{if 'cudaGraphUpload' in found_functions}} - -cdef cudaError_t _cudaGraphUpload(cudaGraphExec_t graphExec, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphUpload(graphExec, stream) -{{endif}} - -{{if 'cudaGraphLaunch' in found_functions}} - -cdef cudaError_t _cudaGraphLaunch(cudaGraphExec_t graphExec, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphLaunch(graphExec, stream) -{{endif}} - -{{if 'cudaGraphExecDestroy' in found_functions}} - -cdef cudaError_t _cudaGraphExecDestroy(cudaGraphExec_t graphExec) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphExecDestroy(graphExec) -{{endif}} - -{{if 'cudaGraphDestroy' in found_functions}} - -cdef cudaError_t _cudaGraphDestroy(cudaGraph_t graph) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphDestroy(graph) -{{endif}} - -{{if 'cudaGraphDebugDotPrint' in found_functions}} - -cdef cudaError_t _cudaGraphDebugDotPrint(cudaGraph_t graph, const char* path, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphDebugDotPrint(graph, path, flags) -{{endif}} - -{{if 'cudaUserObjectCreate' in found_functions}} - -cdef cudaError_t _cudaUserObjectCreate(cudaUserObject_t* object_out, void* ptr, cudaHostFn_t destroy, unsigned int initialRefcount, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaUserObjectCreate(object_out, ptr, destroy, initialRefcount, flags) -{{endif}} - -{{if 'cudaUserObjectRetain' in found_functions}} - -cdef cudaError_t _cudaUserObjectRetain(cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaUserObjectRetain(object, count) -{{endif}} - -{{if 'cudaUserObjectRelease' in found_functions}} - -cdef cudaError_t _cudaUserObjectRelease(cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaUserObjectRelease(object, count) -{{endif}} - -{{if 'cudaGraphRetainUserObject' in found_functions}} - -cdef cudaError_t _cudaGraphRetainUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphRetainUserObject(graph, object, count, flags) -{{endif}} - -{{if 'cudaGraphReleaseUserObject' in found_functions}} - -cdef cudaError_t _cudaGraphReleaseUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphReleaseUserObject(graph, object, count) -{{endif}} - -{{if 'cudaGraphAddNode' in found_functions}} - -cdef cudaError_t _cudaGraphAddNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphAddNode(pGraphNode, graph, pDependencies, dependencyData, numDependencies, nodeParams) -{{endif}} - -{{if 'cudaGraphNodeSetParams' in found_functions}} - -cdef cudaError_t _cudaGraphNodeSetParams(cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphNodeSetParams(node, nodeParams) -{{endif}} - -{{if 'cudaGraphNodeGetParams' in found_functions}} - -cdef cudaError_t _cudaGraphNodeGetParams(cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphNodeGetParams(node, nodeParams) -{{endif}} - -{{if 'cudaGraphExecNodeSetParams' in found_functions}} - -cdef cudaError_t _cudaGraphExecNodeSetParams(cudaGraphExec_t graphExec, cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphExecNodeSetParams(graphExec, node, nodeParams) -{{endif}} - -{{if 'cudaGraphConditionalHandleCreate' in found_functions}} - -cdef cudaError_t _cudaGraphConditionalHandleCreate(cudaGraphConditionalHandle* pHandle_out, cudaGraph_t graph, unsigned int defaultLaunchValue, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphConditionalHandleCreate(pHandle_out, graph, defaultLaunchValue, flags) -{{endif}} - -{{if 'cudaGraphConditionalHandleCreate_v2' in found_functions}} - -cdef cudaError_t _cudaGraphConditionalHandleCreate_v2(cudaGraphConditionalHandle* pHandle_out, cudaGraph_t graph, cudaExecutionContext_t ctx, unsigned int defaultLaunchValue, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGraphConditionalHandleCreate_v2(pHandle_out, graph, ctx, defaultLaunchValue, flags) -{{endif}} - -{{if 'cudaGetDriverEntryPoint' in found_functions}} - -cdef cudaError_t _cudaGetDriverEntryPoint(const char* symbol, void** funcPtr, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGetDriverEntryPoint(symbol, funcPtr, flags, driverStatus) -{{endif}} - -{{if 'cudaGetDriverEntryPointByVersion' in found_functions}} - -cdef cudaError_t _cudaGetDriverEntryPointByVersion(const char* symbol, void** funcPtr, unsigned int cudaVersion, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGetDriverEntryPointByVersion(symbol, funcPtr, cudaVersion, flags, driverStatus) -{{endif}} - -{{if 'cudaLibraryLoadData' in found_functions}} - -cdef cudaError_t _cudaLibraryLoadData(cudaLibrary_t* library, const void* code, cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaLibraryLoadData(library, code, jitOptions, jitOptionsValues, numJitOptions, libraryOptions, libraryOptionValues, numLibraryOptions) -{{endif}} - -{{if 'cudaLibraryLoadFromFile' in found_functions}} - -cdef cudaError_t _cudaLibraryLoadFromFile(cudaLibrary_t* library, const char* fileName, cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaLibraryLoadFromFile(library, fileName, jitOptions, jitOptionsValues, numJitOptions, libraryOptions, libraryOptionValues, numLibraryOptions) -{{endif}} - -{{if 'cudaLibraryUnload' in found_functions}} - -cdef cudaError_t _cudaLibraryUnload(cudaLibrary_t library) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaLibraryUnload(library) -{{endif}} - -{{if 'cudaLibraryGetKernel' in found_functions}} - -cdef cudaError_t _cudaLibraryGetKernel(cudaKernel_t* pKernel, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaLibraryGetKernel(pKernel, library, name) -{{endif}} - -{{if 'cudaLibraryGetGlobal' in found_functions}} - -cdef cudaError_t _cudaLibraryGetGlobal(void** dptr, size_t* numbytes, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaLibraryGetGlobal(dptr, numbytes, library, name) -{{endif}} - -{{if 'cudaLibraryGetManaged' in found_functions}} - -cdef cudaError_t _cudaLibraryGetManaged(void** dptr, size_t* numbytes, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaLibraryGetManaged(dptr, numbytes, library, name) -{{endif}} - -{{if 'cudaLibraryGetUnifiedFunction' in found_functions}} - -cdef cudaError_t _cudaLibraryGetUnifiedFunction(void** fptr, cudaLibrary_t library, const char* symbol) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaLibraryGetUnifiedFunction(fptr, library, symbol) -{{endif}} - -{{if 'cudaLibraryGetKernelCount' in found_functions}} - -cdef cudaError_t _cudaLibraryGetKernelCount(unsigned int* count, cudaLibrary_t lib) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaLibraryGetKernelCount(count, lib) -{{endif}} - -{{if 'cudaLibraryEnumerateKernels' in found_functions}} - -cdef cudaError_t _cudaLibraryEnumerateKernels(cudaKernel_t* kernels, unsigned int numKernels, cudaLibrary_t lib) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaLibraryEnumerateKernels(kernels, numKernels, lib) -{{endif}} - -{{if 'cudaKernelSetAttributeForDevice' in found_functions}} - -cdef cudaError_t _cudaKernelSetAttributeForDevice(cudaKernel_t kernel, cudaFuncAttribute attr, int value, int device) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaKernelSetAttributeForDevice(kernel, attr, value, device) -{{endif}} - -{{if 'cudaDeviceGetDevResource' in found_functions}} - -cdef cudaError_t _cudaDeviceGetDevResource(int device, cudaDevResource* resource, cudaDevResourceType typename) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaDeviceGetDevResource(device, resource, typename) -{{endif}} - -{{if 'cudaDevSmResourceSplitByCount' in found_functions}} - -cdef cudaError_t _cudaDevSmResourceSplitByCount(cudaDevResource* result, unsigned int* nbGroups, const cudaDevResource* input, cudaDevResource* remaining, unsigned int flags, unsigned int minCount) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaDevSmResourceSplitByCount(result, nbGroups, input, remaining, flags, minCount) -{{endif}} - -{{if 'cudaDevSmResourceSplit' in found_functions}} - -cdef cudaError_t _cudaDevSmResourceSplit(cudaDevResource* result, unsigned int nbGroups, const cudaDevResource* input, cudaDevResource* remainder, unsigned int flags, cudaDevSmResourceGroupParams* groupParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaDevSmResourceSplit(result, nbGroups, input, remainder, flags, groupParams) -{{endif}} - -{{if 'cudaDevResourceGenerateDesc' in found_functions}} - -cdef cudaError_t _cudaDevResourceGenerateDesc(cudaDevResourceDesc_t* phDesc, cudaDevResource* resources, unsigned int nbResources) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaDevResourceGenerateDesc(phDesc, resources, nbResources) -{{endif}} - -{{if 'cudaGreenCtxCreate' in found_functions}} - -cdef cudaError_t _cudaGreenCtxCreate(cudaExecutionContext_t* phCtx, cudaDevResourceDesc_t desc, int device, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGreenCtxCreate(phCtx, desc, device, flags) -{{endif}} - -{{if 'cudaExecutionCtxDestroy' in found_functions}} - -cdef cudaError_t _cudaExecutionCtxDestroy(cudaExecutionContext_t ctx) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaExecutionCtxDestroy(ctx) -{{endif}} - -{{if 'cudaExecutionCtxGetDevResource' in found_functions}} - -cdef cudaError_t _cudaExecutionCtxGetDevResource(cudaExecutionContext_t ctx, cudaDevResource* resource, cudaDevResourceType typename) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaExecutionCtxGetDevResource(ctx, resource, typename) -{{endif}} - -{{if 'cudaExecutionCtxGetDevice' in found_functions}} - -cdef cudaError_t _cudaExecutionCtxGetDevice(int* device, cudaExecutionContext_t ctx) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaExecutionCtxGetDevice(device, ctx) -{{endif}} - -{{if 'cudaExecutionCtxGetId' in found_functions}} - -cdef cudaError_t _cudaExecutionCtxGetId(cudaExecutionContext_t ctx, unsigned long long* ctxId) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaExecutionCtxGetId(ctx, ctxId) -{{endif}} - -{{if 'cudaExecutionCtxStreamCreate' in found_functions}} - -cdef cudaError_t _cudaExecutionCtxStreamCreate(cudaStream_t* phStream, cudaExecutionContext_t ctx, unsigned int flags, int priority) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaExecutionCtxStreamCreate(phStream, ctx, flags, priority) -{{endif}} - -{{if 'cudaExecutionCtxSynchronize' in found_functions}} - -cdef cudaError_t _cudaExecutionCtxSynchronize(cudaExecutionContext_t ctx) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaExecutionCtxSynchronize(ctx) -{{endif}} - -{{if 'cudaStreamGetDevResource' in found_functions}} - -cdef cudaError_t _cudaStreamGetDevResource(cudaStream_t hStream, cudaDevResource* resource, cudaDevResourceType typename) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaStreamGetDevResource(hStream, resource, typename) -{{endif}} - -{{if 'cudaExecutionCtxRecordEvent' in found_functions}} - -cdef cudaError_t _cudaExecutionCtxRecordEvent(cudaExecutionContext_t ctx, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaExecutionCtxRecordEvent(ctx, event) -{{endif}} - -{{if 'cudaExecutionCtxWaitEvent' in found_functions}} - -cdef cudaError_t _cudaExecutionCtxWaitEvent(cudaExecutionContext_t ctx, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaExecutionCtxWaitEvent(ctx, event) -{{endif}} - -{{if 'cudaDeviceGetExecutionCtx' in found_functions}} - -cdef cudaError_t _cudaDeviceGetExecutionCtx(cudaExecutionContext_t* ctx, int device) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaDeviceGetExecutionCtx(ctx, device) -{{endif}} - -{{if 'cudaGetExportTable' in found_functions}} - -cdef cudaError_t _cudaGetExportTable(const void** ppExportTable, const cudaUUID_t* pExportTableId) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGetExportTable(ppExportTable, pExportTableId) -{{endif}} - -{{if 'cudaGetKernel' in found_functions}} - -cdef cudaError_t _cudaGetKernel(cudaKernel_t* kernelPtr, const void* entryFuncAddr) except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaGetKernel(kernelPtr, entryFuncAddr) -{{endif}} - -{{if 'make_cudaPitchedPtr' in found_functions}} -@cython.show_performance_hints(False) -cdef cudaPitchedPtr _make_cudaPitchedPtr(void* d, size_t p, size_t xsz, size_t ysz) except* nogil: - return make_cudaPitchedPtr(d, p, xsz, ysz) -{{endif}} - -{{if 'make_cudaPos' in found_functions}} -@cython.show_performance_hints(False) -cdef cudaPos _make_cudaPos(size_t x, size_t y, size_t z) except* nogil: - return make_cudaPos(x, y, z) -{{endif}} - -{{if 'make_cudaExtent' in found_functions}} -@cython.show_performance_hints(False) -cdef cudaExtent _make_cudaExtent(size_t w, size_t h, size_t d) except* nogil: - return make_cudaExtent(w, h, d) -{{endif}} - -{{if 'cudaProfilerStart' in found_functions}} - -cdef cudaError_t _cudaProfilerStart() except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaProfilerStart() -{{endif}} - -{{if 'cudaProfilerStop' in found_functions}} - -cdef cudaError_t _cudaProfilerStop() except ?cudaErrorCallRequiresNewerDriver nogil: - return cudaProfilerStop() -{{endif}} diff --git a/cuda_bindings/cuda/bindings/_bindings/cyruntime.pxd.in b/cuda_bindings/cuda/bindings/_internal/runtime.pxd similarity index 69% rename from cuda_bindings/cuda/bindings/_bindings/cyruntime.pxd.in rename to cuda_bindings/cuda/bindings/_internal/runtime.pxd index 5432ab70c8a..04a943808a3 100644 --- a/cuda_bindings/cuda/bindings/_bindings/cyruntime.pxd.in +++ b/cuda_bindings/cuda/bindings/_internal/runtime.pxd @@ -1,1613 +1,339 @@ # SPDX-FileCopyrightText: Copyright (c) 2021-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# # SPDX-License-Identifier: Apache-2.0 +# +# This code was automatically generated across versions from 12.9.0 to 13.3.0. Do not modify it directly. -# This code was automatically generated with version 13.3.0. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=a99a543be62e221f4b4b43249719b689c33ea030adef3dfa012b31efac555ece -include "../cyruntime_types.pxi" +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=afc5b9003f3efc6f826b46b17b5294f581a00a97f82beaad39634b5037b7669a +from ..cyruntime cimport * +# EGL/GL/VDPAU helper declarations (implementations included in runtime_linux/windows.pyx) include "../_lib/cyruntime/cyruntime.pxd" -{{if 'cudaDeviceReset' in found_functions}} +cdef cudaError_t _getLocalRuntimeVersion(int* runtimeVersion) except ?cudaErrorCallRequiresNewerDriver nogil -cdef cudaError_t _cudaDeviceReset() except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} -{{if 'cudaDeviceSynchronize' in found_functions}} +############################################################################### +# Wrapper functions +############################################################################### +cdef cudaError_t _cudaDeviceReset() except ?cudaErrorCallRequiresNewerDriver nogil cdef cudaError_t _cudaDeviceSynchronize() except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceSetLimit' in found_functions}} - cdef cudaError_t _cudaDeviceSetLimit(cudaLimit limit, size_t value) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetLimit' in found_functions}} - cdef cudaError_t _cudaDeviceGetLimit(size_t* pValue, cudaLimit limit) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetTexture1DLinearMaxWidth' in found_functions}} - cdef cudaError_t _cudaDeviceGetTexture1DLinearMaxWidth(size_t* maxWidthInElements, const cudaChannelFormatDesc* fmtDesc, int device) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetCacheConfig' in found_functions}} - cdef cudaError_t _cudaDeviceGetCacheConfig(cudaFuncCache* pCacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetStreamPriorityRange' in found_functions}} - cdef cudaError_t _cudaDeviceGetStreamPriorityRange(int* leastPriority, int* greatestPriority) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceSetCacheConfig' in found_functions}} - cdef cudaError_t _cudaDeviceSetCacheConfig(cudaFuncCache cacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetByPCIBusId' in found_functions}} - cdef cudaError_t _cudaDeviceGetByPCIBusId(int* device, const char* pciBusId) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetPCIBusId' in found_functions}} - -cdef cudaError_t _cudaDeviceGetPCIBusId(char* pciBusId, int length, int device) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaIpcGetEventHandle' in found_functions}} - +cdef cudaError_t _cudaDeviceGetPCIBusId(char* pciBusId, int len, int device) except ?cudaErrorCallRequiresNewerDriver nogil cdef cudaError_t _cudaIpcGetEventHandle(cudaIpcEventHandle_t* handle, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaIpcOpenEventHandle' in found_functions}} - cdef cudaError_t _cudaIpcOpenEventHandle(cudaEvent_t* event, cudaIpcEventHandle_t handle) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaIpcGetMemHandle' in found_functions}} - cdef cudaError_t _cudaIpcGetMemHandle(cudaIpcMemHandle_t* handle, void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaIpcOpenMemHandle' in found_functions}} - cdef cudaError_t _cudaIpcOpenMemHandle(void** devPtr, cudaIpcMemHandle_t handle, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaIpcCloseMemHandle' in found_functions}} - cdef cudaError_t _cudaIpcCloseMemHandle(void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceFlushGPUDirectRDMAWrites' in found_functions}} - cdef cudaError_t _cudaDeviceFlushGPUDirectRDMAWrites(cudaFlushGPUDirectRDMAWritesTarget target, cudaFlushGPUDirectRDMAWritesScope scope) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceRegisterAsyncNotification' in found_functions}} - cdef cudaError_t _cudaDeviceRegisterAsyncNotification(int device, cudaAsyncCallback callbackFunc, void* userData, cudaAsyncCallbackHandle_t* callback) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceUnregisterAsyncNotification' in found_functions}} - cdef cudaError_t _cudaDeviceUnregisterAsyncNotification(int device, cudaAsyncCallbackHandle_t callback) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetSharedMemConfig' in found_functions}} - cdef cudaError_t _cudaDeviceGetSharedMemConfig(cudaSharedMemConfig* pConfig) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceSetSharedMemConfig' in found_functions}} - cdef cudaError_t _cudaDeviceSetSharedMemConfig(cudaSharedMemConfig config) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGetLastError' in found_functions}} - cdef cudaError_t _cudaGetLastError() except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaPeekAtLastError' in found_functions}} - cdef cudaError_t _cudaPeekAtLastError() except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGetErrorName' in found_functions}} - -cdef const char* _cudaGetErrorName(cudaError_t error) except ?NULL nogil -{{endif}} - -{{if 'cudaGetErrorString' in found_functions}} - -cdef const char* _cudaGetErrorString(cudaError_t error) except ?NULL nogil -{{endif}} - -{{if 'cudaGetDeviceCount' in found_functions}} - +cdef const char* _cudaGetErrorName(cudaError_t error) except?NULL nogil +cdef const char* _cudaGetErrorString(cudaError_t error) except?NULL nogil cdef cudaError_t _cudaGetDeviceCount(int* count) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGetDeviceProperties' in found_functions}} - -cdef cudaError_t _cudaGetDeviceProperties(cudaDeviceProp* prop, int device) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetAttribute' in found_functions}} - cdef cudaError_t _cudaDeviceGetAttribute(int* value, cudaDeviceAttr attr, int device) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetHostAtomicCapabilities' in found_functions}} - -cdef cudaError_t _cudaDeviceGetHostAtomicCapabilities(unsigned int* capabilities, const cudaAtomicOperation* operations, unsigned int count, int device) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetDefaultMemPool' in found_functions}} - cdef cudaError_t _cudaDeviceGetDefaultMemPool(cudaMemPool_t* memPool, int device) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceSetMemPool' in found_functions}} - cdef cudaError_t _cudaDeviceSetMemPool(int device, cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetMemPool' in found_functions}} - cdef cudaError_t _cudaDeviceGetMemPool(cudaMemPool_t* memPool, int device) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetNvSciSyncAttributes' in found_functions}} - cdef cudaError_t _cudaDeviceGetNvSciSyncAttributes(void* nvSciSyncAttrList, int device, int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetP2PAttribute' in found_functions}} - cdef cudaError_t _cudaDeviceGetP2PAttribute(int* value, cudaDeviceP2PAttr attr, int srcDevice, int dstDevice) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetP2PAtomicCapabilities' in found_functions}} - -cdef cudaError_t _cudaDeviceGetP2PAtomicCapabilities(unsigned int* capabilities, const cudaAtomicOperation* operations, unsigned int count, int srcDevice, int dstDevice) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaChooseDevice' in found_functions}} - cdef cudaError_t _cudaChooseDevice(int* device, const cudaDeviceProp* prop) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaInitDevice' in found_functions}} - cdef cudaError_t _cudaInitDevice(int device, unsigned int deviceFlags, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaSetDevice' in found_functions}} - cdef cudaError_t _cudaSetDevice(int device) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGetDevice' in found_functions}} - cdef cudaError_t _cudaGetDevice(int* device) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaSetDeviceFlags' in found_functions}} - cdef cudaError_t _cudaSetDeviceFlags(unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGetDeviceFlags' in found_functions}} - cdef cudaError_t _cudaGetDeviceFlags(unsigned int* flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamCreate' in found_functions}} - cdef cudaError_t _cudaStreamCreate(cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamCreateWithFlags' in found_functions}} - cdef cudaError_t _cudaStreamCreateWithFlags(cudaStream_t* pStream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamCreateWithPriority' in found_functions}} - cdef cudaError_t _cudaStreamCreateWithPriority(cudaStream_t* pStream, unsigned int flags, int priority) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamGetPriority' in found_functions}} - cdef cudaError_t _cudaStreamGetPriority(cudaStream_t hStream, int* priority) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamGetFlags' in found_functions}} - cdef cudaError_t _cudaStreamGetFlags(cudaStream_t hStream, unsigned int* flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamGetId' in found_functions}} - cdef cudaError_t _cudaStreamGetId(cudaStream_t hStream, unsigned long long* streamId) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamGetDevice' in found_functions}} - cdef cudaError_t _cudaStreamGetDevice(cudaStream_t hStream, int* device) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaCtxResetPersistingL2Cache' in found_functions}} - cdef cudaError_t _cudaCtxResetPersistingL2Cache() except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamCopyAttributes' in found_functions}} - cdef cudaError_t _cudaStreamCopyAttributes(cudaStream_t dst, cudaStream_t src) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamGetAttribute' in found_functions}} - cdef cudaError_t _cudaStreamGetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, cudaStreamAttrValue* value_out) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamSetAttribute' in found_functions}} - cdef cudaError_t _cudaStreamSetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, const cudaStreamAttrValue* value) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamDestroy' in found_functions}} - cdef cudaError_t _cudaStreamDestroy(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamWaitEvent' in found_functions}} - cdef cudaError_t _cudaStreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamAddCallback' in found_functions}} - cdef cudaError_t _cudaStreamAddCallback(cudaStream_t stream, cudaStreamCallback_t callback, void* userData, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamSynchronize' in found_functions}} - cdef cudaError_t _cudaStreamSynchronize(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamQuery' in found_functions}} - cdef cudaError_t _cudaStreamQuery(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamAttachMemAsync' in found_functions}} - cdef cudaError_t _cudaStreamAttachMemAsync(cudaStream_t stream, void* devPtr, size_t length, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamBeginCapture' in found_functions}} - cdef cudaError_t _cudaStreamBeginCapture(cudaStream_t stream, cudaStreamCaptureMode mode) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamBeginRecaptureToGraph' in found_functions}} - -cdef cudaError_t _cudaStreamBeginRecaptureToGraph(cudaStream_t stream, cudaStreamCaptureMode mode, cudaGraph_t graph, cudaGraphRecaptureCallbackData* callbackData) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamBeginCaptureToGraph' in found_functions}} - cdef cudaError_t _cudaStreamBeginCaptureToGraph(cudaStream_t stream, cudaGraph_t graph, const cudaGraphNode_t* dependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, cudaStreamCaptureMode mode) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaThreadExchangeStreamCaptureMode' in found_functions}} - cdef cudaError_t _cudaThreadExchangeStreamCaptureMode(cudaStreamCaptureMode* mode) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamEndCapture' in found_functions}} - cdef cudaError_t _cudaStreamEndCapture(cudaStream_t stream, cudaGraph_t* pGraph) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamIsCapturing' in found_functions}} - cdef cudaError_t _cudaStreamIsCapturing(cudaStream_t stream, cudaStreamCaptureStatus* pCaptureStatus) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamGetCaptureInfo' in found_functions}} - -cdef cudaError_t _cudaStreamGetCaptureInfo(cudaStream_t stream, cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out, cudaGraph_t* graph_out, const cudaGraphNode_t** dependencies_out, const cudaGraphEdgeData** edgeData_out, size_t* numDependencies_out) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamUpdateCaptureDependencies' in found_functions}} - cdef cudaError_t _cudaStreamUpdateCaptureDependencies(cudaStream_t stream, cudaGraphNode_t* dependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaEventCreate' in found_functions}} - cdef cudaError_t _cudaEventCreate(cudaEvent_t* event) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaEventCreateWithFlags' in found_functions}} - cdef cudaError_t _cudaEventCreateWithFlags(cudaEvent_t* event, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaEventRecord' in found_functions}} - cdef cudaError_t _cudaEventRecord(cudaEvent_t event, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaEventRecordWithFlags' in found_functions}} - cdef cudaError_t _cudaEventRecordWithFlags(cudaEvent_t event, cudaStream_t stream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaEventQuery' in found_functions}} - cdef cudaError_t _cudaEventQuery(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaEventSynchronize' in found_functions}} - cdef cudaError_t _cudaEventSynchronize(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaEventDestroy' in found_functions}} - cdef cudaError_t _cudaEventDestroy(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaEventElapsedTime' in found_functions}} - cdef cudaError_t _cudaEventElapsedTime(float* ms, cudaEvent_t start, cudaEvent_t end) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaImportExternalMemory' in found_functions}} - cdef cudaError_t _cudaImportExternalMemory(cudaExternalMemory_t* extMem_out, const cudaExternalMemoryHandleDesc* memHandleDesc) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaExternalMemoryGetMappedBuffer' in found_functions}} - cdef cudaError_t _cudaExternalMemoryGetMappedBuffer(void** devPtr, cudaExternalMemory_t extMem, const cudaExternalMemoryBufferDesc* bufferDesc) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaExternalMemoryGetMappedMipmappedArray' in found_functions}} - cdef cudaError_t _cudaExternalMemoryGetMappedMipmappedArray(cudaMipmappedArray_t* mipmap, cudaExternalMemory_t extMem, const cudaExternalMemoryMipmappedArrayDesc* mipmapDesc) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDestroyExternalMemory' in found_functions}} - cdef cudaError_t _cudaDestroyExternalMemory(cudaExternalMemory_t extMem) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaImportExternalSemaphore' in found_functions}} - cdef cudaError_t _cudaImportExternalSemaphore(cudaExternalSemaphore_t* extSem_out, const cudaExternalSemaphoreHandleDesc* semHandleDesc) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaSignalExternalSemaphoresAsync' in found_functions}} - -cdef cudaError_t _cudaSignalExternalSemaphoresAsync(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreSignalParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaWaitExternalSemaphoresAsync' in found_functions}} - -cdef cudaError_t _cudaWaitExternalSemaphoresAsync(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreWaitParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDestroyExternalSemaphore' in found_functions}} - cdef cudaError_t _cudaDestroyExternalSemaphore(cudaExternalSemaphore_t extSem) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaFuncSetCacheConfig' in found_functions}} - cdef cudaError_t _cudaFuncSetCacheConfig(const void* func, cudaFuncCache cacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaFuncGetAttributes' in found_functions}} - cdef cudaError_t _cudaFuncGetAttributes(cudaFuncAttributes* attr, const void* func) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaFuncSetAttribute' in found_functions}} - cdef cudaError_t _cudaFuncSetAttribute(const void* func, cudaFuncAttribute attr, int value) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaFuncGetParamCount' in found_functions}} - -cdef cudaError_t _cudaFuncGetParamCount(const void* func, size_t* paramCount) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLaunchHostFunc' in found_functions}} - +cdef cudaError_t _cudaFuncGetName(const char** name, const void* func) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaFuncGetParamInfo(const void* func, size_t paramIndex, size_t* paramOffset, size_t* paramSize) except ?cudaErrorCallRequiresNewerDriver nogil cdef cudaError_t _cudaLaunchHostFunc(cudaStream_t stream, cudaHostFn_t fn, void* userData) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLaunchHostFunc_v2' in found_functions}} - -cdef cudaError_t _cudaLaunchHostFunc_v2(cudaStream_t stream, cudaHostFn_t fn, void* userData, unsigned int syncMode) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaFuncSetSharedMemConfig' in found_functions}} - cdef cudaError_t _cudaFuncSetSharedMemConfig(const void* func, cudaSharedMemConfig config) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaOccupancyMaxActiveBlocksPerMultiprocessor' in found_functions}} - cdef cudaError_t _cudaOccupancyMaxActiveBlocksPerMultiprocessor(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaOccupancyAvailableDynamicSMemPerBlock' in found_functions}} - cdef cudaError_t _cudaOccupancyAvailableDynamicSMemPerBlock(size_t* dynamicSmemSize, const void* func, int numBlocks, int blockSize) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags' in found_functions}} - cdef cudaError_t _cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMallocManaged' in found_functions}} - cdef cudaError_t _cudaMallocManaged(void** devPtr, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMalloc' in found_functions}} - cdef cudaError_t _cudaMalloc(void** devPtr, size_t size) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMallocHost' in found_functions}} - cdef cudaError_t _cudaMallocHost(void** ptr, size_t size) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMallocPitch' in found_functions}} - cdef cudaError_t _cudaMallocPitch(void** devPtr, size_t* pitch, size_t width, size_t height) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMallocArray' in found_functions}} - cdef cudaError_t _cudaMallocArray(cudaArray_t* array, const cudaChannelFormatDesc* desc, size_t width, size_t height, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaFree' in found_functions}} - cdef cudaError_t _cudaFree(void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaFreeHost' in found_functions}} - cdef cudaError_t _cudaFreeHost(void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaFreeArray' in found_functions}} - cdef cudaError_t _cudaFreeArray(cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaFreeMipmappedArray' in found_functions}} - cdef cudaError_t _cudaFreeMipmappedArray(cudaMipmappedArray_t mipmappedArray) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaHostAlloc' in found_functions}} - cdef cudaError_t _cudaHostAlloc(void** pHost, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaHostRegister' in found_functions}} - cdef cudaError_t _cudaHostRegister(void* ptr, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaHostUnregister' in found_functions}} - cdef cudaError_t _cudaHostUnregister(void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaHostGetDevicePointer' in found_functions}} - cdef cudaError_t _cudaHostGetDevicePointer(void** pDevice, void* pHost, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaHostGetFlags' in found_functions}} - cdef cudaError_t _cudaHostGetFlags(unsigned int* pFlags, void* pHost) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMalloc3D' in found_functions}} - cdef cudaError_t _cudaMalloc3D(cudaPitchedPtr* pitchedDevPtr, cudaExtent extent) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMalloc3DArray' in found_functions}} - cdef cudaError_t _cudaMalloc3DArray(cudaArray_t* array, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMallocMipmappedArray' in found_functions}} - cdef cudaError_t _cudaMallocMipmappedArray(cudaMipmappedArray_t* mipmappedArray, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int numLevels, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGetMipmappedArrayLevel' in found_functions}} - cdef cudaError_t _cudaGetMipmappedArrayLevel(cudaArray_t* levelArray, cudaMipmappedArray_const_t mipmappedArray, unsigned int level) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpy3D' in found_functions}} - cdef cudaError_t _cudaMemcpy3D(const cudaMemcpy3DParms* p) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpy3DPeer' in found_functions}} - cdef cudaError_t _cudaMemcpy3DPeer(const cudaMemcpy3DPeerParms* p) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpy3DAsync' in found_functions}} - cdef cudaError_t _cudaMemcpy3DAsync(const cudaMemcpy3DParms* p, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpy3DPeerAsync' in found_functions}} - cdef cudaError_t _cudaMemcpy3DPeerAsync(const cudaMemcpy3DPeerParms* p, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemGetInfo' in found_functions}} - cdef cudaError_t _cudaMemGetInfo(size_t* free, size_t* total) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaArrayGetInfo' in found_functions}} - cdef cudaError_t _cudaArrayGetInfo(cudaChannelFormatDesc* desc, cudaExtent* extent, unsigned int* flags, cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaArrayGetPlane' in found_functions}} - cdef cudaError_t _cudaArrayGetPlane(cudaArray_t* pPlaneArray, cudaArray_t hArray, unsigned int planeIdx) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaArrayGetMemoryRequirements' in found_functions}} - cdef cudaError_t _cudaArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaArray_t array, int device) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMipmappedArrayGetMemoryRequirements' in found_functions}} - cdef cudaError_t _cudaMipmappedArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaMipmappedArray_t mipmap, int device) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaArrayGetSparseProperties' in found_functions}} - cdef cudaError_t _cudaArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMipmappedArrayGetSparseProperties' in found_functions}} - cdef cudaError_t _cudaMipmappedArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaMipmappedArray_t mipmap) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpy' in found_functions}} - cdef cudaError_t _cudaMemcpy(void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpyPeer' in found_functions}} - cdef cudaError_t _cudaMemcpyPeer(void* dst, int dstDevice, const void* src, int srcDevice, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpy2D' in found_functions}} - cdef cudaError_t _cudaMemcpy2D(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpy2DToArray' in found_functions}} - cdef cudaError_t _cudaMemcpy2DToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpy2DFromArray' in found_functions}} - cdef cudaError_t _cudaMemcpy2DFromArray(void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpy2DArrayToArray' in found_functions}} - cdef cudaError_t _cudaMemcpy2DArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpyAsync' in found_functions}} - cdef cudaError_t _cudaMemcpyAsync(void* dst, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpyPeerAsync' in found_functions}} - cdef cudaError_t _cudaMemcpyPeerAsync(void* dst, int dstDevice, const void* src, int srcDevice, size_t count, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpyBatchAsync' in found_functions}} - cdef cudaError_t _cudaMemcpyBatchAsync(const void** dsts, const void** srcs, const size_t* sizes, size_t count, cudaMemcpyAttributes* attrs, size_t* attrsIdxs, size_t numAttrs, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpy3DBatchAsync' in found_functions}} - cdef cudaError_t _cudaMemcpy3DBatchAsync(size_t numOps, cudaMemcpy3DBatchOp* opList, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpyWithAttributesAsync' in found_functions}} - -cdef cudaError_t _cudaMemcpyWithAttributesAsync(void* dst, const void* src, size_t size, cudaMemcpyAttributes* attr, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpy3DWithAttributesAsync' in found_functions}} - -cdef cudaError_t _cudaMemcpy3DWithAttributesAsync(cudaMemcpy3DBatchOp* op, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpy2DAsync' in found_functions}} - cdef cudaError_t _cudaMemcpy2DAsync(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpy2DToArrayAsync' in found_functions}} - cdef cudaError_t _cudaMemcpy2DToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpy2DFromArrayAsync' in found_functions}} - cdef cudaError_t _cudaMemcpy2DFromArrayAsync(void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemset' in found_functions}} - cdef cudaError_t _cudaMemset(void* devPtr, int value, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemset2D' in found_functions}} - cdef cudaError_t _cudaMemset2D(void* devPtr, size_t pitch, int value, size_t width, size_t height) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemset3D' in found_functions}} - cdef cudaError_t _cudaMemset3D(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemsetAsync' in found_functions}} - cdef cudaError_t _cudaMemsetAsync(void* devPtr, int value, size_t count, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemset2DAsync' in found_functions}} - cdef cudaError_t _cudaMemset2DAsync(void* devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemset3DAsync' in found_functions}} - cdef cudaError_t _cudaMemset3DAsync(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemPrefetchAsync' in found_functions}} - cdef cudaError_t _cudaMemPrefetchAsync(const void* devPtr, size_t count, cudaMemLocation location, unsigned int flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemPrefetchBatchAsync' in found_functions}} - -cdef cudaError_t _cudaMemPrefetchBatchAsync(void** dptrs, size_t* sizes, size_t count, cudaMemLocation* prefetchLocs, size_t* prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemDiscardBatchAsync' in found_functions}} - -cdef cudaError_t _cudaMemDiscardBatchAsync(void** dptrs, size_t* sizes, size_t count, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemDiscardAndPrefetchBatchAsync' in found_functions}} - -cdef cudaError_t _cudaMemDiscardAndPrefetchBatchAsync(void** dptrs, size_t* sizes, size_t count, cudaMemLocation* prefetchLocs, size_t* prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemAdvise' in found_functions}} - cdef cudaError_t _cudaMemAdvise(const void* devPtr, size_t count, cudaMemoryAdvise advice, cudaMemLocation location) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemRangeGetAttribute' in found_functions}} - cdef cudaError_t _cudaMemRangeGetAttribute(void* data, size_t dataSize, cudaMemRangeAttribute attribute, const void* devPtr, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemRangeGetAttributes' in found_functions}} - cdef cudaError_t _cudaMemRangeGetAttributes(void** data, size_t* dataSizes, cudaMemRangeAttribute* attributes, size_t numAttributes, const void* devPtr, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpyToArray' in found_functions}} - cdef cudaError_t _cudaMemcpyToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpyFromArray' in found_functions}} - cdef cudaError_t _cudaMemcpyFromArray(void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpyArrayToArray' in found_functions}} - cdef cudaError_t _cudaMemcpyArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpyToArrayAsync' in found_functions}} - cdef cudaError_t _cudaMemcpyToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpyFromArrayAsync' in found_functions}} - cdef cudaError_t _cudaMemcpyFromArrayAsync(void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMallocAsync' in found_functions}} - cdef cudaError_t _cudaMallocAsync(void** devPtr, size_t size, cudaStream_t hStream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaFreeAsync' in found_functions}} - cdef cudaError_t _cudaFreeAsync(void* devPtr, cudaStream_t hStream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemPoolTrimTo' in found_functions}} - cdef cudaError_t _cudaMemPoolTrimTo(cudaMemPool_t memPool, size_t minBytesToKeep) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemPoolSetAttribute' in found_functions}} - cdef cudaError_t _cudaMemPoolSetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemPoolGetAttribute' in found_functions}} - cdef cudaError_t _cudaMemPoolGetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemPoolSetAccess' in found_functions}} - cdef cudaError_t _cudaMemPoolSetAccess(cudaMemPool_t memPool, const cudaMemAccessDesc* descList, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemPoolGetAccess' in found_functions}} - cdef cudaError_t _cudaMemPoolGetAccess(cudaMemAccessFlags* flags, cudaMemPool_t memPool, cudaMemLocation* location) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemPoolCreate' in found_functions}} - cdef cudaError_t _cudaMemPoolCreate(cudaMemPool_t* memPool, const cudaMemPoolProps* poolProps) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemPoolDestroy' in found_functions}} - cdef cudaError_t _cudaMemPoolDestroy(cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemGetDefaultMemPool' in found_functions}} - -cdef cudaError_t _cudaMemGetDefaultMemPool(cudaMemPool_t* memPool, cudaMemLocation* location, cudaMemAllocationType typename) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemGetMemPool' in found_functions}} - -cdef cudaError_t _cudaMemGetMemPool(cudaMemPool_t* memPool, cudaMemLocation* location, cudaMemAllocationType typename) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemSetMemPool' in found_functions}} - -cdef cudaError_t _cudaMemSetMemPool(cudaMemLocation* location, cudaMemAllocationType typename, cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMallocFromPoolAsync' in found_functions}} - cdef cudaError_t _cudaMallocFromPoolAsync(void** ptr, size_t size, cudaMemPool_t memPool, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemPoolExportToShareableHandle' in found_functions}} - cdef cudaError_t _cudaMemPoolExportToShareableHandle(void* shareableHandle, cudaMemPool_t memPool, cudaMemAllocationHandleType handleType, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemPoolImportFromShareableHandle' in found_functions}} - cdef cudaError_t _cudaMemPoolImportFromShareableHandle(cudaMemPool_t* memPool, void* shareableHandle, cudaMemAllocationHandleType handleType, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemPoolExportPointer' in found_functions}} - cdef cudaError_t _cudaMemPoolExportPointer(cudaMemPoolPtrExportData* exportData, void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemPoolImportPointer' in found_functions}} - cdef cudaError_t _cudaMemPoolImportPointer(void** ptr, cudaMemPool_t memPool, cudaMemPoolPtrExportData* exportData) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaPointerGetAttributes' in found_functions}} - cdef cudaError_t _cudaPointerGetAttributes(cudaPointerAttributes* attributes, const void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceCanAccessPeer' in found_functions}} - cdef cudaError_t _cudaDeviceCanAccessPeer(int* canAccessPeer, int device, int peerDevice) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceEnablePeerAccess' in found_functions}} - cdef cudaError_t _cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceDisablePeerAccess' in found_functions}} - cdef cudaError_t _cudaDeviceDisablePeerAccess(int peerDevice) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphicsUnregisterResource' in found_functions}} - cdef cudaError_t _cudaGraphicsUnregisterResource(cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphicsResourceSetMapFlags' in found_functions}} - cdef cudaError_t _cudaGraphicsResourceSetMapFlags(cudaGraphicsResource_t resource, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphicsMapResources' in found_functions}} - cdef cudaError_t _cudaGraphicsMapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphicsUnmapResources' in found_functions}} - cdef cudaError_t _cudaGraphicsUnmapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphicsResourceGetMappedPointer' in found_functions}} - cdef cudaError_t _cudaGraphicsResourceGetMappedPointer(void** devPtr, size_t* size, cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphicsSubResourceGetMappedArray' in found_functions}} - cdef cudaError_t _cudaGraphicsSubResourceGetMappedArray(cudaArray_t* array, cudaGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphicsResourceGetMappedMipmappedArray' in found_functions}} - cdef cudaError_t _cudaGraphicsResourceGetMappedMipmappedArray(cudaMipmappedArray_t* mipmappedArray, cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGetChannelDesc' in found_functions}} - cdef cudaError_t _cudaGetChannelDesc(cudaChannelFormatDesc* desc, cudaArray_const_t array) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaCreateChannelDesc' in found_functions}} - cdef cudaChannelFormatDesc _cudaCreateChannelDesc(int x, int y, int z, int w, cudaChannelFormatKind f) except* nogil -{{endif}} - -{{if 'cudaCreateTextureObject' in found_functions}} - cdef cudaError_t _cudaCreateTextureObject(cudaTextureObject_t* pTexObject, const cudaResourceDesc* pResDesc, const cudaTextureDesc* pTexDesc, const cudaResourceViewDesc* pResViewDesc) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDestroyTextureObject' in found_functions}} - cdef cudaError_t _cudaDestroyTextureObject(cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGetTextureObjectResourceDesc' in found_functions}} - cdef cudaError_t _cudaGetTextureObjectResourceDesc(cudaResourceDesc* pResDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGetTextureObjectTextureDesc' in found_functions}} - cdef cudaError_t _cudaGetTextureObjectTextureDesc(cudaTextureDesc* pTexDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGetTextureObjectResourceViewDesc' in found_functions}} - cdef cudaError_t _cudaGetTextureObjectResourceViewDesc(cudaResourceViewDesc* pResViewDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaCreateSurfaceObject' in found_functions}} - cdef cudaError_t _cudaCreateSurfaceObject(cudaSurfaceObject_t* pSurfObject, const cudaResourceDesc* pResDesc) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDestroySurfaceObject' in found_functions}} - cdef cudaError_t _cudaDestroySurfaceObject(cudaSurfaceObject_t surfObject) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGetSurfaceObjectResourceDesc' in found_functions}} - cdef cudaError_t _cudaGetSurfaceObjectResourceDesc(cudaResourceDesc* pResDesc, cudaSurfaceObject_t surfObject) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDriverGetVersion' in found_functions}} - cdef cudaError_t _cudaDriverGetVersion(int* driverVersion) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaRuntimeGetVersion' in found_functions}} - cdef cudaError_t _cudaRuntimeGetVersion(int* runtimeVersion) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLogsRegisterCallback' in found_functions}} - -cdef cudaError_t _cudaLogsRegisterCallback(cudaLogsCallback_t callbackFunc, void* userData, cudaLogsCallbackHandle* callback_out) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLogsUnregisterCallback' in found_functions}} - -cdef cudaError_t _cudaLogsUnregisterCallback(cudaLogsCallbackHandle callback) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLogsCurrent' in found_functions}} - -cdef cudaError_t _cudaLogsCurrent(cudaLogIterator* iterator_out, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLogsDumpToFile' in found_functions}} - -cdef cudaError_t _cudaLogsDumpToFile(cudaLogIterator* iterator, const char* pathToFile, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLogsDumpToMemory' in found_functions}} - -cdef cudaError_t _cudaLogsDumpToMemory(cudaLogIterator* iterator, char* buffer, size_t* size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphCreate' in found_functions}} - cdef cudaError_t _cudaGraphCreate(cudaGraph_t* pGraph, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphAddKernelNode' in found_functions}} - cdef cudaError_t _cudaGraphAddKernelNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphKernelNodeGetParams' in found_functions}} - cdef cudaError_t _cudaGraphKernelNodeGetParams(cudaGraphNode_t node, cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphKernelNodeSetParams' in found_functions}} - cdef cudaError_t _cudaGraphKernelNodeSetParams(cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphKernelNodeCopyAttributes' in found_functions}} - cdef cudaError_t _cudaGraphKernelNodeCopyAttributes(cudaGraphNode_t hDst, cudaGraphNode_t hSrc) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphKernelNodeGetAttribute' in found_functions}} - cdef cudaError_t _cudaGraphKernelNodeGetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, cudaKernelNodeAttrValue* value_out) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphKernelNodeSetAttribute' in found_functions}} - cdef cudaError_t _cudaGraphKernelNodeSetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, const cudaKernelNodeAttrValue* value) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphAddMemcpyNode' in found_functions}} - cdef cudaError_t _cudaGraphAddMemcpyNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemcpy3DParms* pCopyParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphAddMemcpyNode1D' in found_functions}} - cdef cudaError_t _cudaGraphAddMemcpyNode1D(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphMemcpyNodeGetParams' in found_functions}} - cdef cudaError_t _cudaGraphMemcpyNodeGetParams(cudaGraphNode_t node, cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphMemcpyNodeSetParams' in found_functions}} - cdef cudaError_t _cudaGraphMemcpyNodeSetParams(cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphMemcpyNodeSetParams1D' in found_functions}} - cdef cudaError_t _cudaGraphMemcpyNodeSetParams1D(cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphAddMemsetNode' in found_functions}} - cdef cudaError_t _cudaGraphAddMemsetNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemsetParams* pMemsetParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphMemsetNodeGetParams' in found_functions}} - cdef cudaError_t _cudaGraphMemsetNodeGetParams(cudaGraphNode_t node, cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphMemsetNodeSetParams' in found_functions}} - cdef cudaError_t _cudaGraphMemsetNodeSetParams(cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphAddHostNode' in found_functions}} - cdef cudaError_t _cudaGraphAddHostNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphHostNodeGetParams' in found_functions}} - cdef cudaError_t _cudaGraphHostNodeGetParams(cudaGraphNode_t node, cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphHostNodeSetParams' in found_functions}} - cdef cudaError_t _cudaGraphHostNodeSetParams(cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphAddChildGraphNode' in found_functions}} - cdef cudaError_t _cudaGraphAddChildGraphNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaGraph_t childGraph) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphChildGraphNodeGetGraph' in found_functions}} - cdef cudaError_t _cudaGraphChildGraphNodeGetGraph(cudaGraphNode_t node, cudaGraph_t* pGraph) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphAddEmptyNode' in found_functions}} - cdef cudaError_t _cudaGraphAddEmptyNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphAddEventRecordNode' in found_functions}} - cdef cudaError_t _cudaGraphAddEventRecordNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphEventRecordNodeGetEvent' in found_functions}} - cdef cudaError_t _cudaGraphEventRecordNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphEventRecordNodeSetEvent' in found_functions}} - cdef cudaError_t _cudaGraphEventRecordNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphAddEventWaitNode' in found_functions}} - cdef cudaError_t _cudaGraphAddEventWaitNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphEventWaitNodeGetEvent' in found_functions}} - cdef cudaError_t _cudaGraphEventWaitNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphEventWaitNodeSetEvent' in found_functions}} - cdef cudaError_t _cudaGraphEventWaitNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphAddExternalSemaphoresSignalNode' in found_functions}} - cdef cudaError_t _cudaGraphAddExternalSemaphoresSignalNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExternalSemaphoresSignalNodeGetParams' in found_functions}} - cdef cudaError_t _cudaGraphExternalSemaphoresSignalNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreSignalNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExternalSemaphoresSignalNodeSetParams' in found_functions}} - cdef cudaError_t _cudaGraphExternalSemaphoresSignalNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphAddExternalSemaphoresWaitNode' in found_functions}} - cdef cudaError_t _cudaGraphAddExternalSemaphoresWaitNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExternalSemaphoresWaitNodeGetParams' in found_functions}} - cdef cudaError_t _cudaGraphExternalSemaphoresWaitNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreWaitNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExternalSemaphoresWaitNodeSetParams' in found_functions}} - cdef cudaError_t _cudaGraphExternalSemaphoresWaitNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphAddMemAllocNode' in found_functions}} - cdef cudaError_t _cudaGraphAddMemAllocNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaMemAllocNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphMemAllocNodeGetParams' in found_functions}} - cdef cudaError_t _cudaGraphMemAllocNodeGetParams(cudaGraphNode_t node, cudaMemAllocNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphAddMemFreeNode' in found_functions}} - cdef cudaError_t _cudaGraphAddMemFreeNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dptr) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphMemFreeNodeGetParams' in found_functions}} - cdef cudaError_t _cudaGraphMemFreeNodeGetParams(cudaGraphNode_t node, void* dptr_out) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGraphMemTrim' in found_functions}} - cdef cudaError_t _cudaDeviceGraphMemTrim(int device) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetGraphMemAttribute' in found_functions}} - cdef cudaError_t _cudaDeviceGetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceSetGraphMemAttribute' in found_functions}} - cdef cudaError_t _cudaDeviceSetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphClone' in found_functions}} - cdef cudaError_t _cudaGraphClone(cudaGraph_t* pGraphClone, cudaGraph_t originalGraph) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphNodeFindInClone' in found_functions}} - cdef cudaError_t _cudaGraphNodeFindInClone(cudaGraphNode_t* pNode, cudaGraphNode_t originalNode, cudaGraph_t clonedGraph) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphNodeGetType' in found_functions}} - cdef cudaError_t _cudaGraphNodeGetType(cudaGraphNode_t node, cudaGraphNodeType* pType) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphNodeGetContainingGraph' in found_functions}} - -cdef cudaError_t _cudaGraphNodeGetContainingGraph(cudaGraphNode_t hNode, cudaGraph_t* phGraph) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphNodeGetLocalId' in found_functions}} - -cdef cudaError_t _cudaGraphNodeGetLocalId(cudaGraphNode_t hNode, unsigned int* nodeId) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphNodeGetToolsId' in found_functions}} - -cdef cudaError_t _cudaGraphNodeGetToolsId(cudaGraphNode_t hNode, unsigned long long* toolsNodeId) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphGetId' in found_functions}} - -cdef cudaError_t _cudaGraphGetId(cudaGraph_t hGraph, unsigned int* graphID) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExecGetId' in found_functions}} - -cdef cudaError_t _cudaGraphExecGetId(cudaGraphExec_t hGraphExec, unsigned int* graphID) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphGetNodes' in found_functions}} - cdef cudaError_t _cudaGraphGetNodes(cudaGraph_t graph, cudaGraphNode_t* nodes, size_t* numNodes) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphGetRootNodes' in found_functions}} - cdef cudaError_t _cudaGraphGetRootNodes(cudaGraph_t graph, cudaGraphNode_t* pRootNodes, size_t* pNumRootNodes) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphGetEdges' in found_functions}} - cdef cudaError_t _cudaGraphGetEdges(cudaGraph_t graph, cudaGraphNode_t* from_, cudaGraphNode_t* to, cudaGraphEdgeData* edgeData, size_t* numEdges) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphNodeGetDependencies' in found_functions}} - cdef cudaError_t _cudaGraphNodeGetDependencies(cudaGraphNode_t node, cudaGraphNode_t* pDependencies, cudaGraphEdgeData* edgeData, size_t* pNumDependencies) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphNodeGetDependentNodes' in found_functions}} - cdef cudaError_t _cudaGraphNodeGetDependentNodes(cudaGraphNode_t node, cudaGraphNode_t* pDependentNodes, cudaGraphEdgeData* edgeData, size_t* pNumDependentNodes) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphAddDependencies' in found_functions}} - cdef cudaError_t _cudaGraphAddDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, const cudaGraphEdgeData* edgeData, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphRemoveDependencies' in found_functions}} - cdef cudaError_t _cudaGraphRemoveDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, const cudaGraphEdgeData* edgeData, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphDestroyNode' in found_functions}} - cdef cudaError_t _cudaGraphDestroyNode(cudaGraphNode_t node) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphInstantiate' in found_functions}} - cdef cudaError_t _cudaGraphInstantiate(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphInstantiateWithFlags' in found_functions}} - cdef cudaError_t _cudaGraphInstantiateWithFlags(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphInstantiateWithParams' in found_functions}} - cdef cudaError_t _cudaGraphInstantiateWithParams(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, cudaGraphInstantiateParams* instantiateParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExecGetFlags' in found_functions}} - cdef cudaError_t _cudaGraphExecGetFlags(cudaGraphExec_t graphExec, unsigned long long* flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExecKernelNodeSetParams' in found_functions}} - cdef cudaError_t _cudaGraphExecKernelNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExecMemcpyNodeSetParams' in found_functions}} - cdef cudaError_t _cudaGraphExecMemcpyNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExecMemcpyNodeSetParams1D' in found_functions}} - cdef cudaError_t _cudaGraphExecMemcpyNodeSetParams1D(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExecMemsetNodeSetParams' in found_functions}} - cdef cudaError_t _cudaGraphExecMemsetNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExecHostNodeSetParams' in found_functions}} - cdef cudaError_t _cudaGraphExecHostNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExecChildGraphNodeSetParams' in found_functions}} - cdef cudaError_t _cudaGraphExecChildGraphNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, cudaGraph_t childGraph) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExecEventRecordNodeSetEvent' in found_functions}} - cdef cudaError_t _cudaGraphExecEventRecordNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExecEventWaitNodeSetEvent' in found_functions}} - cdef cudaError_t _cudaGraphExecEventWaitNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExecExternalSemaphoresSignalNodeSetParams' in found_functions}} - cdef cudaError_t _cudaGraphExecExternalSemaphoresSignalNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExecExternalSemaphoresWaitNodeSetParams' in found_functions}} - cdef cudaError_t _cudaGraphExecExternalSemaphoresWaitNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphNodeSetEnabled' in found_functions}} - cdef cudaError_t _cudaGraphNodeSetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int isEnabled) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphNodeGetEnabled' in found_functions}} - cdef cudaError_t _cudaGraphNodeGetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int* isEnabled) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExecUpdate' in found_functions}} - cdef cudaError_t _cudaGraphExecUpdate(cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphExecUpdateResultInfo* resultInfo) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphUpload' in found_functions}} - cdef cudaError_t _cudaGraphUpload(cudaGraphExec_t graphExec, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphLaunch' in found_functions}} - cdef cudaError_t _cudaGraphLaunch(cudaGraphExec_t graphExec, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExecDestroy' in found_functions}} - cdef cudaError_t _cudaGraphExecDestroy(cudaGraphExec_t graphExec) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphDestroy' in found_functions}} - cdef cudaError_t _cudaGraphDestroy(cudaGraph_t graph) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphDebugDotPrint' in found_functions}} - cdef cudaError_t _cudaGraphDebugDotPrint(cudaGraph_t graph, const char* path, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaUserObjectCreate' in found_functions}} - cdef cudaError_t _cudaUserObjectCreate(cudaUserObject_t* object_out, void* ptr, cudaHostFn_t destroy, unsigned int initialRefcount, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaUserObjectRetain' in found_functions}} - cdef cudaError_t _cudaUserObjectRetain(cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaUserObjectRelease' in found_functions}} - cdef cudaError_t _cudaUserObjectRelease(cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphRetainUserObject' in found_functions}} - cdef cudaError_t _cudaGraphRetainUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphReleaseUserObject' in found_functions}} - cdef cudaError_t _cudaGraphReleaseUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphAddNode' in found_functions}} - cdef cudaError_t _cudaGraphAddNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphNodeSetParams' in found_functions}} - cdef cudaError_t _cudaGraphNodeSetParams(cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphNodeGetParams' in found_functions}} - -cdef cudaError_t _cudaGraphNodeGetParams(cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExecNodeSetParams' in found_functions}} - cdef cudaError_t _cudaGraphExecNodeSetParams(cudaGraphExec_t graphExec, cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphConditionalHandleCreate' in found_functions}} - cdef cudaError_t _cudaGraphConditionalHandleCreate(cudaGraphConditionalHandle* pHandle_out, cudaGraph_t graph, unsigned int defaultLaunchValue, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphConditionalHandleCreate_v2' in found_functions}} - -cdef cudaError_t _cudaGraphConditionalHandleCreate_v2(cudaGraphConditionalHandle* pHandle_out, cudaGraph_t graph, cudaExecutionContext_t ctx, unsigned int defaultLaunchValue, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGetDriverEntryPoint' in found_functions}} - cdef cudaError_t _cudaGetDriverEntryPoint(const char* symbol, void** funcPtr, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGetDriverEntryPointByVersion' in found_functions}} - cdef cudaError_t _cudaGetDriverEntryPointByVersion(const char* symbol, void** funcPtr, unsigned int cudaVersion, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLibraryLoadData' in found_functions}} - cdef cudaError_t _cudaLibraryLoadData(cudaLibrary_t* library, const void* code, cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLibraryLoadFromFile' in found_functions}} - cdef cudaError_t _cudaLibraryLoadFromFile(cudaLibrary_t* library, const char* fileName, cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLibraryUnload' in found_functions}} - cdef cudaError_t _cudaLibraryUnload(cudaLibrary_t library) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLibraryGetKernel' in found_functions}} - cdef cudaError_t _cudaLibraryGetKernel(cudaKernel_t* pKernel, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLibraryGetGlobal' in found_functions}} - -cdef cudaError_t _cudaLibraryGetGlobal(void** dptr, size_t* numbytes, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLibraryGetManaged' in found_functions}} - -cdef cudaError_t _cudaLibraryGetManaged(void** dptr, size_t* numbytes, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLibraryGetUnifiedFunction' in found_functions}} - +cdef cudaError_t _cudaLibraryGetGlobal(void** dptr, size_t* bytes, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaLibraryGetManaged(void** dptr, size_t* bytes, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil cdef cudaError_t _cudaLibraryGetUnifiedFunction(void** fptr, cudaLibrary_t library, const char* symbol) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLibraryGetKernelCount' in found_functions}} - cdef cudaError_t _cudaLibraryGetKernelCount(unsigned int* count, cudaLibrary_t lib) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLibraryEnumerateKernels' in found_functions}} - cdef cudaError_t _cudaLibraryEnumerateKernels(cudaKernel_t* kernels, unsigned int numKernels, cudaLibrary_t lib) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaKernelSetAttributeForDevice' in found_functions}} - cdef cudaError_t _cudaKernelSetAttributeForDevice(cudaKernel_t kernel, cudaFuncAttribute attr, int value, int device) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetDevResource' in found_functions}} - -cdef cudaError_t _cudaDeviceGetDevResource(int device, cudaDevResource* resource, cudaDevResourceType typename) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDevSmResourceSplitByCount' in found_functions}} - +cdef cudaError_t _cudaGetExportTable(const void** ppExportTable, const cudaUUID_t* pExportTableId) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGetKernel(cudaKernel_t* kernelPtr, const void* entryFuncAddr) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaProfilerStart() except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaProfilerStop() except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGetDeviceProperties(cudaDeviceProp* prop, int device) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceGetHostAtomicCapabilities(unsigned int* capabilities, const cudaAtomicOperation* operations, unsigned int count, int device) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceGetP2PAtomicCapabilities(unsigned int* capabilities, const cudaAtomicOperation* operations, unsigned int count, int srcDevice, int dstDevice) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaStreamGetCaptureInfo(cudaStream_t stream, cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out, cudaGraph_t* graph_out, const cudaGraphNode_t** dependencies_out, const cudaGraphEdgeData** edgeData_out, size_t* numDependencies_out) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaSignalExternalSemaphoresAsync(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreSignalParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaWaitExternalSemaphoresAsync(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreWaitParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemPrefetchBatchAsync(void** dptrs, size_t* sizes, size_t count, cudaMemLocation* prefetchLocs, size_t* prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemDiscardBatchAsync(void** dptrs, size_t* sizes, size_t count, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemDiscardAndPrefetchBatchAsync(void** dptrs, size_t* sizes, size_t count, cudaMemLocation* prefetchLocs, size_t* prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemGetDefaultMemPool(cudaMemPool_t* memPool, cudaMemLocation* location, cudaMemAllocationType type) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemGetMemPool(cudaMemPool_t* memPool, cudaMemLocation* location, cudaMemAllocationType type) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemSetMemPool(cudaMemLocation* location, cudaMemAllocationType type, cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaLogsRegisterCallback(cudaLogsCallback_t callbackFunc, void* userData, cudaLogsCallbackHandle* callback_out) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaLogsUnregisterCallback(cudaLogsCallbackHandle callback) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaLogsCurrent(cudaLogIterator* iterator_out, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaLogsDumpToFile(cudaLogIterator* iterator, const char* pathToFile, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaLogsDumpToMemory(cudaLogIterator* iterator, char* buffer, size_t* size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphNodeGetContainingGraph(cudaGraphNode_t hNode, cudaGraph_t* phGraph) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphNodeGetLocalId(cudaGraphNode_t hNode, unsigned int* nodeId) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphNodeGetToolsId(cudaGraphNode_t hNode, unsigned long long* toolsNodeId) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphGetId(cudaGraph_t hGraph, unsigned int* graphID) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphExecGetId(cudaGraphExec_t hGraphExec, unsigned int* graphID) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphConditionalHandleCreate_v2(cudaGraphConditionalHandle* pHandle_out, cudaGraph_t graph, cudaExecutionContext_t ctx, unsigned int defaultLaunchValue, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceGetDevResource(int device, cudaDevResource* resource, cudaDevResourceType type) except ?cudaErrorCallRequiresNewerDriver nogil cdef cudaError_t _cudaDevSmResourceSplitByCount(cudaDevResource* result, unsigned int* nbGroups, const cudaDevResource* input, cudaDevResource* remaining, unsigned int flags, unsigned int minCount) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDevSmResourceSplit' in found_functions}} - cdef cudaError_t _cudaDevSmResourceSplit(cudaDevResource* result, unsigned int nbGroups, const cudaDevResource* input, cudaDevResource* remainder, unsigned int flags, cudaDevSmResourceGroupParams* groupParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDevResourceGenerateDesc' in found_functions}} - cdef cudaError_t _cudaDevResourceGenerateDesc(cudaDevResourceDesc_t* phDesc, cudaDevResource* resources, unsigned int nbResources) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGreenCtxCreate' in found_functions}} - cdef cudaError_t _cudaGreenCtxCreate(cudaExecutionContext_t* phCtx, cudaDevResourceDesc_t desc, int device, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaExecutionCtxDestroy' in found_functions}} - cdef cudaError_t _cudaExecutionCtxDestroy(cudaExecutionContext_t ctx) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaExecutionCtxGetDevResource' in found_functions}} - -cdef cudaError_t _cudaExecutionCtxGetDevResource(cudaExecutionContext_t ctx, cudaDevResource* resource, cudaDevResourceType typename) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaExecutionCtxGetDevice' in found_functions}} - +cdef cudaError_t _cudaExecutionCtxGetDevResource(cudaExecutionContext_t ctx, cudaDevResource* resource, cudaDevResourceType type) except ?cudaErrorCallRequiresNewerDriver nogil cdef cudaError_t _cudaExecutionCtxGetDevice(int* device, cudaExecutionContext_t ctx) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaExecutionCtxGetId' in found_functions}} - cdef cudaError_t _cudaExecutionCtxGetId(cudaExecutionContext_t ctx, unsigned long long* ctxId) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaExecutionCtxStreamCreate' in found_functions}} - cdef cudaError_t _cudaExecutionCtxStreamCreate(cudaStream_t* phStream, cudaExecutionContext_t ctx, unsigned int flags, int priority) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaExecutionCtxSynchronize' in found_functions}} - cdef cudaError_t _cudaExecutionCtxSynchronize(cudaExecutionContext_t ctx) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamGetDevResource' in found_functions}} - -cdef cudaError_t _cudaStreamGetDevResource(cudaStream_t hStream, cudaDevResource* resource, cudaDevResourceType typename) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaExecutionCtxRecordEvent' in found_functions}} - +cdef cudaError_t _cudaStreamGetDevResource(cudaStream_t hStream, cudaDevResource* resource, cudaDevResourceType type) except ?cudaErrorCallRequiresNewerDriver nogil cdef cudaError_t _cudaExecutionCtxRecordEvent(cudaExecutionContext_t ctx, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaExecutionCtxWaitEvent' in found_functions}} - cdef cudaError_t _cudaExecutionCtxWaitEvent(cudaExecutionContext_t ctx, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetExecutionCtx' in found_functions}} - cdef cudaError_t _cudaDeviceGetExecutionCtx(cudaExecutionContext_t* ctx, int device) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGetExportTable' in found_functions}} - -cdef cudaError_t _cudaGetExportTable(const void** ppExportTable, const cudaUUID_t* pExportTableId) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGetKernel' in found_functions}} - -cdef cudaError_t _cudaGetKernel(cudaKernel_t* kernelPtr, const void* entryFuncAddr) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'make_cudaPitchedPtr' in found_functions}} - -cdef cudaPitchedPtr _make_cudaPitchedPtr(void* d, size_t p, size_t xsz, size_t ysz) except* nogil -{{endif}} - -{{if 'make_cudaPos' in found_functions}} - -cdef cudaPos _make_cudaPos(size_t x, size_t y, size_t z) except* nogil -{{endif}} - -{{if 'make_cudaExtent' in found_functions}} - -cdef cudaExtent _make_cudaExtent(size_t w, size_t h, size_t d) except* nogil -{{endif}} - -{{if 'cudaProfilerStart' in found_functions}} - -cdef cudaError_t _cudaProfilerStart() except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaProfilerStop' in found_functions}} - -cdef cudaError_t _cudaProfilerStop() except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} +cdef cudaError_t _cudaFuncGetParamCount(const void* func, size_t* paramCount) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaLaunchHostFunc_v2(cudaStream_t stream, cudaHostFn_t fn, void* userData, unsigned int syncMode) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemcpyWithAttributesAsync(void* dst, const void* src, size_t size, cudaMemcpyAttributes* attr, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemcpy3DWithAttributesAsync(cudaMemcpy3DBatchOp* op, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphNodeGetParams(cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaStreamBeginRecaptureToGraph(cudaStream_t stream, cudaStreamCaptureMode mode, cudaGraph_t graph, cudaGraphRecaptureCallbackData* callbackData) except ?cudaErrorCallRequiresNewerDriver nogil diff --git a/cuda_bindings/cuda/bindings/_internal/runtime_linux.pyx b/cuda_bindings/cuda/bindings/_internal/runtime_linux.pyx new file mode 100644 index 00000000000..2d1409ce2be --- /dev/null +++ b/cuda_bindings/cuda/bindings/_internal/runtime_linux.pyx @@ -0,0 +1,3288 @@ +# SPDX-FileCopyrightText: Copyright (c) 2021-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# SPDX-License-Identifier: Apache-2.0 +# +# This code was automatically generated across versions from 12.9.0 to 13.3.0. Do not modify it directly. + +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=c45a1e41ddef35af045f2ff91e9703cb77870bf90603b3c5c7369e76f7a539f0 +import os + +from libc.stdint cimport uintptr_t + +from cuda.pathfinder import load_nvidia_dynamic_lib +cimport cuda.bindings._lib.dlfcn as dlfcn +cimport cuda.bindings._internal.runtime_ptds as ptds +cimport cython + + +############################################################################### +# Per-thread default stream dispatch +############################################################################### + +cdef bint __cudaPythonInit = False +cdef bint __usePTDS = False + +cdef int _cudaPythonInit() except -1 nogil: + global __cudaPythonInit + global __usePTDS + with gil: + __usePTDS = bool(int(os.getenv('CUDA_PYTHON_CUDA_PER_THREAD_DEFAULT_STREAM', default=0))) + __cudaPythonInit = True + return __usePTDS + +cdef inline int cudaPythonInit() except -1 nogil: + if __cudaPythonInit: + return __usePTDS + return _cudaPythonInit() + + +############################################################################### +# EGL/GL/VDPAU helpers (implementations delegating to driver EGL/VDPAU/GL APIs) +############################################################################### + +include "../_lib/cyruntime/cyruntime.pxi" + + +############################################################################### +# getLocalRuntimeVersion — dynamically loads cudart to read its own version +############################################################################### + +cdef cudaError_t _getLocalRuntimeVersion(int* runtimeVersion) except ?cudaErrorCallRequiresNewerDriver nogil: + # Load cudart dynamically to read its embedded version number. + with gil: + loaded_dl = load_nvidia_dynamic_lib("cudart") + handle = loaded_dl._handle_uint + + cdef void* __cudaRuntimeGetVersion = dlfcn.dlsym(handle, 'cudaRuntimeGetVersion') + + if __cudaRuntimeGetVersion == NULL: + with gil: + raise RuntimeError(f'Function "cudaRuntimeGetVersion" not found in {loaded_dl.abs_path}') + + # We explicitly do *NOT* cleanup the library handle here, acknowledging + # that, yes, the handle leaks. The reason is that there's a + # `functools.cache` on the top-level caller of this function. + # + # This means this library would be opened once and then immediately closed, + # all the while remaining in the cache lurking there for people to call. + # + # Since we open the library one time (technically once per unique library name), + # there's not a ton of leakage, which we deem acceptable for the 1000x speedup + # achieved by caching (ultimately) `ctypes.CDLL` calls. + # + # Long(er)-term we can explore cleaning up the library using higher-level + # Python mechanisms, like `__del__` or `weakref.finalizer`s. + + cdef cudaError_t err = cudaSuccess + err = ( __cudaRuntimeGetVersion)(runtimeVersion) + return err + + +############################################################################### +# C function declarations for static cudart (avoids infinite recursion through +# the same-named Cython wrappers imported via `from ..cyruntime cimport *`) +############################################################################### + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceReset "cudaDeviceReset" () noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceSynchronize "cudaDeviceSynchronize" () noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceSetLimit "cudaDeviceSetLimit" (cudaLimit limit, size_t value) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetLimit "cudaDeviceGetLimit" (size_t* pValue, cudaLimit limit) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetTexture1DLinearMaxWidth "cudaDeviceGetTexture1DLinearMaxWidth" (size_t* maxWidthInElements, const cudaChannelFormatDesc* fmtDesc, int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetCacheConfig "cudaDeviceGetCacheConfig" (cudaFuncCache* pCacheConfig) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetStreamPriorityRange "cudaDeviceGetStreamPriorityRange" (int* leastPriority, int* greatestPriority) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceSetCacheConfig "cudaDeviceSetCacheConfig" (cudaFuncCache cacheConfig) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetByPCIBusId "cudaDeviceGetByPCIBusId" (int* device, const char* pciBusId) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetPCIBusId "cudaDeviceGetPCIBusId" (char* pciBusId, int len, int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaIpcGetEventHandle "cudaIpcGetEventHandle" (cudaIpcEventHandle_t* handle, cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaIpcOpenEventHandle "cudaIpcOpenEventHandle" (cudaEvent_t* event, cudaIpcEventHandle_t handle) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaIpcGetMemHandle "cudaIpcGetMemHandle" (cudaIpcMemHandle_t* handle, void* devPtr) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaIpcOpenMemHandle "cudaIpcOpenMemHandle" (void** devPtr, cudaIpcMemHandle_t handle, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaIpcCloseMemHandle "cudaIpcCloseMemHandle" (void* devPtr) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceFlushGPUDirectRDMAWrites "cudaDeviceFlushGPUDirectRDMAWrites" (cudaFlushGPUDirectRDMAWritesTarget target, cudaFlushGPUDirectRDMAWritesScope scope) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceRegisterAsyncNotification "cudaDeviceRegisterAsyncNotification" (int device, cudaAsyncCallback callbackFunc, void* userData, cudaAsyncCallbackHandle_t* callback) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceUnregisterAsyncNotification "cudaDeviceUnregisterAsyncNotification" (int device, cudaAsyncCallbackHandle_t callback) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetSharedMemConfig "cudaDeviceGetSharedMemConfig" (cudaSharedMemConfig* pConfig) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceSetSharedMemConfig "cudaDeviceSetSharedMemConfig" (cudaSharedMemConfig config) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetLastError "cudaGetLastError" () noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaPeekAtLastError "cudaPeekAtLastError" () noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + const char* _static_cudaGetErrorName "cudaGetErrorName" (cudaError_t error) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + const char* _static_cudaGetErrorString "cudaGetErrorString" (cudaError_t error) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetDeviceCount "cudaGetDeviceCount" (int* count) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetAttribute "cudaDeviceGetAttribute" (int* value, cudaDeviceAttr attr, int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetDefaultMemPool "cudaDeviceGetDefaultMemPool" (cudaMemPool_t* memPool, int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceSetMemPool "cudaDeviceSetMemPool" (int device, cudaMemPool_t memPool) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetMemPool "cudaDeviceGetMemPool" (cudaMemPool_t* memPool, int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetNvSciSyncAttributes "cudaDeviceGetNvSciSyncAttributes" (void* nvSciSyncAttrList, int device, int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetP2PAttribute "cudaDeviceGetP2PAttribute" (int* value, cudaDeviceP2PAttr attr, int srcDevice, int dstDevice) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaChooseDevice "cudaChooseDevice" (int* device, const cudaDeviceProp* prop) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaInitDevice "cudaInitDevice" (int device, unsigned int deviceFlags, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaSetDevice "cudaSetDevice" (int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetDevice "cudaGetDevice" (int* device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaSetDeviceFlags "cudaSetDeviceFlags" (unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetDeviceFlags "cudaGetDeviceFlags" (unsigned int* flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamCreate "cudaStreamCreate" (cudaStream_t* pStream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamCreateWithFlags "cudaStreamCreateWithFlags" (cudaStream_t* pStream, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamCreateWithPriority "cudaStreamCreateWithPriority" (cudaStream_t* pStream, unsigned int flags, int priority) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamGetPriority "cudaStreamGetPriority" (cudaStream_t hStream, int* priority) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamGetFlags "cudaStreamGetFlags" (cudaStream_t hStream, unsigned int* flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamGetId "cudaStreamGetId" (cudaStream_t hStream, unsigned long long* streamId) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamGetDevice "cudaStreamGetDevice" (cudaStream_t hStream, int* device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaCtxResetPersistingL2Cache "cudaCtxResetPersistingL2Cache" () noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamCopyAttributes "cudaStreamCopyAttributes" (cudaStream_t dst, cudaStream_t src) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamGetAttribute "cudaStreamGetAttribute" (cudaStream_t hStream, cudaLaunchAttributeID attr, cudaLaunchAttributeValue* value_out) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamSetAttribute "cudaStreamSetAttribute" (cudaStream_t hStream, cudaLaunchAttributeID attr, const cudaLaunchAttributeValue* value) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamDestroy "cudaStreamDestroy" (cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamWaitEvent "cudaStreamWaitEvent" (cudaStream_t stream, cudaEvent_t event, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamAddCallback "cudaStreamAddCallback" (cudaStream_t stream, cudaStreamCallback_t callback, void* userData, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamSynchronize "cudaStreamSynchronize" (cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamQuery "cudaStreamQuery" (cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamAttachMemAsync "cudaStreamAttachMemAsync" (cudaStream_t stream, void* devPtr, size_t length, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamBeginCapture "cudaStreamBeginCapture" (cudaStream_t stream, cudaStreamCaptureMode mode) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamBeginCaptureToGraph "cudaStreamBeginCaptureToGraph" (cudaStream_t stream, cudaGraph_t graph, const cudaGraphNode_t* dependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, cudaStreamCaptureMode mode) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaThreadExchangeStreamCaptureMode "cudaThreadExchangeStreamCaptureMode" (cudaStreamCaptureMode* mode) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamEndCapture "cudaStreamEndCapture" (cudaStream_t stream, cudaGraph_t* pGraph) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamIsCapturing "cudaStreamIsCapturing" (cudaStream_t stream, cudaStreamCaptureStatus* pCaptureStatus) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamUpdateCaptureDependencies "cudaStreamUpdateCaptureDependencies" (cudaStream_t stream, cudaGraphNode_t* dependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaEventCreate "cudaEventCreate" (cudaEvent_t* event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaEventCreateWithFlags "cudaEventCreateWithFlags" (cudaEvent_t* event, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaEventRecord "cudaEventRecord" (cudaEvent_t event, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaEventRecordWithFlags "cudaEventRecordWithFlags" (cudaEvent_t event, cudaStream_t stream, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaEventQuery "cudaEventQuery" (cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaEventSynchronize "cudaEventSynchronize" (cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaEventDestroy "cudaEventDestroy" (cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaEventElapsedTime "cudaEventElapsedTime" (float* ms, cudaEvent_t start, cudaEvent_t end) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaImportExternalMemory "cudaImportExternalMemory" (cudaExternalMemory_t* extMem_out, const cudaExternalMemoryHandleDesc* memHandleDesc) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaExternalMemoryGetMappedBuffer "cudaExternalMemoryGetMappedBuffer" (void** devPtr, cudaExternalMemory_t extMem, const cudaExternalMemoryBufferDesc* bufferDesc) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaExternalMemoryGetMappedMipmappedArray "cudaExternalMemoryGetMappedMipmappedArray" (cudaMipmappedArray_t* mipmap, cudaExternalMemory_t extMem, const cudaExternalMemoryMipmappedArrayDesc* mipmapDesc) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDestroyExternalMemory "cudaDestroyExternalMemory" (cudaExternalMemory_t extMem) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaImportExternalSemaphore "cudaImportExternalSemaphore" (cudaExternalSemaphore_t* extSem_out, const cudaExternalSemaphoreHandleDesc* semHandleDesc) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDestroyExternalSemaphore "cudaDestroyExternalSemaphore" (cudaExternalSemaphore_t extSem) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFuncSetCacheConfig "cudaFuncSetCacheConfig" (const void* func, cudaFuncCache cacheConfig) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFuncGetAttributes "cudaFuncGetAttributes" (cudaFuncAttributes* attr, const void* func) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFuncSetAttribute "cudaFuncSetAttribute" (const void* func, cudaFuncAttribute attr, int value) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFuncGetName "cudaFuncGetName" (const char** name, const void* func) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFuncGetParamInfo "cudaFuncGetParamInfo" (const void* func, size_t paramIndex, size_t* paramOffset, size_t* paramSize) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLaunchHostFunc "cudaLaunchHostFunc" (cudaStream_t stream, cudaHostFn_t fn, void* userData) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFuncSetSharedMemConfig "cudaFuncSetSharedMemConfig" (const void* func, cudaSharedMemConfig config) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaOccupancyMaxActiveBlocksPerMultiprocessor "cudaOccupancyMaxActiveBlocksPerMultiprocessor" (int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaOccupancyAvailableDynamicSMemPerBlock "cudaOccupancyAvailableDynamicSMemPerBlock" (size_t* dynamicSmemSize, const void* func, int numBlocks, int blockSize) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags "cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags" (int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMallocManaged "cudaMallocManaged" (void** devPtr, size_t size, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMalloc "cudaMalloc" (void** devPtr, size_t size) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMallocHost "cudaMallocHost" (void** ptr, size_t size) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMallocPitch "cudaMallocPitch" (void** devPtr, size_t* pitch, size_t width, size_t height) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMallocArray "cudaMallocArray" (cudaArray_t* array, const cudaChannelFormatDesc* desc, size_t width, size_t height, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFree "cudaFree" (void* devPtr) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFreeHost "cudaFreeHost" (void* ptr) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFreeArray "cudaFreeArray" (cudaArray_t array) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFreeMipmappedArray "cudaFreeMipmappedArray" (cudaMipmappedArray_t mipmappedArray) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaHostAlloc "cudaHostAlloc" (void** pHost, size_t size, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaHostRegister "cudaHostRegister" (void* ptr, size_t size, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaHostUnregister "cudaHostUnregister" (void* ptr) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaHostGetDevicePointer "cudaHostGetDevicePointer" (void** pDevice, void* pHost, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaHostGetFlags "cudaHostGetFlags" (unsigned int* pFlags, void* pHost) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMalloc3D "cudaMalloc3D" (cudaPitchedPtr* pitchedDevPtr, cudaExtent extent) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMalloc3DArray "cudaMalloc3DArray" (cudaArray_t* array, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMallocMipmappedArray "cudaMallocMipmappedArray" (cudaMipmappedArray_t* mipmappedArray, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int numLevels, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetMipmappedArrayLevel "cudaGetMipmappedArrayLevel" (cudaArray_t* levelArray, cudaMipmappedArray_const_t mipmappedArray, unsigned int level) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy3D "cudaMemcpy3D" (const cudaMemcpy3DParms* p) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy3DPeer "cudaMemcpy3DPeer" (const cudaMemcpy3DPeerParms* p) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy3DAsync "cudaMemcpy3DAsync" (const cudaMemcpy3DParms* p, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy3DPeerAsync "cudaMemcpy3DPeerAsync" (const cudaMemcpy3DPeerParms* p, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemGetInfo "cudaMemGetInfo" (size_t* free, size_t* total) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaArrayGetInfo "cudaArrayGetInfo" (cudaChannelFormatDesc* desc, cudaExtent* extent, unsigned int* flags, cudaArray_t array) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaArrayGetPlane "cudaArrayGetPlane" (cudaArray_t* pPlaneArray, cudaArray_t hArray, unsigned int planeIdx) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaArrayGetMemoryRequirements "cudaArrayGetMemoryRequirements" (cudaArrayMemoryRequirements* memoryRequirements, cudaArray_t array, int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMipmappedArrayGetMemoryRequirements "cudaMipmappedArrayGetMemoryRequirements" (cudaArrayMemoryRequirements* memoryRequirements, cudaMipmappedArray_t mipmap, int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaArrayGetSparseProperties "cudaArrayGetSparseProperties" (cudaArraySparseProperties* sparseProperties, cudaArray_t array) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMipmappedArrayGetSparseProperties "cudaMipmappedArrayGetSparseProperties" (cudaArraySparseProperties* sparseProperties, cudaMipmappedArray_t mipmap) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy "cudaMemcpy" (void* dst, const void* src, size_t count, cudaMemcpyKind kind) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpyPeer "cudaMemcpyPeer" (void* dst, int dstDevice, const void* src, int srcDevice, size_t count) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy2D "cudaMemcpy2D" (void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy2DToArray "cudaMemcpy2DToArray" (cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy2DFromArray "cudaMemcpy2DFromArray" (void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy2DArrayToArray "cudaMemcpy2DArrayToArray" (cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t width, size_t height, cudaMemcpyKind kind) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpyAsync "cudaMemcpyAsync" (void* dst, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpyPeerAsync "cudaMemcpyPeerAsync" (void* dst, int dstDevice, const void* src, int srcDevice, size_t count, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpyBatchAsync "cudaMemcpyBatchAsync" (void** dsts, const void** srcs, const size_t* sizes, size_t count, cudaMemcpyAttributes* attrs, size_t* attrsIdxs, size_t numAttrs, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy3DBatchAsync "cudaMemcpy3DBatchAsync" (size_t numOps, cudaMemcpy3DBatchOp* opList, unsigned long long flags, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy2DAsync "cudaMemcpy2DAsync" (void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy2DToArrayAsync "cudaMemcpy2DToArrayAsync" (cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy2DFromArrayAsync "cudaMemcpy2DFromArrayAsync" (void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemset "cudaMemset" (void* devPtr, int value, size_t count) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemset2D "cudaMemset2D" (void* devPtr, size_t pitch, int value, size_t width, size_t height) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemset3D "cudaMemset3D" (cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemsetAsync "cudaMemsetAsync" (void* devPtr, int value, size_t count, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemset2DAsync "cudaMemset2DAsync" (void* devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemset3DAsync "cudaMemset3DAsync" (cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPrefetchAsync "cudaMemPrefetchAsync" (const void* devPtr, size_t count, cudaMemLocation location, unsigned int flags, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemAdvise "cudaMemAdvise" (const void* devPtr, size_t count, cudaMemoryAdvise advice, cudaMemLocation location) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemRangeGetAttribute "cudaMemRangeGetAttribute" (void* data, size_t dataSize, cudaMemRangeAttribute attribute, const void* devPtr, size_t count) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemRangeGetAttributes "cudaMemRangeGetAttributes" (void** data, size_t* dataSizes, cudaMemRangeAttribute* attributes, size_t numAttributes, const void* devPtr, size_t count) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpyToArray "cudaMemcpyToArray" (cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpyFromArray "cudaMemcpyFromArray" (void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpyArrayToArray "cudaMemcpyArrayToArray" (cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t count, cudaMemcpyKind kind) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpyToArrayAsync "cudaMemcpyToArrayAsync" (cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpyFromArrayAsync "cudaMemcpyFromArrayAsync" (void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMallocAsync "cudaMallocAsync" (void** devPtr, size_t size, cudaStream_t hStream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFreeAsync "cudaFreeAsync" (void* devPtr, cudaStream_t hStream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPoolTrimTo "cudaMemPoolTrimTo" (cudaMemPool_t memPool, size_t minBytesToKeep) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPoolSetAttribute "cudaMemPoolSetAttribute" (cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPoolGetAttribute "cudaMemPoolGetAttribute" (cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPoolSetAccess "cudaMemPoolSetAccess" (cudaMemPool_t memPool, const cudaMemAccessDesc* descList, size_t count) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPoolGetAccess "cudaMemPoolGetAccess" (cudaMemAccessFlags* flags, cudaMemPool_t memPool, cudaMemLocation* location) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPoolCreate "cudaMemPoolCreate" (cudaMemPool_t* memPool, const cudaMemPoolProps* poolProps) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPoolDestroy "cudaMemPoolDestroy" (cudaMemPool_t memPool) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMallocFromPoolAsync "cudaMallocFromPoolAsync" (void** ptr, size_t size, cudaMemPool_t memPool, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPoolExportToShareableHandle "cudaMemPoolExportToShareableHandle" (void* shareableHandle, cudaMemPool_t memPool, cudaMemAllocationHandleType handleType, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPoolImportFromShareableHandle "cudaMemPoolImportFromShareableHandle" (cudaMemPool_t* memPool, void* shareableHandle, cudaMemAllocationHandleType handleType, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPoolExportPointer "cudaMemPoolExportPointer" (cudaMemPoolPtrExportData* exportData, void* ptr) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPoolImportPointer "cudaMemPoolImportPointer" (void** ptr, cudaMemPool_t memPool, cudaMemPoolPtrExportData* exportData) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaPointerGetAttributes "cudaPointerGetAttributes" (cudaPointerAttributes* attributes, const void* ptr) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceCanAccessPeer "cudaDeviceCanAccessPeer" (int* canAccessPeer, int device, int peerDevice) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceEnablePeerAccess "cudaDeviceEnablePeerAccess" (int peerDevice, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceDisablePeerAccess "cudaDeviceDisablePeerAccess" (int peerDevice) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphicsUnregisterResource "cudaGraphicsUnregisterResource" (cudaGraphicsResource_t resource) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphicsResourceSetMapFlags "cudaGraphicsResourceSetMapFlags" (cudaGraphicsResource_t resource, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphicsMapResources "cudaGraphicsMapResources" (int count, cudaGraphicsResource_t* resources, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphicsUnmapResources "cudaGraphicsUnmapResources" (int count, cudaGraphicsResource_t* resources, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphicsResourceGetMappedPointer "cudaGraphicsResourceGetMappedPointer" (void** devPtr, size_t* size, cudaGraphicsResource_t resource) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphicsSubResourceGetMappedArray "cudaGraphicsSubResourceGetMappedArray" (cudaArray_t* array, cudaGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphicsResourceGetMappedMipmappedArray "cudaGraphicsResourceGetMappedMipmappedArray" (cudaMipmappedArray_t* mipmappedArray, cudaGraphicsResource_t resource) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetChannelDesc "cudaGetChannelDesc" (cudaChannelFormatDesc* desc, cudaArray_const_t array) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaChannelFormatDesc _static_cudaCreateChannelDesc "cudaCreateChannelDesc" (int x, int y, int z, int w, cudaChannelFormatKind f) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaCreateTextureObject "cudaCreateTextureObject" (cudaTextureObject_t* pTexObject, const cudaResourceDesc* pResDesc, const cudaTextureDesc* pTexDesc, const cudaResourceViewDesc* pResViewDesc) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDestroyTextureObject "cudaDestroyTextureObject" (cudaTextureObject_t texObject) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetTextureObjectResourceDesc "cudaGetTextureObjectResourceDesc" (cudaResourceDesc* pResDesc, cudaTextureObject_t texObject) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetTextureObjectTextureDesc "cudaGetTextureObjectTextureDesc" (cudaTextureDesc* pTexDesc, cudaTextureObject_t texObject) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetTextureObjectResourceViewDesc "cudaGetTextureObjectResourceViewDesc" (cudaResourceViewDesc* pResViewDesc, cudaTextureObject_t texObject) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaCreateSurfaceObject "cudaCreateSurfaceObject" (cudaSurfaceObject_t* pSurfObject, const cudaResourceDesc* pResDesc) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDestroySurfaceObject "cudaDestroySurfaceObject" (cudaSurfaceObject_t surfObject) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetSurfaceObjectResourceDesc "cudaGetSurfaceObjectResourceDesc" (cudaResourceDesc* pResDesc, cudaSurfaceObject_t surfObject) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDriverGetVersion "cudaDriverGetVersion" (int* driverVersion) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaRuntimeGetVersion "cudaRuntimeGetVersion" (int* runtimeVersion) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphCreate "cudaGraphCreate" (cudaGraph_t* pGraph, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddKernelNode "cudaGraphAddKernelNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaKernelNodeParams* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphKernelNodeGetParams "cudaGraphKernelNodeGetParams" (cudaGraphNode_t node, cudaKernelNodeParams* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphKernelNodeSetParams "cudaGraphKernelNodeSetParams" (cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphKernelNodeCopyAttributes "cudaGraphKernelNodeCopyAttributes" (cudaGraphNode_t hDst, cudaGraphNode_t hSrc) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphKernelNodeGetAttribute "cudaGraphKernelNodeGetAttribute" (cudaGraphNode_t hNode, cudaLaunchAttributeID attr, cudaLaunchAttributeValue* value_out) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphKernelNodeSetAttribute "cudaGraphKernelNodeSetAttribute" (cudaGraphNode_t hNode, cudaLaunchAttributeID attr, const cudaLaunchAttributeValue* value) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddMemcpyNode "cudaGraphAddMemcpyNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemcpy3DParms* pCopyParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddMemcpyNode1D "cudaGraphAddMemcpyNode1D" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dst, const void* src, size_t count, cudaMemcpyKind kind) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphMemcpyNodeGetParams "cudaGraphMemcpyNodeGetParams" (cudaGraphNode_t node, cudaMemcpy3DParms* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphMemcpyNodeSetParams "cudaGraphMemcpyNodeSetParams" (cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphMemcpyNodeSetParams1D "cudaGraphMemcpyNodeSetParams1D" (cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddMemsetNode "cudaGraphAddMemsetNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemsetParams* pMemsetParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphMemsetNodeGetParams "cudaGraphMemsetNodeGetParams" (cudaGraphNode_t node, cudaMemsetParams* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphMemsetNodeSetParams "cudaGraphMemsetNodeSetParams" (cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddHostNode "cudaGraphAddHostNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaHostNodeParams* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphHostNodeGetParams "cudaGraphHostNodeGetParams" (cudaGraphNode_t node, cudaHostNodeParams* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphHostNodeSetParams "cudaGraphHostNodeSetParams" (cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddChildGraphNode "cudaGraphAddChildGraphNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaGraph_t childGraph) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphChildGraphNodeGetGraph "cudaGraphChildGraphNodeGetGraph" (cudaGraphNode_t node, cudaGraph_t* pGraph) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddEmptyNode "cudaGraphAddEmptyNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddEventRecordNode "cudaGraphAddEventRecordNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphEventRecordNodeGetEvent "cudaGraphEventRecordNodeGetEvent" (cudaGraphNode_t node, cudaEvent_t* event_out) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphEventRecordNodeSetEvent "cudaGraphEventRecordNodeSetEvent" (cudaGraphNode_t node, cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddEventWaitNode "cudaGraphAddEventWaitNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphEventWaitNodeGetEvent "cudaGraphEventWaitNodeGetEvent" (cudaGraphNode_t node, cudaEvent_t* event_out) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphEventWaitNodeSetEvent "cudaGraphEventWaitNodeSetEvent" (cudaGraphNode_t node, cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddExternalSemaphoresSignalNode "cudaGraphAddExternalSemaphoresSignalNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreSignalNodeParams* nodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExternalSemaphoresSignalNodeGetParams "cudaGraphExternalSemaphoresSignalNodeGetParams" (cudaGraphNode_t hNode, cudaExternalSemaphoreSignalNodeParams* params_out) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExternalSemaphoresSignalNodeSetParams "cudaGraphExternalSemaphoresSignalNodeSetParams" (cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddExternalSemaphoresWaitNode "cudaGraphAddExternalSemaphoresWaitNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreWaitNodeParams* nodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExternalSemaphoresWaitNodeGetParams "cudaGraphExternalSemaphoresWaitNodeGetParams" (cudaGraphNode_t hNode, cudaExternalSemaphoreWaitNodeParams* params_out) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExternalSemaphoresWaitNodeSetParams "cudaGraphExternalSemaphoresWaitNodeSetParams" (cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddMemAllocNode "cudaGraphAddMemAllocNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaMemAllocNodeParams* nodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphMemAllocNodeGetParams "cudaGraphMemAllocNodeGetParams" (cudaGraphNode_t node, cudaMemAllocNodeParams* params_out) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddMemFreeNode "cudaGraphAddMemFreeNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dptr) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphMemFreeNodeGetParams "cudaGraphMemFreeNodeGetParams" (cudaGraphNode_t node, void* dptr_out) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGraphMemTrim "cudaDeviceGraphMemTrim" (int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetGraphMemAttribute "cudaDeviceGetGraphMemAttribute" (int device, cudaGraphMemAttributeType attr, void* value) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceSetGraphMemAttribute "cudaDeviceSetGraphMemAttribute" (int device, cudaGraphMemAttributeType attr, void* value) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphClone "cudaGraphClone" (cudaGraph_t* pGraphClone, cudaGraph_t originalGraph) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphNodeFindInClone "cudaGraphNodeFindInClone" (cudaGraphNode_t* pNode, cudaGraphNode_t originalNode, cudaGraph_t clonedGraph) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphNodeGetType "cudaGraphNodeGetType" (cudaGraphNode_t node, cudaGraphNodeType* pType) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphGetNodes "cudaGraphGetNodes" (cudaGraph_t graph, cudaGraphNode_t* nodes, size_t* numNodes) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphGetRootNodes "cudaGraphGetRootNodes" (cudaGraph_t graph, cudaGraphNode_t* pRootNodes, size_t* pNumRootNodes) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphGetEdges "cudaGraphGetEdges" (cudaGraph_t graph, cudaGraphNode_t* from_, cudaGraphNode_t* to, cudaGraphEdgeData* edgeData, size_t* numEdges) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphNodeGetDependencies "cudaGraphNodeGetDependencies" (cudaGraphNode_t node, cudaGraphNode_t* pDependencies, cudaGraphEdgeData* edgeData, size_t* pNumDependencies) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphNodeGetDependentNodes "cudaGraphNodeGetDependentNodes" (cudaGraphNode_t node, cudaGraphNode_t* pDependentNodes, cudaGraphEdgeData* edgeData, size_t* pNumDependentNodes) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddDependencies "cudaGraphAddDependencies" (cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, const cudaGraphEdgeData* edgeData, size_t numDependencies) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphRemoveDependencies "cudaGraphRemoveDependencies" (cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, const cudaGraphEdgeData* edgeData, size_t numDependencies) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphDestroyNode "cudaGraphDestroyNode" (cudaGraphNode_t node) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphInstantiate "cudaGraphInstantiate" (cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphInstantiateWithFlags "cudaGraphInstantiateWithFlags" (cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphInstantiateWithParams "cudaGraphInstantiateWithParams" (cudaGraphExec_t* pGraphExec, cudaGraph_t graph, cudaGraphInstantiateParams* instantiateParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecGetFlags "cudaGraphExecGetFlags" (cudaGraphExec_t graphExec, unsigned long long* flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecKernelNodeSetParams "cudaGraphExecKernelNodeSetParams" (cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecMemcpyNodeSetParams "cudaGraphExecMemcpyNodeSetParams" (cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecMemcpyNodeSetParams1D "cudaGraphExecMemcpyNodeSetParams1D" (cudaGraphExec_t hGraphExec, cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecMemsetNodeSetParams "cudaGraphExecMemsetNodeSetParams" (cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecHostNodeSetParams "cudaGraphExecHostNodeSetParams" (cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecChildGraphNodeSetParams "cudaGraphExecChildGraphNodeSetParams" (cudaGraphExec_t hGraphExec, cudaGraphNode_t node, cudaGraph_t childGraph) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecEventRecordNodeSetEvent "cudaGraphExecEventRecordNodeSetEvent" (cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecEventWaitNodeSetEvent "cudaGraphExecEventWaitNodeSetEvent" (cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecExternalSemaphoresSignalNodeSetParams "cudaGraphExecExternalSemaphoresSignalNodeSetParams" (cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecExternalSemaphoresWaitNodeSetParams "cudaGraphExecExternalSemaphoresWaitNodeSetParams" (cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphNodeSetEnabled "cudaGraphNodeSetEnabled" (cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int isEnabled) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphNodeGetEnabled "cudaGraphNodeGetEnabled" (cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int* isEnabled) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecUpdate "cudaGraphExecUpdate" (cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphExecUpdateResultInfo* resultInfo) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphUpload "cudaGraphUpload" (cudaGraphExec_t graphExec, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphLaunch "cudaGraphLaunch" (cudaGraphExec_t graphExec, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecDestroy "cudaGraphExecDestroy" (cudaGraphExec_t graphExec) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphDestroy "cudaGraphDestroy" (cudaGraph_t graph) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphDebugDotPrint "cudaGraphDebugDotPrint" (cudaGraph_t graph, const char* path, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaUserObjectCreate "cudaUserObjectCreate" (cudaUserObject_t* object_out, void* ptr, cudaHostFn_t destroy, unsigned int initialRefcount, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaUserObjectRetain "cudaUserObjectRetain" (cudaUserObject_t object, unsigned int count) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaUserObjectRelease "cudaUserObjectRelease" (cudaUserObject_t object, unsigned int count) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphRetainUserObject "cudaGraphRetainUserObject" (cudaGraph_t graph, cudaUserObject_t object, unsigned int count, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphReleaseUserObject "cudaGraphReleaseUserObject" (cudaGraph_t graph, cudaUserObject_t object, unsigned int count) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddNode "cudaGraphAddNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, cudaGraphNodeParams* nodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphNodeSetParams "cudaGraphNodeSetParams" (cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecNodeSetParams "cudaGraphExecNodeSetParams" (cudaGraphExec_t graphExec, cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphConditionalHandleCreate "cudaGraphConditionalHandleCreate" (cudaGraphConditionalHandle* pHandle_out, cudaGraph_t graph, unsigned int defaultLaunchValue, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetDriverEntryPoint "cudaGetDriverEntryPoint" (const char* symbol, void** funcPtr, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetDriverEntryPointByVersion "cudaGetDriverEntryPointByVersion" (const char* symbol, void** funcPtr, unsigned int cudaVersion, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLibraryLoadData "cudaLibraryLoadData" (cudaLibrary_t* library, const void* code, cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLibraryLoadFromFile "cudaLibraryLoadFromFile" (cudaLibrary_t* library, const char* fileName, cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLibraryUnload "cudaLibraryUnload" (cudaLibrary_t library) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLibraryGetKernel "cudaLibraryGetKernel" (cudaKernel_t* pKernel, cudaLibrary_t library, const char* name) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLibraryGetGlobal "cudaLibraryGetGlobal" (void** dptr, size_t* bytes, cudaLibrary_t library, const char* name) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLibraryGetManaged "cudaLibraryGetManaged" (void** dptr, size_t* bytes, cudaLibrary_t library, const char* name) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLibraryGetUnifiedFunction "cudaLibraryGetUnifiedFunction" (void** fptr, cudaLibrary_t library, const char* symbol) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLibraryGetKernelCount "cudaLibraryGetKernelCount" (unsigned int* count, cudaLibrary_t lib) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLibraryEnumerateKernels "cudaLibraryEnumerateKernels" (cudaKernel_t* kernels, unsigned int numKernels, cudaLibrary_t lib) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaKernelSetAttributeForDevice "cudaKernelSetAttributeForDevice" (cudaKernel_t kernel, cudaFuncAttribute attr, int value, int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetExportTable "cudaGetExportTable" (const void** ppExportTable, const cudaUUID_t* pExportTableId) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetKernel "cudaGetKernel" (cudaKernel_t* kernelPtr, const void* entryFuncAddr) noexcept + +cdef extern from 'cuda_profiler_api.h' nogil: + cudaError_t _static_cudaProfilerStart "cudaProfilerStart" () noexcept + +cdef extern from 'cuda_profiler_api.h' nogil: + cudaError_t _static_cudaProfilerStop "cudaProfilerStop" () noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetDeviceProperties "cudaGetDeviceProperties" (cudaDeviceProp* prop, int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetHostAtomicCapabilities "cudaDeviceGetHostAtomicCapabilities" (unsigned int* capabilities, const cudaAtomicOperation* operations, unsigned int count, int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetP2PAtomicCapabilities "cudaDeviceGetP2PAtomicCapabilities" (unsigned int* capabilities, const cudaAtomicOperation* operations, unsigned int count, int srcDevice, int dstDevice) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamGetCaptureInfo "cudaStreamGetCaptureInfo" (cudaStream_t stream, cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out, cudaGraph_t* graph_out, const cudaGraphNode_t** dependencies_out, const cudaGraphEdgeData** edgeData_out, size_t* numDependencies_out) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaSignalExternalSemaphoresAsync "cudaSignalExternalSemaphoresAsync" (const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreSignalParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaWaitExternalSemaphoresAsync "cudaWaitExternalSemaphoresAsync" (const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreWaitParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPrefetchBatchAsync "cudaMemPrefetchBatchAsync" (void** dptrs, size_t* sizes, size_t count, cudaMemLocation* prefetchLocs, size_t* prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemDiscardBatchAsync "cudaMemDiscardBatchAsync" (void** dptrs, size_t* sizes, size_t count, unsigned long long flags, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemDiscardAndPrefetchBatchAsync "cudaMemDiscardAndPrefetchBatchAsync" (void** dptrs, size_t* sizes, size_t count, cudaMemLocation* prefetchLocs, size_t* prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemGetDefaultMemPool "cudaMemGetDefaultMemPool" (cudaMemPool_t* memPool, cudaMemLocation* location, cudaMemAllocationType type) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemGetMemPool "cudaMemGetMemPool" (cudaMemPool_t* memPool, cudaMemLocation* location, cudaMemAllocationType type) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemSetMemPool "cudaMemSetMemPool" (cudaMemLocation* location, cudaMemAllocationType type, cudaMemPool_t memPool) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLogsRegisterCallback "cudaLogsRegisterCallback" (cudaLogsCallback_t callbackFunc, void* userData, cudaLogsCallbackHandle* callback_out) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLogsUnregisterCallback "cudaLogsUnregisterCallback" (cudaLogsCallbackHandle callback) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLogsCurrent "cudaLogsCurrent" (cudaLogIterator* iterator_out, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLogsDumpToFile "cudaLogsDumpToFile" (cudaLogIterator* iterator, const char* pathToFile, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLogsDumpToMemory "cudaLogsDumpToMemory" (cudaLogIterator* iterator, char* buffer, size_t* size, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphNodeGetContainingGraph "cudaGraphNodeGetContainingGraph" (cudaGraphNode_t hNode, cudaGraph_t* phGraph) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphNodeGetLocalId "cudaGraphNodeGetLocalId" (cudaGraphNode_t hNode, unsigned int* nodeId) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphNodeGetToolsId "cudaGraphNodeGetToolsId" (cudaGraphNode_t hNode, unsigned long long* toolsNodeId) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphGetId "cudaGraphGetId" (cudaGraph_t hGraph, unsigned int* graphID) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecGetId "cudaGraphExecGetId" (cudaGraphExec_t hGraphExec, unsigned int* graphID) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphConditionalHandleCreate_v2 "cudaGraphConditionalHandleCreate_v2" (cudaGraphConditionalHandle* pHandle_out, cudaGraph_t graph, cudaExecutionContext_t ctx, unsigned int defaultLaunchValue, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetDevResource "cudaDeviceGetDevResource" (int device, cudaDevResource* resource, cudaDevResourceType type) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDevSmResourceSplitByCount "cudaDevSmResourceSplitByCount" (cudaDevResource* result, unsigned int* nbGroups, const cudaDevResource* input, cudaDevResource* remaining, unsigned int flags, unsigned int minCount) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDevSmResourceSplit "cudaDevSmResourceSplit" (cudaDevResource* result, unsigned int nbGroups, const cudaDevResource* input, cudaDevResource* remainder, unsigned int flags, cudaDevSmResourceGroupParams* groupParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDevResourceGenerateDesc "cudaDevResourceGenerateDesc" (cudaDevResourceDesc_t* phDesc, cudaDevResource* resources, unsigned int nbResources) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGreenCtxCreate "cudaGreenCtxCreate" (cudaExecutionContext_t* phCtx, cudaDevResourceDesc_t desc, int device, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaExecutionCtxDestroy "cudaExecutionCtxDestroy" (cudaExecutionContext_t ctx) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaExecutionCtxGetDevResource "cudaExecutionCtxGetDevResource" (cudaExecutionContext_t ctx, cudaDevResource* resource, cudaDevResourceType type) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaExecutionCtxGetDevice "cudaExecutionCtxGetDevice" (int* device, cudaExecutionContext_t ctx) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaExecutionCtxGetId "cudaExecutionCtxGetId" (cudaExecutionContext_t ctx, unsigned long long* ctxId) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaExecutionCtxStreamCreate "cudaExecutionCtxStreamCreate" (cudaStream_t* phStream, cudaExecutionContext_t ctx, unsigned int flags, int priority) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaExecutionCtxSynchronize "cudaExecutionCtxSynchronize" (cudaExecutionContext_t ctx) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamGetDevResource "cudaStreamGetDevResource" (cudaStream_t hStream, cudaDevResource* resource, cudaDevResourceType type) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaExecutionCtxRecordEvent "cudaExecutionCtxRecordEvent" (cudaExecutionContext_t ctx, cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaExecutionCtxWaitEvent "cudaExecutionCtxWaitEvent" (cudaExecutionContext_t ctx, cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetExecutionCtx "cudaDeviceGetExecutionCtx" (cudaExecutionContext_t* ctx, int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFuncGetParamCount "cudaFuncGetParamCount" (const void* func, size_t* paramCount) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLaunchHostFunc_v2 "cudaLaunchHostFunc_v2" (cudaStream_t stream, cudaHostFn_t fn, void* userData, unsigned int syncMode) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpyWithAttributesAsync "cudaMemcpyWithAttributesAsync" (void* dst, const void* src, size_t size, cudaMemcpyAttributes* attr, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy3DWithAttributesAsync "cudaMemcpy3DWithAttributesAsync" (cudaMemcpy3DBatchOp* op, unsigned long long flags, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphNodeGetParams "cudaGraphNodeGetParams" (cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamBeginRecaptureToGraph "cudaStreamBeginRecaptureToGraph" (cudaStream_t stream, cudaStreamCaptureMode mode, cudaGraph_t graph, cudaGraphRecaptureCallbackData* callbackData) noexcept + + +############################################################################### +# Wrapper functions +############################################################################### + +cdef cudaError_t _cudaDeviceReset() except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaDeviceReset() + return _static_cudaDeviceReset() + + +cdef cudaError_t _cudaDeviceSynchronize() except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaDeviceSynchronize() + return _static_cudaDeviceSynchronize() + + +cdef cudaError_t _cudaDeviceSetLimit(cudaLimit limit, size_t value) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaDeviceSetLimit(limit, value) + return _static_cudaDeviceSetLimit(limit, value) + + +cdef cudaError_t _cudaDeviceGetLimit(size_t* pValue, cudaLimit limit) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaDeviceGetLimit(pValue, limit) + return _static_cudaDeviceGetLimit(pValue, limit) + + +cdef cudaError_t _cudaDeviceGetTexture1DLinearMaxWidth(size_t* maxWidthInElements, const cudaChannelFormatDesc* fmtDesc, int device) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaDeviceGetTexture1DLinearMaxWidth(maxWidthInElements, fmtDesc, device) + return _static_cudaDeviceGetTexture1DLinearMaxWidth(maxWidthInElements, fmtDesc, device) + + +cdef cudaError_t _cudaDeviceGetCacheConfig(cudaFuncCache* pCacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaDeviceGetCacheConfig(pCacheConfig) + return _static_cudaDeviceGetCacheConfig(pCacheConfig) + + +cdef cudaError_t _cudaDeviceGetStreamPriorityRange(int* leastPriority, int* greatestPriority) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaDeviceGetStreamPriorityRange(leastPriority, greatestPriority) + return _static_cudaDeviceGetStreamPriorityRange(leastPriority, greatestPriority) + + +cdef cudaError_t _cudaDeviceSetCacheConfig(cudaFuncCache cacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaDeviceSetCacheConfig(cacheConfig) + return _static_cudaDeviceSetCacheConfig(cacheConfig) + + +cdef cudaError_t _cudaDeviceGetByPCIBusId(int* device, const char* pciBusId) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaDeviceGetByPCIBusId(device, pciBusId) + return _static_cudaDeviceGetByPCIBusId(device, pciBusId) + + +cdef cudaError_t _cudaDeviceGetPCIBusId(char* pciBusId, int len, int device) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaDeviceGetPCIBusId(pciBusId, len, device) + return _static_cudaDeviceGetPCIBusId(pciBusId, len, device) + + +cdef cudaError_t _cudaIpcGetEventHandle(cudaIpcEventHandle_t* handle, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaIpcGetEventHandle(handle, event) + return _static_cudaIpcGetEventHandle(handle, event) + + +cdef cudaError_t _cudaIpcOpenEventHandle(cudaEvent_t* event, cudaIpcEventHandle_t handle) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaIpcOpenEventHandle(event, handle) + return _static_cudaIpcOpenEventHandle(event, handle) + + +cdef cudaError_t _cudaIpcGetMemHandle(cudaIpcMemHandle_t* handle, void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaIpcGetMemHandle(handle, devPtr) + return _static_cudaIpcGetMemHandle(handle, devPtr) + + +cdef cudaError_t _cudaIpcOpenMemHandle(void** devPtr, cudaIpcMemHandle_t handle, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaIpcOpenMemHandle(devPtr, handle, flags) + return _static_cudaIpcOpenMemHandle(devPtr, handle, flags) + + +cdef cudaError_t _cudaIpcCloseMemHandle(void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaIpcCloseMemHandle(devPtr) + return _static_cudaIpcCloseMemHandle(devPtr) + + +cdef cudaError_t _cudaDeviceFlushGPUDirectRDMAWrites(cudaFlushGPUDirectRDMAWritesTarget target, cudaFlushGPUDirectRDMAWritesScope scope) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaDeviceFlushGPUDirectRDMAWrites(target, scope) + return _static_cudaDeviceFlushGPUDirectRDMAWrites(target, scope) + + +cdef cudaError_t _cudaDeviceRegisterAsyncNotification(int device, cudaAsyncCallback callbackFunc, void* userData, cudaAsyncCallbackHandle_t* callback) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaDeviceRegisterAsyncNotification(device, callbackFunc, userData, callback) + return _static_cudaDeviceRegisterAsyncNotification(device, callbackFunc, userData, callback) + + +cdef cudaError_t _cudaDeviceUnregisterAsyncNotification(int device, cudaAsyncCallbackHandle_t callback) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaDeviceUnregisterAsyncNotification(device, callback) + return _static_cudaDeviceUnregisterAsyncNotification(device, callback) + + +cdef cudaError_t _cudaDeviceGetSharedMemConfig(cudaSharedMemConfig* pConfig) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaDeviceGetSharedMemConfig(pConfig) + return _static_cudaDeviceGetSharedMemConfig(pConfig) + + +cdef cudaError_t _cudaDeviceSetSharedMemConfig(cudaSharedMemConfig config) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaDeviceSetSharedMemConfig(config) + return _static_cudaDeviceSetSharedMemConfig(config) + + +cdef cudaError_t _cudaGetLastError() except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGetLastError() + return _static_cudaGetLastError() + + +cdef cudaError_t _cudaPeekAtLastError() except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaPeekAtLastError() + return _static_cudaPeekAtLastError() + + +cdef const char* _cudaGetErrorName(cudaError_t error) except?NULL nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGetErrorName(error) + return _static_cudaGetErrorName(error) + + +cdef const char* _cudaGetErrorString(cudaError_t error) except?NULL nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGetErrorString(error) + return _static_cudaGetErrorString(error) + + +cdef cudaError_t _cudaGetDeviceCount(int* count) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGetDeviceCount(count) + return _static_cudaGetDeviceCount(count) + + +cdef cudaError_t _cudaDeviceGetAttribute(int* value, cudaDeviceAttr attr, int device) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaDeviceGetAttribute(value, attr, device) + return _static_cudaDeviceGetAttribute(value, attr, device) + + +cdef cudaError_t _cudaDeviceGetDefaultMemPool(cudaMemPool_t* memPool, int device) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaDeviceGetDefaultMemPool(memPool, device) + return _static_cudaDeviceGetDefaultMemPool(memPool, device) + + +cdef cudaError_t _cudaDeviceSetMemPool(int device, cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaDeviceSetMemPool(device, memPool) + return _static_cudaDeviceSetMemPool(device, memPool) + + +cdef cudaError_t _cudaDeviceGetMemPool(cudaMemPool_t* memPool, int device) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaDeviceGetMemPool(memPool, device) + return _static_cudaDeviceGetMemPool(memPool, device) + + +cdef cudaError_t _cudaDeviceGetNvSciSyncAttributes(void* nvSciSyncAttrList, int device, int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaDeviceGetNvSciSyncAttributes(nvSciSyncAttrList, device, flags) + return _static_cudaDeviceGetNvSciSyncAttributes(nvSciSyncAttrList, device, flags) + + +cdef cudaError_t _cudaDeviceGetP2PAttribute(int* value, cudaDeviceP2PAttr attr, int srcDevice, int dstDevice) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaDeviceGetP2PAttribute(value, attr, srcDevice, dstDevice) + return _static_cudaDeviceGetP2PAttribute(value, attr, srcDevice, dstDevice) + + +cdef cudaError_t _cudaChooseDevice(int* device, const cudaDeviceProp* prop) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaChooseDevice(device, prop) + return _static_cudaChooseDevice(device, prop) + + +cdef cudaError_t _cudaInitDevice(int device, unsigned int deviceFlags, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaInitDevice(device, deviceFlags, flags) + return _static_cudaInitDevice(device, deviceFlags, flags) + + +cdef cudaError_t _cudaSetDevice(int device) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaSetDevice(device) + return _static_cudaSetDevice(device) + + +cdef cudaError_t _cudaGetDevice(int* device) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGetDevice(device) + return _static_cudaGetDevice(device) + + +cdef cudaError_t _cudaSetDeviceFlags(unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaSetDeviceFlags(flags) + return _static_cudaSetDeviceFlags(flags) + + +cdef cudaError_t _cudaGetDeviceFlags(unsigned int* flags) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGetDeviceFlags(flags) + return _static_cudaGetDeviceFlags(flags) + + +cdef cudaError_t _cudaStreamCreate(cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaStreamCreate(pStream) + return _static_cudaStreamCreate(pStream) + + +cdef cudaError_t _cudaStreamCreateWithFlags(cudaStream_t* pStream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaStreamCreateWithFlags(pStream, flags) + return _static_cudaStreamCreateWithFlags(pStream, flags) + + +cdef cudaError_t _cudaStreamCreateWithPriority(cudaStream_t* pStream, unsigned int flags, int priority) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaStreamCreateWithPriority(pStream, flags, priority) + return _static_cudaStreamCreateWithPriority(pStream, flags, priority) + + +cdef cudaError_t _cudaStreamGetPriority(cudaStream_t hStream, int* priority) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaStreamGetPriority(hStream, priority) + return _static_cudaStreamGetPriority(hStream, priority) + + +cdef cudaError_t _cudaStreamGetFlags(cudaStream_t hStream, unsigned int* flags) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaStreamGetFlags(hStream, flags) + return _static_cudaStreamGetFlags(hStream, flags) + + +cdef cudaError_t _cudaStreamGetId(cudaStream_t hStream, unsigned long long* streamId) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaStreamGetId(hStream, streamId) + return _static_cudaStreamGetId(hStream, streamId) + + +cdef cudaError_t _cudaStreamGetDevice(cudaStream_t hStream, int* device) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaStreamGetDevice(hStream, device) + return _static_cudaStreamGetDevice(hStream, device) + + +cdef cudaError_t _cudaCtxResetPersistingL2Cache() except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaCtxResetPersistingL2Cache() + return _static_cudaCtxResetPersistingL2Cache() + + +cdef cudaError_t _cudaStreamCopyAttributes(cudaStream_t dst, cudaStream_t src) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaStreamCopyAttributes(dst, src) + return _static_cudaStreamCopyAttributes(dst, src) + + +cdef cudaError_t _cudaStreamGetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, cudaStreamAttrValue* value_out) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaStreamGetAttribute(hStream, attr, value_out) + return _static_cudaStreamGetAttribute(hStream, attr, value_out) + + +cdef cudaError_t _cudaStreamSetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, const cudaStreamAttrValue* value) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaStreamSetAttribute(hStream, attr, value) + return _static_cudaStreamSetAttribute(hStream, attr, value) + + +cdef cudaError_t _cudaStreamDestroy(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaStreamDestroy(stream) + return _static_cudaStreamDestroy(stream) + + +cdef cudaError_t _cudaStreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaStreamWaitEvent(stream, event, flags) + return _static_cudaStreamWaitEvent(stream, event, flags) + + +cdef cudaError_t _cudaStreamAddCallback(cudaStream_t stream, cudaStreamCallback_t callback, void* userData, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaStreamAddCallback(stream, callback, userData, flags) + return _static_cudaStreamAddCallback(stream, callback, userData, flags) + + +cdef cudaError_t _cudaStreamSynchronize(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaStreamSynchronize(stream) + return _static_cudaStreamSynchronize(stream) + + +cdef cudaError_t _cudaStreamQuery(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaStreamQuery(stream) + return _static_cudaStreamQuery(stream) + + +cdef cudaError_t _cudaStreamAttachMemAsync(cudaStream_t stream, void* devPtr, size_t length, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaStreamAttachMemAsync(stream, devPtr, length, flags) + return _static_cudaStreamAttachMemAsync(stream, devPtr, length, flags) + + +cdef cudaError_t _cudaStreamBeginCapture(cudaStream_t stream, cudaStreamCaptureMode mode) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaStreamBeginCapture(stream, mode) + return _static_cudaStreamBeginCapture(stream, mode) + + +cdef cudaError_t _cudaStreamBeginCaptureToGraph(cudaStream_t stream, cudaGraph_t graph, const cudaGraphNode_t* dependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, cudaStreamCaptureMode mode) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaStreamBeginCaptureToGraph(stream, graph, dependencies, dependencyData, numDependencies, mode) + return _static_cudaStreamBeginCaptureToGraph(stream, graph, dependencies, dependencyData, numDependencies, mode) + + +cdef cudaError_t _cudaThreadExchangeStreamCaptureMode(cudaStreamCaptureMode* mode) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaThreadExchangeStreamCaptureMode(mode) + return _static_cudaThreadExchangeStreamCaptureMode(mode) + + +cdef cudaError_t _cudaStreamEndCapture(cudaStream_t stream, cudaGraph_t* pGraph) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaStreamEndCapture(stream, pGraph) + return _static_cudaStreamEndCapture(stream, pGraph) + + +cdef cudaError_t _cudaStreamIsCapturing(cudaStream_t stream, cudaStreamCaptureStatus* pCaptureStatus) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaStreamIsCapturing(stream, pCaptureStatus) + return _static_cudaStreamIsCapturing(stream, pCaptureStatus) + + +cdef cudaError_t _cudaStreamUpdateCaptureDependencies(cudaStream_t stream, cudaGraphNode_t* dependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaStreamUpdateCaptureDependencies(stream, dependencies, dependencyData, numDependencies, flags) + return _static_cudaStreamUpdateCaptureDependencies(stream, dependencies, dependencyData, numDependencies, flags) + + +cdef cudaError_t _cudaEventCreate(cudaEvent_t* event) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaEventCreate(event) + return _static_cudaEventCreate(event) + + +cdef cudaError_t _cudaEventCreateWithFlags(cudaEvent_t* event, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaEventCreateWithFlags(event, flags) + return _static_cudaEventCreateWithFlags(event, flags) + + +cdef cudaError_t _cudaEventRecord(cudaEvent_t event, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaEventRecord(event, stream) + return _static_cudaEventRecord(event, stream) + + +cdef cudaError_t _cudaEventRecordWithFlags(cudaEvent_t event, cudaStream_t stream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaEventRecordWithFlags(event, stream, flags) + return _static_cudaEventRecordWithFlags(event, stream, flags) + + +cdef cudaError_t _cudaEventQuery(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaEventQuery(event) + return _static_cudaEventQuery(event) + + +cdef cudaError_t _cudaEventSynchronize(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaEventSynchronize(event) + return _static_cudaEventSynchronize(event) + + +cdef cudaError_t _cudaEventDestroy(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaEventDestroy(event) + return _static_cudaEventDestroy(event) + + +cdef cudaError_t _cudaEventElapsedTime(float* ms, cudaEvent_t start, cudaEvent_t end) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaEventElapsedTime(ms, start, end) + return _static_cudaEventElapsedTime(ms, start, end) + + +cdef cudaError_t _cudaImportExternalMemory(cudaExternalMemory_t* extMem_out, const cudaExternalMemoryHandleDesc* memHandleDesc) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaImportExternalMemory(extMem_out, memHandleDesc) + return _static_cudaImportExternalMemory(extMem_out, memHandleDesc) + + +cdef cudaError_t _cudaExternalMemoryGetMappedBuffer(void** devPtr, cudaExternalMemory_t extMem, const cudaExternalMemoryBufferDesc* bufferDesc) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaExternalMemoryGetMappedBuffer(devPtr, extMem, bufferDesc) + return _static_cudaExternalMemoryGetMappedBuffer(devPtr, extMem, bufferDesc) + + +cdef cudaError_t _cudaExternalMemoryGetMappedMipmappedArray(cudaMipmappedArray_t* mipmap, cudaExternalMemory_t extMem, const cudaExternalMemoryMipmappedArrayDesc* mipmapDesc) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaExternalMemoryGetMappedMipmappedArray(mipmap, extMem, mipmapDesc) + return _static_cudaExternalMemoryGetMappedMipmappedArray(mipmap, extMem, mipmapDesc) + + +cdef cudaError_t _cudaDestroyExternalMemory(cudaExternalMemory_t extMem) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaDestroyExternalMemory(extMem) + return _static_cudaDestroyExternalMemory(extMem) + + +cdef cudaError_t _cudaImportExternalSemaphore(cudaExternalSemaphore_t* extSem_out, const cudaExternalSemaphoreHandleDesc* semHandleDesc) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaImportExternalSemaphore(extSem_out, semHandleDesc) + return _static_cudaImportExternalSemaphore(extSem_out, semHandleDesc) + + +cdef cudaError_t _cudaDestroyExternalSemaphore(cudaExternalSemaphore_t extSem) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaDestroyExternalSemaphore(extSem) + return _static_cudaDestroyExternalSemaphore(extSem) + + +cdef cudaError_t _cudaFuncSetCacheConfig(const void* func, cudaFuncCache cacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaFuncSetCacheConfig(func, cacheConfig) + return _static_cudaFuncSetCacheConfig(func, cacheConfig) + + +cdef cudaError_t _cudaFuncGetAttributes(cudaFuncAttributes* attr, const void* func) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaFuncGetAttributes(attr, func) + return _static_cudaFuncGetAttributes(attr, func) + + +cdef cudaError_t _cudaFuncSetAttribute(const void* func, cudaFuncAttribute attr, int value) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaFuncSetAttribute(func, attr, value) + return _static_cudaFuncSetAttribute(func, attr, value) + + +cdef cudaError_t _cudaFuncGetName(const char** name, const void* func) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaFuncGetName(name, func) + return _static_cudaFuncGetName(name, func) + + +cdef cudaError_t _cudaFuncGetParamInfo(const void* func, size_t paramIndex, size_t* paramOffset, size_t* paramSize) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaFuncGetParamInfo(func, paramIndex, paramOffset, paramSize) + return _static_cudaFuncGetParamInfo(func, paramIndex, paramOffset, paramSize) + + +cdef cudaError_t _cudaLaunchHostFunc(cudaStream_t stream, cudaHostFn_t fn, void* userData) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaLaunchHostFunc(stream, fn, userData) + return _static_cudaLaunchHostFunc(stream, fn, userData) + + +cdef cudaError_t _cudaFuncSetSharedMemConfig(const void* func, cudaSharedMemConfig config) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaFuncSetSharedMemConfig(func, config) + return _static_cudaFuncSetSharedMemConfig(func, config) + + +cdef cudaError_t _cudaOccupancyMaxActiveBlocksPerMultiprocessor(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaOccupancyMaxActiveBlocksPerMultiprocessor(numBlocks, func, blockSize, dynamicSMemSize) + return _static_cudaOccupancyMaxActiveBlocksPerMultiprocessor(numBlocks, func, blockSize, dynamicSMemSize) + + +cdef cudaError_t _cudaOccupancyAvailableDynamicSMemPerBlock(size_t* dynamicSmemSize, const void* func, int numBlocks, int blockSize) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaOccupancyAvailableDynamicSMemPerBlock(dynamicSmemSize, func, numBlocks, blockSize) + return _static_cudaOccupancyAvailableDynamicSMemPerBlock(dynamicSmemSize, func, numBlocks, blockSize) + + +cdef cudaError_t _cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(numBlocks, func, blockSize, dynamicSMemSize, flags) + return _static_cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(numBlocks, func, blockSize, dynamicSMemSize, flags) + + +cdef cudaError_t _cudaMallocManaged(void** devPtr, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMallocManaged(devPtr, size, flags) + return _static_cudaMallocManaged(devPtr, size, flags) + + +cdef cudaError_t _cudaMalloc(void** devPtr, size_t size) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMalloc(devPtr, size) + return _static_cudaMalloc(devPtr, size) + + +cdef cudaError_t _cudaMallocHost(void** ptr, size_t size) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMallocHost(ptr, size) + return _static_cudaMallocHost(ptr, size) + + +cdef cudaError_t _cudaMallocPitch(void** devPtr, size_t* pitch, size_t width, size_t height) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMallocPitch(devPtr, pitch, width, height) + return _static_cudaMallocPitch(devPtr, pitch, width, height) + + +cdef cudaError_t _cudaMallocArray(cudaArray_t* array, const cudaChannelFormatDesc* desc, size_t width, size_t height, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMallocArray(array, desc, width, height, flags) + return _static_cudaMallocArray(array, desc, width, height, flags) + + +cdef cudaError_t _cudaFree(void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaFree(devPtr) + return _static_cudaFree(devPtr) + + +cdef cudaError_t _cudaFreeHost(void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaFreeHost(ptr) + return _static_cudaFreeHost(ptr) + + +cdef cudaError_t _cudaFreeArray(cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaFreeArray(array) + return _static_cudaFreeArray(array) + + +cdef cudaError_t _cudaFreeMipmappedArray(cudaMipmappedArray_t mipmappedArray) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaFreeMipmappedArray(mipmappedArray) + return _static_cudaFreeMipmappedArray(mipmappedArray) + + +cdef cudaError_t _cudaHostAlloc(void** pHost, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaHostAlloc(pHost, size, flags) + return _static_cudaHostAlloc(pHost, size, flags) + + +cdef cudaError_t _cudaHostRegister(void* ptr, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaHostRegister(ptr, size, flags) + return _static_cudaHostRegister(ptr, size, flags) + + +cdef cudaError_t _cudaHostUnregister(void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaHostUnregister(ptr) + return _static_cudaHostUnregister(ptr) + + +cdef cudaError_t _cudaHostGetDevicePointer(void** pDevice, void* pHost, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaHostGetDevicePointer(pDevice, pHost, flags) + return _static_cudaHostGetDevicePointer(pDevice, pHost, flags) + + +cdef cudaError_t _cudaHostGetFlags(unsigned int* pFlags, void* pHost) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaHostGetFlags(pFlags, pHost) + return _static_cudaHostGetFlags(pFlags, pHost) + + +cdef cudaError_t _cudaMalloc3D(cudaPitchedPtr* pitchedDevPtr, cudaExtent extent) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMalloc3D(pitchedDevPtr, extent) + return _static_cudaMalloc3D(pitchedDevPtr, extent) + + +cdef cudaError_t _cudaMalloc3DArray(cudaArray_t* array, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMalloc3DArray(array, desc, extent, flags) + return _static_cudaMalloc3DArray(array, desc, extent, flags) + + +cdef cudaError_t _cudaMallocMipmappedArray(cudaMipmappedArray_t* mipmappedArray, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int numLevels, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMallocMipmappedArray(mipmappedArray, desc, extent, numLevels, flags) + return _static_cudaMallocMipmappedArray(mipmappedArray, desc, extent, numLevels, flags) + + +cdef cudaError_t _cudaGetMipmappedArrayLevel(cudaArray_t* levelArray, cudaMipmappedArray_const_t mipmappedArray, unsigned int level) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGetMipmappedArrayLevel(levelArray, mipmappedArray, level) + return _static_cudaGetMipmappedArrayLevel(levelArray, mipmappedArray, level) + + +cdef cudaError_t _cudaMemcpy3D(const cudaMemcpy3DParms* p) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemcpy3D(p) + return _static_cudaMemcpy3D(p) + + +cdef cudaError_t _cudaMemcpy3DPeer(const cudaMemcpy3DPeerParms* p) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemcpy3DPeer(p) + return _static_cudaMemcpy3DPeer(p) + + +cdef cudaError_t _cudaMemcpy3DAsync(const cudaMemcpy3DParms* p, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemcpy3DAsync(p, stream) + return _static_cudaMemcpy3DAsync(p, stream) + + +cdef cudaError_t _cudaMemcpy3DPeerAsync(const cudaMemcpy3DPeerParms* p, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemcpy3DPeerAsync(p, stream) + return _static_cudaMemcpy3DPeerAsync(p, stream) + + +cdef cudaError_t _cudaMemGetInfo(size_t* free, size_t* total) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemGetInfo(free, total) + return _static_cudaMemGetInfo(free, total) + + +cdef cudaError_t _cudaArrayGetInfo(cudaChannelFormatDesc* desc, cudaExtent* extent, unsigned int* flags, cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaArrayGetInfo(desc, extent, flags, array) + return _static_cudaArrayGetInfo(desc, extent, flags, array) + + +cdef cudaError_t _cudaArrayGetPlane(cudaArray_t* pPlaneArray, cudaArray_t hArray, unsigned int planeIdx) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaArrayGetPlane(pPlaneArray, hArray, planeIdx) + return _static_cudaArrayGetPlane(pPlaneArray, hArray, planeIdx) + + +cdef cudaError_t _cudaArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaArray_t array, int device) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaArrayGetMemoryRequirements(memoryRequirements, array, device) + return _static_cudaArrayGetMemoryRequirements(memoryRequirements, array, device) + + +cdef cudaError_t _cudaMipmappedArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaMipmappedArray_t mipmap, int device) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMipmappedArrayGetMemoryRequirements(memoryRequirements, mipmap, device) + return _static_cudaMipmappedArrayGetMemoryRequirements(memoryRequirements, mipmap, device) + + +cdef cudaError_t _cudaArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaArrayGetSparseProperties(sparseProperties, array) + return _static_cudaArrayGetSparseProperties(sparseProperties, array) + + +cdef cudaError_t _cudaMipmappedArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaMipmappedArray_t mipmap) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMipmappedArrayGetSparseProperties(sparseProperties, mipmap) + return _static_cudaMipmappedArrayGetSparseProperties(sparseProperties, mipmap) + + +cdef cudaError_t _cudaMemcpy(void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemcpy(dst, src, count, kind) + return _static_cudaMemcpy(dst, src, count, kind) + + +cdef cudaError_t _cudaMemcpyPeer(void* dst, int dstDevice, const void* src, int srcDevice, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemcpyPeer(dst, dstDevice, src, srcDevice, count) + return _static_cudaMemcpyPeer(dst, dstDevice, src, srcDevice, count) + + +cdef cudaError_t _cudaMemcpy2D(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemcpy2D(dst, dpitch, src, spitch, width, height, kind) + return _static_cudaMemcpy2D(dst, dpitch, src, spitch, width, height, kind) + + +cdef cudaError_t _cudaMemcpy2DToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemcpy2DToArray(dst, wOffset, hOffset, src, spitch, width, height, kind) + return _static_cudaMemcpy2DToArray(dst, wOffset, hOffset, src, spitch, width, height, kind) + + +cdef cudaError_t _cudaMemcpy2DFromArray(void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemcpy2DFromArray(dst, dpitch, src, wOffset, hOffset, width, height, kind) + return _static_cudaMemcpy2DFromArray(dst, dpitch, src, wOffset, hOffset, width, height, kind) + + +cdef cudaError_t _cudaMemcpy2DArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemcpy2DArrayToArray(dst, wOffsetDst, hOffsetDst, src, wOffsetSrc, hOffsetSrc, width, height, kind) + return _static_cudaMemcpy2DArrayToArray(dst, wOffsetDst, hOffsetDst, src, wOffsetSrc, hOffsetSrc, width, height, kind) + + +cdef cudaError_t _cudaMemcpyAsync(void* dst, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemcpyAsync(dst, src, count, kind, stream) + return _static_cudaMemcpyAsync(dst, src, count, kind, stream) + + +cdef cudaError_t _cudaMemcpyPeerAsync(void* dst, int dstDevice, const void* src, int srcDevice, size_t count, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemcpyPeerAsync(dst, dstDevice, src, srcDevice, count, stream) + return _static_cudaMemcpyPeerAsync(dst, dstDevice, src, srcDevice, count, stream) + + +cdef cudaError_t _cudaMemcpyBatchAsync(const void** dsts, const void** srcs, const size_t* sizes, size_t count, cudaMemcpyAttributes* attrs, size_t* attrsIdxs, size_t numAttrs, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemcpyBatchAsync(dsts, srcs, sizes, count, attrs, attrsIdxs, numAttrs, stream) + return _static_cudaMemcpyBatchAsync(dsts, srcs, sizes, count, attrs, attrsIdxs, numAttrs, stream) + + +cdef cudaError_t _cudaMemcpy3DBatchAsync(size_t numOps, cudaMemcpy3DBatchOp* opList, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemcpy3DBatchAsync(numOps, opList, flags, stream) + return _static_cudaMemcpy3DBatchAsync(numOps, opList, flags, stream) + + +cdef cudaError_t _cudaMemcpy2DAsync(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemcpy2DAsync(dst, dpitch, src, spitch, width, height, kind, stream) + return _static_cudaMemcpy2DAsync(dst, dpitch, src, spitch, width, height, kind, stream) + + +cdef cudaError_t _cudaMemcpy2DToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemcpy2DToArrayAsync(dst, wOffset, hOffset, src, spitch, width, height, kind, stream) + return _static_cudaMemcpy2DToArrayAsync(dst, wOffset, hOffset, src, spitch, width, height, kind, stream) + + +cdef cudaError_t _cudaMemcpy2DFromArrayAsync(void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemcpy2DFromArrayAsync(dst, dpitch, src, wOffset, hOffset, width, height, kind, stream) + return _static_cudaMemcpy2DFromArrayAsync(dst, dpitch, src, wOffset, hOffset, width, height, kind, stream) + + +cdef cudaError_t _cudaMemset(void* devPtr, int value, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemset(devPtr, value, count) + return _static_cudaMemset(devPtr, value, count) + + +cdef cudaError_t _cudaMemset2D(void* devPtr, size_t pitch, int value, size_t width, size_t height) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemset2D(devPtr, pitch, value, width, height) + return _static_cudaMemset2D(devPtr, pitch, value, width, height) + + +cdef cudaError_t _cudaMemset3D(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemset3D(pitchedDevPtr, value, extent) + return _static_cudaMemset3D(pitchedDevPtr, value, extent) + + +cdef cudaError_t _cudaMemsetAsync(void* devPtr, int value, size_t count, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemsetAsync(devPtr, value, count, stream) + return _static_cudaMemsetAsync(devPtr, value, count, stream) + + +cdef cudaError_t _cudaMemset2DAsync(void* devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemset2DAsync(devPtr, pitch, value, width, height, stream) + return _static_cudaMemset2DAsync(devPtr, pitch, value, width, height, stream) + + +cdef cudaError_t _cudaMemset3DAsync(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemset3DAsync(pitchedDevPtr, value, extent, stream) + return _static_cudaMemset3DAsync(pitchedDevPtr, value, extent, stream) + + +cdef cudaError_t _cudaMemPrefetchAsync(const void* devPtr, size_t count, cudaMemLocation location, unsigned int flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemPrefetchAsync(devPtr, count, location, flags, stream) + return _static_cudaMemPrefetchAsync(devPtr, count, location, flags, stream) + + +cdef cudaError_t _cudaMemAdvise(const void* devPtr, size_t count, cudaMemoryAdvise advice, cudaMemLocation location) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemAdvise(devPtr, count, advice, location) + return _static_cudaMemAdvise(devPtr, count, advice, location) + + +cdef cudaError_t _cudaMemRangeGetAttribute(void* data, size_t dataSize, cudaMemRangeAttribute attribute, const void* devPtr, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemRangeGetAttribute(data, dataSize, attribute, devPtr, count) + return _static_cudaMemRangeGetAttribute(data, dataSize, attribute, devPtr, count) + + +cdef cudaError_t _cudaMemRangeGetAttributes(void** data, size_t* dataSizes, cudaMemRangeAttribute* attributes, size_t numAttributes, const void* devPtr, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemRangeGetAttributes(data, dataSizes, attributes, numAttributes, devPtr, count) + return _static_cudaMemRangeGetAttributes(data, dataSizes, attributes, numAttributes, devPtr, count) + + +cdef cudaError_t _cudaMemcpyToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemcpyToArray(dst, wOffset, hOffset, src, count, kind) + return _static_cudaMemcpyToArray(dst, wOffset, hOffset, src, count, kind) + + +cdef cudaError_t _cudaMemcpyFromArray(void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemcpyFromArray(dst, src, wOffset, hOffset, count, kind) + return _static_cudaMemcpyFromArray(dst, src, wOffset, hOffset, count, kind) + + +cdef cudaError_t _cudaMemcpyArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemcpyArrayToArray(dst, wOffsetDst, hOffsetDst, src, wOffsetSrc, hOffsetSrc, count, kind) + return _static_cudaMemcpyArrayToArray(dst, wOffsetDst, hOffsetDst, src, wOffsetSrc, hOffsetSrc, count, kind) + + +cdef cudaError_t _cudaMemcpyToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemcpyToArrayAsync(dst, wOffset, hOffset, src, count, kind, stream) + return _static_cudaMemcpyToArrayAsync(dst, wOffset, hOffset, src, count, kind, stream) + + +cdef cudaError_t _cudaMemcpyFromArrayAsync(void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemcpyFromArrayAsync(dst, src, wOffset, hOffset, count, kind, stream) + return _static_cudaMemcpyFromArrayAsync(dst, src, wOffset, hOffset, count, kind, stream) + + +cdef cudaError_t _cudaMallocAsync(void** devPtr, size_t size, cudaStream_t hStream) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMallocAsync(devPtr, size, hStream) + return _static_cudaMallocAsync(devPtr, size, hStream) + + +cdef cudaError_t _cudaFreeAsync(void* devPtr, cudaStream_t hStream) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaFreeAsync(devPtr, hStream) + return _static_cudaFreeAsync(devPtr, hStream) + + +cdef cudaError_t _cudaMemPoolTrimTo(cudaMemPool_t memPool, size_t minBytesToKeep) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemPoolTrimTo(memPool, minBytesToKeep) + return _static_cudaMemPoolTrimTo(memPool, minBytesToKeep) + + +cdef cudaError_t _cudaMemPoolSetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemPoolSetAttribute(memPool, attr, value) + return _static_cudaMemPoolSetAttribute(memPool, attr, value) + + +cdef cudaError_t _cudaMemPoolGetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemPoolGetAttribute(memPool, attr, value) + return _static_cudaMemPoolGetAttribute(memPool, attr, value) + + +cdef cudaError_t _cudaMemPoolSetAccess(cudaMemPool_t memPool, const cudaMemAccessDesc* descList, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemPoolSetAccess(memPool, descList, count) + return _static_cudaMemPoolSetAccess(memPool, descList, count) + + +cdef cudaError_t _cudaMemPoolGetAccess(cudaMemAccessFlags* flags, cudaMemPool_t memPool, cudaMemLocation* location) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemPoolGetAccess(flags, memPool, location) + return _static_cudaMemPoolGetAccess(flags, memPool, location) + + +cdef cudaError_t _cudaMemPoolCreate(cudaMemPool_t* memPool, const cudaMemPoolProps* poolProps) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemPoolCreate(memPool, poolProps) + return _static_cudaMemPoolCreate(memPool, poolProps) + + +cdef cudaError_t _cudaMemPoolDestroy(cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemPoolDestroy(memPool) + return _static_cudaMemPoolDestroy(memPool) + + +cdef cudaError_t _cudaMallocFromPoolAsync(void** ptr, size_t size, cudaMemPool_t memPool, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMallocFromPoolAsync(ptr, size, memPool, stream) + return _static_cudaMallocFromPoolAsync(ptr, size, memPool, stream) + + +cdef cudaError_t _cudaMemPoolExportToShareableHandle(void* shareableHandle, cudaMemPool_t memPool, cudaMemAllocationHandleType handleType, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemPoolExportToShareableHandle(shareableHandle, memPool, handleType, flags) + return _static_cudaMemPoolExportToShareableHandle(shareableHandle, memPool, handleType, flags) + + +cdef cudaError_t _cudaMemPoolImportFromShareableHandle(cudaMemPool_t* memPool, void* shareableHandle, cudaMemAllocationHandleType handleType, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemPoolImportFromShareableHandle(memPool, shareableHandle, handleType, flags) + return _static_cudaMemPoolImportFromShareableHandle(memPool, shareableHandle, handleType, flags) + + +cdef cudaError_t _cudaMemPoolExportPointer(cudaMemPoolPtrExportData* exportData, void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemPoolExportPointer(exportData, ptr) + return _static_cudaMemPoolExportPointer(exportData, ptr) + + +cdef cudaError_t _cudaMemPoolImportPointer(void** ptr, cudaMemPool_t memPool, cudaMemPoolPtrExportData* exportData) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemPoolImportPointer(ptr, memPool, exportData) + return _static_cudaMemPoolImportPointer(ptr, memPool, exportData) + + +cdef cudaError_t _cudaPointerGetAttributes(cudaPointerAttributes* attributes, const void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaPointerGetAttributes(attributes, ptr) + return _static_cudaPointerGetAttributes(attributes, ptr) + + +cdef cudaError_t _cudaDeviceCanAccessPeer(int* canAccessPeer, int device, int peerDevice) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaDeviceCanAccessPeer(canAccessPeer, device, peerDevice) + return _static_cudaDeviceCanAccessPeer(canAccessPeer, device, peerDevice) + + +cdef cudaError_t _cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaDeviceEnablePeerAccess(peerDevice, flags) + return _static_cudaDeviceEnablePeerAccess(peerDevice, flags) + + +cdef cudaError_t _cudaDeviceDisablePeerAccess(int peerDevice) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaDeviceDisablePeerAccess(peerDevice) + return _static_cudaDeviceDisablePeerAccess(peerDevice) + + +cdef cudaError_t _cudaGraphicsUnregisterResource(cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphicsUnregisterResource(resource) + return _static_cudaGraphicsUnregisterResource(resource) + + +cdef cudaError_t _cudaGraphicsResourceSetMapFlags(cudaGraphicsResource_t resource, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphicsResourceSetMapFlags(resource, flags) + return _static_cudaGraphicsResourceSetMapFlags(resource, flags) + + +cdef cudaError_t _cudaGraphicsMapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphicsMapResources(count, resources, stream) + return _static_cudaGraphicsMapResources(count, resources, stream) + + +cdef cudaError_t _cudaGraphicsUnmapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphicsUnmapResources(count, resources, stream) + return _static_cudaGraphicsUnmapResources(count, resources, stream) + + +cdef cudaError_t _cudaGraphicsResourceGetMappedPointer(void** devPtr, size_t* size, cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphicsResourceGetMappedPointer(devPtr, size, resource) + return _static_cudaGraphicsResourceGetMappedPointer(devPtr, size, resource) + + +cdef cudaError_t _cudaGraphicsSubResourceGetMappedArray(cudaArray_t* array, cudaGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphicsSubResourceGetMappedArray(array, resource, arrayIndex, mipLevel) + return _static_cudaGraphicsSubResourceGetMappedArray(array, resource, arrayIndex, mipLevel) + + +cdef cudaError_t _cudaGraphicsResourceGetMappedMipmappedArray(cudaMipmappedArray_t* mipmappedArray, cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphicsResourceGetMappedMipmappedArray(mipmappedArray, resource) + return _static_cudaGraphicsResourceGetMappedMipmappedArray(mipmappedArray, resource) + + +cdef cudaError_t _cudaGetChannelDesc(cudaChannelFormatDesc* desc, cudaArray_const_t array) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGetChannelDesc(desc, array) + return _static_cudaGetChannelDesc(desc, array) + + +cdef cudaChannelFormatDesc _cudaCreateChannelDesc(int x, int y, int z, int w, cudaChannelFormatKind f) except* nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaCreateChannelDesc(x, y, z, w, f) + return _static_cudaCreateChannelDesc(x, y, z, w, f) + + +cdef cudaError_t _cudaCreateTextureObject(cudaTextureObject_t* pTexObject, const cudaResourceDesc* pResDesc, const cudaTextureDesc* pTexDesc, const cudaResourceViewDesc* pResViewDesc) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaCreateTextureObject(pTexObject, pResDesc, pTexDesc, pResViewDesc) + return _static_cudaCreateTextureObject(pTexObject, pResDesc, pTexDesc, pResViewDesc) + + +cdef cudaError_t _cudaDestroyTextureObject(cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaDestroyTextureObject(texObject) + return _static_cudaDestroyTextureObject(texObject) + + +cdef cudaError_t _cudaGetTextureObjectResourceDesc(cudaResourceDesc* pResDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGetTextureObjectResourceDesc(pResDesc, texObject) + return _static_cudaGetTextureObjectResourceDesc(pResDesc, texObject) + + +cdef cudaError_t _cudaGetTextureObjectTextureDesc(cudaTextureDesc* pTexDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGetTextureObjectTextureDesc(pTexDesc, texObject) + return _static_cudaGetTextureObjectTextureDesc(pTexDesc, texObject) + + +cdef cudaError_t _cudaGetTextureObjectResourceViewDesc(cudaResourceViewDesc* pResViewDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGetTextureObjectResourceViewDesc(pResViewDesc, texObject) + return _static_cudaGetTextureObjectResourceViewDesc(pResViewDesc, texObject) + + +cdef cudaError_t _cudaCreateSurfaceObject(cudaSurfaceObject_t* pSurfObject, const cudaResourceDesc* pResDesc) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaCreateSurfaceObject(pSurfObject, pResDesc) + return _static_cudaCreateSurfaceObject(pSurfObject, pResDesc) + + +cdef cudaError_t _cudaDestroySurfaceObject(cudaSurfaceObject_t surfObject) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaDestroySurfaceObject(surfObject) + return _static_cudaDestroySurfaceObject(surfObject) + + +cdef cudaError_t _cudaGetSurfaceObjectResourceDesc(cudaResourceDesc* pResDesc, cudaSurfaceObject_t surfObject) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGetSurfaceObjectResourceDesc(pResDesc, surfObject) + return _static_cudaGetSurfaceObjectResourceDesc(pResDesc, surfObject) + + +cdef cudaError_t _cudaDriverGetVersion(int* driverVersion) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaDriverGetVersion(driverVersion) + return _static_cudaDriverGetVersion(driverVersion) + + +cdef cudaError_t _cudaRuntimeGetVersion(int* runtimeVersion) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaRuntimeGetVersion(runtimeVersion) + return _static_cudaRuntimeGetVersion(runtimeVersion) + + +cdef cudaError_t _cudaGraphCreate(cudaGraph_t* pGraph, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphCreate(pGraph, flags) + return _static_cudaGraphCreate(pGraph, flags) + + +cdef cudaError_t _cudaGraphAddKernelNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphAddKernelNode(pGraphNode, graph, pDependencies, numDependencies, pNodeParams) + return _static_cudaGraphAddKernelNode(pGraphNode, graph, pDependencies, numDependencies, pNodeParams) + + +cdef cudaError_t _cudaGraphKernelNodeGetParams(cudaGraphNode_t node, cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphKernelNodeGetParams(node, pNodeParams) + return _static_cudaGraphKernelNodeGetParams(node, pNodeParams) + + +cdef cudaError_t _cudaGraphKernelNodeSetParams(cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphKernelNodeSetParams(node, pNodeParams) + return _static_cudaGraphKernelNodeSetParams(node, pNodeParams) + + +cdef cudaError_t _cudaGraphKernelNodeCopyAttributes(cudaGraphNode_t hDst, cudaGraphNode_t hSrc) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphKernelNodeCopyAttributes(hDst, hSrc) + return _static_cudaGraphKernelNodeCopyAttributes(hDst, hSrc) + + +cdef cudaError_t _cudaGraphKernelNodeGetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, cudaKernelNodeAttrValue* value_out) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphKernelNodeGetAttribute(hNode, attr, value_out) + return _static_cudaGraphKernelNodeGetAttribute(hNode, attr, value_out) + + +cdef cudaError_t _cudaGraphKernelNodeSetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, const cudaKernelNodeAttrValue* value) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphKernelNodeSetAttribute(hNode, attr, value) + return _static_cudaGraphKernelNodeSetAttribute(hNode, attr, value) + + +cdef cudaError_t _cudaGraphAddMemcpyNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemcpy3DParms* pCopyParams) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphAddMemcpyNode(pGraphNode, graph, pDependencies, numDependencies, pCopyParams) + return _static_cudaGraphAddMemcpyNode(pGraphNode, graph, pDependencies, numDependencies, pCopyParams) + + +cdef cudaError_t _cudaGraphAddMemcpyNode1D(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphAddMemcpyNode1D(pGraphNode, graph, pDependencies, numDependencies, dst, src, count, kind) + return _static_cudaGraphAddMemcpyNode1D(pGraphNode, graph, pDependencies, numDependencies, dst, src, count, kind) + + +cdef cudaError_t _cudaGraphMemcpyNodeGetParams(cudaGraphNode_t node, cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphMemcpyNodeGetParams(node, pNodeParams) + return _static_cudaGraphMemcpyNodeGetParams(node, pNodeParams) + + +cdef cudaError_t _cudaGraphMemcpyNodeSetParams(cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphMemcpyNodeSetParams(node, pNodeParams) + return _static_cudaGraphMemcpyNodeSetParams(node, pNodeParams) + + +cdef cudaError_t _cudaGraphMemcpyNodeSetParams1D(cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphMemcpyNodeSetParams1D(node, dst, src, count, kind) + return _static_cudaGraphMemcpyNodeSetParams1D(node, dst, src, count, kind) + + +cdef cudaError_t _cudaGraphAddMemsetNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemsetParams* pMemsetParams) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphAddMemsetNode(pGraphNode, graph, pDependencies, numDependencies, pMemsetParams) + return _static_cudaGraphAddMemsetNode(pGraphNode, graph, pDependencies, numDependencies, pMemsetParams) + + +cdef cudaError_t _cudaGraphMemsetNodeGetParams(cudaGraphNode_t node, cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphMemsetNodeGetParams(node, pNodeParams) + return _static_cudaGraphMemsetNodeGetParams(node, pNodeParams) + + +cdef cudaError_t _cudaGraphMemsetNodeSetParams(cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphMemsetNodeSetParams(node, pNodeParams) + return _static_cudaGraphMemsetNodeSetParams(node, pNodeParams) + + +cdef cudaError_t _cudaGraphAddHostNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphAddHostNode(pGraphNode, graph, pDependencies, numDependencies, pNodeParams) + return _static_cudaGraphAddHostNode(pGraphNode, graph, pDependencies, numDependencies, pNodeParams) + + +cdef cudaError_t _cudaGraphHostNodeGetParams(cudaGraphNode_t node, cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphHostNodeGetParams(node, pNodeParams) + return _static_cudaGraphHostNodeGetParams(node, pNodeParams) + + +cdef cudaError_t _cudaGraphHostNodeSetParams(cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphHostNodeSetParams(node, pNodeParams) + return _static_cudaGraphHostNodeSetParams(node, pNodeParams) + + +cdef cudaError_t _cudaGraphAddChildGraphNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaGraph_t childGraph) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphAddChildGraphNode(pGraphNode, graph, pDependencies, numDependencies, childGraph) + return _static_cudaGraphAddChildGraphNode(pGraphNode, graph, pDependencies, numDependencies, childGraph) + + +cdef cudaError_t _cudaGraphChildGraphNodeGetGraph(cudaGraphNode_t node, cudaGraph_t* pGraph) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphChildGraphNodeGetGraph(node, pGraph) + return _static_cudaGraphChildGraphNodeGetGraph(node, pGraph) + + +cdef cudaError_t _cudaGraphAddEmptyNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphAddEmptyNode(pGraphNode, graph, pDependencies, numDependencies) + return _static_cudaGraphAddEmptyNode(pGraphNode, graph, pDependencies, numDependencies) + + +cdef cudaError_t _cudaGraphAddEventRecordNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphAddEventRecordNode(pGraphNode, graph, pDependencies, numDependencies, event) + return _static_cudaGraphAddEventRecordNode(pGraphNode, graph, pDependencies, numDependencies, event) + + +cdef cudaError_t _cudaGraphEventRecordNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphEventRecordNodeGetEvent(node, event_out) + return _static_cudaGraphEventRecordNodeGetEvent(node, event_out) + + +cdef cudaError_t _cudaGraphEventRecordNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphEventRecordNodeSetEvent(node, event) + return _static_cudaGraphEventRecordNodeSetEvent(node, event) + + +cdef cudaError_t _cudaGraphAddEventWaitNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphAddEventWaitNode(pGraphNode, graph, pDependencies, numDependencies, event) + return _static_cudaGraphAddEventWaitNode(pGraphNode, graph, pDependencies, numDependencies, event) + + +cdef cudaError_t _cudaGraphEventWaitNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphEventWaitNodeGetEvent(node, event_out) + return _static_cudaGraphEventWaitNodeGetEvent(node, event_out) + + +cdef cudaError_t _cudaGraphEventWaitNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphEventWaitNodeSetEvent(node, event) + return _static_cudaGraphEventWaitNodeSetEvent(node, event) + + +cdef cudaError_t _cudaGraphAddExternalSemaphoresSignalNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphAddExternalSemaphoresSignalNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams) + return _static_cudaGraphAddExternalSemaphoresSignalNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams) + + +cdef cudaError_t _cudaGraphExternalSemaphoresSignalNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreSignalNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphExternalSemaphoresSignalNodeGetParams(hNode, params_out) + return _static_cudaGraphExternalSemaphoresSignalNodeGetParams(hNode, params_out) + + +cdef cudaError_t _cudaGraphExternalSemaphoresSignalNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphExternalSemaphoresSignalNodeSetParams(hNode, nodeParams) + return _static_cudaGraphExternalSemaphoresSignalNodeSetParams(hNode, nodeParams) + + +cdef cudaError_t _cudaGraphAddExternalSemaphoresWaitNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphAddExternalSemaphoresWaitNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams) + return _static_cudaGraphAddExternalSemaphoresWaitNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams) + + +cdef cudaError_t _cudaGraphExternalSemaphoresWaitNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreWaitNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphExternalSemaphoresWaitNodeGetParams(hNode, params_out) + return _static_cudaGraphExternalSemaphoresWaitNodeGetParams(hNode, params_out) + + +cdef cudaError_t _cudaGraphExternalSemaphoresWaitNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphExternalSemaphoresWaitNodeSetParams(hNode, nodeParams) + return _static_cudaGraphExternalSemaphoresWaitNodeSetParams(hNode, nodeParams) + + +cdef cudaError_t _cudaGraphAddMemAllocNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaMemAllocNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphAddMemAllocNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams) + return _static_cudaGraphAddMemAllocNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams) + + +cdef cudaError_t _cudaGraphMemAllocNodeGetParams(cudaGraphNode_t node, cudaMemAllocNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphMemAllocNodeGetParams(node, params_out) + return _static_cudaGraphMemAllocNodeGetParams(node, params_out) + + +cdef cudaError_t _cudaGraphAddMemFreeNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dptr) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphAddMemFreeNode(pGraphNode, graph, pDependencies, numDependencies, dptr) + return _static_cudaGraphAddMemFreeNode(pGraphNode, graph, pDependencies, numDependencies, dptr) + + +cdef cudaError_t _cudaGraphMemFreeNodeGetParams(cudaGraphNode_t node, void* dptr_out) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphMemFreeNodeGetParams(node, dptr_out) + return _static_cudaGraphMemFreeNodeGetParams(node, dptr_out) + + +cdef cudaError_t _cudaDeviceGraphMemTrim(int device) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaDeviceGraphMemTrim(device) + return _static_cudaDeviceGraphMemTrim(device) + + +cdef cudaError_t _cudaDeviceGetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaDeviceGetGraphMemAttribute(device, attr, value) + return _static_cudaDeviceGetGraphMemAttribute(device, attr, value) + + +cdef cudaError_t _cudaDeviceSetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaDeviceSetGraphMemAttribute(device, attr, value) + return _static_cudaDeviceSetGraphMemAttribute(device, attr, value) + + +cdef cudaError_t _cudaGraphClone(cudaGraph_t* pGraphClone, cudaGraph_t originalGraph) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphClone(pGraphClone, originalGraph) + return _static_cudaGraphClone(pGraphClone, originalGraph) + + +cdef cudaError_t _cudaGraphNodeFindInClone(cudaGraphNode_t* pNode, cudaGraphNode_t originalNode, cudaGraph_t clonedGraph) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphNodeFindInClone(pNode, originalNode, clonedGraph) + return _static_cudaGraphNodeFindInClone(pNode, originalNode, clonedGraph) + + +cdef cudaError_t _cudaGraphNodeGetType(cudaGraphNode_t node, cudaGraphNodeType* pType) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphNodeGetType(node, pType) + return _static_cudaGraphNodeGetType(node, pType) + + +cdef cudaError_t _cudaGraphGetNodes(cudaGraph_t graph, cudaGraphNode_t* nodes, size_t* numNodes) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphGetNodes(graph, nodes, numNodes) + return _static_cudaGraphGetNodes(graph, nodes, numNodes) + + +cdef cudaError_t _cudaGraphGetRootNodes(cudaGraph_t graph, cudaGraphNode_t* pRootNodes, size_t* pNumRootNodes) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphGetRootNodes(graph, pRootNodes, pNumRootNodes) + return _static_cudaGraphGetRootNodes(graph, pRootNodes, pNumRootNodes) + + +cdef cudaError_t _cudaGraphGetEdges(cudaGraph_t graph, cudaGraphNode_t* from_, cudaGraphNode_t* to, cudaGraphEdgeData* edgeData, size_t* numEdges) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphGetEdges(graph, from_, to, edgeData, numEdges) + return _static_cudaGraphGetEdges(graph, from_, to, edgeData, numEdges) + + +cdef cudaError_t _cudaGraphNodeGetDependencies(cudaGraphNode_t node, cudaGraphNode_t* pDependencies, cudaGraphEdgeData* edgeData, size_t* pNumDependencies) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphNodeGetDependencies(node, pDependencies, edgeData, pNumDependencies) + return _static_cudaGraphNodeGetDependencies(node, pDependencies, edgeData, pNumDependencies) + + +cdef cudaError_t _cudaGraphNodeGetDependentNodes(cudaGraphNode_t node, cudaGraphNode_t* pDependentNodes, cudaGraphEdgeData* edgeData, size_t* pNumDependentNodes) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphNodeGetDependentNodes(node, pDependentNodes, edgeData, pNumDependentNodes) + return _static_cudaGraphNodeGetDependentNodes(node, pDependentNodes, edgeData, pNumDependentNodes) + + +cdef cudaError_t _cudaGraphAddDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, const cudaGraphEdgeData* edgeData, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphAddDependencies(graph, from_, to, edgeData, numDependencies) + return _static_cudaGraphAddDependencies(graph, from_, to, edgeData, numDependencies) + + +cdef cudaError_t _cudaGraphRemoveDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, const cudaGraphEdgeData* edgeData, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphRemoveDependencies(graph, from_, to, edgeData, numDependencies) + return _static_cudaGraphRemoveDependencies(graph, from_, to, edgeData, numDependencies) + + +cdef cudaError_t _cudaGraphDestroyNode(cudaGraphNode_t node) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphDestroyNode(node) + return _static_cudaGraphDestroyNode(node) + + +cdef cudaError_t _cudaGraphInstantiate(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphInstantiate(pGraphExec, graph, flags) + return _static_cudaGraphInstantiate(pGraphExec, graph, flags) + + +cdef cudaError_t _cudaGraphInstantiateWithFlags(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphInstantiateWithFlags(pGraphExec, graph, flags) + return _static_cudaGraphInstantiateWithFlags(pGraphExec, graph, flags) + + +cdef cudaError_t _cudaGraphInstantiateWithParams(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, cudaGraphInstantiateParams* instantiateParams) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphInstantiateWithParams(pGraphExec, graph, instantiateParams) + return _static_cudaGraphInstantiateWithParams(pGraphExec, graph, instantiateParams) + + +cdef cudaError_t _cudaGraphExecGetFlags(cudaGraphExec_t graphExec, unsigned long long* flags) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphExecGetFlags(graphExec, flags) + return _static_cudaGraphExecGetFlags(graphExec, flags) + + +cdef cudaError_t _cudaGraphExecKernelNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphExecKernelNodeSetParams(hGraphExec, node, pNodeParams) + return _static_cudaGraphExecKernelNodeSetParams(hGraphExec, node, pNodeParams) + + +cdef cudaError_t _cudaGraphExecMemcpyNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphExecMemcpyNodeSetParams(hGraphExec, node, pNodeParams) + return _static_cudaGraphExecMemcpyNodeSetParams(hGraphExec, node, pNodeParams) + + +cdef cudaError_t _cudaGraphExecMemcpyNodeSetParams1D(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphExecMemcpyNodeSetParams1D(hGraphExec, node, dst, src, count, kind) + return _static_cudaGraphExecMemcpyNodeSetParams1D(hGraphExec, node, dst, src, count, kind) + + +cdef cudaError_t _cudaGraphExecMemsetNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphExecMemsetNodeSetParams(hGraphExec, node, pNodeParams) + return _static_cudaGraphExecMemsetNodeSetParams(hGraphExec, node, pNodeParams) + + +cdef cudaError_t _cudaGraphExecHostNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphExecHostNodeSetParams(hGraphExec, node, pNodeParams) + return _static_cudaGraphExecHostNodeSetParams(hGraphExec, node, pNodeParams) + + +cdef cudaError_t _cudaGraphExecChildGraphNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, cudaGraph_t childGraph) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphExecChildGraphNodeSetParams(hGraphExec, node, childGraph) + return _static_cudaGraphExecChildGraphNodeSetParams(hGraphExec, node, childGraph) + + +cdef cudaError_t _cudaGraphExecEventRecordNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphExecEventRecordNodeSetEvent(hGraphExec, hNode, event) + return _static_cudaGraphExecEventRecordNodeSetEvent(hGraphExec, hNode, event) + + +cdef cudaError_t _cudaGraphExecEventWaitNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphExecEventWaitNodeSetEvent(hGraphExec, hNode, event) + return _static_cudaGraphExecEventWaitNodeSetEvent(hGraphExec, hNode, event) + + +cdef cudaError_t _cudaGraphExecExternalSemaphoresSignalNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphExecExternalSemaphoresSignalNodeSetParams(hGraphExec, hNode, nodeParams) + return _static_cudaGraphExecExternalSemaphoresSignalNodeSetParams(hGraphExec, hNode, nodeParams) + + +cdef cudaError_t _cudaGraphExecExternalSemaphoresWaitNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphExecExternalSemaphoresWaitNodeSetParams(hGraphExec, hNode, nodeParams) + return _static_cudaGraphExecExternalSemaphoresWaitNodeSetParams(hGraphExec, hNode, nodeParams) + + +cdef cudaError_t _cudaGraphNodeSetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int isEnabled) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphNodeSetEnabled(hGraphExec, hNode, isEnabled) + return _static_cudaGraphNodeSetEnabled(hGraphExec, hNode, isEnabled) + + +cdef cudaError_t _cudaGraphNodeGetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int* isEnabled) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphNodeGetEnabled(hGraphExec, hNode, isEnabled) + return _static_cudaGraphNodeGetEnabled(hGraphExec, hNode, isEnabled) + + +cdef cudaError_t _cudaGraphExecUpdate(cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphExecUpdateResultInfo* resultInfo) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphExecUpdate(hGraphExec, hGraph, resultInfo) + return _static_cudaGraphExecUpdate(hGraphExec, hGraph, resultInfo) + + +cdef cudaError_t _cudaGraphUpload(cudaGraphExec_t graphExec, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphUpload(graphExec, stream) + return _static_cudaGraphUpload(graphExec, stream) + + +cdef cudaError_t _cudaGraphLaunch(cudaGraphExec_t graphExec, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphLaunch(graphExec, stream) + return _static_cudaGraphLaunch(graphExec, stream) + + +cdef cudaError_t _cudaGraphExecDestroy(cudaGraphExec_t graphExec) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphExecDestroy(graphExec) + return _static_cudaGraphExecDestroy(graphExec) + + +cdef cudaError_t _cudaGraphDestroy(cudaGraph_t graph) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphDestroy(graph) + return _static_cudaGraphDestroy(graph) + + +cdef cudaError_t _cudaGraphDebugDotPrint(cudaGraph_t graph, const char* path, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphDebugDotPrint(graph, path, flags) + return _static_cudaGraphDebugDotPrint(graph, path, flags) + + +cdef cudaError_t _cudaUserObjectCreate(cudaUserObject_t* object_out, void* ptr, cudaHostFn_t destroy, unsigned int initialRefcount, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaUserObjectCreate(object_out, ptr, destroy, initialRefcount, flags) + return _static_cudaUserObjectCreate(object_out, ptr, destroy, initialRefcount, flags) + + +cdef cudaError_t _cudaUserObjectRetain(cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaUserObjectRetain(object, count) + return _static_cudaUserObjectRetain(object, count) + + +cdef cudaError_t _cudaUserObjectRelease(cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaUserObjectRelease(object, count) + return _static_cudaUserObjectRelease(object, count) + + +cdef cudaError_t _cudaGraphRetainUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphRetainUserObject(graph, object, count, flags) + return _static_cudaGraphRetainUserObject(graph, object, count, flags) + + +cdef cudaError_t _cudaGraphReleaseUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphReleaseUserObject(graph, object, count) + return _static_cudaGraphReleaseUserObject(graph, object, count) + + +cdef cudaError_t _cudaGraphAddNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphAddNode(pGraphNode, graph, pDependencies, dependencyData, numDependencies, nodeParams) + return _static_cudaGraphAddNode(pGraphNode, graph, pDependencies, dependencyData, numDependencies, nodeParams) + + +cdef cudaError_t _cudaGraphNodeSetParams(cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphNodeSetParams(node, nodeParams) + return _static_cudaGraphNodeSetParams(node, nodeParams) + + +cdef cudaError_t _cudaGraphExecNodeSetParams(cudaGraphExec_t graphExec, cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphExecNodeSetParams(graphExec, node, nodeParams) + return _static_cudaGraphExecNodeSetParams(graphExec, node, nodeParams) + + +cdef cudaError_t _cudaGraphConditionalHandleCreate(cudaGraphConditionalHandle* pHandle_out, cudaGraph_t graph, unsigned int defaultLaunchValue, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphConditionalHandleCreate(pHandle_out, graph, defaultLaunchValue, flags) + return _static_cudaGraphConditionalHandleCreate(pHandle_out, graph, defaultLaunchValue, flags) + + +cdef cudaError_t _cudaGetDriverEntryPoint(const char* symbol, void** funcPtr, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGetDriverEntryPoint(symbol, funcPtr, flags, driverStatus) + return _static_cudaGetDriverEntryPoint(symbol, funcPtr, flags, driverStatus) + + +cdef cudaError_t _cudaGetDriverEntryPointByVersion(const char* symbol, void** funcPtr, unsigned int cudaVersion, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGetDriverEntryPointByVersion(symbol, funcPtr, cudaVersion, flags, driverStatus) + return _static_cudaGetDriverEntryPointByVersion(symbol, funcPtr, cudaVersion, flags, driverStatus) + + +cdef cudaError_t _cudaLibraryLoadData(cudaLibrary_t* library, const void* code, cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaLibraryLoadData(library, code, jitOptions, jitOptionsValues, numJitOptions, libraryOptions, libraryOptionValues, numLibraryOptions) + return _static_cudaLibraryLoadData(library, code, jitOptions, jitOptionsValues, numJitOptions, libraryOptions, libraryOptionValues, numLibraryOptions) + + +cdef cudaError_t _cudaLibraryLoadFromFile(cudaLibrary_t* library, const char* fileName, cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaLibraryLoadFromFile(library, fileName, jitOptions, jitOptionsValues, numJitOptions, libraryOptions, libraryOptionValues, numLibraryOptions) + return _static_cudaLibraryLoadFromFile(library, fileName, jitOptions, jitOptionsValues, numJitOptions, libraryOptions, libraryOptionValues, numLibraryOptions) + + +cdef cudaError_t _cudaLibraryUnload(cudaLibrary_t library) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaLibraryUnload(library) + return _static_cudaLibraryUnload(library) + + +cdef cudaError_t _cudaLibraryGetKernel(cudaKernel_t* pKernel, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaLibraryGetKernel(pKernel, library, name) + return _static_cudaLibraryGetKernel(pKernel, library, name) + + +cdef cudaError_t _cudaLibraryGetGlobal(void** dptr, size_t* bytes, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaLibraryGetGlobal(dptr, bytes, library, name) + return _static_cudaLibraryGetGlobal(dptr, bytes, library, name) + + +cdef cudaError_t _cudaLibraryGetManaged(void** dptr, size_t* bytes, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaLibraryGetManaged(dptr, bytes, library, name) + return _static_cudaLibraryGetManaged(dptr, bytes, library, name) + + +cdef cudaError_t _cudaLibraryGetUnifiedFunction(void** fptr, cudaLibrary_t library, const char* symbol) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaLibraryGetUnifiedFunction(fptr, library, symbol) + return _static_cudaLibraryGetUnifiedFunction(fptr, library, symbol) + + +cdef cudaError_t _cudaLibraryGetKernelCount(unsigned int* count, cudaLibrary_t lib) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaLibraryGetKernelCount(count, lib) + return _static_cudaLibraryGetKernelCount(count, lib) + + +cdef cudaError_t _cudaLibraryEnumerateKernels(cudaKernel_t* kernels, unsigned int numKernels, cudaLibrary_t lib) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaLibraryEnumerateKernels(kernels, numKernels, lib) + return _static_cudaLibraryEnumerateKernels(kernels, numKernels, lib) + + +cdef cudaError_t _cudaKernelSetAttributeForDevice(cudaKernel_t kernel, cudaFuncAttribute attr, int value, int device) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaKernelSetAttributeForDevice(kernel, attr, value, device) + return _static_cudaKernelSetAttributeForDevice(kernel, attr, value, device) + + +cdef cudaError_t _cudaGetExportTable(const void** ppExportTable, const cudaUUID_t* pExportTableId) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGetExportTable(ppExportTable, pExportTableId) + return _static_cudaGetExportTable(ppExportTable, pExportTableId) + + +cdef cudaError_t _cudaGetKernel(cudaKernel_t* kernelPtr, const void* entryFuncAddr) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGetKernel(kernelPtr, entryFuncAddr) + return _static_cudaGetKernel(kernelPtr, entryFuncAddr) + + +cdef cudaError_t _cudaProfilerStart() except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaProfilerStart() + return _static_cudaProfilerStart() + + +cdef cudaError_t _cudaProfilerStop() except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaProfilerStop() + return _static_cudaProfilerStop() + + +cdef cudaError_t _cudaGetDeviceProperties(cudaDeviceProp* prop, int device) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGetDeviceProperties(prop, device) + return _static_cudaGetDeviceProperties(prop, device) + + +cdef cudaError_t _cudaDeviceGetHostAtomicCapabilities(unsigned int* capabilities, const cudaAtomicOperation* operations, unsigned int count, int device) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaDeviceGetHostAtomicCapabilities(capabilities, operations, count, device) + return _static_cudaDeviceGetHostAtomicCapabilities(capabilities, operations, count, device) + + +cdef cudaError_t _cudaDeviceGetP2PAtomicCapabilities(unsigned int* capabilities, const cudaAtomicOperation* operations, unsigned int count, int srcDevice, int dstDevice) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaDeviceGetP2PAtomicCapabilities(capabilities, operations, count, srcDevice, dstDevice) + return _static_cudaDeviceGetP2PAtomicCapabilities(capabilities, operations, count, srcDevice, dstDevice) + + +cdef cudaError_t _cudaStreamGetCaptureInfo(cudaStream_t stream, cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out, cudaGraph_t* graph_out, const cudaGraphNode_t** dependencies_out, const cudaGraphEdgeData** edgeData_out, size_t* numDependencies_out) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaStreamGetCaptureInfo(stream, captureStatus_out, id_out, graph_out, dependencies_out, edgeData_out, numDependencies_out) + return _static_cudaStreamGetCaptureInfo(stream, captureStatus_out, id_out, graph_out, dependencies_out, edgeData_out, numDependencies_out) + + +cdef cudaError_t _cudaSignalExternalSemaphoresAsync(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreSignalParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaSignalExternalSemaphoresAsync(extSemArray, paramsArray, numExtSems, stream) + return _static_cudaSignalExternalSemaphoresAsync(extSemArray, paramsArray, numExtSems, stream) + + +cdef cudaError_t _cudaWaitExternalSemaphoresAsync(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreWaitParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaWaitExternalSemaphoresAsync(extSemArray, paramsArray, numExtSems, stream) + return _static_cudaWaitExternalSemaphoresAsync(extSemArray, paramsArray, numExtSems, stream) + + +cdef cudaError_t _cudaMemPrefetchBatchAsync(void** dptrs, size_t* sizes, size_t count, cudaMemLocation* prefetchLocs, size_t* prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemPrefetchBatchAsync(dptrs, sizes, count, prefetchLocs, prefetchLocIdxs, numPrefetchLocs, flags, stream) + return _static_cudaMemPrefetchBatchAsync(dptrs, sizes, count, prefetchLocs, prefetchLocIdxs, numPrefetchLocs, flags, stream) + + +cdef cudaError_t _cudaMemDiscardBatchAsync(void** dptrs, size_t* sizes, size_t count, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemDiscardBatchAsync(dptrs, sizes, count, flags, stream) + return _static_cudaMemDiscardBatchAsync(dptrs, sizes, count, flags, stream) + + +cdef cudaError_t _cudaMemDiscardAndPrefetchBatchAsync(void** dptrs, size_t* sizes, size_t count, cudaMemLocation* prefetchLocs, size_t* prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemDiscardAndPrefetchBatchAsync(dptrs, sizes, count, prefetchLocs, prefetchLocIdxs, numPrefetchLocs, flags, stream) + return _static_cudaMemDiscardAndPrefetchBatchAsync(dptrs, sizes, count, prefetchLocs, prefetchLocIdxs, numPrefetchLocs, flags, stream) + + +cdef cudaError_t _cudaMemGetDefaultMemPool(cudaMemPool_t* memPool, cudaMemLocation* location, cudaMemAllocationType type) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemGetDefaultMemPool(memPool, location, type) + return _static_cudaMemGetDefaultMemPool(memPool, location, type) + + +cdef cudaError_t _cudaMemGetMemPool(cudaMemPool_t* memPool, cudaMemLocation* location, cudaMemAllocationType type) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemGetMemPool(memPool, location, type) + return _static_cudaMemGetMemPool(memPool, location, type) + + +cdef cudaError_t _cudaMemSetMemPool(cudaMemLocation* location, cudaMemAllocationType type, cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemSetMemPool(location, type, memPool) + return _static_cudaMemSetMemPool(location, type, memPool) + + +cdef cudaError_t _cudaLogsRegisterCallback(cudaLogsCallback_t callbackFunc, void* userData, cudaLogsCallbackHandle* callback_out) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaLogsRegisterCallback(callbackFunc, userData, callback_out) + return _static_cudaLogsRegisterCallback(callbackFunc, userData, callback_out) + + +cdef cudaError_t _cudaLogsUnregisterCallback(cudaLogsCallbackHandle callback) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaLogsUnregisterCallback(callback) + return _static_cudaLogsUnregisterCallback(callback) + + +cdef cudaError_t _cudaLogsCurrent(cudaLogIterator* iterator_out, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaLogsCurrent(iterator_out, flags) + return _static_cudaLogsCurrent(iterator_out, flags) + + +cdef cudaError_t _cudaLogsDumpToFile(cudaLogIterator* iterator, const char* pathToFile, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaLogsDumpToFile(iterator, pathToFile, flags) + return _static_cudaLogsDumpToFile(iterator, pathToFile, flags) + + +cdef cudaError_t _cudaLogsDumpToMemory(cudaLogIterator* iterator, char* buffer, size_t* size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaLogsDumpToMemory(iterator, buffer, size, flags) + return _static_cudaLogsDumpToMemory(iterator, buffer, size, flags) + + +cdef cudaError_t _cudaGraphNodeGetContainingGraph(cudaGraphNode_t hNode, cudaGraph_t* phGraph) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphNodeGetContainingGraph(hNode, phGraph) + return _static_cudaGraphNodeGetContainingGraph(hNode, phGraph) + + +cdef cudaError_t _cudaGraphNodeGetLocalId(cudaGraphNode_t hNode, unsigned int* nodeId) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphNodeGetLocalId(hNode, nodeId) + return _static_cudaGraphNodeGetLocalId(hNode, nodeId) + + +cdef cudaError_t _cudaGraphNodeGetToolsId(cudaGraphNode_t hNode, unsigned long long* toolsNodeId) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphNodeGetToolsId(hNode, toolsNodeId) + return _static_cudaGraphNodeGetToolsId(hNode, toolsNodeId) + + +cdef cudaError_t _cudaGraphGetId(cudaGraph_t hGraph, unsigned int* graphID) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphGetId(hGraph, graphID) + return _static_cudaGraphGetId(hGraph, graphID) + + +cdef cudaError_t _cudaGraphExecGetId(cudaGraphExec_t hGraphExec, unsigned int* graphID) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphExecGetId(hGraphExec, graphID) + return _static_cudaGraphExecGetId(hGraphExec, graphID) + + +cdef cudaError_t _cudaGraphConditionalHandleCreate_v2(cudaGraphConditionalHandle* pHandle_out, cudaGraph_t graph, cudaExecutionContext_t ctx, unsigned int defaultLaunchValue, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphConditionalHandleCreate_v2(pHandle_out, graph, ctx, defaultLaunchValue, flags) + return _static_cudaGraphConditionalHandleCreate_v2(pHandle_out, graph, ctx, defaultLaunchValue, flags) + + +cdef cudaError_t _cudaDeviceGetDevResource(int device, cudaDevResource* resource, cudaDevResourceType type) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaDeviceGetDevResource(device, resource, type) + return _static_cudaDeviceGetDevResource(device, resource, type) + + +cdef cudaError_t _cudaDevSmResourceSplitByCount(cudaDevResource* result, unsigned int* nbGroups, const cudaDevResource* input, cudaDevResource* remaining, unsigned int flags, unsigned int minCount) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaDevSmResourceSplitByCount(result, nbGroups, input, remaining, flags, minCount) + return _static_cudaDevSmResourceSplitByCount(result, nbGroups, input, remaining, flags, minCount) + + +cdef cudaError_t _cudaDevSmResourceSplit(cudaDevResource* result, unsigned int nbGroups, const cudaDevResource* input, cudaDevResource* remainder, unsigned int flags, cudaDevSmResourceGroupParams* groupParams) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaDevSmResourceSplit(result, nbGroups, input, remainder, flags, groupParams) + return _static_cudaDevSmResourceSplit(result, nbGroups, input, remainder, flags, groupParams) + + +cdef cudaError_t _cudaDevResourceGenerateDesc(cudaDevResourceDesc_t* phDesc, cudaDevResource* resources, unsigned int nbResources) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaDevResourceGenerateDesc(phDesc, resources, nbResources) + return _static_cudaDevResourceGenerateDesc(phDesc, resources, nbResources) + + +cdef cudaError_t _cudaGreenCtxCreate(cudaExecutionContext_t* phCtx, cudaDevResourceDesc_t desc, int device, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGreenCtxCreate(phCtx, desc, device, flags) + return _static_cudaGreenCtxCreate(phCtx, desc, device, flags) + + +cdef cudaError_t _cudaExecutionCtxDestroy(cudaExecutionContext_t ctx) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaExecutionCtxDestroy(ctx) + return _static_cudaExecutionCtxDestroy(ctx) + + +cdef cudaError_t _cudaExecutionCtxGetDevResource(cudaExecutionContext_t ctx, cudaDevResource* resource, cudaDevResourceType type) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaExecutionCtxGetDevResource(ctx, resource, type) + return _static_cudaExecutionCtxGetDevResource(ctx, resource, type) + + +cdef cudaError_t _cudaExecutionCtxGetDevice(int* device, cudaExecutionContext_t ctx) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaExecutionCtxGetDevice(device, ctx) + return _static_cudaExecutionCtxGetDevice(device, ctx) + + +cdef cudaError_t _cudaExecutionCtxGetId(cudaExecutionContext_t ctx, unsigned long long* ctxId) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaExecutionCtxGetId(ctx, ctxId) + return _static_cudaExecutionCtxGetId(ctx, ctxId) + + +cdef cudaError_t _cudaExecutionCtxStreamCreate(cudaStream_t* phStream, cudaExecutionContext_t ctx, unsigned int flags, int priority) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaExecutionCtxStreamCreate(phStream, ctx, flags, priority) + return _static_cudaExecutionCtxStreamCreate(phStream, ctx, flags, priority) + + +cdef cudaError_t _cudaExecutionCtxSynchronize(cudaExecutionContext_t ctx) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaExecutionCtxSynchronize(ctx) + return _static_cudaExecutionCtxSynchronize(ctx) + + +cdef cudaError_t _cudaStreamGetDevResource(cudaStream_t hStream, cudaDevResource* resource, cudaDevResourceType type) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaStreamGetDevResource(hStream, resource, type) + return _static_cudaStreamGetDevResource(hStream, resource, type) + + +cdef cudaError_t _cudaExecutionCtxRecordEvent(cudaExecutionContext_t ctx, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaExecutionCtxRecordEvent(ctx, event) + return _static_cudaExecutionCtxRecordEvent(ctx, event) + + +cdef cudaError_t _cudaExecutionCtxWaitEvent(cudaExecutionContext_t ctx, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaExecutionCtxWaitEvent(ctx, event) + return _static_cudaExecutionCtxWaitEvent(ctx, event) + + +cdef cudaError_t _cudaDeviceGetExecutionCtx(cudaExecutionContext_t* ctx, int device) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaDeviceGetExecutionCtx(ctx, device) + return _static_cudaDeviceGetExecutionCtx(ctx, device) + + +cdef cudaError_t _cudaFuncGetParamCount(const void* func, size_t* paramCount) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaFuncGetParamCount(func, paramCount) + return _static_cudaFuncGetParamCount(func, paramCount) + + +cdef cudaError_t _cudaLaunchHostFunc_v2(cudaStream_t stream, cudaHostFn_t fn, void* userData, unsigned int syncMode) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaLaunchHostFunc_v2(stream, fn, userData, syncMode) + return _static_cudaLaunchHostFunc_v2(stream, fn, userData, syncMode) + + +cdef cudaError_t _cudaMemcpyWithAttributesAsync(void* dst, const void* src, size_t size, cudaMemcpyAttributes* attr, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemcpyWithAttributesAsync(dst, src, size, attr, stream) + return _static_cudaMemcpyWithAttributesAsync(dst, src, size, attr, stream) + + +cdef cudaError_t _cudaMemcpy3DWithAttributesAsync(cudaMemcpy3DBatchOp* op, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemcpy3DWithAttributesAsync(op, flags, stream) + return _static_cudaMemcpy3DWithAttributesAsync(op, flags, stream) + + +cdef cudaError_t _cudaGraphNodeGetParams(cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphNodeGetParams(node, nodeParams) + return _static_cudaGraphNodeGetParams(node, nodeParams) + + +cdef cudaError_t _cudaStreamBeginRecaptureToGraph(cudaStream_t stream, cudaStreamCaptureMode mode, cudaGraph_t graph, cudaGraphRecaptureCallbackData* callbackData) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaStreamBeginRecaptureToGraph(stream, mode, graph, callbackData) + return _static_cudaStreamBeginRecaptureToGraph(stream, mode, graph, callbackData) diff --git a/cuda_bindings/cuda/bindings/_bindings/cyruntime_ptds.pxd.in b/cuda_bindings/cuda/bindings/_internal/runtime_ptds.pxd similarity index 68% rename from cuda_bindings/cuda/bindings/_bindings/cyruntime_ptds.pxd.in rename to cuda_bindings/cuda/bindings/_internal/runtime_ptds.pxd index d12c7be7141..e1685cd3680 100644 --- a/cuda_bindings/cuda/bindings/_bindings/cyruntime_ptds.pxd.in +++ b/cuda_bindings/cuda/bindings/_internal/runtime_ptds.pxd @@ -1,1616 +1,334 @@ # SPDX-FileCopyrightText: Copyright (c) 2021-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# # SPDX-License-Identifier: Apache-2.0 +# +# This code was automatically generated across versions from 12.9.0 to 13.3.0. Do not modify it directly. -# This code was automatically generated with version 13.3.0. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=005e8f266f43a90c73b382df384f4143abf0e82b26d8ad69cb8aa58fbafa13ef -cdef extern from "": - """ - #define CUDA_API_PER_THREAD_DEFAULT_STREAM - """ +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=fa210f57cc23e0c4cdcad28a1ab8292bc74cc6b557bb3ca1700d1be8c25aa6af +from ..cyruntime cimport * -include "../cyruntime_types.pxi" -{{if 'cudaDeviceReset' in found_functions}} +############################################################################### +# Wrapper functions +############################################################################### cdef cudaError_t _cudaDeviceReset() except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceSynchronize' in found_functions}} - cdef cudaError_t _cudaDeviceSynchronize() except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceSetLimit' in found_functions}} - cdef cudaError_t _cudaDeviceSetLimit(cudaLimit limit, size_t value) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetLimit' in found_functions}} - cdef cudaError_t _cudaDeviceGetLimit(size_t* pValue, cudaLimit limit) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetTexture1DLinearMaxWidth' in found_functions}} - cdef cudaError_t _cudaDeviceGetTexture1DLinearMaxWidth(size_t* maxWidthInElements, const cudaChannelFormatDesc* fmtDesc, int device) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetCacheConfig' in found_functions}} - cdef cudaError_t _cudaDeviceGetCacheConfig(cudaFuncCache* pCacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetStreamPriorityRange' in found_functions}} - cdef cudaError_t _cudaDeviceGetStreamPriorityRange(int* leastPriority, int* greatestPriority) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceSetCacheConfig' in found_functions}} - cdef cudaError_t _cudaDeviceSetCacheConfig(cudaFuncCache cacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetByPCIBusId' in found_functions}} - cdef cudaError_t _cudaDeviceGetByPCIBusId(int* device, const char* pciBusId) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetPCIBusId' in found_functions}} - -cdef cudaError_t _cudaDeviceGetPCIBusId(char* pciBusId, int length, int device) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaIpcGetEventHandle' in found_functions}} - +cdef cudaError_t _cudaDeviceGetPCIBusId(char* pciBusId, int len, int device) except ?cudaErrorCallRequiresNewerDriver nogil cdef cudaError_t _cudaIpcGetEventHandle(cudaIpcEventHandle_t* handle, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaIpcOpenEventHandle' in found_functions}} - cdef cudaError_t _cudaIpcOpenEventHandle(cudaEvent_t* event, cudaIpcEventHandle_t handle) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaIpcGetMemHandle' in found_functions}} - cdef cudaError_t _cudaIpcGetMemHandle(cudaIpcMemHandle_t* handle, void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaIpcOpenMemHandle' in found_functions}} - cdef cudaError_t _cudaIpcOpenMemHandle(void** devPtr, cudaIpcMemHandle_t handle, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaIpcCloseMemHandle' in found_functions}} - cdef cudaError_t _cudaIpcCloseMemHandle(void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceFlushGPUDirectRDMAWrites' in found_functions}} - cdef cudaError_t _cudaDeviceFlushGPUDirectRDMAWrites(cudaFlushGPUDirectRDMAWritesTarget target, cudaFlushGPUDirectRDMAWritesScope scope) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceRegisterAsyncNotification' in found_functions}} - cdef cudaError_t _cudaDeviceRegisterAsyncNotification(int device, cudaAsyncCallback callbackFunc, void* userData, cudaAsyncCallbackHandle_t* callback) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceUnregisterAsyncNotification' in found_functions}} - cdef cudaError_t _cudaDeviceUnregisterAsyncNotification(int device, cudaAsyncCallbackHandle_t callback) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetSharedMemConfig' in found_functions}} - cdef cudaError_t _cudaDeviceGetSharedMemConfig(cudaSharedMemConfig* pConfig) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceSetSharedMemConfig' in found_functions}} - cdef cudaError_t _cudaDeviceSetSharedMemConfig(cudaSharedMemConfig config) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGetLastError' in found_functions}} - cdef cudaError_t _cudaGetLastError() except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaPeekAtLastError' in found_functions}} - cdef cudaError_t _cudaPeekAtLastError() except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGetErrorName' in found_functions}} - -cdef const char* _cudaGetErrorName(cudaError_t error) except ?NULL nogil -{{endif}} - -{{if 'cudaGetErrorString' in found_functions}} - -cdef const char* _cudaGetErrorString(cudaError_t error) except ?NULL nogil -{{endif}} - -{{if 'cudaGetDeviceCount' in found_functions}} - +cdef const char* _cudaGetErrorName(cudaError_t error) except?NULL nogil +cdef const char* _cudaGetErrorString(cudaError_t error) except?NULL nogil cdef cudaError_t _cudaGetDeviceCount(int* count) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGetDeviceProperties' in found_functions}} - -cdef cudaError_t _cudaGetDeviceProperties(cudaDeviceProp* prop, int device) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetAttribute' in found_functions}} - cdef cudaError_t _cudaDeviceGetAttribute(int* value, cudaDeviceAttr attr, int device) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetHostAtomicCapabilities' in found_functions}} - -cdef cudaError_t _cudaDeviceGetHostAtomicCapabilities(unsigned int* capabilities, const cudaAtomicOperation* operations, unsigned int count, int device) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetDefaultMemPool' in found_functions}} - cdef cudaError_t _cudaDeviceGetDefaultMemPool(cudaMemPool_t* memPool, int device) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceSetMemPool' in found_functions}} - cdef cudaError_t _cudaDeviceSetMemPool(int device, cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetMemPool' in found_functions}} - cdef cudaError_t _cudaDeviceGetMemPool(cudaMemPool_t* memPool, int device) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetNvSciSyncAttributes' in found_functions}} - cdef cudaError_t _cudaDeviceGetNvSciSyncAttributes(void* nvSciSyncAttrList, int device, int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetP2PAttribute' in found_functions}} - cdef cudaError_t _cudaDeviceGetP2PAttribute(int* value, cudaDeviceP2PAttr attr, int srcDevice, int dstDevice) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetP2PAtomicCapabilities' in found_functions}} - -cdef cudaError_t _cudaDeviceGetP2PAtomicCapabilities(unsigned int* capabilities, const cudaAtomicOperation* operations, unsigned int count, int srcDevice, int dstDevice) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaChooseDevice' in found_functions}} - cdef cudaError_t _cudaChooseDevice(int* device, const cudaDeviceProp* prop) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaInitDevice' in found_functions}} - cdef cudaError_t _cudaInitDevice(int device, unsigned int deviceFlags, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaSetDevice' in found_functions}} - cdef cudaError_t _cudaSetDevice(int device) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGetDevice' in found_functions}} - cdef cudaError_t _cudaGetDevice(int* device) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaSetDeviceFlags' in found_functions}} - cdef cudaError_t _cudaSetDeviceFlags(unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGetDeviceFlags' in found_functions}} - cdef cudaError_t _cudaGetDeviceFlags(unsigned int* flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamCreate' in found_functions}} - cdef cudaError_t _cudaStreamCreate(cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamCreateWithFlags' in found_functions}} - cdef cudaError_t _cudaStreamCreateWithFlags(cudaStream_t* pStream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamCreateWithPriority' in found_functions}} - cdef cudaError_t _cudaStreamCreateWithPriority(cudaStream_t* pStream, unsigned int flags, int priority) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamGetPriority' in found_functions}} - cdef cudaError_t _cudaStreamGetPriority(cudaStream_t hStream, int* priority) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamGetFlags' in found_functions}} - cdef cudaError_t _cudaStreamGetFlags(cudaStream_t hStream, unsigned int* flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamGetId' in found_functions}} - cdef cudaError_t _cudaStreamGetId(cudaStream_t hStream, unsigned long long* streamId) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamGetDevice' in found_functions}} - cdef cudaError_t _cudaStreamGetDevice(cudaStream_t hStream, int* device) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaCtxResetPersistingL2Cache' in found_functions}} - cdef cudaError_t _cudaCtxResetPersistingL2Cache() except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamCopyAttributes' in found_functions}} - cdef cudaError_t _cudaStreamCopyAttributes(cudaStream_t dst, cudaStream_t src) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamGetAttribute' in found_functions}} - cdef cudaError_t _cudaStreamGetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, cudaStreamAttrValue* value_out) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamSetAttribute' in found_functions}} - cdef cudaError_t _cudaStreamSetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, const cudaStreamAttrValue* value) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamDestroy' in found_functions}} - cdef cudaError_t _cudaStreamDestroy(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamWaitEvent' in found_functions}} - cdef cudaError_t _cudaStreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamAddCallback' in found_functions}} - cdef cudaError_t _cudaStreamAddCallback(cudaStream_t stream, cudaStreamCallback_t callback, void* userData, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamSynchronize' in found_functions}} - cdef cudaError_t _cudaStreamSynchronize(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamQuery' in found_functions}} - cdef cudaError_t _cudaStreamQuery(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamAttachMemAsync' in found_functions}} - cdef cudaError_t _cudaStreamAttachMemAsync(cudaStream_t stream, void* devPtr, size_t length, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamBeginCapture' in found_functions}} - cdef cudaError_t _cudaStreamBeginCapture(cudaStream_t stream, cudaStreamCaptureMode mode) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamBeginRecaptureToGraph' in found_functions}} - -cdef cudaError_t _cudaStreamBeginRecaptureToGraph(cudaStream_t stream, cudaStreamCaptureMode mode, cudaGraph_t graph, cudaGraphRecaptureCallbackData* callbackData) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamBeginCaptureToGraph' in found_functions}} - cdef cudaError_t _cudaStreamBeginCaptureToGraph(cudaStream_t stream, cudaGraph_t graph, const cudaGraphNode_t* dependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, cudaStreamCaptureMode mode) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaThreadExchangeStreamCaptureMode' in found_functions}} - cdef cudaError_t _cudaThreadExchangeStreamCaptureMode(cudaStreamCaptureMode* mode) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamEndCapture' in found_functions}} - cdef cudaError_t _cudaStreamEndCapture(cudaStream_t stream, cudaGraph_t* pGraph) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamIsCapturing' in found_functions}} - cdef cudaError_t _cudaStreamIsCapturing(cudaStream_t stream, cudaStreamCaptureStatus* pCaptureStatus) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamGetCaptureInfo' in found_functions}} - -cdef cudaError_t _cudaStreamGetCaptureInfo(cudaStream_t stream, cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out, cudaGraph_t* graph_out, const cudaGraphNode_t** dependencies_out, const cudaGraphEdgeData** edgeData_out, size_t* numDependencies_out) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamUpdateCaptureDependencies' in found_functions}} - cdef cudaError_t _cudaStreamUpdateCaptureDependencies(cudaStream_t stream, cudaGraphNode_t* dependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaEventCreate' in found_functions}} - cdef cudaError_t _cudaEventCreate(cudaEvent_t* event) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaEventCreateWithFlags' in found_functions}} - cdef cudaError_t _cudaEventCreateWithFlags(cudaEvent_t* event, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaEventRecord' in found_functions}} - cdef cudaError_t _cudaEventRecord(cudaEvent_t event, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaEventRecordWithFlags' in found_functions}} - cdef cudaError_t _cudaEventRecordWithFlags(cudaEvent_t event, cudaStream_t stream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaEventQuery' in found_functions}} - cdef cudaError_t _cudaEventQuery(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaEventSynchronize' in found_functions}} - cdef cudaError_t _cudaEventSynchronize(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaEventDestroy' in found_functions}} - cdef cudaError_t _cudaEventDestroy(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaEventElapsedTime' in found_functions}} - cdef cudaError_t _cudaEventElapsedTime(float* ms, cudaEvent_t start, cudaEvent_t end) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaImportExternalMemory' in found_functions}} - cdef cudaError_t _cudaImportExternalMemory(cudaExternalMemory_t* extMem_out, const cudaExternalMemoryHandleDesc* memHandleDesc) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaExternalMemoryGetMappedBuffer' in found_functions}} - cdef cudaError_t _cudaExternalMemoryGetMappedBuffer(void** devPtr, cudaExternalMemory_t extMem, const cudaExternalMemoryBufferDesc* bufferDesc) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaExternalMemoryGetMappedMipmappedArray' in found_functions}} - cdef cudaError_t _cudaExternalMemoryGetMappedMipmappedArray(cudaMipmappedArray_t* mipmap, cudaExternalMemory_t extMem, const cudaExternalMemoryMipmappedArrayDesc* mipmapDesc) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDestroyExternalMemory' in found_functions}} - cdef cudaError_t _cudaDestroyExternalMemory(cudaExternalMemory_t extMem) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaImportExternalSemaphore' in found_functions}} - cdef cudaError_t _cudaImportExternalSemaphore(cudaExternalSemaphore_t* extSem_out, const cudaExternalSemaphoreHandleDesc* semHandleDesc) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaSignalExternalSemaphoresAsync' in found_functions}} - -cdef cudaError_t _cudaSignalExternalSemaphoresAsync(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreSignalParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaWaitExternalSemaphoresAsync' in found_functions}} - -cdef cudaError_t _cudaWaitExternalSemaphoresAsync(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreWaitParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDestroyExternalSemaphore' in found_functions}} - cdef cudaError_t _cudaDestroyExternalSemaphore(cudaExternalSemaphore_t extSem) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaFuncSetCacheConfig' in found_functions}} - cdef cudaError_t _cudaFuncSetCacheConfig(const void* func, cudaFuncCache cacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaFuncGetAttributes' in found_functions}} - cdef cudaError_t _cudaFuncGetAttributes(cudaFuncAttributes* attr, const void* func) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaFuncSetAttribute' in found_functions}} - cdef cudaError_t _cudaFuncSetAttribute(const void* func, cudaFuncAttribute attr, int value) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaFuncGetParamCount' in found_functions}} - -cdef cudaError_t _cudaFuncGetParamCount(const void* func, size_t* paramCount) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLaunchHostFunc' in found_functions}} - +cdef cudaError_t _cudaFuncGetName(const char** name, const void* func) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaFuncGetParamInfo(const void* func, size_t paramIndex, size_t* paramOffset, size_t* paramSize) except ?cudaErrorCallRequiresNewerDriver nogil cdef cudaError_t _cudaLaunchHostFunc(cudaStream_t stream, cudaHostFn_t fn, void* userData) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLaunchHostFunc_v2' in found_functions}} - -cdef cudaError_t _cudaLaunchHostFunc_v2(cudaStream_t stream, cudaHostFn_t fn, void* userData, unsigned int syncMode) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaFuncSetSharedMemConfig' in found_functions}} - cdef cudaError_t _cudaFuncSetSharedMemConfig(const void* func, cudaSharedMemConfig config) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaOccupancyMaxActiveBlocksPerMultiprocessor' in found_functions}} - cdef cudaError_t _cudaOccupancyMaxActiveBlocksPerMultiprocessor(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaOccupancyAvailableDynamicSMemPerBlock' in found_functions}} - cdef cudaError_t _cudaOccupancyAvailableDynamicSMemPerBlock(size_t* dynamicSmemSize, const void* func, int numBlocks, int blockSize) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags' in found_functions}} - cdef cudaError_t _cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMallocManaged' in found_functions}} - cdef cudaError_t _cudaMallocManaged(void** devPtr, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMalloc' in found_functions}} - cdef cudaError_t _cudaMalloc(void** devPtr, size_t size) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMallocHost' in found_functions}} - cdef cudaError_t _cudaMallocHost(void** ptr, size_t size) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMallocPitch' in found_functions}} - cdef cudaError_t _cudaMallocPitch(void** devPtr, size_t* pitch, size_t width, size_t height) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMallocArray' in found_functions}} - cdef cudaError_t _cudaMallocArray(cudaArray_t* array, const cudaChannelFormatDesc* desc, size_t width, size_t height, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaFree' in found_functions}} - cdef cudaError_t _cudaFree(void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaFreeHost' in found_functions}} - cdef cudaError_t _cudaFreeHost(void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaFreeArray' in found_functions}} - cdef cudaError_t _cudaFreeArray(cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaFreeMipmappedArray' in found_functions}} - cdef cudaError_t _cudaFreeMipmappedArray(cudaMipmappedArray_t mipmappedArray) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaHostAlloc' in found_functions}} - cdef cudaError_t _cudaHostAlloc(void** pHost, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaHostRegister' in found_functions}} - cdef cudaError_t _cudaHostRegister(void* ptr, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaHostUnregister' in found_functions}} - cdef cudaError_t _cudaHostUnregister(void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaHostGetDevicePointer' in found_functions}} - cdef cudaError_t _cudaHostGetDevicePointer(void** pDevice, void* pHost, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaHostGetFlags' in found_functions}} - cdef cudaError_t _cudaHostGetFlags(unsigned int* pFlags, void* pHost) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMalloc3D' in found_functions}} - cdef cudaError_t _cudaMalloc3D(cudaPitchedPtr* pitchedDevPtr, cudaExtent extent) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMalloc3DArray' in found_functions}} - cdef cudaError_t _cudaMalloc3DArray(cudaArray_t* array, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMallocMipmappedArray' in found_functions}} - cdef cudaError_t _cudaMallocMipmappedArray(cudaMipmappedArray_t* mipmappedArray, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int numLevels, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGetMipmappedArrayLevel' in found_functions}} - cdef cudaError_t _cudaGetMipmappedArrayLevel(cudaArray_t* levelArray, cudaMipmappedArray_const_t mipmappedArray, unsigned int level) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpy3D' in found_functions}} - cdef cudaError_t _cudaMemcpy3D(const cudaMemcpy3DParms* p) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpy3DPeer' in found_functions}} - cdef cudaError_t _cudaMemcpy3DPeer(const cudaMemcpy3DPeerParms* p) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpy3DAsync' in found_functions}} - cdef cudaError_t _cudaMemcpy3DAsync(const cudaMemcpy3DParms* p, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpy3DPeerAsync' in found_functions}} - cdef cudaError_t _cudaMemcpy3DPeerAsync(const cudaMemcpy3DPeerParms* p, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemGetInfo' in found_functions}} - cdef cudaError_t _cudaMemGetInfo(size_t* free, size_t* total) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaArrayGetInfo' in found_functions}} - cdef cudaError_t _cudaArrayGetInfo(cudaChannelFormatDesc* desc, cudaExtent* extent, unsigned int* flags, cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaArrayGetPlane' in found_functions}} - cdef cudaError_t _cudaArrayGetPlane(cudaArray_t* pPlaneArray, cudaArray_t hArray, unsigned int planeIdx) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaArrayGetMemoryRequirements' in found_functions}} - cdef cudaError_t _cudaArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaArray_t array, int device) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMipmappedArrayGetMemoryRequirements' in found_functions}} - cdef cudaError_t _cudaMipmappedArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaMipmappedArray_t mipmap, int device) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaArrayGetSparseProperties' in found_functions}} - cdef cudaError_t _cudaArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMipmappedArrayGetSparseProperties' in found_functions}} - cdef cudaError_t _cudaMipmappedArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaMipmappedArray_t mipmap) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpy' in found_functions}} - cdef cudaError_t _cudaMemcpy(void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpyPeer' in found_functions}} - cdef cudaError_t _cudaMemcpyPeer(void* dst, int dstDevice, const void* src, int srcDevice, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpy2D' in found_functions}} - cdef cudaError_t _cudaMemcpy2D(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpy2DToArray' in found_functions}} - cdef cudaError_t _cudaMemcpy2DToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpy2DFromArray' in found_functions}} - cdef cudaError_t _cudaMemcpy2DFromArray(void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpy2DArrayToArray' in found_functions}} - cdef cudaError_t _cudaMemcpy2DArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpyAsync' in found_functions}} - cdef cudaError_t _cudaMemcpyAsync(void* dst, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpyPeerAsync' in found_functions}} - cdef cudaError_t _cudaMemcpyPeerAsync(void* dst, int dstDevice, const void* src, int srcDevice, size_t count, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpyBatchAsync' in found_functions}} - cdef cudaError_t _cudaMemcpyBatchAsync(const void** dsts, const void** srcs, const size_t* sizes, size_t count, cudaMemcpyAttributes* attrs, size_t* attrsIdxs, size_t numAttrs, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpy3DBatchAsync' in found_functions}} - cdef cudaError_t _cudaMemcpy3DBatchAsync(size_t numOps, cudaMemcpy3DBatchOp* opList, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpyWithAttributesAsync' in found_functions}} - -cdef cudaError_t _cudaMemcpyWithAttributesAsync(void* dst, const void* src, size_t size, cudaMemcpyAttributes* attr, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpy3DWithAttributesAsync' in found_functions}} - -cdef cudaError_t _cudaMemcpy3DWithAttributesAsync(cudaMemcpy3DBatchOp* op, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpy2DAsync' in found_functions}} - cdef cudaError_t _cudaMemcpy2DAsync(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpy2DToArrayAsync' in found_functions}} - cdef cudaError_t _cudaMemcpy2DToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpy2DFromArrayAsync' in found_functions}} - cdef cudaError_t _cudaMemcpy2DFromArrayAsync(void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemset' in found_functions}} - cdef cudaError_t _cudaMemset(void* devPtr, int value, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemset2D' in found_functions}} - cdef cudaError_t _cudaMemset2D(void* devPtr, size_t pitch, int value, size_t width, size_t height) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemset3D' in found_functions}} - cdef cudaError_t _cudaMemset3D(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemsetAsync' in found_functions}} - cdef cudaError_t _cudaMemsetAsync(void* devPtr, int value, size_t count, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemset2DAsync' in found_functions}} - cdef cudaError_t _cudaMemset2DAsync(void* devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemset3DAsync' in found_functions}} - cdef cudaError_t _cudaMemset3DAsync(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemPrefetchAsync' in found_functions}} - cdef cudaError_t _cudaMemPrefetchAsync(const void* devPtr, size_t count, cudaMemLocation location, unsigned int flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemPrefetchBatchAsync' in found_functions}} - -cdef cudaError_t _cudaMemPrefetchBatchAsync(void** dptrs, size_t* sizes, size_t count, cudaMemLocation* prefetchLocs, size_t* prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemDiscardBatchAsync' in found_functions}} - -cdef cudaError_t _cudaMemDiscardBatchAsync(void** dptrs, size_t* sizes, size_t count, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemDiscardAndPrefetchBatchAsync' in found_functions}} - -cdef cudaError_t _cudaMemDiscardAndPrefetchBatchAsync(void** dptrs, size_t* sizes, size_t count, cudaMemLocation* prefetchLocs, size_t* prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemAdvise' in found_functions}} - cdef cudaError_t _cudaMemAdvise(const void* devPtr, size_t count, cudaMemoryAdvise advice, cudaMemLocation location) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemRangeGetAttribute' in found_functions}} - cdef cudaError_t _cudaMemRangeGetAttribute(void* data, size_t dataSize, cudaMemRangeAttribute attribute, const void* devPtr, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemRangeGetAttributes' in found_functions}} - cdef cudaError_t _cudaMemRangeGetAttributes(void** data, size_t* dataSizes, cudaMemRangeAttribute* attributes, size_t numAttributes, const void* devPtr, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpyToArray' in found_functions}} - cdef cudaError_t _cudaMemcpyToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpyFromArray' in found_functions}} - cdef cudaError_t _cudaMemcpyFromArray(void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpyArrayToArray' in found_functions}} - cdef cudaError_t _cudaMemcpyArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpyToArrayAsync' in found_functions}} - cdef cudaError_t _cudaMemcpyToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpyFromArrayAsync' in found_functions}} - cdef cudaError_t _cudaMemcpyFromArrayAsync(void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMallocAsync' in found_functions}} - cdef cudaError_t _cudaMallocAsync(void** devPtr, size_t size, cudaStream_t hStream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaFreeAsync' in found_functions}} - cdef cudaError_t _cudaFreeAsync(void* devPtr, cudaStream_t hStream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemPoolTrimTo' in found_functions}} - cdef cudaError_t _cudaMemPoolTrimTo(cudaMemPool_t memPool, size_t minBytesToKeep) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemPoolSetAttribute' in found_functions}} - cdef cudaError_t _cudaMemPoolSetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemPoolGetAttribute' in found_functions}} - cdef cudaError_t _cudaMemPoolGetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemPoolSetAccess' in found_functions}} - cdef cudaError_t _cudaMemPoolSetAccess(cudaMemPool_t memPool, const cudaMemAccessDesc* descList, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemPoolGetAccess' in found_functions}} - cdef cudaError_t _cudaMemPoolGetAccess(cudaMemAccessFlags* flags, cudaMemPool_t memPool, cudaMemLocation* location) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemPoolCreate' in found_functions}} - cdef cudaError_t _cudaMemPoolCreate(cudaMemPool_t* memPool, const cudaMemPoolProps* poolProps) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemPoolDestroy' in found_functions}} - cdef cudaError_t _cudaMemPoolDestroy(cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemGetDefaultMemPool' in found_functions}} - -cdef cudaError_t _cudaMemGetDefaultMemPool(cudaMemPool_t* memPool, cudaMemLocation* location, cudaMemAllocationType typename) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemGetMemPool' in found_functions}} - -cdef cudaError_t _cudaMemGetMemPool(cudaMemPool_t* memPool, cudaMemLocation* location, cudaMemAllocationType typename) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemSetMemPool' in found_functions}} - -cdef cudaError_t _cudaMemSetMemPool(cudaMemLocation* location, cudaMemAllocationType typename, cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMallocFromPoolAsync' in found_functions}} - cdef cudaError_t _cudaMallocFromPoolAsync(void** ptr, size_t size, cudaMemPool_t memPool, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemPoolExportToShareableHandle' in found_functions}} - cdef cudaError_t _cudaMemPoolExportToShareableHandle(void* shareableHandle, cudaMemPool_t memPool, cudaMemAllocationHandleType handleType, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemPoolImportFromShareableHandle' in found_functions}} - cdef cudaError_t _cudaMemPoolImportFromShareableHandle(cudaMemPool_t* memPool, void* shareableHandle, cudaMemAllocationHandleType handleType, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemPoolExportPointer' in found_functions}} - cdef cudaError_t _cudaMemPoolExportPointer(cudaMemPoolPtrExportData* exportData, void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemPoolImportPointer' in found_functions}} - cdef cudaError_t _cudaMemPoolImportPointer(void** ptr, cudaMemPool_t memPool, cudaMemPoolPtrExportData* exportData) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaPointerGetAttributes' in found_functions}} - cdef cudaError_t _cudaPointerGetAttributes(cudaPointerAttributes* attributes, const void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceCanAccessPeer' in found_functions}} - cdef cudaError_t _cudaDeviceCanAccessPeer(int* canAccessPeer, int device, int peerDevice) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceEnablePeerAccess' in found_functions}} - cdef cudaError_t _cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceDisablePeerAccess' in found_functions}} - cdef cudaError_t _cudaDeviceDisablePeerAccess(int peerDevice) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphicsUnregisterResource' in found_functions}} - cdef cudaError_t _cudaGraphicsUnregisterResource(cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphicsResourceSetMapFlags' in found_functions}} - cdef cudaError_t _cudaGraphicsResourceSetMapFlags(cudaGraphicsResource_t resource, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphicsMapResources' in found_functions}} - cdef cudaError_t _cudaGraphicsMapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphicsUnmapResources' in found_functions}} - cdef cudaError_t _cudaGraphicsUnmapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphicsResourceGetMappedPointer' in found_functions}} - cdef cudaError_t _cudaGraphicsResourceGetMappedPointer(void** devPtr, size_t* size, cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphicsSubResourceGetMappedArray' in found_functions}} - cdef cudaError_t _cudaGraphicsSubResourceGetMappedArray(cudaArray_t* array, cudaGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphicsResourceGetMappedMipmappedArray' in found_functions}} - cdef cudaError_t _cudaGraphicsResourceGetMappedMipmappedArray(cudaMipmappedArray_t* mipmappedArray, cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGetChannelDesc' in found_functions}} - cdef cudaError_t _cudaGetChannelDesc(cudaChannelFormatDesc* desc, cudaArray_const_t array) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaCreateChannelDesc' in found_functions}} - cdef cudaChannelFormatDesc _cudaCreateChannelDesc(int x, int y, int z, int w, cudaChannelFormatKind f) except* nogil -{{endif}} - -{{if 'cudaCreateTextureObject' in found_functions}} - cdef cudaError_t _cudaCreateTextureObject(cudaTextureObject_t* pTexObject, const cudaResourceDesc* pResDesc, const cudaTextureDesc* pTexDesc, const cudaResourceViewDesc* pResViewDesc) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDestroyTextureObject' in found_functions}} - cdef cudaError_t _cudaDestroyTextureObject(cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGetTextureObjectResourceDesc' in found_functions}} - cdef cudaError_t _cudaGetTextureObjectResourceDesc(cudaResourceDesc* pResDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGetTextureObjectTextureDesc' in found_functions}} - cdef cudaError_t _cudaGetTextureObjectTextureDesc(cudaTextureDesc* pTexDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGetTextureObjectResourceViewDesc' in found_functions}} - cdef cudaError_t _cudaGetTextureObjectResourceViewDesc(cudaResourceViewDesc* pResViewDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaCreateSurfaceObject' in found_functions}} - cdef cudaError_t _cudaCreateSurfaceObject(cudaSurfaceObject_t* pSurfObject, const cudaResourceDesc* pResDesc) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDestroySurfaceObject' in found_functions}} - cdef cudaError_t _cudaDestroySurfaceObject(cudaSurfaceObject_t surfObject) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGetSurfaceObjectResourceDesc' in found_functions}} - cdef cudaError_t _cudaGetSurfaceObjectResourceDesc(cudaResourceDesc* pResDesc, cudaSurfaceObject_t surfObject) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDriverGetVersion' in found_functions}} - cdef cudaError_t _cudaDriverGetVersion(int* driverVersion) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaRuntimeGetVersion' in found_functions}} - cdef cudaError_t _cudaRuntimeGetVersion(int* runtimeVersion) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLogsRegisterCallback' in found_functions}} - -cdef cudaError_t _cudaLogsRegisterCallback(cudaLogsCallback_t callbackFunc, void* userData, cudaLogsCallbackHandle* callback_out) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLogsUnregisterCallback' in found_functions}} - -cdef cudaError_t _cudaLogsUnregisterCallback(cudaLogsCallbackHandle callback) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLogsCurrent' in found_functions}} - -cdef cudaError_t _cudaLogsCurrent(cudaLogIterator* iterator_out, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLogsDumpToFile' in found_functions}} - -cdef cudaError_t _cudaLogsDumpToFile(cudaLogIterator* iterator, const char* pathToFile, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLogsDumpToMemory' in found_functions}} - -cdef cudaError_t _cudaLogsDumpToMemory(cudaLogIterator* iterator, char* buffer, size_t* size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphCreate' in found_functions}} - cdef cudaError_t _cudaGraphCreate(cudaGraph_t* pGraph, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphAddKernelNode' in found_functions}} - cdef cudaError_t _cudaGraphAddKernelNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphKernelNodeGetParams' in found_functions}} - cdef cudaError_t _cudaGraphKernelNodeGetParams(cudaGraphNode_t node, cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphKernelNodeSetParams' in found_functions}} - cdef cudaError_t _cudaGraphKernelNodeSetParams(cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphKernelNodeCopyAttributes' in found_functions}} - cdef cudaError_t _cudaGraphKernelNodeCopyAttributes(cudaGraphNode_t hDst, cudaGraphNode_t hSrc) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphKernelNodeGetAttribute' in found_functions}} - cdef cudaError_t _cudaGraphKernelNodeGetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, cudaKernelNodeAttrValue* value_out) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphKernelNodeSetAttribute' in found_functions}} - cdef cudaError_t _cudaGraphKernelNodeSetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, const cudaKernelNodeAttrValue* value) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphAddMemcpyNode' in found_functions}} - cdef cudaError_t _cudaGraphAddMemcpyNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemcpy3DParms* pCopyParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphAddMemcpyNode1D' in found_functions}} - cdef cudaError_t _cudaGraphAddMemcpyNode1D(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphMemcpyNodeGetParams' in found_functions}} - cdef cudaError_t _cudaGraphMemcpyNodeGetParams(cudaGraphNode_t node, cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphMemcpyNodeSetParams' in found_functions}} - cdef cudaError_t _cudaGraphMemcpyNodeSetParams(cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphMemcpyNodeSetParams1D' in found_functions}} - cdef cudaError_t _cudaGraphMemcpyNodeSetParams1D(cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphAddMemsetNode' in found_functions}} - cdef cudaError_t _cudaGraphAddMemsetNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemsetParams* pMemsetParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphMemsetNodeGetParams' in found_functions}} - cdef cudaError_t _cudaGraphMemsetNodeGetParams(cudaGraphNode_t node, cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphMemsetNodeSetParams' in found_functions}} - cdef cudaError_t _cudaGraphMemsetNodeSetParams(cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphAddHostNode' in found_functions}} - cdef cudaError_t _cudaGraphAddHostNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphHostNodeGetParams' in found_functions}} - cdef cudaError_t _cudaGraphHostNodeGetParams(cudaGraphNode_t node, cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphHostNodeSetParams' in found_functions}} - cdef cudaError_t _cudaGraphHostNodeSetParams(cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphAddChildGraphNode' in found_functions}} - cdef cudaError_t _cudaGraphAddChildGraphNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaGraph_t childGraph) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphChildGraphNodeGetGraph' in found_functions}} - cdef cudaError_t _cudaGraphChildGraphNodeGetGraph(cudaGraphNode_t node, cudaGraph_t* pGraph) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphAddEmptyNode' in found_functions}} - cdef cudaError_t _cudaGraphAddEmptyNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphAddEventRecordNode' in found_functions}} - cdef cudaError_t _cudaGraphAddEventRecordNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphEventRecordNodeGetEvent' in found_functions}} - cdef cudaError_t _cudaGraphEventRecordNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphEventRecordNodeSetEvent' in found_functions}} - cdef cudaError_t _cudaGraphEventRecordNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphAddEventWaitNode' in found_functions}} - cdef cudaError_t _cudaGraphAddEventWaitNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphEventWaitNodeGetEvent' in found_functions}} - cdef cudaError_t _cudaGraphEventWaitNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphEventWaitNodeSetEvent' in found_functions}} - cdef cudaError_t _cudaGraphEventWaitNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphAddExternalSemaphoresSignalNode' in found_functions}} - cdef cudaError_t _cudaGraphAddExternalSemaphoresSignalNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExternalSemaphoresSignalNodeGetParams' in found_functions}} - cdef cudaError_t _cudaGraphExternalSemaphoresSignalNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreSignalNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExternalSemaphoresSignalNodeSetParams' in found_functions}} - cdef cudaError_t _cudaGraphExternalSemaphoresSignalNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphAddExternalSemaphoresWaitNode' in found_functions}} - cdef cudaError_t _cudaGraphAddExternalSemaphoresWaitNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExternalSemaphoresWaitNodeGetParams' in found_functions}} - cdef cudaError_t _cudaGraphExternalSemaphoresWaitNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreWaitNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExternalSemaphoresWaitNodeSetParams' in found_functions}} - cdef cudaError_t _cudaGraphExternalSemaphoresWaitNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphAddMemAllocNode' in found_functions}} - cdef cudaError_t _cudaGraphAddMemAllocNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaMemAllocNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphMemAllocNodeGetParams' in found_functions}} - cdef cudaError_t _cudaGraphMemAllocNodeGetParams(cudaGraphNode_t node, cudaMemAllocNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphAddMemFreeNode' in found_functions}} - cdef cudaError_t _cudaGraphAddMemFreeNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dptr) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphMemFreeNodeGetParams' in found_functions}} - cdef cudaError_t _cudaGraphMemFreeNodeGetParams(cudaGraphNode_t node, void* dptr_out) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGraphMemTrim' in found_functions}} - cdef cudaError_t _cudaDeviceGraphMemTrim(int device) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetGraphMemAttribute' in found_functions}} - cdef cudaError_t _cudaDeviceGetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceSetGraphMemAttribute' in found_functions}} - cdef cudaError_t _cudaDeviceSetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphClone' in found_functions}} - cdef cudaError_t _cudaGraphClone(cudaGraph_t* pGraphClone, cudaGraph_t originalGraph) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphNodeFindInClone' in found_functions}} - cdef cudaError_t _cudaGraphNodeFindInClone(cudaGraphNode_t* pNode, cudaGraphNode_t originalNode, cudaGraph_t clonedGraph) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphNodeGetType' in found_functions}} - cdef cudaError_t _cudaGraphNodeGetType(cudaGraphNode_t node, cudaGraphNodeType* pType) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphNodeGetContainingGraph' in found_functions}} - -cdef cudaError_t _cudaGraphNodeGetContainingGraph(cudaGraphNode_t hNode, cudaGraph_t* phGraph) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphNodeGetLocalId' in found_functions}} - -cdef cudaError_t _cudaGraphNodeGetLocalId(cudaGraphNode_t hNode, unsigned int* nodeId) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphNodeGetToolsId' in found_functions}} - -cdef cudaError_t _cudaGraphNodeGetToolsId(cudaGraphNode_t hNode, unsigned long long* toolsNodeId) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphGetId' in found_functions}} - -cdef cudaError_t _cudaGraphGetId(cudaGraph_t hGraph, unsigned int* graphID) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExecGetId' in found_functions}} - -cdef cudaError_t _cudaGraphExecGetId(cudaGraphExec_t hGraphExec, unsigned int* graphID) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphGetNodes' in found_functions}} - cdef cudaError_t _cudaGraphGetNodes(cudaGraph_t graph, cudaGraphNode_t* nodes, size_t* numNodes) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphGetRootNodes' in found_functions}} - cdef cudaError_t _cudaGraphGetRootNodes(cudaGraph_t graph, cudaGraphNode_t* pRootNodes, size_t* pNumRootNodes) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphGetEdges' in found_functions}} - cdef cudaError_t _cudaGraphGetEdges(cudaGraph_t graph, cudaGraphNode_t* from_, cudaGraphNode_t* to, cudaGraphEdgeData* edgeData, size_t* numEdges) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphNodeGetDependencies' in found_functions}} - cdef cudaError_t _cudaGraphNodeGetDependencies(cudaGraphNode_t node, cudaGraphNode_t* pDependencies, cudaGraphEdgeData* edgeData, size_t* pNumDependencies) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphNodeGetDependentNodes' in found_functions}} - cdef cudaError_t _cudaGraphNodeGetDependentNodes(cudaGraphNode_t node, cudaGraphNode_t* pDependentNodes, cudaGraphEdgeData* edgeData, size_t* pNumDependentNodes) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphAddDependencies' in found_functions}} - cdef cudaError_t _cudaGraphAddDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, const cudaGraphEdgeData* edgeData, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphRemoveDependencies' in found_functions}} - cdef cudaError_t _cudaGraphRemoveDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, const cudaGraphEdgeData* edgeData, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphDestroyNode' in found_functions}} - cdef cudaError_t _cudaGraphDestroyNode(cudaGraphNode_t node) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphInstantiate' in found_functions}} - cdef cudaError_t _cudaGraphInstantiate(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphInstantiateWithFlags' in found_functions}} - cdef cudaError_t _cudaGraphInstantiateWithFlags(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphInstantiateWithParams' in found_functions}} - cdef cudaError_t _cudaGraphInstantiateWithParams(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, cudaGraphInstantiateParams* instantiateParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExecGetFlags' in found_functions}} - cdef cudaError_t _cudaGraphExecGetFlags(cudaGraphExec_t graphExec, unsigned long long* flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExecKernelNodeSetParams' in found_functions}} - cdef cudaError_t _cudaGraphExecKernelNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExecMemcpyNodeSetParams' in found_functions}} - cdef cudaError_t _cudaGraphExecMemcpyNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExecMemcpyNodeSetParams1D' in found_functions}} - cdef cudaError_t _cudaGraphExecMemcpyNodeSetParams1D(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExecMemsetNodeSetParams' in found_functions}} - cdef cudaError_t _cudaGraphExecMemsetNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExecHostNodeSetParams' in found_functions}} - cdef cudaError_t _cudaGraphExecHostNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExecChildGraphNodeSetParams' in found_functions}} - cdef cudaError_t _cudaGraphExecChildGraphNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, cudaGraph_t childGraph) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExecEventRecordNodeSetEvent' in found_functions}} - cdef cudaError_t _cudaGraphExecEventRecordNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExecEventWaitNodeSetEvent' in found_functions}} - cdef cudaError_t _cudaGraphExecEventWaitNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExecExternalSemaphoresSignalNodeSetParams' in found_functions}} - cdef cudaError_t _cudaGraphExecExternalSemaphoresSignalNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExecExternalSemaphoresWaitNodeSetParams' in found_functions}} - cdef cudaError_t _cudaGraphExecExternalSemaphoresWaitNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphNodeSetEnabled' in found_functions}} - cdef cudaError_t _cudaGraphNodeSetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int isEnabled) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphNodeGetEnabled' in found_functions}} - cdef cudaError_t _cudaGraphNodeGetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int* isEnabled) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExecUpdate' in found_functions}} - cdef cudaError_t _cudaGraphExecUpdate(cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphExecUpdateResultInfo* resultInfo) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphUpload' in found_functions}} - cdef cudaError_t _cudaGraphUpload(cudaGraphExec_t graphExec, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphLaunch' in found_functions}} - cdef cudaError_t _cudaGraphLaunch(cudaGraphExec_t graphExec, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExecDestroy' in found_functions}} - cdef cudaError_t _cudaGraphExecDestroy(cudaGraphExec_t graphExec) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphDestroy' in found_functions}} - cdef cudaError_t _cudaGraphDestroy(cudaGraph_t graph) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphDebugDotPrint' in found_functions}} - cdef cudaError_t _cudaGraphDebugDotPrint(cudaGraph_t graph, const char* path, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaUserObjectCreate' in found_functions}} - cdef cudaError_t _cudaUserObjectCreate(cudaUserObject_t* object_out, void* ptr, cudaHostFn_t destroy, unsigned int initialRefcount, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaUserObjectRetain' in found_functions}} - cdef cudaError_t _cudaUserObjectRetain(cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaUserObjectRelease' in found_functions}} - cdef cudaError_t _cudaUserObjectRelease(cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphRetainUserObject' in found_functions}} - cdef cudaError_t _cudaGraphRetainUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphReleaseUserObject' in found_functions}} - cdef cudaError_t _cudaGraphReleaseUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphAddNode' in found_functions}} - cdef cudaError_t _cudaGraphAddNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphNodeSetParams' in found_functions}} - cdef cudaError_t _cudaGraphNodeSetParams(cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphNodeGetParams' in found_functions}} - -cdef cudaError_t _cudaGraphNodeGetParams(cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExecNodeSetParams' in found_functions}} - cdef cudaError_t _cudaGraphExecNodeSetParams(cudaGraphExec_t graphExec, cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphConditionalHandleCreate' in found_functions}} - cdef cudaError_t _cudaGraphConditionalHandleCreate(cudaGraphConditionalHandle* pHandle_out, cudaGraph_t graph, unsigned int defaultLaunchValue, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphConditionalHandleCreate_v2' in found_functions}} - -cdef cudaError_t _cudaGraphConditionalHandleCreate_v2(cudaGraphConditionalHandle* pHandle_out, cudaGraph_t graph, cudaExecutionContext_t ctx, unsigned int defaultLaunchValue, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGetDriverEntryPoint' in found_functions}} - cdef cudaError_t _cudaGetDriverEntryPoint(const char* symbol, void** funcPtr, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGetDriverEntryPointByVersion' in found_functions}} - cdef cudaError_t _cudaGetDriverEntryPointByVersion(const char* symbol, void** funcPtr, unsigned int cudaVersion, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLibraryLoadData' in found_functions}} - cdef cudaError_t _cudaLibraryLoadData(cudaLibrary_t* library, const void* code, cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLibraryLoadFromFile' in found_functions}} - cdef cudaError_t _cudaLibraryLoadFromFile(cudaLibrary_t* library, const char* fileName, cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLibraryUnload' in found_functions}} - cdef cudaError_t _cudaLibraryUnload(cudaLibrary_t library) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLibraryGetKernel' in found_functions}} - cdef cudaError_t _cudaLibraryGetKernel(cudaKernel_t* pKernel, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLibraryGetGlobal' in found_functions}} - -cdef cudaError_t _cudaLibraryGetGlobal(void** dptr, size_t* numbytes, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLibraryGetManaged' in found_functions}} - -cdef cudaError_t _cudaLibraryGetManaged(void** dptr, size_t* numbytes, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLibraryGetUnifiedFunction' in found_functions}} - +cdef cudaError_t _cudaLibraryGetGlobal(void** dptr, size_t* bytes, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaLibraryGetManaged(void** dptr, size_t* bytes, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil cdef cudaError_t _cudaLibraryGetUnifiedFunction(void** fptr, cudaLibrary_t library, const char* symbol) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLibraryGetKernelCount' in found_functions}} - cdef cudaError_t _cudaLibraryGetKernelCount(unsigned int* count, cudaLibrary_t lib) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLibraryEnumerateKernels' in found_functions}} - cdef cudaError_t _cudaLibraryEnumerateKernels(cudaKernel_t* kernels, unsigned int numKernels, cudaLibrary_t lib) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaKernelSetAttributeForDevice' in found_functions}} - cdef cudaError_t _cudaKernelSetAttributeForDevice(cudaKernel_t kernel, cudaFuncAttribute attr, int value, int device) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetDevResource' in found_functions}} - -cdef cudaError_t _cudaDeviceGetDevResource(int device, cudaDevResource* resource, cudaDevResourceType typename) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDevSmResourceSplitByCount' in found_functions}} - +cdef cudaError_t _cudaGetExportTable(const void** ppExportTable, const cudaUUID_t* pExportTableId) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGetKernel(cudaKernel_t* kernelPtr, const void* entryFuncAddr) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaProfilerStart() except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaProfilerStop() except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGetDeviceProperties(cudaDeviceProp* prop, int device) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceGetHostAtomicCapabilities(unsigned int* capabilities, const cudaAtomicOperation* operations, unsigned int count, int device) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceGetP2PAtomicCapabilities(unsigned int* capabilities, const cudaAtomicOperation* operations, unsigned int count, int srcDevice, int dstDevice) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaStreamGetCaptureInfo(cudaStream_t stream, cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out, cudaGraph_t* graph_out, const cudaGraphNode_t** dependencies_out, const cudaGraphEdgeData** edgeData_out, size_t* numDependencies_out) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaSignalExternalSemaphoresAsync(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreSignalParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaWaitExternalSemaphoresAsync(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreWaitParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemPrefetchBatchAsync(void** dptrs, size_t* sizes, size_t count, cudaMemLocation* prefetchLocs, size_t* prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemDiscardBatchAsync(void** dptrs, size_t* sizes, size_t count, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemDiscardAndPrefetchBatchAsync(void** dptrs, size_t* sizes, size_t count, cudaMemLocation* prefetchLocs, size_t* prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemGetDefaultMemPool(cudaMemPool_t* memPool, cudaMemLocation* location, cudaMemAllocationType type) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemGetMemPool(cudaMemPool_t* memPool, cudaMemLocation* location, cudaMemAllocationType type) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemSetMemPool(cudaMemLocation* location, cudaMemAllocationType type, cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaLogsRegisterCallback(cudaLogsCallback_t callbackFunc, void* userData, cudaLogsCallbackHandle* callback_out) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaLogsUnregisterCallback(cudaLogsCallbackHandle callback) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaLogsCurrent(cudaLogIterator* iterator_out, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaLogsDumpToFile(cudaLogIterator* iterator, const char* pathToFile, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaLogsDumpToMemory(cudaLogIterator* iterator, char* buffer, size_t* size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphNodeGetContainingGraph(cudaGraphNode_t hNode, cudaGraph_t* phGraph) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphNodeGetLocalId(cudaGraphNode_t hNode, unsigned int* nodeId) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphNodeGetToolsId(cudaGraphNode_t hNode, unsigned long long* toolsNodeId) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphGetId(cudaGraph_t hGraph, unsigned int* graphID) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphExecGetId(cudaGraphExec_t hGraphExec, unsigned int* graphID) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphConditionalHandleCreate_v2(cudaGraphConditionalHandle* pHandle_out, cudaGraph_t graph, cudaExecutionContext_t ctx, unsigned int defaultLaunchValue, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceGetDevResource(int device, cudaDevResource* resource, cudaDevResourceType type) except ?cudaErrorCallRequiresNewerDriver nogil cdef cudaError_t _cudaDevSmResourceSplitByCount(cudaDevResource* result, unsigned int* nbGroups, const cudaDevResource* input, cudaDevResource* remaining, unsigned int flags, unsigned int minCount) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDevSmResourceSplit' in found_functions}} - cdef cudaError_t _cudaDevSmResourceSplit(cudaDevResource* result, unsigned int nbGroups, const cudaDevResource* input, cudaDevResource* remainder, unsigned int flags, cudaDevSmResourceGroupParams* groupParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDevResourceGenerateDesc' in found_functions}} - cdef cudaError_t _cudaDevResourceGenerateDesc(cudaDevResourceDesc_t* phDesc, cudaDevResource* resources, unsigned int nbResources) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGreenCtxCreate' in found_functions}} - cdef cudaError_t _cudaGreenCtxCreate(cudaExecutionContext_t* phCtx, cudaDevResourceDesc_t desc, int device, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaExecutionCtxDestroy' in found_functions}} - cdef cudaError_t _cudaExecutionCtxDestroy(cudaExecutionContext_t ctx) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaExecutionCtxGetDevResource' in found_functions}} - -cdef cudaError_t _cudaExecutionCtxGetDevResource(cudaExecutionContext_t ctx, cudaDevResource* resource, cudaDevResourceType typename) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaExecutionCtxGetDevice' in found_functions}} - +cdef cudaError_t _cudaExecutionCtxGetDevResource(cudaExecutionContext_t ctx, cudaDevResource* resource, cudaDevResourceType type) except ?cudaErrorCallRequiresNewerDriver nogil cdef cudaError_t _cudaExecutionCtxGetDevice(int* device, cudaExecutionContext_t ctx) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaExecutionCtxGetId' in found_functions}} - cdef cudaError_t _cudaExecutionCtxGetId(cudaExecutionContext_t ctx, unsigned long long* ctxId) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaExecutionCtxStreamCreate' in found_functions}} - cdef cudaError_t _cudaExecutionCtxStreamCreate(cudaStream_t* phStream, cudaExecutionContext_t ctx, unsigned int flags, int priority) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaExecutionCtxSynchronize' in found_functions}} - cdef cudaError_t _cudaExecutionCtxSynchronize(cudaExecutionContext_t ctx) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamGetDevResource' in found_functions}} - -cdef cudaError_t _cudaStreamGetDevResource(cudaStream_t hStream, cudaDevResource* resource, cudaDevResourceType typename) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaExecutionCtxRecordEvent' in found_functions}} - +cdef cudaError_t _cudaStreamGetDevResource(cudaStream_t hStream, cudaDevResource* resource, cudaDevResourceType type) except ?cudaErrorCallRequiresNewerDriver nogil cdef cudaError_t _cudaExecutionCtxRecordEvent(cudaExecutionContext_t ctx, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaExecutionCtxWaitEvent' in found_functions}} - cdef cudaError_t _cudaExecutionCtxWaitEvent(cudaExecutionContext_t ctx, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetExecutionCtx' in found_functions}} - cdef cudaError_t _cudaDeviceGetExecutionCtx(cudaExecutionContext_t* ctx, int device) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGetExportTable' in found_functions}} - -cdef cudaError_t _cudaGetExportTable(const void** ppExportTable, const cudaUUID_t* pExportTableId) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGetKernel' in found_functions}} - -cdef cudaError_t _cudaGetKernel(cudaKernel_t* kernelPtr, const void* entryFuncAddr) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'make_cudaPitchedPtr' in found_functions}} - -cdef cudaPitchedPtr _make_cudaPitchedPtr(void* d, size_t p, size_t xsz, size_t ysz) except* nogil -{{endif}} - -{{if 'make_cudaPos' in found_functions}} - -cdef cudaPos _make_cudaPos(size_t x, size_t y, size_t z) except* nogil -{{endif}} - -{{if 'make_cudaExtent' in found_functions}} - -cdef cudaExtent _make_cudaExtent(size_t w, size_t h, size_t d) except* nogil -{{endif}} - -{{if 'cudaProfilerStart' in found_functions}} - -cdef cudaError_t _cudaProfilerStart() except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaProfilerStop' in found_functions}} - -cdef cudaError_t _cudaProfilerStop() except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} +cdef cudaError_t _cudaFuncGetParamCount(const void* func, size_t* paramCount) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaLaunchHostFunc_v2(cudaStream_t stream, cudaHostFn_t fn, void* userData, unsigned int syncMode) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemcpyWithAttributesAsync(void* dst, const void* src, size_t size, cudaMemcpyAttributes* attr, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemcpy3DWithAttributesAsync(cudaMemcpy3DBatchOp* op, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphNodeGetParams(cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaStreamBeginRecaptureToGraph(cudaStream_t stream, cudaStreamCaptureMode mode, cudaGraph_t graph, cudaGraphRecaptureCallbackData* callbackData) except ?cudaErrorCallRequiresNewerDriver nogil diff --git a/cuda_bindings/cuda/bindings/_internal/runtime_ptds_linux.pyx b/cuda_bindings/cuda/bindings/_internal/runtime_ptds_linux.pyx new file mode 100644 index 00000000000..0f940954d0d --- /dev/null +++ b/cuda_bindings/cuda/bindings/_internal/runtime_ptds_linux.pyx @@ -0,0 +1,2262 @@ +# SPDX-FileCopyrightText: Copyright (c) 2021-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# SPDX-License-Identifier: Apache-2.0 +# +# This code was automatically generated across versions from 12.9.0 to 13.3.0. Do not modify it directly. + +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=33b0c77f7174d41189a91abfe73613b5ba48bd31b5da37d509da61c00b11a004 +cdef extern from "": + """ + #define CUDA_API_PER_THREAD_DEFAULT_STREAM + """ + + +############################################################################### +# C function declarations for static cudart with per-thread default stream +# (CUDA_API_PER_THREAD_DEFAULT_STREAM causes cudaXxx to resolve to the _ptsz +# per-thread-stream symbol variants) +############################################################################### + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceReset "cudaDeviceReset" () noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceSynchronize "cudaDeviceSynchronize" () noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceSetLimit "cudaDeviceSetLimit" (cudaLimit limit, size_t value) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetLimit "cudaDeviceGetLimit" (size_t* pValue, cudaLimit limit) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetTexture1DLinearMaxWidth "cudaDeviceGetTexture1DLinearMaxWidth" (size_t* maxWidthInElements, const cudaChannelFormatDesc* fmtDesc, int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetCacheConfig "cudaDeviceGetCacheConfig" (cudaFuncCache* pCacheConfig) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetStreamPriorityRange "cudaDeviceGetStreamPriorityRange" (int* leastPriority, int* greatestPriority) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceSetCacheConfig "cudaDeviceSetCacheConfig" (cudaFuncCache cacheConfig) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetByPCIBusId "cudaDeviceGetByPCIBusId" (int* device, const char* pciBusId) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetPCIBusId "cudaDeviceGetPCIBusId" (char* pciBusId, int len, int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaIpcGetEventHandle "cudaIpcGetEventHandle" (cudaIpcEventHandle_t* handle, cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaIpcOpenEventHandle "cudaIpcOpenEventHandle" (cudaEvent_t* event, cudaIpcEventHandle_t handle) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaIpcGetMemHandle "cudaIpcGetMemHandle" (cudaIpcMemHandle_t* handle, void* devPtr) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaIpcOpenMemHandle "cudaIpcOpenMemHandle" (void** devPtr, cudaIpcMemHandle_t handle, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaIpcCloseMemHandle "cudaIpcCloseMemHandle" (void* devPtr) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceFlushGPUDirectRDMAWrites "cudaDeviceFlushGPUDirectRDMAWrites" (cudaFlushGPUDirectRDMAWritesTarget target, cudaFlushGPUDirectRDMAWritesScope scope) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceRegisterAsyncNotification "cudaDeviceRegisterAsyncNotification" (int device, cudaAsyncCallback callbackFunc, void* userData, cudaAsyncCallbackHandle_t* callback) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceUnregisterAsyncNotification "cudaDeviceUnregisterAsyncNotification" (int device, cudaAsyncCallbackHandle_t callback) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetSharedMemConfig "cudaDeviceGetSharedMemConfig" (cudaSharedMemConfig* pConfig) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceSetSharedMemConfig "cudaDeviceSetSharedMemConfig" (cudaSharedMemConfig config) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetLastError "cudaGetLastError" () noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaPeekAtLastError "cudaPeekAtLastError" () noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + const char* _static_cudaGetErrorName "cudaGetErrorName" (cudaError_t error) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + const char* _static_cudaGetErrorString "cudaGetErrorString" (cudaError_t error) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetDeviceCount "cudaGetDeviceCount" (int* count) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetAttribute "cudaDeviceGetAttribute" (int* value, cudaDeviceAttr attr, int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetDefaultMemPool "cudaDeviceGetDefaultMemPool" (cudaMemPool_t* memPool, int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceSetMemPool "cudaDeviceSetMemPool" (int device, cudaMemPool_t memPool) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetMemPool "cudaDeviceGetMemPool" (cudaMemPool_t* memPool, int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetNvSciSyncAttributes "cudaDeviceGetNvSciSyncAttributes" (void* nvSciSyncAttrList, int device, int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetP2PAttribute "cudaDeviceGetP2PAttribute" (int* value, cudaDeviceP2PAttr attr, int srcDevice, int dstDevice) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaChooseDevice "cudaChooseDevice" (int* device, const cudaDeviceProp* prop) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaInitDevice "cudaInitDevice" (int device, unsigned int deviceFlags, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaSetDevice "cudaSetDevice" (int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetDevice "cudaGetDevice" (int* device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaSetDeviceFlags "cudaSetDeviceFlags" (unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetDeviceFlags "cudaGetDeviceFlags" (unsigned int* flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamCreate "cudaStreamCreate" (cudaStream_t* pStream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamCreateWithFlags "cudaStreamCreateWithFlags" (cudaStream_t* pStream, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamCreateWithPriority "cudaStreamCreateWithPriority" (cudaStream_t* pStream, unsigned int flags, int priority) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamGetPriority "cudaStreamGetPriority" (cudaStream_t hStream, int* priority) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamGetFlags "cudaStreamGetFlags" (cudaStream_t hStream, unsigned int* flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamGetId "cudaStreamGetId" (cudaStream_t hStream, unsigned long long* streamId) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamGetDevice "cudaStreamGetDevice" (cudaStream_t hStream, int* device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaCtxResetPersistingL2Cache "cudaCtxResetPersistingL2Cache" () noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamCopyAttributes "cudaStreamCopyAttributes" (cudaStream_t dst, cudaStream_t src) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamGetAttribute "cudaStreamGetAttribute" (cudaStream_t hStream, cudaLaunchAttributeID attr, cudaLaunchAttributeValue* value_out) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamSetAttribute "cudaStreamSetAttribute" (cudaStream_t hStream, cudaLaunchAttributeID attr, const cudaLaunchAttributeValue* value) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamDestroy "cudaStreamDestroy" (cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamWaitEvent "cudaStreamWaitEvent" (cudaStream_t stream, cudaEvent_t event, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamAddCallback "cudaStreamAddCallback" (cudaStream_t stream, cudaStreamCallback_t callback, void* userData, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamSynchronize "cudaStreamSynchronize" (cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamQuery "cudaStreamQuery" (cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamAttachMemAsync "cudaStreamAttachMemAsync" (cudaStream_t stream, void* devPtr, size_t length, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamBeginCapture "cudaStreamBeginCapture" (cudaStream_t stream, cudaStreamCaptureMode mode) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamBeginCaptureToGraph "cudaStreamBeginCaptureToGraph" (cudaStream_t stream, cudaGraph_t graph, const cudaGraphNode_t* dependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, cudaStreamCaptureMode mode) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaThreadExchangeStreamCaptureMode "cudaThreadExchangeStreamCaptureMode" (cudaStreamCaptureMode* mode) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamEndCapture "cudaStreamEndCapture" (cudaStream_t stream, cudaGraph_t* pGraph) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamIsCapturing "cudaStreamIsCapturing" (cudaStream_t stream, cudaStreamCaptureStatus* pCaptureStatus) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamUpdateCaptureDependencies "cudaStreamUpdateCaptureDependencies" (cudaStream_t stream, cudaGraphNode_t* dependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaEventCreate "cudaEventCreate" (cudaEvent_t* event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaEventCreateWithFlags "cudaEventCreateWithFlags" (cudaEvent_t* event, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaEventRecord "cudaEventRecord" (cudaEvent_t event, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaEventRecordWithFlags "cudaEventRecordWithFlags" (cudaEvent_t event, cudaStream_t stream, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaEventQuery "cudaEventQuery" (cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaEventSynchronize "cudaEventSynchronize" (cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaEventDestroy "cudaEventDestroy" (cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaEventElapsedTime "cudaEventElapsedTime" (float* ms, cudaEvent_t start, cudaEvent_t end) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaImportExternalMemory "cudaImportExternalMemory" (cudaExternalMemory_t* extMem_out, const cudaExternalMemoryHandleDesc* memHandleDesc) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaExternalMemoryGetMappedBuffer "cudaExternalMemoryGetMappedBuffer" (void** devPtr, cudaExternalMemory_t extMem, const cudaExternalMemoryBufferDesc* bufferDesc) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaExternalMemoryGetMappedMipmappedArray "cudaExternalMemoryGetMappedMipmappedArray" (cudaMipmappedArray_t* mipmap, cudaExternalMemory_t extMem, const cudaExternalMemoryMipmappedArrayDesc* mipmapDesc) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDestroyExternalMemory "cudaDestroyExternalMemory" (cudaExternalMemory_t extMem) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaImportExternalSemaphore "cudaImportExternalSemaphore" (cudaExternalSemaphore_t* extSem_out, const cudaExternalSemaphoreHandleDesc* semHandleDesc) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDestroyExternalSemaphore "cudaDestroyExternalSemaphore" (cudaExternalSemaphore_t extSem) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFuncSetCacheConfig "cudaFuncSetCacheConfig" (const void* func, cudaFuncCache cacheConfig) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFuncGetAttributes "cudaFuncGetAttributes" (cudaFuncAttributes* attr, const void* func) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFuncSetAttribute "cudaFuncSetAttribute" (const void* func, cudaFuncAttribute attr, int value) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFuncGetName "cudaFuncGetName" (const char** name, const void* func) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFuncGetParamInfo "cudaFuncGetParamInfo" (const void* func, size_t paramIndex, size_t* paramOffset, size_t* paramSize) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLaunchHostFunc "cudaLaunchHostFunc" (cudaStream_t stream, cudaHostFn_t fn, void* userData) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFuncSetSharedMemConfig "cudaFuncSetSharedMemConfig" (const void* func, cudaSharedMemConfig config) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaOccupancyMaxActiveBlocksPerMultiprocessor "cudaOccupancyMaxActiveBlocksPerMultiprocessor" (int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaOccupancyAvailableDynamicSMemPerBlock "cudaOccupancyAvailableDynamicSMemPerBlock" (size_t* dynamicSmemSize, const void* func, int numBlocks, int blockSize) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags "cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags" (int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMallocManaged "cudaMallocManaged" (void** devPtr, size_t size, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMalloc "cudaMalloc" (void** devPtr, size_t size) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMallocHost "cudaMallocHost" (void** ptr, size_t size) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMallocPitch "cudaMallocPitch" (void** devPtr, size_t* pitch, size_t width, size_t height) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMallocArray "cudaMallocArray" (cudaArray_t* array, const cudaChannelFormatDesc* desc, size_t width, size_t height, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFree "cudaFree" (void* devPtr) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFreeHost "cudaFreeHost" (void* ptr) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFreeArray "cudaFreeArray" (cudaArray_t array) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFreeMipmappedArray "cudaFreeMipmappedArray" (cudaMipmappedArray_t mipmappedArray) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaHostAlloc "cudaHostAlloc" (void** pHost, size_t size, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaHostRegister "cudaHostRegister" (void* ptr, size_t size, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaHostUnregister "cudaHostUnregister" (void* ptr) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaHostGetDevicePointer "cudaHostGetDevicePointer" (void** pDevice, void* pHost, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaHostGetFlags "cudaHostGetFlags" (unsigned int* pFlags, void* pHost) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMalloc3D "cudaMalloc3D" (cudaPitchedPtr* pitchedDevPtr, cudaExtent extent) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMalloc3DArray "cudaMalloc3DArray" (cudaArray_t* array, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMallocMipmappedArray "cudaMallocMipmappedArray" (cudaMipmappedArray_t* mipmappedArray, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int numLevels, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetMipmappedArrayLevel "cudaGetMipmappedArrayLevel" (cudaArray_t* levelArray, cudaMipmappedArray_const_t mipmappedArray, unsigned int level) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy3D "cudaMemcpy3D" (const cudaMemcpy3DParms* p) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy3DPeer "cudaMemcpy3DPeer" (const cudaMemcpy3DPeerParms* p) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy3DAsync "cudaMemcpy3DAsync" (const cudaMemcpy3DParms* p, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy3DPeerAsync "cudaMemcpy3DPeerAsync" (const cudaMemcpy3DPeerParms* p, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemGetInfo "cudaMemGetInfo" (size_t* free, size_t* total) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaArrayGetInfo "cudaArrayGetInfo" (cudaChannelFormatDesc* desc, cudaExtent* extent, unsigned int* flags, cudaArray_t array) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaArrayGetPlane "cudaArrayGetPlane" (cudaArray_t* pPlaneArray, cudaArray_t hArray, unsigned int planeIdx) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaArrayGetMemoryRequirements "cudaArrayGetMemoryRequirements" (cudaArrayMemoryRequirements* memoryRequirements, cudaArray_t array, int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMipmappedArrayGetMemoryRequirements "cudaMipmappedArrayGetMemoryRequirements" (cudaArrayMemoryRequirements* memoryRequirements, cudaMipmappedArray_t mipmap, int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaArrayGetSparseProperties "cudaArrayGetSparseProperties" (cudaArraySparseProperties* sparseProperties, cudaArray_t array) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMipmappedArrayGetSparseProperties "cudaMipmappedArrayGetSparseProperties" (cudaArraySparseProperties* sparseProperties, cudaMipmappedArray_t mipmap) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy "cudaMemcpy" (void* dst, const void* src, size_t count, cudaMemcpyKind kind) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpyPeer "cudaMemcpyPeer" (void* dst, int dstDevice, const void* src, int srcDevice, size_t count) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy2D "cudaMemcpy2D" (void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy2DToArray "cudaMemcpy2DToArray" (cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy2DFromArray "cudaMemcpy2DFromArray" (void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy2DArrayToArray "cudaMemcpy2DArrayToArray" (cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t width, size_t height, cudaMemcpyKind kind) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpyAsync "cudaMemcpyAsync" (void* dst, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpyPeerAsync "cudaMemcpyPeerAsync" (void* dst, int dstDevice, const void* src, int srcDevice, size_t count, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpyBatchAsync "cudaMemcpyBatchAsync" (void** dsts, const void** srcs, const size_t* sizes, size_t count, cudaMemcpyAttributes* attrs, size_t* attrsIdxs, size_t numAttrs, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy3DBatchAsync "cudaMemcpy3DBatchAsync" (size_t numOps, cudaMemcpy3DBatchOp* opList, unsigned long long flags, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy2DAsync "cudaMemcpy2DAsync" (void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy2DToArrayAsync "cudaMemcpy2DToArrayAsync" (cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy2DFromArrayAsync "cudaMemcpy2DFromArrayAsync" (void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemset "cudaMemset" (void* devPtr, int value, size_t count) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemset2D "cudaMemset2D" (void* devPtr, size_t pitch, int value, size_t width, size_t height) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemset3D "cudaMemset3D" (cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemsetAsync "cudaMemsetAsync" (void* devPtr, int value, size_t count, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemset2DAsync "cudaMemset2DAsync" (void* devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemset3DAsync "cudaMemset3DAsync" (cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPrefetchAsync "cudaMemPrefetchAsync" (const void* devPtr, size_t count, cudaMemLocation location, unsigned int flags, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemAdvise "cudaMemAdvise" (const void* devPtr, size_t count, cudaMemoryAdvise advice, cudaMemLocation location) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemRangeGetAttribute "cudaMemRangeGetAttribute" (void* data, size_t dataSize, cudaMemRangeAttribute attribute, const void* devPtr, size_t count) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemRangeGetAttributes "cudaMemRangeGetAttributes" (void** data, size_t* dataSizes, cudaMemRangeAttribute* attributes, size_t numAttributes, const void* devPtr, size_t count) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpyToArray "cudaMemcpyToArray" (cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpyFromArray "cudaMemcpyFromArray" (void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpyArrayToArray "cudaMemcpyArrayToArray" (cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t count, cudaMemcpyKind kind) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpyToArrayAsync "cudaMemcpyToArrayAsync" (cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpyFromArrayAsync "cudaMemcpyFromArrayAsync" (void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMallocAsync "cudaMallocAsync" (void** devPtr, size_t size, cudaStream_t hStream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFreeAsync "cudaFreeAsync" (void* devPtr, cudaStream_t hStream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPoolTrimTo "cudaMemPoolTrimTo" (cudaMemPool_t memPool, size_t minBytesToKeep) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPoolSetAttribute "cudaMemPoolSetAttribute" (cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPoolGetAttribute "cudaMemPoolGetAttribute" (cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPoolSetAccess "cudaMemPoolSetAccess" (cudaMemPool_t memPool, const cudaMemAccessDesc* descList, size_t count) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPoolGetAccess "cudaMemPoolGetAccess" (cudaMemAccessFlags* flags, cudaMemPool_t memPool, cudaMemLocation* location) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPoolCreate "cudaMemPoolCreate" (cudaMemPool_t* memPool, const cudaMemPoolProps* poolProps) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPoolDestroy "cudaMemPoolDestroy" (cudaMemPool_t memPool) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMallocFromPoolAsync "cudaMallocFromPoolAsync" (void** ptr, size_t size, cudaMemPool_t memPool, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPoolExportToShareableHandle "cudaMemPoolExportToShareableHandle" (void* shareableHandle, cudaMemPool_t memPool, cudaMemAllocationHandleType handleType, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPoolImportFromShareableHandle "cudaMemPoolImportFromShareableHandle" (cudaMemPool_t* memPool, void* shareableHandle, cudaMemAllocationHandleType handleType, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPoolExportPointer "cudaMemPoolExportPointer" (cudaMemPoolPtrExportData* exportData, void* ptr) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPoolImportPointer "cudaMemPoolImportPointer" (void** ptr, cudaMemPool_t memPool, cudaMemPoolPtrExportData* exportData) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaPointerGetAttributes "cudaPointerGetAttributes" (cudaPointerAttributes* attributes, const void* ptr) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceCanAccessPeer "cudaDeviceCanAccessPeer" (int* canAccessPeer, int device, int peerDevice) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceEnablePeerAccess "cudaDeviceEnablePeerAccess" (int peerDevice, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceDisablePeerAccess "cudaDeviceDisablePeerAccess" (int peerDevice) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphicsUnregisterResource "cudaGraphicsUnregisterResource" (cudaGraphicsResource_t resource) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphicsResourceSetMapFlags "cudaGraphicsResourceSetMapFlags" (cudaGraphicsResource_t resource, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphicsMapResources "cudaGraphicsMapResources" (int count, cudaGraphicsResource_t* resources, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphicsUnmapResources "cudaGraphicsUnmapResources" (int count, cudaGraphicsResource_t* resources, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphicsResourceGetMappedPointer "cudaGraphicsResourceGetMappedPointer" (void** devPtr, size_t* size, cudaGraphicsResource_t resource) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphicsSubResourceGetMappedArray "cudaGraphicsSubResourceGetMappedArray" (cudaArray_t* array, cudaGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphicsResourceGetMappedMipmappedArray "cudaGraphicsResourceGetMappedMipmappedArray" (cudaMipmappedArray_t* mipmappedArray, cudaGraphicsResource_t resource) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetChannelDesc "cudaGetChannelDesc" (cudaChannelFormatDesc* desc, cudaArray_const_t array) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaChannelFormatDesc _static_cudaCreateChannelDesc "cudaCreateChannelDesc" (int x, int y, int z, int w, cudaChannelFormatKind f) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaCreateTextureObject "cudaCreateTextureObject" (cudaTextureObject_t* pTexObject, const cudaResourceDesc* pResDesc, const cudaTextureDesc* pTexDesc, const cudaResourceViewDesc* pResViewDesc) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDestroyTextureObject "cudaDestroyTextureObject" (cudaTextureObject_t texObject) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetTextureObjectResourceDesc "cudaGetTextureObjectResourceDesc" (cudaResourceDesc* pResDesc, cudaTextureObject_t texObject) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetTextureObjectTextureDesc "cudaGetTextureObjectTextureDesc" (cudaTextureDesc* pTexDesc, cudaTextureObject_t texObject) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetTextureObjectResourceViewDesc "cudaGetTextureObjectResourceViewDesc" (cudaResourceViewDesc* pResViewDesc, cudaTextureObject_t texObject) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaCreateSurfaceObject "cudaCreateSurfaceObject" (cudaSurfaceObject_t* pSurfObject, const cudaResourceDesc* pResDesc) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDestroySurfaceObject "cudaDestroySurfaceObject" (cudaSurfaceObject_t surfObject) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetSurfaceObjectResourceDesc "cudaGetSurfaceObjectResourceDesc" (cudaResourceDesc* pResDesc, cudaSurfaceObject_t surfObject) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDriverGetVersion "cudaDriverGetVersion" (int* driverVersion) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaRuntimeGetVersion "cudaRuntimeGetVersion" (int* runtimeVersion) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphCreate "cudaGraphCreate" (cudaGraph_t* pGraph, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddKernelNode "cudaGraphAddKernelNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaKernelNodeParams* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphKernelNodeGetParams "cudaGraphKernelNodeGetParams" (cudaGraphNode_t node, cudaKernelNodeParams* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphKernelNodeSetParams "cudaGraphKernelNodeSetParams" (cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphKernelNodeCopyAttributes "cudaGraphKernelNodeCopyAttributes" (cudaGraphNode_t hDst, cudaGraphNode_t hSrc) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphKernelNodeGetAttribute "cudaGraphKernelNodeGetAttribute" (cudaGraphNode_t hNode, cudaLaunchAttributeID attr, cudaLaunchAttributeValue* value_out) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphKernelNodeSetAttribute "cudaGraphKernelNodeSetAttribute" (cudaGraphNode_t hNode, cudaLaunchAttributeID attr, const cudaLaunchAttributeValue* value) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddMemcpyNode "cudaGraphAddMemcpyNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemcpy3DParms* pCopyParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddMemcpyNode1D "cudaGraphAddMemcpyNode1D" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dst, const void* src, size_t count, cudaMemcpyKind kind) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphMemcpyNodeGetParams "cudaGraphMemcpyNodeGetParams" (cudaGraphNode_t node, cudaMemcpy3DParms* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphMemcpyNodeSetParams "cudaGraphMemcpyNodeSetParams" (cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphMemcpyNodeSetParams1D "cudaGraphMemcpyNodeSetParams1D" (cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddMemsetNode "cudaGraphAddMemsetNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemsetParams* pMemsetParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphMemsetNodeGetParams "cudaGraphMemsetNodeGetParams" (cudaGraphNode_t node, cudaMemsetParams* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphMemsetNodeSetParams "cudaGraphMemsetNodeSetParams" (cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddHostNode "cudaGraphAddHostNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaHostNodeParams* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphHostNodeGetParams "cudaGraphHostNodeGetParams" (cudaGraphNode_t node, cudaHostNodeParams* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphHostNodeSetParams "cudaGraphHostNodeSetParams" (cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddChildGraphNode "cudaGraphAddChildGraphNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaGraph_t childGraph) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphChildGraphNodeGetGraph "cudaGraphChildGraphNodeGetGraph" (cudaGraphNode_t node, cudaGraph_t* pGraph) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddEmptyNode "cudaGraphAddEmptyNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddEventRecordNode "cudaGraphAddEventRecordNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphEventRecordNodeGetEvent "cudaGraphEventRecordNodeGetEvent" (cudaGraphNode_t node, cudaEvent_t* event_out) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphEventRecordNodeSetEvent "cudaGraphEventRecordNodeSetEvent" (cudaGraphNode_t node, cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddEventWaitNode "cudaGraphAddEventWaitNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphEventWaitNodeGetEvent "cudaGraphEventWaitNodeGetEvent" (cudaGraphNode_t node, cudaEvent_t* event_out) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphEventWaitNodeSetEvent "cudaGraphEventWaitNodeSetEvent" (cudaGraphNode_t node, cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddExternalSemaphoresSignalNode "cudaGraphAddExternalSemaphoresSignalNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreSignalNodeParams* nodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExternalSemaphoresSignalNodeGetParams "cudaGraphExternalSemaphoresSignalNodeGetParams" (cudaGraphNode_t hNode, cudaExternalSemaphoreSignalNodeParams* params_out) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExternalSemaphoresSignalNodeSetParams "cudaGraphExternalSemaphoresSignalNodeSetParams" (cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddExternalSemaphoresWaitNode "cudaGraphAddExternalSemaphoresWaitNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreWaitNodeParams* nodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExternalSemaphoresWaitNodeGetParams "cudaGraphExternalSemaphoresWaitNodeGetParams" (cudaGraphNode_t hNode, cudaExternalSemaphoreWaitNodeParams* params_out) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExternalSemaphoresWaitNodeSetParams "cudaGraphExternalSemaphoresWaitNodeSetParams" (cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddMemAllocNode "cudaGraphAddMemAllocNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaMemAllocNodeParams* nodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphMemAllocNodeGetParams "cudaGraphMemAllocNodeGetParams" (cudaGraphNode_t node, cudaMemAllocNodeParams* params_out) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddMemFreeNode "cudaGraphAddMemFreeNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dptr) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphMemFreeNodeGetParams "cudaGraphMemFreeNodeGetParams" (cudaGraphNode_t node, void* dptr_out) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGraphMemTrim "cudaDeviceGraphMemTrim" (int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetGraphMemAttribute "cudaDeviceGetGraphMemAttribute" (int device, cudaGraphMemAttributeType attr, void* value) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceSetGraphMemAttribute "cudaDeviceSetGraphMemAttribute" (int device, cudaGraphMemAttributeType attr, void* value) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphClone "cudaGraphClone" (cudaGraph_t* pGraphClone, cudaGraph_t originalGraph) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphNodeFindInClone "cudaGraphNodeFindInClone" (cudaGraphNode_t* pNode, cudaGraphNode_t originalNode, cudaGraph_t clonedGraph) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphNodeGetType "cudaGraphNodeGetType" (cudaGraphNode_t node, cudaGraphNodeType* pType) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphGetNodes "cudaGraphGetNodes" (cudaGraph_t graph, cudaGraphNode_t* nodes, size_t* numNodes) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphGetRootNodes "cudaGraphGetRootNodes" (cudaGraph_t graph, cudaGraphNode_t* pRootNodes, size_t* pNumRootNodes) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphGetEdges "cudaGraphGetEdges" (cudaGraph_t graph, cudaGraphNode_t* from_, cudaGraphNode_t* to, cudaGraphEdgeData* edgeData, size_t* numEdges) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphNodeGetDependencies "cudaGraphNodeGetDependencies" (cudaGraphNode_t node, cudaGraphNode_t* pDependencies, cudaGraphEdgeData* edgeData, size_t* pNumDependencies) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphNodeGetDependentNodes "cudaGraphNodeGetDependentNodes" (cudaGraphNode_t node, cudaGraphNode_t* pDependentNodes, cudaGraphEdgeData* edgeData, size_t* pNumDependentNodes) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddDependencies "cudaGraphAddDependencies" (cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, const cudaGraphEdgeData* edgeData, size_t numDependencies) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphRemoveDependencies "cudaGraphRemoveDependencies" (cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, const cudaGraphEdgeData* edgeData, size_t numDependencies) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphDestroyNode "cudaGraphDestroyNode" (cudaGraphNode_t node) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphInstantiate "cudaGraphInstantiate" (cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphInstantiateWithFlags "cudaGraphInstantiateWithFlags" (cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphInstantiateWithParams "cudaGraphInstantiateWithParams" (cudaGraphExec_t* pGraphExec, cudaGraph_t graph, cudaGraphInstantiateParams* instantiateParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecGetFlags "cudaGraphExecGetFlags" (cudaGraphExec_t graphExec, unsigned long long* flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecKernelNodeSetParams "cudaGraphExecKernelNodeSetParams" (cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecMemcpyNodeSetParams "cudaGraphExecMemcpyNodeSetParams" (cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecMemcpyNodeSetParams1D "cudaGraphExecMemcpyNodeSetParams1D" (cudaGraphExec_t hGraphExec, cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecMemsetNodeSetParams "cudaGraphExecMemsetNodeSetParams" (cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecHostNodeSetParams "cudaGraphExecHostNodeSetParams" (cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecChildGraphNodeSetParams "cudaGraphExecChildGraphNodeSetParams" (cudaGraphExec_t hGraphExec, cudaGraphNode_t node, cudaGraph_t childGraph) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecEventRecordNodeSetEvent "cudaGraphExecEventRecordNodeSetEvent" (cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecEventWaitNodeSetEvent "cudaGraphExecEventWaitNodeSetEvent" (cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecExternalSemaphoresSignalNodeSetParams "cudaGraphExecExternalSemaphoresSignalNodeSetParams" (cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecExternalSemaphoresWaitNodeSetParams "cudaGraphExecExternalSemaphoresWaitNodeSetParams" (cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphNodeSetEnabled "cudaGraphNodeSetEnabled" (cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int isEnabled) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphNodeGetEnabled "cudaGraphNodeGetEnabled" (cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int* isEnabled) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecUpdate "cudaGraphExecUpdate" (cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphExecUpdateResultInfo* resultInfo) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphUpload "cudaGraphUpload" (cudaGraphExec_t graphExec, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphLaunch "cudaGraphLaunch" (cudaGraphExec_t graphExec, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecDestroy "cudaGraphExecDestroy" (cudaGraphExec_t graphExec) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphDestroy "cudaGraphDestroy" (cudaGraph_t graph) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphDebugDotPrint "cudaGraphDebugDotPrint" (cudaGraph_t graph, const char* path, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaUserObjectCreate "cudaUserObjectCreate" (cudaUserObject_t* object_out, void* ptr, cudaHostFn_t destroy, unsigned int initialRefcount, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaUserObjectRetain "cudaUserObjectRetain" (cudaUserObject_t object, unsigned int count) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaUserObjectRelease "cudaUserObjectRelease" (cudaUserObject_t object, unsigned int count) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphRetainUserObject "cudaGraphRetainUserObject" (cudaGraph_t graph, cudaUserObject_t object, unsigned int count, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphReleaseUserObject "cudaGraphReleaseUserObject" (cudaGraph_t graph, cudaUserObject_t object, unsigned int count) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddNode "cudaGraphAddNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, cudaGraphNodeParams* nodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphNodeSetParams "cudaGraphNodeSetParams" (cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecNodeSetParams "cudaGraphExecNodeSetParams" (cudaGraphExec_t graphExec, cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphConditionalHandleCreate "cudaGraphConditionalHandleCreate" (cudaGraphConditionalHandle* pHandle_out, cudaGraph_t graph, unsigned int defaultLaunchValue, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetDriverEntryPoint "cudaGetDriverEntryPoint" (const char* symbol, void** funcPtr, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetDriverEntryPointByVersion "cudaGetDriverEntryPointByVersion" (const char* symbol, void** funcPtr, unsigned int cudaVersion, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLibraryLoadData "cudaLibraryLoadData" (cudaLibrary_t* library, const void* code, cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLibraryLoadFromFile "cudaLibraryLoadFromFile" (cudaLibrary_t* library, const char* fileName, cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLibraryUnload "cudaLibraryUnload" (cudaLibrary_t library) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLibraryGetKernel "cudaLibraryGetKernel" (cudaKernel_t* pKernel, cudaLibrary_t library, const char* name) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLibraryGetGlobal "cudaLibraryGetGlobal" (void** dptr, size_t* bytes, cudaLibrary_t library, const char* name) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLibraryGetManaged "cudaLibraryGetManaged" (void** dptr, size_t* bytes, cudaLibrary_t library, const char* name) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLibraryGetUnifiedFunction "cudaLibraryGetUnifiedFunction" (void** fptr, cudaLibrary_t library, const char* symbol) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLibraryGetKernelCount "cudaLibraryGetKernelCount" (unsigned int* count, cudaLibrary_t lib) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLibraryEnumerateKernels "cudaLibraryEnumerateKernels" (cudaKernel_t* kernels, unsigned int numKernels, cudaLibrary_t lib) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaKernelSetAttributeForDevice "cudaKernelSetAttributeForDevice" (cudaKernel_t kernel, cudaFuncAttribute attr, int value, int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetExportTable "cudaGetExportTable" (const void** ppExportTable, const cudaUUID_t* pExportTableId) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetKernel "cudaGetKernel" (cudaKernel_t* kernelPtr, const void* entryFuncAddr) noexcept + +cdef extern from 'cuda_profiler_api.h' nogil: + cudaError_t _static_cudaProfilerStart "cudaProfilerStart" () noexcept + +cdef extern from 'cuda_profiler_api.h' nogil: + cudaError_t _static_cudaProfilerStop "cudaProfilerStop" () noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetDeviceProperties "cudaGetDeviceProperties" (cudaDeviceProp* prop, int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetHostAtomicCapabilities "cudaDeviceGetHostAtomicCapabilities" (unsigned int* capabilities, const cudaAtomicOperation* operations, unsigned int count, int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetP2PAtomicCapabilities "cudaDeviceGetP2PAtomicCapabilities" (unsigned int* capabilities, const cudaAtomicOperation* operations, unsigned int count, int srcDevice, int dstDevice) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamGetCaptureInfo "cudaStreamGetCaptureInfo" (cudaStream_t stream, cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out, cudaGraph_t* graph_out, const cudaGraphNode_t** dependencies_out, const cudaGraphEdgeData** edgeData_out, size_t* numDependencies_out) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaSignalExternalSemaphoresAsync "cudaSignalExternalSemaphoresAsync" (const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreSignalParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaWaitExternalSemaphoresAsync "cudaWaitExternalSemaphoresAsync" (const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreWaitParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPrefetchBatchAsync "cudaMemPrefetchBatchAsync" (void** dptrs, size_t* sizes, size_t count, cudaMemLocation* prefetchLocs, size_t* prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemDiscardBatchAsync "cudaMemDiscardBatchAsync" (void** dptrs, size_t* sizes, size_t count, unsigned long long flags, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemDiscardAndPrefetchBatchAsync "cudaMemDiscardAndPrefetchBatchAsync" (void** dptrs, size_t* sizes, size_t count, cudaMemLocation* prefetchLocs, size_t* prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemGetDefaultMemPool "cudaMemGetDefaultMemPool" (cudaMemPool_t* memPool, cudaMemLocation* location, cudaMemAllocationType type) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemGetMemPool "cudaMemGetMemPool" (cudaMemPool_t* memPool, cudaMemLocation* location, cudaMemAllocationType type) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemSetMemPool "cudaMemSetMemPool" (cudaMemLocation* location, cudaMemAllocationType type, cudaMemPool_t memPool) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLogsRegisterCallback "cudaLogsRegisterCallback" (cudaLogsCallback_t callbackFunc, void* userData, cudaLogsCallbackHandle* callback_out) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLogsUnregisterCallback "cudaLogsUnregisterCallback" (cudaLogsCallbackHandle callback) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLogsCurrent "cudaLogsCurrent" (cudaLogIterator* iterator_out, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLogsDumpToFile "cudaLogsDumpToFile" (cudaLogIterator* iterator, const char* pathToFile, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLogsDumpToMemory "cudaLogsDumpToMemory" (cudaLogIterator* iterator, char* buffer, size_t* size, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphNodeGetContainingGraph "cudaGraphNodeGetContainingGraph" (cudaGraphNode_t hNode, cudaGraph_t* phGraph) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphNodeGetLocalId "cudaGraphNodeGetLocalId" (cudaGraphNode_t hNode, unsigned int* nodeId) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphNodeGetToolsId "cudaGraphNodeGetToolsId" (cudaGraphNode_t hNode, unsigned long long* toolsNodeId) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphGetId "cudaGraphGetId" (cudaGraph_t hGraph, unsigned int* graphID) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecGetId "cudaGraphExecGetId" (cudaGraphExec_t hGraphExec, unsigned int* graphID) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphConditionalHandleCreate_v2 "cudaGraphConditionalHandleCreate_v2" (cudaGraphConditionalHandle* pHandle_out, cudaGraph_t graph, cudaExecutionContext_t ctx, unsigned int defaultLaunchValue, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetDevResource "cudaDeviceGetDevResource" (int device, cudaDevResource* resource, cudaDevResourceType type) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDevSmResourceSplitByCount "cudaDevSmResourceSplitByCount" (cudaDevResource* result, unsigned int* nbGroups, const cudaDevResource* input, cudaDevResource* remaining, unsigned int flags, unsigned int minCount) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDevSmResourceSplit "cudaDevSmResourceSplit" (cudaDevResource* result, unsigned int nbGroups, const cudaDevResource* input, cudaDevResource* remainder, unsigned int flags, cudaDevSmResourceGroupParams* groupParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDevResourceGenerateDesc "cudaDevResourceGenerateDesc" (cudaDevResourceDesc_t* phDesc, cudaDevResource* resources, unsigned int nbResources) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGreenCtxCreate "cudaGreenCtxCreate" (cudaExecutionContext_t* phCtx, cudaDevResourceDesc_t desc, int device, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaExecutionCtxDestroy "cudaExecutionCtxDestroy" (cudaExecutionContext_t ctx) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaExecutionCtxGetDevResource "cudaExecutionCtxGetDevResource" (cudaExecutionContext_t ctx, cudaDevResource* resource, cudaDevResourceType type) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaExecutionCtxGetDevice "cudaExecutionCtxGetDevice" (int* device, cudaExecutionContext_t ctx) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaExecutionCtxGetId "cudaExecutionCtxGetId" (cudaExecutionContext_t ctx, unsigned long long* ctxId) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaExecutionCtxStreamCreate "cudaExecutionCtxStreamCreate" (cudaStream_t* phStream, cudaExecutionContext_t ctx, unsigned int flags, int priority) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaExecutionCtxSynchronize "cudaExecutionCtxSynchronize" (cudaExecutionContext_t ctx) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamGetDevResource "cudaStreamGetDevResource" (cudaStream_t hStream, cudaDevResource* resource, cudaDevResourceType type) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaExecutionCtxRecordEvent "cudaExecutionCtxRecordEvent" (cudaExecutionContext_t ctx, cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaExecutionCtxWaitEvent "cudaExecutionCtxWaitEvent" (cudaExecutionContext_t ctx, cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetExecutionCtx "cudaDeviceGetExecutionCtx" (cudaExecutionContext_t* ctx, int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFuncGetParamCount "cudaFuncGetParamCount" (const void* func, size_t* paramCount) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLaunchHostFunc_v2 "cudaLaunchHostFunc_v2" (cudaStream_t stream, cudaHostFn_t fn, void* userData, unsigned int syncMode) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpyWithAttributesAsync "cudaMemcpyWithAttributesAsync" (void* dst, const void* src, size_t size, cudaMemcpyAttributes* attr, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy3DWithAttributesAsync "cudaMemcpy3DWithAttributesAsync" (cudaMemcpy3DBatchOp* op, unsigned long long flags, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphNodeGetParams "cudaGraphNodeGetParams" (cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamBeginRecaptureToGraph "cudaStreamBeginRecaptureToGraph" (cudaStream_t stream, cudaStreamCaptureMode mode, cudaGraph_t graph, cudaGraphRecaptureCallbackData* callbackData) noexcept + + +############################################################################### +# Wrapper functions +############################################################################### + +cdef cudaError_t _cudaDeviceReset() except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceReset() + + +cdef cudaError_t _cudaDeviceSynchronize() except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceSynchronize() + + +cdef cudaError_t _cudaDeviceSetLimit(cudaLimit limit, size_t value) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceSetLimit(limit, value) + + +cdef cudaError_t _cudaDeviceGetLimit(size_t* pValue, cudaLimit limit) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceGetLimit(pValue, limit) + + +cdef cudaError_t _cudaDeviceGetTexture1DLinearMaxWidth(size_t* maxWidthInElements, const cudaChannelFormatDesc* fmtDesc, int device) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceGetTexture1DLinearMaxWidth(maxWidthInElements, fmtDesc, device) + + +cdef cudaError_t _cudaDeviceGetCacheConfig(cudaFuncCache* pCacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceGetCacheConfig(pCacheConfig) + + +cdef cudaError_t _cudaDeviceGetStreamPriorityRange(int* leastPriority, int* greatestPriority) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceGetStreamPriorityRange(leastPriority, greatestPriority) + + +cdef cudaError_t _cudaDeviceSetCacheConfig(cudaFuncCache cacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceSetCacheConfig(cacheConfig) + + +cdef cudaError_t _cudaDeviceGetByPCIBusId(int* device, const char* pciBusId) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceGetByPCIBusId(device, pciBusId) + + +cdef cudaError_t _cudaDeviceGetPCIBusId(char* pciBusId, int len, int device) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceGetPCIBusId(pciBusId, len, device) + + +cdef cudaError_t _cudaIpcGetEventHandle(cudaIpcEventHandle_t* handle, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaIpcGetEventHandle(handle, event) + + +cdef cudaError_t _cudaIpcOpenEventHandle(cudaEvent_t* event, cudaIpcEventHandle_t handle) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaIpcOpenEventHandle(event, handle) + + +cdef cudaError_t _cudaIpcGetMemHandle(cudaIpcMemHandle_t* handle, void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaIpcGetMemHandle(handle, devPtr) + + +cdef cudaError_t _cudaIpcOpenMemHandle(void** devPtr, cudaIpcMemHandle_t handle, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaIpcOpenMemHandle(devPtr, handle, flags) + + +cdef cudaError_t _cudaIpcCloseMemHandle(void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaIpcCloseMemHandle(devPtr) + + +cdef cudaError_t _cudaDeviceFlushGPUDirectRDMAWrites(cudaFlushGPUDirectRDMAWritesTarget target, cudaFlushGPUDirectRDMAWritesScope scope) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceFlushGPUDirectRDMAWrites(target, scope) + + +cdef cudaError_t _cudaDeviceRegisterAsyncNotification(int device, cudaAsyncCallback callbackFunc, void* userData, cudaAsyncCallbackHandle_t* callback) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceRegisterAsyncNotification(device, callbackFunc, userData, callback) + + +cdef cudaError_t _cudaDeviceUnregisterAsyncNotification(int device, cudaAsyncCallbackHandle_t callback) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceUnregisterAsyncNotification(device, callback) + + +cdef cudaError_t _cudaDeviceGetSharedMemConfig(cudaSharedMemConfig* pConfig) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceGetSharedMemConfig(pConfig) + + +cdef cudaError_t _cudaDeviceSetSharedMemConfig(cudaSharedMemConfig config) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceSetSharedMemConfig(config) + + +cdef cudaError_t _cudaGetLastError() except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGetLastError() + + +cdef cudaError_t _cudaPeekAtLastError() except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaPeekAtLastError() + + +cdef const char* _cudaGetErrorName(cudaError_t error) except?NULL nogil: + return _static_cudaGetErrorName(error) + + +cdef const char* _cudaGetErrorString(cudaError_t error) except?NULL nogil: + return _static_cudaGetErrorString(error) + + +cdef cudaError_t _cudaGetDeviceCount(int* count) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGetDeviceCount(count) + + +cdef cudaError_t _cudaDeviceGetAttribute(int* value, cudaDeviceAttr attr, int device) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceGetAttribute(value, attr, device) + + +cdef cudaError_t _cudaDeviceGetDefaultMemPool(cudaMemPool_t* memPool, int device) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceGetDefaultMemPool(memPool, device) + + +cdef cudaError_t _cudaDeviceSetMemPool(int device, cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceSetMemPool(device, memPool) + + +cdef cudaError_t _cudaDeviceGetMemPool(cudaMemPool_t* memPool, int device) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceGetMemPool(memPool, device) + + +cdef cudaError_t _cudaDeviceGetNvSciSyncAttributes(void* nvSciSyncAttrList, int device, int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceGetNvSciSyncAttributes(nvSciSyncAttrList, device, flags) + + +cdef cudaError_t _cudaDeviceGetP2PAttribute(int* value, cudaDeviceP2PAttr attr, int srcDevice, int dstDevice) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceGetP2PAttribute(value, attr, srcDevice, dstDevice) + + +cdef cudaError_t _cudaChooseDevice(int* device, const cudaDeviceProp* prop) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaChooseDevice(device, prop) + + +cdef cudaError_t _cudaInitDevice(int device, unsigned int deviceFlags, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaInitDevice(device, deviceFlags, flags) + + +cdef cudaError_t _cudaSetDevice(int device) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaSetDevice(device) + + +cdef cudaError_t _cudaGetDevice(int* device) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGetDevice(device) + + +cdef cudaError_t _cudaSetDeviceFlags(unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaSetDeviceFlags(flags) + + +cdef cudaError_t _cudaGetDeviceFlags(unsigned int* flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGetDeviceFlags(flags) + + +cdef cudaError_t _cudaStreamCreate(cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamCreate(pStream) + + +cdef cudaError_t _cudaStreamCreateWithFlags(cudaStream_t* pStream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamCreateWithFlags(pStream, flags) + + +cdef cudaError_t _cudaStreamCreateWithPriority(cudaStream_t* pStream, unsigned int flags, int priority) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamCreateWithPriority(pStream, flags, priority) + + +cdef cudaError_t _cudaStreamGetPriority(cudaStream_t hStream, int* priority) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamGetPriority(hStream, priority) + + +cdef cudaError_t _cudaStreamGetFlags(cudaStream_t hStream, unsigned int* flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamGetFlags(hStream, flags) + + +cdef cudaError_t _cudaStreamGetId(cudaStream_t hStream, unsigned long long* streamId) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamGetId(hStream, streamId) + + +cdef cudaError_t _cudaStreamGetDevice(cudaStream_t hStream, int* device) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamGetDevice(hStream, device) + + +cdef cudaError_t _cudaCtxResetPersistingL2Cache() except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaCtxResetPersistingL2Cache() + + +cdef cudaError_t _cudaStreamCopyAttributes(cudaStream_t dst, cudaStream_t src) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamCopyAttributes(dst, src) + + +cdef cudaError_t _cudaStreamGetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, cudaStreamAttrValue* value_out) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamGetAttribute(hStream, attr, value_out) + + +cdef cudaError_t _cudaStreamSetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, const cudaStreamAttrValue* value) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamSetAttribute(hStream, attr, value) + + +cdef cudaError_t _cudaStreamDestroy(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamDestroy(stream) + + +cdef cudaError_t _cudaStreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamWaitEvent(stream, event, flags) + + +cdef cudaError_t _cudaStreamAddCallback(cudaStream_t stream, cudaStreamCallback_t callback, void* userData, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamAddCallback(stream, callback, userData, flags) + + +cdef cudaError_t _cudaStreamSynchronize(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamSynchronize(stream) + + +cdef cudaError_t _cudaStreamQuery(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamQuery(stream) + + +cdef cudaError_t _cudaStreamAttachMemAsync(cudaStream_t stream, void* devPtr, size_t length, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamAttachMemAsync(stream, devPtr, length, flags) + + +cdef cudaError_t _cudaStreamBeginCapture(cudaStream_t stream, cudaStreamCaptureMode mode) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamBeginCapture(stream, mode) + + +cdef cudaError_t _cudaStreamBeginCaptureToGraph(cudaStream_t stream, cudaGraph_t graph, const cudaGraphNode_t* dependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, cudaStreamCaptureMode mode) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamBeginCaptureToGraph(stream, graph, dependencies, dependencyData, numDependencies, mode) + + +cdef cudaError_t _cudaThreadExchangeStreamCaptureMode(cudaStreamCaptureMode* mode) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaThreadExchangeStreamCaptureMode(mode) + + +cdef cudaError_t _cudaStreamEndCapture(cudaStream_t stream, cudaGraph_t* pGraph) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamEndCapture(stream, pGraph) + + +cdef cudaError_t _cudaStreamIsCapturing(cudaStream_t stream, cudaStreamCaptureStatus* pCaptureStatus) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamIsCapturing(stream, pCaptureStatus) + + +cdef cudaError_t _cudaStreamUpdateCaptureDependencies(cudaStream_t stream, cudaGraphNode_t* dependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamUpdateCaptureDependencies(stream, dependencies, dependencyData, numDependencies, flags) + + +cdef cudaError_t _cudaEventCreate(cudaEvent_t* event) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaEventCreate(event) + + +cdef cudaError_t _cudaEventCreateWithFlags(cudaEvent_t* event, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaEventCreateWithFlags(event, flags) + + +cdef cudaError_t _cudaEventRecord(cudaEvent_t event, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaEventRecord(event, stream) + + +cdef cudaError_t _cudaEventRecordWithFlags(cudaEvent_t event, cudaStream_t stream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaEventRecordWithFlags(event, stream, flags) + + +cdef cudaError_t _cudaEventQuery(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaEventQuery(event) + + +cdef cudaError_t _cudaEventSynchronize(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaEventSynchronize(event) + + +cdef cudaError_t _cudaEventDestroy(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaEventDestroy(event) + + +cdef cudaError_t _cudaEventElapsedTime(float* ms, cudaEvent_t start, cudaEvent_t end) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaEventElapsedTime(ms, start, end) + + +cdef cudaError_t _cudaImportExternalMemory(cudaExternalMemory_t* extMem_out, const cudaExternalMemoryHandleDesc* memHandleDesc) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaImportExternalMemory(extMem_out, memHandleDesc) + + +cdef cudaError_t _cudaExternalMemoryGetMappedBuffer(void** devPtr, cudaExternalMemory_t extMem, const cudaExternalMemoryBufferDesc* bufferDesc) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaExternalMemoryGetMappedBuffer(devPtr, extMem, bufferDesc) + + +cdef cudaError_t _cudaExternalMemoryGetMappedMipmappedArray(cudaMipmappedArray_t* mipmap, cudaExternalMemory_t extMem, const cudaExternalMemoryMipmappedArrayDesc* mipmapDesc) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaExternalMemoryGetMappedMipmappedArray(mipmap, extMem, mipmapDesc) + + +cdef cudaError_t _cudaDestroyExternalMemory(cudaExternalMemory_t extMem) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDestroyExternalMemory(extMem) + + +cdef cudaError_t _cudaImportExternalSemaphore(cudaExternalSemaphore_t* extSem_out, const cudaExternalSemaphoreHandleDesc* semHandleDesc) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaImportExternalSemaphore(extSem_out, semHandleDesc) + + +cdef cudaError_t _cudaDestroyExternalSemaphore(cudaExternalSemaphore_t extSem) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDestroyExternalSemaphore(extSem) + + +cdef cudaError_t _cudaFuncSetCacheConfig(const void* func, cudaFuncCache cacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaFuncSetCacheConfig(func, cacheConfig) + + +cdef cudaError_t _cudaFuncGetAttributes(cudaFuncAttributes* attr, const void* func) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaFuncGetAttributes(attr, func) + + +cdef cudaError_t _cudaFuncSetAttribute(const void* func, cudaFuncAttribute attr, int value) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaFuncSetAttribute(func, attr, value) + + +cdef cudaError_t _cudaFuncGetName(const char** name, const void* func) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaFuncGetName(name, func) + + +cdef cudaError_t _cudaFuncGetParamInfo(const void* func, size_t paramIndex, size_t* paramOffset, size_t* paramSize) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaFuncGetParamInfo(func, paramIndex, paramOffset, paramSize) + + +cdef cudaError_t _cudaLaunchHostFunc(cudaStream_t stream, cudaHostFn_t fn, void* userData) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaLaunchHostFunc(stream, fn, userData) + + +cdef cudaError_t _cudaFuncSetSharedMemConfig(const void* func, cudaSharedMemConfig config) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaFuncSetSharedMemConfig(func, config) + + +cdef cudaError_t _cudaOccupancyMaxActiveBlocksPerMultiprocessor(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaOccupancyMaxActiveBlocksPerMultiprocessor(numBlocks, func, blockSize, dynamicSMemSize) + + +cdef cudaError_t _cudaOccupancyAvailableDynamicSMemPerBlock(size_t* dynamicSmemSize, const void* func, int numBlocks, int blockSize) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaOccupancyAvailableDynamicSMemPerBlock(dynamicSmemSize, func, numBlocks, blockSize) + + +cdef cudaError_t _cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(numBlocks, func, blockSize, dynamicSMemSize, flags) + + +cdef cudaError_t _cudaMallocManaged(void** devPtr, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMallocManaged(devPtr, size, flags) + + +cdef cudaError_t _cudaMalloc(void** devPtr, size_t size) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMalloc(devPtr, size) + + +cdef cudaError_t _cudaMallocHost(void** ptr, size_t size) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMallocHost(ptr, size) + + +cdef cudaError_t _cudaMallocPitch(void** devPtr, size_t* pitch, size_t width, size_t height) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMallocPitch(devPtr, pitch, width, height) + + +cdef cudaError_t _cudaMallocArray(cudaArray_t* array, const cudaChannelFormatDesc* desc, size_t width, size_t height, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMallocArray(array, desc, width, height, flags) + + +cdef cudaError_t _cudaFree(void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaFree(devPtr) + + +cdef cudaError_t _cudaFreeHost(void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaFreeHost(ptr) + + +cdef cudaError_t _cudaFreeArray(cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaFreeArray(array) + + +cdef cudaError_t _cudaFreeMipmappedArray(cudaMipmappedArray_t mipmappedArray) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaFreeMipmappedArray(mipmappedArray) + + +cdef cudaError_t _cudaHostAlloc(void** pHost, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaHostAlloc(pHost, size, flags) + + +cdef cudaError_t _cudaHostRegister(void* ptr, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaHostRegister(ptr, size, flags) + + +cdef cudaError_t _cudaHostUnregister(void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaHostUnregister(ptr) + + +cdef cudaError_t _cudaHostGetDevicePointer(void** pDevice, void* pHost, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaHostGetDevicePointer(pDevice, pHost, flags) + + +cdef cudaError_t _cudaHostGetFlags(unsigned int* pFlags, void* pHost) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaHostGetFlags(pFlags, pHost) + + +cdef cudaError_t _cudaMalloc3D(cudaPitchedPtr* pitchedDevPtr, cudaExtent extent) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMalloc3D(pitchedDevPtr, extent) + + +cdef cudaError_t _cudaMalloc3DArray(cudaArray_t* array, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMalloc3DArray(array, desc, extent, flags) + + +cdef cudaError_t _cudaMallocMipmappedArray(cudaMipmappedArray_t* mipmappedArray, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int numLevels, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMallocMipmappedArray(mipmappedArray, desc, extent, numLevels, flags) + + +cdef cudaError_t _cudaGetMipmappedArrayLevel(cudaArray_t* levelArray, cudaMipmappedArray_const_t mipmappedArray, unsigned int level) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGetMipmappedArrayLevel(levelArray, mipmappedArray, level) + + +cdef cudaError_t _cudaMemcpy3D(const cudaMemcpy3DParms* p) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpy3D(p) + + +cdef cudaError_t _cudaMemcpy3DPeer(const cudaMemcpy3DPeerParms* p) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpy3DPeer(p) + + +cdef cudaError_t _cudaMemcpy3DAsync(const cudaMemcpy3DParms* p, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpy3DAsync(p, stream) + + +cdef cudaError_t _cudaMemcpy3DPeerAsync(const cudaMemcpy3DPeerParms* p, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpy3DPeerAsync(p, stream) + + +cdef cudaError_t _cudaMemGetInfo(size_t* free, size_t* total) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemGetInfo(free, total) + + +cdef cudaError_t _cudaArrayGetInfo(cudaChannelFormatDesc* desc, cudaExtent* extent, unsigned int* flags, cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaArrayGetInfo(desc, extent, flags, array) + + +cdef cudaError_t _cudaArrayGetPlane(cudaArray_t* pPlaneArray, cudaArray_t hArray, unsigned int planeIdx) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaArrayGetPlane(pPlaneArray, hArray, planeIdx) + + +cdef cudaError_t _cudaArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaArray_t array, int device) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaArrayGetMemoryRequirements(memoryRequirements, array, device) + + +cdef cudaError_t _cudaMipmappedArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaMipmappedArray_t mipmap, int device) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMipmappedArrayGetMemoryRequirements(memoryRequirements, mipmap, device) + + +cdef cudaError_t _cudaArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaArrayGetSparseProperties(sparseProperties, array) + + +cdef cudaError_t _cudaMipmappedArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaMipmappedArray_t mipmap) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMipmappedArrayGetSparseProperties(sparseProperties, mipmap) + + +cdef cudaError_t _cudaMemcpy(void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpy(dst, src, count, kind) + + +cdef cudaError_t _cudaMemcpyPeer(void* dst, int dstDevice, const void* src, int srcDevice, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpyPeer(dst, dstDevice, src, srcDevice, count) + + +cdef cudaError_t _cudaMemcpy2D(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpy2D(dst, dpitch, src, spitch, width, height, kind) + + +cdef cudaError_t _cudaMemcpy2DToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpy2DToArray(dst, wOffset, hOffset, src, spitch, width, height, kind) + + +cdef cudaError_t _cudaMemcpy2DFromArray(void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpy2DFromArray(dst, dpitch, src, wOffset, hOffset, width, height, kind) + + +cdef cudaError_t _cudaMemcpy2DArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpy2DArrayToArray(dst, wOffsetDst, hOffsetDst, src, wOffsetSrc, hOffsetSrc, width, height, kind) + + +cdef cudaError_t _cudaMemcpyAsync(void* dst, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpyAsync(dst, src, count, kind, stream) + + +cdef cudaError_t _cudaMemcpyPeerAsync(void* dst, int dstDevice, const void* src, int srcDevice, size_t count, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpyPeerAsync(dst, dstDevice, src, srcDevice, count, stream) + + +cdef cudaError_t _cudaMemcpyBatchAsync(const void** dsts, const void** srcs, const size_t* sizes, size_t count, cudaMemcpyAttributes* attrs, size_t* attrsIdxs, size_t numAttrs, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpyBatchAsync(dsts, srcs, sizes, count, attrs, attrsIdxs, numAttrs, stream) + + +cdef cudaError_t _cudaMemcpy3DBatchAsync(size_t numOps, cudaMemcpy3DBatchOp* opList, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpy3DBatchAsync(numOps, opList, flags, stream) + + +cdef cudaError_t _cudaMemcpy2DAsync(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpy2DAsync(dst, dpitch, src, spitch, width, height, kind, stream) + + +cdef cudaError_t _cudaMemcpy2DToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpy2DToArrayAsync(dst, wOffset, hOffset, src, spitch, width, height, kind, stream) + + +cdef cudaError_t _cudaMemcpy2DFromArrayAsync(void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpy2DFromArrayAsync(dst, dpitch, src, wOffset, hOffset, width, height, kind, stream) + + +cdef cudaError_t _cudaMemset(void* devPtr, int value, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemset(devPtr, value, count) + + +cdef cudaError_t _cudaMemset2D(void* devPtr, size_t pitch, int value, size_t width, size_t height) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemset2D(devPtr, pitch, value, width, height) + + +cdef cudaError_t _cudaMemset3D(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemset3D(pitchedDevPtr, value, extent) + + +cdef cudaError_t _cudaMemsetAsync(void* devPtr, int value, size_t count, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemsetAsync(devPtr, value, count, stream) + + +cdef cudaError_t _cudaMemset2DAsync(void* devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemset2DAsync(devPtr, pitch, value, width, height, stream) + + +cdef cudaError_t _cudaMemset3DAsync(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemset3DAsync(pitchedDevPtr, value, extent, stream) + + +cdef cudaError_t _cudaMemPrefetchAsync(const void* devPtr, size_t count, cudaMemLocation location, unsigned int flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemPrefetchAsync(devPtr, count, location, flags, stream) + + +cdef cudaError_t _cudaMemAdvise(const void* devPtr, size_t count, cudaMemoryAdvise advice, cudaMemLocation location) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemAdvise(devPtr, count, advice, location) + + +cdef cudaError_t _cudaMemRangeGetAttribute(void* data, size_t dataSize, cudaMemRangeAttribute attribute, const void* devPtr, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemRangeGetAttribute(data, dataSize, attribute, devPtr, count) + + +cdef cudaError_t _cudaMemRangeGetAttributes(void** data, size_t* dataSizes, cudaMemRangeAttribute* attributes, size_t numAttributes, const void* devPtr, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemRangeGetAttributes(data, dataSizes, attributes, numAttributes, devPtr, count) + + +cdef cudaError_t _cudaMemcpyToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpyToArray(dst, wOffset, hOffset, src, count, kind) + + +cdef cudaError_t _cudaMemcpyFromArray(void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpyFromArray(dst, src, wOffset, hOffset, count, kind) + + +cdef cudaError_t _cudaMemcpyArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpyArrayToArray(dst, wOffsetDst, hOffsetDst, src, wOffsetSrc, hOffsetSrc, count, kind) + + +cdef cudaError_t _cudaMemcpyToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpyToArrayAsync(dst, wOffset, hOffset, src, count, kind, stream) + + +cdef cudaError_t _cudaMemcpyFromArrayAsync(void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpyFromArrayAsync(dst, src, wOffset, hOffset, count, kind, stream) + + +cdef cudaError_t _cudaMallocAsync(void** devPtr, size_t size, cudaStream_t hStream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMallocAsync(devPtr, size, hStream) + + +cdef cudaError_t _cudaFreeAsync(void* devPtr, cudaStream_t hStream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaFreeAsync(devPtr, hStream) + + +cdef cudaError_t _cudaMemPoolTrimTo(cudaMemPool_t memPool, size_t minBytesToKeep) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemPoolTrimTo(memPool, minBytesToKeep) + + +cdef cudaError_t _cudaMemPoolSetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemPoolSetAttribute(memPool, attr, value) + + +cdef cudaError_t _cudaMemPoolGetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemPoolGetAttribute(memPool, attr, value) + + +cdef cudaError_t _cudaMemPoolSetAccess(cudaMemPool_t memPool, const cudaMemAccessDesc* descList, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemPoolSetAccess(memPool, descList, count) + + +cdef cudaError_t _cudaMemPoolGetAccess(cudaMemAccessFlags* flags, cudaMemPool_t memPool, cudaMemLocation* location) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemPoolGetAccess(flags, memPool, location) + + +cdef cudaError_t _cudaMemPoolCreate(cudaMemPool_t* memPool, const cudaMemPoolProps* poolProps) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemPoolCreate(memPool, poolProps) + + +cdef cudaError_t _cudaMemPoolDestroy(cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemPoolDestroy(memPool) + + +cdef cudaError_t _cudaMallocFromPoolAsync(void** ptr, size_t size, cudaMemPool_t memPool, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMallocFromPoolAsync(ptr, size, memPool, stream) + + +cdef cudaError_t _cudaMemPoolExportToShareableHandle(void* shareableHandle, cudaMemPool_t memPool, cudaMemAllocationHandleType handleType, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemPoolExportToShareableHandle(shareableHandle, memPool, handleType, flags) + + +cdef cudaError_t _cudaMemPoolImportFromShareableHandle(cudaMemPool_t* memPool, void* shareableHandle, cudaMemAllocationHandleType handleType, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemPoolImportFromShareableHandle(memPool, shareableHandle, handleType, flags) + + +cdef cudaError_t _cudaMemPoolExportPointer(cudaMemPoolPtrExportData* exportData, void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemPoolExportPointer(exportData, ptr) + + +cdef cudaError_t _cudaMemPoolImportPointer(void** ptr, cudaMemPool_t memPool, cudaMemPoolPtrExportData* exportData) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemPoolImportPointer(ptr, memPool, exportData) + + +cdef cudaError_t _cudaPointerGetAttributes(cudaPointerAttributes* attributes, const void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaPointerGetAttributes(attributes, ptr) + + +cdef cudaError_t _cudaDeviceCanAccessPeer(int* canAccessPeer, int device, int peerDevice) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceCanAccessPeer(canAccessPeer, device, peerDevice) + + +cdef cudaError_t _cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceEnablePeerAccess(peerDevice, flags) + + +cdef cudaError_t _cudaDeviceDisablePeerAccess(int peerDevice) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceDisablePeerAccess(peerDevice) + + +cdef cudaError_t _cudaGraphicsUnregisterResource(cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphicsUnregisterResource(resource) + + +cdef cudaError_t _cudaGraphicsResourceSetMapFlags(cudaGraphicsResource_t resource, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphicsResourceSetMapFlags(resource, flags) + + +cdef cudaError_t _cudaGraphicsMapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphicsMapResources(count, resources, stream) + + +cdef cudaError_t _cudaGraphicsUnmapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphicsUnmapResources(count, resources, stream) + + +cdef cudaError_t _cudaGraphicsResourceGetMappedPointer(void** devPtr, size_t* size, cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphicsResourceGetMappedPointer(devPtr, size, resource) + + +cdef cudaError_t _cudaGraphicsSubResourceGetMappedArray(cudaArray_t* array, cudaGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphicsSubResourceGetMappedArray(array, resource, arrayIndex, mipLevel) + + +cdef cudaError_t _cudaGraphicsResourceGetMappedMipmappedArray(cudaMipmappedArray_t* mipmappedArray, cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphicsResourceGetMappedMipmappedArray(mipmappedArray, resource) + + +cdef cudaError_t _cudaGetChannelDesc(cudaChannelFormatDesc* desc, cudaArray_const_t array) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGetChannelDesc(desc, array) + + +cdef cudaChannelFormatDesc _cudaCreateChannelDesc(int x, int y, int z, int w, cudaChannelFormatKind f) except* nogil: + return _static_cudaCreateChannelDesc(x, y, z, w, f) + + +cdef cudaError_t _cudaCreateTextureObject(cudaTextureObject_t* pTexObject, const cudaResourceDesc* pResDesc, const cudaTextureDesc* pTexDesc, const cudaResourceViewDesc* pResViewDesc) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaCreateTextureObject(pTexObject, pResDesc, pTexDesc, pResViewDesc) + + +cdef cudaError_t _cudaDestroyTextureObject(cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDestroyTextureObject(texObject) + + +cdef cudaError_t _cudaGetTextureObjectResourceDesc(cudaResourceDesc* pResDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGetTextureObjectResourceDesc(pResDesc, texObject) + + +cdef cudaError_t _cudaGetTextureObjectTextureDesc(cudaTextureDesc* pTexDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGetTextureObjectTextureDesc(pTexDesc, texObject) + + +cdef cudaError_t _cudaGetTextureObjectResourceViewDesc(cudaResourceViewDesc* pResViewDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGetTextureObjectResourceViewDesc(pResViewDesc, texObject) + + +cdef cudaError_t _cudaCreateSurfaceObject(cudaSurfaceObject_t* pSurfObject, const cudaResourceDesc* pResDesc) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaCreateSurfaceObject(pSurfObject, pResDesc) + + +cdef cudaError_t _cudaDestroySurfaceObject(cudaSurfaceObject_t surfObject) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDestroySurfaceObject(surfObject) + + +cdef cudaError_t _cudaGetSurfaceObjectResourceDesc(cudaResourceDesc* pResDesc, cudaSurfaceObject_t surfObject) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGetSurfaceObjectResourceDesc(pResDesc, surfObject) + + +cdef cudaError_t _cudaDriverGetVersion(int* driverVersion) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDriverGetVersion(driverVersion) + + +cdef cudaError_t _cudaRuntimeGetVersion(int* runtimeVersion) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaRuntimeGetVersion(runtimeVersion) + + +cdef cudaError_t _cudaGraphCreate(cudaGraph_t* pGraph, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphCreate(pGraph, flags) + + +cdef cudaError_t _cudaGraphAddKernelNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphAddKernelNode(pGraphNode, graph, pDependencies, numDependencies, pNodeParams) + + +cdef cudaError_t _cudaGraphKernelNodeGetParams(cudaGraphNode_t node, cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphKernelNodeGetParams(node, pNodeParams) + + +cdef cudaError_t _cudaGraphKernelNodeSetParams(cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphKernelNodeSetParams(node, pNodeParams) + + +cdef cudaError_t _cudaGraphKernelNodeCopyAttributes(cudaGraphNode_t hDst, cudaGraphNode_t hSrc) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphKernelNodeCopyAttributes(hDst, hSrc) + + +cdef cudaError_t _cudaGraphKernelNodeGetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, cudaKernelNodeAttrValue* value_out) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphKernelNodeGetAttribute(hNode, attr, value_out) + + +cdef cudaError_t _cudaGraphKernelNodeSetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, const cudaKernelNodeAttrValue* value) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphKernelNodeSetAttribute(hNode, attr, value) + + +cdef cudaError_t _cudaGraphAddMemcpyNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemcpy3DParms* pCopyParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphAddMemcpyNode(pGraphNode, graph, pDependencies, numDependencies, pCopyParams) + + +cdef cudaError_t _cudaGraphAddMemcpyNode1D(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphAddMemcpyNode1D(pGraphNode, graph, pDependencies, numDependencies, dst, src, count, kind) + + +cdef cudaError_t _cudaGraphMemcpyNodeGetParams(cudaGraphNode_t node, cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphMemcpyNodeGetParams(node, pNodeParams) + + +cdef cudaError_t _cudaGraphMemcpyNodeSetParams(cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphMemcpyNodeSetParams(node, pNodeParams) + + +cdef cudaError_t _cudaGraphMemcpyNodeSetParams1D(cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphMemcpyNodeSetParams1D(node, dst, src, count, kind) + + +cdef cudaError_t _cudaGraphAddMemsetNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemsetParams* pMemsetParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphAddMemsetNode(pGraphNode, graph, pDependencies, numDependencies, pMemsetParams) + + +cdef cudaError_t _cudaGraphMemsetNodeGetParams(cudaGraphNode_t node, cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphMemsetNodeGetParams(node, pNodeParams) + + +cdef cudaError_t _cudaGraphMemsetNodeSetParams(cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphMemsetNodeSetParams(node, pNodeParams) + + +cdef cudaError_t _cudaGraphAddHostNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphAddHostNode(pGraphNode, graph, pDependencies, numDependencies, pNodeParams) + + +cdef cudaError_t _cudaGraphHostNodeGetParams(cudaGraphNode_t node, cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphHostNodeGetParams(node, pNodeParams) + + +cdef cudaError_t _cudaGraphHostNodeSetParams(cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphHostNodeSetParams(node, pNodeParams) + + +cdef cudaError_t _cudaGraphAddChildGraphNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaGraph_t childGraph) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphAddChildGraphNode(pGraphNode, graph, pDependencies, numDependencies, childGraph) + + +cdef cudaError_t _cudaGraphChildGraphNodeGetGraph(cudaGraphNode_t node, cudaGraph_t* pGraph) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphChildGraphNodeGetGraph(node, pGraph) + + +cdef cudaError_t _cudaGraphAddEmptyNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphAddEmptyNode(pGraphNode, graph, pDependencies, numDependencies) + + +cdef cudaError_t _cudaGraphAddEventRecordNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphAddEventRecordNode(pGraphNode, graph, pDependencies, numDependencies, event) + + +cdef cudaError_t _cudaGraphEventRecordNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphEventRecordNodeGetEvent(node, event_out) + + +cdef cudaError_t _cudaGraphEventRecordNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphEventRecordNodeSetEvent(node, event) + + +cdef cudaError_t _cudaGraphAddEventWaitNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphAddEventWaitNode(pGraphNode, graph, pDependencies, numDependencies, event) + + +cdef cudaError_t _cudaGraphEventWaitNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphEventWaitNodeGetEvent(node, event_out) + + +cdef cudaError_t _cudaGraphEventWaitNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphEventWaitNodeSetEvent(node, event) + + +cdef cudaError_t _cudaGraphAddExternalSemaphoresSignalNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphAddExternalSemaphoresSignalNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams) + + +cdef cudaError_t _cudaGraphExternalSemaphoresSignalNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreSignalNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphExternalSemaphoresSignalNodeGetParams(hNode, params_out) + + +cdef cudaError_t _cudaGraphExternalSemaphoresSignalNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphExternalSemaphoresSignalNodeSetParams(hNode, nodeParams) + + +cdef cudaError_t _cudaGraphAddExternalSemaphoresWaitNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphAddExternalSemaphoresWaitNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams) + + +cdef cudaError_t _cudaGraphExternalSemaphoresWaitNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreWaitNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphExternalSemaphoresWaitNodeGetParams(hNode, params_out) + + +cdef cudaError_t _cudaGraphExternalSemaphoresWaitNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphExternalSemaphoresWaitNodeSetParams(hNode, nodeParams) + + +cdef cudaError_t _cudaGraphAddMemAllocNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaMemAllocNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphAddMemAllocNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams) + + +cdef cudaError_t _cudaGraphMemAllocNodeGetParams(cudaGraphNode_t node, cudaMemAllocNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphMemAllocNodeGetParams(node, params_out) + + +cdef cudaError_t _cudaGraphAddMemFreeNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dptr) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphAddMemFreeNode(pGraphNode, graph, pDependencies, numDependencies, dptr) + + +cdef cudaError_t _cudaGraphMemFreeNodeGetParams(cudaGraphNode_t node, void* dptr_out) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphMemFreeNodeGetParams(node, dptr_out) + + +cdef cudaError_t _cudaDeviceGraphMemTrim(int device) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceGraphMemTrim(device) + + +cdef cudaError_t _cudaDeviceGetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceGetGraphMemAttribute(device, attr, value) + + +cdef cudaError_t _cudaDeviceSetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceSetGraphMemAttribute(device, attr, value) + + +cdef cudaError_t _cudaGraphClone(cudaGraph_t* pGraphClone, cudaGraph_t originalGraph) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphClone(pGraphClone, originalGraph) + + +cdef cudaError_t _cudaGraphNodeFindInClone(cudaGraphNode_t* pNode, cudaGraphNode_t originalNode, cudaGraph_t clonedGraph) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphNodeFindInClone(pNode, originalNode, clonedGraph) + + +cdef cudaError_t _cudaGraphNodeGetType(cudaGraphNode_t node, cudaGraphNodeType* pType) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphNodeGetType(node, pType) + + +cdef cudaError_t _cudaGraphGetNodes(cudaGraph_t graph, cudaGraphNode_t* nodes, size_t* numNodes) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphGetNodes(graph, nodes, numNodes) + + +cdef cudaError_t _cudaGraphGetRootNodes(cudaGraph_t graph, cudaGraphNode_t* pRootNodes, size_t* pNumRootNodes) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphGetRootNodes(graph, pRootNodes, pNumRootNodes) + + +cdef cudaError_t _cudaGraphGetEdges(cudaGraph_t graph, cudaGraphNode_t* from_, cudaGraphNode_t* to, cudaGraphEdgeData* edgeData, size_t* numEdges) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphGetEdges(graph, from_, to, edgeData, numEdges) + + +cdef cudaError_t _cudaGraphNodeGetDependencies(cudaGraphNode_t node, cudaGraphNode_t* pDependencies, cudaGraphEdgeData* edgeData, size_t* pNumDependencies) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphNodeGetDependencies(node, pDependencies, edgeData, pNumDependencies) + + +cdef cudaError_t _cudaGraphNodeGetDependentNodes(cudaGraphNode_t node, cudaGraphNode_t* pDependentNodes, cudaGraphEdgeData* edgeData, size_t* pNumDependentNodes) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphNodeGetDependentNodes(node, pDependentNodes, edgeData, pNumDependentNodes) + + +cdef cudaError_t _cudaGraphAddDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, const cudaGraphEdgeData* edgeData, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphAddDependencies(graph, from_, to, edgeData, numDependencies) + + +cdef cudaError_t _cudaGraphRemoveDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, const cudaGraphEdgeData* edgeData, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphRemoveDependencies(graph, from_, to, edgeData, numDependencies) + + +cdef cudaError_t _cudaGraphDestroyNode(cudaGraphNode_t node) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphDestroyNode(node) + + +cdef cudaError_t _cudaGraphInstantiate(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphInstantiate(pGraphExec, graph, flags) + + +cdef cudaError_t _cudaGraphInstantiateWithFlags(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphInstantiateWithFlags(pGraphExec, graph, flags) + + +cdef cudaError_t _cudaGraphInstantiateWithParams(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, cudaGraphInstantiateParams* instantiateParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphInstantiateWithParams(pGraphExec, graph, instantiateParams) + + +cdef cudaError_t _cudaGraphExecGetFlags(cudaGraphExec_t graphExec, unsigned long long* flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphExecGetFlags(graphExec, flags) + + +cdef cudaError_t _cudaGraphExecKernelNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphExecKernelNodeSetParams(hGraphExec, node, pNodeParams) + + +cdef cudaError_t _cudaGraphExecMemcpyNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphExecMemcpyNodeSetParams(hGraphExec, node, pNodeParams) + + +cdef cudaError_t _cudaGraphExecMemcpyNodeSetParams1D(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphExecMemcpyNodeSetParams1D(hGraphExec, node, dst, src, count, kind) + + +cdef cudaError_t _cudaGraphExecMemsetNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphExecMemsetNodeSetParams(hGraphExec, node, pNodeParams) + + +cdef cudaError_t _cudaGraphExecHostNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphExecHostNodeSetParams(hGraphExec, node, pNodeParams) + + +cdef cudaError_t _cudaGraphExecChildGraphNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, cudaGraph_t childGraph) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphExecChildGraphNodeSetParams(hGraphExec, node, childGraph) + + +cdef cudaError_t _cudaGraphExecEventRecordNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphExecEventRecordNodeSetEvent(hGraphExec, hNode, event) + + +cdef cudaError_t _cudaGraphExecEventWaitNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphExecEventWaitNodeSetEvent(hGraphExec, hNode, event) + + +cdef cudaError_t _cudaGraphExecExternalSemaphoresSignalNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphExecExternalSemaphoresSignalNodeSetParams(hGraphExec, hNode, nodeParams) + + +cdef cudaError_t _cudaGraphExecExternalSemaphoresWaitNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphExecExternalSemaphoresWaitNodeSetParams(hGraphExec, hNode, nodeParams) + + +cdef cudaError_t _cudaGraphNodeSetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int isEnabled) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphNodeSetEnabled(hGraphExec, hNode, isEnabled) + + +cdef cudaError_t _cudaGraphNodeGetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int* isEnabled) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphNodeGetEnabled(hGraphExec, hNode, isEnabled) + + +cdef cudaError_t _cudaGraphExecUpdate(cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphExecUpdateResultInfo* resultInfo) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphExecUpdate(hGraphExec, hGraph, resultInfo) + + +cdef cudaError_t _cudaGraphUpload(cudaGraphExec_t graphExec, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphUpload(graphExec, stream) + + +cdef cudaError_t _cudaGraphLaunch(cudaGraphExec_t graphExec, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphLaunch(graphExec, stream) + + +cdef cudaError_t _cudaGraphExecDestroy(cudaGraphExec_t graphExec) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphExecDestroy(graphExec) + + +cdef cudaError_t _cudaGraphDestroy(cudaGraph_t graph) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphDestroy(graph) + + +cdef cudaError_t _cudaGraphDebugDotPrint(cudaGraph_t graph, const char* path, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphDebugDotPrint(graph, path, flags) + + +cdef cudaError_t _cudaUserObjectCreate(cudaUserObject_t* object_out, void* ptr, cudaHostFn_t destroy, unsigned int initialRefcount, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaUserObjectCreate(object_out, ptr, destroy, initialRefcount, flags) + + +cdef cudaError_t _cudaUserObjectRetain(cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaUserObjectRetain(object, count) + + +cdef cudaError_t _cudaUserObjectRelease(cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaUserObjectRelease(object, count) + + +cdef cudaError_t _cudaGraphRetainUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphRetainUserObject(graph, object, count, flags) + + +cdef cudaError_t _cudaGraphReleaseUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphReleaseUserObject(graph, object, count) + + +cdef cudaError_t _cudaGraphAddNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphAddNode(pGraphNode, graph, pDependencies, dependencyData, numDependencies, nodeParams) + + +cdef cudaError_t _cudaGraphNodeSetParams(cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphNodeSetParams(node, nodeParams) + + +cdef cudaError_t _cudaGraphExecNodeSetParams(cudaGraphExec_t graphExec, cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphExecNodeSetParams(graphExec, node, nodeParams) + + +cdef cudaError_t _cudaGraphConditionalHandleCreate(cudaGraphConditionalHandle* pHandle_out, cudaGraph_t graph, unsigned int defaultLaunchValue, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphConditionalHandleCreate(pHandle_out, graph, defaultLaunchValue, flags) + + +cdef cudaError_t _cudaGetDriverEntryPoint(const char* symbol, void** funcPtr, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGetDriverEntryPoint(symbol, funcPtr, flags, driverStatus) + + +cdef cudaError_t _cudaGetDriverEntryPointByVersion(const char* symbol, void** funcPtr, unsigned int cudaVersion, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGetDriverEntryPointByVersion(symbol, funcPtr, cudaVersion, flags, driverStatus) + + +cdef cudaError_t _cudaLibraryLoadData(cudaLibrary_t* library, const void* code, cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaLibraryLoadData(library, code, jitOptions, jitOptionsValues, numJitOptions, libraryOptions, libraryOptionValues, numLibraryOptions) + + +cdef cudaError_t _cudaLibraryLoadFromFile(cudaLibrary_t* library, const char* fileName, cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaLibraryLoadFromFile(library, fileName, jitOptions, jitOptionsValues, numJitOptions, libraryOptions, libraryOptionValues, numLibraryOptions) + + +cdef cudaError_t _cudaLibraryUnload(cudaLibrary_t library) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaLibraryUnload(library) + + +cdef cudaError_t _cudaLibraryGetKernel(cudaKernel_t* pKernel, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaLibraryGetKernel(pKernel, library, name) + + +cdef cudaError_t _cudaLibraryGetGlobal(void** dptr, size_t* bytes, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaLibraryGetGlobal(dptr, bytes, library, name) + + +cdef cudaError_t _cudaLibraryGetManaged(void** dptr, size_t* bytes, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaLibraryGetManaged(dptr, bytes, library, name) + + +cdef cudaError_t _cudaLibraryGetUnifiedFunction(void** fptr, cudaLibrary_t library, const char* symbol) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaLibraryGetUnifiedFunction(fptr, library, symbol) + + +cdef cudaError_t _cudaLibraryGetKernelCount(unsigned int* count, cudaLibrary_t lib) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaLibraryGetKernelCount(count, lib) + + +cdef cudaError_t _cudaLibraryEnumerateKernels(cudaKernel_t* kernels, unsigned int numKernels, cudaLibrary_t lib) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaLibraryEnumerateKernels(kernels, numKernels, lib) + + +cdef cudaError_t _cudaKernelSetAttributeForDevice(cudaKernel_t kernel, cudaFuncAttribute attr, int value, int device) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaKernelSetAttributeForDevice(kernel, attr, value, device) + + +cdef cudaError_t _cudaGetExportTable(const void** ppExportTable, const cudaUUID_t* pExportTableId) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGetExportTable(ppExportTable, pExportTableId) + + +cdef cudaError_t _cudaGetKernel(cudaKernel_t* kernelPtr, const void* entryFuncAddr) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGetKernel(kernelPtr, entryFuncAddr) + + +cdef cudaError_t _cudaProfilerStart() except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaProfilerStart() + + +cdef cudaError_t _cudaProfilerStop() except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaProfilerStop() + + +cdef cudaError_t _cudaGetDeviceProperties(cudaDeviceProp* prop, int device) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGetDeviceProperties(prop, device) + + +cdef cudaError_t _cudaDeviceGetHostAtomicCapabilities(unsigned int* capabilities, const cudaAtomicOperation* operations, unsigned int count, int device) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceGetHostAtomicCapabilities(capabilities, operations, count, device) + + +cdef cudaError_t _cudaDeviceGetP2PAtomicCapabilities(unsigned int* capabilities, const cudaAtomicOperation* operations, unsigned int count, int srcDevice, int dstDevice) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceGetP2PAtomicCapabilities(capabilities, operations, count, srcDevice, dstDevice) + + +cdef cudaError_t _cudaStreamGetCaptureInfo(cudaStream_t stream, cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out, cudaGraph_t* graph_out, const cudaGraphNode_t** dependencies_out, const cudaGraphEdgeData** edgeData_out, size_t* numDependencies_out) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamGetCaptureInfo(stream, captureStatus_out, id_out, graph_out, dependencies_out, edgeData_out, numDependencies_out) + + +cdef cudaError_t _cudaSignalExternalSemaphoresAsync(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreSignalParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaSignalExternalSemaphoresAsync(extSemArray, paramsArray, numExtSems, stream) + + +cdef cudaError_t _cudaWaitExternalSemaphoresAsync(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreWaitParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaWaitExternalSemaphoresAsync(extSemArray, paramsArray, numExtSems, stream) + + +cdef cudaError_t _cudaMemPrefetchBatchAsync(void** dptrs, size_t* sizes, size_t count, cudaMemLocation* prefetchLocs, size_t* prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemPrefetchBatchAsync(dptrs, sizes, count, prefetchLocs, prefetchLocIdxs, numPrefetchLocs, flags, stream) + + +cdef cudaError_t _cudaMemDiscardBatchAsync(void** dptrs, size_t* sizes, size_t count, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemDiscardBatchAsync(dptrs, sizes, count, flags, stream) + + +cdef cudaError_t _cudaMemDiscardAndPrefetchBatchAsync(void** dptrs, size_t* sizes, size_t count, cudaMemLocation* prefetchLocs, size_t* prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemDiscardAndPrefetchBatchAsync(dptrs, sizes, count, prefetchLocs, prefetchLocIdxs, numPrefetchLocs, flags, stream) + + +cdef cudaError_t _cudaMemGetDefaultMemPool(cudaMemPool_t* memPool, cudaMemLocation* location, cudaMemAllocationType type) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemGetDefaultMemPool(memPool, location, type) + + +cdef cudaError_t _cudaMemGetMemPool(cudaMemPool_t* memPool, cudaMemLocation* location, cudaMemAllocationType type) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemGetMemPool(memPool, location, type) + + +cdef cudaError_t _cudaMemSetMemPool(cudaMemLocation* location, cudaMemAllocationType type, cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemSetMemPool(location, type, memPool) + + +cdef cudaError_t _cudaLogsRegisterCallback(cudaLogsCallback_t callbackFunc, void* userData, cudaLogsCallbackHandle* callback_out) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaLogsRegisterCallback(callbackFunc, userData, callback_out) + + +cdef cudaError_t _cudaLogsUnregisterCallback(cudaLogsCallbackHandle callback) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaLogsUnregisterCallback(callback) + + +cdef cudaError_t _cudaLogsCurrent(cudaLogIterator* iterator_out, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaLogsCurrent(iterator_out, flags) + + +cdef cudaError_t _cudaLogsDumpToFile(cudaLogIterator* iterator, const char* pathToFile, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaLogsDumpToFile(iterator, pathToFile, flags) + + +cdef cudaError_t _cudaLogsDumpToMemory(cudaLogIterator* iterator, char* buffer, size_t* size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaLogsDumpToMemory(iterator, buffer, size, flags) + + +cdef cudaError_t _cudaGraphNodeGetContainingGraph(cudaGraphNode_t hNode, cudaGraph_t* phGraph) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphNodeGetContainingGraph(hNode, phGraph) + + +cdef cudaError_t _cudaGraphNodeGetLocalId(cudaGraphNode_t hNode, unsigned int* nodeId) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphNodeGetLocalId(hNode, nodeId) + + +cdef cudaError_t _cudaGraphNodeGetToolsId(cudaGraphNode_t hNode, unsigned long long* toolsNodeId) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphNodeGetToolsId(hNode, toolsNodeId) + + +cdef cudaError_t _cudaGraphGetId(cudaGraph_t hGraph, unsigned int* graphID) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphGetId(hGraph, graphID) + + +cdef cudaError_t _cudaGraphExecGetId(cudaGraphExec_t hGraphExec, unsigned int* graphID) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphExecGetId(hGraphExec, graphID) + + +cdef cudaError_t _cudaGraphConditionalHandleCreate_v2(cudaGraphConditionalHandle* pHandle_out, cudaGraph_t graph, cudaExecutionContext_t ctx, unsigned int defaultLaunchValue, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphConditionalHandleCreate_v2(pHandle_out, graph, ctx, defaultLaunchValue, flags) + + +cdef cudaError_t _cudaDeviceGetDevResource(int device, cudaDevResource* resource, cudaDevResourceType type) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceGetDevResource(device, resource, type) + + +cdef cudaError_t _cudaDevSmResourceSplitByCount(cudaDevResource* result, unsigned int* nbGroups, const cudaDevResource* input, cudaDevResource* remaining, unsigned int flags, unsigned int minCount) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDevSmResourceSplitByCount(result, nbGroups, input, remaining, flags, minCount) + + +cdef cudaError_t _cudaDevSmResourceSplit(cudaDevResource* result, unsigned int nbGroups, const cudaDevResource* input, cudaDevResource* remainder, unsigned int flags, cudaDevSmResourceGroupParams* groupParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDevSmResourceSplit(result, nbGroups, input, remainder, flags, groupParams) + + +cdef cudaError_t _cudaDevResourceGenerateDesc(cudaDevResourceDesc_t* phDesc, cudaDevResource* resources, unsigned int nbResources) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDevResourceGenerateDesc(phDesc, resources, nbResources) + + +cdef cudaError_t _cudaGreenCtxCreate(cudaExecutionContext_t* phCtx, cudaDevResourceDesc_t desc, int device, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGreenCtxCreate(phCtx, desc, device, flags) + + +cdef cudaError_t _cudaExecutionCtxDestroy(cudaExecutionContext_t ctx) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaExecutionCtxDestroy(ctx) + + +cdef cudaError_t _cudaExecutionCtxGetDevResource(cudaExecutionContext_t ctx, cudaDevResource* resource, cudaDevResourceType type) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaExecutionCtxGetDevResource(ctx, resource, type) + + +cdef cudaError_t _cudaExecutionCtxGetDevice(int* device, cudaExecutionContext_t ctx) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaExecutionCtxGetDevice(device, ctx) + + +cdef cudaError_t _cudaExecutionCtxGetId(cudaExecutionContext_t ctx, unsigned long long* ctxId) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaExecutionCtxGetId(ctx, ctxId) + + +cdef cudaError_t _cudaExecutionCtxStreamCreate(cudaStream_t* phStream, cudaExecutionContext_t ctx, unsigned int flags, int priority) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaExecutionCtxStreamCreate(phStream, ctx, flags, priority) + + +cdef cudaError_t _cudaExecutionCtxSynchronize(cudaExecutionContext_t ctx) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaExecutionCtxSynchronize(ctx) + + +cdef cudaError_t _cudaStreamGetDevResource(cudaStream_t hStream, cudaDevResource* resource, cudaDevResourceType type) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamGetDevResource(hStream, resource, type) + + +cdef cudaError_t _cudaExecutionCtxRecordEvent(cudaExecutionContext_t ctx, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaExecutionCtxRecordEvent(ctx, event) + + +cdef cudaError_t _cudaExecutionCtxWaitEvent(cudaExecutionContext_t ctx, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaExecutionCtxWaitEvent(ctx, event) + + +cdef cudaError_t _cudaDeviceGetExecutionCtx(cudaExecutionContext_t* ctx, int device) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceGetExecutionCtx(ctx, device) + + +cdef cudaError_t _cudaFuncGetParamCount(const void* func, size_t* paramCount) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaFuncGetParamCount(func, paramCount) + + +cdef cudaError_t _cudaLaunchHostFunc_v2(cudaStream_t stream, cudaHostFn_t fn, void* userData, unsigned int syncMode) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaLaunchHostFunc_v2(stream, fn, userData, syncMode) + + +cdef cudaError_t _cudaMemcpyWithAttributesAsync(void* dst, const void* src, size_t size, cudaMemcpyAttributes* attr, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpyWithAttributesAsync(dst, src, size, attr, stream) + + +cdef cudaError_t _cudaMemcpy3DWithAttributesAsync(cudaMemcpy3DBatchOp* op, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpy3DWithAttributesAsync(op, flags, stream) + + +cdef cudaError_t _cudaGraphNodeGetParams(cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphNodeGetParams(node, nodeParams) + + +cdef cudaError_t _cudaStreamBeginRecaptureToGraph(cudaStream_t stream, cudaStreamCaptureMode mode, cudaGraph_t graph, cudaGraphRecaptureCallbackData* callbackData) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamBeginRecaptureToGraph(stream, mode, graph, callbackData) diff --git a/cuda_bindings/cuda/bindings/_internal/runtime_ptds_windows.pyx b/cuda_bindings/cuda/bindings/_internal/runtime_ptds_windows.pyx new file mode 100644 index 00000000000..0f940954d0d --- /dev/null +++ b/cuda_bindings/cuda/bindings/_internal/runtime_ptds_windows.pyx @@ -0,0 +1,2262 @@ +# SPDX-FileCopyrightText: Copyright (c) 2021-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# SPDX-License-Identifier: Apache-2.0 +# +# This code was automatically generated across versions from 12.9.0 to 13.3.0. Do not modify it directly. + +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=33b0c77f7174d41189a91abfe73613b5ba48bd31b5da37d509da61c00b11a004 +cdef extern from "": + """ + #define CUDA_API_PER_THREAD_DEFAULT_STREAM + """ + + +############################################################################### +# C function declarations for static cudart with per-thread default stream +# (CUDA_API_PER_THREAD_DEFAULT_STREAM causes cudaXxx to resolve to the _ptsz +# per-thread-stream symbol variants) +############################################################################### + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceReset "cudaDeviceReset" () noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceSynchronize "cudaDeviceSynchronize" () noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceSetLimit "cudaDeviceSetLimit" (cudaLimit limit, size_t value) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetLimit "cudaDeviceGetLimit" (size_t* pValue, cudaLimit limit) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetTexture1DLinearMaxWidth "cudaDeviceGetTexture1DLinearMaxWidth" (size_t* maxWidthInElements, const cudaChannelFormatDesc* fmtDesc, int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetCacheConfig "cudaDeviceGetCacheConfig" (cudaFuncCache* pCacheConfig) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetStreamPriorityRange "cudaDeviceGetStreamPriorityRange" (int* leastPriority, int* greatestPriority) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceSetCacheConfig "cudaDeviceSetCacheConfig" (cudaFuncCache cacheConfig) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetByPCIBusId "cudaDeviceGetByPCIBusId" (int* device, const char* pciBusId) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetPCIBusId "cudaDeviceGetPCIBusId" (char* pciBusId, int len, int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaIpcGetEventHandle "cudaIpcGetEventHandle" (cudaIpcEventHandle_t* handle, cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaIpcOpenEventHandle "cudaIpcOpenEventHandle" (cudaEvent_t* event, cudaIpcEventHandle_t handle) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaIpcGetMemHandle "cudaIpcGetMemHandle" (cudaIpcMemHandle_t* handle, void* devPtr) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaIpcOpenMemHandle "cudaIpcOpenMemHandle" (void** devPtr, cudaIpcMemHandle_t handle, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaIpcCloseMemHandle "cudaIpcCloseMemHandle" (void* devPtr) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceFlushGPUDirectRDMAWrites "cudaDeviceFlushGPUDirectRDMAWrites" (cudaFlushGPUDirectRDMAWritesTarget target, cudaFlushGPUDirectRDMAWritesScope scope) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceRegisterAsyncNotification "cudaDeviceRegisterAsyncNotification" (int device, cudaAsyncCallback callbackFunc, void* userData, cudaAsyncCallbackHandle_t* callback) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceUnregisterAsyncNotification "cudaDeviceUnregisterAsyncNotification" (int device, cudaAsyncCallbackHandle_t callback) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetSharedMemConfig "cudaDeviceGetSharedMemConfig" (cudaSharedMemConfig* pConfig) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceSetSharedMemConfig "cudaDeviceSetSharedMemConfig" (cudaSharedMemConfig config) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetLastError "cudaGetLastError" () noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaPeekAtLastError "cudaPeekAtLastError" () noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + const char* _static_cudaGetErrorName "cudaGetErrorName" (cudaError_t error) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + const char* _static_cudaGetErrorString "cudaGetErrorString" (cudaError_t error) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetDeviceCount "cudaGetDeviceCount" (int* count) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetAttribute "cudaDeviceGetAttribute" (int* value, cudaDeviceAttr attr, int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetDefaultMemPool "cudaDeviceGetDefaultMemPool" (cudaMemPool_t* memPool, int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceSetMemPool "cudaDeviceSetMemPool" (int device, cudaMemPool_t memPool) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetMemPool "cudaDeviceGetMemPool" (cudaMemPool_t* memPool, int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetNvSciSyncAttributes "cudaDeviceGetNvSciSyncAttributes" (void* nvSciSyncAttrList, int device, int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetP2PAttribute "cudaDeviceGetP2PAttribute" (int* value, cudaDeviceP2PAttr attr, int srcDevice, int dstDevice) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaChooseDevice "cudaChooseDevice" (int* device, const cudaDeviceProp* prop) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaInitDevice "cudaInitDevice" (int device, unsigned int deviceFlags, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaSetDevice "cudaSetDevice" (int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetDevice "cudaGetDevice" (int* device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaSetDeviceFlags "cudaSetDeviceFlags" (unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetDeviceFlags "cudaGetDeviceFlags" (unsigned int* flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamCreate "cudaStreamCreate" (cudaStream_t* pStream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamCreateWithFlags "cudaStreamCreateWithFlags" (cudaStream_t* pStream, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamCreateWithPriority "cudaStreamCreateWithPriority" (cudaStream_t* pStream, unsigned int flags, int priority) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamGetPriority "cudaStreamGetPriority" (cudaStream_t hStream, int* priority) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamGetFlags "cudaStreamGetFlags" (cudaStream_t hStream, unsigned int* flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamGetId "cudaStreamGetId" (cudaStream_t hStream, unsigned long long* streamId) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamGetDevice "cudaStreamGetDevice" (cudaStream_t hStream, int* device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaCtxResetPersistingL2Cache "cudaCtxResetPersistingL2Cache" () noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamCopyAttributes "cudaStreamCopyAttributes" (cudaStream_t dst, cudaStream_t src) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamGetAttribute "cudaStreamGetAttribute" (cudaStream_t hStream, cudaLaunchAttributeID attr, cudaLaunchAttributeValue* value_out) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamSetAttribute "cudaStreamSetAttribute" (cudaStream_t hStream, cudaLaunchAttributeID attr, const cudaLaunchAttributeValue* value) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamDestroy "cudaStreamDestroy" (cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamWaitEvent "cudaStreamWaitEvent" (cudaStream_t stream, cudaEvent_t event, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamAddCallback "cudaStreamAddCallback" (cudaStream_t stream, cudaStreamCallback_t callback, void* userData, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamSynchronize "cudaStreamSynchronize" (cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamQuery "cudaStreamQuery" (cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamAttachMemAsync "cudaStreamAttachMemAsync" (cudaStream_t stream, void* devPtr, size_t length, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamBeginCapture "cudaStreamBeginCapture" (cudaStream_t stream, cudaStreamCaptureMode mode) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamBeginCaptureToGraph "cudaStreamBeginCaptureToGraph" (cudaStream_t stream, cudaGraph_t graph, const cudaGraphNode_t* dependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, cudaStreamCaptureMode mode) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaThreadExchangeStreamCaptureMode "cudaThreadExchangeStreamCaptureMode" (cudaStreamCaptureMode* mode) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamEndCapture "cudaStreamEndCapture" (cudaStream_t stream, cudaGraph_t* pGraph) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamIsCapturing "cudaStreamIsCapturing" (cudaStream_t stream, cudaStreamCaptureStatus* pCaptureStatus) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamUpdateCaptureDependencies "cudaStreamUpdateCaptureDependencies" (cudaStream_t stream, cudaGraphNode_t* dependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaEventCreate "cudaEventCreate" (cudaEvent_t* event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaEventCreateWithFlags "cudaEventCreateWithFlags" (cudaEvent_t* event, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaEventRecord "cudaEventRecord" (cudaEvent_t event, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaEventRecordWithFlags "cudaEventRecordWithFlags" (cudaEvent_t event, cudaStream_t stream, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaEventQuery "cudaEventQuery" (cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaEventSynchronize "cudaEventSynchronize" (cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaEventDestroy "cudaEventDestroy" (cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaEventElapsedTime "cudaEventElapsedTime" (float* ms, cudaEvent_t start, cudaEvent_t end) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaImportExternalMemory "cudaImportExternalMemory" (cudaExternalMemory_t* extMem_out, const cudaExternalMemoryHandleDesc* memHandleDesc) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaExternalMemoryGetMappedBuffer "cudaExternalMemoryGetMappedBuffer" (void** devPtr, cudaExternalMemory_t extMem, const cudaExternalMemoryBufferDesc* bufferDesc) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaExternalMemoryGetMappedMipmappedArray "cudaExternalMemoryGetMappedMipmappedArray" (cudaMipmappedArray_t* mipmap, cudaExternalMemory_t extMem, const cudaExternalMemoryMipmappedArrayDesc* mipmapDesc) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDestroyExternalMemory "cudaDestroyExternalMemory" (cudaExternalMemory_t extMem) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaImportExternalSemaphore "cudaImportExternalSemaphore" (cudaExternalSemaphore_t* extSem_out, const cudaExternalSemaphoreHandleDesc* semHandleDesc) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDestroyExternalSemaphore "cudaDestroyExternalSemaphore" (cudaExternalSemaphore_t extSem) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFuncSetCacheConfig "cudaFuncSetCacheConfig" (const void* func, cudaFuncCache cacheConfig) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFuncGetAttributes "cudaFuncGetAttributes" (cudaFuncAttributes* attr, const void* func) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFuncSetAttribute "cudaFuncSetAttribute" (const void* func, cudaFuncAttribute attr, int value) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFuncGetName "cudaFuncGetName" (const char** name, const void* func) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFuncGetParamInfo "cudaFuncGetParamInfo" (const void* func, size_t paramIndex, size_t* paramOffset, size_t* paramSize) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLaunchHostFunc "cudaLaunchHostFunc" (cudaStream_t stream, cudaHostFn_t fn, void* userData) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFuncSetSharedMemConfig "cudaFuncSetSharedMemConfig" (const void* func, cudaSharedMemConfig config) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaOccupancyMaxActiveBlocksPerMultiprocessor "cudaOccupancyMaxActiveBlocksPerMultiprocessor" (int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaOccupancyAvailableDynamicSMemPerBlock "cudaOccupancyAvailableDynamicSMemPerBlock" (size_t* dynamicSmemSize, const void* func, int numBlocks, int blockSize) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags "cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags" (int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMallocManaged "cudaMallocManaged" (void** devPtr, size_t size, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMalloc "cudaMalloc" (void** devPtr, size_t size) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMallocHost "cudaMallocHost" (void** ptr, size_t size) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMallocPitch "cudaMallocPitch" (void** devPtr, size_t* pitch, size_t width, size_t height) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMallocArray "cudaMallocArray" (cudaArray_t* array, const cudaChannelFormatDesc* desc, size_t width, size_t height, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFree "cudaFree" (void* devPtr) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFreeHost "cudaFreeHost" (void* ptr) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFreeArray "cudaFreeArray" (cudaArray_t array) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFreeMipmappedArray "cudaFreeMipmappedArray" (cudaMipmappedArray_t mipmappedArray) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaHostAlloc "cudaHostAlloc" (void** pHost, size_t size, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaHostRegister "cudaHostRegister" (void* ptr, size_t size, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaHostUnregister "cudaHostUnregister" (void* ptr) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaHostGetDevicePointer "cudaHostGetDevicePointer" (void** pDevice, void* pHost, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaHostGetFlags "cudaHostGetFlags" (unsigned int* pFlags, void* pHost) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMalloc3D "cudaMalloc3D" (cudaPitchedPtr* pitchedDevPtr, cudaExtent extent) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMalloc3DArray "cudaMalloc3DArray" (cudaArray_t* array, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMallocMipmappedArray "cudaMallocMipmappedArray" (cudaMipmappedArray_t* mipmappedArray, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int numLevels, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetMipmappedArrayLevel "cudaGetMipmappedArrayLevel" (cudaArray_t* levelArray, cudaMipmappedArray_const_t mipmappedArray, unsigned int level) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy3D "cudaMemcpy3D" (const cudaMemcpy3DParms* p) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy3DPeer "cudaMemcpy3DPeer" (const cudaMemcpy3DPeerParms* p) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy3DAsync "cudaMemcpy3DAsync" (const cudaMemcpy3DParms* p, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy3DPeerAsync "cudaMemcpy3DPeerAsync" (const cudaMemcpy3DPeerParms* p, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemGetInfo "cudaMemGetInfo" (size_t* free, size_t* total) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaArrayGetInfo "cudaArrayGetInfo" (cudaChannelFormatDesc* desc, cudaExtent* extent, unsigned int* flags, cudaArray_t array) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaArrayGetPlane "cudaArrayGetPlane" (cudaArray_t* pPlaneArray, cudaArray_t hArray, unsigned int planeIdx) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaArrayGetMemoryRequirements "cudaArrayGetMemoryRequirements" (cudaArrayMemoryRequirements* memoryRequirements, cudaArray_t array, int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMipmappedArrayGetMemoryRequirements "cudaMipmappedArrayGetMemoryRequirements" (cudaArrayMemoryRequirements* memoryRequirements, cudaMipmappedArray_t mipmap, int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaArrayGetSparseProperties "cudaArrayGetSparseProperties" (cudaArraySparseProperties* sparseProperties, cudaArray_t array) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMipmappedArrayGetSparseProperties "cudaMipmappedArrayGetSparseProperties" (cudaArraySparseProperties* sparseProperties, cudaMipmappedArray_t mipmap) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy "cudaMemcpy" (void* dst, const void* src, size_t count, cudaMemcpyKind kind) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpyPeer "cudaMemcpyPeer" (void* dst, int dstDevice, const void* src, int srcDevice, size_t count) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy2D "cudaMemcpy2D" (void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy2DToArray "cudaMemcpy2DToArray" (cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy2DFromArray "cudaMemcpy2DFromArray" (void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy2DArrayToArray "cudaMemcpy2DArrayToArray" (cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t width, size_t height, cudaMemcpyKind kind) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpyAsync "cudaMemcpyAsync" (void* dst, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpyPeerAsync "cudaMemcpyPeerAsync" (void* dst, int dstDevice, const void* src, int srcDevice, size_t count, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpyBatchAsync "cudaMemcpyBatchAsync" (void** dsts, const void** srcs, const size_t* sizes, size_t count, cudaMemcpyAttributes* attrs, size_t* attrsIdxs, size_t numAttrs, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy3DBatchAsync "cudaMemcpy3DBatchAsync" (size_t numOps, cudaMemcpy3DBatchOp* opList, unsigned long long flags, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy2DAsync "cudaMemcpy2DAsync" (void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy2DToArrayAsync "cudaMemcpy2DToArrayAsync" (cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy2DFromArrayAsync "cudaMemcpy2DFromArrayAsync" (void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemset "cudaMemset" (void* devPtr, int value, size_t count) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemset2D "cudaMemset2D" (void* devPtr, size_t pitch, int value, size_t width, size_t height) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemset3D "cudaMemset3D" (cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemsetAsync "cudaMemsetAsync" (void* devPtr, int value, size_t count, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemset2DAsync "cudaMemset2DAsync" (void* devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemset3DAsync "cudaMemset3DAsync" (cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPrefetchAsync "cudaMemPrefetchAsync" (const void* devPtr, size_t count, cudaMemLocation location, unsigned int flags, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemAdvise "cudaMemAdvise" (const void* devPtr, size_t count, cudaMemoryAdvise advice, cudaMemLocation location) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemRangeGetAttribute "cudaMemRangeGetAttribute" (void* data, size_t dataSize, cudaMemRangeAttribute attribute, const void* devPtr, size_t count) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemRangeGetAttributes "cudaMemRangeGetAttributes" (void** data, size_t* dataSizes, cudaMemRangeAttribute* attributes, size_t numAttributes, const void* devPtr, size_t count) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpyToArray "cudaMemcpyToArray" (cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpyFromArray "cudaMemcpyFromArray" (void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpyArrayToArray "cudaMemcpyArrayToArray" (cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t count, cudaMemcpyKind kind) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpyToArrayAsync "cudaMemcpyToArrayAsync" (cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpyFromArrayAsync "cudaMemcpyFromArrayAsync" (void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMallocAsync "cudaMallocAsync" (void** devPtr, size_t size, cudaStream_t hStream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFreeAsync "cudaFreeAsync" (void* devPtr, cudaStream_t hStream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPoolTrimTo "cudaMemPoolTrimTo" (cudaMemPool_t memPool, size_t minBytesToKeep) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPoolSetAttribute "cudaMemPoolSetAttribute" (cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPoolGetAttribute "cudaMemPoolGetAttribute" (cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPoolSetAccess "cudaMemPoolSetAccess" (cudaMemPool_t memPool, const cudaMemAccessDesc* descList, size_t count) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPoolGetAccess "cudaMemPoolGetAccess" (cudaMemAccessFlags* flags, cudaMemPool_t memPool, cudaMemLocation* location) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPoolCreate "cudaMemPoolCreate" (cudaMemPool_t* memPool, const cudaMemPoolProps* poolProps) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPoolDestroy "cudaMemPoolDestroy" (cudaMemPool_t memPool) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMallocFromPoolAsync "cudaMallocFromPoolAsync" (void** ptr, size_t size, cudaMemPool_t memPool, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPoolExportToShareableHandle "cudaMemPoolExportToShareableHandle" (void* shareableHandle, cudaMemPool_t memPool, cudaMemAllocationHandleType handleType, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPoolImportFromShareableHandle "cudaMemPoolImportFromShareableHandle" (cudaMemPool_t* memPool, void* shareableHandle, cudaMemAllocationHandleType handleType, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPoolExportPointer "cudaMemPoolExportPointer" (cudaMemPoolPtrExportData* exportData, void* ptr) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPoolImportPointer "cudaMemPoolImportPointer" (void** ptr, cudaMemPool_t memPool, cudaMemPoolPtrExportData* exportData) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaPointerGetAttributes "cudaPointerGetAttributes" (cudaPointerAttributes* attributes, const void* ptr) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceCanAccessPeer "cudaDeviceCanAccessPeer" (int* canAccessPeer, int device, int peerDevice) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceEnablePeerAccess "cudaDeviceEnablePeerAccess" (int peerDevice, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceDisablePeerAccess "cudaDeviceDisablePeerAccess" (int peerDevice) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphicsUnregisterResource "cudaGraphicsUnregisterResource" (cudaGraphicsResource_t resource) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphicsResourceSetMapFlags "cudaGraphicsResourceSetMapFlags" (cudaGraphicsResource_t resource, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphicsMapResources "cudaGraphicsMapResources" (int count, cudaGraphicsResource_t* resources, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphicsUnmapResources "cudaGraphicsUnmapResources" (int count, cudaGraphicsResource_t* resources, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphicsResourceGetMappedPointer "cudaGraphicsResourceGetMappedPointer" (void** devPtr, size_t* size, cudaGraphicsResource_t resource) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphicsSubResourceGetMappedArray "cudaGraphicsSubResourceGetMappedArray" (cudaArray_t* array, cudaGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphicsResourceGetMappedMipmappedArray "cudaGraphicsResourceGetMappedMipmappedArray" (cudaMipmappedArray_t* mipmappedArray, cudaGraphicsResource_t resource) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetChannelDesc "cudaGetChannelDesc" (cudaChannelFormatDesc* desc, cudaArray_const_t array) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaChannelFormatDesc _static_cudaCreateChannelDesc "cudaCreateChannelDesc" (int x, int y, int z, int w, cudaChannelFormatKind f) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaCreateTextureObject "cudaCreateTextureObject" (cudaTextureObject_t* pTexObject, const cudaResourceDesc* pResDesc, const cudaTextureDesc* pTexDesc, const cudaResourceViewDesc* pResViewDesc) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDestroyTextureObject "cudaDestroyTextureObject" (cudaTextureObject_t texObject) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetTextureObjectResourceDesc "cudaGetTextureObjectResourceDesc" (cudaResourceDesc* pResDesc, cudaTextureObject_t texObject) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetTextureObjectTextureDesc "cudaGetTextureObjectTextureDesc" (cudaTextureDesc* pTexDesc, cudaTextureObject_t texObject) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetTextureObjectResourceViewDesc "cudaGetTextureObjectResourceViewDesc" (cudaResourceViewDesc* pResViewDesc, cudaTextureObject_t texObject) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaCreateSurfaceObject "cudaCreateSurfaceObject" (cudaSurfaceObject_t* pSurfObject, const cudaResourceDesc* pResDesc) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDestroySurfaceObject "cudaDestroySurfaceObject" (cudaSurfaceObject_t surfObject) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetSurfaceObjectResourceDesc "cudaGetSurfaceObjectResourceDesc" (cudaResourceDesc* pResDesc, cudaSurfaceObject_t surfObject) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDriverGetVersion "cudaDriverGetVersion" (int* driverVersion) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaRuntimeGetVersion "cudaRuntimeGetVersion" (int* runtimeVersion) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphCreate "cudaGraphCreate" (cudaGraph_t* pGraph, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddKernelNode "cudaGraphAddKernelNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaKernelNodeParams* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphKernelNodeGetParams "cudaGraphKernelNodeGetParams" (cudaGraphNode_t node, cudaKernelNodeParams* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphKernelNodeSetParams "cudaGraphKernelNodeSetParams" (cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphKernelNodeCopyAttributes "cudaGraphKernelNodeCopyAttributes" (cudaGraphNode_t hDst, cudaGraphNode_t hSrc) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphKernelNodeGetAttribute "cudaGraphKernelNodeGetAttribute" (cudaGraphNode_t hNode, cudaLaunchAttributeID attr, cudaLaunchAttributeValue* value_out) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphKernelNodeSetAttribute "cudaGraphKernelNodeSetAttribute" (cudaGraphNode_t hNode, cudaLaunchAttributeID attr, const cudaLaunchAttributeValue* value) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddMemcpyNode "cudaGraphAddMemcpyNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemcpy3DParms* pCopyParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddMemcpyNode1D "cudaGraphAddMemcpyNode1D" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dst, const void* src, size_t count, cudaMemcpyKind kind) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphMemcpyNodeGetParams "cudaGraphMemcpyNodeGetParams" (cudaGraphNode_t node, cudaMemcpy3DParms* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphMemcpyNodeSetParams "cudaGraphMemcpyNodeSetParams" (cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphMemcpyNodeSetParams1D "cudaGraphMemcpyNodeSetParams1D" (cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddMemsetNode "cudaGraphAddMemsetNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemsetParams* pMemsetParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphMemsetNodeGetParams "cudaGraphMemsetNodeGetParams" (cudaGraphNode_t node, cudaMemsetParams* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphMemsetNodeSetParams "cudaGraphMemsetNodeSetParams" (cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddHostNode "cudaGraphAddHostNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaHostNodeParams* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphHostNodeGetParams "cudaGraphHostNodeGetParams" (cudaGraphNode_t node, cudaHostNodeParams* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphHostNodeSetParams "cudaGraphHostNodeSetParams" (cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddChildGraphNode "cudaGraphAddChildGraphNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaGraph_t childGraph) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphChildGraphNodeGetGraph "cudaGraphChildGraphNodeGetGraph" (cudaGraphNode_t node, cudaGraph_t* pGraph) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddEmptyNode "cudaGraphAddEmptyNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddEventRecordNode "cudaGraphAddEventRecordNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphEventRecordNodeGetEvent "cudaGraphEventRecordNodeGetEvent" (cudaGraphNode_t node, cudaEvent_t* event_out) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphEventRecordNodeSetEvent "cudaGraphEventRecordNodeSetEvent" (cudaGraphNode_t node, cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddEventWaitNode "cudaGraphAddEventWaitNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphEventWaitNodeGetEvent "cudaGraphEventWaitNodeGetEvent" (cudaGraphNode_t node, cudaEvent_t* event_out) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphEventWaitNodeSetEvent "cudaGraphEventWaitNodeSetEvent" (cudaGraphNode_t node, cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddExternalSemaphoresSignalNode "cudaGraphAddExternalSemaphoresSignalNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreSignalNodeParams* nodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExternalSemaphoresSignalNodeGetParams "cudaGraphExternalSemaphoresSignalNodeGetParams" (cudaGraphNode_t hNode, cudaExternalSemaphoreSignalNodeParams* params_out) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExternalSemaphoresSignalNodeSetParams "cudaGraphExternalSemaphoresSignalNodeSetParams" (cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddExternalSemaphoresWaitNode "cudaGraphAddExternalSemaphoresWaitNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreWaitNodeParams* nodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExternalSemaphoresWaitNodeGetParams "cudaGraphExternalSemaphoresWaitNodeGetParams" (cudaGraphNode_t hNode, cudaExternalSemaphoreWaitNodeParams* params_out) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExternalSemaphoresWaitNodeSetParams "cudaGraphExternalSemaphoresWaitNodeSetParams" (cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddMemAllocNode "cudaGraphAddMemAllocNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaMemAllocNodeParams* nodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphMemAllocNodeGetParams "cudaGraphMemAllocNodeGetParams" (cudaGraphNode_t node, cudaMemAllocNodeParams* params_out) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddMemFreeNode "cudaGraphAddMemFreeNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dptr) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphMemFreeNodeGetParams "cudaGraphMemFreeNodeGetParams" (cudaGraphNode_t node, void* dptr_out) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGraphMemTrim "cudaDeviceGraphMemTrim" (int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetGraphMemAttribute "cudaDeviceGetGraphMemAttribute" (int device, cudaGraphMemAttributeType attr, void* value) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceSetGraphMemAttribute "cudaDeviceSetGraphMemAttribute" (int device, cudaGraphMemAttributeType attr, void* value) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphClone "cudaGraphClone" (cudaGraph_t* pGraphClone, cudaGraph_t originalGraph) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphNodeFindInClone "cudaGraphNodeFindInClone" (cudaGraphNode_t* pNode, cudaGraphNode_t originalNode, cudaGraph_t clonedGraph) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphNodeGetType "cudaGraphNodeGetType" (cudaGraphNode_t node, cudaGraphNodeType* pType) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphGetNodes "cudaGraphGetNodes" (cudaGraph_t graph, cudaGraphNode_t* nodes, size_t* numNodes) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphGetRootNodes "cudaGraphGetRootNodes" (cudaGraph_t graph, cudaGraphNode_t* pRootNodes, size_t* pNumRootNodes) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphGetEdges "cudaGraphGetEdges" (cudaGraph_t graph, cudaGraphNode_t* from_, cudaGraphNode_t* to, cudaGraphEdgeData* edgeData, size_t* numEdges) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphNodeGetDependencies "cudaGraphNodeGetDependencies" (cudaGraphNode_t node, cudaGraphNode_t* pDependencies, cudaGraphEdgeData* edgeData, size_t* pNumDependencies) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphNodeGetDependentNodes "cudaGraphNodeGetDependentNodes" (cudaGraphNode_t node, cudaGraphNode_t* pDependentNodes, cudaGraphEdgeData* edgeData, size_t* pNumDependentNodes) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddDependencies "cudaGraphAddDependencies" (cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, const cudaGraphEdgeData* edgeData, size_t numDependencies) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphRemoveDependencies "cudaGraphRemoveDependencies" (cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, const cudaGraphEdgeData* edgeData, size_t numDependencies) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphDestroyNode "cudaGraphDestroyNode" (cudaGraphNode_t node) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphInstantiate "cudaGraphInstantiate" (cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphInstantiateWithFlags "cudaGraphInstantiateWithFlags" (cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphInstantiateWithParams "cudaGraphInstantiateWithParams" (cudaGraphExec_t* pGraphExec, cudaGraph_t graph, cudaGraphInstantiateParams* instantiateParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecGetFlags "cudaGraphExecGetFlags" (cudaGraphExec_t graphExec, unsigned long long* flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecKernelNodeSetParams "cudaGraphExecKernelNodeSetParams" (cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecMemcpyNodeSetParams "cudaGraphExecMemcpyNodeSetParams" (cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecMemcpyNodeSetParams1D "cudaGraphExecMemcpyNodeSetParams1D" (cudaGraphExec_t hGraphExec, cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecMemsetNodeSetParams "cudaGraphExecMemsetNodeSetParams" (cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecHostNodeSetParams "cudaGraphExecHostNodeSetParams" (cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecChildGraphNodeSetParams "cudaGraphExecChildGraphNodeSetParams" (cudaGraphExec_t hGraphExec, cudaGraphNode_t node, cudaGraph_t childGraph) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecEventRecordNodeSetEvent "cudaGraphExecEventRecordNodeSetEvent" (cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecEventWaitNodeSetEvent "cudaGraphExecEventWaitNodeSetEvent" (cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecExternalSemaphoresSignalNodeSetParams "cudaGraphExecExternalSemaphoresSignalNodeSetParams" (cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecExternalSemaphoresWaitNodeSetParams "cudaGraphExecExternalSemaphoresWaitNodeSetParams" (cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphNodeSetEnabled "cudaGraphNodeSetEnabled" (cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int isEnabled) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphNodeGetEnabled "cudaGraphNodeGetEnabled" (cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int* isEnabled) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecUpdate "cudaGraphExecUpdate" (cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphExecUpdateResultInfo* resultInfo) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphUpload "cudaGraphUpload" (cudaGraphExec_t graphExec, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphLaunch "cudaGraphLaunch" (cudaGraphExec_t graphExec, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecDestroy "cudaGraphExecDestroy" (cudaGraphExec_t graphExec) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphDestroy "cudaGraphDestroy" (cudaGraph_t graph) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphDebugDotPrint "cudaGraphDebugDotPrint" (cudaGraph_t graph, const char* path, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaUserObjectCreate "cudaUserObjectCreate" (cudaUserObject_t* object_out, void* ptr, cudaHostFn_t destroy, unsigned int initialRefcount, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaUserObjectRetain "cudaUserObjectRetain" (cudaUserObject_t object, unsigned int count) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaUserObjectRelease "cudaUserObjectRelease" (cudaUserObject_t object, unsigned int count) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphRetainUserObject "cudaGraphRetainUserObject" (cudaGraph_t graph, cudaUserObject_t object, unsigned int count, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphReleaseUserObject "cudaGraphReleaseUserObject" (cudaGraph_t graph, cudaUserObject_t object, unsigned int count) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddNode "cudaGraphAddNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, cudaGraphNodeParams* nodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphNodeSetParams "cudaGraphNodeSetParams" (cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecNodeSetParams "cudaGraphExecNodeSetParams" (cudaGraphExec_t graphExec, cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphConditionalHandleCreate "cudaGraphConditionalHandleCreate" (cudaGraphConditionalHandle* pHandle_out, cudaGraph_t graph, unsigned int defaultLaunchValue, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetDriverEntryPoint "cudaGetDriverEntryPoint" (const char* symbol, void** funcPtr, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetDriverEntryPointByVersion "cudaGetDriverEntryPointByVersion" (const char* symbol, void** funcPtr, unsigned int cudaVersion, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLibraryLoadData "cudaLibraryLoadData" (cudaLibrary_t* library, const void* code, cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLibraryLoadFromFile "cudaLibraryLoadFromFile" (cudaLibrary_t* library, const char* fileName, cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLibraryUnload "cudaLibraryUnload" (cudaLibrary_t library) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLibraryGetKernel "cudaLibraryGetKernel" (cudaKernel_t* pKernel, cudaLibrary_t library, const char* name) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLibraryGetGlobal "cudaLibraryGetGlobal" (void** dptr, size_t* bytes, cudaLibrary_t library, const char* name) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLibraryGetManaged "cudaLibraryGetManaged" (void** dptr, size_t* bytes, cudaLibrary_t library, const char* name) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLibraryGetUnifiedFunction "cudaLibraryGetUnifiedFunction" (void** fptr, cudaLibrary_t library, const char* symbol) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLibraryGetKernelCount "cudaLibraryGetKernelCount" (unsigned int* count, cudaLibrary_t lib) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLibraryEnumerateKernels "cudaLibraryEnumerateKernels" (cudaKernel_t* kernels, unsigned int numKernels, cudaLibrary_t lib) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaKernelSetAttributeForDevice "cudaKernelSetAttributeForDevice" (cudaKernel_t kernel, cudaFuncAttribute attr, int value, int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetExportTable "cudaGetExportTable" (const void** ppExportTable, const cudaUUID_t* pExportTableId) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetKernel "cudaGetKernel" (cudaKernel_t* kernelPtr, const void* entryFuncAddr) noexcept + +cdef extern from 'cuda_profiler_api.h' nogil: + cudaError_t _static_cudaProfilerStart "cudaProfilerStart" () noexcept + +cdef extern from 'cuda_profiler_api.h' nogil: + cudaError_t _static_cudaProfilerStop "cudaProfilerStop" () noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetDeviceProperties "cudaGetDeviceProperties" (cudaDeviceProp* prop, int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetHostAtomicCapabilities "cudaDeviceGetHostAtomicCapabilities" (unsigned int* capabilities, const cudaAtomicOperation* operations, unsigned int count, int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetP2PAtomicCapabilities "cudaDeviceGetP2PAtomicCapabilities" (unsigned int* capabilities, const cudaAtomicOperation* operations, unsigned int count, int srcDevice, int dstDevice) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamGetCaptureInfo "cudaStreamGetCaptureInfo" (cudaStream_t stream, cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out, cudaGraph_t* graph_out, const cudaGraphNode_t** dependencies_out, const cudaGraphEdgeData** edgeData_out, size_t* numDependencies_out) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaSignalExternalSemaphoresAsync "cudaSignalExternalSemaphoresAsync" (const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreSignalParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaWaitExternalSemaphoresAsync "cudaWaitExternalSemaphoresAsync" (const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreWaitParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPrefetchBatchAsync "cudaMemPrefetchBatchAsync" (void** dptrs, size_t* sizes, size_t count, cudaMemLocation* prefetchLocs, size_t* prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemDiscardBatchAsync "cudaMemDiscardBatchAsync" (void** dptrs, size_t* sizes, size_t count, unsigned long long flags, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemDiscardAndPrefetchBatchAsync "cudaMemDiscardAndPrefetchBatchAsync" (void** dptrs, size_t* sizes, size_t count, cudaMemLocation* prefetchLocs, size_t* prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemGetDefaultMemPool "cudaMemGetDefaultMemPool" (cudaMemPool_t* memPool, cudaMemLocation* location, cudaMemAllocationType type) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemGetMemPool "cudaMemGetMemPool" (cudaMemPool_t* memPool, cudaMemLocation* location, cudaMemAllocationType type) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemSetMemPool "cudaMemSetMemPool" (cudaMemLocation* location, cudaMemAllocationType type, cudaMemPool_t memPool) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLogsRegisterCallback "cudaLogsRegisterCallback" (cudaLogsCallback_t callbackFunc, void* userData, cudaLogsCallbackHandle* callback_out) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLogsUnregisterCallback "cudaLogsUnregisterCallback" (cudaLogsCallbackHandle callback) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLogsCurrent "cudaLogsCurrent" (cudaLogIterator* iterator_out, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLogsDumpToFile "cudaLogsDumpToFile" (cudaLogIterator* iterator, const char* pathToFile, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLogsDumpToMemory "cudaLogsDumpToMemory" (cudaLogIterator* iterator, char* buffer, size_t* size, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphNodeGetContainingGraph "cudaGraphNodeGetContainingGraph" (cudaGraphNode_t hNode, cudaGraph_t* phGraph) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphNodeGetLocalId "cudaGraphNodeGetLocalId" (cudaGraphNode_t hNode, unsigned int* nodeId) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphNodeGetToolsId "cudaGraphNodeGetToolsId" (cudaGraphNode_t hNode, unsigned long long* toolsNodeId) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphGetId "cudaGraphGetId" (cudaGraph_t hGraph, unsigned int* graphID) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecGetId "cudaGraphExecGetId" (cudaGraphExec_t hGraphExec, unsigned int* graphID) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphConditionalHandleCreate_v2 "cudaGraphConditionalHandleCreate_v2" (cudaGraphConditionalHandle* pHandle_out, cudaGraph_t graph, cudaExecutionContext_t ctx, unsigned int defaultLaunchValue, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetDevResource "cudaDeviceGetDevResource" (int device, cudaDevResource* resource, cudaDevResourceType type) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDevSmResourceSplitByCount "cudaDevSmResourceSplitByCount" (cudaDevResource* result, unsigned int* nbGroups, const cudaDevResource* input, cudaDevResource* remaining, unsigned int flags, unsigned int minCount) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDevSmResourceSplit "cudaDevSmResourceSplit" (cudaDevResource* result, unsigned int nbGroups, const cudaDevResource* input, cudaDevResource* remainder, unsigned int flags, cudaDevSmResourceGroupParams* groupParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDevResourceGenerateDesc "cudaDevResourceGenerateDesc" (cudaDevResourceDesc_t* phDesc, cudaDevResource* resources, unsigned int nbResources) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGreenCtxCreate "cudaGreenCtxCreate" (cudaExecutionContext_t* phCtx, cudaDevResourceDesc_t desc, int device, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaExecutionCtxDestroy "cudaExecutionCtxDestroy" (cudaExecutionContext_t ctx) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaExecutionCtxGetDevResource "cudaExecutionCtxGetDevResource" (cudaExecutionContext_t ctx, cudaDevResource* resource, cudaDevResourceType type) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaExecutionCtxGetDevice "cudaExecutionCtxGetDevice" (int* device, cudaExecutionContext_t ctx) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaExecutionCtxGetId "cudaExecutionCtxGetId" (cudaExecutionContext_t ctx, unsigned long long* ctxId) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaExecutionCtxStreamCreate "cudaExecutionCtxStreamCreate" (cudaStream_t* phStream, cudaExecutionContext_t ctx, unsigned int flags, int priority) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaExecutionCtxSynchronize "cudaExecutionCtxSynchronize" (cudaExecutionContext_t ctx) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamGetDevResource "cudaStreamGetDevResource" (cudaStream_t hStream, cudaDevResource* resource, cudaDevResourceType type) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaExecutionCtxRecordEvent "cudaExecutionCtxRecordEvent" (cudaExecutionContext_t ctx, cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaExecutionCtxWaitEvent "cudaExecutionCtxWaitEvent" (cudaExecutionContext_t ctx, cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetExecutionCtx "cudaDeviceGetExecutionCtx" (cudaExecutionContext_t* ctx, int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFuncGetParamCount "cudaFuncGetParamCount" (const void* func, size_t* paramCount) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLaunchHostFunc_v2 "cudaLaunchHostFunc_v2" (cudaStream_t stream, cudaHostFn_t fn, void* userData, unsigned int syncMode) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpyWithAttributesAsync "cudaMemcpyWithAttributesAsync" (void* dst, const void* src, size_t size, cudaMemcpyAttributes* attr, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy3DWithAttributesAsync "cudaMemcpy3DWithAttributesAsync" (cudaMemcpy3DBatchOp* op, unsigned long long flags, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphNodeGetParams "cudaGraphNodeGetParams" (cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamBeginRecaptureToGraph "cudaStreamBeginRecaptureToGraph" (cudaStream_t stream, cudaStreamCaptureMode mode, cudaGraph_t graph, cudaGraphRecaptureCallbackData* callbackData) noexcept + + +############################################################################### +# Wrapper functions +############################################################################### + +cdef cudaError_t _cudaDeviceReset() except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceReset() + + +cdef cudaError_t _cudaDeviceSynchronize() except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceSynchronize() + + +cdef cudaError_t _cudaDeviceSetLimit(cudaLimit limit, size_t value) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceSetLimit(limit, value) + + +cdef cudaError_t _cudaDeviceGetLimit(size_t* pValue, cudaLimit limit) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceGetLimit(pValue, limit) + + +cdef cudaError_t _cudaDeviceGetTexture1DLinearMaxWidth(size_t* maxWidthInElements, const cudaChannelFormatDesc* fmtDesc, int device) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceGetTexture1DLinearMaxWidth(maxWidthInElements, fmtDesc, device) + + +cdef cudaError_t _cudaDeviceGetCacheConfig(cudaFuncCache* pCacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceGetCacheConfig(pCacheConfig) + + +cdef cudaError_t _cudaDeviceGetStreamPriorityRange(int* leastPriority, int* greatestPriority) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceGetStreamPriorityRange(leastPriority, greatestPriority) + + +cdef cudaError_t _cudaDeviceSetCacheConfig(cudaFuncCache cacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceSetCacheConfig(cacheConfig) + + +cdef cudaError_t _cudaDeviceGetByPCIBusId(int* device, const char* pciBusId) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceGetByPCIBusId(device, pciBusId) + + +cdef cudaError_t _cudaDeviceGetPCIBusId(char* pciBusId, int len, int device) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceGetPCIBusId(pciBusId, len, device) + + +cdef cudaError_t _cudaIpcGetEventHandle(cudaIpcEventHandle_t* handle, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaIpcGetEventHandle(handle, event) + + +cdef cudaError_t _cudaIpcOpenEventHandle(cudaEvent_t* event, cudaIpcEventHandle_t handle) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaIpcOpenEventHandle(event, handle) + + +cdef cudaError_t _cudaIpcGetMemHandle(cudaIpcMemHandle_t* handle, void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaIpcGetMemHandle(handle, devPtr) + + +cdef cudaError_t _cudaIpcOpenMemHandle(void** devPtr, cudaIpcMemHandle_t handle, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaIpcOpenMemHandle(devPtr, handle, flags) + + +cdef cudaError_t _cudaIpcCloseMemHandle(void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaIpcCloseMemHandle(devPtr) + + +cdef cudaError_t _cudaDeviceFlushGPUDirectRDMAWrites(cudaFlushGPUDirectRDMAWritesTarget target, cudaFlushGPUDirectRDMAWritesScope scope) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceFlushGPUDirectRDMAWrites(target, scope) + + +cdef cudaError_t _cudaDeviceRegisterAsyncNotification(int device, cudaAsyncCallback callbackFunc, void* userData, cudaAsyncCallbackHandle_t* callback) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceRegisterAsyncNotification(device, callbackFunc, userData, callback) + + +cdef cudaError_t _cudaDeviceUnregisterAsyncNotification(int device, cudaAsyncCallbackHandle_t callback) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceUnregisterAsyncNotification(device, callback) + + +cdef cudaError_t _cudaDeviceGetSharedMemConfig(cudaSharedMemConfig* pConfig) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceGetSharedMemConfig(pConfig) + + +cdef cudaError_t _cudaDeviceSetSharedMemConfig(cudaSharedMemConfig config) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceSetSharedMemConfig(config) + + +cdef cudaError_t _cudaGetLastError() except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGetLastError() + + +cdef cudaError_t _cudaPeekAtLastError() except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaPeekAtLastError() + + +cdef const char* _cudaGetErrorName(cudaError_t error) except?NULL nogil: + return _static_cudaGetErrorName(error) + + +cdef const char* _cudaGetErrorString(cudaError_t error) except?NULL nogil: + return _static_cudaGetErrorString(error) + + +cdef cudaError_t _cudaGetDeviceCount(int* count) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGetDeviceCount(count) + + +cdef cudaError_t _cudaDeviceGetAttribute(int* value, cudaDeviceAttr attr, int device) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceGetAttribute(value, attr, device) + + +cdef cudaError_t _cudaDeviceGetDefaultMemPool(cudaMemPool_t* memPool, int device) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceGetDefaultMemPool(memPool, device) + + +cdef cudaError_t _cudaDeviceSetMemPool(int device, cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceSetMemPool(device, memPool) + + +cdef cudaError_t _cudaDeviceGetMemPool(cudaMemPool_t* memPool, int device) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceGetMemPool(memPool, device) + + +cdef cudaError_t _cudaDeviceGetNvSciSyncAttributes(void* nvSciSyncAttrList, int device, int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceGetNvSciSyncAttributes(nvSciSyncAttrList, device, flags) + + +cdef cudaError_t _cudaDeviceGetP2PAttribute(int* value, cudaDeviceP2PAttr attr, int srcDevice, int dstDevice) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceGetP2PAttribute(value, attr, srcDevice, dstDevice) + + +cdef cudaError_t _cudaChooseDevice(int* device, const cudaDeviceProp* prop) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaChooseDevice(device, prop) + + +cdef cudaError_t _cudaInitDevice(int device, unsigned int deviceFlags, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaInitDevice(device, deviceFlags, flags) + + +cdef cudaError_t _cudaSetDevice(int device) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaSetDevice(device) + + +cdef cudaError_t _cudaGetDevice(int* device) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGetDevice(device) + + +cdef cudaError_t _cudaSetDeviceFlags(unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaSetDeviceFlags(flags) + + +cdef cudaError_t _cudaGetDeviceFlags(unsigned int* flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGetDeviceFlags(flags) + + +cdef cudaError_t _cudaStreamCreate(cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamCreate(pStream) + + +cdef cudaError_t _cudaStreamCreateWithFlags(cudaStream_t* pStream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamCreateWithFlags(pStream, flags) + + +cdef cudaError_t _cudaStreamCreateWithPriority(cudaStream_t* pStream, unsigned int flags, int priority) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamCreateWithPriority(pStream, flags, priority) + + +cdef cudaError_t _cudaStreamGetPriority(cudaStream_t hStream, int* priority) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamGetPriority(hStream, priority) + + +cdef cudaError_t _cudaStreamGetFlags(cudaStream_t hStream, unsigned int* flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamGetFlags(hStream, flags) + + +cdef cudaError_t _cudaStreamGetId(cudaStream_t hStream, unsigned long long* streamId) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamGetId(hStream, streamId) + + +cdef cudaError_t _cudaStreamGetDevice(cudaStream_t hStream, int* device) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamGetDevice(hStream, device) + + +cdef cudaError_t _cudaCtxResetPersistingL2Cache() except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaCtxResetPersistingL2Cache() + + +cdef cudaError_t _cudaStreamCopyAttributes(cudaStream_t dst, cudaStream_t src) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamCopyAttributes(dst, src) + + +cdef cudaError_t _cudaStreamGetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, cudaStreamAttrValue* value_out) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamGetAttribute(hStream, attr, value_out) + + +cdef cudaError_t _cudaStreamSetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, const cudaStreamAttrValue* value) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamSetAttribute(hStream, attr, value) + + +cdef cudaError_t _cudaStreamDestroy(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamDestroy(stream) + + +cdef cudaError_t _cudaStreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamWaitEvent(stream, event, flags) + + +cdef cudaError_t _cudaStreamAddCallback(cudaStream_t stream, cudaStreamCallback_t callback, void* userData, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamAddCallback(stream, callback, userData, flags) + + +cdef cudaError_t _cudaStreamSynchronize(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamSynchronize(stream) + + +cdef cudaError_t _cudaStreamQuery(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamQuery(stream) + + +cdef cudaError_t _cudaStreamAttachMemAsync(cudaStream_t stream, void* devPtr, size_t length, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamAttachMemAsync(stream, devPtr, length, flags) + + +cdef cudaError_t _cudaStreamBeginCapture(cudaStream_t stream, cudaStreamCaptureMode mode) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamBeginCapture(stream, mode) + + +cdef cudaError_t _cudaStreamBeginCaptureToGraph(cudaStream_t stream, cudaGraph_t graph, const cudaGraphNode_t* dependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, cudaStreamCaptureMode mode) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamBeginCaptureToGraph(stream, graph, dependencies, dependencyData, numDependencies, mode) + + +cdef cudaError_t _cudaThreadExchangeStreamCaptureMode(cudaStreamCaptureMode* mode) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaThreadExchangeStreamCaptureMode(mode) + + +cdef cudaError_t _cudaStreamEndCapture(cudaStream_t stream, cudaGraph_t* pGraph) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamEndCapture(stream, pGraph) + + +cdef cudaError_t _cudaStreamIsCapturing(cudaStream_t stream, cudaStreamCaptureStatus* pCaptureStatus) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamIsCapturing(stream, pCaptureStatus) + + +cdef cudaError_t _cudaStreamUpdateCaptureDependencies(cudaStream_t stream, cudaGraphNode_t* dependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamUpdateCaptureDependencies(stream, dependencies, dependencyData, numDependencies, flags) + + +cdef cudaError_t _cudaEventCreate(cudaEvent_t* event) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaEventCreate(event) + + +cdef cudaError_t _cudaEventCreateWithFlags(cudaEvent_t* event, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaEventCreateWithFlags(event, flags) + + +cdef cudaError_t _cudaEventRecord(cudaEvent_t event, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaEventRecord(event, stream) + + +cdef cudaError_t _cudaEventRecordWithFlags(cudaEvent_t event, cudaStream_t stream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaEventRecordWithFlags(event, stream, flags) + + +cdef cudaError_t _cudaEventQuery(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaEventQuery(event) + + +cdef cudaError_t _cudaEventSynchronize(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaEventSynchronize(event) + + +cdef cudaError_t _cudaEventDestroy(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaEventDestroy(event) + + +cdef cudaError_t _cudaEventElapsedTime(float* ms, cudaEvent_t start, cudaEvent_t end) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaEventElapsedTime(ms, start, end) + + +cdef cudaError_t _cudaImportExternalMemory(cudaExternalMemory_t* extMem_out, const cudaExternalMemoryHandleDesc* memHandleDesc) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaImportExternalMemory(extMem_out, memHandleDesc) + + +cdef cudaError_t _cudaExternalMemoryGetMappedBuffer(void** devPtr, cudaExternalMemory_t extMem, const cudaExternalMemoryBufferDesc* bufferDesc) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaExternalMemoryGetMappedBuffer(devPtr, extMem, bufferDesc) + + +cdef cudaError_t _cudaExternalMemoryGetMappedMipmappedArray(cudaMipmappedArray_t* mipmap, cudaExternalMemory_t extMem, const cudaExternalMemoryMipmappedArrayDesc* mipmapDesc) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaExternalMemoryGetMappedMipmappedArray(mipmap, extMem, mipmapDesc) + + +cdef cudaError_t _cudaDestroyExternalMemory(cudaExternalMemory_t extMem) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDestroyExternalMemory(extMem) + + +cdef cudaError_t _cudaImportExternalSemaphore(cudaExternalSemaphore_t* extSem_out, const cudaExternalSemaphoreHandleDesc* semHandleDesc) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaImportExternalSemaphore(extSem_out, semHandleDesc) + + +cdef cudaError_t _cudaDestroyExternalSemaphore(cudaExternalSemaphore_t extSem) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDestroyExternalSemaphore(extSem) + + +cdef cudaError_t _cudaFuncSetCacheConfig(const void* func, cudaFuncCache cacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaFuncSetCacheConfig(func, cacheConfig) + + +cdef cudaError_t _cudaFuncGetAttributes(cudaFuncAttributes* attr, const void* func) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaFuncGetAttributes(attr, func) + + +cdef cudaError_t _cudaFuncSetAttribute(const void* func, cudaFuncAttribute attr, int value) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaFuncSetAttribute(func, attr, value) + + +cdef cudaError_t _cudaFuncGetName(const char** name, const void* func) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaFuncGetName(name, func) + + +cdef cudaError_t _cudaFuncGetParamInfo(const void* func, size_t paramIndex, size_t* paramOffset, size_t* paramSize) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaFuncGetParamInfo(func, paramIndex, paramOffset, paramSize) + + +cdef cudaError_t _cudaLaunchHostFunc(cudaStream_t stream, cudaHostFn_t fn, void* userData) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaLaunchHostFunc(stream, fn, userData) + + +cdef cudaError_t _cudaFuncSetSharedMemConfig(const void* func, cudaSharedMemConfig config) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaFuncSetSharedMemConfig(func, config) + + +cdef cudaError_t _cudaOccupancyMaxActiveBlocksPerMultiprocessor(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaOccupancyMaxActiveBlocksPerMultiprocessor(numBlocks, func, blockSize, dynamicSMemSize) + + +cdef cudaError_t _cudaOccupancyAvailableDynamicSMemPerBlock(size_t* dynamicSmemSize, const void* func, int numBlocks, int blockSize) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaOccupancyAvailableDynamicSMemPerBlock(dynamicSmemSize, func, numBlocks, blockSize) + + +cdef cudaError_t _cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(numBlocks, func, blockSize, dynamicSMemSize, flags) + + +cdef cudaError_t _cudaMallocManaged(void** devPtr, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMallocManaged(devPtr, size, flags) + + +cdef cudaError_t _cudaMalloc(void** devPtr, size_t size) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMalloc(devPtr, size) + + +cdef cudaError_t _cudaMallocHost(void** ptr, size_t size) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMallocHost(ptr, size) + + +cdef cudaError_t _cudaMallocPitch(void** devPtr, size_t* pitch, size_t width, size_t height) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMallocPitch(devPtr, pitch, width, height) + + +cdef cudaError_t _cudaMallocArray(cudaArray_t* array, const cudaChannelFormatDesc* desc, size_t width, size_t height, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMallocArray(array, desc, width, height, flags) + + +cdef cudaError_t _cudaFree(void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaFree(devPtr) + + +cdef cudaError_t _cudaFreeHost(void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaFreeHost(ptr) + + +cdef cudaError_t _cudaFreeArray(cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaFreeArray(array) + + +cdef cudaError_t _cudaFreeMipmappedArray(cudaMipmappedArray_t mipmappedArray) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaFreeMipmappedArray(mipmappedArray) + + +cdef cudaError_t _cudaHostAlloc(void** pHost, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaHostAlloc(pHost, size, flags) + + +cdef cudaError_t _cudaHostRegister(void* ptr, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaHostRegister(ptr, size, flags) + + +cdef cudaError_t _cudaHostUnregister(void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaHostUnregister(ptr) + + +cdef cudaError_t _cudaHostGetDevicePointer(void** pDevice, void* pHost, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaHostGetDevicePointer(pDevice, pHost, flags) + + +cdef cudaError_t _cudaHostGetFlags(unsigned int* pFlags, void* pHost) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaHostGetFlags(pFlags, pHost) + + +cdef cudaError_t _cudaMalloc3D(cudaPitchedPtr* pitchedDevPtr, cudaExtent extent) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMalloc3D(pitchedDevPtr, extent) + + +cdef cudaError_t _cudaMalloc3DArray(cudaArray_t* array, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMalloc3DArray(array, desc, extent, flags) + + +cdef cudaError_t _cudaMallocMipmappedArray(cudaMipmappedArray_t* mipmappedArray, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int numLevels, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMallocMipmappedArray(mipmappedArray, desc, extent, numLevels, flags) + + +cdef cudaError_t _cudaGetMipmappedArrayLevel(cudaArray_t* levelArray, cudaMipmappedArray_const_t mipmappedArray, unsigned int level) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGetMipmappedArrayLevel(levelArray, mipmappedArray, level) + + +cdef cudaError_t _cudaMemcpy3D(const cudaMemcpy3DParms* p) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpy3D(p) + + +cdef cudaError_t _cudaMemcpy3DPeer(const cudaMemcpy3DPeerParms* p) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpy3DPeer(p) + + +cdef cudaError_t _cudaMemcpy3DAsync(const cudaMemcpy3DParms* p, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpy3DAsync(p, stream) + + +cdef cudaError_t _cudaMemcpy3DPeerAsync(const cudaMemcpy3DPeerParms* p, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpy3DPeerAsync(p, stream) + + +cdef cudaError_t _cudaMemGetInfo(size_t* free, size_t* total) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemGetInfo(free, total) + + +cdef cudaError_t _cudaArrayGetInfo(cudaChannelFormatDesc* desc, cudaExtent* extent, unsigned int* flags, cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaArrayGetInfo(desc, extent, flags, array) + + +cdef cudaError_t _cudaArrayGetPlane(cudaArray_t* pPlaneArray, cudaArray_t hArray, unsigned int planeIdx) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaArrayGetPlane(pPlaneArray, hArray, planeIdx) + + +cdef cudaError_t _cudaArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaArray_t array, int device) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaArrayGetMemoryRequirements(memoryRequirements, array, device) + + +cdef cudaError_t _cudaMipmappedArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaMipmappedArray_t mipmap, int device) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMipmappedArrayGetMemoryRequirements(memoryRequirements, mipmap, device) + + +cdef cudaError_t _cudaArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaArrayGetSparseProperties(sparseProperties, array) + + +cdef cudaError_t _cudaMipmappedArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaMipmappedArray_t mipmap) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMipmappedArrayGetSparseProperties(sparseProperties, mipmap) + + +cdef cudaError_t _cudaMemcpy(void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpy(dst, src, count, kind) + + +cdef cudaError_t _cudaMemcpyPeer(void* dst, int dstDevice, const void* src, int srcDevice, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpyPeer(dst, dstDevice, src, srcDevice, count) + + +cdef cudaError_t _cudaMemcpy2D(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpy2D(dst, dpitch, src, spitch, width, height, kind) + + +cdef cudaError_t _cudaMemcpy2DToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpy2DToArray(dst, wOffset, hOffset, src, spitch, width, height, kind) + + +cdef cudaError_t _cudaMemcpy2DFromArray(void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpy2DFromArray(dst, dpitch, src, wOffset, hOffset, width, height, kind) + + +cdef cudaError_t _cudaMemcpy2DArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpy2DArrayToArray(dst, wOffsetDst, hOffsetDst, src, wOffsetSrc, hOffsetSrc, width, height, kind) + + +cdef cudaError_t _cudaMemcpyAsync(void* dst, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpyAsync(dst, src, count, kind, stream) + + +cdef cudaError_t _cudaMemcpyPeerAsync(void* dst, int dstDevice, const void* src, int srcDevice, size_t count, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpyPeerAsync(dst, dstDevice, src, srcDevice, count, stream) + + +cdef cudaError_t _cudaMemcpyBatchAsync(const void** dsts, const void** srcs, const size_t* sizes, size_t count, cudaMemcpyAttributes* attrs, size_t* attrsIdxs, size_t numAttrs, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpyBatchAsync(dsts, srcs, sizes, count, attrs, attrsIdxs, numAttrs, stream) + + +cdef cudaError_t _cudaMemcpy3DBatchAsync(size_t numOps, cudaMemcpy3DBatchOp* opList, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpy3DBatchAsync(numOps, opList, flags, stream) + + +cdef cudaError_t _cudaMemcpy2DAsync(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpy2DAsync(dst, dpitch, src, spitch, width, height, kind, stream) + + +cdef cudaError_t _cudaMemcpy2DToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpy2DToArrayAsync(dst, wOffset, hOffset, src, spitch, width, height, kind, stream) + + +cdef cudaError_t _cudaMemcpy2DFromArrayAsync(void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpy2DFromArrayAsync(dst, dpitch, src, wOffset, hOffset, width, height, kind, stream) + + +cdef cudaError_t _cudaMemset(void* devPtr, int value, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemset(devPtr, value, count) + + +cdef cudaError_t _cudaMemset2D(void* devPtr, size_t pitch, int value, size_t width, size_t height) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemset2D(devPtr, pitch, value, width, height) + + +cdef cudaError_t _cudaMemset3D(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemset3D(pitchedDevPtr, value, extent) + + +cdef cudaError_t _cudaMemsetAsync(void* devPtr, int value, size_t count, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemsetAsync(devPtr, value, count, stream) + + +cdef cudaError_t _cudaMemset2DAsync(void* devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemset2DAsync(devPtr, pitch, value, width, height, stream) + + +cdef cudaError_t _cudaMemset3DAsync(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemset3DAsync(pitchedDevPtr, value, extent, stream) + + +cdef cudaError_t _cudaMemPrefetchAsync(const void* devPtr, size_t count, cudaMemLocation location, unsigned int flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemPrefetchAsync(devPtr, count, location, flags, stream) + + +cdef cudaError_t _cudaMemAdvise(const void* devPtr, size_t count, cudaMemoryAdvise advice, cudaMemLocation location) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemAdvise(devPtr, count, advice, location) + + +cdef cudaError_t _cudaMemRangeGetAttribute(void* data, size_t dataSize, cudaMemRangeAttribute attribute, const void* devPtr, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemRangeGetAttribute(data, dataSize, attribute, devPtr, count) + + +cdef cudaError_t _cudaMemRangeGetAttributes(void** data, size_t* dataSizes, cudaMemRangeAttribute* attributes, size_t numAttributes, const void* devPtr, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemRangeGetAttributes(data, dataSizes, attributes, numAttributes, devPtr, count) + + +cdef cudaError_t _cudaMemcpyToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpyToArray(dst, wOffset, hOffset, src, count, kind) + + +cdef cudaError_t _cudaMemcpyFromArray(void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpyFromArray(dst, src, wOffset, hOffset, count, kind) + + +cdef cudaError_t _cudaMemcpyArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpyArrayToArray(dst, wOffsetDst, hOffsetDst, src, wOffsetSrc, hOffsetSrc, count, kind) + + +cdef cudaError_t _cudaMemcpyToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpyToArrayAsync(dst, wOffset, hOffset, src, count, kind, stream) + + +cdef cudaError_t _cudaMemcpyFromArrayAsync(void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpyFromArrayAsync(dst, src, wOffset, hOffset, count, kind, stream) + + +cdef cudaError_t _cudaMallocAsync(void** devPtr, size_t size, cudaStream_t hStream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMallocAsync(devPtr, size, hStream) + + +cdef cudaError_t _cudaFreeAsync(void* devPtr, cudaStream_t hStream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaFreeAsync(devPtr, hStream) + + +cdef cudaError_t _cudaMemPoolTrimTo(cudaMemPool_t memPool, size_t minBytesToKeep) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemPoolTrimTo(memPool, minBytesToKeep) + + +cdef cudaError_t _cudaMemPoolSetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemPoolSetAttribute(memPool, attr, value) + + +cdef cudaError_t _cudaMemPoolGetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemPoolGetAttribute(memPool, attr, value) + + +cdef cudaError_t _cudaMemPoolSetAccess(cudaMemPool_t memPool, const cudaMemAccessDesc* descList, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemPoolSetAccess(memPool, descList, count) + + +cdef cudaError_t _cudaMemPoolGetAccess(cudaMemAccessFlags* flags, cudaMemPool_t memPool, cudaMemLocation* location) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemPoolGetAccess(flags, memPool, location) + + +cdef cudaError_t _cudaMemPoolCreate(cudaMemPool_t* memPool, const cudaMemPoolProps* poolProps) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemPoolCreate(memPool, poolProps) + + +cdef cudaError_t _cudaMemPoolDestroy(cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemPoolDestroy(memPool) + + +cdef cudaError_t _cudaMallocFromPoolAsync(void** ptr, size_t size, cudaMemPool_t memPool, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMallocFromPoolAsync(ptr, size, memPool, stream) + + +cdef cudaError_t _cudaMemPoolExportToShareableHandle(void* shareableHandle, cudaMemPool_t memPool, cudaMemAllocationHandleType handleType, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemPoolExportToShareableHandle(shareableHandle, memPool, handleType, flags) + + +cdef cudaError_t _cudaMemPoolImportFromShareableHandle(cudaMemPool_t* memPool, void* shareableHandle, cudaMemAllocationHandleType handleType, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemPoolImportFromShareableHandle(memPool, shareableHandle, handleType, flags) + + +cdef cudaError_t _cudaMemPoolExportPointer(cudaMemPoolPtrExportData* exportData, void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemPoolExportPointer(exportData, ptr) + + +cdef cudaError_t _cudaMemPoolImportPointer(void** ptr, cudaMemPool_t memPool, cudaMemPoolPtrExportData* exportData) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemPoolImportPointer(ptr, memPool, exportData) + + +cdef cudaError_t _cudaPointerGetAttributes(cudaPointerAttributes* attributes, const void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaPointerGetAttributes(attributes, ptr) + + +cdef cudaError_t _cudaDeviceCanAccessPeer(int* canAccessPeer, int device, int peerDevice) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceCanAccessPeer(canAccessPeer, device, peerDevice) + + +cdef cudaError_t _cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceEnablePeerAccess(peerDevice, flags) + + +cdef cudaError_t _cudaDeviceDisablePeerAccess(int peerDevice) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceDisablePeerAccess(peerDevice) + + +cdef cudaError_t _cudaGraphicsUnregisterResource(cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphicsUnregisterResource(resource) + + +cdef cudaError_t _cudaGraphicsResourceSetMapFlags(cudaGraphicsResource_t resource, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphicsResourceSetMapFlags(resource, flags) + + +cdef cudaError_t _cudaGraphicsMapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphicsMapResources(count, resources, stream) + + +cdef cudaError_t _cudaGraphicsUnmapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphicsUnmapResources(count, resources, stream) + + +cdef cudaError_t _cudaGraphicsResourceGetMappedPointer(void** devPtr, size_t* size, cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphicsResourceGetMappedPointer(devPtr, size, resource) + + +cdef cudaError_t _cudaGraphicsSubResourceGetMappedArray(cudaArray_t* array, cudaGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphicsSubResourceGetMappedArray(array, resource, arrayIndex, mipLevel) + + +cdef cudaError_t _cudaGraphicsResourceGetMappedMipmappedArray(cudaMipmappedArray_t* mipmappedArray, cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphicsResourceGetMappedMipmappedArray(mipmappedArray, resource) + + +cdef cudaError_t _cudaGetChannelDesc(cudaChannelFormatDesc* desc, cudaArray_const_t array) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGetChannelDesc(desc, array) + + +cdef cudaChannelFormatDesc _cudaCreateChannelDesc(int x, int y, int z, int w, cudaChannelFormatKind f) except* nogil: + return _static_cudaCreateChannelDesc(x, y, z, w, f) + + +cdef cudaError_t _cudaCreateTextureObject(cudaTextureObject_t* pTexObject, const cudaResourceDesc* pResDesc, const cudaTextureDesc* pTexDesc, const cudaResourceViewDesc* pResViewDesc) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaCreateTextureObject(pTexObject, pResDesc, pTexDesc, pResViewDesc) + + +cdef cudaError_t _cudaDestroyTextureObject(cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDestroyTextureObject(texObject) + + +cdef cudaError_t _cudaGetTextureObjectResourceDesc(cudaResourceDesc* pResDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGetTextureObjectResourceDesc(pResDesc, texObject) + + +cdef cudaError_t _cudaGetTextureObjectTextureDesc(cudaTextureDesc* pTexDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGetTextureObjectTextureDesc(pTexDesc, texObject) + + +cdef cudaError_t _cudaGetTextureObjectResourceViewDesc(cudaResourceViewDesc* pResViewDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGetTextureObjectResourceViewDesc(pResViewDesc, texObject) + + +cdef cudaError_t _cudaCreateSurfaceObject(cudaSurfaceObject_t* pSurfObject, const cudaResourceDesc* pResDesc) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaCreateSurfaceObject(pSurfObject, pResDesc) + + +cdef cudaError_t _cudaDestroySurfaceObject(cudaSurfaceObject_t surfObject) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDestroySurfaceObject(surfObject) + + +cdef cudaError_t _cudaGetSurfaceObjectResourceDesc(cudaResourceDesc* pResDesc, cudaSurfaceObject_t surfObject) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGetSurfaceObjectResourceDesc(pResDesc, surfObject) + + +cdef cudaError_t _cudaDriverGetVersion(int* driverVersion) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDriverGetVersion(driverVersion) + + +cdef cudaError_t _cudaRuntimeGetVersion(int* runtimeVersion) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaRuntimeGetVersion(runtimeVersion) + + +cdef cudaError_t _cudaGraphCreate(cudaGraph_t* pGraph, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphCreate(pGraph, flags) + + +cdef cudaError_t _cudaGraphAddKernelNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphAddKernelNode(pGraphNode, graph, pDependencies, numDependencies, pNodeParams) + + +cdef cudaError_t _cudaGraphKernelNodeGetParams(cudaGraphNode_t node, cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphKernelNodeGetParams(node, pNodeParams) + + +cdef cudaError_t _cudaGraphKernelNodeSetParams(cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphKernelNodeSetParams(node, pNodeParams) + + +cdef cudaError_t _cudaGraphKernelNodeCopyAttributes(cudaGraphNode_t hDst, cudaGraphNode_t hSrc) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphKernelNodeCopyAttributes(hDst, hSrc) + + +cdef cudaError_t _cudaGraphKernelNodeGetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, cudaKernelNodeAttrValue* value_out) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphKernelNodeGetAttribute(hNode, attr, value_out) + + +cdef cudaError_t _cudaGraphKernelNodeSetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, const cudaKernelNodeAttrValue* value) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphKernelNodeSetAttribute(hNode, attr, value) + + +cdef cudaError_t _cudaGraphAddMemcpyNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemcpy3DParms* pCopyParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphAddMemcpyNode(pGraphNode, graph, pDependencies, numDependencies, pCopyParams) + + +cdef cudaError_t _cudaGraphAddMemcpyNode1D(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphAddMemcpyNode1D(pGraphNode, graph, pDependencies, numDependencies, dst, src, count, kind) + + +cdef cudaError_t _cudaGraphMemcpyNodeGetParams(cudaGraphNode_t node, cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphMemcpyNodeGetParams(node, pNodeParams) + + +cdef cudaError_t _cudaGraphMemcpyNodeSetParams(cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphMemcpyNodeSetParams(node, pNodeParams) + + +cdef cudaError_t _cudaGraphMemcpyNodeSetParams1D(cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphMemcpyNodeSetParams1D(node, dst, src, count, kind) + + +cdef cudaError_t _cudaGraphAddMemsetNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemsetParams* pMemsetParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphAddMemsetNode(pGraphNode, graph, pDependencies, numDependencies, pMemsetParams) + + +cdef cudaError_t _cudaGraphMemsetNodeGetParams(cudaGraphNode_t node, cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphMemsetNodeGetParams(node, pNodeParams) + + +cdef cudaError_t _cudaGraphMemsetNodeSetParams(cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphMemsetNodeSetParams(node, pNodeParams) + + +cdef cudaError_t _cudaGraphAddHostNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphAddHostNode(pGraphNode, graph, pDependencies, numDependencies, pNodeParams) + + +cdef cudaError_t _cudaGraphHostNodeGetParams(cudaGraphNode_t node, cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphHostNodeGetParams(node, pNodeParams) + + +cdef cudaError_t _cudaGraphHostNodeSetParams(cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphHostNodeSetParams(node, pNodeParams) + + +cdef cudaError_t _cudaGraphAddChildGraphNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaGraph_t childGraph) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphAddChildGraphNode(pGraphNode, graph, pDependencies, numDependencies, childGraph) + + +cdef cudaError_t _cudaGraphChildGraphNodeGetGraph(cudaGraphNode_t node, cudaGraph_t* pGraph) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphChildGraphNodeGetGraph(node, pGraph) + + +cdef cudaError_t _cudaGraphAddEmptyNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphAddEmptyNode(pGraphNode, graph, pDependencies, numDependencies) + + +cdef cudaError_t _cudaGraphAddEventRecordNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphAddEventRecordNode(pGraphNode, graph, pDependencies, numDependencies, event) + + +cdef cudaError_t _cudaGraphEventRecordNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphEventRecordNodeGetEvent(node, event_out) + + +cdef cudaError_t _cudaGraphEventRecordNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphEventRecordNodeSetEvent(node, event) + + +cdef cudaError_t _cudaGraphAddEventWaitNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphAddEventWaitNode(pGraphNode, graph, pDependencies, numDependencies, event) + + +cdef cudaError_t _cudaGraphEventWaitNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphEventWaitNodeGetEvent(node, event_out) + + +cdef cudaError_t _cudaGraphEventWaitNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphEventWaitNodeSetEvent(node, event) + + +cdef cudaError_t _cudaGraphAddExternalSemaphoresSignalNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphAddExternalSemaphoresSignalNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams) + + +cdef cudaError_t _cudaGraphExternalSemaphoresSignalNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreSignalNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphExternalSemaphoresSignalNodeGetParams(hNode, params_out) + + +cdef cudaError_t _cudaGraphExternalSemaphoresSignalNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphExternalSemaphoresSignalNodeSetParams(hNode, nodeParams) + + +cdef cudaError_t _cudaGraphAddExternalSemaphoresWaitNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphAddExternalSemaphoresWaitNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams) + + +cdef cudaError_t _cudaGraphExternalSemaphoresWaitNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreWaitNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphExternalSemaphoresWaitNodeGetParams(hNode, params_out) + + +cdef cudaError_t _cudaGraphExternalSemaphoresWaitNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphExternalSemaphoresWaitNodeSetParams(hNode, nodeParams) + + +cdef cudaError_t _cudaGraphAddMemAllocNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaMemAllocNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphAddMemAllocNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams) + + +cdef cudaError_t _cudaGraphMemAllocNodeGetParams(cudaGraphNode_t node, cudaMemAllocNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphMemAllocNodeGetParams(node, params_out) + + +cdef cudaError_t _cudaGraphAddMemFreeNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dptr) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphAddMemFreeNode(pGraphNode, graph, pDependencies, numDependencies, dptr) + + +cdef cudaError_t _cudaGraphMemFreeNodeGetParams(cudaGraphNode_t node, void* dptr_out) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphMemFreeNodeGetParams(node, dptr_out) + + +cdef cudaError_t _cudaDeviceGraphMemTrim(int device) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceGraphMemTrim(device) + + +cdef cudaError_t _cudaDeviceGetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceGetGraphMemAttribute(device, attr, value) + + +cdef cudaError_t _cudaDeviceSetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceSetGraphMemAttribute(device, attr, value) + + +cdef cudaError_t _cudaGraphClone(cudaGraph_t* pGraphClone, cudaGraph_t originalGraph) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphClone(pGraphClone, originalGraph) + + +cdef cudaError_t _cudaGraphNodeFindInClone(cudaGraphNode_t* pNode, cudaGraphNode_t originalNode, cudaGraph_t clonedGraph) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphNodeFindInClone(pNode, originalNode, clonedGraph) + + +cdef cudaError_t _cudaGraphNodeGetType(cudaGraphNode_t node, cudaGraphNodeType* pType) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphNodeGetType(node, pType) + + +cdef cudaError_t _cudaGraphGetNodes(cudaGraph_t graph, cudaGraphNode_t* nodes, size_t* numNodes) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphGetNodes(graph, nodes, numNodes) + + +cdef cudaError_t _cudaGraphGetRootNodes(cudaGraph_t graph, cudaGraphNode_t* pRootNodes, size_t* pNumRootNodes) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphGetRootNodes(graph, pRootNodes, pNumRootNodes) + + +cdef cudaError_t _cudaGraphGetEdges(cudaGraph_t graph, cudaGraphNode_t* from_, cudaGraphNode_t* to, cudaGraphEdgeData* edgeData, size_t* numEdges) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphGetEdges(graph, from_, to, edgeData, numEdges) + + +cdef cudaError_t _cudaGraphNodeGetDependencies(cudaGraphNode_t node, cudaGraphNode_t* pDependencies, cudaGraphEdgeData* edgeData, size_t* pNumDependencies) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphNodeGetDependencies(node, pDependencies, edgeData, pNumDependencies) + + +cdef cudaError_t _cudaGraphNodeGetDependentNodes(cudaGraphNode_t node, cudaGraphNode_t* pDependentNodes, cudaGraphEdgeData* edgeData, size_t* pNumDependentNodes) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphNodeGetDependentNodes(node, pDependentNodes, edgeData, pNumDependentNodes) + + +cdef cudaError_t _cudaGraphAddDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, const cudaGraphEdgeData* edgeData, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphAddDependencies(graph, from_, to, edgeData, numDependencies) + + +cdef cudaError_t _cudaGraphRemoveDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, const cudaGraphEdgeData* edgeData, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphRemoveDependencies(graph, from_, to, edgeData, numDependencies) + + +cdef cudaError_t _cudaGraphDestroyNode(cudaGraphNode_t node) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphDestroyNode(node) + + +cdef cudaError_t _cudaGraphInstantiate(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphInstantiate(pGraphExec, graph, flags) + + +cdef cudaError_t _cudaGraphInstantiateWithFlags(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphInstantiateWithFlags(pGraphExec, graph, flags) + + +cdef cudaError_t _cudaGraphInstantiateWithParams(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, cudaGraphInstantiateParams* instantiateParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphInstantiateWithParams(pGraphExec, graph, instantiateParams) + + +cdef cudaError_t _cudaGraphExecGetFlags(cudaGraphExec_t graphExec, unsigned long long* flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphExecGetFlags(graphExec, flags) + + +cdef cudaError_t _cudaGraphExecKernelNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphExecKernelNodeSetParams(hGraphExec, node, pNodeParams) + + +cdef cudaError_t _cudaGraphExecMemcpyNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphExecMemcpyNodeSetParams(hGraphExec, node, pNodeParams) + + +cdef cudaError_t _cudaGraphExecMemcpyNodeSetParams1D(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphExecMemcpyNodeSetParams1D(hGraphExec, node, dst, src, count, kind) + + +cdef cudaError_t _cudaGraphExecMemsetNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphExecMemsetNodeSetParams(hGraphExec, node, pNodeParams) + + +cdef cudaError_t _cudaGraphExecHostNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphExecHostNodeSetParams(hGraphExec, node, pNodeParams) + + +cdef cudaError_t _cudaGraphExecChildGraphNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, cudaGraph_t childGraph) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphExecChildGraphNodeSetParams(hGraphExec, node, childGraph) + + +cdef cudaError_t _cudaGraphExecEventRecordNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphExecEventRecordNodeSetEvent(hGraphExec, hNode, event) + + +cdef cudaError_t _cudaGraphExecEventWaitNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphExecEventWaitNodeSetEvent(hGraphExec, hNode, event) + + +cdef cudaError_t _cudaGraphExecExternalSemaphoresSignalNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphExecExternalSemaphoresSignalNodeSetParams(hGraphExec, hNode, nodeParams) + + +cdef cudaError_t _cudaGraphExecExternalSemaphoresWaitNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphExecExternalSemaphoresWaitNodeSetParams(hGraphExec, hNode, nodeParams) + + +cdef cudaError_t _cudaGraphNodeSetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int isEnabled) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphNodeSetEnabled(hGraphExec, hNode, isEnabled) + + +cdef cudaError_t _cudaGraphNodeGetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int* isEnabled) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphNodeGetEnabled(hGraphExec, hNode, isEnabled) + + +cdef cudaError_t _cudaGraphExecUpdate(cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphExecUpdateResultInfo* resultInfo) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphExecUpdate(hGraphExec, hGraph, resultInfo) + + +cdef cudaError_t _cudaGraphUpload(cudaGraphExec_t graphExec, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphUpload(graphExec, stream) + + +cdef cudaError_t _cudaGraphLaunch(cudaGraphExec_t graphExec, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphLaunch(graphExec, stream) + + +cdef cudaError_t _cudaGraphExecDestroy(cudaGraphExec_t graphExec) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphExecDestroy(graphExec) + + +cdef cudaError_t _cudaGraphDestroy(cudaGraph_t graph) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphDestroy(graph) + + +cdef cudaError_t _cudaGraphDebugDotPrint(cudaGraph_t graph, const char* path, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphDebugDotPrint(graph, path, flags) + + +cdef cudaError_t _cudaUserObjectCreate(cudaUserObject_t* object_out, void* ptr, cudaHostFn_t destroy, unsigned int initialRefcount, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaUserObjectCreate(object_out, ptr, destroy, initialRefcount, flags) + + +cdef cudaError_t _cudaUserObjectRetain(cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaUserObjectRetain(object, count) + + +cdef cudaError_t _cudaUserObjectRelease(cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaUserObjectRelease(object, count) + + +cdef cudaError_t _cudaGraphRetainUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphRetainUserObject(graph, object, count, flags) + + +cdef cudaError_t _cudaGraphReleaseUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphReleaseUserObject(graph, object, count) + + +cdef cudaError_t _cudaGraphAddNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphAddNode(pGraphNode, graph, pDependencies, dependencyData, numDependencies, nodeParams) + + +cdef cudaError_t _cudaGraphNodeSetParams(cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphNodeSetParams(node, nodeParams) + + +cdef cudaError_t _cudaGraphExecNodeSetParams(cudaGraphExec_t graphExec, cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphExecNodeSetParams(graphExec, node, nodeParams) + + +cdef cudaError_t _cudaGraphConditionalHandleCreate(cudaGraphConditionalHandle* pHandle_out, cudaGraph_t graph, unsigned int defaultLaunchValue, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphConditionalHandleCreate(pHandle_out, graph, defaultLaunchValue, flags) + + +cdef cudaError_t _cudaGetDriverEntryPoint(const char* symbol, void** funcPtr, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGetDriverEntryPoint(symbol, funcPtr, flags, driverStatus) + + +cdef cudaError_t _cudaGetDriverEntryPointByVersion(const char* symbol, void** funcPtr, unsigned int cudaVersion, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGetDriverEntryPointByVersion(symbol, funcPtr, cudaVersion, flags, driverStatus) + + +cdef cudaError_t _cudaLibraryLoadData(cudaLibrary_t* library, const void* code, cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaLibraryLoadData(library, code, jitOptions, jitOptionsValues, numJitOptions, libraryOptions, libraryOptionValues, numLibraryOptions) + + +cdef cudaError_t _cudaLibraryLoadFromFile(cudaLibrary_t* library, const char* fileName, cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaLibraryLoadFromFile(library, fileName, jitOptions, jitOptionsValues, numJitOptions, libraryOptions, libraryOptionValues, numLibraryOptions) + + +cdef cudaError_t _cudaLibraryUnload(cudaLibrary_t library) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaLibraryUnload(library) + + +cdef cudaError_t _cudaLibraryGetKernel(cudaKernel_t* pKernel, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaLibraryGetKernel(pKernel, library, name) + + +cdef cudaError_t _cudaLibraryGetGlobal(void** dptr, size_t* bytes, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaLibraryGetGlobal(dptr, bytes, library, name) + + +cdef cudaError_t _cudaLibraryGetManaged(void** dptr, size_t* bytes, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaLibraryGetManaged(dptr, bytes, library, name) + + +cdef cudaError_t _cudaLibraryGetUnifiedFunction(void** fptr, cudaLibrary_t library, const char* symbol) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaLibraryGetUnifiedFunction(fptr, library, symbol) + + +cdef cudaError_t _cudaLibraryGetKernelCount(unsigned int* count, cudaLibrary_t lib) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaLibraryGetKernelCount(count, lib) + + +cdef cudaError_t _cudaLibraryEnumerateKernels(cudaKernel_t* kernels, unsigned int numKernels, cudaLibrary_t lib) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaLibraryEnumerateKernels(kernels, numKernels, lib) + + +cdef cudaError_t _cudaKernelSetAttributeForDevice(cudaKernel_t kernel, cudaFuncAttribute attr, int value, int device) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaKernelSetAttributeForDevice(kernel, attr, value, device) + + +cdef cudaError_t _cudaGetExportTable(const void** ppExportTable, const cudaUUID_t* pExportTableId) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGetExportTable(ppExportTable, pExportTableId) + + +cdef cudaError_t _cudaGetKernel(cudaKernel_t* kernelPtr, const void* entryFuncAddr) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGetKernel(kernelPtr, entryFuncAddr) + + +cdef cudaError_t _cudaProfilerStart() except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaProfilerStart() + + +cdef cudaError_t _cudaProfilerStop() except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaProfilerStop() + + +cdef cudaError_t _cudaGetDeviceProperties(cudaDeviceProp* prop, int device) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGetDeviceProperties(prop, device) + + +cdef cudaError_t _cudaDeviceGetHostAtomicCapabilities(unsigned int* capabilities, const cudaAtomicOperation* operations, unsigned int count, int device) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceGetHostAtomicCapabilities(capabilities, operations, count, device) + + +cdef cudaError_t _cudaDeviceGetP2PAtomicCapabilities(unsigned int* capabilities, const cudaAtomicOperation* operations, unsigned int count, int srcDevice, int dstDevice) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceGetP2PAtomicCapabilities(capabilities, operations, count, srcDevice, dstDevice) + + +cdef cudaError_t _cudaStreamGetCaptureInfo(cudaStream_t stream, cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out, cudaGraph_t* graph_out, const cudaGraphNode_t** dependencies_out, const cudaGraphEdgeData** edgeData_out, size_t* numDependencies_out) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamGetCaptureInfo(stream, captureStatus_out, id_out, graph_out, dependencies_out, edgeData_out, numDependencies_out) + + +cdef cudaError_t _cudaSignalExternalSemaphoresAsync(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreSignalParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaSignalExternalSemaphoresAsync(extSemArray, paramsArray, numExtSems, stream) + + +cdef cudaError_t _cudaWaitExternalSemaphoresAsync(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreWaitParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaWaitExternalSemaphoresAsync(extSemArray, paramsArray, numExtSems, stream) + + +cdef cudaError_t _cudaMemPrefetchBatchAsync(void** dptrs, size_t* sizes, size_t count, cudaMemLocation* prefetchLocs, size_t* prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemPrefetchBatchAsync(dptrs, sizes, count, prefetchLocs, prefetchLocIdxs, numPrefetchLocs, flags, stream) + + +cdef cudaError_t _cudaMemDiscardBatchAsync(void** dptrs, size_t* sizes, size_t count, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemDiscardBatchAsync(dptrs, sizes, count, flags, stream) + + +cdef cudaError_t _cudaMemDiscardAndPrefetchBatchAsync(void** dptrs, size_t* sizes, size_t count, cudaMemLocation* prefetchLocs, size_t* prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemDiscardAndPrefetchBatchAsync(dptrs, sizes, count, prefetchLocs, prefetchLocIdxs, numPrefetchLocs, flags, stream) + + +cdef cudaError_t _cudaMemGetDefaultMemPool(cudaMemPool_t* memPool, cudaMemLocation* location, cudaMemAllocationType type) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemGetDefaultMemPool(memPool, location, type) + + +cdef cudaError_t _cudaMemGetMemPool(cudaMemPool_t* memPool, cudaMemLocation* location, cudaMemAllocationType type) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemGetMemPool(memPool, location, type) + + +cdef cudaError_t _cudaMemSetMemPool(cudaMemLocation* location, cudaMemAllocationType type, cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemSetMemPool(location, type, memPool) + + +cdef cudaError_t _cudaLogsRegisterCallback(cudaLogsCallback_t callbackFunc, void* userData, cudaLogsCallbackHandle* callback_out) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaLogsRegisterCallback(callbackFunc, userData, callback_out) + + +cdef cudaError_t _cudaLogsUnregisterCallback(cudaLogsCallbackHandle callback) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaLogsUnregisterCallback(callback) + + +cdef cudaError_t _cudaLogsCurrent(cudaLogIterator* iterator_out, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaLogsCurrent(iterator_out, flags) + + +cdef cudaError_t _cudaLogsDumpToFile(cudaLogIterator* iterator, const char* pathToFile, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaLogsDumpToFile(iterator, pathToFile, flags) + + +cdef cudaError_t _cudaLogsDumpToMemory(cudaLogIterator* iterator, char* buffer, size_t* size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaLogsDumpToMemory(iterator, buffer, size, flags) + + +cdef cudaError_t _cudaGraphNodeGetContainingGraph(cudaGraphNode_t hNode, cudaGraph_t* phGraph) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphNodeGetContainingGraph(hNode, phGraph) + + +cdef cudaError_t _cudaGraphNodeGetLocalId(cudaGraphNode_t hNode, unsigned int* nodeId) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphNodeGetLocalId(hNode, nodeId) + + +cdef cudaError_t _cudaGraphNodeGetToolsId(cudaGraphNode_t hNode, unsigned long long* toolsNodeId) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphNodeGetToolsId(hNode, toolsNodeId) + + +cdef cudaError_t _cudaGraphGetId(cudaGraph_t hGraph, unsigned int* graphID) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphGetId(hGraph, graphID) + + +cdef cudaError_t _cudaGraphExecGetId(cudaGraphExec_t hGraphExec, unsigned int* graphID) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphExecGetId(hGraphExec, graphID) + + +cdef cudaError_t _cudaGraphConditionalHandleCreate_v2(cudaGraphConditionalHandle* pHandle_out, cudaGraph_t graph, cudaExecutionContext_t ctx, unsigned int defaultLaunchValue, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphConditionalHandleCreate_v2(pHandle_out, graph, ctx, defaultLaunchValue, flags) + + +cdef cudaError_t _cudaDeviceGetDevResource(int device, cudaDevResource* resource, cudaDevResourceType type) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceGetDevResource(device, resource, type) + + +cdef cudaError_t _cudaDevSmResourceSplitByCount(cudaDevResource* result, unsigned int* nbGroups, const cudaDevResource* input, cudaDevResource* remaining, unsigned int flags, unsigned int minCount) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDevSmResourceSplitByCount(result, nbGroups, input, remaining, flags, minCount) + + +cdef cudaError_t _cudaDevSmResourceSplit(cudaDevResource* result, unsigned int nbGroups, const cudaDevResource* input, cudaDevResource* remainder, unsigned int flags, cudaDevSmResourceGroupParams* groupParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDevSmResourceSplit(result, nbGroups, input, remainder, flags, groupParams) + + +cdef cudaError_t _cudaDevResourceGenerateDesc(cudaDevResourceDesc_t* phDesc, cudaDevResource* resources, unsigned int nbResources) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDevResourceGenerateDesc(phDesc, resources, nbResources) + + +cdef cudaError_t _cudaGreenCtxCreate(cudaExecutionContext_t* phCtx, cudaDevResourceDesc_t desc, int device, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGreenCtxCreate(phCtx, desc, device, flags) + + +cdef cudaError_t _cudaExecutionCtxDestroy(cudaExecutionContext_t ctx) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaExecutionCtxDestroy(ctx) + + +cdef cudaError_t _cudaExecutionCtxGetDevResource(cudaExecutionContext_t ctx, cudaDevResource* resource, cudaDevResourceType type) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaExecutionCtxGetDevResource(ctx, resource, type) + + +cdef cudaError_t _cudaExecutionCtxGetDevice(int* device, cudaExecutionContext_t ctx) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaExecutionCtxGetDevice(device, ctx) + + +cdef cudaError_t _cudaExecutionCtxGetId(cudaExecutionContext_t ctx, unsigned long long* ctxId) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaExecutionCtxGetId(ctx, ctxId) + + +cdef cudaError_t _cudaExecutionCtxStreamCreate(cudaStream_t* phStream, cudaExecutionContext_t ctx, unsigned int flags, int priority) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaExecutionCtxStreamCreate(phStream, ctx, flags, priority) + + +cdef cudaError_t _cudaExecutionCtxSynchronize(cudaExecutionContext_t ctx) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaExecutionCtxSynchronize(ctx) + + +cdef cudaError_t _cudaStreamGetDevResource(cudaStream_t hStream, cudaDevResource* resource, cudaDevResourceType type) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamGetDevResource(hStream, resource, type) + + +cdef cudaError_t _cudaExecutionCtxRecordEvent(cudaExecutionContext_t ctx, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaExecutionCtxRecordEvent(ctx, event) + + +cdef cudaError_t _cudaExecutionCtxWaitEvent(cudaExecutionContext_t ctx, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaExecutionCtxWaitEvent(ctx, event) + + +cdef cudaError_t _cudaDeviceGetExecutionCtx(cudaExecutionContext_t* ctx, int device) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaDeviceGetExecutionCtx(ctx, device) + + +cdef cudaError_t _cudaFuncGetParamCount(const void* func, size_t* paramCount) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaFuncGetParamCount(func, paramCount) + + +cdef cudaError_t _cudaLaunchHostFunc_v2(cudaStream_t stream, cudaHostFn_t fn, void* userData, unsigned int syncMode) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaLaunchHostFunc_v2(stream, fn, userData, syncMode) + + +cdef cudaError_t _cudaMemcpyWithAttributesAsync(void* dst, const void* src, size_t size, cudaMemcpyAttributes* attr, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpyWithAttributesAsync(dst, src, size, attr, stream) + + +cdef cudaError_t _cudaMemcpy3DWithAttributesAsync(cudaMemcpy3DBatchOp* op, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaMemcpy3DWithAttributesAsync(op, flags, stream) + + +cdef cudaError_t _cudaGraphNodeGetParams(cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaGraphNodeGetParams(node, nodeParams) + + +cdef cudaError_t _cudaStreamBeginRecaptureToGraph(cudaStream_t stream, cudaStreamCaptureMode mode, cudaGraph_t graph, cudaGraphRecaptureCallbackData* callbackData) except ?cudaErrorCallRequiresNewerDriver nogil: + return _static_cudaStreamBeginRecaptureToGraph(stream, mode, graph, callbackData) diff --git a/cuda_bindings/cuda/bindings/_bindings/cyruntime.pyx.in b/cuda_bindings/cuda/bindings/_internal/runtime_windows.pyx similarity index 50% rename from cuda_bindings/cuda/bindings/_bindings/cyruntime.pyx.in rename to cuda_bindings/cuda/bindings/_internal/runtime_windows.pyx index 58388d3dd92..f848344f483 100644 --- a/cuda_bindings/cuda/bindings/_bindings/cyruntime.pyx.in +++ b/cuda_bindings/cuda/bindings/_internal/runtime_windows.pyx @@ -1,2920 +1,3276 @@ # SPDX-FileCopyrightText: Copyright (c) 2021-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# # SPDX-License-Identifier: Apache-2.0 +# +# This code was automatically generated across versions from 12.9.0 to 13.3.0. Do not modify it directly. -# This code was automatically generated with version 13.3.0. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=ccadd478eafb421b735d8fc0c44e1c03e873885646a81381f1d995bd573b5120 -include "../cyruntime_functions.pxi" - +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=5f0e930fd8c13f49036a66fc40729a3270cc44d8b16234b1387b93e51f0e0a0f import os -cimport cuda.bindings._bindings.cyruntime_ptds as ptds + +from libc.stdint cimport uintptr_t + +from cuda.pathfinder import load_nvidia_dynamic_lib +cimport cuda.bindings._lib.windll as windll +cimport cuda.bindings._internal.runtime_ptds as ptds cimport cython + +############################################################################### +# Per-thread default stream dispatch +############################################################################### + cdef bint __cudaPythonInit = False cdef bint __usePTDS = False -cdef int _cudaPythonInit() except -1 nogil: - global __cudaPythonInit - global __usePTDS - with gil: - __usePTDS = bool(int(os.getenv('CUDA_PYTHON_CUDA_PER_THREAD_DEFAULT_STREAM', default=0))) - __cudaPythonInit = True - return __usePTDS +cdef int _cudaPythonInit() except -1 nogil: + global __cudaPythonInit + global __usePTDS + with gil: + __usePTDS = bool(int(os.getenv('CUDA_PYTHON_CUDA_PER_THREAD_DEFAULT_STREAM', default=0))) + __cudaPythonInit = True + return __usePTDS -# Create a very small function to check whether we are init'ed, so the C -# compiler can inline it. cdef inline int cudaPythonInit() except -1 nogil: if __cudaPythonInit: return __usePTDS return _cudaPythonInit() -{{if 'cudaDeviceReset' in found_functions}} + +############################################################################### +# EGL/GL/VDPAU helpers (implementations delegating to driver EGL/VDPAU/GL APIs) +############################################################################### + +include "../_lib/cyruntime/cyruntime.pxi" + + +############################################################################### +# getLocalRuntimeVersion — dynamically loads cudart to read its own version +############################################################################### + +cdef cudaError_t _getLocalRuntimeVersion(int* runtimeVersion) except ?cudaErrorCallRequiresNewerDriver nogil: + # Load cudart dynamically to read its embedded version number. + with gil: + loaded_dl = load_nvidia_dynamic_lib("cudart") + handle = loaded_dl._handle_uint + + cdef void* __cudaRuntimeGetVersion = windll.GetProcAddress(handle, b'cudaRuntimeGetVersion') + + if __cudaRuntimeGetVersion == NULL: + with gil: + raise RuntimeError(f'Function "cudaRuntimeGetVersion" not found in {loaded_dl.abs_path}') + + # We explicitly do *NOT* cleanup the library handle here — see runtime_linux.pyx comment. + + cdef cudaError_t err = cudaSuccess + err = ( __cudaRuntimeGetVersion)(runtimeVersion) + return err + + +############################################################################### +# C function declarations for static cudart (avoids infinite recursion through +# the same-named Cython wrappers imported via `from ..cyruntime cimport *`) +############################################################################### + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceReset "cudaDeviceReset" () noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceSynchronize "cudaDeviceSynchronize" () noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceSetLimit "cudaDeviceSetLimit" (cudaLimit limit, size_t value) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetLimit "cudaDeviceGetLimit" (size_t* pValue, cudaLimit limit) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetTexture1DLinearMaxWidth "cudaDeviceGetTexture1DLinearMaxWidth" (size_t* maxWidthInElements, const cudaChannelFormatDesc* fmtDesc, int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetCacheConfig "cudaDeviceGetCacheConfig" (cudaFuncCache* pCacheConfig) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetStreamPriorityRange "cudaDeviceGetStreamPriorityRange" (int* leastPriority, int* greatestPriority) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceSetCacheConfig "cudaDeviceSetCacheConfig" (cudaFuncCache cacheConfig) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetByPCIBusId "cudaDeviceGetByPCIBusId" (int* device, const char* pciBusId) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetPCIBusId "cudaDeviceGetPCIBusId" (char* pciBusId, int len, int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaIpcGetEventHandle "cudaIpcGetEventHandle" (cudaIpcEventHandle_t* handle, cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaIpcOpenEventHandle "cudaIpcOpenEventHandle" (cudaEvent_t* event, cudaIpcEventHandle_t handle) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaIpcGetMemHandle "cudaIpcGetMemHandle" (cudaIpcMemHandle_t* handle, void* devPtr) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaIpcOpenMemHandle "cudaIpcOpenMemHandle" (void** devPtr, cudaIpcMemHandle_t handle, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaIpcCloseMemHandle "cudaIpcCloseMemHandle" (void* devPtr) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceFlushGPUDirectRDMAWrites "cudaDeviceFlushGPUDirectRDMAWrites" (cudaFlushGPUDirectRDMAWritesTarget target, cudaFlushGPUDirectRDMAWritesScope scope) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceRegisterAsyncNotification "cudaDeviceRegisterAsyncNotification" (int device, cudaAsyncCallback callbackFunc, void* userData, cudaAsyncCallbackHandle_t* callback) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceUnregisterAsyncNotification "cudaDeviceUnregisterAsyncNotification" (int device, cudaAsyncCallbackHandle_t callback) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetSharedMemConfig "cudaDeviceGetSharedMemConfig" (cudaSharedMemConfig* pConfig) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceSetSharedMemConfig "cudaDeviceSetSharedMemConfig" (cudaSharedMemConfig config) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetLastError "cudaGetLastError" () noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaPeekAtLastError "cudaPeekAtLastError" () noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + const char* _static_cudaGetErrorName "cudaGetErrorName" (cudaError_t error) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + const char* _static_cudaGetErrorString "cudaGetErrorString" (cudaError_t error) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetDeviceCount "cudaGetDeviceCount" (int* count) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetAttribute "cudaDeviceGetAttribute" (int* value, cudaDeviceAttr attr, int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetDefaultMemPool "cudaDeviceGetDefaultMemPool" (cudaMemPool_t* memPool, int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceSetMemPool "cudaDeviceSetMemPool" (int device, cudaMemPool_t memPool) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetMemPool "cudaDeviceGetMemPool" (cudaMemPool_t* memPool, int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetNvSciSyncAttributes "cudaDeviceGetNvSciSyncAttributes" (void* nvSciSyncAttrList, int device, int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetP2PAttribute "cudaDeviceGetP2PAttribute" (int* value, cudaDeviceP2PAttr attr, int srcDevice, int dstDevice) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaChooseDevice "cudaChooseDevice" (int* device, const cudaDeviceProp* prop) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaInitDevice "cudaInitDevice" (int device, unsigned int deviceFlags, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaSetDevice "cudaSetDevice" (int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetDevice "cudaGetDevice" (int* device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaSetDeviceFlags "cudaSetDeviceFlags" (unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetDeviceFlags "cudaGetDeviceFlags" (unsigned int* flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamCreate "cudaStreamCreate" (cudaStream_t* pStream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamCreateWithFlags "cudaStreamCreateWithFlags" (cudaStream_t* pStream, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamCreateWithPriority "cudaStreamCreateWithPriority" (cudaStream_t* pStream, unsigned int flags, int priority) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamGetPriority "cudaStreamGetPriority" (cudaStream_t hStream, int* priority) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamGetFlags "cudaStreamGetFlags" (cudaStream_t hStream, unsigned int* flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamGetId "cudaStreamGetId" (cudaStream_t hStream, unsigned long long* streamId) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamGetDevice "cudaStreamGetDevice" (cudaStream_t hStream, int* device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaCtxResetPersistingL2Cache "cudaCtxResetPersistingL2Cache" () noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamCopyAttributes "cudaStreamCopyAttributes" (cudaStream_t dst, cudaStream_t src) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamGetAttribute "cudaStreamGetAttribute" (cudaStream_t hStream, cudaLaunchAttributeID attr, cudaLaunchAttributeValue* value_out) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamSetAttribute "cudaStreamSetAttribute" (cudaStream_t hStream, cudaLaunchAttributeID attr, const cudaLaunchAttributeValue* value) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamDestroy "cudaStreamDestroy" (cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamWaitEvent "cudaStreamWaitEvent" (cudaStream_t stream, cudaEvent_t event, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamAddCallback "cudaStreamAddCallback" (cudaStream_t stream, cudaStreamCallback_t callback, void* userData, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamSynchronize "cudaStreamSynchronize" (cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamQuery "cudaStreamQuery" (cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamAttachMemAsync "cudaStreamAttachMemAsync" (cudaStream_t stream, void* devPtr, size_t length, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamBeginCapture "cudaStreamBeginCapture" (cudaStream_t stream, cudaStreamCaptureMode mode) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamBeginCaptureToGraph "cudaStreamBeginCaptureToGraph" (cudaStream_t stream, cudaGraph_t graph, const cudaGraphNode_t* dependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, cudaStreamCaptureMode mode) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaThreadExchangeStreamCaptureMode "cudaThreadExchangeStreamCaptureMode" (cudaStreamCaptureMode* mode) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamEndCapture "cudaStreamEndCapture" (cudaStream_t stream, cudaGraph_t* pGraph) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamIsCapturing "cudaStreamIsCapturing" (cudaStream_t stream, cudaStreamCaptureStatus* pCaptureStatus) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamUpdateCaptureDependencies "cudaStreamUpdateCaptureDependencies" (cudaStream_t stream, cudaGraphNode_t* dependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaEventCreate "cudaEventCreate" (cudaEvent_t* event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaEventCreateWithFlags "cudaEventCreateWithFlags" (cudaEvent_t* event, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaEventRecord "cudaEventRecord" (cudaEvent_t event, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaEventRecordWithFlags "cudaEventRecordWithFlags" (cudaEvent_t event, cudaStream_t stream, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaEventQuery "cudaEventQuery" (cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaEventSynchronize "cudaEventSynchronize" (cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaEventDestroy "cudaEventDestroy" (cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaEventElapsedTime "cudaEventElapsedTime" (float* ms, cudaEvent_t start, cudaEvent_t end) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaImportExternalMemory "cudaImportExternalMemory" (cudaExternalMemory_t* extMem_out, const cudaExternalMemoryHandleDesc* memHandleDesc) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaExternalMemoryGetMappedBuffer "cudaExternalMemoryGetMappedBuffer" (void** devPtr, cudaExternalMemory_t extMem, const cudaExternalMemoryBufferDesc* bufferDesc) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaExternalMemoryGetMappedMipmappedArray "cudaExternalMemoryGetMappedMipmappedArray" (cudaMipmappedArray_t* mipmap, cudaExternalMemory_t extMem, const cudaExternalMemoryMipmappedArrayDesc* mipmapDesc) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDestroyExternalMemory "cudaDestroyExternalMemory" (cudaExternalMemory_t extMem) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaImportExternalSemaphore "cudaImportExternalSemaphore" (cudaExternalSemaphore_t* extSem_out, const cudaExternalSemaphoreHandleDesc* semHandleDesc) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDestroyExternalSemaphore "cudaDestroyExternalSemaphore" (cudaExternalSemaphore_t extSem) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFuncSetCacheConfig "cudaFuncSetCacheConfig" (const void* func, cudaFuncCache cacheConfig) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFuncGetAttributes "cudaFuncGetAttributes" (cudaFuncAttributes* attr, const void* func) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFuncSetAttribute "cudaFuncSetAttribute" (const void* func, cudaFuncAttribute attr, int value) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFuncGetName "cudaFuncGetName" (const char** name, const void* func) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFuncGetParamInfo "cudaFuncGetParamInfo" (const void* func, size_t paramIndex, size_t* paramOffset, size_t* paramSize) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLaunchHostFunc "cudaLaunchHostFunc" (cudaStream_t stream, cudaHostFn_t fn, void* userData) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFuncSetSharedMemConfig "cudaFuncSetSharedMemConfig" (const void* func, cudaSharedMemConfig config) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaOccupancyMaxActiveBlocksPerMultiprocessor "cudaOccupancyMaxActiveBlocksPerMultiprocessor" (int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaOccupancyAvailableDynamicSMemPerBlock "cudaOccupancyAvailableDynamicSMemPerBlock" (size_t* dynamicSmemSize, const void* func, int numBlocks, int blockSize) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags "cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags" (int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMallocManaged "cudaMallocManaged" (void** devPtr, size_t size, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMalloc "cudaMalloc" (void** devPtr, size_t size) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMallocHost "cudaMallocHost" (void** ptr, size_t size) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMallocPitch "cudaMallocPitch" (void** devPtr, size_t* pitch, size_t width, size_t height) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMallocArray "cudaMallocArray" (cudaArray_t* array, const cudaChannelFormatDesc* desc, size_t width, size_t height, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFree "cudaFree" (void* devPtr) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFreeHost "cudaFreeHost" (void* ptr) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFreeArray "cudaFreeArray" (cudaArray_t array) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFreeMipmappedArray "cudaFreeMipmappedArray" (cudaMipmappedArray_t mipmappedArray) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaHostAlloc "cudaHostAlloc" (void** pHost, size_t size, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaHostRegister "cudaHostRegister" (void* ptr, size_t size, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaHostUnregister "cudaHostUnregister" (void* ptr) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaHostGetDevicePointer "cudaHostGetDevicePointer" (void** pDevice, void* pHost, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaHostGetFlags "cudaHostGetFlags" (unsigned int* pFlags, void* pHost) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMalloc3D "cudaMalloc3D" (cudaPitchedPtr* pitchedDevPtr, cudaExtent extent) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMalloc3DArray "cudaMalloc3DArray" (cudaArray_t* array, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMallocMipmappedArray "cudaMallocMipmappedArray" (cudaMipmappedArray_t* mipmappedArray, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int numLevels, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetMipmappedArrayLevel "cudaGetMipmappedArrayLevel" (cudaArray_t* levelArray, cudaMipmappedArray_const_t mipmappedArray, unsigned int level) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy3D "cudaMemcpy3D" (const cudaMemcpy3DParms* p) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy3DPeer "cudaMemcpy3DPeer" (const cudaMemcpy3DPeerParms* p) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy3DAsync "cudaMemcpy3DAsync" (const cudaMemcpy3DParms* p, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy3DPeerAsync "cudaMemcpy3DPeerAsync" (const cudaMemcpy3DPeerParms* p, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemGetInfo "cudaMemGetInfo" (size_t* free, size_t* total) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaArrayGetInfo "cudaArrayGetInfo" (cudaChannelFormatDesc* desc, cudaExtent* extent, unsigned int* flags, cudaArray_t array) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaArrayGetPlane "cudaArrayGetPlane" (cudaArray_t* pPlaneArray, cudaArray_t hArray, unsigned int planeIdx) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaArrayGetMemoryRequirements "cudaArrayGetMemoryRequirements" (cudaArrayMemoryRequirements* memoryRequirements, cudaArray_t array, int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMipmappedArrayGetMemoryRequirements "cudaMipmappedArrayGetMemoryRequirements" (cudaArrayMemoryRequirements* memoryRequirements, cudaMipmappedArray_t mipmap, int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaArrayGetSparseProperties "cudaArrayGetSparseProperties" (cudaArraySparseProperties* sparseProperties, cudaArray_t array) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMipmappedArrayGetSparseProperties "cudaMipmappedArrayGetSparseProperties" (cudaArraySparseProperties* sparseProperties, cudaMipmappedArray_t mipmap) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy "cudaMemcpy" (void* dst, const void* src, size_t count, cudaMemcpyKind kind) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpyPeer "cudaMemcpyPeer" (void* dst, int dstDevice, const void* src, int srcDevice, size_t count) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy2D "cudaMemcpy2D" (void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy2DToArray "cudaMemcpy2DToArray" (cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy2DFromArray "cudaMemcpy2DFromArray" (void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy2DArrayToArray "cudaMemcpy2DArrayToArray" (cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t width, size_t height, cudaMemcpyKind kind) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpyAsync "cudaMemcpyAsync" (void* dst, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpyPeerAsync "cudaMemcpyPeerAsync" (void* dst, int dstDevice, const void* src, int srcDevice, size_t count, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpyBatchAsync "cudaMemcpyBatchAsync" (void** dsts, const void** srcs, const size_t* sizes, size_t count, cudaMemcpyAttributes* attrs, size_t* attrsIdxs, size_t numAttrs, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy3DBatchAsync "cudaMemcpy3DBatchAsync" (size_t numOps, cudaMemcpy3DBatchOp* opList, unsigned long long flags, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy2DAsync "cudaMemcpy2DAsync" (void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy2DToArrayAsync "cudaMemcpy2DToArrayAsync" (cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy2DFromArrayAsync "cudaMemcpy2DFromArrayAsync" (void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemset "cudaMemset" (void* devPtr, int value, size_t count) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemset2D "cudaMemset2D" (void* devPtr, size_t pitch, int value, size_t width, size_t height) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemset3D "cudaMemset3D" (cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemsetAsync "cudaMemsetAsync" (void* devPtr, int value, size_t count, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemset2DAsync "cudaMemset2DAsync" (void* devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemset3DAsync "cudaMemset3DAsync" (cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPrefetchAsync "cudaMemPrefetchAsync" (const void* devPtr, size_t count, cudaMemLocation location, unsigned int flags, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemAdvise "cudaMemAdvise" (const void* devPtr, size_t count, cudaMemoryAdvise advice, cudaMemLocation location) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemRangeGetAttribute "cudaMemRangeGetAttribute" (void* data, size_t dataSize, cudaMemRangeAttribute attribute, const void* devPtr, size_t count) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemRangeGetAttributes "cudaMemRangeGetAttributes" (void** data, size_t* dataSizes, cudaMemRangeAttribute* attributes, size_t numAttributes, const void* devPtr, size_t count) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpyToArray "cudaMemcpyToArray" (cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpyFromArray "cudaMemcpyFromArray" (void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpyArrayToArray "cudaMemcpyArrayToArray" (cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t count, cudaMemcpyKind kind) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpyToArrayAsync "cudaMemcpyToArrayAsync" (cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpyFromArrayAsync "cudaMemcpyFromArrayAsync" (void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMallocAsync "cudaMallocAsync" (void** devPtr, size_t size, cudaStream_t hStream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFreeAsync "cudaFreeAsync" (void* devPtr, cudaStream_t hStream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPoolTrimTo "cudaMemPoolTrimTo" (cudaMemPool_t memPool, size_t minBytesToKeep) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPoolSetAttribute "cudaMemPoolSetAttribute" (cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPoolGetAttribute "cudaMemPoolGetAttribute" (cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPoolSetAccess "cudaMemPoolSetAccess" (cudaMemPool_t memPool, const cudaMemAccessDesc* descList, size_t count) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPoolGetAccess "cudaMemPoolGetAccess" (cudaMemAccessFlags* flags, cudaMemPool_t memPool, cudaMemLocation* location) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPoolCreate "cudaMemPoolCreate" (cudaMemPool_t* memPool, const cudaMemPoolProps* poolProps) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPoolDestroy "cudaMemPoolDestroy" (cudaMemPool_t memPool) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMallocFromPoolAsync "cudaMallocFromPoolAsync" (void** ptr, size_t size, cudaMemPool_t memPool, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPoolExportToShareableHandle "cudaMemPoolExportToShareableHandle" (void* shareableHandle, cudaMemPool_t memPool, cudaMemAllocationHandleType handleType, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPoolImportFromShareableHandle "cudaMemPoolImportFromShareableHandle" (cudaMemPool_t* memPool, void* shareableHandle, cudaMemAllocationHandleType handleType, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPoolExportPointer "cudaMemPoolExportPointer" (cudaMemPoolPtrExportData* exportData, void* ptr) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPoolImportPointer "cudaMemPoolImportPointer" (void** ptr, cudaMemPool_t memPool, cudaMemPoolPtrExportData* exportData) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaPointerGetAttributes "cudaPointerGetAttributes" (cudaPointerAttributes* attributes, const void* ptr) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceCanAccessPeer "cudaDeviceCanAccessPeer" (int* canAccessPeer, int device, int peerDevice) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceEnablePeerAccess "cudaDeviceEnablePeerAccess" (int peerDevice, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceDisablePeerAccess "cudaDeviceDisablePeerAccess" (int peerDevice) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphicsUnregisterResource "cudaGraphicsUnregisterResource" (cudaGraphicsResource_t resource) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphicsResourceSetMapFlags "cudaGraphicsResourceSetMapFlags" (cudaGraphicsResource_t resource, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphicsMapResources "cudaGraphicsMapResources" (int count, cudaGraphicsResource_t* resources, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphicsUnmapResources "cudaGraphicsUnmapResources" (int count, cudaGraphicsResource_t* resources, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphicsResourceGetMappedPointer "cudaGraphicsResourceGetMappedPointer" (void** devPtr, size_t* size, cudaGraphicsResource_t resource) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphicsSubResourceGetMappedArray "cudaGraphicsSubResourceGetMappedArray" (cudaArray_t* array, cudaGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphicsResourceGetMappedMipmappedArray "cudaGraphicsResourceGetMappedMipmappedArray" (cudaMipmappedArray_t* mipmappedArray, cudaGraphicsResource_t resource) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetChannelDesc "cudaGetChannelDesc" (cudaChannelFormatDesc* desc, cudaArray_const_t array) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaChannelFormatDesc _static_cudaCreateChannelDesc "cudaCreateChannelDesc" (int x, int y, int z, int w, cudaChannelFormatKind f) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaCreateTextureObject "cudaCreateTextureObject" (cudaTextureObject_t* pTexObject, const cudaResourceDesc* pResDesc, const cudaTextureDesc* pTexDesc, const cudaResourceViewDesc* pResViewDesc) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDestroyTextureObject "cudaDestroyTextureObject" (cudaTextureObject_t texObject) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetTextureObjectResourceDesc "cudaGetTextureObjectResourceDesc" (cudaResourceDesc* pResDesc, cudaTextureObject_t texObject) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetTextureObjectTextureDesc "cudaGetTextureObjectTextureDesc" (cudaTextureDesc* pTexDesc, cudaTextureObject_t texObject) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetTextureObjectResourceViewDesc "cudaGetTextureObjectResourceViewDesc" (cudaResourceViewDesc* pResViewDesc, cudaTextureObject_t texObject) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaCreateSurfaceObject "cudaCreateSurfaceObject" (cudaSurfaceObject_t* pSurfObject, const cudaResourceDesc* pResDesc) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDestroySurfaceObject "cudaDestroySurfaceObject" (cudaSurfaceObject_t surfObject) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetSurfaceObjectResourceDesc "cudaGetSurfaceObjectResourceDesc" (cudaResourceDesc* pResDesc, cudaSurfaceObject_t surfObject) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDriverGetVersion "cudaDriverGetVersion" (int* driverVersion) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaRuntimeGetVersion "cudaRuntimeGetVersion" (int* runtimeVersion) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphCreate "cudaGraphCreate" (cudaGraph_t* pGraph, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddKernelNode "cudaGraphAddKernelNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaKernelNodeParams* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphKernelNodeGetParams "cudaGraphKernelNodeGetParams" (cudaGraphNode_t node, cudaKernelNodeParams* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphKernelNodeSetParams "cudaGraphKernelNodeSetParams" (cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphKernelNodeCopyAttributes "cudaGraphKernelNodeCopyAttributes" (cudaGraphNode_t hDst, cudaGraphNode_t hSrc) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphKernelNodeGetAttribute "cudaGraphKernelNodeGetAttribute" (cudaGraphNode_t hNode, cudaLaunchAttributeID attr, cudaLaunchAttributeValue* value_out) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphKernelNodeSetAttribute "cudaGraphKernelNodeSetAttribute" (cudaGraphNode_t hNode, cudaLaunchAttributeID attr, const cudaLaunchAttributeValue* value) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddMemcpyNode "cudaGraphAddMemcpyNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemcpy3DParms* pCopyParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddMemcpyNode1D "cudaGraphAddMemcpyNode1D" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dst, const void* src, size_t count, cudaMemcpyKind kind) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphMemcpyNodeGetParams "cudaGraphMemcpyNodeGetParams" (cudaGraphNode_t node, cudaMemcpy3DParms* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphMemcpyNodeSetParams "cudaGraphMemcpyNodeSetParams" (cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphMemcpyNodeSetParams1D "cudaGraphMemcpyNodeSetParams1D" (cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddMemsetNode "cudaGraphAddMemsetNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemsetParams* pMemsetParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphMemsetNodeGetParams "cudaGraphMemsetNodeGetParams" (cudaGraphNode_t node, cudaMemsetParams* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphMemsetNodeSetParams "cudaGraphMemsetNodeSetParams" (cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddHostNode "cudaGraphAddHostNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaHostNodeParams* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphHostNodeGetParams "cudaGraphHostNodeGetParams" (cudaGraphNode_t node, cudaHostNodeParams* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphHostNodeSetParams "cudaGraphHostNodeSetParams" (cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddChildGraphNode "cudaGraphAddChildGraphNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaGraph_t childGraph) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphChildGraphNodeGetGraph "cudaGraphChildGraphNodeGetGraph" (cudaGraphNode_t node, cudaGraph_t* pGraph) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddEmptyNode "cudaGraphAddEmptyNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddEventRecordNode "cudaGraphAddEventRecordNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphEventRecordNodeGetEvent "cudaGraphEventRecordNodeGetEvent" (cudaGraphNode_t node, cudaEvent_t* event_out) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphEventRecordNodeSetEvent "cudaGraphEventRecordNodeSetEvent" (cudaGraphNode_t node, cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddEventWaitNode "cudaGraphAddEventWaitNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphEventWaitNodeGetEvent "cudaGraphEventWaitNodeGetEvent" (cudaGraphNode_t node, cudaEvent_t* event_out) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphEventWaitNodeSetEvent "cudaGraphEventWaitNodeSetEvent" (cudaGraphNode_t node, cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddExternalSemaphoresSignalNode "cudaGraphAddExternalSemaphoresSignalNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreSignalNodeParams* nodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExternalSemaphoresSignalNodeGetParams "cudaGraphExternalSemaphoresSignalNodeGetParams" (cudaGraphNode_t hNode, cudaExternalSemaphoreSignalNodeParams* params_out) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExternalSemaphoresSignalNodeSetParams "cudaGraphExternalSemaphoresSignalNodeSetParams" (cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddExternalSemaphoresWaitNode "cudaGraphAddExternalSemaphoresWaitNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreWaitNodeParams* nodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExternalSemaphoresWaitNodeGetParams "cudaGraphExternalSemaphoresWaitNodeGetParams" (cudaGraphNode_t hNode, cudaExternalSemaphoreWaitNodeParams* params_out) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExternalSemaphoresWaitNodeSetParams "cudaGraphExternalSemaphoresWaitNodeSetParams" (cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddMemAllocNode "cudaGraphAddMemAllocNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaMemAllocNodeParams* nodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphMemAllocNodeGetParams "cudaGraphMemAllocNodeGetParams" (cudaGraphNode_t node, cudaMemAllocNodeParams* params_out) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddMemFreeNode "cudaGraphAddMemFreeNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dptr) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphMemFreeNodeGetParams "cudaGraphMemFreeNodeGetParams" (cudaGraphNode_t node, void* dptr_out) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGraphMemTrim "cudaDeviceGraphMemTrim" (int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetGraphMemAttribute "cudaDeviceGetGraphMemAttribute" (int device, cudaGraphMemAttributeType attr, void* value) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceSetGraphMemAttribute "cudaDeviceSetGraphMemAttribute" (int device, cudaGraphMemAttributeType attr, void* value) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphClone "cudaGraphClone" (cudaGraph_t* pGraphClone, cudaGraph_t originalGraph) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphNodeFindInClone "cudaGraphNodeFindInClone" (cudaGraphNode_t* pNode, cudaGraphNode_t originalNode, cudaGraph_t clonedGraph) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphNodeGetType "cudaGraphNodeGetType" (cudaGraphNode_t node, cudaGraphNodeType* pType) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphGetNodes "cudaGraphGetNodes" (cudaGraph_t graph, cudaGraphNode_t* nodes, size_t* numNodes) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphGetRootNodes "cudaGraphGetRootNodes" (cudaGraph_t graph, cudaGraphNode_t* pRootNodes, size_t* pNumRootNodes) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphGetEdges "cudaGraphGetEdges" (cudaGraph_t graph, cudaGraphNode_t* from_, cudaGraphNode_t* to, cudaGraphEdgeData* edgeData, size_t* numEdges) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphNodeGetDependencies "cudaGraphNodeGetDependencies" (cudaGraphNode_t node, cudaGraphNode_t* pDependencies, cudaGraphEdgeData* edgeData, size_t* pNumDependencies) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphNodeGetDependentNodes "cudaGraphNodeGetDependentNodes" (cudaGraphNode_t node, cudaGraphNode_t* pDependentNodes, cudaGraphEdgeData* edgeData, size_t* pNumDependentNodes) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddDependencies "cudaGraphAddDependencies" (cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, const cudaGraphEdgeData* edgeData, size_t numDependencies) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphRemoveDependencies "cudaGraphRemoveDependencies" (cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, const cudaGraphEdgeData* edgeData, size_t numDependencies) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphDestroyNode "cudaGraphDestroyNode" (cudaGraphNode_t node) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphInstantiate "cudaGraphInstantiate" (cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphInstantiateWithFlags "cudaGraphInstantiateWithFlags" (cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphInstantiateWithParams "cudaGraphInstantiateWithParams" (cudaGraphExec_t* pGraphExec, cudaGraph_t graph, cudaGraphInstantiateParams* instantiateParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecGetFlags "cudaGraphExecGetFlags" (cudaGraphExec_t graphExec, unsigned long long* flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecKernelNodeSetParams "cudaGraphExecKernelNodeSetParams" (cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecMemcpyNodeSetParams "cudaGraphExecMemcpyNodeSetParams" (cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecMemcpyNodeSetParams1D "cudaGraphExecMemcpyNodeSetParams1D" (cudaGraphExec_t hGraphExec, cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecMemsetNodeSetParams "cudaGraphExecMemsetNodeSetParams" (cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecHostNodeSetParams "cudaGraphExecHostNodeSetParams" (cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecChildGraphNodeSetParams "cudaGraphExecChildGraphNodeSetParams" (cudaGraphExec_t hGraphExec, cudaGraphNode_t node, cudaGraph_t childGraph) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecEventRecordNodeSetEvent "cudaGraphExecEventRecordNodeSetEvent" (cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecEventWaitNodeSetEvent "cudaGraphExecEventWaitNodeSetEvent" (cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecExternalSemaphoresSignalNodeSetParams "cudaGraphExecExternalSemaphoresSignalNodeSetParams" (cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecExternalSemaphoresWaitNodeSetParams "cudaGraphExecExternalSemaphoresWaitNodeSetParams" (cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphNodeSetEnabled "cudaGraphNodeSetEnabled" (cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int isEnabled) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphNodeGetEnabled "cudaGraphNodeGetEnabled" (cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int* isEnabled) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecUpdate "cudaGraphExecUpdate" (cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphExecUpdateResultInfo* resultInfo) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphUpload "cudaGraphUpload" (cudaGraphExec_t graphExec, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphLaunch "cudaGraphLaunch" (cudaGraphExec_t graphExec, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecDestroy "cudaGraphExecDestroy" (cudaGraphExec_t graphExec) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphDestroy "cudaGraphDestroy" (cudaGraph_t graph) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphDebugDotPrint "cudaGraphDebugDotPrint" (cudaGraph_t graph, const char* path, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaUserObjectCreate "cudaUserObjectCreate" (cudaUserObject_t* object_out, void* ptr, cudaHostFn_t destroy, unsigned int initialRefcount, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaUserObjectRetain "cudaUserObjectRetain" (cudaUserObject_t object, unsigned int count) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaUserObjectRelease "cudaUserObjectRelease" (cudaUserObject_t object, unsigned int count) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphRetainUserObject "cudaGraphRetainUserObject" (cudaGraph_t graph, cudaUserObject_t object, unsigned int count, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphReleaseUserObject "cudaGraphReleaseUserObject" (cudaGraph_t graph, cudaUserObject_t object, unsigned int count) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphAddNode "cudaGraphAddNode" (cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, cudaGraphNodeParams* nodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphNodeSetParams "cudaGraphNodeSetParams" (cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecNodeSetParams "cudaGraphExecNodeSetParams" (cudaGraphExec_t graphExec, cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphConditionalHandleCreate "cudaGraphConditionalHandleCreate" (cudaGraphConditionalHandle* pHandle_out, cudaGraph_t graph, unsigned int defaultLaunchValue, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetDriverEntryPoint "cudaGetDriverEntryPoint" (const char* symbol, void** funcPtr, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetDriverEntryPointByVersion "cudaGetDriverEntryPointByVersion" (const char* symbol, void** funcPtr, unsigned int cudaVersion, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLibraryLoadData "cudaLibraryLoadData" (cudaLibrary_t* library, const void* code, cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLibraryLoadFromFile "cudaLibraryLoadFromFile" (cudaLibrary_t* library, const char* fileName, cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLibraryUnload "cudaLibraryUnload" (cudaLibrary_t library) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLibraryGetKernel "cudaLibraryGetKernel" (cudaKernel_t* pKernel, cudaLibrary_t library, const char* name) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLibraryGetGlobal "cudaLibraryGetGlobal" (void** dptr, size_t* bytes, cudaLibrary_t library, const char* name) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLibraryGetManaged "cudaLibraryGetManaged" (void** dptr, size_t* bytes, cudaLibrary_t library, const char* name) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLibraryGetUnifiedFunction "cudaLibraryGetUnifiedFunction" (void** fptr, cudaLibrary_t library, const char* symbol) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLibraryGetKernelCount "cudaLibraryGetKernelCount" (unsigned int* count, cudaLibrary_t lib) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLibraryEnumerateKernels "cudaLibraryEnumerateKernels" (cudaKernel_t* kernels, unsigned int numKernels, cudaLibrary_t lib) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaKernelSetAttributeForDevice "cudaKernelSetAttributeForDevice" (cudaKernel_t kernel, cudaFuncAttribute attr, int value, int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetExportTable "cudaGetExportTable" (const void** ppExportTable, const cudaUUID_t* pExportTableId) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetKernel "cudaGetKernel" (cudaKernel_t* kernelPtr, const void* entryFuncAddr) noexcept + +cdef extern from 'cuda_profiler_api.h' nogil: + cudaError_t _static_cudaProfilerStart "cudaProfilerStart" () noexcept + +cdef extern from 'cuda_profiler_api.h' nogil: + cudaError_t _static_cudaProfilerStop "cudaProfilerStop" () noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGetDeviceProperties "cudaGetDeviceProperties" (cudaDeviceProp* prop, int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetHostAtomicCapabilities "cudaDeviceGetHostAtomicCapabilities" (unsigned int* capabilities, const cudaAtomicOperation* operations, unsigned int count, int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetP2PAtomicCapabilities "cudaDeviceGetP2PAtomicCapabilities" (unsigned int* capabilities, const cudaAtomicOperation* operations, unsigned int count, int srcDevice, int dstDevice) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamGetCaptureInfo "cudaStreamGetCaptureInfo" (cudaStream_t stream, cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out, cudaGraph_t* graph_out, const cudaGraphNode_t** dependencies_out, const cudaGraphEdgeData** edgeData_out, size_t* numDependencies_out) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaSignalExternalSemaphoresAsync "cudaSignalExternalSemaphoresAsync" (const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreSignalParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaWaitExternalSemaphoresAsync "cudaWaitExternalSemaphoresAsync" (const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreWaitParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemPrefetchBatchAsync "cudaMemPrefetchBatchAsync" (void** dptrs, size_t* sizes, size_t count, cudaMemLocation* prefetchLocs, size_t* prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemDiscardBatchAsync "cudaMemDiscardBatchAsync" (void** dptrs, size_t* sizes, size_t count, unsigned long long flags, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemDiscardAndPrefetchBatchAsync "cudaMemDiscardAndPrefetchBatchAsync" (void** dptrs, size_t* sizes, size_t count, cudaMemLocation* prefetchLocs, size_t* prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemGetDefaultMemPool "cudaMemGetDefaultMemPool" (cudaMemPool_t* memPool, cudaMemLocation* location, cudaMemAllocationType type) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemGetMemPool "cudaMemGetMemPool" (cudaMemPool_t* memPool, cudaMemLocation* location, cudaMemAllocationType type) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemSetMemPool "cudaMemSetMemPool" (cudaMemLocation* location, cudaMemAllocationType type, cudaMemPool_t memPool) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLogsRegisterCallback "cudaLogsRegisterCallback" (cudaLogsCallback_t callbackFunc, void* userData, cudaLogsCallbackHandle* callback_out) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLogsUnregisterCallback "cudaLogsUnregisterCallback" (cudaLogsCallbackHandle callback) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLogsCurrent "cudaLogsCurrent" (cudaLogIterator* iterator_out, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLogsDumpToFile "cudaLogsDumpToFile" (cudaLogIterator* iterator, const char* pathToFile, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLogsDumpToMemory "cudaLogsDumpToMemory" (cudaLogIterator* iterator, char* buffer, size_t* size, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphNodeGetContainingGraph "cudaGraphNodeGetContainingGraph" (cudaGraphNode_t hNode, cudaGraph_t* phGraph) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphNodeGetLocalId "cudaGraphNodeGetLocalId" (cudaGraphNode_t hNode, unsigned int* nodeId) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphNodeGetToolsId "cudaGraphNodeGetToolsId" (cudaGraphNode_t hNode, unsigned long long* toolsNodeId) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphGetId "cudaGraphGetId" (cudaGraph_t hGraph, unsigned int* graphID) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphExecGetId "cudaGraphExecGetId" (cudaGraphExec_t hGraphExec, unsigned int* graphID) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphConditionalHandleCreate_v2 "cudaGraphConditionalHandleCreate_v2" (cudaGraphConditionalHandle* pHandle_out, cudaGraph_t graph, cudaExecutionContext_t ctx, unsigned int defaultLaunchValue, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetDevResource "cudaDeviceGetDevResource" (int device, cudaDevResource* resource, cudaDevResourceType type) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDevSmResourceSplitByCount "cudaDevSmResourceSplitByCount" (cudaDevResource* result, unsigned int* nbGroups, const cudaDevResource* input, cudaDevResource* remaining, unsigned int flags, unsigned int minCount) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDevSmResourceSplit "cudaDevSmResourceSplit" (cudaDevResource* result, unsigned int nbGroups, const cudaDevResource* input, cudaDevResource* remainder, unsigned int flags, cudaDevSmResourceGroupParams* groupParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDevResourceGenerateDesc "cudaDevResourceGenerateDesc" (cudaDevResourceDesc_t* phDesc, cudaDevResource* resources, unsigned int nbResources) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGreenCtxCreate "cudaGreenCtxCreate" (cudaExecutionContext_t* phCtx, cudaDevResourceDesc_t desc, int device, unsigned int flags) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaExecutionCtxDestroy "cudaExecutionCtxDestroy" (cudaExecutionContext_t ctx) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaExecutionCtxGetDevResource "cudaExecutionCtxGetDevResource" (cudaExecutionContext_t ctx, cudaDevResource* resource, cudaDevResourceType type) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaExecutionCtxGetDevice "cudaExecutionCtxGetDevice" (int* device, cudaExecutionContext_t ctx) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaExecutionCtxGetId "cudaExecutionCtxGetId" (cudaExecutionContext_t ctx, unsigned long long* ctxId) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaExecutionCtxStreamCreate "cudaExecutionCtxStreamCreate" (cudaStream_t* phStream, cudaExecutionContext_t ctx, unsigned int flags, int priority) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaExecutionCtxSynchronize "cudaExecutionCtxSynchronize" (cudaExecutionContext_t ctx) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamGetDevResource "cudaStreamGetDevResource" (cudaStream_t hStream, cudaDevResource* resource, cudaDevResourceType type) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaExecutionCtxRecordEvent "cudaExecutionCtxRecordEvent" (cudaExecutionContext_t ctx, cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaExecutionCtxWaitEvent "cudaExecutionCtxWaitEvent" (cudaExecutionContext_t ctx, cudaEvent_t event) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaDeviceGetExecutionCtx "cudaDeviceGetExecutionCtx" (cudaExecutionContext_t* ctx, int device) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaFuncGetParamCount "cudaFuncGetParamCount" (const void* func, size_t* paramCount) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaLaunchHostFunc_v2 "cudaLaunchHostFunc_v2" (cudaStream_t stream, cudaHostFn_t fn, void* userData, unsigned int syncMode) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpyWithAttributesAsync "cudaMemcpyWithAttributesAsync" (void* dst, const void* src, size_t size, cudaMemcpyAttributes* attr, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaMemcpy3DWithAttributesAsync "cudaMemcpy3DWithAttributesAsync" (cudaMemcpy3DBatchOp* op, unsigned long long flags, cudaStream_t stream) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaGraphNodeGetParams "cudaGraphNodeGetParams" (cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) noexcept + +cdef extern from 'cuda_runtime_api.h' nogil: + cudaError_t _static_cudaStreamBeginRecaptureToGraph "cudaStreamBeginRecaptureToGraph" (cudaStream_t stream, cudaStreamCaptureMode mode, cudaGraph_t graph, cudaGraphRecaptureCallbackData* callbackData) noexcept + + +############################################################################### +# Wrapper functions +############################################################################### cdef cudaError_t _cudaDeviceReset() except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceReset() - return cudaDeviceReset() -{{endif}} + return _static_cudaDeviceReset() -{{if 'cudaDeviceSynchronize' in found_functions}} cdef cudaError_t _cudaDeviceSynchronize() except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceSynchronize() - return cudaDeviceSynchronize() -{{endif}} + return _static_cudaDeviceSynchronize() -{{if 'cudaDeviceSetLimit' in found_functions}} cdef cudaError_t _cudaDeviceSetLimit(cudaLimit limit, size_t value) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceSetLimit(limit, value) - return cudaDeviceSetLimit(limit, value) -{{endif}} + return _static_cudaDeviceSetLimit(limit, value) -{{if 'cudaDeviceGetLimit' in found_functions}} cdef cudaError_t _cudaDeviceGetLimit(size_t* pValue, cudaLimit limit) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceGetLimit(pValue, limit) - return cudaDeviceGetLimit(pValue, limit) -{{endif}} + return _static_cudaDeviceGetLimit(pValue, limit) -{{if 'cudaDeviceGetTexture1DLinearMaxWidth' in found_functions}} cdef cudaError_t _cudaDeviceGetTexture1DLinearMaxWidth(size_t* maxWidthInElements, const cudaChannelFormatDesc* fmtDesc, int device) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceGetTexture1DLinearMaxWidth(maxWidthInElements, fmtDesc, device) - return cudaDeviceGetTexture1DLinearMaxWidth(maxWidthInElements, fmtDesc, device) -{{endif}} + return _static_cudaDeviceGetTexture1DLinearMaxWidth(maxWidthInElements, fmtDesc, device) -{{if 'cudaDeviceGetCacheConfig' in found_functions}} cdef cudaError_t _cudaDeviceGetCacheConfig(cudaFuncCache* pCacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceGetCacheConfig(pCacheConfig) - return cudaDeviceGetCacheConfig(pCacheConfig) -{{endif}} + return _static_cudaDeviceGetCacheConfig(pCacheConfig) -{{if 'cudaDeviceGetStreamPriorityRange' in found_functions}} cdef cudaError_t _cudaDeviceGetStreamPriorityRange(int* leastPriority, int* greatestPriority) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceGetStreamPriorityRange(leastPriority, greatestPriority) - return cudaDeviceGetStreamPriorityRange(leastPriority, greatestPriority) -{{endif}} + return _static_cudaDeviceGetStreamPriorityRange(leastPriority, greatestPriority) -{{if 'cudaDeviceSetCacheConfig' in found_functions}} cdef cudaError_t _cudaDeviceSetCacheConfig(cudaFuncCache cacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceSetCacheConfig(cacheConfig) - return cudaDeviceSetCacheConfig(cacheConfig) -{{endif}} + return _static_cudaDeviceSetCacheConfig(cacheConfig) -{{if 'cudaDeviceGetByPCIBusId' in found_functions}} cdef cudaError_t _cudaDeviceGetByPCIBusId(int* device, const char* pciBusId) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceGetByPCIBusId(device, pciBusId) - return cudaDeviceGetByPCIBusId(device, pciBusId) -{{endif}} + return _static_cudaDeviceGetByPCIBusId(device, pciBusId) -{{if 'cudaDeviceGetPCIBusId' in found_functions}} -cdef cudaError_t _cudaDeviceGetPCIBusId(char* pciBusId, int length, int device) except ?cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceGetPCIBusId(char* pciBusId, int len, int device) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: - return ptds._cudaDeviceGetPCIBusId(pciBusId, length, device) - return cudaDeviceGetPCIBusId(pciBusId, length, device) -{{endif}} + return ptds._cudaDeviceGetPCIBusId(pciBusId, len, device) + return _static_cudaDeviceGetPCIBusId(pciBusId, len, device) -{{if 'cudaIpcGetEventHandle' in found_functions}} cdef cudaError_t _cudaIpcGetEventHandle(cudaIpcEventHandle_t* handle, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaIpcGetEventHandle(handle, event) - return cudaIpcGetEventHandle(handle, event) -{{endif}} + return _static_cudaIpcGetEventHandle(handle, event) -{{if 'cudaIpcOpenEventHandle' in found_functions}} cdef cudaError_t _cudaIpcOpenEventHandle(cudaEvent_t* event, cudaIpcEventHandle_t handle) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaIpcOpenEventHandle(event, handle) - return cudaIpcOpenEventHandle(event, handle) -{{endif}} + return _static_cudaIpcOpenEventHandle(event, handle) -{{if 'cudaIpcGetMemHandle' in found_functions}} cdef cudaError_t _cudaIpcGetMemHandle(cudaIpcMemHandle_t* handle, void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaIpcGetMemHandle(handle, devPtr) - return cudaIpcGetMemHandle(handle, devPtr) -{{endif}} + return _static_cudaIpcGetMemHandle(handle, devPtr) -{{if 'cudaIpcOpenMemHandle' in found_functions}} cdef cudaError_t _cudaIpcOpenMemHandle(void** devPtr, cudaIpcMemHandle_t handle, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaIpcOpenMemHandle(devPtr, handle, flags) - return cudaIpcOpenMemHandle(devPtr, handle, flags) -{{endif}} + return _static_cudaIpcOpenMemHandle(devPtr, handle, flags) -{{if 'cudaIpcCloseMemHandle' in found_functions}} cdef cudaError_t _cudaIpcCloseMemHandle(void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaIpcCloseMemHandle(devPtr) - return cudaIpcCloseMemHandle(devPtr) -{{endif}} + return _static_cudaIpcCloseMemHandle(devPtr) -{{if 'cudaDeviceFlushGPUDirectRDMAWrites' in found_functions}} cdef cudaError_t _cudaDeviceFlushGPUDirectRDMAWrites(cudaFlushGPUDirectRDMAWritesTarget target, cudaFlushGPUDirectRDMAWritesScope scope) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceFlushGPUDirectRDMAWrites(target, scope) - return cudaDeviceFlushGPUDirectRDMAWrites(target, scope) -{{endif}} + return _static_cudaDeviceFlushGPUDirectRDMAWrites(target, scope) -{{if 'cudaDeviceRegisterAsyncNotification' in found_functions}} cdef cudaError_t _cudaDeviceRegisterAsyncNotification(int device, cudaAsyncCallback callbackFunc, void* userData, cudaAsyncCallbackHandle_t* callback) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceRegisterAsyncNotification(device, callbackFunc, userData, callback) - return cudaDeviceRegisterAsyncNotification(device, callbackFunc, userData, callback) -{{endif}} + return _static_cudaDeviceRegisterAsyncNotification(device, callbackFunc, userData, callback) -{{if 'cudaDeviceUnregisterAsyncNotification' in found_functions}} cdef cudaError_t _cudaDeviceUnregisterAsyncNotification(int device, cudaAsyncCallbackHandle_t callback) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceUnregisterAsyncNotification(device, callback) - return cudaDeviceUnregisterAsyncNotification(device, callback) -{{endif}} + return _static_cudaDeviceUnregisterAsyncNotification(device, callback) -{{if 'cudaDeviceGetSharedMemConfig' in found_functions}} cdef cudaError_t _cudaDeviceGetSharedMemConfig(cudaSharedMemConfig* pConfig) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceGetSharedMemConfig(pConfig) - return cudaDeviceGetSharedMemConfig(pConfig) -{{endif}} + return _static_cudaDeviceGetSharedMemConfig(pConfig) -{{if 'cudaDeviceSetSharedMemConfig' in found_functions}} cdef cudaError_t _cudaDeviceSetSharedMemConfig(cudaSharedMemConfig config) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceSetSharedMemConfig(config) - return cudaDeviceSetSharedMemConfig(config) -{{endif}} + return _static_cudaDeviceSetSharedMemConfig(config) -{{if 'cudaGetLastError' in found_functions}} cdef cudaError_t _cudaGetLastError() except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGetLastError() - return cudaGetLastError() -{{endif}} + return _static_cudaGetLastError() -{{if 'cudaPeekAtLastError' in found_functions}} cdef cudaError_t _cudaPeekAtLastError() except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaPeekAtLastError() - return cudaPeekAtLastError() -{{endif}} + return _static_cudaPeekAtLastError() -{{if 'cudaGetErrorName' in found_functions}} -cdef const char* _cudaGetErrorName(cudaError_t error) except ?NULL nogil: +cdef const char* _cudaGetErrorName(cudaError_t error) except?NULL nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGetErrorName(error) - return cudaGetErrorName(error) -{{endif}} + return _static_cudaGetErrorName(error) -{{if 'cudaGetErrorString' in found_functions}} -cdef const char* _cudaGetErrorString(cudaError_t error) except ?NULL nogil: +cdef const char* _cudaGetErrorString(cudaError_t error) except?NULL nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGetErrorString(error) - return cudaGetErrorString(error) -{{endif}} + return _static_cudaGetErrorString(error) -{{if 'cudaGetDeviceCount' in found_functions}} cdef cudaError_t _cudaGetDeviceCount(int* count) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGetDeviceCount(count) - return cudaGetDeviceCount(count) -{{endif}} - -{{if 'cudaGetDeviceProperties' in found_functions}} - -cdef cudaError_t _cudaGetDeviceProperties(cudaDeviceProp* prop, int device) except ?cudaErrorCallRequiresNewerDriver nogil: - cdef bint usePTDS = cudaPythonInit() - if usePTDS: - return ptds._cudaGetDeviceProperties(prop, device) - return cudaGetDeviceProperties(prop, device) -{{endif}} + return _static_cudaGetDeviceCount(count) -{{if 'cudaDeviceGetAttribute' in found_functions}} cdef cudaError_t _cudaDeviceGetAttribute(int* value, cudaDeviceAttr attr, int device) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceGetAttribute(value, attr, device) - return cudaDeviceGetAttribute(value, attr, device) -{{endif}} - -{{if 'cudaDeviceGetHostAtomicCapabilities' in found_functions}} - -cdef cudaError_t _cudaDeviceGetHostAtomicCapabilities(unsigned int* capabilities, const cudaAtomicOperation* operations, unsigned int count, int device) except ?cudaErrorCallRequiresNewerDriver nogil: - cdef bint usePTDS = cudaPythonInit() - if usePTDS: - return ptds._cudaDeviceGetHostAtomicCapabilities(capabilities, operations, count, device) - return cudaDeviceGetHostAtomicCapabilities(capabilities, operations, count, device) -{{endif}} + return _static_cudaDeviceGetAttribute(value, attr, device) -{{if 'cudaDeviceGetDefaultMemPool' in found_functions}} cdef cudaError_t _cudaDeviceGetDefaultMemPool(cudaMemPool_t* memPool, int device) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceGetDefaultMemPool(memPool, device) - return cudaDeviceGetDefaultMemPool(memPool, device) -{{endif}} + return _static_cudaDeviceGetDefaultMemPool(memPool, device) -{{if 'cudaDeviceSetMemPool' in found_functions}} cdef cudaError_t _cudaDeviceSetMemPool(int device, cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceSetMemPool(device, memPool) - return cudaDeviceSetMemPool(device, memPool) -{{endif}} + return _static_cudaDeviceSetMemPool(device, memPool) -{{if 'cudaDeviceGetMemPool' in found_functions}} cdef cudaError_t _cudaDeviceGetMemPool(cudaMemPool_t* memPool, int device) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceGetMemPool(memPool, device) - return cudaDeviceGetMemPool(memPool, device) -{{endif}} + return _static_cudaDeviceGetMemPool(memPool, device) -{{if 'cudaDeviceGetNvSciSyncAttributes' in found_functions}} cdef cudaError_t _cudaDeviceGetNvSciSyncAttributes(void* nvSciSyncAttrList, int device, int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceGetNvSciSyncAttributes(nvSciSyncAttrList, device, flags) - return cudaDeviceGetNvSciSyncAttributes(nvSciSyncAttrList, device, flags) -{{endif}} + return _static_cudaDeviceGetNvSciSyncAttributes(nvSciSyncAttrList, device, flags) -{{if 'cudaDeviceGetP2PAttribute' in found_functions}} cdef cudaError_t _cudaDeviceGetP2PAttribute(int* value, cudaDeviceP2PAttr attr, int srcDevice, int dstDevice) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceGetP2PAttribute(value, attr, srcDevice, dstDevice) - return cudaDeviceGetP2PAttribute(value, attr, srcDevice, dstDevice) -{{endif}} + return _static_cudaDeviceGetP2PAttribute(value, attr, srcDevice, dstDevice) -{{if 'cudaDeviceGetP2PAtomicCapabilities' in found_functions}} - -cdef cudaError_t _cudaDeviceGetP2PAtomicCapabilities(unsigned int* capabilities, const cudaAtomicOperation* operations, unsigned int count, int srcDevice, int dstDevice) except ?cudaErrorCallRequiresNewerDriver nogil: - cdef bint usePTDS = cudaPythonInit() - if usePTDS: - return ptds._cudaDeviceGetP2PAtomicCapabilities(capabilities, operations, count, srcDevice, dstDevice) - return cudaDeviceGetP2PAtomicCapabilities(capabilities, operations, count, srcDevice, dstDevice) -{{endif}} - -{{if 'cudaChooseDevice' in found_functions}} cdef cudaError_t _cudaChooseDevice(int* device, const cudaDeviceProp* prop) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaChooseDevice(device, prop) - return cudaChooseDevice(device, prop) -{{endif}} + return _static_cudaChooseDevice(device, prop) -{{if 'cudaInitDevice' in found_functions}} cdef cudaError_t _cudaInitDevice(int device, unsigned int deviceFlags, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaInitDevice(device, deviceFlags, flags) - return cudaInitDevice(device, deviceFlags, flags) -{{endif}} + return _static_cudaInitDevice(device, deviceFlags, flags) -{{if 'cudaSetDevice' in found_functions}} cdef cudaError_t _cudaSetDevice(int device) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaSetDevice(device) - return cudaSetDevice(device) -{{endif}} + return _static_cudaSetDevice(device) -{{if 'cudaGetDevice' in found_functions}} cdef cudaError_t _cudaGetDevice(int* device) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGetDevice(device) - return cudaGetDevice(device) -{{endif}} + return _static_cudaGetDevice(device) -{{if 'cudaSetDeviceFlags' in found_functions}} cdef cudaError_t _cudaSetDeviceFlags(unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaSetDeviceFlags(flags) - return cudaSetDeviceFlags(flags) -{{endif}} + return _static_cudaSetDeviceFlags(flags) -{{if 'cudaGetDeviceFlags' in found_functions}} cdef cudaError_t _cudaGetDeviceFlags(unsigned int* flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGetDeviceFlags(flags) - return cudaGetDeviceFlags(flags) -{{endif}} + return _static_cudaGetDeviceFlags(flags) -{{if 'cudaStreamCreate' in found_functions}} cdef cudaError_t _cudaStreamCreate(cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaStreamCreate(pStream) - return cudaStreamCreate(pStream) -{{endif}} + return _static_cudaStreamCreate(pStream) -{{if 'cudaStreamCreateWithFlags' in found_functions}} cdef cudaError_t _cudaStreamCreateWithFlags(cudaStream_t* pStream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaStreamCreateWithFlags(pStream, flags) - return cudaStreamCreateWithFlags(pStream, flags) -{{endif}} + return _static_cudaStreamCreateWithFlags(pStream, flags) -{{if 'cudaStreamCreateWithPriority' in found_functions}} cdef cudaError_t _cudaStreamCreateWithPriority(cudaStream_t* pStream, unsigned int flags, int priority) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaStreamCreateWithPriority(pStream, flags, priority) - return cudaStreamCreateWithPriority(pStream, flags, priority) -{{endif}} + return _static_cudaStreamCreateWithPriority(pStream, flags, priority) -{{if 'cudaStreamGetPriority' in found_functions}} cdef cudaError_t _cudaStreamGetPriority(cudaStream_t hStream, int* priority) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaStreamGetPriority(hStream, priority) - return cudaStreamGetPriority(hStream, priority) -{{endif}} + return _static_cudaStreamGetPriority(hStream, priority) -{{if 'cudaStreamGetFlags' in found_functions}} cdef cudaError_t _cudaStreamGetFlags(cudaStream_t hStream, unsigned int* flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaStreamGetFlags(hStream, flags) - return cudaStreamGetFlags(hStream, flags) -{{endif}} + return _static_cudaStreamGetFlags(hStream, flags) -{{if 'cudaStreamGetId' in found_functions}} cdef cudaError_t _cudaStreamGetId(cudaStream_t hStream, unsigned long long* streamId) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaStreamGetId(hStream, streamId) - return cudaStreamGetId(hStream, streamId) -{{endif}} + return _static_cudaStreamGetId(hStream, streamId) -{{if 'cudaStreamGetDevice' in found_functions}} cdef cudaError_t _cudaStreamGetDevice(cudaStream_t hStream, int* device) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaStreamGetDevice(hStream, device) - return cudaStreamGetDevice(hStream, device) -{{endif}} + return _static_cudaStreamGetDevice(hStream, device) -{{if 'cudaCtxResetPersistingL2Cache' in found_functions}} cdef cudaError_t _cudaCtxResetPersistingL2Cache() except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaCtxResetPersistingL2Cache() - return cudaCtxResetPersistingL2Cache() -{{endif}} + return _static_cudaCtxResetPersistingL2Cache() -{{if 'cudaStreamCopyAttributes' in found_functions}} cdef cudaError_t _cudaStreamCopyAttributes(cudaStream_t dst, cudaStream_t src) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaStreamCopyAttributes(dst, src) - return cudaStreamCopyAttributes(dst, src) -{{endif}} + return _static_cudaStreamCopyAttributes(dst, src) -{{if 'cudaStreamGetAttribute' in found_functions}} cdef cudaError_t _cudaStreamGetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, cudaStreamAttrValue* value_out) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaStreamGetAttribute(hStream, attr, value_out) - return cudaStreamGetAttribute(hStream, attr, value_out) -{{endif}} + return _static_cudaStreamGetAttribute(hStream, attr, value_out) -{{if 'cudaStreamSetAttribute' in found_functions}} cdef cudaError_t _cudaStreamSetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, const cudaStreamAttrValue* value) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaStreamSetAttribute(hStream, attr, value) - return cudaStreamSetAttribute(hStream, attr, value) -{{endif}} + return _static_cudaStreamSetAttribute(hStream, attr, value) -{{if 'cudaStreamDestroy' in found_functions}} cdef cudaError_t _cudaStreamDestroy(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaStreamDestroy(stream) - return cudaStreamDestroy(stream) -{{endif}} + return _static_cudaStreamDestroy(stream) -{{if 'cudaStreamWaitEvent' in found_functions}} cdef cudaError_t _cudaStreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaStreamWaitEvent(stream, event, flags) - return cudaStreamWaitEvent(stream, event, flags) -{{endif}} + return _static_cudaStreamWaitEvent(stream, event, flags) -{{if 'cudaStreamAddCallback' in found_functions}} cdef cudaError_t _cudaStreamAddCallback(cudaStream_t stream, cudaStreamCallback_t callback, void* userData, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaStreamAddCallback(stream, callback, userData, flags) - return cudaStreamAddCallback(stream, callback, userData, flags) -{{endif}} + return _static_cudaStreamAddCallback(stream, callback, userData, flags) -{{if 'cudaStreamSynchronize' in found_functions}} cdef cudaError_t _cudaStreamSynchronize(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaStreamSynchronize(stream) - return cudaStreamSynchronize(stream) -{{endif}} + return _static_cudaStreamSynchronize(stream) -{{if 'cudaStreamQuery' in found_functions}} cdef cudaError_t _cudaStreamQuery(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaStreamQuery(stream) - return cudaStreamQuery(stream) -{{endif}} + return _static_cudaStreamQuery(stream) -{{if 'cudaStreamAttachMemAsync' in found_functions}} cdef cudaError_t _cudaStreamAttachMemAsync(cudaStream_t stream, void* devPtr, size_t length, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaStreamAttachMemAsync(stream, devPtr, length, flags) - return cudaStreamAttachMemAsync(stream, devPtr, length, flags) -{{endif}} + return _static_cudaStreamAttachMemAsync(stream, devPtr, length, flags) -{{if 'cudaStreamBeginCapture' in found_functions}} cdef cudaError_t _cudaStreamBeginCapture(cudaStream_t stream, cudaStreamCaptureMode mode) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaStreamBeginCapture(stream, mode) - return cudaStreamBeginCapture(stream, mode) -{{endif}} - -{{if 'cudaStreamBeginRecaptureToGraph' in found_functions}} + return _static_cudaStreamBeginCapture(stream, mode) -cdef cudaError_t _cudaStreamBeginRecaptureToGraph(cudaStream_t stream, cudaStreamCaptureMode mode, cudaGraph_t graph, cudaGraphRecaptureCallbackData* callbackData) except ?cudaErrorCallRequiresNewerDriver nogil: - cdef bint usePTDS = cudaPythonInit() - if usePTDS: - return ptds._cudaStreamBeginRecaptureToGraph(stream, mode, graph, callbackData) - return cudaStreamBeginRecaptureToGraph(stream, mode, graph, callbackData) -{{endif}} - -{{if 'cudaStreamBeginCaptureToGraph' in found_functions}} cdef cudaError_t _cudaStreamBeginCaptureToGraph(cudaStream_t stream, cudaGraph_t graph, const cudaGraphNode_t* dependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, cudaStreamCaptureMode mode) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaStreamBeginCaptureToGraph(stream, graph, dependencies, dependencyData, numDependencies, mode) - return cudaStreamBeginCaptureToGraph(stream, graph, dependencies, dependencyData, numDependencies, mode) -{{endif}} + return _static_cudaStreamBeginCaptureToGraph(stream, graph, dependencies, dependencyData, numDependencies, mode) -{{if 'cudaThreadExchangeStreamCaptureMode' in found_functions}} cdef cudaError_t _cudaThreadExchangeStreamCaptureMode(cudaStreamCaptureMode* mode) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaThreadExchangeStreamCaptureMode(mode) - return cudaThreadExchangeStreamCaptureMode(mode) -{{endif}} + return _static_cudaThreadExchangeStreamCaptureMode(mode) -{{if 'cudaStreamEndCapture' in found_functions}} cdef cudaError_t _cudaStreamEndCapture(cudaStream_t stream, cudaGraph_t* pGraph) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaStreamEndCapture(stream, pGraph) - return cudaStreamEndCapture(stream, pGraph) -{{endif}} + return _static_cudaStreamEndCapture(stream, pGraph) -{{if 'cudaStreamIsCapturing' in found_functions}} cdef cudaError_t _cudaStreamIsCapturing(cudaStream_t stream, cudaStreamCaptureStatus* pCaptureStatus) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaStreamIsCapturing(stream, pCaptureStatus) - return cudaStreamIsCapturing(stream, pCaptureStatus) -{{endif}} + return _static_cudaStreamIsCapturing(stream, pCaptureStatus) -{{if 'cudaStreamGetCaptureInfo' in found_functions}} - -cdef cudaError_t _cudaStreamGetCaptureInfo(cudaStream_t stream, cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out, cudaGraph_t* graph_out, const cudaGraphNode_t** dependencies_out, const cudaGraphEdgeData** edgeData_out, size_t* numDependencies_out) except ?cudaErrorCallRequiresNewerDriver nogil: - cdef bint usePTDS = cudaPythonInit() - if usePTDS: - return ptds._cudaStreamGetCaptureInfo(stream, captureStatus_out, id_out, graph_out, dependencies_out, edgeData_out, numDependencies_out) - return cudaStreamGetCaptureInfo(stream, captureStatus_out, id_out, graph_out, dependencies_out, edgeData_out, numDependencies_out) -{{endif}} - -{{if 'cudaStreamUpdateCaptureDependencies' in found_functions}} cdef cudaError_t _cudaStreamUpdateCaptureDependencies(cudaStream_t stream, cudaGraphNode_t* dependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaStreamUpdateCaptureDependencies(stream, dependencies, dependencyData, numDependencies, flags) - return cudaStreamUpdateCaptureDependencies(stream, dependencies, dependencyData, numDependencies, flags) -{{endif}} + return _static_cudaStreamUpdateCaptureDependencies(stream, dependencies, dependencyData, numDependencies, flags) -{{if 'cudaEventCreate' in found_functions}} cdef cudaError_t _cudaEventCreate(cudaEvent_t* event) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaEventCreate(event) - return cudaEventCreate(event) -{{endif}} + return _static_cudaEventCreate(event) -{{if 'cudaEventCreateWithFlags' in found_functions}} cdef cudaError_t _cudaEventCreateWithFlags(cudaEvent_t* event, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaEventCreateWithFlags(event, flags) - return cudaEventCreateWithFlags(event, flags) -{{endif}} + return _static_cudaEventCreateWithFlags(event, flags) -{{if 'cudaEventRecord' in found_functions}} cdef cudaError_t _cudaEventRecord(cudaEvent_t event, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaEventRecord(event, stream) - return cudaEventRecord(event, stream) -{{endif}} + return _static_cudaEventRecord(event, stream) -{{if 'cudaEventRecordWithFlags' in found_functions}} cdef cudaError_t _cudaEventRecordWithFlags(cudaEvent_t event, cudaStream_t stream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaEventRecordWithFlags(event, stream, flags) - return cudaEventRecordWithFlags(event, stream, flags) -{{endif}} + return _static_cudaEventRecordWithFlags(event, stream, flags) -{{if 'cudaEventQuery' in found_functions}} cdef cudaError_t _cudaEventQuery(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaEventQuery(event) - return cudaEventQuery(event) -{{endif}} + return _static_cudaEventQuery(event) -{{if 'cudaEventSynchronize' in found_functions}} cdef cudaError_t _cudaEventSynchronize(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaEventSynchronize(event) - return cudaEventSynchronize(event) -{{endif}} + return _static_cudaEventSynchronize(event) -{{if 'cudaEventDestroy' in found_functions}} cdef cudaError_t _cudaEventDestroy(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaEventDestroy(event) - return cudaEventDestroy(event) -{{endif}} + return _static_cudaEventDestroy(event) -{{if 'cudaEventElapsedTime' in found_functions}} cdef cudaError_t _cudaEventElapsedTime(float* ms, cudaEvent_t start, cudaEvent_t end) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaEventElapsedTime(ms, start, end) - return cudaEventElapsedTime(ms, start, end) -{{endif}} + return _static_cudaEventElapsedTime(ms, start, end) -{{if 'cudaImportExternalMemory' in found_functions}} cdef cudaError_t _cudaImportExternalMemory(cudaExternalMemory_t* extMem_out, const cudaExternalMemoryHandleDesc* memHandleDesc) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaImportExternalMemory(extMem_out, memHandleDesc) - return cudaImportExternalMemory(extMem_out, memHandleDesc) -{{endif}} + return _static_cudaImportExternalMemory(extMem_out, memHandleDesc) -{{if 'cudaExternalMemoryGetMappedBuffer' in found_functions}} cdef cudaError_t _cudaExternalMemoryGetMappedBuffer(void** devPtr, cudaExternalMemory_t extMem, const cudaExternalMemoryBufferDesc* bufferDesc) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaExternalMemoryGetMappedBuffer(devPtr, extMem, bufferDesc) - return cudaExternalMemoryGetMappedBuffer(devPtr, extMem, bufferDesc) -{{endif}} + return _static_cudaExternalMemoryGetMappedBuffer(devPtr, extMem, bufferDesc) -{{if 'cudaExternalMemoryGetMappedMipmappedArray' in found_functions}} cdef cudaError_t _cudaExternalMemoryGetMappedMipmappedArray(cudaMipmappedArray_t* mipmap, cudaExternalMemory_t extMem, const cudaExternalMemoryMipmappedArrayDesc* mipmapDesc) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaExternalMemoryGetMappedMipmappedArray(mipmap, extMem, mipmapDesc) - return cudaExternalMemoryGetMappedMipmappedArray(mipmap, extMem, mipmapDesc) -{{endif}} + return _static_cudaExternalMemoryGetMappedMipmappedArray(mipmap, extMem, mipmapDesc) -{{if 'cudaDestroyExternalMemory' in found_functions}} cdef cudaError_t _cudaDestroyExternalMemory(cudaExternalMemory_t extMem) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDestroyExternalMemory(extMem) - return cudaDestroyExternalMemory(extMem) -{{endif}} + return _static_cudaDestroyExternalMemory(extMem) -{{if 'cudaImportExternalSemaphore' in found_functions}} cdef cudaError_t _cudaImportExternalSemaphore(cudaExternalSemaphore_t* extSem_out, const cudaExternalSemaphoreHandleDesc* semHandleDesc) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaImportExternalSemaphore(extSem_out, semHandleDesc) - return cudaImportExternalSemaphore(extSem_out, semHandleDesc) -{{endif}} + return _static_cudaImportExternalSemaphore(extSem_out, semHandleDesc) -{{if 'cudaSignalExternalSemaphoresAsync' in found_functions}} - -cdef cudaError_t _cudaSignalExternalSemaphoresAsync(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreSignalParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - cdef bint usePTDS = cudaPythonInit() - if usePTDS: - return ptds._cudaSignalExternalSemaphoresAsync(extSemArray, paramsArray, numExtSems, stream) - return cudaSignalExternalSemaphoresAsync(extSemArray, paramsArray, numExtSems, stream) -{{endif}} - -{{if 'cudaWaitExternalSemaphoresAsync' in found_functions}} - -cdef cudaError_t _cudaWaitExternalSemaphoresAsync(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreWaitParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - cdef bint usePTDS = cudaPythonInit() - if usePTDS: - return ptds._cudaWaitExternalSemaphoresAsync(extSemArray, paramsArray, numExtSems, stream) - return cudaWaitExternalSemaphoresAsync(extSemArray, paramsArray, numExtSems, stream) -{{endif}} - -{{if 'cudaDestroyExternalSemaphore' in found_functions}} cdef cudaError_t _cudaDestroyExternalSemaphore(cudaExternalSemaphore_t extSem) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDestroyExternalSemaphore(extSem) - return cudaDestroyExternalSemaphore(extSem) -{{endif}} + return _static_cudaDestroyExternalSemaphore(extSem) -{{if 'cudaFuncSetCacheConfig' in found_functions}} cdef cudaError_t _cudaFuncSetCacheConfig(const void* func, cudaFuncCache cacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaFuncSetCacheConfig(func, cacheConfig) - return cudaFuncSetCacheConfig(func, cacheConfig) -{{endif}} + return _static_cudaFuncSetCacheConfig(func, cacheConfig) -{{if 'cudaFuncGetAttributes' in found_functions}} cdef cudaError_t _cudaFuncGetAttributes(cudaFuncAttributes* attr, const void* func) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaFuncGetAttributes(attr, func) - return cudaFuncGetAttributes(attr, func) -{{endif}} + return _static_cudaFuncGetAttributes(attr, func) -{{if 'cudaFuncSetAttribute' in found_functions}} cdef cudaError_t _cudaFuncSetAttribute(const void* func, cudaFuncAttribute attr, int value) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaFuncSetAttribute(func, attr, value) - return cudaFuncSetAttribute(func, attr, value) -{{endif}} + return _static_cudaFuncSetAttribute(func, attr, value) -{{if 'cudaFuncGetParamCount' in found_functions}} -cdef cudaError_t _cudaFuncGetParamCount(const void* func, size_t* paramCount) except ?cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaFuncGetName(const char** name, const void* func) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: - return ptds._cudaFuncGetParamCount(func, paramCount) - return cudaFuncGetParamCount(func, paramCount) -{{endif}} + return ptds._cudaFuncGetName(name, func) + return _static_cudaFuncGetName(name, func) -{{if 'cudaLaunchHostFunc' in found_functions}} -cdef cudaError_t _cudaLaunchHostFunc(cudaStream_t stream, cudaHostFn_t fn, void* userData) except ?cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaFuncGetParamInfo(const void* func, size_t paramIndex, size_t* paramOffset, size_t* paramSize) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: - return ptds._cudaLaunchHostFunc(stream, fn, userData) - return cudaLaunchHostFunc(stream, fn, userData) -{{endif}} + return ptds._cudaFuncGetParamInfo(func, paramIndex, paramOffset, paramSize) + return _static_cudaFuncGetParamInfo(func, paramIndex, paramOffset, paramSize) -{{if 'cudaLaunchHostFunc_v2' in found_functions}} -cdef cudaError_t _cudaLaunchHostFunc_v2(cudaStream_t stream, cudaHostFn_t fn, void* userData, unsigned int syncMode) except ?cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaLaunchHostFunc(cudaStream_t stream, cudaHostFn_t fn, void* userData) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: - return ptds._cudaLaunchHostFunc_v2(stream, fn, userData, syncMode) - return cudaLaunchHostFunc_v2(stream, fn, userData, syncMode) -{{endif}} + return ptds._cudaLaunchHostFunc(stream, fn, userData) + return _static_cudaLaunchHostFunc(stream, fn, userData) -{{if 'cudaFuncSetSharedMemConfig' in found_functions}} cdef cudaError_t _cudaFuncSetSharedMemConfig(const void* func, cudaSharedMemConfig config) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaFuncSetSharedMemConfig(func, config) - return cudaFuncSetSharedMemConfig(func, config) -{{endif}} + return _static_cudaFuncSetSharedMemConfig(func, config) -{{if 'cudaOccupancyMaxActiveBlocksPerMultiprocessor' in found_functions}} cdef cudaError_t _cudaOccupancyMaxActiveBlocksPerMultiprocessor(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaOccupancyMaxActiveBlocksPerMultiprocessor(numBlocks, func, blockSize, dynamicSMemSize) - return cudaOccupancyMaxActiveBlocksPerMultiprocessor(numBlocks, func, blockSize, dynamicSMemSize) -{{endif}} + return _static_cudaOccupancyMaxActiveBlocksPerMultiprocessor(numBlocks, func, blockSize, dynamicSMemSize) -{{if 'cudaOccupancyAvailableDynamicSMemPerBlock' in found_functions}} cdef cudaError_t _cudaOccupancyAvailableDynamicSMemPerBlock(size_t* dynamicSmemSize, const void* func, int numBlocks, int blockSize) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaOccupancyAvailableDynamicSMemPerBlock(dynamicSmemSize, func, numBlocks, blockSize) - return cudaOccupancyAvailableDynamicSMemPerBlock(dynamicSmemSize, func, numBlocks, blockSize) -{{endif}} + return _static_cudaOccupancyAvailableDynamicSMemPerBlock(dynamicSmemSize, func, numBlocks, blockSize) -{{if 'cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags' in found_functions}} cdef cudaError_t _cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(numBlocks, func, blockSize, dynamicSMemSize, flags) - return cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(numBlocks, func, blockSize, dynamicSMemSize, flags) -{{endif}} + return _static_cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(numBlocks, func, blockSize, dynamicSMemSize, flags) -{{if 'cudaMallocManaged' in found_functions}} cdef cudaError_t _cudaMallocManaged(void** devPtr, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMallocManaged(devPtr, size, flags) - return cudaMallocManaged(devPtr, size, flags) -{{endif}} + return _static_cudaMallocManaged(devPtr, size, flags) -{{if 'cudaMalloc' in found_functions}} cdef cudaError_t _cudaMalloc(void** devPtr, size_t size) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMalloc(devPtr, size) - return cudaMalloc(devPtr, size) -{{endif}} + return _static_cudaMalloc(devPtr, size) -{{if 'cudaMallocHost' in found_functions}} cdef cudaError_t _cudaMallocHost(void** ptr, size_t size) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMallocHost(ptr, size) - return cudaMallocHost(ptr, size) -{{endif}} + return _static_cudaMallocHost(ptr, size) -{{if 'cudaMallocPitch' in found_functions}} cdef cudaError_t _cudaMallocPitch(void** devPtr, size_t* pitch, size_t width, size_t height) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMallocPitch(devPtr, pitch, width, height) - return cudaMallocPitch(devPtr, pitch, width, height) -{{endif}} + return _static_cudaMallocPitch(devPtr, pitch, width, height) -{{if 'cudaMallocArray' in found_functions}} cdef cudaError_t _cudaMallocArray(cudaArray_t* array, const cudaChannelFormatDesc* desc, size_t width, size_t height, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMallocArray(array, desc, width, height, flags) - return cudaMallocArray(array, desc, width, height, flags) -{{endif}} + return _static_cudaMallocArray(array, desc, width, height, flags) -{{if 'cudaFree' in found_functions}} cdef cudaError_t _cudaFree(void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaFree(devPtr) - return cudaFree(devPtr) -{{endif}} + return _static_cudaFree(devPtr) -{{if 'cudaFreeHost' in found_functions}} cdef cudaError_t _cudaFreeHost(void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaFreeHost(ptr) - return cudaFreeHost(ptr) -{{endif}} + return _static_cudaFreeHost(ptr) -{{if 'cudaFreeArray' in found_functions}} cdef cudaError_t _cudaFreeArray(cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaFreeArray(array) - return cudaFreeArray(array) -{{endif}} + return _static_cudaFreeArray(array) -{{if 'cudaFreeMipmappedArray' in found_functions}} cdef cudaError_t _cudaFreeMipmappedArray(cudaMipmappedArray_t mipmappedArray) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaFreeMipmappedArray(mipmappedArray) - return cudaFreeMipmappedArray(mipmappedArray) -{{endif}} + return _static_cudaFreeMipmappedArray(mipmappedArray) -{{if 'cudaHostAlloc' in found_functions}} cdef cudaError_t _cudaHostAlloc(void** pHost, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaHostAlloc(pHost, size, flags) - return cudaHostAlloc(pHost, size, flags) -{{endif}} + return _static_cudaHostAlloc(pHost, size, flags) -{{if 'cudaHostRegister' in found_functions}} cdef cudaError_t _cudaHostRegister(void* ptr, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaHostRegister(ptr, size, flags) - return cudaHostRegister(ptr, size, flags) -{{endif}} + return _static_cudaHostRegister(ptr, size, flags) -{{if 'cudaHostUnregister' in found_functions}} cdef cudaError_t _cudaHostUnregister(void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaHostUnregister(ptr) - return cudaHostUnregister(ptr) -{{endif}} + return _static_cudaHostUnregister(ptr) -{{if 'cudaHostGetDevicePointer' in found_functions}} cdef cudaError_t _cudaHostGetDevicePointer(void** pDevice, void* pHost, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaHostGetDevicePointer(pDevice, pHost, flags) - return cudaHostGetDevicePointer(pDevice, pHost, flags) -{{endif}} + return _static_cudaHostGetDevicePointer(pDevice, pHost, flags) -{{if 'cudaHostGetFlags' in found_functions}} cdef cudaError_t _cudaHostGetFlags(unsigned int* pFlags, void* pHost) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaHostGetFlags(pFlags, pHost) - return cudaHostGetFlags(pFlags, pHost) -{{endif}} + return _static_cudaHostGetFlags(pFlags, pHost) -{{if 'cudaMalloc3D' in found_functions}} cdef cudaError_t _cudaMalloc3D(cudaPitchedPtr* pitchedDevPtr, cudaExtent extent) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMalloc3D(pitchedDevPtr, extent) - return cudaMalloc3D(pitchedDevPtr, extent) -{{endif}} + return _static_cudaMalloc3D(pitchedDevPtr, extent) -{{if 'cudaMalloc3DArray' in found_functions}} cdef cudaError_t _cudaMalloc3DArray(cudaArray_t* array, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMalloc3DArray(array, desc, extent, flags) - return cudaMalloc3DArray(array, desc, extent, flags) -{{endif}} + return _static_cudaMalloc3DArray(array, desc, extent, flags) -{{if 'cudaMallocMipmappedArray' in found_functions}} cdef cudaError_t _cudaMallocMipmappedArray(cudaMipmappedArray_t* mipmappedArray, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int numLevels, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMallocMipmappedArray(mipmappedArray, desc, extent, numLevels, flags) - return cudaMallocMipmappedArray(mipmappedArray, desc, extent, numLevels, flags) -{{endif}} + return _static_cudaMallocMipmappedArray(mipmappedArray, desc, extent, numLevels, flags) -{{if 'cudaGetMipmappedArrayLevel' in found_functions}} cdef cudaError_t _cudaGetMipmappedArrayLevel(cudaArray_t* levelArray, cudaMipmappedArray_const_t mipmappedArray, unsigned int level) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGetMipmappedArrayLevel(levelArray, mipmappedArray, level) - return cudaGetMipmappedArrayLevel(levelArray, mipmappedArray, level) -{{endif}} + return _static_cudaGetMipmappedArrayLevel(levelArray, mipmappedArray, level) -{{if 'cudaMemcpy3D' in found_functions}} cdef cudaError_t _cudaMemcpy3D(const cudaMemcpy3DParms* p) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemcpy3D(p) - return cudaMemcpy3D(p) -{{endif}} + return _static_cudaMemcpy3D(p) -{{if 'cudaMemcpy3DPeer' in found_functions}} cdef cudaError_t _cudaMemcpy3DPeer(const cudaMemcpy3DPeerParms* p) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemcpy3DPeer(p) - return cudaMemcpy3DPeer(p) -{{endif}} + return _static_cudaMemcpy3DPeer(p) -{{if 'cudaMemcpy3DAsync' in found_functions}} cdef cudaError_t _cudaMemcpy3DAsync(const cudaMemcpy3DParms* p, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemcpy3DAsync(p, stream) - return cudaMemcpy3DAsync(p, stream) -{{endif}} + return _static_cudaMemcpy3DAsync(p, stream) -{{if 'cudaMemcpy3DPeerAsync' in found_functions}} cdef cudaError_t _cudaMemcpy3DPeerAsync(const cudaMemcpy3DPeerParms* p, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemcpy3DPeerAsync(p, stream) - return cudaMemcpy3DPeerAsync(p, stream) -{{endif}} + return _static_cudaMemcpy3DPeerAsync(p, stream) -{{if 'cudaMemGetInfo' in found_functions}} cdef cudaError_t _cudaMemGetInfo(size_t* free, size_t* total) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemGetInfo(free, total) - return cudaMemGetInfo(free, total) -{{endif}} + return _static_cudaMemGetInfo(free, total) -{{if 'cudaArrayGetInfo' in found_functions}} cdef cudaError_t _cudaArrayGetInfo(cudaChannelFormatDesc* desc, cudaExtent* extent, unsigned int* flags, cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaArrayGetInfo(desc, extent, flags, array) - return cudaArrayGetInfo(desc, extent, flags, array) -{{endif}} + return _static_cudaArrayGetInfo(desc, extent, flags, array) -{{if 'cudaArrayGetPlane' in found_functions}} cdef cudaError_t _cudaArrayGetPlane(cudaArray_t* pPlaneArray, cudaArray_t hArray, unsigned int planeIdx) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaArrayGetPlane(pPlaneArray, hArray, planeIdx) - return cudaArrayGetPlane(pPlaneArray, hArray, planeIdx) -{{endif}} + return _static_cudaArrayGetPlane(pPlaneArray, hArray, planeIdx) -{{if 'cudaArrayGetMemoryRequirements' in found_functions}} cdef cudaError_t _cudaArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaArray_t array, int device) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaArrayGetMemoryRequirements(memoryRequirements, array, device) - return cudaArrayGetMemoryRequirements(memoryRequirements, array, device) -{{endif}} + return _static_cudaArrayGetMemoryRequirements(memoryRequirements, array, device) -{{if 'cudaMipmappedArrayGetMemoryRequirements' in found_functions}} cdef cudaError_t _cudaMipmappedArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaMipmappedArray_t mipmap, int device) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMipmappedArrayGetMemoryRequirements(memoryRequirements, mipmap, device) - return cudaMipmappedArrayGetMemoryRequirements(memoryRequirements, mipmap, device) -{{endif}} + return _static_cudaMipmappedArrayGetMemoryRequirements(memoryRequirements, mipmap, device) -{{if 'cudaArrayGetSparseProperties' in found_functions}} cdef cudaError_t _cudaArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaArrayGetSparseProperties(sparseProperties, array) - return cudaArrayGetSparseProperties(sparseProperties, array) -{{endif}} + return _static_cudaArrayGetSparseProperties(sparseProperties, array) -{{if 'cudaMipmappedArrayGetSparseProperties' in found_functions}} cdef cudaError_t _cudaMipmappedArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaMipmappedArray_t mipmap) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMipmappedArrayGetSparseProperties(sparseProperties, mipmap) - return cudaMipmappedArrayGetSparseProperties(sparseProperties, mipmap) -{{endif}} + return _static_cudaMipmappedArrayGetSparseProperties(sparseProperties, mipmap) -{{if 'cudaMemcpy' in found_functions}} cdef cudaError_t _cudaMemcpy(void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemcpy(dst, src, count, kind) - return cudaMemcpy(dst, src, count, kind) -{{endif}} + return _static_cudaMemcpy(dst, src, count, kind) -{{if 'cudaMemcpyPeer' in found_functions}} cdef cudaError_t _cudaMemcpyPeer(void* dst, int dstDevice, const void* src, int srcDevice, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemcpyPeer(dst, dstDevice, src, srcDevice, count) - return cudaMemcpyPeer(dst, dstDevice, src, srcDevice, count) -{{endif}} + return _static_cudaMemcpyPeer(dst, dstDevice, src, srcDevice, count) -{{if 'cudaMemcpy2D' in found_functions}} cdef cudaError_t _cudaMemcpy2D(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemcpy2D(dst, dpitch, src, spitch, width, height, kind) - return cudaMemcpy2D(dst, dpitch, src, spitch, width, height, kind) -{{endif}} + return _static_cudaMemcpy2D(dst, dpitch, src, spitch, width, height, kind) -{{if 'cudaMemcpy2DToArray' in found_functions}} cdef cudaError_t _cudaMemcpy2DToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemcpy2DToArray(dst, wOffset, hOffset, src, spitch, width, height, kind) - return cudaMemcpy2DToArray(dst, wOffset, hOffset, src, spitch, width, height, kind) -{{endif}} + return _static_cudaMemcpy2DToArray(dst, wOffset, hOffset, src, spitch, width, height, kind) -{{if 'cudaMemcpy2DFromArray' in found_functions}} cdef cudaError_t _cudaMemcpy2DFromArray(void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemcpy2DFromArray(dst, dpitch, src, wOffset, hOffset, width, height, kind) - return cudaMemcpy2DFromArray(dst, dpitch, src, wOffset, hOffset, width, height, kind) -{{endif}} + return _static_cudaMemcpy2DFromArray(dst, dpitch, src, wOffset, hOffset, width, height, kind) -{{if 'cudaMemcpy2DArrayToArray' in found_functions}} cdef cudaError_t _cudaMemcpy2DArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemcpy2DArrayToArray(dst, wOffsetDst, hOffsetDst, src, wOffsetSrc, hOffsetSrc, width, height, kind) - return cudaMemcpy2DArrayToArray(dst, wOffsetDst, hOffsetDst, src, wOffsetSrc, hOffsetSrc, width, height, kind) -{{endif}} + return _static_cudaMemcpy2DArrayToArray(dst, wOffsetDst, hOffsetDst, src, wOffsetSrc, hOffsetSrc, width, height, kind) -{{if 'cudaMemcpyAsync' in found_functions}} cdef cudaError_t _cudaMemcpyAsync(void* dst, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemcpyAsync(dst, src, count, kind, stream) - return cudaMemcpyAsync(dst, src, count, kind, stream) -{{endif}} + return _static_cudaMemcpyAsync(dst, src, count, kind, stream) -{{if 'cudaMemcpyPeerAsync' in found_functions}} cdef cudaError_t _cudaMemcpyPeerAsync(void* dst, int dstDevice, const void* src, int srcDevice, size_t count, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemcpyPeerAsync(dst, dstDevice, src, srcDevice, count, stream) - return cudaMemcpyPeerAsync(dst, dstDevice, src, srcDevice, count, stream) -{{endif}} + return _static_cudaMemcpyPeerAsync(dst, dstDevice, src, srcDevice, count, stream) -{{if 'cudaMemcpyBatchAsync' in found_functions}} cdef cudaError_t _cudaMemcpyBatchAsync(const void** dsts, const void** srcs, const size_t* sizes, size_t count, cudaMemcpyAttributes* attrs, size_t* attrsIdxs, size_t numAttrs, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemcpyBatchAsync(dsts, srcs, sizes, count, attrs, attrsIdxs, numAttrs, stream) - return cudaMemcpyBatchAsync(dsts, srcs, sizes, count, attrs, attrsIdxs, numAttrs, stream) -{{endif}} + return _static_cudaMemcpyBatchAsync(dsts, srcs, sizes, count, attrs, attrsIdxs, numAttrs, stream) -{{if 'cudaMemcpy3DBatchAsync' in found_functions}} cdef cudaError_t _cudaMemcpy3DBatchAsync(size_t numOps, cudaMemcpy3DBatchOp* opList, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemcpy3DBatchAsync(numOps, opList, flags, stream) - return cudaMemcpy3DBatchAsync(numOps, opList, flags, stream) -{{endif}} + return _static_cudaMemcpy3DBatchAsync(numOps, opList, flags, stream) -{{if 'cudaMemcpyWithAttributesAsync' in found_functions}} - -cdef cudaError_t _cudaMemcpyWithAttributesAsync(void* dst, const void* src, size_t size, cudaMemcpyAttributes* attr, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - cdef bint usePTDS = cudaPythonInit() - if usePTDS: - return ptds._cudaMemcpyWithAttributesAsync(dst, src, size, attr, stream) - return cudaMemcpyWithAttributesAsync(dst, src, size, attr, stream) -{{endif}} - -{{if 'cudaMemcpy3DWithAttributesAsync' in found_functions}} - -cdef cudaError_t _cudaMemcpy3DWithAttributesAsync(cudaMemcpy3DBatchOp* op, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - cdef bint usePTDS = cudaPythonInit() - if usePTDS: - return ptds._cudaMemcpy3DWithAttributesAsync(op, flags, stream) - return cudaMemcpy3DWithAttributesAsync(op, flags, stream) -{{endif}} - -{{if 'cudaMemcpy2DAsync' in found_functions}} cdef cudaError_t _cudaMemcpy2DAsync(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemcpy2DAsync(dst, dpitch, src, spitch, width, height, kind, stream) - return cudaMemcpy2DAsync(dst, dpitch, src, spitch, width, height, kind, stream) -{{endif}} + return _static_cudaMemcpy2DAsync(dst, dpitch, src, spitch, width, height, kind, stream) -{{if 'cudaMemcpy2DToArrayAsync' in found_functions}} cdef cudaError_t _cudaMemcpy2DToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemcpy2DToArrayAsync(dst, wOffset, hOffset, src, spitch, width, height, kind, stream) - return cudaMemcpy2DToArrayAsync(dst, wOffset, hOffset, src, spitch, width, height, kind, stream) -{{endif}} + return _static_cudaMemcpy2DToArrayAsync(dst, wOffset, hOffset, src, spitch, width, height, kind, stream) -{{if 'cudaMemcpy2DFromArrayAsync' in found_functions}} cdef cudaError_t _cudaMemcpy2DFromArrayAsync(void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemcpy2DFromArrayAsync(dst, dpitch, src, wOffset, hOffset, width, height, kind, stream) - return cudaMemcpy2DFromArrayAsync(dst, dpitch, src, wOffset, hOffset, width, height, kind, stream) -{{endif}} + return _static_cudaMemcpy2DFromArrayAsync(dst, dpitch, src, wOffset, hOffset, width, height, kind, stream) -{{if 'cudaMemset' in found_functions}} cdef cudaError_t _cudaMemset(void* devPtr, int value, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemset(devPtr, value, count) - return cudaMemset(devPtr, value, count) -{{endif}} + return _static_cudaMemset(devPtr, value, count) -{{if 'cudaMemset2D' in found_functions}} cdef cudaError_t _cudaMemset2D(void* devPtr, size_t pitch, int value, size_t width, size_t height) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemset2D(devPtr, pitch, value, width, height) - return cudaMemset2D(devPtr, pitch, value, width, height) -{{endif}} + return _static_cudaMemset2D(devPtr, pitch, value, width, height) -{{if 'cudaMemset3D' in found_functions}} cdef cudaError_t _cudaMemset3D(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemset3D(pitchedDevPtr, value, extent) - return cudaMemset3D(pitchedDevPtr, value, extent) -{{endif}} + return _static_cudaMemset3D(pitchedDevPtr, value, extent) -{{if 'cudaMemsetAsync' in found_functions}} cdef cudaError_t _cudaMemsetAsync(void* devPtr, int value, size_t count, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemsetAsync(devPtr, value, count, stream) - return cudaMemsetAsync(devPtr, value, count, stream) -{{endif}} + return _static_cudaMemsetAsync(devPtr, value, count, stream) -{{if 'cudaMemset2DAsync' in found_functions}} cdef cudaError_t _cudaMemset2DAsync(void* devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemset2DAsync(devPtr, pitch, value, width, height, stream) - return cudaMemset2DAsync(devPtr, pitch, value, width, height, stream) -{{endif}} + return _static_cudaMemset2DAsync(devPtr, pitch, value, width, height, stream) -{{if 'cudaMemset3DAsync' in found_functions}} cdef cudaError_t _cudaMemset3DAsync(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemset3DAsync(pitchedDevPtr, value, extent, stream) - return cudaMemset3DAsync(pitchedDevPtr, value, extent, stream) -{{endif}} + return _static_cudaMemset3DAsync(pitchedDevPtr, value, extent, stream) -{{if 'cudaMemPrefetchAsync' in found_functions}} cdef cudaError_t _cudaMemPrefetchAsync(const void* devPtr, size_t count, cudaMemLocation location, unsigned int flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemPrefetchAsync(devPtr, count, location, flags, stream) - return cudaMemPrefetchAsync(devPtr, count, location, flags, stream) -{{endif}} - -{{if 'cudaMemPrefetchBatchAsync' in found_functions}} - -cdef cudaError_t _cudaMemPrefetchBatchAsync(void** dptrs, size_t* sizes, size_t count, cudaMemLocation* prefetchLocs, size_t* prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - cdef bint usePTDS = cudaPythonInit() - if usePTDS: - return ptds._cudaMemPrefetchBatchAsync(dptrs, sizes, count, prefetchLocs, prefetchLocIdxs, numPrefetchLocs, flags, stream) - return cudaMemPrefetchBatchAsync(dptrs, sizes, count, prefetchLocs, prefetchLocIdxs, numPrefetchLocs, flags, stream) -{{endif}} - -{{if 'cudaMemDiscardBatchAsync' in found_functions}} - -cdef cudaError_t _cudaMemDiscardBatchAsync(void** dptrs, size_t* sizes, size_t count, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - cdef bint usePTDS = cudaPythonInit() - if usePTDS: - return ptds._cudaMemDiscardBatchAsync(dptrs, sizes, count, flags, stream) - return cudaMemDiscardBatchAsync(dptrs, sizes, count, flags, stream) -{{endif}} - -{{if 'cudaMemDiscardAndPrefetchBatchAsync' in found_functions}} - -cdef cudaError_t _cudaMemDiscardAndPrefetchBatchAsync(void** dptrs, size_t* sizes, size_t count, cudaMemLocation* prefetchLocs, size_t* prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - cdef bint usePTDS = cudaPythonInit() - if usePTDS: - return ptds._cudaMemDiscardAndPrefetchBatchAsync(dptrs, sizes, count, prefetchLocs, prefetchLocIdxs, numPrefetchLocs, flags, stream) - return cudaMemDiscardAndPrefetchBatchAsync(dptrs, sizes, count, prefetchLocs, prefetchLocIdxs, numPrefetchLocs, flags, stream) -{{endif}} + return _static_cudaMemPrefetchAsync(devPtr, count, location, flags, stream) -{{if 'cudaMemAdvise' in found_functions}} cdef cudaError_t _cudaMemAdvise(const void* devPtr, size_t count, cudaMemoryAdvise advice, cudaMemLocation location) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemAdvise(devPtr, count, advice, location) - return cudaMemAdvise(devPtr, count, advice, location) -{{endif}} + return _static_cudaMemAdvise(devPtr, count, advice, location) -{{if 'cudaMemRangeGetAttribute' in found_functions}} cdef cudaError_t _cudaMemRangeGetAttribute(void* data, size_t dataSize, cudaMemRangeAttribute attribute, const void* devPtr, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemRangeGetAttribute(data, dataSize, attribute, devPtr, count) - return cudaMemRangeGetAttribute(data, dataSize, attribute, devPtr, count) -{{endif}} + return _static_cudaMemRangeGetAttribute(data, dataSize, attribute, devPtr, count) -{{if 'cudaMemRangeGetAttributes' in found_functions}} cdef cudaError_t _cudaMemRangeGetAttributes(void** data, size_t* dataSizes, cudaMemRangeAttribute* attributes, size_t numAttributes, const void* devPtr, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemRangeGetAttributes(data, dataSizes, attributes, numAttributes, devPtr, count) - return cudaMemRangeGetAttributes(data, dataSizes, attributes, numAttributes, devPtr, count) -{{endif}} + return _static_cudaMemRangeGetAttributes(data, dataSizes, attributes, numAttributes, devPtr, count) -{{if 'cudaMemcpyToArray' in found_functions}} cdef cudaError_t _cudaMemcpyToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemcpyToArray(dst, wOffset, hOffset, src, count, kind) - return cudaMemcpyToArray(dst, wOffset, hOffset, src, count, kind) -{{endif}} + return _static_cudaMemcpyToArray(dst, wOffset, hOffset, src, count, kind) -{{if 'cudaMemcpyFromArray' in found_functions}} cdef cudaError_t _cudaMemcpyFromArray(void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemcpyFromArray(dst, src, wOffset, hOffset, count, kind) - return cudaMemcpyFromArray(dst, src, wOffset, hOffset, count, kind) -{{endif}} + return _static_cudaMemcpyFromArray(dst, src, wOffset, hOffset, count, kind) -{{if 'cudaMemcpyArrayToArray' in found_functions}} cdef cudaError_t _cudaMemcpyArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemcpyArrayToArray(dst, wOffsetDst, hOffsetDst, src, wOffsetSrc, hOffsetSrc, count, kind) - return cudaMemcpyArrayToArray(dst, wOffsetDst, hOffsetDst, src, wOffsetSrc, hOffsetSrc, count, kind) -{{endif}} + return _static_cudaMemcpyArrayToArray(dst, wOffsetDst, hOffsetDst, src, wOffsetSrc, hOffsetSrc, count, kind) -{{if 'cudaMemcpyToArrayAsync' in found_functions}} cdef cudaError_t _cudaMemcpyToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemcpyToArrayAsync(dst, wOffset, hOffset, src, count, kind, stream) - return cudaMemcpyToArrayAsync(dst, wOffset, hOffset, src, count, kind, stream) -{{endif}} + return _static_cudaMemcpyToArrayAsync(dst, wOffset, hOffset, src, count, kind, stream) -{{if 'cudaMemcpyFromArrayAsync' in found_functions}} cdef cudaError_t _cudaMemcpyFromArrayAsync(void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemcpyFromArrayAsync(dst, src, wOffset, hOffset, count, kind, stream) - return cudaMemcpyFromArrayAsync(dst, src, wOffset, hOffset, count, kind, stream) -{{endif}} + return _static_cudaMemcpyFromArrayAsync(dst, src, wOffset, hOffset, count, kind, stream) -{{if 'cudaMallocAsync' in found_functions}} cdef cudaError_t _cudaMallocAsync(void** devPtr, size_t size, cudaStream_t hStream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMallocAsync(devPtr, size, hStream) - return cudaMallocAsync(devPtr, size, hStream) -{{endif}} + return _static_cudaMallocAsync(devPtr, size, hStream) -{{if 'cudaFreeAsync' in found_functions}} cdef cudaError_t _cudaFreeAsync(void* devPtr, cudaStream_t hStream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaFreeAsync(devPtr, hStream) - return cudaFreeAsync(devPtr, hStream) -{{endif}} + return _static_cudaFreeAsync(devPtr, hStream) -{{if 'cudaMemPoolTrimTo' in found_functions}} cdef cudaError_t _cudaMemPoolTrimTo(cudaMemPool_t memPool, size_t minBytesToKeep) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemPoolTrimTo(memPool, minBytesToKeep) - return cudaMemPoolTrimTo(memPool, minBytesToKeep) -{{endif}} + return _static_cudaMemPoolTrimTo(memPool, minBytesToKeep) -{{if 'cudaMemPoolSetAttribute' in found_functions}} cdef cudaError_t _cudaMemPoolSetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemPoolSetAttribute(memPool, attr, value) - return cudaMemPoolSetAttribute(memPool, attr, value) -{{endif}} + return _static_cudaMemPoolSetAttribute(memPool, attr, value) -{{if 'cudaMemPoolGetAttribute' in found_functions}} cdef cudaError_t _cudaMemPoolGetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemPoolGetAttribute(memPool, attr, value) - return cudaMemPoolGetAttribute(memPool, attr, value) -{{endif}} + return _static_cudaMemPoolGetAttribute(memPool, attr, value) -{{if 'cudaMemPoolSetAccess' in found_functions}} cdef cudaError_t _cudaMemPoolSetAccess(cudaMemPool_t memPool, const cudaMemAccessDesc* descList, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemPoolSetAccess(memPool, descList, count) - return cudaMemPoolSetAccess(memPool, descList, count) -{{endif}} + return _static_cudaMemPoolSetAccess(memPool, descList, count) -{{if 'cudaMemPoolGetAccess' in found_functions}} cdef cudaError_t _cudaMemPoolGetAccess(cudaMemAccessFlags* flags, cudaMemPool_t memPool, cudaMemLocation* location) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemPoolGetAccess(flags, memPool, location) - return cudaMemPoolGetAccess(flags, memPool, location) -{{endif}} + return _static_cudaMemPoolGetAccess(flags, memPool, location) -{{if 'cudaMemPoolCreate' in found_functions}} cdef cudaError_t _cudaMemPoolCreate(cudaMemPool_t* memPool, const cudaMemPoolProps* poolProps) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemPoolCreate(memPool, poolProps) - return cudaMemPoolCreate(memPool, poolProps) -{{endif}} + return _static_cudaMemPoolCreate(memPool, poolProps) -{{if 'cudaMemPoolDestroy' in found_functions}} cdef cudaError_t _cudaMemPoolDestroy(cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: - return ptds._cudaMemPoolDestroy(memPool) - return cudaMemPoolDestroy(memPool) -{{endif}} - -{{if 'cudaMemGetDefaultMemPool' in found_functions}} - -cdef cudaError_t _cudaMemGetDefaultMemPool(cudaMemPool_t* memPool, cudaMemLocation* location, cudaMemAllocationType typename) except ?cudaErrorCallRequiresNewerDriver nogil: - cdef bint usePTDS = cudaPythonInit() - if usePTDS: - return ptds._cudaMemGetDefaultMemPool(memPool, location, typename) - return cudaMemGetDefaultMemPool(memPool, location, typename) -{{endif}} - -{{if 'cudaMemGetMemPool' in found_functions}} - -cdef cudaError_t _cudaMemGetMemPool(cudaMemPool_t* memPool, cudaMemLocation* location, cudaMemAllocationType typename) except ?cudaErrorCallRequiresNewerDriver nogil: - cdef bint usePTDS = cudaPythonInit() - if usePTDS: - return ptds._cudaMemGetMemPool(memPool, location, typename) - return cudaMemGetMemPool(memPool, location, typename) -{{endif}} - -{{if 'cudaMemSetMemPool' in found_functions}} - -cdef cudaError_t _cudaMemSetMemPool(cudaMemLocation* location, cudaMemAllocationType typename, cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil: - cdef bint usePTDS = cudaPythonInit() - if usePTDS: - return ptds._cudaMemSetMemPool(location, typename, memPool) - return cudaMemSetMemPool(location, typename, memPool) -{{endif}} + return ptds._cudaMemPoolDestroy(memPool) + return _static_cudaMemPoolDestroy(memPool) -{{if 'cudaMallocFromPoolAsync' in found_functions}} cdef cudaError_t _cudaMallocFromPoolAsync(void** ptr, size_t size, cudaMemPool_t memPool, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMallocFromPoolAsync(ptr, size, memPool, stream) - return cudaMallocFromPoolAsync(ptr, size, memPool, stream) -{{endif}} + return _static_cudaMallocFromPoolAsync(ptr, size, memPool, stream) -{{if 'cudaMemPoolExportToShareableHandle' in found_functions}} cdef cudaError_t _cudaMemPoolExportToShareableHandle(void* shareableHandle, cudaMemPool_t memPool, cudaMemAllocationHandleType handleType, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemPoolExportToShareableHandle(shareableHandle, memPool, handleType, flags) - return cudaMemPoolExportToShareableHandle(shareableHandle, memPool, handleType, flags) -{{endif}} + return _static_cudaMemPoolExportToShareableHandle(shareableHandle, memPool, handleType, flags) -{{if 'cudaMemPoolImportFromShareableHandle' in found_functions}} cdef cudaError_t _cudaMemPoolImportFromShareableHandle(cudaMemPool_t* memPool, void* shareableHandle, cudaMemAllocationHandleType handleType, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemPoolImportFromShareableHandle(memPool, shareableHandle, handleType, flags) - return cudaMemPoolImportFromShareableHandle(memPool, shareableHandle, handleType, flags) -{{endif}} + return _static_cudaMemPoolImportFromShareableHandle(memPool, shareableHandle, handleType, flags) -{{if 'cudaMemPoolExportPointer' in found_functions}} cdef cudaError_t _cudaMemPoolExportPointer(cudaMemPoolPtrExportData* exportData, void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemPoolExportPointer(exportData, ptr) - return cudaMemPoolExportPointer(exportData, ptr) -{{endif}} + return _static_cudaMemPoolExportPointer(exportData, ptr) -{{if 'cudaMemPoolImportPointer' in found_functions}} cdef cudaError_t _cudaMemPoolImportPointer(void** ptr, cudaMemPool_t memPool, cudaMemPoolPtrExportData* exportData) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemPoolImportPointer(ptr, memPool, exportData) - return cudaMemPoolImportPointer(ptr, memPool, exportData) -{{endif}} + return _static_cudaMemPoolImportPointer(ptr, memPool, exportData) -{{if 'cudaPointerGetAttributes' in found_functions}} cdef cudaError_t _cudaPointerGetAttributes(cudaPointerAttributes* attributes, const void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaPointerGetAttributes(attributes, ptr) - return cudaPointerGetAttributes(attributes, ptr) -{{endif}} + return _static_cudaPointerGetAttributes(attributes, ptr) -{{if 'cudaDeviceCanAccessPeer' in found_functions}} cdef cudaError_t _cudaDeviceCanAccessPeer(int* canAccessPeer, int device, int peerDevice) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceCanAccessPeer(canAccessPeer, device, peerDevice) - return cudaDeviceCanAccessPeer(canAccessPeer, device, peerDevice) -{{endif}} + return _static_cudaDeviceCanAccessPeer(canAccessPeer, device, peerDevice) -{{if 'cudaDeviceEnablePeerAccess' in found_functions}} cdef cudaError_t _cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceEnablePeerAccess(peerDevice, flags) - return cudaDeviceEnablePeerAccess(peerDevice, flags) -{{endif}} + return _static_cudaDeviceEnablePeerAccess(peerDevice, flags) -{{if 'cudaDeviceDisablePeerAccess' in found_functions}} cdef cudaError_t _cudaDeviceDisablePeerAccess(int peerDevice) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceDisablePeerAccess(peerDevice) - return cudaDeviceDisablePeerAccess(peerDevice) -{{endif}} + return _static_cudaDeviceDisablePeerAccess(peerDevice) -{{if 'cudaGraphicsUnregisterResource' in found_functions}} cdef cudaError_t _cudaGraphicsUnregisterResource(cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphicsUnregisterResource(resource) - return cudaGraphicsUnregisterResource(resource) -{{endif}} + return _static_cudaGraphicsUnregisterResource(resource) -{{if 'cudaGraphicsResourceSetMapFlags' in found_functions}} cdef cudaError_t _cudaGraphicsResourceSetMapFlags(cudaGraphicsResource_t resource, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphicsResourceSetMapFlags(resource, flags) - return cudaGraphicsResourceSetMapFlags(resource, flags) -{{endif}} + return _static_cudaGraphicsResourceSetMapFlags(resource, flags) -{{if 'cudaGraphicsMapResources' in found_functions}} cdef cudaError_t _cudaGraphicsMapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphicsMapResources(count, resources, stream) - return cudaGraphicsMapResources(count, resources, stream) -{{endif}} + return _static_cudaGraphicsMapResources(count, resources, stream) -{{if 'cudaGraphicsUnmapResources' in found_functions}} cdef cudaError_t _cudaGraphicsUnmapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphicsUnmapResources(count, resources, stream) - return cudaGraphicsUnmapResources(count, resources, stream) -{{endif}} + return _static_cudaGraphicsUnmapResources(count, resources, stream) -{{if 'cudaGraphicsResourceGetMappedPointer' in found_functions}} cdef cudaError_t _cudaGraphicsResourceGetMappedPointer(void** devPtr, size_t* size, cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphicsResourceGetMappedPointer(devPtr, size, resource) - return cudaGraphicsResourceGetMappedPointer(devPtr, size, resource) -{{endif}} + return _static_cudaGraphicsResourceGetMappedPointer(devPtr, size, resource) -{{if 'cudaGraphicsSubResourceGetMappedArray' in found_functions}} cdef cudaError_t _cudaGraphicsSubResourceGetMappedArray(cudaArray_t* array, cudaGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphicsSubResourceGetMappedArray(array, resource, arrayIndex, mipLevel) - return cudaGraphicsSubResourceGetMappedArray(array, resource, arrayIndex, mipLevel) -{{endif}} + return _static_cudaGraphicsSubResourceGetMappedArray(array, resource, arrayIndex, mipLevel) -{{if 'cudaGraphicsResourceGetMappedMipmappedArray' in found_functions}} cdef cudaError_t _cudaGraphicsResourceGetMappedMipmappedArray(cudaMipmappedArray_t* mipmappedArray, cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphicsResourceGetMappedMipmappedArray(mipmappedArray, resource) - return cudaGraphicsResourceGetMappedMipmappedArray(mipmappedArray, resource) -{{endif}} + return _static_cudaGraphicsResourceGetMappedMipmappedArray(mipmappedArray, resource) -{{if 'cudaGetChannelDesc' in found_functions}} cdef cudaError_t _cudaGetChannelDesc(cudaChannelFormatDesc* desc, cudaArray_const_t array) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGetChannelDesc(desc, array) - return cudaGetChannelDesc(desc, array) -{{endif}} + return _static_cudaGetChannelDesc(desc, array) + -{{if 'cudaCreateChannelDesc' in found_functions}} -@cython.show_performance_hints(False) cdef cudaChannelFormatDesc _cudaCreateChannelDesc(int x, int y, int z, int w, cudaChannelFormatKind f) except* nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaCreateChannelDesc(x, y, z, w, f) - return cudaCreateChannelDesc(x, y, z, w, f) -{{endif}} + return _static_cudaCreateChannelDesc(x, y, z, w, f) -{{if 'cudaCreateTextureObject' in found_functions}} cdef cudaError_t _cudaCreateTextureObject(cudaTextureObject_t* pTexObject, const cudaResourceDesc* pResDesc, const cudaTextureDesc* pTexDesc, const cudaResourceViewDesc* pResViewDesc) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaCreateTextureObject(pTexObject, pResDesc, pTexDesc, pResViewDesc) - return cudaCreateTextureObject(pTexObject, pResDesc, pTexDesc, pResViewDesc) -{{endif}} + return _static_cudaCreateTextureObject(pTexObject, pResDesc, pTexDesc, pResViewDesc) -{{if 'cudaDestroyTextureObject' in found_functions}} cdef cudaError_t _cudaDestroyTextureObject(cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDestroyTextureObject(texObject) - return cudaDestroyTextureObject(texObject) -{{endif}} + return _static_cudaDestroyTextureObject(texObject) -{{if 'cudaGetTextureObjectResourceDesc' in found_functions}} cdef cudaError_t _cudaGetTextureObjectResourceDesc(cudaResourceDesc* pResDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGetTextureObjectResourceDesc(pResDesc, texObject) - return cudaGetTextureObjectResourceDesc(pResDesc, texObject) -{{endif}} + return _static_cudaGetTextureObjectResourceDesc(pResDesc, texObject) -{{if 'cudaGetTextureObjectTextureDesc' in found_functions}} cdef cudaError_t _cudaGetTextureObjectTextureDesc(cudaTextureDesc* pTexDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGetTextureObjectTextureDesc(pTexDesc, texObject) - return cudaGetTextureObjectTextureDesc(pTexDesc, texObject) -{{endif}} + return _static_cudaGetTextureObjectTextureDesc(pTexDesc, texObject) -{{if 'cudaGetTextureObjectResourceViewDesc' in found_functions}} cdef cudaError_t _cudaGetTextureObjectResourceViewDesc(cudaResourceViewDesc* pResViewDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGetTextureObjectResourceViewDesc(pResViewDesc, texObject) - return cudaGetTextureObjectResourceViewDesc(pResViewDesc, texObject) -{{endif}} + return _static_cudaGetTextureObjectResourceViewDesc(pResViewDesc, texObject) -{{if 'cudaCreateSurfaceObject' in found_functions}} cdef cudaError_t _cudaCreateSurfaceObject(cudaSurfaceObject_t* pSurfObject, const cudaResourceDesc* pResDesc) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaCreateSurfaceObject(pSurfObject, pResDesc) - return cudaCreateSurfaceObject(pSurfObject, pResDesc) -{{endif}} + return _static_cudaCreateSurfaceObject(pSurfObject, pResDesc) -{{if 'cudaDestroySurfaceObject' in found_functions}} cdef cudaError_t _cudaDestroySurfaceObject(cudaSurfaceObject_t surfObject) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDestroySurfaceObject(surfObject) - return cudaDestroySurfaceObject(surfObject) -{{endif}} + return _static_cudaDestroySurfaceObject(surfObject) -{{if 'cudaGetSurfaceObjectResourceDesc' in found_functions}} cdef cudaError_t _cudaGetSurfaceObjectResourceDesc(cudaResourceDesc* pResDesc, cudaSurfaceObject_t surfObject) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGetSurfaceObjectResourceDesc(pResDesc, surfObject) - return cudaGetSurfaceObjectResourceDesc(pResDesc, surfObject) -{{endif}} + return _static_cudaGetSurfaceObjectResourceDesc(pResDesc, surfObject) -{{if 'cudaDriverGetVersion' in found_functions}} cdef cudaError_t _cudaDriverGetVersion(int* driverVersion) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDriverGetVersion(driverVersion) - return cudaDriverGetVersion(driverVersion) -{{endif}} + return _static_cudaDriverGetVersion(driverVersion) -{{if 'cudaRuntimeGetVersion' in found_functions}} cdef cudaError_t _cudaRuntimeGetVersion(int* runtimeVersion) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaRuntimeGetVersion(runtimeVersion) - return cudaRuntimeGetVersion(runtimeVersion) -{{endif}} - -{{if 'cudaLogsRegisterCallback' in found_functions}} - -cdef cudaError_t _cudaLogsRegisterCallback(cudaLogsCallback_t callbackFunc, void* userData, cudaLogsCallbackHandle* callback_out) except ?cudaErrorCallRequiresNewerDriver nogil: - cdef bint usePTDS = cudaPythonInit() - if usePTDS: - return ptds._cudaLogsRegisterCallback(callbackFunc, userData, callback_out) - return cudaLogsRegisterCallback(callbackFunc, userData, callback_out) -{{endif}} - -{{if 'cudaLogsUnregisterCallback' in found_functions}} - -cdef cudaError_t _cudaLogsUnregisterCallback(cudaLogsCallbackHandle callback) except ?cudaErrorCallRequiresNewerDriver nogil: - cdef bint usePTDS = cudaPythonInit() - if usePTDS: - return ptds._cudaLogsUnregisterCallback(callback) - return cudaLogsUnregisterCallback(callback) -{{endif}} - -{{if 'cudaLogsCurrent' in found_functions}} - -cdef cudaError_t _cudaLogsCurrent(cudaLogIterator* iterator_out, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - cdef bint usePTDS = cudaPythonInit() - if usePTDS: - return ptds._cudaLogsCurrent(iterator_out, flags) - return cudaLogsCurrent(iterator_out, flags) -{{endif}} - -{{if 'cudaLogsDumpToFile' in found_functions}} - -cdef cudaError_t _cudaLogsDumpToFile(cudaLogIterator* iterator, const char* pathToFile, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - cdef bint usePTDS = cudaPythonInit() - if usePTDS: - return ptds._cudaLogsDumpToFile(iterator, pathToFile, flags) - return cudaLogsDumpToFile(iterator, pathToFile, flags) -{{endif}} - -{{if 'cudaLogsDumpToMemory' in found_functions}} - -cdef cudaError_t _cudaLogsDumpToMemory(cudaLogIterator* iterator, char* buffer, size_t* size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - cdef bint usePTDS = cudaPythonInit() - if usePTDS: - return ptds._cudaLogsDumpToMemory(iterator, buffer, size, flags) - return cudaLogsDumpToMemory(iterator, buffer, size, flags) -{{endif}} + return _static_cudaRuntimeGetVersion(runtimeVersion) -{{if 'cudaGraphCreate' in found_functions}} cdef cudaError_t _cudaGraphCreate(cudaGraph_t* pGraph, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphCreate(pGraph, flags) - return cudaGraphCreate(pGraph, flags) -{{endif}} + return _static_cudaGraphCreate(pGraph, flags) -{{if 'cudaGraphAddKernelNode' in found_functions}} cdef cudaError_t _cudaGraphAddKernelNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphAddKernelNode(pGraphNode, graph, pDependencies, numDependencies, pNodeParams) - return cudaGraphAddKernelNode(pGraphNode, graph, pDependencies, numDependencies, pNodeParams) -{{endif}} + return _static_cudaGraphAddKernelNode(pGraphNode, graph, pDependencies, numDependencies, pNodeParams) -{{if 'cudaGraphKernelNodeGetParams' in found_functions}} cdef cudaError_t _cudaGraphKernelNodeGetParams(cudaGraphNode_t node, cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphKernelNodeGetParams(node, pNodeParams) - return cudaGraphKernelNodeGetParams(node, pNodeParams) -{{endif}} + return _static_cudaGraphKernelNodeGetParams(node, pNodeParams) -{{if 'cudaGraphKernelNodeSetParams' in found_functions}} cdef cudaError_t _cudaGraphKernelNodeSetParams(cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphKernelNodeSetParams(node, pNodeParams) - return cudaGraphKernelNodeSetParams(node, pNodeParams) -{{endif}} + return _static_cudaGraphKernelNodeSetParams(node, pNodeParams) -{{if 'cudaGraphKernelNodeCopyAttributes' in found_functions}} cdef cudaError_t _cudaGraphKernelNodeCopyAttributes(cudaGraphNode_t hDst, cudaGraphNode_t hSrc) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphKernelNodeCopyAttributes(hDst, hSrc) - return cudaGraphKernelNodeCopyAttributes(hDst, hSrc) -{{endif}} + return _static_cudaGraphKernelNodeCopyAttributes(hDst, hSrc) -{{if 'cudaGraphKernelNodeGetAttribute' in found_functions}} cdef cudaError_t _cudaGraphKernelNodeGetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, cudaKernelNodeAttrValue* value_out) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphKernelNodeGetAttribute(hNode, attr, value_out) - return cudaGraphKernelNodeGetAttribute(hNode, attr, value_out) -{{endif}} + return _static_cudaGraphKernelNodeGetAttribute(hNode, attr, value_out) -{{if 'cudaGraphKernelNodeSetAttribute' in found_functions}} cdef cudaError_t _cudaGraphKernelNodeSetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, const cudaKernelNodeAttrValue* value) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphKernelNodeSetAttribute(hNode, attr, value) - return cudaGraphKernelNodeSetAttribute(hNode, attr, value) -{{endif}} + return _static_cudaGraphKernelNodeSetAttribute(hNode, attr, value) -{{if 'cudaGraphAddMemcpyNode' in found_functions}} cdef cudaError_t _cudaGraphAddMemcpyNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemcpy3DParms* pCopyParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphAddMemcpyNode(pGraphNode, graph, pDependencies, numDependencies, pCopyParams) - return cudaGraphAddMemcpyNode(pGraphNode, graph, pDependencies, numDependencies, pCopyParams) -{{endif}} + return _static_cudaGraphAddMemcpyNode(pGraphNode, graph, pDependencies, numDependencies, pCopyParams) -{{if 'cudaGraphAddMemcpyNode1D' in found_functions}} cdef cudaError_t _cudaGraphAddMemcpyNode1D(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphAddMemcpyNode1D(pGraphNode, graph, pDependencies, numDependencies, dst, src, count, kind) - return cudaGraphAddMemcpyNode1D(pGraphNode, graph, pDependencies, numDependencies, dst, src, count, kind) -{{endif}} + return _static_cudaGraphAddMemcpyNode1D(pGraphNode, graph, pDependencies, numDependencies, dst, src, count, kind) -{{if 'cudaGraphMemcpyNodeGetParams' in found_functions}} cdef cudaError_t _cudaGraphMemcpyNodeGetParams(cudaGraphNode_t node, cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphMemcpyNodeGetParams(node, pNodeParams) - return cudaGraphMemcpyNodeGetParams(node, pNodeParams) -{{endif}} + return _static_cudaGraphMemcpyNodeGetParams(node, pNodeParams) -{{if 'cudaGraphMemcpyNodeSetParams' in found_functions}} cdef cudaError_t _cudaGraphMemcpyNodeSetParams(cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphMemcpyNodeSetParams(node, pNodeParams) - return cudaGraphMemcpyNodeSetParams(node, pNodeParams) -{{endif}} + return _static_cudaGraphMemcpyNodeSetParams(node, pNodeParams) -{{if 'cudaGraphMemcpyNodeSetParams1D' in found_functions}} cdef cudaError_t _cudaGraphMemcpyNodeSetParams1D(cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphMemcpyNodeSetParams1D(node, dst, src, count, kind) - return cudaGraphMemcpyNodeSetParams1D(node, dst, src, count, kind) -{{endif}} + return _static_cudaGraphMemcpyNodeSetParams1D(node, dst, src, count, kind) -{{if 'cudaGraphAddMemsetNode' in found_functions}} cdef cudaError_t _cudaGraphAddMemsetNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemsetParams* pMemsetParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphAddMemsetNode(pGraphNode, graph, pDependencies, numDependencies, pMemsetParams) - return cudaGraphAddMemsetNode(pGraphNode, graph, pDependencies, numDependencies, pMemsetParams) -{{endif}} + return _static_cudaGraphAddMemsetNode(pGraphNode, graph, pDependencies, numDependencies, pMemsetParams) -{{if 'cudaGraphMemsetNodeGetParams' in found_functions}} cdef cudaError_t _cudaGraphMemsetNodeGetParams(cudaGraphNode_t node, cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphMemsetNodeGetParams(node, pNodeParams) - return cudaGraphMemsetNodeGetParams(node, pNodeParams) -{{endif}} + return _static_cudaGraphMemsetNodeGetParams(node, pNodeParams) -{{if 'cudaGraphMemsetNodeSetParams' in found_functions}} cdef cudaError_t _cudaGraphMemsetNodeSetParams(cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphMemsetNodeSetParams(node, pNodeParams) - return cudaGraphMemsetNodeSetParams(node, pNodeParams) -{{endif}} + return _static_cudaGraphMemsetNodeSetParams(node, pNodeParams) -{{if 'cudaGraphAddHostNode' in found_functions}} cdef cudaError_t _cudaGraphAddHostNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphAddHostNode(pGraphNode, graph, pDependencies, numDependencies, pNodeParams) - return cudaGraphAddHostNode(pGraphNode, graph, pDependencies, numDependencies, pNodeParams) -{{endif}} + return _static_cudaGraphAddHostNode(pGraphNode, graph, pDependencies, numDependencies, pNodeParams) -{{if 'cudaGraphHostNodeGetParams' in found_functions}} cdef cudaError_t _cudaGraphHostNodeGetParams(cudaGraphNode_t node, cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphHostNodeGetParams(node, pNodeParams) - return cudaGraphHostNodeGetParams(node, pNodeParams) -{{endif}} + return _static_cudaGraphHostNodeGetParams(node, pNodeParams) -{{if 'cudaGraphHostNodeSetParams' in found_functions}} cdef cudaError_t _cudaGraphHostNodeSetParams(cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphHostNodeSetParams(node, pNodeParams) - return cudaGraphHostNodeSetParams(node, pNodeParams) -{{endif}} + return _static_cudaGraphHostNodeSetParams(node, pNodeParams) -{{if 'cudaGraphAddChildGraphNode' in found_functions}} cdef cudaError_t _cudaGraphAddChildGraphNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaGraph_t childGraph) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphAddChildGraphNode(pGraphNode, graph, pDependencies, numDependencies, childGraph) - return cudaGraphAddChildGraphNode(pGraphNode, graph, pDependencies, numDependencies, childGraph) -{{endif}} + return _static_cudaGraphAddChildGraphNode(pGraphNode, graph, pDependencies, numDependencies, childGraph) -{{if 'cudaGraphChildGraphNodeGetGraph' in found_functions}} cdef cudaError_t _cudaGraphChildGraphNodeGetGraph(cudaGraphNode_t node, cudaGraph_t* pGraph) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphChildGraphNodeGetGraph(node, pGraph) - return cudaGraphChildGraphNodeGetGraph(node, pGraph) -{{endif}} + return _static_cudaGraphChildGraphNodeGetGraph(node, pGraph) -{{if 'cudaGraphAddEmptyNode' in found_functions}} cdef cudaError_t _cudaGraphAddEmptyNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphAddEmptyNode(pGraphNode, graph, pDependencies, numDependencies) - return cudaGraphAddEmptyNode(pGraphNode, graph, pDependencies, numDependencies) -{{endif}} + return _static_cudaGraphAddEmptyNode(pGraphNode, graph, pDependencies, numDependencies) -{{if 'cudaGraphAddEventRecordNode' in found_functions}} cdef cudaError_t _cudaGraphAddEventRecordNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphAddEventRecordNode(pGraphNode, graph, pDependencies, numDependencies, event) - return cudaGraphAddEventRecordNode(pGraphNode, graph, pDependencies, numDependencies, event) -{{endif}} + return _static_cudaGraphAddEventRecordNode(pGraphNode, graph, pDependencies, numDependencies, event) -{{if 'cudaGraphEventRecordNodeGetEvent' in found_functions}} cdef cudaError_t _cudaGraphEventRecordNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphEventRecordNodeGetEvent(node, event_out) - return cudaGraphEventRecordNodeGetEvent(node, event_out) -{{endif}} + return _static_cudaGraphEventRecordNodeGetEvent(node, event_out) -{{if 'cudaGraphEventRecordNodeSetEvent' in found_functions}} cdef cudaError_t _cudaGraphEventRecordNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphEventRecordNodeSetEvent(node, event) - return cudaGraphEventRecordNodeSetEvent(node, event) -{{endif}} + return _static_cudaGraphEventRecordNodeSetEvent(node, event) -{{if 'cudaGraphAddEventWaitNode' in found_functions}} cdef cudaError_t _cudaGraphAddEventWaitNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphAddEventWaitNode(pGraphNode, graph, pDependencies, numDependencies, event) - return cudaGraphAddEventWaitNode(pGraphNode, graph, pDependencies, numDependencies, event) -{{endif}} + return _static_cudaGraphAddEventWaitNode(pGraphNode, graph, pDependencies, numDependencies, event) -{{if 'cudaGraphEventWaitNodeGetEvent' in found_functions}} cdef cudaError_t _cudaGraphEventWaitNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphEventWaitNodeGetEvent(node, event_out) - return cudaGraphEventWaitNodeGetEvent(node, event_out) -{{endif}} + return _static_cudaGraphEventWaitNodeGetEvent(node, event_out) -{{if 'cudaGraphEventWaitNodeSetEvent' in found_functions}} cdef cudaError_t _cudaGraphEventWaitNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphEventWaitNodeSetEvent(node, event) - return cudaGraphEventWaitNodeSetEvent(node, event) -{{endif}} + return _static_cudaGraphEventWaitNodeSetEvent(node, event) -{{if 'cudaGraphAddExternalSemaphoresSignalNode' in found_functions}} cdef cudaError_t _cudaGraphAddExternalSemaphoresSignalNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphAddExternalSemaphoresSignalNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams) - return cudaGraphAddExternalSemaphoresSignalNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams) -{{endif}} + return _static_cudaGraphAddExternalSemaphoresSignalNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams) -{{if 'cudaGraphExternalSemaphoresSignalNodeGetParams' in found_functions}} cdef cudaError_t _cudaGraphExternalSemaphoresSignalNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreSignalNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphExternalSemaphoresSignalNodeGetParams(hNode, params_out) - return cudaGraphExternalSemaphoresSignalNodeGetParams(hNode, params_out) -{{endif}} + return _static_cudaGraphExternalSemaphoresSignalNodeGetParams(hNode, params_out) -{{if 'cudaGraphExternalSemaphoresSignalNodeSetParams' in found_functions}} cdef cudaError_t _cudaGraphExternalSemaphoresSignalNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphExternalSemaphoresSignalNodeSetParams(hNode, nodeParams) - return cudaGraphExternalSemaphoresSignalNodeSetParams(hNode, nodeParams) -{{endif}} + return _static_cudaGraphExternalSemaphoresSignalNodeSetParams(hNode, nodeParams) -{{if 'cudaGraphAddExternalSemaphoresWaitNode' in found_functions}} cdef cudaError_t _cudaGraphAddExternalSemaphoresWaitNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphAddExternalSemaphoresWaitNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams) - return cudaGraphAddExternalSemaphoresWaitNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams) -{{endif}} + return _static_cudaGraphAddExternalSemaphoresWaitNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams) -{{if 'cudaGraphExternalSemaphoresWaitNodeGetParams' in found_functions}} cdef cudaError_t _cudaGraphExternalSemaphoresWaitNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreWaitNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphExternalSemaphoresWaitNodeGetParams(hNode, params_out) - return cudaGraphExternalSemaphoresWaitNodeGetParams(hNode, params_out) -{{endif}} + return _static_cudaGraphExternalSemaphoresWaitNodeGetParams(hNode, params_out) -{{if 'cudaGraphExternalSemaphoresWaitNodeSetParams' in found_functions}} cdef cudaError_t _cudaGraphExternalSemaphoresWaitNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphExternalSemaphoresWaitNodeSetParams(hNode, nodeParams) - return cudaGraphExternalSemaphoresWaitNodeSetParams(hNode, nodeParams) -{{endif}} + return _static_cudaGraphExternalSemaphoresWaitNodeSetParams(hNode, nodeParams) -{{if 'cudaGraphAddMemAllocNode' in found_functions}} cdef cudaError_t _cudaGraphAddMemAllocNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaMemAllocNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphAddMemAllocNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams) - return cudaGraphAddMemAllocNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams) -{{endif}} + return _static_cudaGraphAddMemAllocNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams) -{{if 'cudaGraphMemAllocNodeGetParams' in found_functions}} cdef cudaError_t _cudaGraphMemAllocNodeGetParams(cudaGraphNode_t node, cudaMemAllocNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphMemAllocNodeGetParams(node, params_out) - return cudaGraphMemAllocNodeGetParams(node, params_out) -{{endif}} + return _static_cudaGraphMemAllocNodeGetParams(node, params_out) -{{if 'cudaGraphAddMemFreeNode' in found_functions}} cdef cudaError_t _cudaGraphAddMemFreeNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dptr) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphAddMemFreeNode(pGraphNode, graph, pDependencies, numDependencies, dptr) - return cudaGraphAddMemFreeNode(pGraphNode, graph, pDependencies, numDependencies, dptr) -{{endif}} + return _static_cudaGraphAddMemFreeNode(pGraphNode, graph, pDependencies, numDependencies, dptr) -{{if 'cudaGraphMemFreeNodeGetParams' in found_functions}} cdef cudaError_t _cudaGraphMemFreeNodeGetParams(cudaGraphNode_t node, void* dptr_out) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphMemFreeNodeGetParams(node, dptr_out) - return cudaGraphMemFreeNodeGetParams(node, dptr_out) -{{endif}} + return _static_cudaGraphMemFreeNodeGetParams(node, dptr_out) -{{if 'cudaDeviceGraphMemTrim' in found_functions}} cdef cudaError_t _cudaDeviceGraphMemTrim(int device) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceGraphMemTrim(device) - return cudaDeviceGraphMemTrim(device) -{{endif}} + return _static_cudaDeviceGraphMemTrim(device) -{{if 'cudaDeviceGetGraphMemAttribute' in found_functions}} cdef cudaError_t _cudaDeviceGetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceGetGraphMemAttribute(device, attr, value) - return cudaDeviceGetGraphMemAttribute(device, attr, value) -{{endif}} + return _static_cudaDeviceGetGraphMemAttribute(device, attr, value) -{{if 'cudaDeviceSetGraphMemAttribute' in found_functions}} cdef cudaError_t _cudaDeviceSetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceSetGraphMemAttribute(device, attr, value) - return cudaDeviceSetGraphMemAttribute(device, attr, value) -{{endif}} + return _static_cudaDeviceSetGraphMemAttribute(device, attr, value) -{{if 'cudaGraphClone' in found_functions}} cdef cudaError_t _cudaGraphClone(cudaGraph_t* pGraphClone, cudaGraph_t originalGraph) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphClone(pGraphClone, originalGraph) - return cudaGraphClone(pGraphClone, originalGraph) -{{endif}} + return _static_cudaGraphClone(pGraphClone, originalGraph) -{{if 'cudaGraphNodeFindInClone' in found_functions}} cdef cudaError_t _cudaGraphNodeFindInClone(cudaGraphNode_t* pNode, cudaGraphNode_t originalNode, cudaGraph_t clonedGraph) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphNodeFindInClone(pNode, originalNode, clonedGraph) - return cudaGraphNodeFindInClone(pNode, originalNode, clonedGraph) -{{endif}} + return _static_cudaGraphNodeFindInClone(pNode, originalNode, clonedGraph) -{{if 'cudaGraphNodeGetType' in found_functions}} cdef cudaError_t _cudaGraphNodeGetType(cudaGraphNode_t node, cudaGraphNodeType* pType) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphNodeGetType(node, pType) - return cudaGraphNodeGetType(node, pType) -{{endif}} + return _static_cudaGraphNodeGetType(node, pType) -{{if 'cudaGraphNodeGetContainingGraph' in found_functions}} - -cdef cudaError_t _cudaGraphNodeGetContainingGraph(cudaGraphNode_t hNode, cudaGraph_t* phGraph) except ?cudaErrorCallRequiresNewerDriver nogil: - cdef bint usePTDS = cudaPythonInit() - if usePTDS: - return ptds._cudaGraphNodeGetContainingGraph(hNode, phGraph) - return cudaGraphNodeGetContainingGraph(hNode, phGraph) -{{endif}} - -{{if 'cudaGraphNodeGetLocalId' in found_functions}} - -cdef cudaError_t _cudaGraphNodeGetLocalId(cudaGraphNode_t hNode, unsigned int* nodeId) except ?cudaErrorCallRequiresNewerDriver nogil: - cdef bint usePTDS = cudaPythonInit() - if usePTDS: - return ptds._cudaGraphNodeGetLocalId(hNode, nodeId) - return cudaGraphNodeGetLocalId(hNode, nodeId) -{{endif}} - -{{if 'cudaGraphNodeGetToolsId' in found_functions}} - -cdef cudaError_t _cudaGraphNodeGetToolsId(cudaGraphNode_t hNode, unsigned long long* toolsNodeId) except ?cudaErrorCallRequiresNewerDriver nogil: - cdef bint usePTDS = cudaPythonInit() - if usePTDS: - return ptds._cudaGraphNodeGetToolsId(hNode, toolsNodeId) - return cudaGraphNodeGetToolsId(hNode, toolsNodeId) -{{endif}} - -{{if 'cudaGraphGetId' in found_functions}} - -cdef cudaError_t _cudaGraphGetId(cudaGraph_t hGraph, unsigned int* graphID) except ?cudaErrorCallRequiresNewerDriver nogil: - cdef bint usePTDS = cudaPythonInit() - if usePTDS: - return ptds._cudaGraphGetId(hGraph, graphID) - return cudaGraphGetId(hGraph, graphID) -{{endif}} - -{{if 'cudaGraphExecGetId' in found_functions}} - -cdef cudaError_t _cudaGraphExecGetId(cudaGraphExec_t hGraphExec, unsigned int* graphID) except ?cudaErrorCallRequiresNewerDriver nogil: - cdef bint usePTDS = cudaPythonInit() - if usePTDS: - return ptds._cudaGraphExecGetId(hGraphExec, graphID) - return cudaGraphExecGetId(hGraphExec, graphID) -{{endif}} - -{{if 'cudaGraphGetNodes' in found_functions}} cdef cudaError_t _cudaGraphGetNodes(cudaGraph_t graph, cudaGraphNode_t* nodes, size_t* numNodes) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphGetNodes(graph, nodes, numNodes) - return cudaGraphGetNodes(graph, nodes, numNodes) -{{endif}} + return _static_cudaGraphGetNodes(graph, nodes, numNodes) -{{if 'cudaGraphGetRootNodes' in found_functions}} cdef cudaError_t _cudaGraphGetRootNodes(cudaGraph_t graph, cudaGraphNode_t* pRootNodes, size_t* pNumRootNodes) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphGetRootNodes(graph, pRootNodes, pNumRootNodes) - return cudaGraphGetRootNodes(graph, pRootNodes, pNumRootNodes) -{{endif}} + return _static_cudaGraphGetRootNodes(graph, pRootNodes, pNumRootNodes) -{{if 'cudaGraphGetEdges' in found_functions}} cdef cudaError_t _cudaGraphGetEdges(cudaGraph_t graph, cudaGraphNode_t* from_, cudaGraphNode_t* to, cudaGraphEdgeData* edgeData, size_t* numEdges) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphGetEdges(graph, from_, to, edgeData, numEdges) - return cudaGraphGetEdges(graph, from_, to, edgeData, numEdges) -{{endif}} + return _static_cudaGraphGetEdges(graph, from_, to, edgeData, numEdges) -{{if 'cudaGraphNodeGetDependencies' in found_functions}} cdef cudaError_t _cudaGraphNodeGetDependencies(cudaGraphNode_t node, cudaGraphNode_t* pDependencies, cudaGraphEdgeData* edgeData, size_t* pNumDependencies) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphNodeGetDependencies(node, pDependencies, edgeData, pNumDependencies) - return cudaGraphNodeGetDependencies(node, pDependencies, edgeData, pNumDependencies) -{{endif}} + return _static_cudaGraphNodeGetDependencies(node, pDependencies, edgeData, pNumDependencies) -{{if 'cudaGraphNodeGetDependentNodes' in found_functions}} cdef cudaError_t _cudaGraphNodeGetDependentNodes(cudaGraphNode_t node, cudaGraphNode_t* pDependentNodes, cudaGraphEdgeData* edgeData, size_t* pNumDependentNodes) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphNodeGetDependentNodes(node, pDependentNodes, edgeData, pNumDependentNodes) - return cudaGraphNodeGetDependentNodes(node, pDependentNodes, edgeData, pNumDependentNodes) -{{endif}} + return _static_cudaGraphNodeGetDependentNodes(node, pDependentNodes, edgeData, pNumDependentNodes) -{{if 'cudaGraphAddDependencies' in found_functions}} cdef cudaError_t _cudaGraphAddDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, const cudaGraphEdgeData* edgeData, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphAddDependencies(graph, from_, to, edgeData, numDependencies) - return cudaGraphAddDependencies(graph, from_, to, edgeData, numDependencies) -{{endif}} + return _static_cudaGraphAddDependencies(graph, from_, to, edgeData, numDependencies) -{{if 'cudaGraphRemoveDependencies' in found_functions}} cdef cudaError_t _cudaGraphRemoveDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, const cudaGraphEdgeData* edgeData, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphRemoveDependencies(graph, from_, to, edgeData, numDependencies) - return cudaGraphRemoveDependencies(graph, from_, to, edgeData, numDependencies) -{{endif}} + return _static_cudaGraphRemoveDependencies(graph, from_, to, edgeData, numDependencies) -{{if 'cudaGraphDestroyNode' in found_functions}} cdef cudaError_t _cudaGraphDestroyNode(cudaGraphNode_t node) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphDestroyNode(node) - return cudaGraphDestroyNode(node) -{{endif}} + return _static_cudaGraphDestroyNode(node) -{{if 'cudaGraphInstantiate' in found_functions}} cdef cudaError_t _cudaGraphInstantiate(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphInstantiate(pGraphExec, graph, flags) - return cudaGraphInstantiate(pGraphExec, graph, flags) -{{endif}} + return _static_cudaGraphInstantiate(pGraphExec, graph, flags) -{{if 'cudaGraphInstantiateWithFlags' in found_functions}} cdef cudaError_t _cudaGraphInstantiateWithFlags(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphInstantiateWithFlags(pGraphExec, graph, flags) - return cudaGraphInstantiateWithFlags(pGraphExec, graph, flags) -{{endif}} + return _static_cudaGraphInstantiateWithFlags(pGraphExec, graph, flags) -{{if 'cudaGraphInstantiateWithParams' in found_functions}} cdef cudaError_t _cudaGraphInstantiateWithParams(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, cudaGraphInstantiateParams* instantiateParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphInstantiateWithParams(pGraphExec, graph, instantiateParams) - return cudaGraphInstantiateWithParams(pGraphExec, graph, instantiateParams) -{{endif}} + return _static_cudaGraphInstantiateWithParams(pGraphExec, graph, instantiateParams) -{{if 'cudaGraphExecGetFlags' in found_functions}} cdef cudaError_t _cudaGraphExecGetFlags(cudaGraphExec_t graphExec, unsigned long long* flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphExecGetFlags(graphExec, flags) - return cudaGraphExecGetFlags(graphExec, flags) -{{endif}} + return _static_cudaGraphExecGetFlags(graphExec, flags) -{{if 'cudaGraphExecKernelNodeSetParams' in found_functions}} cdef cudaError_t _cudaGraphExecKernelNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphExecKernelNodeSetParams(hGraphExec, node, pNodeParams) - return cudaGraphExecKernelNodeSetParams(hGraphExec, node, pNodeParams) -{{endif}} + return _static_cudaGraphExecKernelNodeSetParams(hGraphExec, node, pNodeParams) -{{if 'cudaGraphExecMemcpyNodeSetParams' in found_functions}} cdef cudaError_t _cudaGraphExecMemcpyNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphExecMemcpyNodeSetParams(hGraphExec, node, pNodeParams) - return cudaGraphExecMemcpyNodeSetParams(hGraphExec, node, pNodeParams) -{{endif}} + return _static_cudaGraphExecMemcpyNodeSetParams(hGraphExec, node, pNodeParams) -{{if 'cudaGraphExecMemcpyNodeSetParams1D' in found_functions}} cdef cudaError_t _cudaGraphExecMemcpyNodeSetParams1D(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphExecMemcpyNodeSetParams1D(hGraphExec, node, dst, src, count, kind) - return cudaGraphExecMemcpyNodeSetParams1D(hGraphExec, node, dst, src, count, kind) -{{endif}} + return _static_cudaGraphExecMemcpyNodeSetParams1D(hGraphExec, node, dst, src, count, kind) -{{if 'cudaGraphExecMemsetNodeSetParams' in found_functions}} cdef cudaError_t _cudaGraphExecMemsetNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphExecMemsetNodeSetParams(hGraphExec, node, pNodeParams) - return cudaGraphExecMemsetNodeSetParams(hGraphExec, node, pNodeParams) -{{endif}} + return _static_cudaGraphExecMemsetNodeSetParams(hGraphExec, node, pNodeParams) -{{if 'cudaGraphExecHostNodeSetParams' in found_functions}} cdef cudaError_t _cudaGraphExecHostNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphExecHostNodeSetParams(hGraphExec, node, pNodeParams) - return cudaGraphExecHostNodeSetParams(hGraphExec, node, pNodeParams) -{{endif}} + return _static_cudaGraphExecHostNodeSetParams(hGraphExec, node, pNodeParams) -{{if 'cudaGraphExecChildGraphNodeSetParams' in found_functions}} cdef cudaError_t _cudaGraphExecChildGraphNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, cudaGraph_t childGraph) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphExecChildGraphNodeSetParams(hGraphExec, node, childGraph) - return cudaGraphExecChildGraphNodeSetParams(hGraphExec, node, childGraph) -{{endif}} + return _static_cudaGraphExecChildGraphNodeSetParams(hGraphExec, node, childGraph) -{{if 'cudaGraphExecEventRecordNodeSetEvent' in found_functions}} cdef cudaError_t _cudaGraphExecEventRecordNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphExecEventRecordNodeSetEvent(hGraphExec, hNode, event) - return cudaGraphExecEventRecordNodeSetEvent(hGraphExec, hNode, event) -{{endif}} + return _static_cudaGraphExecEventRecordNodeSetEvent(hGraphExec, hNode, event) -{{if 'cudaGraphExecEventWaitNodeSetEvent' in found_functions}} cdef cudaError_t _cudaGraphExecEventWaitNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphExecEventWaitNodeSetEvent(hGraphExec, hNode, event) - return cudaGraphExecEventWaitNodeSetEvent(hGraphExec, hNode, event) -{{endif}} + return _static_cudaGraphExecEventWaitNodeSetEvent(hGraphExec, hNode, event) -{{if 'cudaGraphExecExternalSemaphoresSignalNodeSetParams' in found_functions}} cdef cudaError_t _cudaGraphExecExternalSemaphoresSignalNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphExecExternalSemaphoresSignalNodeSetParams(hGraphExec, hNode, nodeParams) - return cudaGraphExecExternalSemaphoresSignalNodeSetParams(hGraphExec, hNode, nodeParams) -{{endif}} + return _static_cudaGraphExecExternalSemaphoresSignalNodeSetParams(hGraphExec, hNode, nodeParams) -{{if 'cudaGraphExecExternalSemaphoresWaitNodeSetParams' in found_functions}} cdef cudaError_t _cudaGraphExecExternalSemaphoresWaitNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphExecExternalSemaphoresWaitNodeSetParams(hGraphExec, hNode, nodeParams) - return cudaGraphExecExternalSemaphoresWaitNodeSetParams(hGraphExec, hNode, nodeParams) -{{endif}} + return _static_cudaGraphExecExternalSemaphoresWaitNodeSetParams(hGraphExec, hNode, nodeParams) -{{if 'cudaGraphNodeSetEnabled' in found_functions}} cdef cudaError_t _cudaGraphNodeSetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int isEnabled) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphNodeSetEnabled(hGraphExec, hNode, isEnabled) - return cudaGraphNodeSetEnabled(hGraphExec, hNode, isEnabled) -{{endif}} + return _static_cudaGraphNodeSetEnabled(hGraphExec, hNode, isEnabled) -{{if 'cudaGraphNodeGetEnabled' in found_functions}} cdef cudaError_t _cudaGraphNodeGetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int* isEnabled) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphNodeGetEnabled(hGraphExec, hNode, isEnabled) - return cudaGraphNodeGetEnabled(hGraphExec, hNode, isEnabled) -{{endif}} + return _static_cudaGraphNodeGetEnabled(hGraphExec, hNode, isEnabled) -{{if 'cudaGraphExecUpdate' in found_functions}} cdef cudaError_t _cudaGraphExecUpdate(cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphExecUpdateResultInfo* resultInfo) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphExecUpdate(hGraphExec, hGraph, resultInfo) - return cudaGraphExecUpdate(hGraphExec, hGraph, resultInfo) -{{endif}} + return _static_cudaGraphExecUpdate(hGraphExec, hGraph, resultInfo) -{{if 'cudaGraphUpload' in found_functions}} cdef cudaError_t _cudaGraphUpload(cudaGraphExec_t graphExec, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphUpload(graphExec, stream) - return cudaGraphUpload(graphExec, stream) -{{endif}} + return _static_cudaGraphUpload(graphExec, stream) -{{if 'cudaGraphLaunch' in found_functions}} cdef cudaError_t _cudaGraphLaunch(cudaGraphExec_t graphExec, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphLaunch(graphExec, stream) - return cudaGraphLaunch(graphExec, stream) -{{endif}} + return _static_cudaGraphLaunch(graphExec, stream) -{{if 'cudaGraphExecDestroy' in found_functions}} cdef cudaError_t _cudaGraphExecDestroy(cudaGraphExec_t graphExec) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphExecDestroy(graphExec) - return cudaGraphExecDestroy(graphExec) -{{endif}} + return _static_cudaGraphExecDestroy(graphExec) -{{if 'cudaGraphDestroy' in found_functions}} cdef cudaError_t _cudaGraphDestroy(cudaGraph_t graph) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphDestroy(graph) - return cudaGraphDestroy(graph) -{{endif}} + return _static_cudaGraphDestroy(graph) -{{if 'cudaGraphDebugDotPrint' in found_functions}} cdef cudaError_t _cudaGraphDebugDotPrint(cudaGraph_t graph, const char* path, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphDebugDotPrint(graph, path, flags) - return cudaGraphDebugDotPrint(graph, path, flags) -{{endif}} + return _static_cudaGraphDebugDotPrint(graph, path, flags) -{{if 'cudaUserObjectCreate' in found_functions}} cdef cudaError_t _cudaUserObjectCreate(cudaUserObject_t* object_out, void* ptr, cudaHostFn_t destroy, unsigned int initialRefcount, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaUserObjectCreate(object_out, ptr, destroy, initialRefcount, flags) - return cudaUserObjectCreate(object_out, ptr, destroy, initialRefcount, flags) -{{endif}} + return _static_cudaUserObjectCreate(object_out, ptr, destroy, initialRefcount, flags) -{{if 'cudaUserObjectRetain' in found_functions}} cdef cudaError_t _cudaUserObjectRetain(cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaUserObjectRetain(object, count) - return cudaUserObjectRetain(object, count) -{{endif}} + return _static_cudaUserObjectRetain(object, count) -{{if 'cudaUserObjectRelease' in found_functions}} cdef cudaError_t _cudaUserObjectRelease(cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaUserObjectRelease(object, count) - return cudaUserObjectRelease(object, count) -{{endif}} + return _static_cudaUserObjectRelease(object, count) -{{if 'cudaGraphRetainUserObject' in found_functions}} cdef cudaError_t _cudaGraphRetainUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphRetainUserObject(graph, object, count, flags) - return cudaGraphRetainUserObject(graph, object, count, flags) -{{endif}} + return _static_cudaGraphRetainUserObject(graph, object, count, flags) -{{if 'cudaGraphReleaseUserObject' in found_functions}} cdef cudaError_t _cudaGraphReleaseUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphReleaseUserObject(graph, object, count) - return cudaGraphReleaseUserObject(graph, object, count) -{{endif}} + return _static_cudaGraphReleaseUserObject(graph, object, count) -{{if 'cudaGraphAddNode' in found_functions}} cdef cudaError_t _cudaGraphAddNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphAddNode(pGraphNode, graph, pDependencies, dependencyData, numDependencies, nodeParams) - return cudaGraphAddNode(pGraphNode, graph, pDependencies, dependencyData, numDependencies, nodeParams) -{{endif}} + return _static_cudaGraphAddNode(pGraphNode, graph, pDependencies, dependencyData, numDependencies, nodeParams) -{{if 'cudaGraphNodeSetParams' in found_functions}} cdef cudaError_t _cudaGraphNodeSetParams(cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphNodeSetParams(node, nodeParams) - return cudaGraphNodeSetParams(node, nodeParams) -{{endif}} - -{{if 'cudaGraphNodeGetParams' in found_functions}} - -cdef cudaError_t _cudaGraphNodeGetParams(cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - cdef bint usePTDS = cudaPythonInit() - if usePTDS: - return ptds._cudaGraphNodeGetParams(node, nodeParams) - return cudaGraphNodeGetParams(node, nodeParams) -{{endif}} + return _static_cudaGraphNodeSetParams(node, nodeParams) -{{if 'cudaGraphExecNodeSetParams' in found_functions}} cdef cudaError_t _cudaGraphExecNodeSetParams(cudaGraphExec_t graphExec, cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphExecNodeSetParams(graphExec, node, nodeParams) - return cudaGraphExecNodeSetParams(graphExec, node, nodeParams) -{{endif}} + return _static_cudaGraphExecNodeSetParams(graphExec, node, nodeParams) -{{if 'cudaGraphConditionalHandleCreate' in found_functions}} cdef cudaError_t _cudaGraphConditionalHandleCreate(cudaGraphConditionalHandle* pHandle_out, cudaGraph_t graph, unsigned int defaultLaunchValue, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphConditionalHandleCreate(pHandle_out, graph, defaultLaunchValue, flags) - return cudaGraphConditionalHandleCreate(pHandle_out, graph, defaultLaunchValue, flags) -{{endif}} - -{{if 'cudaGraphConditionalHandleCreate_v2' in found_functions}} - -cdef cudaError_t _cudaGraphConditionalHandleCreate_v2(cudaGraphConditionalHandle* pHandle_out, cudaGraph_t graph, cudaExecutionContext_t ctx, unsigned int defaultLaunchValue, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - cdef bint usePTDS = cudaPythonInit() - if usePTDS: - return ptds._cudaGraphConditionalHandleCreate_v2(pHandle_out, graph, ctx, defaultLaunchValue, flags) - return cudaGraphConditionalHandleCreate_v2(pHandle_out, graph, ctx, defaultLaunchValue, flags) -{{endif}} + return _static_cudaGraphConditionalHandleCreate(pHandle_out, graph, defaultLaunchValue, flags) -{{if 'cudaGetDriverEntryPoint' in found_functions}} cdef cudaError_t _cudaGetDriverEntryPoint(const char* symbol, void** funcPtr, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGetDriverEntryPoint(symbol, funcPtr, flags, driverStatus) - return cudaGetDriverEntryPoint(symbol, funcPtr, flags, driverStatus) -{{endif}} + return _static_cudaGetDriverEntryPoint(symbol, funcPtr, flags, driverStatus) -{{if 'cudaGetDriverEntryPointByVersion' in found_functions}} cdef cudaError_t _cudaGetDriverEntryPointByVersion(const char* symbol, void** funcPtr, unsigned int cudaVersion, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGetDriverEntryPointByVersion(symbol, funcPtr, cudaVersion, flags, driverStatus) - return cudaGetDriverEntryPointByVersion(symbol, funcPtr, cudaVersion, flags, driverStatus) -{{endif}} + return _static_cudaGetDriverEntryPointByVersion(symbol, funcPtr, cudaVersion, flags, driverStatus) -{{if 'cudaLibraryLoadData' in found_functions}} cdef cudaError_t _cudaLibraryLoadData(cudaLibrary_t* library, const void* code, cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaLibraryLoadData(library, code, jitOptions, jitOptionsValues, numJitOptions, libraryOptions, libraryOptionValues, numLibraryOptions) - return cudaLibraryLoadData(library, code, jitOptions, jitOptionsValues, numJitOptions, libraryOptions, libraryOptionValues, numLibraryOptions) -{{endif}} + return _static_cudaLibraryLoadData(library, code, jitOptions, jitOptionsValues, numJitOptions, libraryOptions, libraryOptionValues, numLibraryOptions) -{{if 'cudaLibraryLoadFromFile' in found_functions}} cdef cudaError_t _cudaLibraryLoadFromFile(cudaLibrary_t* library, const char* fileName, cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaLibraryLoadFromFile(library, fileName, jitOptions, jitOptionsValues, numJitOptions, libraryOptions, libraryOptionValues, numLibraryOptions) - return cudaLibraryLoadFromFile(library, fileName, jitOptions, jitOptionsValues, numJitOptions, libraryOptions, libraryOptionValues, numLibraryOptions) -{{endif}} + return _static_cudaLibraryLoadFromFile(library, fileName, jitOptions, jitOptionsValues, numJitOptions, libraryOptions, libraryOptionValues, numLibraryOptions) -{{if 'cudaLibraryUnload' in found_functions}} cdef cudaError_t _cudaLibraryUnload(cudaLibrary_t library) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaLibraryUnload(library) - return cudaLibraryUnload(library) -{{endif}} + return _static_cudaLibraryUnload(library) -{{if 'cudaLibraryGetKernel' in found_functions}} cdef cudaError_t _cudaLibraryGetKernel(cudaKernel_t* pKernel, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaLibraryGetKernel(pKernel, library, name) - return cudaLibraryGetKernel(pKernel, library, name) -{{endif}} + return _static_cudaLibraryGetKernel(pKernel, library, name) -{{if 'cudaLibraryGetGlobal' in found_functions}} -cdef cudaError_t _cudaLibraryGetGlobal(void** dptr, size_t* numbytes, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaLibraryGetGlobal(void** dptr, size_t* bytes, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: - return ptds._cudaLibraryGetGlobal(dptr, numbytes, library, name) - return cudaLibraryGetGlobal(dptr, numbytes, library, name) -{{endif}} + return ptds._cudaLibraryGetGlobal(dptr, bytes, library, name) + return _static_cudaLibraryGetGlobal(dptr, bytes, library, name) -{{if 'cudaLibraryGetManaged' in found_functions}} -cdef cudaError_t _cudaLibraryGetManaged(void** dptr, size_t* numbytes, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaLibraryGetManaged(void** dptr, size_t* bytes, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: - return ptds._cudaLibraryGetManaged(dptr, numbytes, library, name) - return cudaLibraryGetManaged(dptr, numbytes, library, name) -{{endif}} + return ptds._cudaLibraryGetManaged(dptr, bytes, library, name) + return _static_cudaLibraryGetManaged(dptr, bytes, library, name) -{{if 'cudaLibraryGetUnifiedFunction' in found_functions}} cdef cudaError_t _cudaLibraryGetUnifiedFunction(void** fptr, cudaLibrary_t library, const char* symbol) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaLibraryGetUnifiedFunction(fptr, library, symbol) - return cudaLibraryGetUnifiedFunction(fptr, library, symbol) -{{endif}} + return _static_cudaLibraryGetUnifiedFunction(fptr, library, symbol) -{{if 'cudaLibraryGetKernelCount' in found_functions}} cdef cudaError_t _cudaLibraryGetKernelCount(unsigned int* count, cudaLibrary_t lib) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaLibraryGetKernelCount(count, lib) - return cudaLibraryGetKernelCount(count, lib) -{{endif}} + return _static_cudaLibraryGetKernelCount(count, lib) -{{if 'cudaLibraryEnumerateKernels' in found_functions}} cdef cudaError_t _cudaLibraryEnumerateKernels(cudaKernel_t* kernels, unsigned int numKernels, cudaLibrary_t lib) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaLibraryEnumerateKernels(kernels, numKernels, lib) - return cudaLibraryEnumerateKernels(kernels, numKernels, lib) -{{endif}} + return _static_cudaLibraryEnumerateKernels(kernels, numKernels, lib) -{{if 'cudaKernelSetAttributeForDevice' in found_functions}} cdef cudaError_t _cudaKernelSetAttributeForDevice(cudaKernel_t kernel, cudaFuncAttribute attr, int value, int device) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaKernelSetAttributeForDevice(kernel, attr, value, device) - return cudaKernelSetAttributeForDevice(kernel, attr, value, device) -{{endif}} + return _static_cudaKernelSetAttributeForDevice(kernel, attr, value, device) + + +cdef cudaError_t _cudaGetExportTable(const void** ppExportTable, const cudaUUID_t* pExportTableId) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGetExportTable(ppExportTable, pExportTableId) + return _static_cudaGetExportTable(ppExportTable, pExportTableId) + + +cdef cudaError_t _cudaGetKernel(cudaKernel_t* kernelPtr, const void* entryFuncAddr) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGetKernel(kernelPtr, entryFuncAddr) + return _static_cudaGetKernel(kernelPtr, entryFuncAddr) + + +cdef cudaError_t _cudaProfilerStart() except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaProfilerStart() + return _static_cudaProfilerStart() + + +cdef cudaError_t _cudaProfilerStop() except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaProfilerStop() + return _static_cudaProfilerStop() + + +cdef cudaError_t _cudaGetDeviceProperties(cudaDeviceProp* prop, int device) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGetDeviceProperties(prop, device) + return _static_cudaGetDeviceProperties(prop, device) + + +cdef cudaError_t _cudaDeviceGetHostAtomicCapabilities(unsigned int* capabilities, const cudaAtomicOperation* operations, unsigned int count, int device) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaDeviceGetHostAtomicCapabilities(capabilities, operations, count, device) + return _static_cudaDeviceGetHostAtomicCapabilities(capabilities, operations, count, device) + + +cdef cudaError_t _cudaDeviceGetP2PAtomicCapabilities(unsigned int* capabilities, const cudaAtomicOperation* operations, unsigned int count, int srcDevice, int dstDevice) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaDeviceGetP2PAtomicCapabilities(capabilities, operations, count, srcDevice, dstDevice) + return _static_cudaDeviceGetP2PAtomicCapabilities(capabilities, operations, count, srcDevice, dstDevice) + + +cdef cudaError_t _cudaStreamGetCaptureInfo(cudaStream_t stream, cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out, cudaGraph_t* graph_out, const cudaGraphNode_t** dependencies_out, const cudaGraphEdgeData** edgeData_out, size_t* numDependencies_out) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaStreamGetCaptureInfo(stream, captureStatus_out, id_out, graph_out, dependencies_out, edgeData_out, numDependencies_out) + return _static_cudaStreamGetCaptureInfo(stream, captureStatus_out, id_out, graph_out, dependencies_out, edgeData_out, numDependencies_out) + + +cdef cudaError_t _cudaSignalExternalSemaphoresAsync(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreSignalParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaSignalExternalSemaphoresAsync(extSemArray, paramsArray, numExtSems, stream) + return _static_cudaSignalExternalSemaphoresAsync(extSemArray, paramsArray, numExtSems, stream) -{{if 'cudaDeviceGetDevResource' in found_functions}} -cdef cudaError_t _cudaDeviceGetDevResource(int device, cudaDevResource* resource, cudaDevResourceType typename) except ?cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaWaitExternalSemaphoresAsync(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreWaitParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaWaitExternalSemaphoresAsync(extSemArray, paramsArray, numExtSems, stream) + return _static_cudaWaitExternalSemaphoresAsync(extSemArray, paramsArray, numExtSems, stream) + + +cdef cudaError_t _cudaMemPrefetchBatchAsync(void** dptrs, size_t* sizes, size_t count, cudaMemLocation* prefetchLocs, size_t* prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemPrefetchBatchAsync(dptrs, sizes, count, prefetchLocs, prefetchLocIdxs, numPrefetchLocs, flags, stream) + return _static_cudaMemPrefetchBatchAsync(dptrs, sizes, count, prefetchLocs, prefetchLocIdxs, numPrefetchLocs, flags, stream) + + +cdef cudaError_t _cudaMemDiscardBatchAsync(void** dptrs, size_t* sizes, size_t count, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemDiscardBatchAsync(dptrs, sizes, count, flags, stream) + return _static_cudaMemDiscardBatchAsync(dptrs, sizes, count, flags, stream) + + +cdef cudaError_t _cudaMemDiscardAndPrefetchBatchAsync(void** dptrs, size_t* sizes, size_t count, cudaMemLocation* prefetchLocs, size_t* prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemDiscardAndPrefetchBatchAsync(dptrs, sizes, count, prefetchLocs, prefetchLocIdxs, numPrefetchLocs, flags, stream) + return _static_cudaMemDiscardAndPrefetchBatchAsync(dptrs, sizes, count, prefetchLocs, prefetchLocIdxs, numPrefetchLocs, flags, stream) + + +cdef cudaError_t _cudaMemGetDefaultMemPool(cudaMemPool_t* memPool, cudaMemLocation* location, cudaMemAllocationType type) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemGetDefaultMemPool(memPool, location, type) + return _static_cudaMemGetDefaultMemPool(memPool, location, type) + + +cdef cudaError_t _cudaMemGetMemPool(cudaMemPool_t* memPool, cudaMemLocation* location, cudaMemAllocationType type) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemGetMemPool(memPool, location, type) + return _static_cudaMemGetMemPool(memPool, location, type) + + +cdef cudaError_t _cudaMemSetMemPool(cudaMemLocation* location, cudaMemAllocationType type, cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaMemSetMemPool(location, type, memPool) + return _static_cudaMemSetMemPool(location, type, memPool) + + +cdef cudaError_t _cudaLogsRegisterCallback(cudaLogsCallback_t callbackFunc, void* userData, cudaLogsCallbackHandle* callback_out) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaLogsRegisterCallback(callbackFunc, userData, callback_out) + return _static_cudaLogsRegisterCallback(callbackFunc, userData, callback_out) + + +cdef cudaError_t _cudaLogsUnregisterCallback(cudaLogsCallbackHandle callback) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaLogsUnregisterCallback(callback) + return _static_cudaLogsUnregisterCallback(callback) + + +cdef cudaError_t _cudaLogsCurrent(cudaLogIterator* iterator_out, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaLogsCurrent(iterator_out, flags) + return _static_cudaLogsCurrent(iterator_out, flags) + + +cdef cudaError_t _cudaLogsDumpToFile(cudaLogIterator* iterator, const char* pathToFile, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaLogsDumpToFile(iterator, pathToFile, flags) + return _static_cudaLogsDumpToFile(iterator, pathToFile, flags) + + +cdef cudaError_t _cudaLogsDumpToMemory(cudaLogIterator* iterator, char* buffer, size_t* size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaLogsDumpToMemory(iterator, buffer, size, flags) + return _static_cudaLogsDumpToMemory(iterator, buffer, size, flags) + + +cdef cudaError_t _cudaGraphNodeGetContainingGraph(cudaGraphNode_t hNode, cudaGraph_t* phGraph) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphNodeGetContainingGraph(hNode, phGraph) + return _static_cudaGraphNodeGetContainingGraph(hNode, phGraph) + + +cdef cudaError_t _cudaGraphNodeGetLocalId(cudaGraphNode_t hNode, unsigned int* nodeId) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphNodeGetLocalId(hNode, nodeId) + return _static_cudaGraphNodeGetLocalId(hNode, nodeId) + + +cdef cudaError_t _cudaGraphNodeGetToolsId(cudaGraphNode_t hNode, unsigned long long* toolsNodeId) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphNodeGetToolsId(hNode, toolsNodeId) + return _static_cudaGraphNodeGetToolsId(hNode, toolsNodeId) + + +cdef cudaError_t _cudaGraphGetId(cudaGraph_t hGraph, unsigned int* graphID) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphGetId(hGraph, graphID) + return _static_cudaGraphGetId(hGraph, graphID) + + +cdef cudaError_t _cudaGraphExecGetId(cudaGraphExec_t hGraphExec, unsigned int* graphID) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphExecGetId(hGraphExec, graphID) + return _static_cudaGraphExecGetId(hGraphExec, graphID) + + +cdef cudaError_t _cudaGraphConditionalHandleCreate_v2(cudaGraphConditionalHandle* pHandle_out, cudaGraph_t graph, cudaExecutionContext_t ctx, unsigned int defaultLaunchValue, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + cdef bint usePTDS = cudaPythonInit() + if usePTDS: + return ptds._cudaGraphConditionalHandleCreate_v2(pHandle_out, graph, ctx, defaultLaunchValue, flags) + return _static_cudaGraphConditionalHandleCreate_v2(pHandle_out, graph, ctx, defaultLaunchValue, flags) + + +cdef cudaError_t _cudaDeviceGetDevResource(int device, cudaDevResource* resource, cudaDevResourceType type) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: - return ptds._cudaDeviceGetDevResource(device, resource, typename) - return cudaDeviceGetDevResource(device, resource, typename) -{{endif}} + return ptds._cudaDeviceGetDevResource(device, resource, type) + return _static_cudaDeviceGetDevResource(device, resource, type) -{{if 'cudaDevSmResourceSplitByCount' in found_functions}} cdef cudaError_t _cudaDevSmResourceSplitByCount(cudaDevResource* result, unsigned int* nbGroups, const cudaDevResource* input, cudaDevResource* remaining, unsigned int flags, unsigned int minCount) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDevSmResourceSplitByCount(result, nbGroups, input, remaining, flags, minCount) - return cudaDevSmResourceSplitByCount(result, nbGroups, input, remaining, flags, minCount) -{{endif}} + return _static_cudaDevSmResourceSplitByCount(result, nbGroups, input, remaining, flags, minCount) -{{if 'cudaDevSmResourceSplit' in found_functions}} cdef cudaError_t _cudaDevSmResourceSplit(cudaDevResource* result, unsigned int nbGroups, const cudaDevResource* input, cudaDevResource* remainder, unsigned int flags, cudaDevSmResourceGroupParams* groupParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDevSmResourceSplit(result, nbGroups, input, remainder, flags, groupParams) - return cudaDevSmResourceSplit(result, nbGroups, input, remainder, flags, groupParams) -{{endif}} + return _static_cudaDevSmResourceSplit(result, nbGroups, input, remainder, flags, groupParams) -{{if 'cudaDevResourceGenerateDesc' in found_functions}} cdef cudaError_t _cudaDevResourceGenerateDesc(cudaDevResourceDesc_t* phDesc, cudaDevResource* resources, unsigned int nbResources) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDevResourceGenerateDesc(phDesc, resources, nbResources) - return cudaDevResourceGenerateDesc(phDesc, resources, nbResources) -{{endif}} + return _static_cudaDevResourceGenerateDesc(phDesc, resources, nbResources) -{{if 'cudaGreenCtxCreate' in found_functions}} cdef cudaError_t _cudaGreenCtxCreate(cudaExecutionContext_t* phCtx, cudaDevResourceDesc_t desc, int device, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGreenCtxCreate(phCtx, desc, device, flags) - return cudaGreenCtxCreate(phCtx, desc, device, flags) -{{endif}} + return _static_cudaGreenCtxCreate(phCtx, desc, device, flags) -{{if 'cudaExecutionCtxDestroy' in found_functions}} cdef cudaError_t _cudaExecutionCtxDestroy(cudaExecutionContext_t ctx) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaExecutionCtxDestroy(ctx) - return cudaExecutionCtxDestroy(ctx) -{{endif}} + return _static_cudaExecutionCtxDestroy(ctx) -{{if 'cudaExecutionCtxGetDevResource' in found_functions}} -cdef cudaError_t _cudaExecutionCtxGetDevResource(cudaExecutionContext_t ctx, cudaDevResource* resource, cudaDevResourceType typename) except ?cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaExecutionCtxGetDevResource(cudaExecutionContext_t ctx, cudaDevResource* resource, cudaDevResourceType type) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: - return ptds._cudaExecutionCtxGetDevResource(ctx, resource, typename) - return cudaExecutionCtxGetDevResource(ctx, resource, typename) -{{endif}} + return ptds._cudaExecutionCtxGetDevResource(ctx, resource, type) + return _static_cudaExecutionCtxGetDevResource(ctx, resource, type) -{{if 'cudaExecutionCtxGetDevice' in found_functions}} cdef cudaError_t _cudaExecutionCtxGetDevice(int* device, cudaExecutionContext_t ctx) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaExecutionCtxGetDevice(device, ctx) - return cudaExecutionCtxGetDevice(device, ctx) -{{endif}} + return _static_cudaExecutionCtxGetDevice(device, ctx) -{{if 'cudaExecutionCtxGetId' in found_functions}} cdef cudaError_t _cudaExecutionCtxGetId(cudaExecutionContext_t ctx, unsigned long long* ctxId) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaExecutionCtxGetId(ctx, ctxId) - return cudaExecutionCtxGetId(ctx, ctxId) -{{endif}} + return _static_cudaExecutionCtxGetId(ctx, ctxId) -{{if 'cudaExecutionCtxStreamCreate' in found_functions}} cdef cudaError_t _cudaExecutionCtxStreamCreate(cudaStream_t* phStream, cudaExecutionContext_t ctx, unsigned int flags, int priority) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaExecutionCtxStreamCreate(phStream, ctx, flags, priority) - return cudaExecutionCtxStreamCreate(phStream, ctx, flags, priority) -{{endif}} + return _static_cudaExecutionCtxStreamCreate(phStream, ctx, flags, priority) -{{if 'cudaExecutionCtxSynchronize' in found_functions}} cdef cudaError_t _cudaExecutionCtxSynchronize(cudaExecutionContext_t ctx) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaExecutionCtxSynchronize(ctx) - return cudaExecutionCtxSynchronize(ctx) -{{endif}} + return _static_cudaExecutionCtxSynchronize(ctx) -{{if 'cudaStreamGetDevResource' in found_functions}} -cdef cudaError_t _cudaStreamGetDevResource(cudaStream_t hStream, cudaDevResource* resource, cudaDevResourceType typename) except ?cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaStreamGetDevResource(cudaStream_t hStream, cudaDevResource* resource, cudaDevResourceType type) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: - return ptds._cudaStreamGetDevResource(hStream, resource, typename) - return cudaStreamGetDevResource(hStream, resource, typename) -{{endif}} + return ptds._cudaStreamGetDevResource(hStream, resource, type) + return _static_cudaStreamGetDevResource(hStream, resource, type) -{{if 'cudaExecutionCtxRecordEvent' in found_functions}} cdef cudaError_t _cudaExecutionCtxRecordEvent(cudaExecutionContext_t ctx, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaExecutionCtxRecordEvent(ctx, event) - return cudaExecutionCtxRecordEvent(ctx, event) -{{endif}} + return _static_cudaExecutionCtxRecordEvent(ctx, event) -{{if 'cudaExecutionCtxWaitEvent' in found_functions}} cdef cudaError_t _cudaExecutionCtxWaitEvent(cudaExecutionContext_t ctx, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaExecutionCtxWaitEvent(ctx, event) - return cudaExecutionCtxWaitEvent(ctx, event) -{{endif}} + return _static_cudaExecutionCtxWaitEvent(ctx, event) -{{if 'cudaDeviceGetExecutionCtx' in found_functions}} cdef cudaError_t _cudaDeviceGetExecutionCtx(cudaExecutionContext_t* ctx, int device) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceGetExecutionCtx(ctx, device) - return cudaDeviceGetExecutionCtx(ctx, device) -{{endif}} + return _static_cudaDeviceGetExecutionCtx(ctx, device) -{{if 'cudaGetExportTable' in found_functions}} -cdef cudaError_t _cudaGetExportTable(const void** ppExportTable, const cudaUUID_t* pExportTableId) except ?cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaFuncGetParamCount(const void* func, size_t* paramCount) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: - return ptds._cudaGetExportTable(ppExportTable, pExportTableId) - return cudaGetExportTable(ppExportTable, pExportTableId) -{{endif}} + return ptds._cudaFuncGetParamCount(func, paramCount) + return _static_cudaFuncGetParamCount(func, paramCount) -{{if 'cudaGetKernel' in found_functions}} -cdef cudaError_t _cudaGetKernel(cudaKernel_t* kernelPtr, const void* entryFuncAddr) except ?cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaLaunchHostFunc_v2(cudaStream_t stream, cudaHostFn_t fn, void* userData, unsigned int syncMode) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: - return ptds._cudaGetKernel(kernelPtr, entryFuncAddr) - return cudaGetKernel(kernelPtr, entryFuncAddr) -{{endif}} + return ptds._cudaLaunchHostFunc_v2(stream, fn, userData, syncMode) + return _static_cudaLaunchHostFunc_v2(stream, fn, userData, syncMode) -{{if 'make_cudaPitchedPtr' in found_functions}} -@cython.show_performance_hints(False) -cdef cudaPitchedPtr _make_cudaPitchedPtr(void* d, size_t p, size_t xsz, size_t ysz) except* nogil: - cdef bint usePTDS = cudaPythonInit() - if usePTDS: - return ptds._make_cudaPitchedPtr(d, p, xsz, ysz) - return make_cudaPitchedPtr(d, p, xsz, ysz) -{{endif}} -{{if 'make_cudaPos' in found_functions}} -@cython.show_performance_hints(False) -cdef cudaPos _make_cudaPos(size_t x, size_t y, size_t z) except* nogil: +cdef cudaError_t _cudaMemcpyWithAttributesAsync(void* dst, const void* src, size_t size, cudaMemcpyAttributes* attr, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: - return ptds._make_cudaPos(x, y, z) - return make_cudaPos(x, y, z) -{{endif}} + return ptds._cudaMemcpyWithAttributesAsync(dst, src, size, attr, stream) + return _static_cudaMemcpyWithAttributesAsync(dst, src, size, attr, stream) -{{if 'make_cudaExtent' in found_functions}} -@cython.show_performance_hints(False) -cdef cudaExtent _make_cudaExtent(size_t w, size_t h, size_t d) except* nogil: + +cdef cudaError_t _cudaMemcpy3DWithAttributesAsync(cudaMemcpy3DBatchOp* op, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: - return ptds._make_cudaExtent(w, h, d) - return make_cudaExtent(w, h, d) -{{endif}} + return ptds._cudaMemcpy3DWithAttributesAsync(op, flags, stream) + return _static_cudaMemcpy3DWithAttributesAsync(op, flags, stream) -{{if 'cudaProfilerStart' in found_functions}} -cdef cudaError_t _cudaProfilerStart() except ?cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphNodeGetParams(cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: - return ptds._cudaProfilerStart() - return cudaProfilerStart() -{{endif}} + return ptds._cudaGraphNodeGetParams(node, nodeParams) + return _static_cudaGraphNodeGetParams(node, nodeParams) -{{if 'cudaProfilerStop' in found_functions}} -cdef cudaError_t _cudaProfilerStop() except ?cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaStreamBeginRecaptureToGraph(cudaStream_t stream, cudaStreamCaptureMode mode, cudaGraph_t graph, cudaGraphRecaptureCallbackData* callbackData) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: - return ptds._cudaProfilerStop() - return cudaProfilerStop() -{{endif}} - - -include "../_lib/cyruntime/cyruntime.pxi" + return ptds._cudaStreamBeginRecaptureToGraph(stream, mode, graph, callbackData) + return _static_cudaStreamBeginRecaptureToGraph(stream, mode, graph, callbackData) diff --git a/cuda_bindings/cuda/bindings/_lib/cyruntime/cyruntime.pxd b/cuda_bindings/cuda/bindings/_lib/cyruntime/cyruntime.pxd index 482f91ca595..7258d4b43cc 100644 --- a/cuda_bindings/cuda/bindings/_lib/cyruntime/cyruntime.pxd +++ b/cuda_bindings/cuda/bindings/_lib/cyruntime/cyruntime.pxd @@ -1,7 +1,6 @@ # SPDX-FileCopyrightText: Copyright (c) 2021-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: Apache-2.0 -cimport cuda.bindings.cyruntime as cyruntime cimport cuda.bindings._internal.driver as _cydriver # These graphics API are the reimplemented version of what's supported by CUDA Runtime. @@ -17,27 +16,27 @@ cimport cuda.bindings._internal.driver as _cydriver # independent modules (c.b._lib.cyruntime.cyruntime and # c.b._lib.cyruntime.utils), but was merged into one. -cdef cudaError_t _cudaEGLStreamProducerPresentFrame(cyruntime.cudaEglStreamConnection* conn, cyruntime.cudaEglFrame eglframe, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil -cdef cudaError_t _cudaEGLStreamProducerReturnFrame(cyruntime.cudaEglStreamConnection* conn, cyruntime.cudaEglFrame* eglframe, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil -cdef cudaError_t _cudaGraphicsResourceGetMappedEglFrame(cyruntime.cudaEglFrame* eglFrame, cudaGraphicsResource_t resource, unsigned int index, unsigned int mipLevel) except ?cudaErrorCallRequiresNewerDriver nogil -cdef cudaError_t _cudaVDPAUSetVDPAUDevice(int device, cyruntime.VdpDevice vdpDevice, cyruntime.VdpGetProcAddress* vdpGetProcAddress) except ?cudaErrorCallRequiresNewerDriver nogil -cdef cudaError_t _cudaVDPAUGetDevice(int* device, cyruntime.VdpDevice vdpDevice, cyruntime.VdpGetProcAddress* vdpGetProcAddress) except ?cudaErrorCallRequiresNewerDriver nogil -cdef cudaError_t _cudaGraphicsVDPAURegisterVideoSurface(cudaGraphicsResource** resource, cyruntime.VdpVideoSurface vdpSurface, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -cdef cudaError_t _cudaGraphicsVDPAURegisterOutputSurface(cudaGraphicsResource** resource, cyruntime.VdpOutputSurface vdpSurface, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -cdef cudaError_t _cudaGLGetDevices(unsigned int* pCudaDeviceCount, int* pCudaDevices, unsigned int cudaDeviceCount, cyruntime.cudaGLDeviceList deviceList) except ?cudaErrorCallRequiresNewerDriver nogil -cdef cudaError_t _cudaGraphicsGLRegisterImage(cudaGraphicsResource** resource, cyruntime.GLuint image, cyruntime.GLenum target, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -cdef cudaError_t _cudaGraphicsGLRegisterBuffer(cudaGraphicsResource** resource, cyruntime.GLuint buffer, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -cdef cudaError_t _cudaGraphicsEGLRegisterImage(cudaGraphicsResource_t* pCudaResource, cyruntime.EGLImageKHR image, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -cdef cudaError_t _cudaEGLStreamConsumerConnect(cyruntime.cudaEglStreamConnection* conn, cyruntime.EGLStreamKHR eglStream) except ?cudaErrorCallRequiresNewerDriver nogil -cdef cudaError_t _cudaEGLStreamConsumerConnectWithFlags(cyruntime.cudaEglStreamConnection* conn, cyruntime.EGLStreamKHR eglStream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -cdef cudaError_t _cudaEGLStreamConsumerDisconnect(cyruntime.cudaEglStreamConnection* conn) except ?cudaErrorCallRequiresNewerDriver nogil -cdef cudaError_t _cudaEGLStreamConsumerAcquireFrame(cyruntime.cudaEglStreamConnection* conn, cudaGraphicsResource_t* pCudaResource, cudaStream_t* pStream, unsigned int timeout) except ?cudaErrorCallRequiresNewerDriver nogil -cdef cudaError_t _cudaEGLStreamConsumerReleaseFrame(cyruntime.cudaEglStreamConnection* conn, cudaGraphicsResource_t pCudaResource, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil -cdef cudaError_t _cudaEGLStreamProducerConnect(cyruntime.cudaEglStreamConnection* conn, cyruntime.EGLStreamKHR eglStream, cyruntime.EGLint width, cyruntime.EGLint height) except ?cudaErrorCallRequiresNewerDriver nogil -cdef cudaError_t _cudaEGLStreamProducerDisconnect(cyruntime.cudaEglStreamConnection* conn) except ?cudaErrorCallRequiresNewerDriver nogil -cdef cudaError_t _cudaEventCreateFromEGLSync(cudaEvent_t* phEvent, cyruntime.EGLSyncKHR eglSync, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaEGLStreamProducerPresentFrame(cudaEglStreamConnection* conn, cudaEglFrame eglframe, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaEGLStreamProducerReturnFrame(cudaEglStreamConnection* conn, cudaEglFrame* eglframe, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphicsResourceGetMappedEglFrame(cudaEglFrame* eglFrame, cudaGraphicsResource_t resource, unsigned int index, unsigned int mipLevel) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaVDPAUSetVDPAUDevice(int device, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaVDPAUGetDevice(int* device, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphicsVDPAURegisterVideoSurface(cudaGraphicsResource** resource, VdpVideoSurface vdpSurface, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphicsVDPAURegisterOutputSurface(cudaGraphicsResource** resource, VdpOutputSurface vdpSurface, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGLGetDevices(unsigned int* pCudaDeviceCount, int* pCudaDevices, unsigned int cudaDeviceCount, cudaGLDeviceList deviceList) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphicsGLRegisterImage(cudaGraphicsResource** resource, GLuint image, GLenum target, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphicsGLRegisterBuffer(cudaGraphicsResource** resource, GLuint buffer, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphicsEGLRegisterImage(cudaGraphicsResource_t* pCudaResource, EGLImageKHR image, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaEGLStreamConsumerConnect(cudaEglStreamConnection* conn, EGLStreamKHR eglStream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaEGLStreamConsumerConnectWithFlags(cudaEglStreamConnection* conn, EGLStreamKHR eglStream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaEGLStreamConsumerDisconnect(cudaEglStreamConnection* conn) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaEGLStreamConsumerAcquireFrame(cudaEglStreamConnection* conn, cudaGraphicsResource_t* pCudaResource, cudaStream_t* pStream, unsigned int timeout) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaEGLStreamConsumerReleaseFrame(cudaEglStreamConnection* conn, cudaGraphicsResource_t pCudaResource, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaEGLStreamProducerConnect(cudaEglStreamConnection* conn, EGLStreamKHR eglStream, EGLint width, EGLint height) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaEGLStreamProducerDisconnect(cudaEglStreamConnection* conn) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaEventCreateFromEGLSync(cudaEvent_t* phEvent, EGLSyncKHR eglSync, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil # utility functions -cdef cudaError_t getDriverEglFrame(_cydriver.CUeglFrame *cuEglFrame, cyruntime.cudaEglFrame eglFrame) except ?cudaErrorCallRequiresNewerDriver nogil -cdef cudaError_t getRuntimeEglFrame(cyruntime.cudaEglFrame *eglFrame, _cydriver.CUeglFrame cueglFrame) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t getDriverEglFrame(_cydriver.CUeglFrame *cuEglFrame, cudaEglFrame eglFrame) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t getRuntimeEglFrame(cudaEglFrame *eglFrame, _cydriver.CUeglFrame cueglFrame) except ?cudaErrorCallRequiresNewerDriver nogil diff --git a/cuda_bindings/cuda/bindings/_lib/cyruntime/cyruntime.pxi b/cuda_bindings/cuda/bindings/_lib/cyruntime/cyruntime.pxi index 5a7e5e42bd4..cd99c894ca6 100644 --- a/cuda_bindings/cuda/bindings/_lib/cyruntime/cyruntime.pxi +++ b/cuda_bindings/cuda/bindings/_lib/cyruntime/cyruntime.pxi @@ -11,14 +11,22 @@ # Prior to https://github.com/NVIDIA/cuda-python/pull/914, this was two # independent modules (c.b._lib.cyruntime.cyruntime and # c.b._lib.cyruntime.utils), but was merged into one. +import cython +cimport cython from libc.string cimport memset cimport cuda.bindings._internal.driver as cydriver -cdef cudaError_t _cudaEGLStreamProducerPresentFrame(cyruntime.cudaEglStreamConnection* conn, cyruntime.cudaEglFrame eglframe, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil: +# Call make_cudaPitchedPtr directly from the C header to avoid a runtime import +# of cuda.bindings.cyruntime (the Cython wrapper lives there but including it +# here would create a circular import via _internal.runtime → cyruntime → _internal.runtime). +cdef extern from 'driver_functions.h': + cudaPitchedPtr _cylib_make_cudaPitchedPtr "make_cudaPitchedPtr"(void* d, size_t p, size_t xsz, size_t ysz) nogil + +cdef cudaError_t _cudaEGLStreamProducerPresentFrame(cudaEglStreamConnection* conn, cudaEglFrame eglframe, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef cudaError_t err = cudaSuccess # cudaFree(0) is a NOP operations that initializes the context state - err = cudaFree(0) + err = _cudaFree(0) if err != cudaSuccess: return err cdef cydriver.CUeglFrame cueglFrame @@ -28,10 +36,10 @@ cdef cudaError_t _cudaEGLStreamProducerPresentFrame(cyruntime.cudaEglStreamConne err = cydriver._cuEGLStreamProducerPresentFrame(conn, cueglFrame, pStream) return err -cdef cudaError_t _cudaEGLStreamProducerReturnFrame(cyruntime.cudaEglStreamConnection* conn, cyruntime.cudaEglFrame* eglframe, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaEGLStreamProducerReturnFrame(cudaEglStreamConnection* conn, cudaEglFrame* eglframe, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef cudaError_t err = cudaSuccess # cudaFree(0) is a NOP operations that initializes the context state - err = cudaFree(0) + err = _cudaFree(0) if err != cudaSuccess: return err if eglframe == NULL: @@ -44,10 +52,10 @@ cdef cudaError_t _cudaEGLStreamProducerReturnFrame(cyruntime.cudaEglStreamConnec err = getRuntimeEglFrame(eglframe, cueglFrame) return err -cdef cudaError_t _cudaGraphicsResourceGetMappedEglFrame(cyruntime.cudaEglFrame* eglFrame, cudaGraphicsResource_t resource, unsigned int index, unsigned int mipLevel) except ?cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphicsResourceGetMappedEglFrame(cudaEglFrame* eglFrame, cudaGraphicsResource_t resource, unsigned int index, unsigned int mipLevel) except ?cudaErrorCallRequiresNewerDriver nogil: cdef cudaError_t err = cudaSuccess # cudaFree(0) is a NOP operations that initializes the context state - err = cudaFree(0) + err = _cudaFree(0) if err != cudaSuccess: return err cdef cydriver.CUeglFrame cueglFrame @@ -58,139 +66,139 @@ cdef cudaError_t _cudaGraphicsResourceGetMappedEglFrame(cyruntime.cudaEglFrame* err = getRuntimeEglFrame(eglFrame, cueglFrame) return err -cdef cudaError_t _cudaVDPAUSetVDPAUDevice(int device, cyruntime.VdpDevice vdpDevice, cyruntime.VdpGetProcAddress* vdpGetProcAddress) except ?cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaVDPAUSetVDPAUDevice(int device, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaErrorNotSupported -cdef cudaError_t _cudaVDPAUGetDevice(int* device, cyruntime.VdpDevice vdpDevice, cyruntime.VdpGetProcAddress* vdpGetProcAddress) except ?cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaVDPAUGetDevice(int* device, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?cudaErrorCallRequiresNewerDriver nogil: cdef cudaError_t err = cudaSuccess # cudaFree(0) is a NOP operations that initializes the context state - err = cudaFree(0) + err = _cudaFree(0) if err != cudaSuccess: return err err = cydriver._cuVDPAUGetDevice(device, vdpDevice, vdpGetProcAddress) return err -cdef cudaError_t _cudaGraphicsVDPAURegisterVideoSurface(cudaGraphicsResource** resource, cyruntime.VdpVideoSurface vdpSurface, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphicsVDPAURegisterVideoSurface(cudaGraphicsResource** resource, VdpVideoSurface vdpSurface, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef cudaError_t err = cudaSuccess # cudaFree(0) is a NOP operations that initializes the context state - err = cudaFree(0) + err = _cudaFree(0) if err != cudaSuccess: return err err = cydriver._cuGraphicsVDPAURegisterVideoSurface(resource, vdpSurface, flags) return err -cdef cudaError_t _cudaGraphicsVDPAURegisterOutputSurface(cudaGraphicsResource** resource, cyruntime.VdpOutputSurface vdpSurface, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphicsVDPAURegisterOutputSurface(cudaGraphicsResource** resource, VdpOutputSurface vdpSurface, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef cudaError_t err = cudaSuccess # cudaFree(0) is a NOP operations that initializes the context state - err = cudaFree(0) + err = _cudaFree(0) if err != cudaSuccess: return err err = cydriver._cuGraphicsVDPAURegisterOutputSurface(resource, vdpSurface, flags) return err -cdef cudaError_t _cudaGLGetDevices(unsigned int* pCudaDeviceCount, int* pCudaDevices, unsigned int cudaDeviceCount, cyruntime.cudaGLDeviceList deviceList) except ?cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGLGetDevices(unsigned int* pCudaDeviceCount, int* pCudaDevices, unsigned int cudaDeviceCount, cudaGLDeviceList deviceList) except ?cudaErrorCallRequiresNewerDriver nogil: cdef cudaError_t err = cudaSuccess # cudaFree(0) is a NOP operations that initializes the context state - err = cudaFree(0) + err = _cudaFree(0) if err != cudaSuccess: return err err = cydriver._cuGLGetDevices_v2(pCudaDeviceCount, pCudaDevices, cudaDeviceCount, deviceList) return err -cdef cudaError_t _cudaGraphicsGLRegisterImage(cudaGraphicsResource** resource, cyruntime.GLuint image, cyruntime.GLenum target, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphicsGLRegisterImage(cudaGraphicsResource** resource, GLuint image, GLenum target, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef cudaError_t err = cudaSuccess # cudaFree(0) is a NOP operations that initializes the context state - err = cudaFree(0) + err = _cudaFree(0) if err != cudaSuccess: return err err = cydriver._cuGraphicsGLRegisterImage(resource, image, target, flags) return err -cdef cudaError_t _cudaGraphicsGLRegisterBuffer(cudaGraphicsResource** resource, cyruntime.GLuint buffer, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphicsGLRegisterBuffer(cudaGraphicsResource** resource, GLuint buffer, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef cudaError_t err = cudaSuccess # cudaFree(0) is a NOP operations that initializes the context state - err = cudaFree(0) + err = _cudaFree(0) if err != cudaSuccess: return err err = cydriver._cuGraphicsGLRegisterBuffer(resource, buffer, flags) return err -cdef cudaError_t _cudaGraphicsEGLRegisterImage(cudaGraphicsResource_t* pCudaResource, cyruntime.EGLImageKHR image, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphicsEGLRegisterImage(cudaGraphicsResource_t* pCudaResource, EGLImageKHR image, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef cudaError_t err = cudaSuccess # cudaFree(0) is a NOP operations that initializes the context state - err = cudaFree(0) + err = _cudaFree(0) if err != cudaSuccess: return err err = cydriver._cuGraphicsEGLRegisterImage(pCudaResource, image, flags) return err -cdef cudaError_t _cudaEGLStreamConsumerConnect(cyruntime.cudaEglStreamConnection* conn, cyruntime.EGLStreamKHR eglStream) except ?cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaEGLStreamConsumerConnect(cudaEglStreamConnection* conn, EGLStreamKHR eglStream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef cudaError_t err = cudaSuccess # cudaFree(0) is a NOP operations that initializes the context state - err = cudaFree(0) + err = _cudaFree(0) if err != cudaSuccess: return err err = cydriver._cuEGLStreamConsumerConnect(conn, eglStream) return err -cdef cudaError_t _cudaEGLStreamConsumerConnectWithFlags(cyruntime.cudaEglStreamConnection* conn, cyruntime.EGLStreamKHR eglStream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaEGLStreamConsumerConnectWithFlags(cudaEglStreamConnection* conn, EGLStreamKHR eglStream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef cudaError_t err = cudaSuccess # cudaFree(0) is a NOP operations that initializes the context state - err = cudaFree(0) + err = _cudaFree(0) if err != cudaSuccess: return err err = cydriver._cuEGLStreamConsumerConnectWithFlags(conn, eglStream, flags) return err -cdef cudaError_t _cudaEGLStreamConsumerDisconnect(cyruntime.cudaEglStreamConnection* conn) except ?cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaEGLStreamConsumerDisconnect(cudaEglStreamConnection* conn) except ?cudaErrorCallRequiresNewerDriver nogil: cdef cudaError_t err = cudaSuccess # cudaFree(0) is a NOP operations that initializes the context state - err = cudaFree(0) + err = _cudaFree(0) if err != cudaSuccess: return err err = cydriver._cuEGLStreamConsumerDisconnect(conn) return err -cdef cudaError_t _cudaEGLStreamConsumerAcquireFrame(cyruntime.cudaEglStreamConnection* conn, cudaGraphicsResource_t* pCudaResource, cudaStream_t* pStream, unsigned int timeout) except ?cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaEGLStreamConsumerAcquireFrame(cudaEglStreamConnection* conn, cudaGraphicsResource_t* pCudaResource, cudaStream_t* pStream, unsigned int timeout) except ?cudaErrorCallRequiresNewerDriver nogil: cdef cudaError_t err = cudaSuccess # cudaFree(0) is a NOP operations that initializes the context state - err = cudaFree(0) + err = _cudaFree(0) if err != cudaSuccess: return err err = cydriver._cuEGLStreamConsumerAcquireFrame(conn, pCudaResource, pStream, timeout) return err -cdef cudaError_t _cudaEGLStreamConsumerReleaseFrame(cyruntime.cudaEglStreamConnection* conn, cudaGraphicsResource_t pCudaResource, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaEGLStreamConsumerReleaseFrame(cudaEglStreamConnection* conn, cudaGraphicsResource_t pCudaResource, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef cudaError_t err = cudaSuccess # cudaFree(0) is a NOP operations that initializes the context state - err = cudaFree(0) + err = _cudaFree(0) if err != cudaSuccess: return err err = cydriver._cuEGLStreamConsumerReleaseFrame(conn, pCudaResource, pStream) return err -cdef cudaError_t _cudaEGLStreamProducerConnect(cyruntime.cudaEglStreamConnection* conn, cyruntime.EGLStreamKHR eglStream, cyruntime.EGLint width, cyruntime.EGLint height) except ?cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaEGLStreamProducerConnect(cudaEglStreamConnection* conn, EGLStreamKHR eglStream, EGLint width, EGLint height) except ?cudaErrorCallRequiresNewerDriver nogil: cdef cudaError_t err = cudaSuccess # cudaFree(0) is a NOP operations that initializes the context state - err = cudaFree(0) + err = _cudaFree(0) if err != cudaSuccess: return err err = cydriver._cuEGLStreamProducerConnect(conn, eglStream, width, height) return err -cdef cudaError_t _cudaEGLStreamProducerDisconnect(cyruntime.cudaEglStreamConnection* conn) except ?cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaEGLStreamProducerDisconnect(cudaEglStreamConnection* conn) except ?cudaErrorCallRequiresNewerDriver nogil: cdef cudaError_t err = cudaSuccess # cudaFree(0) is a NOP operations that initializes the context state - err = cudaFree(0) + err = _cudaFree(0) if err != cudaSuccess: return err err = cydriver._cuEGLStreamProducerDisconnect(conn) return err -cdef cudaError_t _cudaEventCreateFromEGLSync(cudaEvent_t* phEvent, cyruntime.EGLSyncKHR eglSync, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaEventCreateFromEGLSync(cudaEvent_t* phEvent, EGLSyncKHR eglSync, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef cudaError_t err = cudaSuccess # cudaFree(0) is a NOP operations that initializes the context state - err = cudaFree(0) + err = _cudaFree(0) if err != cudaSuccess: return err err = cydriver._cuEventCreateFromEGLSync(phEvent, eglSync, flags) @@ -564,7 +572,7 @@ cdef cudaError_t getChannelFormatDescFromDriverDesc(cudaChannelFormatDesc* pRunt pWidth[0] = pDriverDesc[0].Width return cudaSuccess -cdef cudaError_t getDriverEglFrame(cydriver.CUeglFrame *cuEglFrame, cyruntime.cudaEglFrame eglFrame) except ?cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t getDriverEglFrame(cydriver.CUeglFrame *cuEglFrame, cudaEglFrame eglFrame) except ?cudaErrorCallRequiresNewerDriver nogil: cdef cudaError_t err = cudaSuccess cdef unsigned int i = 0 @@ -572,7 +580,7 @@ cdef cudaError_t getDriverEglFrame(cydriver.CUeglFrame *cuEglFrame, cyruntime.cu if err != cudaSuccess: return err for i in range(eglFrame.planeCount): - if eglFrame.frameType == cyruntime.cudaEglFrameTypeArray: + if eglFrame.frameType == cudaEglFrameTypeArray: cuEglFrame[0].frame.pArray[i] = eglFrame.frame.pArray[i] else: cuEglFrame[0].frame.pPitch[i] = eglFrame.frame.pPitch[i].ptr @@ -581,243 +589,243 @@ cdef cudaError_t getDriverEglFrame(cydriver.CUeglFrame *cuEglFrame, cyruntime.cu cuEglFrame[0].depth = eglFrame.planeDesc[0].depth cuEglFrame[0].pitch = eglFrame.planeDesc[0].pitch cuEglFrame[0].planeCount = eglFrame.planeCount - if eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatYUV420Planar: + if eglFrame.eglColorFormat == cudaEglColorFormatYUV420Planar: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatYUV420SemiPlanar: + elif eglFrame.eglColorFormat == cudaEglColorFormatYUV420SemiPlanar: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatYUV422Planar: + elif eglFrame.eglColorFormat == cudaEglColorFormatYUV422Planar: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_PLANAR - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatYUV422SemiPlanar: + elif eglFrame.eglColorFormat == cudaEglColorFormatYUV422SemiPlanar: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_SEMIPLANAR - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatYUV444Planar: + elif eglFrame.eglColorFormat == cudaEglColorFormatYUV444Planar: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_PLANAR - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatYUV444SemiPlanar: + elif eglFrame.eglColorFormat == cudaEglColorFormatYUV444SemiPlanar: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_SEMIPLANAR - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatYUYV422: + elif eglFrame.eglColorFormat == cudaEglColorFormatYUYV422: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUYV_422 - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatUYVY422: + elif eglFrame.eglColorFormat == cudaEglColorFormatUYVY422: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_UYVY_422 - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatUYVY709: + elif eglFrame.eglColorFormat == cudaEglColorFormatUYVY709: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_UYVY_709 - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatUYVY709_ER: + elif eglFrame.eglColorFormat == cudaEglColorFormatUYVY709_ER: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_UYVY_709_ER - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatUYVY2020: + elif eglFrame.eglColorFormat == cudaEglColorFormatUYVY2020: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_UYVY_2020 - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatARGB: + elif eglFrame.eglColorFormat == cudaEglColorFormatARGB: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_ARGB - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatRGBA: + elif eglFrame.eglColorFormat == cudaEglColorFormatRGBA: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_RGBA - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatABGR: + elif eglFrame.eglColorFormat == cudaEglColorFormatABGR: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_ABGR - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatBGRA: + elif eglFrame.eglColorFormat == cudaEglColorFormatBGRA: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BGRA - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatL: + elif eglFrame.eglColorFormat == cudaEglColorFormatL: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_L - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatR: + elif eglFrame.eglColorFormat == cudaEglColorFormatR: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_R - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatA: + elif eglFrame.eglColorFormat == cudaEglColorFormatA: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_A - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatRG: + elif eglFrame.eglColorFormat == cudaEglColorFormatRG: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_RG - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatAYUV: + elif eglFrame.eglColorFormat == cudaEglColorFormatAYUV: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_AYUV - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatYVU444SemiPlanar: + elif eglFrame.eglColorFormat == cudaEglColorFormatYVU444SemiPlanar: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_SEMIPLANAR - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatYVU422SemiPlanar: + elif eglFrame.eglColorFormat == cudaEglColorFormatYVU422SemiPlanar: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_SEMIPLANAR - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatYVU420SemiPlanar: + elif eglFrame.eglColorFormat == cudaEglColorFormatYVU420SemiPlanar: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatY10V10U10_444SemiPlanar: + elif eglFrame.eglColorFormat == cudaEglColorFormatY10V10U10_444SemiPlanar: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatY10V10U10_420SemiPlanar: + elif eglFrame.eglColorFormat == cudaEglColorFormatY10V10U10_420SemiPlanar: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatY12V12U12_444SemiPlanar: + elif eglFrame.eglColorFormat == cudaEglColorFormatY12V12U12_444SemiPlanar: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatY12V12U12_420SemiPlanar: + elif eglFrame.eglColorFormat == cudaEglColorFormatY12V12U12_420SemiPlanar: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatVYUY_ER: + elif eglFrame.eglColorFormat == cudaEglColorFormatVYUY_ER: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_VYUY_ER - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatUYVY_ER: + elif eglFrame.eglColorFormat == cudaEglColorFormatUYVY_ER: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_UYVY_ER - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatYUYV_ER: + elif eglFrame.eglColorFormat == cudaEglColorFormatYUYV_ER: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUYV_ER - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatYVYU_ER: + elif eglFrame.eglColorFormat == cudaEglColorFormatYVYU_ER: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVYU_ER - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatYUVA_ER: + elif eglFrame.eglColorFormat == cudaEglColorFormatYUVA_ER: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUVA_ER - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatAYUV_ER: + elif eglFrame.eglColorFormat == cudaEglColorFormatAYUV_ER: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_AYUV_ER - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatYUV444Planar_ER: + elif eglFrame.eglColorFormat == cudaEglColorFormatYUV444Planar_ER: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_PLANAR_ER - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatYUV422Planar_ER: + elif eglFrame.eglColorFormat == cudaEglColorFormatYUV422Planar_ER: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_PLANAR_ER - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatYUV420Planar_ER: + elif eglFrame.eglColorFormat == cudaEglColorFormatYUV420Planar_ER: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR_ER - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatYUV444SemiPlanar_ER: + elif eglFrame.eglColorFormat == cudaEglColorFormatYUV444SemiPlanar_ER: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_SEMIPLANAR_ER - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatYUV422SemiPlanar_ER: + elif eglFrame.eglColorFormat == cudaEglColorFormatYUV422SemiPlanar_ER: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_SEMIPLANAR_ER - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatYUV420SemiPlanar_ER: + elif eglFrame.eglColorFormat == cudaEglColorFormatYUV420SemiPlanar_ER: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_ER - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatYVU444Planar_ER: + elif eglFrame.eglColorFormat == cudaEglColorFormatYVU444Planar_ER: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_PLANAR_ER - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatYVU422Planar_ER: + elif eglFrame.eglColorFormat == cudaEglColorFormatYVU422Planar_ER: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_PLANAR_ER - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatYVU420Planar_ER: + elif eglFrame.eglColorFormat == cudaEglColorFormatYVU420Planar_ER: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR_ER - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatYVU444SemiPlanar_ER: + elif eglFrame.eglColorFormat == cudaEglColorFormatYVU444SemiPlanar_ER: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_SEMIPLANAR_ER - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatYVU422SemiPlanar_ER: + elif eglFrame.eglColorFormat == cudaEglColorFormatYVU422SemiPlanar_ER: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_SEMIPLANAR_ER - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatYVU420SemiPlanar_ER: + elif eglFrame.eglColorFormat == cudaEglColorFormatYVU420SemiPlanar_ER: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_ER - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatBayerRGGB: + elif eglFrame.eglColorFormat == cudaEglColorFormatBayerRGGB: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_RGGB - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatBayerBGGR: + elif eglFrame.eglColorFormat == cudaEglColorFormatBayerBGGR: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_BGGR - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatBayerGRBG: + elif eglFrame.eglColorFormat == cudaEglColorFormatBayerGRBG: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_GRBG - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatBayerGBRG: + elif eglFrame.eglColorFormat == cudaEglColorFormatBayerGBRG: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_GBRG - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatBayer10RGGB: + elif eglFrame.eglColorFormat == cudaEglColorFormatBayer10RGGB: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_RGGB - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatBayer10BGGR: + elif eglFrame.eglColorFormat == cudaEglColorFormatBayer10BGGR: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_BGGR - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatBayer10GRBG: + elif eglFrame.eglColorFormat == cudaEglColorFormatBayer10GRBG: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_GRBG - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatBayer10GBRG: + elif eglFrame.eglColorFormat == cudaEglColorFormatBayer10GBRG: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_GBRG - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatBayer12RGGB: + elif eglFrame.eglColorFormat == cudaEglColorFormatBayer12RGGB: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_RGGB - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatBayer12BGGR: + elif eglFrame.eglColorFormat == cudaEglColorFormatBayer12BGGR: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_BGGR - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatBayer12GRBG: + elif eglFrame.eglColorFormat == cudaEglColorFormatBayer12GRBG: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_GRBG - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatBayer12GBRG: + elif eglFrame.eglColorFormat == cudaEglColorFormatBayer12GBRG: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_GBRG - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatBayer14RGGB: + elif eglFrame.eglColorFormat == cudaEglColorFormatBayer14RGGB: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER14_RGGB - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatBayer14BGGR: + elif eglFrame.eglColorFormat == cudaEglColorFormatBayer14BGGR: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER14_BGGR - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatBayer14GRBG: + elif eglFrame.eglColorFormat == cudaEglColorFormatBayer14GRBG: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER14_GRBG - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatBayer14GBRG: + elif eglFrame.eglColorFormat == cudaEglColorFormatBayer14GBRG: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER14_GBRG - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatBayer20RGGB: + elif eglFrame.eglColorFormat == cudaEglColorFormatBayer20RGGB: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER20_RGGB - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatBayer20BGGR: + elif eglFrame.eglColorFormat == cudaEglColorFormatBayer20BGGR: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER20_BGGR - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatBayer20GRBG: + elif eglFrame.eglColorFormat == cudaEglColorFormatBayer20GRBG: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER20_GRBG - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatBayer20GBRG: + elif eglFrame.eglColorFormat == cudaEglColorFormatBayer20GBRG: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER20_GBRG - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatBayerIspRGGB: + elif eglFrame.eglColorFormat == cudaEglColorFormatBayerIspRGGB: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_ISP_RGGB - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatBayerIspBGGR: + elif eglFrame.eglColorFormat == cudaEglColorFormatBayerIspBGGR: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_ISP_BGGR - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatBayerIspGRBG: + elif eglFrame.eglColorFormat == cudaEglColorFormatBayerIspGRBG: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_ISP_GRBG - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatBayerIspGBRG: + elif eglFrame.eglColorFormat == cudaEglColorFormatBayerIspGBRG: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_ISP_GBRG - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatYVU444Planar: + elif eglFrame.eglColorFormat == cudaEglColorFormatYVU444Planar: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_PLANAR - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatYVU422Planar: + elif eglFrame.eglColorFormat == cudaEglColorFormatYVU422Planar: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_PLANAR - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatYVU420Planar: + elif eglFrame.eglColorFormat == cudaEglColorFormatYVU420Planar: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatBayerBCCR: + elif eglFrame.eglColorFormat == cudaEglColorFormatBayerBCCR: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_BCCR - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatBayerRCCB: + elif eglFrame.eglColorFormat == cudaEglColorFormatBayerRCCB: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_RCCB - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatBayerCRBC: + elif eglFrame.eglColorFormat == cudaEglColorFormatBayerCRBC: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_CRBC - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatBayerCBRC: + elif eglFrame.eglColorFormat == cudaEglColorFormatBayerCBRC: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_CBRC - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatBayer10CCCC: + elif eglFrame.eglColorFormat == cudaEglColorFormatBayer10CCCC: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_CCCC - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatBayer12BCCR: + elif eglFrame.eglColorFormat == cudaEglColorFormatBayer12BCCR: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_BCCR - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatBayer12RCCB: + elif eglFrame.eglColorFormat == cudaEglColorFormatBayer12RCCB: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_RCCB - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatBayer12CRBC: + elif eglFrame.eglColorFormat == cudaEglColorFormatBayer12CRBC: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_CRBC - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatBayer12CBRC: + elif eglFrame.eglColorFormat == cudaEglColorFormatBayer12CBRC: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_CBRC - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatBayer12CCCC: + elif eglFrame.eglColorFormat == cudaEglColorFormatBayer12CCCC: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_CCCC - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatY: + elif eglFrame.eglColorFormat == cudaEglColorFormatY: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatYUV420SemiPlanar_2020: + elif eglFrame.eglColorFormat == cudaEglColorFormatYUV420SemiPlanar_2020: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_2020 - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatYVU420SemiPlanar_2020: + elif eglFrame.eglColorFormat == cudaEglColorFormatYVU420SemiPlanar_2020: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_2020 - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatYUV420Planar_2020: + elif eglFrame.eglColorFormat == cudaEglColorFormatYUV420Planar_2020: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR_2020 - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatYVU420Planar_2020: + elif eglFrame.eglColorFormat == cudaEglColorFormatYVU420Planar_2020: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR_2020 - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatYUV420SemiPlanar_709: + elif eglFrame.eglColorFormat == cudaEglColorFormatYUV420SemiPlanar_709: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_709 - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatYVU420SemiPlanar_709: + elif eglFrame.eglColorFormat == cudaEglColorFormatYVU420SemiPlanar_709: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_709 - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatYUV420Planar_709: + elif eglFrame.eglColorFormat == cudaEglColorFormatYUV420Planar_709: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR_709 - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatYVU420Planar_709: + elif eglFrame.eglColorFormat == cudaEglColorFormatYVU420Planar_709: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR_709 - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatY10V10U10_420SemiPlanar_709: + elif eglFrame.eglColorFormat == cudaEglColorFormatY10V10U10_420SemiPlanar_709: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709 - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatY10V10U10_420SemiPlanar_2020: + elif eglFrame.eglColorFormat == cudaEglColorFormatY10V10U10_420SemiPlanar_2020: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_2020 - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatY10V10U10_422SemiPlanar_2020: + elif eglFrame.eglColorFormat == cudaEglColorFormatY10V10U10_422SemiPlanar_2020: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_2020 - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatY10V10U10_422SemiPlanar: + elif eglFrame.eglColorFormat == cudaEglColorFormatY10V10U10_422SemiPlanar: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatY10V10U10_422SemiPlanar_709: + elif eglFrame.eglColorFormat == cudaEglColorFormatY10V10U10_422SemiPlanar_709: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_709 - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatY_ER: + elif eglFrame.eglColorFormat == cudaEglColorFormatY_ER: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y_ER - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatY_709_ER: + elif eglFrame.eglColorFormat == cudaEglColorFormatY_709_ER: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y_709_ER - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatY10_ER: + elif eglFrame.eglColorFormat == cudaEglColorFormatY10_ER: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10_ER - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatY10_709_ER: + elif eglFrame.eglColorFormat == cudaEglColorFormatY10_709_ER: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10_709_ER - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatY12_ER: + elif eglFrame.eglColorFormat == cudaEglColorFormatY12_ER: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12_ER - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatY12_709_ER: + elif eglFrame.eglColorFormat == cudaEglColorFormatY12_709_ER: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12_709_ER - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatYUVA: + elif eglFrame.eglColorFormat == cudaEglColorFormatYUVA: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUVA - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatYVYU: + elif eglFrame.eglColorFormat == cudaEglColorFormatYVYU: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVYU - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatVYUY: + elif eglFrame.eglColorFormat == cudaEglColorFormatVYUY: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_VYUY - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatY10V10U10_420SemiPlanar_ER: + elif eglFrame.eglColorFormat == cudaEglColorFormatY10V10U10_420SemiPlanar_ER: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_ER - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatY10V10U10_420SemiPlanar_709_ER: + elif eglFrame.eglColorFormat == cudaEglColorFormatY10V10U10_420SemiPlanar_709_ER: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709_ER - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatY10V10U10_444SemiPlanar_ER: + elif eglFrame.eglColorFormat == cudaEglColorFormatY10V10U10_444SemiPlanar_ER: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_ER - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatY10V10U10_444SemiPlanar_709_ER: + elif eglFrame.eglColorFormat == cudaEglColorFormatY10V10U10_444SemiPlanar_709_ER: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_709_ER - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatY12V12U12_420SemiPlanar_ER: + elif eglFrame.eglColorFormat == cudaEglColorFormatY12V12U12_420SemiPlanar_ER: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_ER - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatY12V12U12_420SemiPlanar_709_ER: + elif eglFrame.eglColorFormat == cudaEglColorFormatY12V12U12_420SemiPlanar_709_ER: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_709_ER - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatY12V12U12_444SemiPlanar_ER: + elif eglFrame.eglColorFormat == cudaEglColorFormatY12V12U12_444SemiPlanar_ER: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_ER - elif eglFrame.eglColorFormat == cyruntime.cudaEglColorFormatY12V12U12_444SemiPlanar_709_ER: + elif eglFrame.eglColorFormat == cudaEglColorFormatY12V12U12_444SemiPlanar_709_ER: cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_709_ER else: return cudaErrorInvalidValue - if eglFrame.frameType == cyruntime.cudaEglFrameTypeArray: + if eglFrame.frameType == cudaEglFrameTypeArray: cuEglFrame[0].frameType = cydriver.CUeglFrameType_enum.CU_EGL_FRAME_TYPE_ARRAY - elif eglFrame.frameType == cyruntime.cudaEglFrameTypePitch: + elif eglFrame.frameType == cudaEglFrameTypePitch: cuEglFrame[0].frameType = cydriver.CUeglFrameType_enum.CU_EGL_FRAME_TYPE_PITCH else: return cudaErrorInvalidValue @cython.show_performance_hints(False) -cdef cudaError_t getRuntimeEglFrame(cyruntime.cudaEglFrame *eglFrame, cydriver.CUeglFrame cueglFrame) except ?cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t getRuntimeEglFrame(cudaEglFrame *eglFrame, cydriver.CUeglFrame cueglFrame) except ?cudaErrorCallRequiresNewerDriver nogil: cdef cudaError_t err = cudaSuccess cdef unsigned int i cdef cydriver.CUDA_ARRAY3D_DESCRIPTOR_v2 ad @@ -935,242 +943,242 @@ cdef cudaError_t getRuntimeEglFrame(cyruntime.cudaEglFrame *eglFrame, cydriver.C if cueglFrame.frameType == cydriver.CUeglFrameType_enum.CU_EGL_FRAME_TYPE_ARRAY: eglFrame[0].frame.pArray[i] = cueglFrame.frame.pArray[i] else: - pPtr = make_cudaPitchedPtr(cueglFrame.frame.pPitch[i], eglFrame[0].planeDesc[i].pitch, + pPtr = _cylib_make_cudaPitchedPtr(cueglFrame.frame.pPitch[i], eglFrame[0].planeDesc[i].pitch, eglFrame[0].planeDesc[i].width, eglFrame[0].planeDesc[i].height) eglFrame[0].frame.pPitch[i] = pPtr eglFrame[0].planeCount = cueglFrame.planeCount if cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatYUV420Planar + eglFrame[0].eglColorFormat = cudaEglColorFormatYUV420Planar elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatYUV420SemiPlanar + eglFrame[0].eglColorFormat = cudaEglColorFormatYUV420SemiPlanar elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_PLANAR: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatYUV422Planar + eglFrame[0].eglColorFormat = cudaEglColorFormatYUV422Planar elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_SEMIPLANAR: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatYUV422SemiPlanar + eglFrame[0].eglColorFormat = cudaEglColorFormatYUV422SemiPlanar elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_PLANAR: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatYUV444Planar + eglFrame[0].eglColorFormat = cudaEglColorFormatYUV444Planar elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_SEMIPLANAR: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatYUV444SemiPlanar + eglFrame[0].eglColorFormat = cudaEglColorFormatYUV444SemiPlanar elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUYV_422: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatYUYV422 + eglFrame[0].eglColorFormat = cudaEglColorFormatYUYV422 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_UYVY_422: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatUYVY422 + eglFrame[0].eglColorFormat = cudaEglColorFormatUYVY422 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_UYVY_709: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatUYVY709 + eglFrame[0].eglColorFormat = cudaEglColorFormatUYVY709 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_UYVY_709_ER: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatUYVY709_ER + eglFrame[0].eglColorFormat = cudaEglColorFormatUYVY709_ER elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_UYVY_2020: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatUYVY2020 + eglFrame[0].eglColorFormat = cudaEglColorFormatUYVY2020 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_ARGB: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatARGB + eglFrame[0].eglColorFormat = cudaEglColorFormatARGB elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_RGBA: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatRGBA + eglFrame[0].eglColorFormat = cudaEglColorFormatRGBA elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_ABGR: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatABGR + eglFrame[0].eglColorFormat = cudaEglColorFormatABGR elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BGRA: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatBGRA + eglFrame[0].eglColorFormat = cudaEglColorFormatBGRA elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_L: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatL + eglFrame[0].eglColorFormat = cudaEglColorFormatL elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_R: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatR + eglFrame[0].eglColorFormat = cudaEglColorFormatR elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_A: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatA + eglFrame[0].eglColorFormat = cudaEglColorFormatA elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_RG: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatRG + eglFrame[0].eglColorFormat = cudaEglColorFormatRG elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_AYUV: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatAYUV + eglFrame[0].eglColorFormat = cudaEglColorFormatAYUV elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_SEMIPLANAR: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatYVU444SemiPlanar + eglFrame[0].eglColorFormat = cudaEglColorFormatYVU444SemiPlanar elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_SEMIPLANAR: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatYVU422SemiPlanar + eglFrame[0].eglColorFormat = cudaEglColorFormatYVU422SemiPlanar elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatYVU420SemiPlanar + eglFrame[0].eglColorFormat = cudaEglColorFormatYVU420SemiPlanar elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatY10V10U10_444SemiPlanar + eglFrame[0].eglColorFormat = cudaEglColorFormatY10V10U10_444SemiPlanar elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatY10V10U10_420SemiPlanar + eglFrame[0].eglColorFormat = cudaEglColorFormatY10V10U10_420SemiPlanar elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatY12V12U12_444SemiPlanar + eglFrame[0].eglColorFormat = cudaEglColorFormatY12V12U12_444SemiPlanar elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatY12V12U12_420SemiPlanar + eglFrame[0].eglColorFormat = cudaEglColorFormatY12V12U12_420SemiPlanar elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_VYUY_ER: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatVYUY_ER + eglFrame[0].eglColorFormat = cudaEglColorFormatVYUY_ER elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_UYVY_ER: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatUYVY_ER + eglFrame[0].eglColorFormat = cudaEglColorFormatUYVY_ER elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUYV_ER: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatYUYV_ER + eglFrame[0].eglColorFormat = cudaEglColorFormatYUYV_ER elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVYU_ER: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatYVYU_ER + eglFrame[0].eglColorFormat = cudaEglColorFormatYVYU_ER elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUVA_ER: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatYUVA_ER + eglFrame[0].eglColorFormat = cudaEglColorFormatYUVA_ER elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_AYUV_ER: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatAYUV_ER + eglFrame[0].eglColorFormat = cudaEglColorFormatAYUV_ER elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_PLANAR_ER: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatYUV444Planar_ER + eglFrame[0].eglColorFormat = cudaEglColorFormatYUV444Planar_ER elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_PLANAR_ER: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatYUV422Planar_ER + eglFrame[0].eglColorFormat = cudaEglColorFormatYUV422Planar_ER elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR_ER: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatYUV420Planar_ER + eglFrame[0].eglColorFormat = cudaEglColorFormatYUV420Planar_ER elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_SEMIPLANAR_ER: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatYUV444SemiPlanar_ER + eglFrame[0].eglColorFormat = cudaEglColorFormatYUV444SemiPlanar_ER elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_SEMIPLANAR_ER: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatYUV422SemiPlanar_ER + eglFrame[0].eglColorFormat = cudaEglColorFormatYUV422SemiPlanar_ER elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_ER: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatYUV420SemiPlanar_ER + eglFrame[0].eglColorFormat = cudaEglColorFormatYUV420SemiPlanar_ER elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_PLANAR_ER: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatYVU444Planar_ER + eglFrame[0].eglColorFormat = cudaEglColorFormatYVU444Planar_ER elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_PLANAR_ER: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatYVU422Planar_ER + eglFrame[0].eglColorFormat = cudaEglColorFormatYVU422Planar_ER elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR_ER: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatYVU420Planar_ER + eglFrame[0].eglColorFormat = cudaEglColorFormatYVU420Planar_ER elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_SEMIPLANAR_ER: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatYVU444SemiPlanar_ER + eglFrame[0].eglColorFormat = cudaEglColorFormatYVU444SemiPlanar_ER elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_SEMIPLANAR_ER: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatYVU422SemiPlanar_ER + eglFrame[0].eglColorFormat = cudaEglColorFormatYVU422SemiPlanar_ER elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_ER: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatYVU420SemiPlanar_ER + eglFrame[0].eglColorFormat = cudaEglColorFormatYVU420SemiPlanar_ER elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_RGGB: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatBayerRGGB + eglFrame[0].eglColorFormat = cudaEglColorFormatBayerRGGB elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_BGGR: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatBayerBGGR + eglFrame[0].eglColorFormat = cudaEglColorFormatBayerBGGR elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_GRBG: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatBayerGRBG + eglFrame[0].eglColorFormat = cudaEglColorFormatBayerGRBG elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_GBRG: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatBayerGBRG + eglFrame[0].eglColorFormat = cudaEglColorFormatBayerGBRG elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_RGGB: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatBayer10RGGB + eglFrame[0].eglColorFormat = cudaEglColorFormatBayer10RGGB elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_BGGR: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatBayer10BGGR + eglFrame[0].eglColorFormat = cudaEglColorFormatBayer10BGGR elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_GRBG: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatBayer10GRBG + eglFrame[0].eglColorFormat = cudaEglColorFormatBayer10GRBG elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_GBRG: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatBayer10GBRG + eglFrame[0].eglColorFormat = cudaEglColorFormatBayer10GBRG elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_RGGB: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatBayer12RGGB + eglFrame[0].eglColorFormat = cudaEglColorFormatBayer12RGGB elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_BGGR: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatBayer12BGGR + eglFrame[0].eglColorFormat = cudaEglColorFormatBayer12BGGR elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_GRBG: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatBayer12GRBG + eglFrame[0].eglColorFormat = cudaEglColorFormatBayer12GRBG elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_GBRG: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatBayer12GBRG + eglFrame[0].eglColorFormat = cudaEglColorFormatBayer12GBRG elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER14_RGGB: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatBayer14RGGB + eglFrame[0].eglColorFormat = cudaEglColorFormatBayer14RGGB elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER14_BGGR: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatBayer14BGGR + eglFrame[0].eglColorFormat = cudaEglColorFormatBayer14BGGR elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER14_GRBG: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatBayer14GRBG + eglFrame[0].eglColorFormat = cudaEglColorFormatBayer14GRBG elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER14_GBRG: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatBayer14GBRG + eglFrame[0].eglColorFormat = cudaEglColorFormatBayer14GBRG elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER20_RGGB: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatBayer20RGGB + eglFrame[0].eglColorFormat = cudaEglColorFormatBayer20RGGB elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER20_BGGR: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatBayer20BGGR + eglFrame[0].eglColorFormat = cudaEglColorFormatBayer20BGGR elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER20_GRBG: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatBayer20GRBG + eglFrame[0].eglColorFormat = cudaEglColorFormatBayer20GRBG elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER20_GBRG: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatBayer20GBRG + eglFrame[0].eglColorFormat = cudaEglColorFormatBayer20GBRG elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_ISP_RGGB: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatBayerIspRGGB + eglFrame[0].eglColorFormat = cudaEglColorFormatBayerIspRGGB elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_ISP_BGGR: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatBayerIspBGGR + eglFrame[0].eglColorFormat = cudaEglColorFormatBayerIspBGGR elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_ISP_GRBG: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatBayerIspGRBG + eglFrame[0].eglColorFormat = cudaEglColorFormatBayerIspGRBG elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_ISP_GBRG: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatBayerIspGBRG + eglFrame[0].eglColorFormat = cudaEglColorFormatBayerIspGBRG elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_PLANAR: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatYVU444Planar + eglFrame[0].eglColorFormat = cudaEglColorFormatYVU444Planar elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_PLANAR: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatYVU422Planar + eglFrame[0].eglColorFormat = cudaEglColorFormatYVU422Planar elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatYVU420Planar + eglFrame[0].eglColorFormat = cudaEglColorFormatYVU420Planar elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_BCCR: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatBayerBCCR + eglFrame[0].eglColorFormat = cudaEglColorFormatBayerBCCR elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_RCCB: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatBayerRCCB + eglFrame[0].eglColorFormat = cudaEglColorFormatBayerRCCB elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_CRBC: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatBayerCRBC + eglFrame[0].eglColorFormat = cudaEglColorFormatBayerCRBC elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_CBRC: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatBayerCBRC + eglFrame[0].eglColorFormat = cudaEglColorFormatBayerCBRC elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_CCCC: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatBayer10CCCC + eglFrame[0].eglColorFormat = cudaEglColorFormatBayer10CCCC elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_BCCR: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatBayer12BCCR + eglFrame[0].eglColorFormat = cudaEglColorFormatBayer12BCCR elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_RCCB: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatBayer12RCCB + eglFrame[0].eglColorFormat = cudaEglColorFormatBayer12RCCB elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_CRBC: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatBayer12CRBC + eglFrame[0].eglColorFormat = cudaEglColorFormatBayer12CRBC elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_CBRC: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatBayer12CBRC + eglFrame[0].eglColorFormat = cudaEglColorFormatBayer12CBRC elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_CCCC: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatBayer12CCCC + eglFrame[0].eglColorFormat = cudaEglColorFormatBayer12CCCC elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatY + eglFrame[0].eglColorFormat = cudaEglColorFormatY elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_2020: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatYUV420SemiPlanar_2020 + eglFrame[0].eglColorFormat = cudaEglColorFormatYUV420SemiPlanar_2020 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_2020: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatYVU420SemiPlanar_2020 + eglFrame[0].eglColorFormat = cudaEglColorFormatYVU420SemiPlanar_2020 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR_2020: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatYUV420Planar_2020 + eglFrame[0].eglColorFormat = cudaEglColorFormatYUV420Planar_2020 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR_2020: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatYVU420Planar_2020 + eglFrame[0].eglColorFormat = cudaEglColorFormatYVU420Planar_2020 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_709: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatYUV420SemiPlanar_709 + eglFrame[0].eglColorFormat = cudaEglColorFormatYUV420SemiPlanar_709 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_709: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatYVU420SemiPlanar_709 + eglFrame[0].eglColorFormat = cudaEglColorFormatYVU420SemiPlanar_709 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR_709: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatYUV420Planar_709 + eglFrame[0].eglColorFormat = cudaEglColorFormatYUV420Planar_709 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR_709: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatYVU420Planar_709 + eglFrame[0].eglColorFormat = cudaEglColorFormatYVU420Planar_709 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatY10V10U10_420SemiPlanar_709 + eglFrame[0].eglColorFormat = cudaEglColorFormatY10V10U10_420SemiPlanar_709 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_2020: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatY10V10U10_420SemiPlanar_2020 + eglFrame[0].eglColorFormat = cudaEglColorFormatY10V10U10_420SemiPlanar_2020 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_2020: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatY10V10U10_422SemiPlanar_2020 + eglFrame[0].eglColorFormat = cudaEglColorFormatY10V10U10_422SemiPlanar_2020 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatY10V10U10_422SemiPlanar + eglFrame[0].eglColorFormat = cudaEglColorFormatY10V10U10_422SemiPlanar elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_709: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatY10V10U10_422SemiPlanar_709 + eglFrame[0].eglColorFormat = cudaEglColorFormatY10V10U10_422SemiPlanar_709 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y_ER: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatY_ER + eglFrame[0].eglColorFormat = cudaEglColorFormatY_ER elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y_709_ER: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatY_709_ER + eglFrame[0].eglColorFormat = cudaEglColorFormatY_709_ER elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10_ER: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatY10_ER + eglFrame[0].eglColorFormat = cudaEglColorFormatY10_ER elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10_709_ER: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatY10_709_ER + eglFrame[0].eglColorFormat = cudaEglColorFormatY10_709_ER elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12_ER: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatY12_ER + eglFrame[0].eglColorFormat = cudaEglColorFormatY12_ER elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12_709_ER: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatY12_709_ER + eglFrame[0].eglColorFormat = cudaEglColorFormatY12_709_ER elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUVA: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatYUVA + eglFrame[0].eglColorFormat = cudaEglColorFormatYUVA elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVYU: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatYVYU + eglFrame[0].eglColorFormat = cudaEglColorFormatYVYU elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_VYUY: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatVYUY + eglFrame[0].eglColorFormat = cudaEglColorFormatVYUY elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_ER: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatY10V10U10_420SemiPlanar_ER + eglFrame[0].eglColorFormat = cudaEglColorFormatY10V10U10_420SemiPlanar_ER elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709_ER: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatY10V10U10_420SemiPlanar_709_ER + eglFrame[0].eglColorFormat = cudaEglColorFormatY10V10U10_420SemiPlanar_709_ER elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_ER: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatY10V10U10_444SemiPlanar_ER + eglFrame[0].eglColorFormat = cudaEglColorFormatY10V10U10_444SemiPlanar_ER elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_709_ER: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatY10V10U10_444SemiPlanar_709_ER + eglFrame[0].eglColorFormat = cudaEglColorFormatY10V10U10_444SemiPlanar_709_ER elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_ER: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatY12V12U12_420SemiPlanar_ER + eglFrame[0].eglColorFormat = cudaEglColorFormatY12V12U12_420SemiPlanar_ER elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_709_ER: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatY12V12U12_420SemiPlanar_709_ER + eglFrame[0].eglColorFormat = cudaEglColorFormatY12V12U12_420SemiPlanar_709_ER elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_ER: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatY12V12U12_444SemiPlanar_ER + eglFrame[0].eglColorFormat = cudaEglColorFormatY12V12U12_444SemiPlanar_ER elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_709_ER: - eglFrame[0].eglColorFormat = cyruntime.cudaEglColorFormatY12V12U12_444SemiPlanar_709_ER + eglFrame[0].eglColorFormat = cudaEglColorFormatY12V12U12_444SemiPlanar_709_ER else: return cudaErrorInvalidValue if cueglFrame.frameType == cydriver.CUeglFrameType_enum.CU_EGL_FRAME_TYPE_ARRAY: - eglFrame[0].frameType = cyruntime.cudaEglFrameTypeArray + eglFrame[0].frameType = cudaEglFrameTypeArray elif cueglFrame.frameType == cydriver.CUeglFrameType_enum.CU_EGL_FRAME_TYPE_PITCH: - eglFrame[0].frameType = cyruntime.cudaEglFrameTypePitch + eglFrame[0].frameType = cudaEglFrameTypePitch else: return cudaErrorInvalidValue diff --git a/cuda_bindings/cuda/bindings/cydriver.pxd b/cuda_bindings/cuda/bindings/cydriver.pxd index 090ac5417ef..43f9d031e24 100644 --- a/cuda_bindings/cuda/bindings/cydriver.pxd +++ b/cuda_bindings/cuda/bindings/cydriver.pxd @@ -4,7 +4,7 @@ # # This code was automatically generated across versions from 12.9.0 to 13.3.0. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=be542bd43838a355344b0cdedcf3496368dd3cf0ebdfeda22b5963f384f4d06d +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=cccb0572002cd20232f2b9f5c7acf559c92813d33dfc364136d57c8f453e50c6 from libc.stdint cimport uint32_t, uint64_t @@ -1329,12 +1329,12 @@ cdef extern from 'cuda.h': CU_COREDUMP_LIGHTWEIGHT_FLAGS cdef extern from 'cuda.h': - ctypedef enum CUgreenCtxCreate_flags: + ctypedef enum CUgreenCtxCreate_flags "CUgreenCtxCreate_flags": CU_GREEN_CTX_NONE CU_GREEN_CTX_DEFAULT_STREAM cdef extern from 'cuda.h': - ctypedef enum CUdevResourceType: + ctypedef enum CUdevResourceType "CUdevResourceType": CU_DEV_RESOURCE_TYPE_INVALID CU_DEV_RESOURCE_TYPE_SM CU_DEV_RESOURCE_TYPE_WORKQUEUE_CONFIG @@ -1531,17 +1531,17 @@ cdef extern from 'cuda.h': ctypedef CUstreamAtomicReductionDataType_enum CUstreamAtomicReductionDataType cdef extern from 'cuda.h': - ctypedef enum CUdevSmResourceGroup_flags: + ctypedef enum CUdevSmResourceGroup_flags "CUdevSmResourceGroup_flags": CU_DEV_SM_RESOURCE_GROUP_DEFAULT CU_DEV_SM_RESOURCE_GROUP_BACKFILL cdef extern from 'cuda.h': - ctypedef enum CUdevSmResourceSplitByCount_flags: + ctypedef enum CUdevSmResourceSplitByCount_flags "CUdevSmResourceSplitByCount_flags": CU_DEV_SM_RESOURCE_SPLIT_IGNORE_SM_COSCHEDULING CU_DEV_SM_RESOURCE_SPLIT_MAX_POTENTIAL_CLUSTER_SIZE cdef extern from 'cuda.h': - ctypedef enum CUdevWorkqueueConfigScope: + ctypedef enum CUdevWorkqueueConfigScope "CUdevWorkqueueConfigScope": CU_WORKQUEUE_SCOPE_DEVICE_CTX CU_WORKQUEUE_SCOPE_GREEN_CTX_BALANCED diff --git a/cuda_bindings/cuda/bindings/cynvrtc.pxd b/cuda_bindings/cuda/bindings/cynvrtc.pxd index 0c0ec2f624d..e377fd316e2 100644 --- a/cuda_bindings/cuda/bindings/cynvrtc.pxd +++ b/cuda_bindings/cuda/bindings/cynvrtc.pxd @@ -4,13 +4,13 @@ # # This code was automatically generated across versions from 12.9.0 to 13.3.0. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=0da658de603326899002d26fdbea39e6f469626207e7b40435f7f24a7e5accf0 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=dbbc8028df717e2c963cb78a4e59700459ad88e1ac111c61e5992d7d007ecc5e from libc.stdint cimport uint32_t, uint64_t # ENUMS cdef extern from 'nvrtc.h': - ctypedef enum nvrtcResult: + ctypedef enum nvrtcResult "nvrtcResult": NVRTC_SUCCESS NVRTC_ERROR_OUT_OF_MEMORY NVRTC_ERROR_PROGRAM_CREATION_FAILURE diff --git a/cuda_bindings/cuda/bindings/cyruntime.pxd b/cuda_bindings/cuda/bindings/cyruntime.pxd new file mode 100644 index 00000000000..58e0a14ca60 --- /dev/null +++ b/cuda_bindings/cuda/bindings/cyruntime.pxd @@ -0,0 +1,2662 @@ +# SPDX-FileCopyrightText: Copyright (c) 2021-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# SPDX-License-Identifier: Apache-2.0 +# +# This code was automatically generated across versions from 12.9.0 to 13.3.0. Do not modify it directly. + +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=2b62a3b56226f5cf6953f578057af792369a100b7775328c5aa66d81d780d2ac +from libc.stdint cimport uint32_t, uint64_t + + +# Types overridden or aliased here because they are macros in driver_types.h +# (not real C types) and cannot be generated from headers directly. + +# GL +ctypedef unsigned int GLenum +ctypedef unsigned int GLuint + +# EGL +ctypedef void *EGLImageKHR +ctypedef void *EGLStreamKHR +ctypedef unsigned int EGLint +ctypedef void *EGLSyncKHR + +# VDPAU +ctypedef uint32_t VdpDevice +ctypedef unsigned long long VdpGetProcAddress +ctypedef uint32_t VdpVideoSurface +ctypedef uint32_t VdpOutputSurface + +# These four names are preprocessor macros in driver_types.h that alias the +# cudaLaunchAttribute* types. Omitting the C alias string is intentional: it +# preserves the Cython-mangled ABI (__pyx_t_...) that legacy_cython_gen produced, +# so downstream extensions compiled against the old headers keep working. +# Do NOT add 'CName' aliases here — that would break binary compatibility. +ctypedef cudaLaunchAttributeID cudaStreamAttrID +ctypedef cudaLaunchAttributeID cudaKernelNodeAttrID +ctypedef cudaLaunchAttributeValue cudaStreamAttrValue +ctypedef cudaLaunchAttributeValue cudaKernelNodeAttrValue + +# dim3 is used as a member type in several CUDA structs +cdef extern from 'vector_types.h': + ctypedef struct dim3 'dim3': + unsigned int x + unsigned int y + unsigned int z + +# Opaque CUDA runtime handle types declared as their underlying CU*_st pointer types +# (matching cydriver's declarations) so that runtime wrapper classes sharing _pvt_ptr +# with driver wrapper classes can assign values without Cython type errors. +cdef extern from 'driver_types.h': + cdef struct CUstream_st 'CUstream_st': + pass + ctypedef CUstream_st* cudaStream_t 'cudaStream_t' + +cdef extern from 'driver_types.h': + cdef struct CUevent_st 'CUevent_st': + pass + ctypedef CUevent_st* cudaEvent_t 'cudaEvent_t' + +cdef extern from 'driver_types.h': + cdef struct CUexternalMemory_st 'CUexternalMemory_st': + pass + ctypedef CUexternalMemory_st* cudaExternalMemory_t 'cudaExternalMemory_t' + +cdef extern from 'driver_types.h': + cdef struct CUexternalSemaphore_st 'CUexternalSemaphore_st': + pass + ctypedef CUexternalSemaphore_st* cudaExternalSemaphore_t 'cudaExternalSemaphore_t' + +cdef extern from 'driver_types.h': + cdef struct CUgraph_st 'CUgraph_st': + pass + ctypedef CUgraph_st* cudaGraph_t 'cudaGraph_t' + +cdef extern from 'driver_types.h': + cdef struct CUgraphNode_st 'CUgraphNode_st': + pass + ctypedef CUgraphNode_st* cudaGraphNode_t 'cudaGraphNode_t' + +cdef extern from 'driver_types.h': + cdef struct CUuserObject_st 'CUuserObject_st': + pass + ctypedef CUuserObject_st* cudaUserObject_t 'cudaUserObject_t' + +cdef extern from 'driver_types.h': + cdef struct CUfunc_st 'CUfunc_st': + pass + ctypedef CUfunc_st* cudaFunction_t 'cudaFunction_t' + +cdef extern from 'driver_types.h': + cdef struct CUkern_st 'CUkern_st': + pass + ctypedef CUkern_st* cudaKernel_t 'cudaKernel_t' + +cdef extern from 'driver_types.h': + cdef struct CUlib_st 'CUlib_st': + pass + ctypedef CUlib_st* cudaLibrary_t 'cudaLibrary_t' + +cdef extern from 'driver_types.h': + cdef struct CUmemPoolHandle_st 'CUmemPoolHandle_st': + pass + ctypedef CUmemPoolHandle_st* cudaMemPool_t 'cudaMemPool_t' + +cdef extern from 'driver_types.h': + cdef struct CUgraphExec_st 'CUgraphExec_st': + pass + ctypedef CUgraphExec_st* cudaGraphExec_t 'cudaGraphExec_t' + +cdef extern from 'driver_types.h': + cdef struct CUgraphDeviceUpdatableNode_st 'CUgraphDeviceUpdatableNode_st': + pass + ctypedef CUgraphDeviceUpdatableNode_st* cudaGraphDeviceNode_t 'cudaGraphDeviceNode_t' + +cdef extern from 'driver_types.h': + cdef struct CUlogsCallbackEntry_st 'CUlogsCallbackEntry_st': + pass + ctypedef CUlogsCallbackEntry_st* cudaLogsCallbackHandle 'cudaLogsCallbackHandle' + +cdef extern from 'driver_types.h': + cdef struct CUdevResourceDesc_st 'CUdevResourceDesc_st': + pass + ctypedef CUdevResourceDesc_st* cudaDevResourceDesc_t 'cudaDevResourceDesc_t' + +cdef extern from 'driver_types.h': + cdef struct cudaExecutionContext_st 'cudaExecutionContext_st': + pass + ctypedef cudaExecutionContext_st* cudaExecutionContext_t 'cudaExecutionContext_t' + +# Types that are outside the naming pattern or SKIPped but required for ABI compatibility +# with the lowpp layer (runtime.pxd) which was generated by legacy_cython_gen. +cdef extern from 'driver_types.h': + cdef struct CUuuid_st 'CUuuid_st': + char bytes[16] + ctypedef CUuuid_st CUuuid 'CUuuid' + +cdef extern from 'driver_types.h': + cdef struct cudalibraryHostUniversalFunctionAndDataTable 'cudalibraryHostUniversalFunctionAndDataTable': + void* functionTable + size_t functionWindowSize + void* dataTable + size_t dataWindowSize + +# Forward declarations for types that are SKIPped but referenced in non-skipped structs/functions +cdef extern from 'driver_types.h': + ctypedef struct cudaUUID_t 'cudaUUID_t': + char bytes[16] + +cdef extern from 'driver_types.h': + cdef struct cudaGraphicsResource 'cudaGraphicsResource': + pass + ctypedef cudaGraphicsResource* cudaGraphicsResource_t 'cudaGraphicsResource_t' + +cdef extern from *: + """ + struct CUeglStreamConnection_st; + typedef struct CUeglStreamConnection_st *cudaEglStreamConnection; + """ + cdef struct CUeglStreamConnection_st 'CUeglStreamConnection_st': + pass + +# Declared at module scope (not inside cdef extern from) so that Cython assigns +# its own mangled name (__pyx_t_...) to this typedef, preserving the Cython ABI +# that legacy_cython_gen produced for the EGL functions that take this type. +# Do NOT move this declaration back inside the cdef extern from block. +ctypedef CUeglStreamConnection_st* cudaEglStreamConnection + + +# ENUMS +cdef extern from 'driver_types.h': + cdef enum cudaError: + cudaSuccess + cudaErrorInvalidValue + cudaErrorMemoryAllocation + cudaErrorInitializationError + cudaErrorCudartUnloading + cudaErrorProfilerDisabled + cudaErrorProfilerNotInitialized + cudaErrorProfilerAlreadyStarted + cudaErrorProfilerAlreadyStopped + cudaErrorInvalidConfiguration + cudaErrorVersionTranslation + cudaErrorInvalidPitchValue + cudaErrorInvalidSymbol + cudaErrorInvalidHostPointer + cudaErrorInvalidDevicePointer + cudaErrorInvalidTexture + cudaErrorInvalidTextureBinding + cudaErrorInvalidChannelDescriptor + cudaErrorInvalidMemcpyDirection + cudaErrorAddressOfConstant + cudaErrorTextureFetchFailed + cudaErrorTextureNotBound + cudaErrorSynchronizationError + cudaErrorInvalidFilterSetting + cudaErrorInvalidNormSetting + cudaErrorMixedDeviceExecution + cudaErrorNotYetImplemented + cudaErrorMemoryValueTooLarge + cudaErrorStubLibrary + cudaErrorInsufficientDriver + cudaErrorCallRequiresNewerDriver + cudaErrorInvalidSurface + cudaErrorDuplicateVariableName + cudaErrorDuplicateTextureName + cudaErrorDuplicateSurfaceName + cudaErrorDevicesUnavailable + cudaErrorIncompatibleDriverContext + cudaErrorMissingConfiguration + cudaErrorPriorLaunchFailure + cudaErrorLaunchMaxDepthExceeded + cudaErrorLaunchFileScopedTex + cudaErrorLaunchFileScopedSurf + cudaErrorSyncDepthExceeded + cudaErrorLaunchPendingCountExceeded + cudaErrorInvalidDeviceFunction + cudaErrorNoDevice + cudaErrorInvalidDevice + cudaErrorDeviceNotLicensed + cudaErrorSoftwareValidityNotEstablished + cudaErrorStartupFailure + cudaErrorInvalidKernelImage + cudaErrorDeviceUninitialized + cudaErrorMapBufferObjectFailed + cudaErrorUnmapBufferObjectFailed + cudaErrorArrayIsMapped + cudaErrorAlreadyMapped + cudaErrorNoKernelImageForDevice + cudaErrorAlreadyAcquired + cudaErrorNotMapped + cudaErrorNotMappedAsArray + cudaErrorNotMappedAsPointer + cudaErrorECCUncorrectable + cudaErrorUnsupportedLimit + cudaErrorDeviceAlreadyInUse + cudaErrorPeerAccessUnsupported + cudaErrorInvalidPtx + cudaErrorInvalidGraphicsContext + cudaErrorNvlinkUncorrectable + cudaErrorJitCompilerNotFound + cudaErrorUnsupportedPtxVersion + cudaErrorJitCompilationDisabled + cudaErrorUnsupportedExecAffinity + cudaErrorUnsupportedDevSideSync + cudaErrorContained + cudaErrorInvalidSource + cudaErrorFileNotFound + cudaErrorSharedObjectSymbolNotFound + cudaErrorSharedObjectInitFailed + cudaErrorOperatingSystem + cudaErrorInvalidResourceHandle + cudaErrorIllegalState + cudaErrorLossyQuery + cudaErrorSymbolNotFound + cudaErrorNotReady + cudaErrorIllegalAddress + cudaErrorLaunchOutOfResources + cudaErrorLaunchTimeout + cudaErrorLaunchIncompatibleTexturing + cudaErrorPeerAccessAlreadyEnabled + cudaErrorPeerAccessNotEnabled + cudaErrorSetOnActiveProcess + cudaErrorContextIsDestroyed + cudaErrorAssert + cudaErrorTooManyPeers + cudaErrorHostMemoryAlreadyRegistered + cudaErrorHostMemoryNotRegistered + cudaErrorHardwareStackError + cudaErrorIllegalInstruction + cudaErrorMisalignedAddress + cudaErrorInvalidAddressSpace + cudaErrorInvalidPc + cudaErrorLaunchFailure + cudaErrorCooperativeLaunchTooLarge + cudaErrorTensorMemoryLeak + cudaErrorNotPermitted + cudaErrorNotSupported + cudaErrorSystemNotReady + cudaErrorSystemDriverMismatch + cudaErrorCompatNotSupportedOnDevice + cudaErrorMpsConnectionFailed + cudaErrorMpsRpcFailure + cudaErrorMpsServerNotReady + cudaErrorMpsMaxClientsReached + cudaErrorMpsMaxConnectionsReached + cudaErrorMpsClientTerminated + cudaErrorCdpNotSupported + cudaErrorCdpVersionMismatch + cudaErrorStreamCaptureUnsupported + cudaErrorStreamCaptureInvalidated + cudaErrorStreamCaptureMerge + cudaErrorStreamCaptureUnmatched + cudaErrorStreamCaptureUnjoined + cudaErrorStreamCaptureIsolation + cudaErrorStreamCaptureImplicit + cudaErrorCapturedEvent + cudaErrorStreamCaptureWrongThread + cudaErrorTimeout + cudaErrorGraphExecUpdateFailure + cudaErrorExternalDevice + cudaErrorInvalidClusterSize + cudaErrorFunctionNotLoaded + cudaErrorInvalidResourceType + cudaErrorInvalidResourceConfiguration + cudaErrorStreamDetached + cudaErrorGraphRecaptureFailure + cudaErrorUnknown + cudaErrorApiFailureBase + +cdef extern from 'driver_types.h': + cdef enum cudaChannelFormatKind: + cudaChannelFormatKindSigned + cudaChannelFormatKindUnsigned + cudaChannelFormatKindFloat + cudaChannelFormatKindNone + cudaChannelFormatKindNV12 + cudaChannelFormatKindUnsignedNormalized8X1 + cudaChannelFormatKindUnsignedNormalized8X2 + cudaChannelFormatKindUnsignedNormalized8X4 + cudaChannelFormatKindUnsignedNormalized16X1 + cudaChannelFormatKindUnsignedNormalized16X2 + cudaChannelFormatKindUnsignedNormalized16X4 + cudaChannelFormatKindSignedNormalized8X1 + cudaChannelFormatKindSignedNormalized8X2 + cudaChannelFormatKindSignedNormalized8X4 + cudaChannelFormatKindSignedNormalized16X1 + cudaChannelFormatKindSignedNormalized16X2 + cudaChannelFormatKindSignedNormalized16X4 + cudaChannelFormatKindUnsignedBlockCompressed1 + cudaChannelFormatKindUnsignedBlockCompressed1SRGB + cudaChannelFormatKindUnsignedBlockCompressed2 + cudaChannelFormatKindUnsignedBlockCompressed2SRGB + cudaChannelFormatKindUnsignedBlockCompressed3 + cudaChannelFormatKindUnsignedBlockCompressed3SRGB + cudaChannelFormatKindUnsignedBlockCompressed4 + cudaChannelFormatKindSignedBlockCompressed4 + cudaChannelFormatKindUnsignedBlockCompressed5 + cudaChannelFormatKindSignedBlockCompressed5 + cudaChannelFormatKindUnsignedBlockCompressed6H + cudaChannelFormatKindSignedBlockCompressed6H + cudaChannelFormatKindUnsignedBlockCompressed7 + cudaChannelFormatKindUnsignedBlockCompressed7SRGB + cudaChannelFormatKindUnsignedNormalized1010102 + cudaChannelFormatKindUnsigned8Packed422 + cudaChannelFormatKindUnsigned8Packed444 + cudaChannelFormatKindUnsigned8SemiPlanar420 + cudaChannelFormatKindUnsigned16SemiPlanar420 + cudaChannelFormatKindUnsigned8SemiPlanar422 + cudaChannelFormatKindUnsigned16SemiPlanar422 + cudaChannelFormatKindUnsigned8SemiPlanar444 + cudaChannelFormatKindUnsigned16SemiPlanar444 + cudaChannelFormatKindUnsigned8Planar420 + cudaChannelFormatKindUnsigned16Planar420 + cudaChannelFormatKindUnsigned8Planar422 + cudaChannelFormatKindUnsigned16Planar422 + cudaChannelFormatKindUnsigned8Planar444 + cudaChannelFormatKindUnsigned16Planar444 + +cdef extern from 'driver_types.h': + cdef enum cudaMemoryType: + cudaMemoryTypeUnregistered + cudaMemoryTypeHost + cudaMemoryTypeDevice + cudaMemoryTypeManaged + +cdef extern from 'driver_types.h': + cdef enum cudaMemcpyKind: + cudaMemcpyHostToHost + cudaMemcpyHostToDevice + cudaMemcpyDeviceToHost + cudaMemcpyDeviceToDevice + cudaMemcpyDefault + +cdef extern from 'driver_types.h': + cdef enum cudaAccessProperty: + cudaAccessPropertyNormal + cudaAccessPropertyStreaming + cudaAccessPropertyPersisting + +cdef extern from 'driver_types.h': + cdef enum cudaStreamCaptureStatus: + cudaStreamCaptureStatusNone + cudaStreamCaptureStatusActive + cudaStreamCaptureStatusInvalidated + +cdef extern from 'driver_types.h': + cdef enum cudaStreamCaptureMode: + cudaStreamCaptureModeGlobal + cudaStreamCaptureModeThreadLocal + cudaStreamCaptureModeRelaxed + +cdef extern from 'driver_types.h': + cdef enum cudaSynchronizationPolicy: + cudaSyncPolicyAuto + cudaSyncPolicySpin + cudaSyncPolicyYield + cudaSyncPolicyBlockingSync + +cdef extern from 'driver_types.h': + cdef enum cudaClusterSchedulingPolicy: + cudaClusterSchedulingPolicyDefault + cudaClusterSchedulingPolicySpread + cudaClusterSchedulingPolicyLoadBalancing + +cdef extern from 'driver_types.h': + cdef enum cudaStreamUpdateCaptureDependenciesFlags: + cudaStreamAddCaptureDependencies + cudaStreamSetCaptureDependencies + +cdef extern from 'driver_types.h': + cdef enum cudaUserObjectFlags: + cudaUserObjectNoDestructorSync + +cdef extern from 'driver_types.h': + cdef enum cudaUserObjectRetainFlags: + cudaGraphUserObjectMove + +cdef extern from 'driver_types.h': + cdef enum cudaGraphicsRegisterFlags: + cudaGraphicsRegisterFlagsNone + cudaGraphicsRegisterFlagsReadOnly + cudaGraphicsRegisterFlagsWriteDiscard + cudaGraphicsRegisterFlagsSurfaceLoadStore + cudaGraphicsRegisterFlagsTextureGather + +cdef extern from 'driver_types.h': + cdef enum cudaGraphicsMapFlags: + cudaGraphicsMapFlagsNone + cudaGraphicsMapFlagsReadOnly + cudaGraphicsMapFlagsWriteDiscard + +cdef extern from 'driver_types.h': + cdef enum cudaGraphicsCubeFace: + cudaGraphicsCubeFacePositiveX + cudaGraphicsCubeFaceNegativeX + cudaGraphicsCubeFacePositiveY + cudaGraphicsCubeFaceNegativeY + cudaGraphicsCubeFacePositiveZ + cudaGraphicsCubeFaceNegativeZ + +cdef extern from 'driver_types.h': + cdef enum cudaResourceType: + cudaResourceTypeArray + cudaResourceTypeMipmappedArray + cudaResourceTypeLinear + cudaResourceTypePitch2D + +cdef extern from 'driver_types.h': + cdef enum cudaResourceViewFormat: + cudaResViewFormatNone + cudaResViewFormatUnsignedChar1 + cudaResViewFormatUnsignedChar2 + cudaResViewFormatUnsignedChar4 + cudaResViewFormatSignedChar1 + cudaResViewFormatSignedChar2 + cudaResViewFormatSignedChar4 + cudaResViewFormatUnsignedShort1 + cudaResViewFormatUnsignedShort2 + cudaResViewFormatUnsignedShort4 + cudaResViewFormatSignedShort1 + cudaResViewFormatSignedShort2 + cudaResViewFormatSignedShort4 + cudaResViewFormatUnsignedInt1 + cudaResViewFormatUnsignedInt2 + cudaResViewFormatUnsignedInt4 + cudaResViewFormatSignedInt1 + cudaResViewFormatSignedInt2 + cudaResViewFormatSignedInt4 + cudaResViewFormatHalf1 + cudaResViewFormatHalf2 + cudaResViewFormatHalf4 + cudaResViewFormatFloat1 + cudaResViewFormatFloat2 + cudaResViewFormatFloat4 + cudaResViewFormatUnsignedBlockCompressed1 + cudaResViewFormatUnsignedBlockCompressed2 + cudaResViewFormatUnsignedBlockCompressed3 + cudaResViewFormatUnsignedBlockCompressed4 + cudaResViewFormatSignedBlockCompressed4 + cudaResViewFormatUnsignedBlockCompressed5 + cudaResViewFormatSignedBlockCompressed5 + cudaResViewFormatUnsignedBlockCompressed6H + cudaResViewFormatSignedBlockCompressed6H + cudaResViewFormatUnsignedBlockCompressed7 + +cdef extern from 'driver_types.h': + cdef enum cudaFuncAttribute: + cudaFuncAttributeMaxDynamicSharedMemorySize + cudaFuncAttributePreferredSharedMemoryCarveout + cudaFuncAttributeClusterDimMustBeSet + cudaFuncAttributeRequiredClusterWidth + cudaFuncAttributeRequiredClusterHeight + cudaFuncAttributeRequiredClusterDepth + cudaFuncAttributeNonPortableClusterSizeAllowed + cudaFuncAttributeClusterSchedulingPolicyPreference + cudaFuncAttributeMax + +cdef extern from 'driver_types.h': + cdef enum cudaFuncCache: + cudaFuncCachePreferNone + cudaFuncCachePreferShared + cudaFuncCachePreferL1 + cudaFuncCachePreferEqual + +cdef extern from 'driver_types.h': + cdef enum cudaSharedMemConfig: + cudaSharedMemBankSizeDefault + cudaSharedMemBankSizeFourByte + cudaSharedMemBankSizeEightByte + +cdef extern from 'driver_types.h': + cdef enum cudaSharedCarveout: + cudaSharedmemCarveoutDefault + cudaSharedmemCarveoutMaxShared + cudaSharedmemCarveoutMaxL1 + +cdef extern from 'driver_types.h': + cdef enum cudaComputeMode: + cudaComputeModeDefault + cudaComputeModeExclusive + cudaComputeModeProhibited + cudaComputeModeExclusiveProcess + +cdef extern from 'driver_types.h': + cdef enum cudaLimit: + cudaLimitStackSize + cudaLimitPrintfFifoSize + cudaLimitMallocHeapSize + cudaLimitDevRuntimeSyncDepth + cudaLimitDevRuntimePendingLaunchCount + cudaLimitMaxL2FetchGranularity + cudaLimitPersistingL2CacheSize + +cdef extern from 'driver_types.h': + cdef enum cudaMemoryAdvise: + cudaMemAdviseSetReadMostly + cudaMemAdviseUnsetReadMostly + cudaMemAdviseSetPreferredLocation + cudaMemAdviseUnsetPreferredLocation + cudaMemAdviseSetAccessedBy + cudaMemAdviseUnsetAccessedBy + +cdef extern from 'driver_types.h': + cdef enum cudaMemRangeAttribute: + cudaMemRangeAttributeReadMostly + cudaMemRangeAttributePreferredLocation + cudaMemRangeAttributeAccessedBy + cudaMemRangeAttributeLastPrefetchLocation + cudaMemRangeAttributePreferredLocationType + cudaMemRangeAttributePreferredLocationId + cudaMemRangeAttributeLastPrefetchLocationType + cudaMemRangeAttributeLastPrefetchLocationId + +cdef extern from 'driver_types.h': + cdef enum cudaFlushGPUDirectRDMAWritesOptions: + cudaFlushGPUDirectRDMAWritesOptionHost + cudaFlushGPUDirectRDMAWritesOptionMemOps + +cdef extern from 'driver_types.h': + cdef enum cudaGPUDirectRDMAWritesOrdering: + cudaGPUDirectRDMAWritesOrderingNone + cudaGPUDirectRDMAWritesOrderingOwner + cudaGPUDirectRDMAWritesOrderingAllDevices + +cdef extern from 'driver_types.h': + cdef enum cudaFlushGPUDirectRDMAWritesScope: + cudaFlushGPUDirectRDMAWritesToOwner + cudaFlushGPUDirectRDMAWritesToAllDevices + +cdef extern from 'driver_types.h': + cdef enum cudaFlushGPUDirectRDMAWritesTarget: + cudaFlushGPUDirectRDMAWritesTargetCurrentDevice + +cdef extern from 'driver_types.h': + cdef enum cudaDeviceAttr: + cudaDevAttrMaxThreadsPerBlock + cudaDevAttrMaxBlockDimX + cudaDevAttrMaxBlockDimY + cudaDevAttrMaxBlockDimZ + cudaDevAttrMaxGridDimX + cudaDevAttrMaxGridDimY + cudaDevAttrMaxGridDimZ + cudaDevAttrMaxSharedMemoryPerBlock + cudaDevAttrTotalConstantMemory + cudaDevAttrWarpSize + cudaDevAttrMaxPitch + cudaDevAttrMaxRegistersPerBlock + cudaDevAttrClockRate + cudaDevAttrTextureAlignment + cudaDevAttrGpuOverlap + cudaDevAttrMultiProcessorCount + cudaDevAttrKernelExecTimeout + cudaDevAttrIntegrated + cudaDevAttrCanMapHostMemory + cudaDevAttrComputeMode + cudaDevAttrMaxTexture1DWidth + cudaDevAttrMaxTexture2DWidth + cudaDevAttrMaxTexture2DHeight + cudaDevAttrMaxTexture3DWidth + cudaDevAttrMaxTexture3DHeight + cudaDevAttrMaxTexture3DDepth + cudaDevAttrMaxTexture2DLayeredWidth + cudaDevAttrMaxTexture2DLayeredHeight + cudaDevAttrMaxTexture2DLayeredLayers + cudaDevAttrSurfaceAlignment + cudaDevAttrConcurrentKernels + cudaDevAttrEccEnabled + cudaDevAttrPciBusId + cudaDevAttrPciDeviceId + cudaDevAttrTccDriver + cudaDevAttrMemoryClockRate + cudaDevAttrGlobalMemoryBusWidth + cudaDevAttrL2CacheSize + cudaDevAttrMaxThreadsPerMultiProcessor + cudaDevAttrAsyncEngineCount + cudaDevAttrUnifiedAddressing + cudaDevAttrMaxTexture1DLayeredWidth + cudaDevAttrMaxTexture1DLayeredLayers + cudaDevAttrMaxTexture2DGatherWidth + cudaDevAttrMaxTexture2DGatherHeight + cudaDevAttrMaxTexture3DWidthAlt + cudaDevAttrMaxTexture3DHeightAlt + cudaDevAttrMaxTexture3DDepthAlt + cudaDevAttrPciDomainId + cudaDevAttrTexturePitchAlignment + cudaDevAttrMaxTextureCubemapWidth + cudaDevAttrMaxTextureCubemapLayeredWidth + cudaDevAttrMaxTextureCubemapLayeredLayers + cudaDevAttrMaxSurface1DWidth + cudaDevAttrMaxSurface2DWidth + cudaDevAttrMaxSurface2DHeight + cudaDevAttrMaxSurface3DWidth + cudaDevAttrMaxSurface3DHeight + cudaDevAttrMaxSurface3DDepth + cudaDevAttrMaxSurface1DLayeredWidth + cudaDevAttrMaxSurface1DLayeredLayers + cudaDevAttrMaxSurface2DLayeredWidth + cudaDevAttrMaxSurface2DLayeredHeight + cudaDevAttrMaxSurface2DLayeredLayers + cudaDevAttrMaxSurfaceCubemapWidth + cudaDevAttrMaxSurfaceCubemapLayeredWidth + cudaDevAttrMaxSurfaceCubemapLayeredLayers + cudaDevAttrMaxTexture1DLinearWidth + cudaDevAttrMaxTexture2DLinearWidth + cudaDevAttrMaxTexture2DLinearHeight + cudaDevAttrMaxTexture2DLinearPitch + cudaDevAttrMaxTexture2DMipmappedWidth + cudaDevAttrMaxTexture2DMipmappedHeight + cudaDevAttrComputeCapabilityMajor + cudaDevAttrComputeCapabilityMinor + cudaDevAttrMaxTexture1DMipmappedWidth + cudaDevAttrStreamPrioritiesSupported + cudaDevAttrGlobalL1CacheSupported + cudaDevAttrLocalL1CacheSupported + cudaDevAttrMaxSharedMemoryPerMultiprocessor + cudaDevAttrMaxRegistersPerMultiprocessor + cudaDevAttrManagedMemory + cudaDevAttrIsMultiGpuBoard + cudaDevAttrMultiGpuBoardGroupID + cudaDevAttrHostNativeAtomicSupported + cudaDevAttrSingleToDoublePrecisionPerfRatio + cudaDevAttrPageableMemoryAccess + cudaDevAttrConcurrentManagedAccess + cudaDevAttrComputePreemptionSupported + cudaDevAttrCanUseHostPointerForRegisteredMem + cudaDevAttrReserved92 + cudaDevAttrReserved93 + cudaDevAttrReserved94 + cudaDevAttrCooperativeLaunch + cudaDevAttrReserved96 + cudaDevAttrMaxSharedMemoryPerBlockOptin + cudaDevAttrCanFlushRemoteWrites + cudaDevAttrHostRegisterSupported + cudaDevAttrPageableMemoryAccessUsesHostPageTables + cudaDevAttrDirectManagedMemAccessFromHost + cudaDevAttrMaxBlocksPerMultiprocessor + cudaDevAttrMaxPersistingL2CacheSize + cudaDevAttrMaxAccessPolicyWindowSize + cudaDevAttrReservedSharedMemoryPerBlock + cudaDevAttrSparseCudaArraySupported + cudaDevAttrHostRegisterReadOnlySupported + cudaDevAttrTimelineSemaphoreInteropSupported + cudaDevAttrMemoryPoolsSupported + cudaDevAttrGPUDirectRDMASupported + cudaDevAttrGPUDirectRDMAFlushWritesOptions + cudaDevAttrGPUDirectRDMAWritesOrdering + cudaDevAttrMemoryPoolSupportedHandleTypes + cudaDevAttrClusterLaunch + cudaDevAttrDeferredMappingCudaArraySupported + cudaDevAttrReserved122 + cudaDevAttrReserved123 + cudaDevAttrReserved124 + cudaDevAttrIpcEventSupport + cudaDevAttrMemSyncDomainCount + cudaDevAttrReserved127 + cudaDevAttrReserved128 + cudaDevAttrReserved129 + cudaDevAttrNumaConfig + cudaDevAttrNumaId + cudaDevAttrReserved132 + cudaDevAttrMpsEnabled + cudaDevAttrHostNumaId + cudaDevAttrD3D12CigSupported + cudaDevAttrVulkanCigSupported + cudaDevAttrGpuPciDeviceId + cudaDevAttrGpuPciSubsystemId + cudaDevAttrReserved141 + cudaDevAttrHostNumaMemoryPoolsSupported + cudaDevAttrHostNumaMultinodeIpcSupported + cudaDevAttrHostMemoryPoolsSupported + cudaDevAttrReserved145 + cudaDevAttrOnlyPartialHostNativeAtomicSupported + cudaDevAttrAtomicReductionSupported + cudaDevAttrCigStreamsSupported + cudaDevAttrMax + cudaDevAttrCooperativeMultiDeviceLaunch + cudaDevAttrMaxTimelineSemaphoreInteropSupported + +cdef extern from 'driver_types.h': + cdef enum cudaMemPoolAttr: + cudaMemPoolReuseFollowEventDependencies + cudaMemPoolReuseAllowOpportunistic + cudaMemPoolReuseAllowInternalDependencies + cudaMemPoolAttrReleaseThreshold + cudaMemPoolAttrReservedMemCurrent + cudaMemPoolAttrReservedMemHigh + cudaMemPoolAttrUsedMemCurrent + cudaMemPoolAttrUsedMemHigh + cudaMemPoolAttrAllocationType + cudaMemPoolAttrExportHandleTypes + cudaMemPoolAttrLocationId + cudaMemPoolAttrLocationType + cudaMemPoolAttrMaxPoolSize + cudaMemPoolAttrHwDecompressEnabled + +cdef extern from 'driver_types.h': + cdef enum cudaMemLocationType: + cudaMemLocationTypeInvalid + cudaMemLocationTypeNone + cudaMemLocationTypeDevice + cudaMemLocationTypeHost + cudaMemLocationTypeHostNuma + cudaMemLocationTypeHostNumaCurrent + cudaMemLocationTypeInvisible + +cdef extern from 'driver_types.h': + cdef enum cudaMemAccessFlags: + cudaMemAccessFlagsProtNone + cudaMemAccessFlagsProtRead + cudaMemAccessFlagsProtReadWrite + +cdef extern from 'driver_types.h': + cdef enum cudaMemAllocationType: + cudaMemAllocationTypeInvalid + cudaMemAllocationTypePinned + cudaMemAllocationTypeManaged + cudaMemAllocationTypeMax + +cdef extern from 'driver_types.h': + cdef enum cudaMemAllocationHandleType: + cudaMemHandleTypeNone + cudaMemHandleTypePosixFileDescriptor + cudaMemHandleTypeWin32 + cudaMemHandleTypeWin32Kmt + cudaMemHandleTypeFabric + +cdef extern from 'driver_types.h': + cdef enum cudaGraphMemAttributeType: + cudaGraphMemAttrUsedMemCurrent + cudaGraphMemAttrUsedMemHigh + cudaGraphMemAttrReservedMemCurrent + cudaGraphMemAttrReservedMemHigh + +cdef extern from 'driver_types.h': + cdef enum cudaMemcpyFlags: + cudaMemcpyFlagDefault + cudaMemcpyFlagPreferOverlapWithCompute + +cdef extern from 'driver_types.h': + cdef enum cudaMemcpySrcAccessOrder: + cudaMemcpySrcAccessOrderInvalid + cudaMemcpySrcAccessOrderStream + cudaMemcpySrcAccessOrderDuringApiCall + cudaMemcpySrcAccessOrderAny + cudaMemcpySrcAccessOrderMax + +cdef extern from 'driver_types.h': + cdef enum cudaMemcpy3DOperandType: + cudaMemcpyOperandTypePointer + cudaMemcpyOperandTypeArray + cudaMemcpyOperandTypeMax + +cdef extern from 'driver_types.h': + cdef enum cudaDeviceP2PAttr: + cudaDevP2PAttrPerformanceRank + cudaDevP2PAttrAccessSupported + cudaDevP2PAttrNativeAtomicSupported + cudaDevP2PAttrCudaArrayAccessSupported + cudaDevP2PAttrOnlyPartialNativeAtomicSupported + +cdef extern from 'driver_types.h': + cdef enum cudaExternalMemoryHandleType: + cudaExternalMemoryHandleTypeOpaqueFd + cudaExternalMemoryHandleTypeOpaqueWin32 + cudaExternalMemoryHandleTypeOpaqueWin32Kmt + cudaExternalMemoryHandleTypeD3D12Heap + cudaExternalMemoryHandleTypeD3D12Resource + cudaExternalMemoryHandleTypeD3D11Resource + cudaExternalMemoryHandleTypeD3D11ResourceKmt + cudaExternalMemoryHandleTypeNvSciBuf + +cdef extern from 'driver_types.h': + cdef enum cudaExternalSemaphoreHandleType: + cudaExternalSemaphoreHandleTypeOpaqueFd + cudaExternalSemaphoreHandleTypeOpaqueWin32 + cudaExternalSemaphoreHandleTypeOpaqueWin32Kmt + cudaExternalSemaphoreHandleTypeD3D12Fence + cudaExternalSemaphoreHandleTypeD3D11Fence + cudaExternalSemaphoreHandleTypeNvSciSync + cudaExternalSemaphoreHandleTypeKeyedMutex + cudaExternalSemaphoreHandleTypeKeyedMutexKmt + cudaExternalSemaphoreHandleTypeTimelineSemaphoreFd + cudaExternalSemaphoreHandleTypeTimelineSemaphoreWin32 + +cdef extern from 'driver_types.h': + ctypedef cudaError cudaError_t + +cdef extern from 'driver_types.h': + cdef enum cudaJitOption: + cudaJitMaxRegisters + cudaJitThreadsPerBlock + cudaJitWallTime + cudaJitInfoLogBuffer + cudaJitInfoLogBufferSizeBytes + cudaJitErrorLogBuffer + cudaJitErrorLogBufferSizeBytes + cudaJitOptimizationLevel + cudaJitFallbackStrategy + cudaJitGenerateDebugInfo + cudaJitLogVerbose + cudaJitGenerateLineInfo + cudaJitCacheMode + cudaJitPositionIndependentCode + cudaJitMinCtaPerSm + cudaJitMaxThreadsPerBlock + cudaJitOverrideDirectiveValues + +cdef extern from 'driver_types.h': + cdef enum cudaLibraryOption: + cudaLibraryHostUniversalFunctionAndDataTable + cudaLibraryBinaryIsPreserved + +cdef extern from 'driver_types.h': + cdef enum cudaJit_CacheMode: + cudaJitCacheOptionNone + cudaJitCacheOptionCG + cudaJitCacheOptionCA + +cdef extern from 'driver_types.h': + cdef enum cudaJit_Fallback: + cudaPreferPtx + cudaPreferBinary + +cdef extern from 'driver_types.h': + cdef enum cudaCGScope: + cudaCGScopeInvalid + cudaCGScopeGrid + cudaCGScopeReserved + cudaCGScopeMultiGrid + +cdef extern from 'driver_types.h': + cdef enum cudaGraphConditionalHandleFlags: + cudaGraphCondAssignDefault + +cdef extern from 'driver_types.h': + cdef enum cudaGraphConditionalNodeType: + cudaGraphCondTypeIf + cudaGraphCondTypeWhile + cudaGraphCondTypeSwitch + +cdef extern from 'driver_types.h': + cdef enum cudaGraphNodeType: + cudaGraphNodeTypeKernel + cudaGraphNodeTypeMemcpy + cudaGraphNodeTypeMemset + cudaGraphNodeTypeHost + cudaGraphNodeTypeGraph + cudaGraphNodeTypeEmpty + cudaGraphNodeTypeWaitEvent + cudaGraphNodeTypeEventRecord + cudaGraphNodeTypeExtSemaphoreSignal + cudaGraphNodeTypeExtSemaphoreWait + cudaGraphNodeTypeMemAlloc + cudaGraphNodeTypeMemFree + cudaGraphNodeTypeConditional + cudaGraphNodeTypeReserved16 + cudaGraphNodeTypeCount + +cdef extern from 'driver_types.h': + cdef enum cudaGraphChildGraphNodeOwnership: + cudaGraphChildGraphOwnershipClone + cudaGraphChildGraphOwnershipMove + cudaGraphChildGraphOwnershipInvalid + +cdef extern from 'driver_types.h': + cdef enum cudaGraphDependencyType_enum: + cudaGraphDependencyTypeDefault + cudaGraphDependencyTypeProgrammatic + ctypedef cudaGraphDependencyType_enum cudaGraphDependencyType + +cdef extern from 'driver_types.h': + cdef enum cudaGraphExecUpdateResult: + cudaGraphExecUpdateSuccess + cudaGraphExecUpdateError + cudaGraphExecUpdateErrorTopologyChanged + cudaGraphExecUpdateErrorNodeTypeChanged + cudaGraphExecUpdateErrorFunctionChanged + cudaGraphExecUpdateErrorParametersChanged + cudaGraphExecUpdateErrorNotSupported + cudaGraphExecUpdateErrorUnsupportedFunctionChange + cudaGraphExecUpdateErrorAttributesChanged + +cdef extern from 'driver_types.h': + cdef enum cudaGraphInstantiateResult: + cudaGraphInstantiateSuccess + cudaGraphInstantiateError + cudaGraphInstantiateInvalidStructure + cudaGraphInstantiateNodeOperationNotSupported + cudaGraphInstantiateMultipleDevicesNotSupported + cudaGraphInstantiateConditionalHandleUnused + +cdef extern from 'driver_types.h': + cdef enum cudaGraphKernelNodeField: + cudaGraphKernelNodeFieldInvalid + cudaGraphKernelNodeFieldGridDim + cudaGraphKernelNodeFieldParam + cudaGraphKernelNodeFieldEnabled + +cdef extern from 'driver_types.h': + cdef enum cudaGetDriverEntryPointFlags: + cudaEnableDefault + cudaEnableLegacyStream + cudaEnablePerThreadDefaultStream + +cdef extern from 'driver_types.h': + cdef enum cudaDriverEntryPointQueryResult: + cudaDriverEntryPointSuccess + cudaDriverEntryPointSymbolNotFound + cudaDriverEntryPointVersionNotSufficent + +cdef extern from 'driver_types.h': + cdef enum cudaGraphDebugDotFlags: + cudaGraphDebugDotFlagsVerbose + cudaGraphDebugDotFlagsKernelNodeParams + cudaGraphDebugDotFlagsMemcpyNodeParams + cudaGraphDebugDotFlagsMemsetNodeParams + cudaGraphDebugDotFlagsHostNodeParams + cudaGraphDebugDotFlagsEventNodeParams + cudaGraphDebugDotFlagsExtSemasSignalNodeParams + cudaGraphDebugDotFlagsExtSemasWaitNodeParams + cudaGraphDebugDotFlagsKernelNodeAttributes + cudaGraphDebugDotFlagsHandles + cudaGraphDebugDotFlagsConditionalNodeParams + +cdef extern from 'driver_types.h': + cdef enum cudaGraphInstantiateFlags: + cudaGraphInstantiateFlagAutoFreeOnLaunch + cudaGraphInstantiateFlagUpload + cudaGraphInstantiateFlagDeviceLaunch + cudaGraphInstantiateFlagUseNodePriority + +cdef extern from 'driver_types.h': + cdef enum cudaLaunchMemSyncDomain: + cudaLaunchMemSyncDomainDefault + cudaLaunchMemSyncDomainRemote + +cdef extern from 'driver_types.h': + cdef enum cudaLaunchAttributeID: + cudaLaunchAttributeIgnore + cudaLaunchAttributeAccessPolicyWindow + cudaLaunchAttributeCooperative + cudaLaunchAttributeSynchronizationPolicy + cudaLaunchAttributeClusterDimension + cudaLaunchAttributeClusterSchedulingPolicyPreference + cudaLaunchAttributeProgrammaticStreamSerialization + cudaLaunchAttributeProgrammaticEvent + cudaLaunchAttributePriority + cudaLaunchAttributeMemSyncDomainMap + cudaLaunchAttributeMemSyncDomain + cudaLaunchAttributePreferredClusterDimension + cudaLaunchAttributeLaunchCompletionEvent + cudaLaunchAttributeDeviceUpdatableKernelNode + cudaLaunchAttributePreferredSharedMemoryCarveout + cudaLaunchAttributeNvlinkUtilCentricScheduling + cudaLaunchAttributePortableClusterSizeMode + cudaLaunchAttributeSharedMemoryMode + +cdef extern from 'driver_types.h': + cdef enum cudaDeviceNumaConfig: + cudaDeviceNumaConfigNone + cudaDeviceNumaConfigNumaNode + +cdef extern from 'driver_types.h': + cdef enum cudaAsyncNotificationType_enum: + cudaAsyncNotificationTypeOverBudget + ctypedef cudaAsyncNotificationType_enum cudaAsyncNotificationType + +cdef extern from 'device_types.h': + cdef enum cudaRoundMode: + cudaRoundNearest + cudaRoundZero + cudaRoundPosInf + cudaRoundMinInf + +cdef extern from 'surface_types.h': + cdef enum cudaSurfaceBoundaryMode: + cudaBoundaryModeZero + cudaBoundaryModeClamp + cudaBoundaryModeTrap + +cdef extern from 'surface_types.h': + cdef enum cudaSurfaceFormatMode: + cudaFormatModeForced + cudaFormatModeAuto + +cdef extern from 'texture_types.h': + cdef enum cudaTextureAddressMode: + cudaAddressModeWrap + cudaAddressModeClamp + cudaAddressModeMirror + cudaAddressModeBorder + +cdef extern from 'texture_types.h': + cdef enum cudaTextureFilterMode: + cudaFilterModePoint + cudaFilterModeLinear + +cdef extern from 'texture_types.h': + cdef enum cudaTextureReadMode: + cudaReadModeElementType + cudaReadModeNormalizedFloat + +cdef extern from 'library_types.h': + cdef enum cudaDataType_t: + CUDA_R_16F + CUDA_C_16F + CUDA_R_16BF + CUDA_C_16BF + CUDA_R_32F + CUDA_C_32F + CUDA_R_64F + CUDA_C_64F + CUDA_R_4I + CUDA_C_4I + CUDA_R_4U + CUDA_C_4U + CUDA_R_8I + CUDA_C_8I + CUDA_R_8U + CUDA_C_8U + CUDA_R_16I + CUDA_C_16I + CUDA_R_16U + CUDA_C_16U + CUDA_R_32I + CUDA_C_32I + CUDA_R_32U + CUDA_C_32U + CUDA_R_64I + CUDA_C_64I + CUDA_R_64U + CUDA_C_64U + CUDA_R_8F_E4M3 + CUDA_R_8F_UE4M3 + CUDA_R_8F_E5M2 + CUDA_R_8F_UE8M0 + CUDA_R_6F_E2M3 + CUDA_R_6F_E3M2 + CUDA_R_4F_E2M1 + ctypedef cudaDataType_t cudaDataType + +cdef enum cudaEglFrameType_enum: + cudaEglFrameTypeArray = 0 + cudaEglFrameTypePitch = 1 +ctypedef cudaEglFrameType_enum cudaEglFrameType + +cdef enum cudaEglResourceLocationFlags_enum: + cudaEglResourceLocationSysmem = 0x00 + cudaEglResourceLocationVidmem = 0x01 +ctypedef cudaEglResourceLocationFlags_enum cudaEglResourceLocationFlags + +cdef enum cudaEglColorFormat_enum: + cudaEglColorFormatYUV420Planar = 0 + cudaEglColorFormatYUV420SemiPlanar = 1 + cudaEglColorFormatYUV422Planar = 2 + cudaEglColorFormatYUV422SemiPlanar = 3 + cudaEglColorFormatARGB = 6 + cudaEglColorFormatRGBA = 7 + cudaEglColorFormatL = 8 + cudaEglColorFormatR = 9 + cudaEglColorFormatYUV444Planar = 10 + cudaEglColorFormatYUV444SemiPlanar = 11 + cudaEglColorFormatYUYV422 = 12 + cudaEglColorFormatUYVY422 = 13 + cudaEglColorFormatABGR = 14 + cudaEglColorFormatBGRA = 15 + cudaEglColorFormatA = 16 + cudaEglColorFormatRG = 17 + cudaEglColorFormatAYUV = 18 + cudaEglColorFormatYVU444SemiPlanar = 19 + cudaEglColorFormatYVU422SemiPlanar = 20 + cudaEglColorFormatYVU420SemiPlanar = 21 + cudaEglColorFormatY10V10U10_444SemiPlanar = 22 + cudaEglColorFormatY10V10U10_420SemiPlanar = 23 + cudaEglColorFormatY12V12U12_444SemiPlanar = 24 + cudaEglColorFormatY12V12U12_420SemiPlanar = 25 + cudaEglColorFormatVYUY_ER = 26 + cudaEglColorFormatUYVY_ER = 27 + cudaEglColorFormatYUYV_ER = 28 + cudaEglColorFormatYVYU_ER = 29 + cudaEglColorFormatYUVA_ER = 31 + cudaEglColorFormatAYUV_ER = 32 + cudaEglColorFormatYUV444Planar_ER = 33 + cudaEglColorFormatYUV422Planar_ER = 34 + cudaEglColorFormatYUV420Planar_ER = 35 + cudaEglColorFormatYUV444SemiPlanar_ER = 36 + cudaEglColorFormatYUV422SemiPlanar_ER = 37 + cudaEglColorFormatYUV420SemiPlanar_ER = 38 + cudaEglColorFormatYVU444Planar_ER = 39 + cudaEglColorFormatYVU422Planar_ER = 40 + cudaEglColorFormatYVU420Planar_ER = 41 + cudaEglColorFormatYVU444SemiPlanar_ER = 42 + cudaEglColorFormatYVU422SemiPlanar_ER = 43 + cudaEglColorFormatYVU420SemiPlanar_ER = 44 + cudaEglColorFormatBayerRGGB = 45 + cudaEglColorFormatBayerBGGR = 46 + cudaEglColorFormatBayerGRBG = 47 + cudaEglColorFormatBayerGBRG = 48 + cudaEglColorFormatBayer10RGGB = 49 + cudaEglColorFormatBayer10BGGR = 50 + cudaEglColorFormatBayer10GRBG = 51 + cudaEglColorFormatBayer10GBRG = 52 + cudaEglColorFormatBayer12RGGB = 53 + cudaEglColorFormatBayer12BGGR = 54 + cudaEglColorFormatBayer12GRBG = 55 + cudaEglColorFormatBayer12GBRG = 56 + cudaEglColorFormatBayer14RGGB = 57 + cudaEglColorFormatBayer14BGGR = 58 + cudaEglColorFormatBayer14GRBG = 59 + cudaEglColorFormatBayer14GBRG = 60 + cudaEglColorFormatBayer20RGGB = 61 + cudaEglColorFormatBayer20BGGR = 62 + cudaEglColorFormatBayer20GRBG = 63 + cudaEglColorFormatBayer20GBRG = 64 + cudaEglColorFormatYVU444Planar = 65 + cudaEglColorFormatYVU422Planar = 66 + cudaEglColorFormatYVU420Planar = 67 + cudaEglColorFormatBayerIspRGGB = 68 + cudaEglColorFormatBayerIspBGGR = 69 + cudaEglColorFormatBayerIspGRBG = 70 + cudaEglColorFormatBayerIspGBRG = 71 + cudaEglColorFormatBayerBCCR = 72 + cudaEglColorFormatBayerRCCB = 73 + cudaEglColorFormatBayerCRBC = 74 + cudaEglColorFormatBayerCBRC = 75 + cudaEglColorFormatBayer10CCCC = 76 + cudaEglColorFormatBayer12BCCR = 77 + cudaEglColorFormatBayer12RCCB = 78 + cudaEglColorFormatBayer12CRBC = 79 + cudaEglColorFormatBayer12CBRC = 80 + cudaEglColorFormatBayer12CCCC = 81 + cudaEglColorFormatY = 82 + cudaEglColorFormatYUV420SemiPlanar_2020 = 83 + cudaEglColorFormatYVU420SemiPlanar_2020 = 84 + cudaEglColorFormatYUV420Planar_2020 = 85 + cudaEglColorFormatYVU420Planar_2020 = 86 + cudaEglColorFormatYUV420SemiPlanar_709 = 87 + cudaEglColorFormatYVU420SemiPlanar_709 = 88 + cudaEglColorFormatYUV420Planar_709 = 89 + cudaEglColorFormatYVU420Planar_709 = 90 + cudaEglColorFormatY10V10U10_420SemiPlanar_709 = 91 + cudaEglColorFormatY10V10U10_420SemiPlanar_2020 = 92 + cudaEglColorFormatY10V10U10_422SemiPlanar_2020 = 93 + cudaEglColorFormatY10V10U10_422SemiPlanar = 94 + cudaEglColorFormatY10V10U10_422SemiPlanar_709 = 95 + cudaEglColorFormatY_ER = 96 + cudaEglColorFormatY_709_ER = 97 + cudaEglColorFormatY10_ER = 98 + cudaEglColorFormatY10_709_ER = 99 + cudaEglColorFormatY12_ER = 100 + cudaEglColorFormatY12_709_ER = 101 + cudaEglColorFormatYUVA = 102 + cudaEglColorFormatYVYU = 104 + cudaEglColorFormatVYUY = 105 + cudaEglColorFormatY10V10U10_420SemiPlanar_ER = 106 + cudaEglColorFormatY10V10U10_420SemiPlanar_709_ER = 107 + cudaEglColorFormatY10V10U10_444SemiPlanar_ER = 108 + cudaEglColorFormatY10V10U10_444SemiPlanar_709_ER = 109 + cudaEglColorFormatY12V12U12_420SemiPlanar_ER = 110 + cudaEglColorFormatY12V12U12_420SemiPlanar_709_ER = 111 + cudaEglColorFormatY12V12U12_444SemiPlanar_ER = 112 + cudaEglColorFormatY12V12U12_444SemiPlanar_709_ER = 113 + cudaEglColorFormatUYVY709 = 114 + cudaEglColorFormatUYVY709_ER = 115 + cudaEglColorFormatUYVY2020 = 116 +ctypedef cudaEglColorFormat_enum cudaEglColorFormat + +cdef enum cudaGLDeviceList: + cudaGLDeviceListAll = 1 + cudaGLDeviceListCurrentFrame = 2 + cudaGLDeviceListNextFrame = 3 + +cdef enum cudaGLMapFlags: + cudaGLMapFlagsNone = 0 + cudaGLMapFlagsReadOnly = 1 + cudaGLMapFlagsWriteDiscard = 2 + +cdef extern from 'driver_types.h': + cdef enum cudaAtomicOperation: + cudaAtomicOperationIntegerAdd + cudaAtomicOperationIntegerMin + cudaAtomicOperationIntegerMax + cudaAtomicOperationIntegerIncrement + cudaAtomicOperationIntegerDecrement + cudaAtomicOperationAnd + cudaAtomicOperationOr + cudaAtomicOperationXOR + cudaAtomicOperationExchange + cudaAtomicOperationCAS + cudaAtomicOperationFloatAdd + cudaAtomicOperationFloatMin + cudaAtomicOperationFloatMax + +cdef extern from 'driver_types.h': + cdef enum cudaAtomicOperationCapability: + cudaAtomicCapabilitySigned + cudaAtomicCapabilityUnsigned + cudaAtomicCapabilityReduction + cudaAtomicCapabilityScalar32 + cudaAtomicCapabilityScalar64 + cudaAtomicCapabilityScalar128 + cudaAtomicCapabilityVector32x4 + +cdef extern from 'driver_types.h': + cdef enum CUDAlogLevel_enum: + cudaLogLevelError + cudaLogLevelWarning + ctypedef CUDAlogLevel_enum cudaLogLevel + +cdef extern from 'library_types.h': + cdef enum cudaEmulationStrategy_t: + CUDA_EMULATION_STRATEGY_DEFAULT + CUDA_EMULATION_STRATEGY_PERFORMANT + CUDA_EMULATION_STRATEGY_EAGER + ctypedef cudaEmulationStrategy_t cudaEmulationStrategy + +cdef extern from 'driver_types.h': + cdef enum cudaDevSmResourceGroup_flags: + cudaDevSmResourceGroupDefault + cudaDevSmResourceGroupBackfill + +cdef extern from 'driver_types.h': + cdef enum cudaDevSmResourceSplitByCount_flags: + cudaDevSmResourceSplitIgnoreSmCoscheduling + cudaDevSmResourceSplitMaxPotentialClusterSize + +cdef extern from 'driver_types.h': + cdef enum cudaDevResourceType: + cudaDevResourceTypeInvalid + cudaDevResourceTypeSm + cudaDevResourceTypeWorkqueueConfig + cudaDevResourceTypeWorkqueue + +cdef extern from 'driver_types.h': + cdef enum cudaDevWorkqueueConfigScope: + cudaDevWorkqueueConfigScopeDeviceCtx + cudaDevWorkqueueConfigScopeGreenCtxBalanced + +cdef extern from 'library_types.h': + cdef enum cudaEmulationMantissaControl_t: + CUDA_EMULATION_MANTISSA_CONTROL_DYNAMIC + CUDA_EMULATION_MANTISSA_CONTROL_FIXED + ctypedef cudaEmulationMantissaControl_t cudaEmulationMantissaControl + +cdef extern from 'library_types.h': + cdef enum cudaEmulationSpecialValuesSupport_t: + CUDA_EMULATION_SPECIAL_VALUES_SUPPORT_DEFAULT + CUDA_EMULATION_SPECIAL_VALUES_SUPPORT_NONE + CUDA_EMULATION_SPECIAL_VALUES_SUPPORT_INFINITY + CUDA_EMULATION_SPECIAL_VALUES_SUPPORT_NAN + ctypedef cudaEmulationSpecialValuesSupport_t cudaEmulationSpecialValuesSupport + +cdef extern from 'driver_types.h': + cdef enum cudaHostTaskSyncMode: + cudaHostTaskBlocking + cudaHostTaskSpinWait + +cdef extern from 'driver_types.h': + cdef enum cudaKernelFunctionType: + cudaKernelFunctionTypeUnspecified + cudaKernelFunctionTypeDeviceEntry + cudaKernelFunctionTypeKernel + cudaKernelFunctionTypeFunction + +cdef extern from 'driver_types.h': + cdef enum cudaLaunchAttributePortableClusterMode: + cudaLaunchPortableClusterModeDefault + cudaLaunchPortableClusterModeRequirePortable + cudaLaunchPortableClusterModeAllowNonPortable + +cdef extern from 'driver_types.h': + cdef enum cudaSharedMemoryMode: + cudaSharedMemoryModeDefault + cudaSharedMemoryModeRequirePortable + cudaSharedMemoryModeAllowNonPortable + +cdef extern from 'driver_types.h': + cdef enum cudaGraphRecaptureStatus: + cudaGraphRecaptureEligibleForUpdate + cudaGraphRecaptureIneligibleForUpdate + cudaGraphRecaptureError + +cdef extern from 'driver_types.h': + cdef enum cudaFabricOpStatusSource: + cudaFabricOpStatusSourceMbarrierV1 + cudaFabricOpStatusSourceMax + +cdef extern from 'driver_types.h': + cdef enum cudaFabricOpStatusInfo: + cudaFabricOpStatusInfoSuccess + cudaFabricOpStatusInfoLast + cudaFabricOpStatusInfoMax +cdef enum: _CUDAERROR_T_INTERNAL_LOADING_ERROR = cudaError_t.cudaErrorCallRequiresNewerDriver + + +# TYPES +cdef extern from 'driver_types.h': + ctypedef unsigned long long cudaGraphConditionalHandle 'cudaGraphConditionalHandle' + + +cdef extern from 'surface_types.h': + ctypedef unsigned long long cudaSurfaceObject_t 'cudaSurfaceObject_t' + + +cdef extern from 'texture_types.h': + ctypedef unsigned long long cudaTextureObject_t 'cudaTextureObject_t' + + +cdef extern from 'driver_types.h': + ctypedef unsigned int cudaLogIterator 'cudaLogIterator' + + +cdef extern from 'driver_types.h': + ctypedef struct cudaArray: + pass + ctypedef cudaArray* cudaArray_t 'cudaArray_t' + + +cdef extern from 'driver_types.h': + ctypedef struct cudaArray: + pass + ctypedef cudaArray* cudaArray_const_t 'cudaArray_const_t' + + +cdef extern from 'driver_types.h': + ctypedef struct cudaMipmappedArray: + pass + ctypedef cudaMipmappedArray* cudaMipmappedArray_t 'cudaMipmappedArray_t' + + +cdef extern from 'driver_types.h': + ctypedef struct cudaMipmappedArray: + pass + ctypedef cudaMipmappedArray* cudaMipmappedArray_const_t 'cudaMipmappedArray_const_t' + + +cdef extern from 'driver_types.h': + ctypedef struct cudaAsyncCallbackEntry: + pass + ctypedef cudaAsyncCallbackEntry* cudaAsyncCallbackHandle_t 'cudaAsyncCallbackHandle_t' + + +cdef extern from 'driver_types.h': + cdef struct cudaChannelFormatDesc: + int x + int y + int z + int w + cudaChannelFormatKind f + +cdef struct cuda_bindings_runtime__anon_pod0: + unsigned int width + unsigned int height + unsigned int depth + +cdef extern from 'driver_types.h': + cdef struct cudaArrayMemoryRequirements: + size_t size + size_t alignment + unsigned int reserved[4] + +cdef extern from 'driver_types.h': + cdef struct cudaPitchedPtr: + void* ptr + size_t pitch + size_t xsize + size_t ysize + +cdef extern from 'driver_types.h': + cdef struct cudaExtent: + size_t width + size_t height + size_t depth + +cdef extern from 'driver_types.h': + cdef struct cudaPos: + size_t x + size_t y + size_t z + +cdef extern from 'driver_types.h': + cdef struct cudaMemsetParams: + void* dst + size_t pitch + unsigned int value + unsigned int elementSize + size_t width + size_t height + +cdef extern from 'driver_types.h': + cdef struct cudaAccessPolicyWindow: + void* base_ptr + size_t num_bytes + float hitRatio + cudaAccessProperty hitProp + cudaAccessProperty missProp + +cdef extern from 'driver_types.h': + ctypedef void (*cudaHostFn_t 'cudaHostFn_t')( + void* userData + ) + + +cdef struct cuda_bindings_runtime__anon_pod6: + int reserved[32] + +cdef extern from 'driver_types.h': + cdef struct cudaResourceViewDesc: + cudaResourceViewFormat format + size_t width + size_t height + size_t depth + unsigned int firstMipmapLevel + unsigned int lastMipmapLevel + unsigned int firstLayer + unsigned int lastLayer + unsigned int reserved[16] + +cdef extern from 'driver_types.h': + cdef struct cudaPointerAttributes: + cudaMemoryType type + int device + void* devicePointer + void* hostPointer + long reserved[8] + +cdef extern from 'driver_types.h': + cdef struct cudaFuncAttributes: + size_t sharedSizeBytes + size_t constSizeBytes + size_t localSizeBytes + int maxThreadsPerBlock + int numRegs + int ptxVersion + int binaryVersion + int cacheModeCA + int maxDynamicSharedSizeBytes + int preferredShmemCarveout + int clusterDimMustBeSet + int requiredClusterWidth + int requiredClusterHeight + int requiredClusterDepth + int clusterSchedulingPolicyPreference + int nonPortableClusterSizeAllowed + int deviceNodeUpdateStatus + int reserved1 + int reserved[14] + +cdef extern from 'driver_types.h': + cdef struct cudaMemPoolPtrExportData: + unsigned char reserved[64] + +cdef extern from 'driver_types.h': + cdef struct cudaMemFreeNodeParams: + void* dptr + +cdef extern from 'driver_types.h': + cdef struct cudaOffset3D: + size_t x + size_t y + size_t z + +cdef extern from 'driver_types.h': + cdef struct cudaDeviceProp: + char name[256] + cudaUUID_t uuid + char luid[8] + unsigned int luidDeviceNodeMask + size_t totalGlobalMem + size_t sharedMemPerBlock + int regsPerBlock + int warpSize + size_t memPitch + int maxThreadsPerBlock + int maxThreadsDim[3] + int maxGridSize[3] + size_t totalConstMem + int major + int minor + size_t textureAlignment + size_t texturePitchAlignment + int multiProcessorCount + int integrated + int canMapHostMemory + int maxTexture1D + int maxTexture1DMipmap + int maxTexture2D[2] + int maxTexture2DMipmap[2] + int maxTexture2DLinear[3] + int maxTexture2DGather[2] + int maxTexture3D[3] + int maxTexture3DAlt[3] + int maxTextureCubemap + int maxTexture1DLayered[2] + int maxTexture2DLayered[3] + int maxTextureCubemapLayered[2] + int maxSurface1D + int maxSurface2D[2] + int maxSurface3D[3] + int maxSurface1DLayered[2] + int maxSurface2DLayered[3] + int maxSurfaceCubemap + int maxSurfaceCubemapLayered[2] + size_t surfaceAlignment + int concurrentKernels + int ECCEnabled + int pciBusID + int pciDeviceID + int pciDomainID + int tccDriver + int asyncEngineCount + int unifiedAddressing + int memoryBusWidth + int l2CacheSize + int persistingL2CacheMaxSize + int maxThreadsPerMultiProcessor + int streamPrioritiesSupported + int globalL1CacheSupported + int localL1CacheSupported + size_t sharedMemPerMultiprocessor + int regsPerMultiprocessor + int managedMemory + int isMultiGpuBoard + int multiGpuBoardGroupID + int hostNativeAtomicSupported + int pageableMemoryAccess + int concurrentManagedAccess + int computePreemptionSupported + int canUseHostPointerForRegisteredMem + int cooperativeLaunch + size_t sharedMemPerBlockOptin + int pageableMemoryAccessUsesHostPageTables + int directManagedMemAccessFromHost + int maxBlocksPerMultiProcessor + int accessPolicyMaxWindowSize + size_t reservedSharedMemPerBlock + int hostRegisterSupported + int sparseCudaArraySupported + int hostRegisterReadOnlySupported + int timelineSemaphoreInteropSupported + int memoryPoolsSupported + int gpuDirectRDMASupported + unsigned int gpuDirectRDMAFlushWritesOptions + int gpuDirectRDMAWritesOrdering + unsigned int memoryPoolSupportedHandleTypes + int deferredMappingCudaArraySupported + int ipcEventSupported + int clusterLaunch + int unifiedFunctionPointers + int deviceNumaConfig + int deviceNumaId + int mpsEnabled + int hostNumaId + unsigned int gpuPciDeviceID + unsigned int gpuPciSubsystemID + int hostNumaMultinodeIpcSupported + int reserved[56] + +cdef extern from 'driver_types.h': + cdef struct cudaIpcEventHandle_st: + char reserved[64] + ctypedef cudaIpcEventHandle_st cudaIpcEventHandle_t + +cdef extern from 'driver_types.h': + cdef struct cudaIpcMemHandle_st: + char reserved[64] + ctypedef cudaIpcMemHandle_st cudaIpcMemHandle_t + +cdef extern from 'driver_types.h': + cdef struct cudaMemFabricHandle_st: + char reserved[64] + ctypedef cudaMemFabricHandle_st cudaMemFabricHandle_t + +cdef struct cuda_bindings_runtime__anon_pod12: + void* handle + void* name + +cdef extern from 'driver_types.h': + cdef struct cudaExternalMemoryBufferDesc: + unsigned long long offset + unsigned long long size + unsigned int flags + unsigned int reserved[16] + +cdef struct cuda_bindings_runtime__anon_pod14: + void* handle + void* name + +cdef struct cuda_bindings_runtime__anon_pod16: + unsigned long long value + +cdef union cuda_bindings_runtime__anon_pod17: + void* fence + unsigned long long reserved + +cdef struct cuda_bindings_runtime__anon_pod18: + unsigned long long key + +cdef struct cuda_bindings_runtime__anon_pod20: + unsigned long long value + +cdef union cuda_bindings_runtime__anon_pod21: + void* fence + unsigned long long reserved + +cdef struct cuda_bindings_runtime__anon_pod22: + unsigned long long key + unsigned int timeoutMs + +cdef extern from 'driver_types.h': + cdef struct cudaKernelNodeParams: + void* func + dim3 gridDim + dim3 blockDim + unsigned int sharedMemBytes + void** kernelParams + void** extra + +cdef extern from 'driver_types.h': + cdef struct cudaGraphEdgeData_st: + unsigned char from_port + unsigned char to_port + unsigned char type + unsigned char reserved[5] + ctypedef cudaGraphEdgeData_st cudaGraphEdgeData + +cdef struct cuda_bindings_runtime__anon_pod26: + void* pValue + size_t offset + size_t size + +cdef extern from 'driver_types.h': + cdef struct cudaLaunchMemSyncDomainMap_st: + unsigned char default_ + unsigned char remote + ctypedef cudaLaunchMemSyncDomainMap_st cudaLaunchMemSyncDomainMap + +cdef struct cuda_bindings_runtime__anon_pod27: + unsigned int x + unsigned int y + unsigned int z + +cdef struct cuda_bindings_runtime__anon_pod29: + unsigned int x + unsigned int y + unsigned int z + +cdef struct cuda_bindings_runtime__anon_pod33: + unsigned long long bytesOverBudget + +cdef extern from '': + cdef struct cudaTextureDesc: + cudaTextureAddressMode addressMode[3] + cudaTextureFilterMode filterMode + cudaTextureReadMode readMode + int sRGB + float borderColor[4] + int normalizedCoords + unsigned int maxAnisotropy + cudaTextureFilterMode mipmapFilterMode + float mipmapLevelBias + float minMipmapLevelClamp + float maxMipmapLevelClamp + int disableTrilinearOptimization + int seamlessCubemap + +cdef extern from 'driver_types.h': + cdef struct cudaDevSmResource: + unsigned int smCount + unsigned int minSmPartitionSize + unsigned int smCoscheduledAlignment + unsigned int flags + +cdef extern from 'driver_types.h': + cdef struct cudaDevWorkqueueConfigResource: + int device + unsigned int wqConcurrencyLimit + cudaDevWorkqueueConfigScope sharingScope + +cdef extern from 'driver_types.h': + cdef struct cudaDevWorkqueueResource: + unsigned char reserved[40] + +cdef extern from 'driver_types.h': + cdef struct cudaDevSmResourceGroupParams_st: + unsigned int smCount + unsigned int coscheduledSmCount + unsigned int preferredCoscheduledSmCount + unsigned int flags + unsigned int reserved[12] + ctypedef cudaDevSmResourceGroupParams_st cudaDevSmResourceGroupParams + +cdef extern from 'cuda_runtime_api.h': + ctypedef void (*cudaLogsCallback_t 'cudaLogsCallback_t')( + void* data, + cudaLogLevel logLevel, + char* message, + size_t length + ) + + +cdef struct cuda_bindings_runtime__anon_pod2: + cudaArray_t array + +cdef struct cuda_bindings_runtime__anon_pod3: + cudaMipmappedArray_t mipmap + +cdef extern from 'cuda_runtime_api.h': + ctypedef void (*cudaStreamCallback_t 'cudaStreamCallback_t')( + cudaStream_t stream, + cudaError_t status, + void* userData + ) + + +cdef extern from 'driver_types.h': + cdef struct cudaEventRecordNodeParams: + cudaEvent_t event + +cdef extern from 'driver_types.h': + cdef struct cudaEventWaitNodeParams: + cudaEvent_t event + +cdef struct cuda_bindings_runtime__anon_pod28: + cudaEvent_t event + int flags + int triggerAtBlockStart + +cdef struct cuda_bindings_runtime__anon_pod30: + cudaEvent_t event + int flags + +cdef extern from 'driver_types.h': + cdef struct cudaChildGraphNodeParams: + cudaGraph_t graph + cudaGraphChildGraphNodeOwnership ownership + +cdef extern from 'driver_types.h': + cdef struct cudaGraphInstantiateParams_st: + unsigned long long flags + cudaStream_t uploadStream + cudaGraphNode_t errNode_out + cudaGraphInstantiateResult result_out + ctypedef cudaGraphInstantiateParams_st cudaGraphInstantiateParams + +cdef extern from 'driver_types.h': + cdef struct cudaGraphExecUpdateResultInfo_st: + cudaGraphExecUpdateResult result + cudaGraphNode_t errorNode + cudaGraphNode_t errorFromNode + ctypedef cudaGraphExecUpdateResultInfo_st cudaGraphExecUpdateResultInfo + +cdef struct cuda_bindings_runtime__anon_pod31: + int deviceUpdatable + cudaGraphDeviceNode_t devNode + +cdef extern from 'driver_types.h': + cdef struct cudaMemsetParamsV2: + void* dst + size_t pitch + unsigned int value + unsigned int elementSize + size_t width + size_t height + cudaExecutionContext_t ctx + +cdef extern from 'driver_types.h': + cdef struct cudaConditionalNodeParams: + cudaGraphConditionalHandle handle + cudaGraphConditionalNodeType type + unsigned int size + cudaGraph_t* phGraph_out + cudaExecutionContext_t ctx + +cdef struct cuda_bindings_runtime__anon_pod4: + void* devPtr + cudaChannelFormatDesc desc + size_t sizeInBytes + +cdef struct cuda_bindings_runtime__anon_pod5: + void* devPtr + cudaChannelFormatDesc desc + size_t width + size_t height + size_t pitchInBytes + +cdef struct cudaEglPlaneDesc_st: + unsigned int width + unsigned int height + unsigned int depth + unsigned int pitch + unsigned int numChannels + cudaChannelFormatDesc channelDesc + unsigned int reserved[4] +ctypedef cudaEglPlaneDesc_st cudaEglPlaneDesc + +cdef extern from 'driver_types.h': + cdef struct cudaArraySparseProperties: + cuda_bindings_runtime__anon_pod0 tileExtent + unsigned int miptailFirstLevel + unsigned long long miptailSize + unsigned int flags + unsigned int reserved[4] + +cdef union cuda_bindings_runtime__anon_pod34: + cudaArray_t pArray[3] + cudaPitchedPtr pPitch[3] + +cdef extern from 'driver_types.h': + cdef struct cudaExternalMemoryMipmappedArrayDesc: + unsigned long long offset + cudaChannelFormatDesc formatDesc + cudaExtent extent + unsigned int flags + unsigned int numLevels + unsigned int reserved[16] + +cdef extern from 'driver_types.h': + cdef struct cudaMemcpy3DParms: + cudaArray_t srcArray + cudaPos srcPos + cudaPitchedPtr srcPtr + cudaArray_t dstArray + cudaPos dstPos + cudaPitchedPtr dstPtr + cudaExtent extent + cudaMemcpyKind kind + +cdef extern from 'driver_types.h': + cdef struct cudaMemcpy3DPeerParms: + cudaArray_t srcArray + cudaPos srcPos + cudaPitchedPtr srcPtr + int srcDevice + cudaArray_t dstArray + cudaPos dstPos + cudaPitchedPtr dstPtr + int dstDevice + cudaExtent extent + +cdef extern from 'driver_types.h': + cdef struct cudaHostNodeParams: + cudaHostFn_t fn + void* userData + +cdef extern from 'driver_types.h': + cdef struct cudaHostNodeParamsV2: + cudaHostFn_t fn + void* userData + unsigned int syncMode + +cdef extern from 'driver_types.h': + cdef struct cudaMemLocation: + cudaMemLocationType type + int id + +cdef struct cuda_bindings_runtime__anon_pod10: + cudaArray_t array + cudaOffset3D offset + +cdef union cuda_bindings_runtime__anon_pod11: + int fd + cuda_bindings_runtime__anon_pod12 win32 + void* nvSciBufObject + +cdef union cuda_bindings_runtime__anon_pod13: + int fd + cuda_bindings_runtime__anon_pod14 win32 + void* nvSciSyncObj + +cdef struct cuda_bindings_runtime__anon_pod15: + cuda_bindings_runtime__anon_pod16 fence + cuda_bindings_runtime__anon_pod17 nvSciSync + cuda_bindings_runtime__anon_pod18 keyedMutex + unsigned int reserved[12] + +cdef struct cuda_bindings_runtime__anon_pod19: + cuda_bindings_runtime__anon_pod20 fence + cuda_bindings_runtime__anon_pod21 nvSciSync + cuda_bindings_runtime__anon_pod22 keyedMutex + unsigned int reserved[10] + +cdef union cuda_bindings_runtime__anon_pod25: + dim3 gridDim + cuda_bindings_runtime__anon_pod26 param + unsigned int isEnabled + +cdef union cuda_bindings_runtime__anon_pod32: + cuda_bindings_runtime__anon_pod33 overBudget + +cdef extern from 'driver_types.h': + cdef struct cudaKernelNodeParamsV2: + void* func + cudaKernel_t kern + cudaFunction_t cuFunc + dim3 gridDim + dim3 blockDim + unsigned int sharedMemBytes + void** kernelParams + void** extra + cudaExecutionContext_t ctx + cudaKernelFunctionType functionType + +cdef extern from 'driver_types.h': + cdef union cudaLaunchAttributeValue: + char pad[64] + cudaAccessPolicyWindow accessPolicyWindow + int cooperative + cudaSynchronizationPolicy syncPolicy + cuda_bindings_runtime__anon_pod27 clusterDim + cudaClusterSchedulingPolicy clusterSchedulingPolicyPreference + int programmaticStreamSerializationAllowed + cuda_bindings_runtime__anon_pod28 programmaticEvent + int priority + cudaLaunchMemSyncDomainMap memSyncDomainMap + cudaLaunchMemSyncDomain memSyncDomain + cuda_bindings_runtime__anon_pod29 preferredClusterDim + cuda_bindings_runtime__anon_pod30 launchCompletionEvent + cuda_bindings_runtime__anon_pod31 deviceUpdatableKernelNode + unsigned int sharedMemCarveout + unsigned int nvlinkUtilCentricScheduling + cudaLaunchAttributePortableClusterMode portableClusterSizeMode + cudaSharedMemoryMode sharedMemoryMode + +cdef union cuda_bindings_runtime__anon_pod1: + cuda_bindings_runtime__anon_pod2 array + cuda_bindings_runtime__anon_pod3 mipmap + cuda_bindings_runtime__anon_pod4 linear + cuda_bindings_runtime__anon_pod5 pitch2D + cuda_bindings_runtime__anon_pod6 reserved + +cdef struct cudaEglFrame_st: + cuda_bindings_runtime__anon_pod34 frame + cudaEglPlaneDesc planeDesc[3] + unsigned int planeCount + cudaEglFrameType frameType + cudaEglColorFormat eglColorFormat +ctypedef cudaEglFrame_st cudaEglFrame + +cdef extern from 'driver_types.h': + cdef struct cudaMemcpyNodeParams: + int flags + int reserved + cudaExecutionContext_t ctx + cudaMemcpy3DParms copyParams + +cdef extern from 'driver_types.h': + cdef struct cudaMemAccessDesc: + cudaMemLocation location + cudaMemAccessFlags flags + +cdef extern from 'driver_types.h': + cdef struct cudaMemPoolProps: + cudaMemAllocationType allocType + cudaMemAllocationHandleType handleTypes + cudaMemLocation location + void* win32SecurityAttributes + size_t maxSize + unsigned short usage + unsigned char reserved[54] + +cdef extern from 'driver_types.h': + cdef struct cudaMemcpyAttributes: + cudaMemcpySrcAccessOrder srcAccessOrder + cudaMemLocation srcLocHint + cudaMemLocation dstLocHint + unsigned int flags + +cdef struct cuda_bindings_runtime__anon_pod9: + void* ptr + size_t rowLength + size_t layerHeight + cudaMemLocation locHint + +cdef extern from 'driver_types.h': + cdef struct cudaExternalMemoryHandleDesc: + cudaExternalMemoryHandleType type + cuda_bindings_runtime__anon_pod11 handle + unsigned long long size + unsigned int flags + unsigned int reserved[16] + +cdef extern from 'driver_types.h': + cdef struct cudaExternalSemaphoreHandleDesc: + cudaExternalSemaphoreHandleType type + cuda_bindings_runtime__anon_pod13 handle + unsigned int flags + unsigned int reserved[16] + +cdef extern from 'driver_types.h': + cdef struct cudaExternalSemaphoreSignalParams: + cuda_bindings_runtime__anon_pod15 params + unsigned int flags + unsigned int reserved[16] + +cdef extern from 'driver_types.h': + cdef struct cudaExternalSemaphoreWaitParams: + cuda_bindings_runtime__anon_pod19 params + unsigned int flags + unsigned int reserved[16] + +cdef extern from 'driver_types.h': + cdef struct cudaGraphKernelNodeUpdate: + cudaGraphDeviceNode_t node + cudaGraphKernelNodeField field + cuda_bindings_runtime__anon_pod25 updateData + +cdef extern from 'driver_types.h': + cdef struct cudaAsyncNotificationInfo: + cudaAsyncNotificationType type + cuda_bindings_runtime__anon_pod32 info + ctypedef cudaAsyncNotificationInfo cudaAsyncNotificationInfo_t + +cdef extern from 'driver_types.h': + cdef struct cudaDevResource_st: + cudaDevResourceType type + unsigned char _internal_padding[92] + cudaDevSmResource sm + cudaDevWorkqueueConfigResource wqConfig + cudaDevWorkqueueResource wq + unsigned char _oversize[40] + cudaDevResource_st* nextResource + ctypedef cudaDevResource_st cudaDevResource + +cdef extern from 'driver_types.h': + cdef struct cudaResourceDesc: + cudaResourceType resType + cuda_bindings_runtime__anon_pod1 res + unsigned int flags + +cdef extern from 'driver_types.h': + cdef struct cudaMemAllocNodeParams: + cudaMemPoolProps poolProps + cudaMemAccessDesc* accessDescs + size_t accessDescCount + size_t bytesize + void* dptr + +cdef extern from 'driver_types.h': + cdef struct cudaMemAllocNodeParamsV2: + cudaMemPoolProps poolProps + cudaMemAccessDesc* accessDescs + size_t accessDescCount + size_t bytesize + void* dptr + +cdef union cuda_bindings_runtime__anon_pod8: + cuda_bindings_runtime__anon_pod9 ptr + cuda_bindings_runtime__anon_pod10 array + +cdef extern from 'driver_types.h': + cdef struct cudaExternalSemaphoreSignalNodeParams: + cudaExternalSemaphore_t* extSemArray + cudaExternalSemaphoreSignalParams* paramsArray + unsigned int numExtSems + +cdef extern from 'driver_types.h': + cdef struct cudaExternalSemaphoreSignalNodeParamsV2: + cudaExternalSemaphore_t* extSemArray + cudaExternalSemaphoreSignalParams* paramsArray + unsigned int numExtSems + +cdef extern from 'driver_types.h': + cdef struct cudaExternalSemaphoreWaitNodeParams: + cudaExternalSemaphore_t* extSemArray + cudaExternalSemaphoreWaitParams* paramsArray + unsigned int numExtSems + +cdef extern from 'driver_types.h': + cdef struct cudaExternalSemaphoreWaitNodeParamsV2: + cudaExternalSemaphore_t* extSemArray + cudaExternalSemaphoreWaitParams* paramsArray + unsigned int numExtSems + +cdef extern from 'driver_types.h': + cdef struct cudaMemcpy3DOperand: + cudaMemcpy3DOperandType type + cuda_bindings_runtime__anon_pod8 op + +cdef extern from 'driver_types.h': + cdef struct cudaMemcpy3DBatchOp: + cudaMemcpy3DOperand src + cudaMemcpy3DOperand dst + cudaExtent extent + cudaMemcpySrcAccessOrder srcAccessOrder + unsigned int flags + +cdef extern from 'driver_types.h': + cdef struct cudaGraphNodeParams: + cudaGraphNodeType type + int reserved0[3] + long long reserved1[29] + cudaKernelNodeParamsV2 kernel + cudaMemcpyNodeParams memcpy + cudaMemsetParamsV2 memset + cudaHostNodeParamsV2 host + cudaChildGraphNodeParams graph + cudaEventWaitNodeParams eventWait + cudaEventRecordNodeParams eventRecord + cudaExternalSemaphoreSignalNodeParamsV2 extSemSignal + cudaExternalSemaphoreWaitNodeParamsV2 extSemWait + cudaMemAllocNodeParamsV2 alloc + cudaMemFreeNodeParams free + cudaConditionalNodeParams conditional + long long reserved2 + +cdef extern from 'cuda_runtime_api.h': + ctypedef cudaError_t (*cudaGraphRecaptureCallback_t 'cudaGraphRecaptureCallback_t')( + void* data, + cudaGraphNode_t node, + const cudaGraphNodeParams* originalParams, + const cudaGraphNodeParams* recaptureParams, + cudaGraphRecaptureStatus status + ) + + +cdef extern from '': + cdef struct cudaGraphRecaptureCallbackData: + cudaGraphRecaptureCallback_t callbackFunc + void* userData + +cdef extern from 'driver_types.h': + # cudaLaunchAttribute_st is SKIPped (sizeof-based array dimension in pad field). + # Declared here (after the enum and type sections) so that cudaLaunchAttributeID and + # cudaLaunchAttributeValue are already in scope — Cython requires forward types to + # be visible at the point of use even inside cdef extern from blocks. + # Field types must match the legacy_cython_gen ABI baseline for __pyx_capi__ compat. + ctypedef struct cudaLaunchAttribute_st 'cudaLaunchAttribute_st': + cudaLaunchAttributeID id + cudaLaunchAttributeValue val + +cdef extern from 'driver_types.h': + ctypedef cudaLaunchAttribute_st cudaLaunchAttribute 'cudaLaunchAttribute' + +# cudaLaunchConfig_st references cudaLaunchAttribute* so it must follow the above. +# Declared here rather than auto-generated (which would land in type_decls, before +# cudaLaunchAttribute) to satisfy Cython's forward-declaration requirement. +cdef extern from '': + cdef struct cudaLaunchConfig_st: + dim3 gridDim + dim3 blockDim + size_t dynamicSmemBytes + cudaStream_t stream + cudaLaunchAttribute* attrs + unsigned int numAttrs + ctypedef cudaLaunchConfig_st cudaLaunchConfig_t + +cdef extern from 'cuda_runtime_api.h': + ctypedef void (*cudaAsyncCallback)(cudaAsyncNotificationInfo_t* info, void* userData, cudaAsyncCallbackHandle_t handle) nogil + + +# FUNCTIONS +cdef cudaError_t cudaDeviceReset() except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaDeviceSynchronize() except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaDeviceSetLimit(cudaLimit limit, size_t value) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaDeviceGetLimit(size_t* pValue, cudaLimit limit) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaDeviceGetTexture1DLinearMaxWidth(size_t* maxWidthInElements, const cudaChannelFormatDesc* fmtDesc, int device) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaDeviceGetCacheConfig(cudaFuncCache* pCacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaDeviceGetStreamPriorityRange(int* leastPriority, int* greatestPriority) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaDeviceSetCacheConfig(cudaFuncCache cacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaDeviceGetByPCIBusId(int* device, const char* pciBusId) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaDeviceGetPCIBusId(char* pciBusId, int len, int device) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaIpcGetEventHandle(cudaIpcEventHandle_t* handle, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaIpcOpenEventHandle(cudaEvent_t* event, cudaIpcEventHandle_t handle) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaIpcGetMemHandle(cudaIpcMemHandle_t* handle, void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaIpcOpenMemHandle(void** devPtr, cudaIpcMemHandle_t handle, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaIpcCloseMemHandle(void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaDeviceFlushGPUDirectRDMAWrites(cudaFlushGPUDirectRDMAWritesTarget target, cudaFlushGPUDirectRDMAWritesScope scope) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaDeviceRegisterAsyncNotification(int device, cudaAsyncCallback callbackFunc, void* userData, cudaAsyncCallbackHandle_t* callback) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaDeviceUnregisterAsyncNotification(int device, cudaAsyncCallbackHandle_t callback) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaDeviceGetSharedMemConfig(cudaSharedMemConfig* pConfig) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaDeviceSetSharedMemConfig(cudaSharedMemConfig config) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGetLastError() except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaPeekAtLastError() except ?cudaErrorCallRequiresNewerDriver nogil +cdef const char* cudaGetErrorName(cudaError_t error) except?NULL nogil +cdef const char* cudaGetErrorString(cudaError_t error) except?NULL nogil +cdef cudaError_t cudaGetDeviceCount(int* count) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaDeviceGetAttribute(int* value, cudaDeviceAttr attr, int device) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaDeviceGetDefaultMemPool(cudaMemPool_t* memPool, int device) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaDeviceSetMemPool(int device, cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaDeviceGetMemPool(cudaMemPool_t* memPool, int device) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaDeviceGetNvSciSyncAttributes(void* nvSciSyncAttrList, int device, int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaDeviceGetP2PAttribute(int* value, cudaDeviceP2PAttr attr, int srcDevice, int dstDevice) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaChooseDevice(int* device, const cudaDeviceProp* prop) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaInitDevice(int device, unsigned int deviceFlags, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaSetDevice(int device) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGetDevice(int* device) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaSetDeviceFlags(unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGetDeviceFlags(unsigned int* flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaStreamCreate(cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaStreamCreateWithFlags(cudaStream_t* pStream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaStreamCreateWithPriority(cudaStream_t* pStream, unsigned int flags, int priority) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaStreamGetPriority(cudaStream_t hStream, int* priority) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaStreamGetFlags(cudaStream_t hStream, unsigned int* flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaStreamGetId(cudaStream_t hStream, unsigned long long* streamId) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaStreamGetDevice(cudaStream_t hStream, int* device) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaCtxResetPersistingL2Cache() except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaStreamCopyAttributes(cudaStream_t dst, cudaStream_t src) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaStreamGetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, cudaStreamAttrValue* value_out) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaStreamSetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, const cudaStreamAttrValue* value) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaStreamDestroy(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaStreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaStreamAddCallback(cudaStream_t stream, cudaStreamCallback_t callback, void* userData, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaStreamSynchronize(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaStreamQuery(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaStreamAttachMemAsync(cudaStream_t stream, void* devPtr, size_t length, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaStreamBeginCapture(cudaStream_t stream, cudaStreamCaptureMode mode) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaStreamBeginCaptureToGraph(cudaStream_t stream, cudaGraph_t graph, const cudaGraphNode_t* dependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, cudaStreamCaptureMode mode) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaThreadExchangeStreamCaptureMode(cudaStreamCaptureMode* mode) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaStreamEndCapture(cudaStream_t stream, cudaGraph_t* pGraph) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaStreamIsCapturing(cudaStream_t stream, cudaStreamCaptureStatus* pCaptureStatus) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaStreamUpdateCaptureDependencies(cudaStream_t stream, cudaGraphNode_t* dependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaEventCreate(cudaEvent_t* event) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaEventCreateWithFlags(cudaEvent_t* event, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaEventRecord(cudaEvent_t event, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaEventRecordWithFlags(cudaEvent_t event, cudaStream_t stream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaEventQuery(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaEventSynchronize(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaEventDestroy(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaEventElapsedTime(float* ms, cudaEvent_t start, cudaEvent_t end) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaImportExternalMemory(cudaExternalMemory_t* extMem_out, const cudaExternalMemoryHandleDesc* memHandleDesc) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaExternalMemoryGetMappedBuffer(void** devPtr, cudaExternalMemory_t extMem, const cudaExternalMemoryBufferDesc* bufferDesc) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaExternalMemoryGetMappedMipmappedArray(cudaMipmappedArray_t* mipmap, cudaExternalMemory_t extMem, const cudaExternalMemoryMipmappedArrayDesc* mipmapDesc) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaDestroyExternalMemory(cudaExternalMemory_t extMem) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaImportExternalSemaphore(cudaExternalSemaphore_t* extSem_out, const cudaExternalSemaphoreHandleDesc* semHandleDesc) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaDestroyExternalSemaphore(cudaExternalSemaphore_t extSem) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaFuncSetCacheConfig(const void* func, cudaFuncCache cacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaFuncGetAttributes(cudaFuncAttributes* attr, const void* func) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaFuncSetAttribute(const void* func, cudaFuncAttribute attr, int value) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaFuncGetName(const char** name, const void* func) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaFuncGetParamInfo(const void* func, size_t paramIndex, size_t* paramOffset, size_t* paramSize) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaLaunchHostFunc(cudaStream_t stream, cudaHostFn_t fn, void* userData) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaFuncSetSharedMemConfig(const void* func, cudaSharedMemConfig config) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessor(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaOccupancyAvailableDynamicSMemPerBlock(size_t* dynamicSmemSize, const void* func, int numBlocks, int blockSize) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMallocManaged(void** devPtr, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMalloc(void** devPtr, size_t size) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMallocHost(void** ptr, size_t size) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMallocPitch(void** devPtr, size_t* pitch, size_t width, size_t height) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMallocArray(cudaArray_t* array, const cudaChannelFormatDesc* desc, size_t width, size_t height, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaFree(void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaFreeHost(void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaFreeArray(cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaFreeMipmappedArray(cudaMipmappedArray_t mipmappedArray) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaHostAlloc(void** pHost, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaHostRegister(void* ptr, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaHostUnregister(void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaHostGetDevicePointer(void** pDevice, void* pHost, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaHostGetFlags(unsigned int* pFlags, void* pHost) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMalloc3D(cudaPitchedPtr* pitchedDevPtr, cudaExtent extent) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMalloc3DArray(cudaArray_t* array, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMallocMipmappedArray(cudaMipmappedArray_t* mipmappedArray, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int numLevels, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGetMipmappedArrayLevel(cudaArray_t* levelArray, cudaMipmappedArray_const_t mipmappedArray, unsigned int level) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemcpy3D(const cudaMemcpy3DParms* p) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemcpy3DPeer(const cudaMemcpy3DPeerParms* p) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemcpy3DAsync(const cudaMemcpy3DParms* p, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemcpy3DPeerAsync(const cudaMemcpy3DPeerParms* p, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemGetInfo(size_t* free, size_t* total) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaArrayGetInfo(cudaChannelFormatDesc* desc, cudaExtent* extent, unsigned int* flags, cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaArrayGetPlane(cudaArray_t* pPlaneArray, cudaArray_t hArray, unsigned int planeIdx) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaArray_t array, int device) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMipmappedArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaMipmappedArray_t mipmap, int device) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMipmappedArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaMipmappedArray_t mipmap) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemcpy(void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemcpyPeer(void* dst, int dstDevice, const void* src, int srcDevice, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemcpy2D(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemcpy2DToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemcpy2DFromArray(void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemcpy2DArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemcpyAsync(void* dst, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemcpyPeerAsync(void* dst, int dstDevice, const void* src, int srcDevice, size_t count, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemcpyBatchAsync(const void** dsts, const void** srcs, const size_t* sizes, size_t count, cudaMemcpyAttributes* attrs, size_t* attrsIdxs, size_t numAttrs, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemcpy3DBatchAsync(size_t numOps, cudaMemcpy3DBatchOp* opList, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemcpy2DAsync(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemcpy2DToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemcpy2DFromArrayAsync(void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemset(void* devPtr, int value, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemset2D(void* devPtr, size_t pitch, int value, size_t width, size_t height) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemset3D(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemsetAsync(void* devPtr, int value, size_t count, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemset2DAsync(void* devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemset3DAsync(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemPrefetchAsync(const void* devPtr, size_t count, cudaMemLocation location, unsigned int flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemAdvise(const void* devPtr, size_t count, cudaMemoryAdvise advice, cudaMemLocation location) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemRangeGetAttribute(void* data, size_t dataSize, cudaMemRangeAttribute attribute, const void* devPtr, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemRangeGetAttributes(void** data, size_t* dataSizes, cudaMemRangeAttribute* attributes, size_t numAttributes, const void* devPtr, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemcpyToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemcpyFromArray(void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemcpyArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemcpyToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemcpyFromArrayAsync(void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMallocAsync(void** devPtr, size_t size, cudaStream_t hStream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaFreeAsync(void* devPtr, cudaStream_t hStream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemPoolTrimTo(cudaMemPool_t memPool, size_t minBytesToKeep) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemPoolSetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemPoolGetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemPoolSetAccess(cudaMemPool_t memPool, const cudaMemAccessDesc* descList, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemPoolGetAccess(cudaMemAccessFlags* flags, cudaMemPool_t memPool, cudaMemLocation* location) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemPoolCreate(cudaMemPool_t* memPool, const cudaMemPoolProps* poolProps) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemPoolDestroy(cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMallocFromPoolAsync(void** ptr, size_t size, cudaMemPool_t memPool, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemPoolExportToShareableHandle(void* shareableHandle, cudaMemPool_t memPool, cudaMemAllocationHandleType handleType, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemPoolImportFromShareableHandle(cudaMemPool_t* memPool, void* shareableHandle, cudaMemAllocationHandleType handleType, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemPoolExportPointer(cudaMemPoolPtrExportData* exportData, void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemPoolImportPointer(void** ptr, cudaMemPool_t memPool, cudaMemPoolPtrExportData* exportData) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaPointerGetAttributes(cudaPointerAttributes* attributes, const void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaDeviceCanAccessPeer(int* canAccessPeer, int device, int peerDevice) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaDeviceDisablePeerAccess(int peerDevice) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphicsUnregisterResource(cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphicsResourceSetMapFlags(cudaGraphicsResource_t resource, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphicsMapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphicsUnmapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphicsResourceGetMappedPointer(void** devPtr, size_t* size, cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphicsSubResourceGetMappedArray(cudaArray_t* array, cudaGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphicsResourceGetMappedMipmappedArray(cudaMipmappedArray_t* mipmappedArray, cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGetChannelDesc(cudaChannelFormatDesc* desc, cudaArray_const_t array) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaChannelFormatDesc cudaCreateChannelDesc(int x, int y, int z, int w, cudaChannelFormatKind f) except* nogil +cdef cudaError_t cudaCreateTextureObject(cudaTextureObject_t* pTexObject, const cudaResourceDesc* pResDesc, const cudaTextureDesc* pTexDesc, const cudaResourceViewDesc* pResViewDesc) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaDestroyTextureObject(cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGetTextureObjectResourceDesc(cudaResourceDesc* pResDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGetTextureObjectTextureDesc(cudaTextureDesc* pTexDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGetTextureObjectResourceViewDesc(cudaResourceViewDesc* pResViewDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaCreateSurfaceObject(cudaSurfaceObject_t* pSurfObject, const cudaResourceDesc* pResDesc) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaDestroySurfaceObject(cudaSurfaceObject_t surfObject) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGetSurfaceObjectResourceDesc(cudaResourceDesc* pResDesc, cudaSurfaceObject_t surfObject) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaDriverGetVersion(int* driverVersion) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaRuntimeGetVersion(int* runtimeVersion) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphCreate(cudaGraph_t* pGraph, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphAddKernelNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphKernelNodeGetParams(cudaGraphNode_t node, cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphKernelNodeSetParams(cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphKernelNodeCopyAttributes(cudaGraphNode_t hDst, cudaGraphNode_t hSrc) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphKernelNodeGetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, cudaKernelNodeAttrValue* value_out) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphKernelNodeSetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, const cudaKernelNodeAttrValue* value) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphAddMemcpyNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemcpy3DParms* pCopyParams) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphAddMemcpyNode1D(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphMemcpyNodeGetParams(cudaGraphNode_t node, cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphMemcpyNodeSetParams(cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphMemcpyNodeSetParams1D(cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphAddMemsetNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemsetParams* pMemsetParams) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphMemsetNodeGetParams(cudaGraphNode_t node, cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphMemsetNodeSetParams(cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphAddHostNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphHostNodeGetParams(cudaGraphNode_t node, cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphHostNodeSetParams(cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphAddChildGraphNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaGraph_t childGraph) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphChildGraphNodeGetGraph(cudaGraphNode_t node, cudaGraph_t* pGraph) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphAddEmptyNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphAddEventRecordNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphEventRecordNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphEventRecordNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphAddEventWaitNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphEventWaitNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphEventWaitNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphAddExternalSemaphoresSignalNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphExternalSemaphoresSignalNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreSignalNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphExternalSemaphoresSignalNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphAddExternalSemaphoresWaitNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphExternalSemaphoresWaitNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreWaitNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphExternalSemaphoresWaitNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphAddMemAllocNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaMemAllocNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphMemAllocNodeGetParams(cudaGraphNode_t node, cudaMemAllocNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphAddMemFreeNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dptr) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphMemFreeNodeGetParams(cudaGraphNode_t node, void* dptr_out) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaDeviceGraphMemTrim(int device) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaDeviceGetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaDeviceSetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphClone(cudaGraph_t* pGraphClone, cudaGraph_t originalGraph) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphNodeFindInClone(cudaGraphNode_t* pNode, cudaGraphNode_t originalNode, cudaGraph_t clonedGraph) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphNodeGetType(cudaGraphNode_t node, cudaGraphNodeType* pType) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphGetNodes(cudaGraph_t graph, cudaGraphNode_t* nodes, size_t* numNodes) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphGetRootNodes(cudaGraph_t graph, cudaGraphNode_t* pRootNodes, size_t* pNumRootNodes) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphGetEdges(cudaGraph_t graph, cudaGraphNode_t* from_, cudaGraphNode_t* to, cudaGraphEdgeData* edgeData, size_t* numEdges) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphNodeGetDependencies(cudaGraphNode_t node, cudaGraphNode_t* pDependencies, cudaGraphEdgeData* edgeData, size_t* pNumDependencies) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphNodeGetDependentNodes(cudaGraphNode_t node, cudaGraphNode_t* pDependentNodes, cudaGraphEdgeData* edgeData, size_t* pNumDependentNodes) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphAddDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, const cudaGraphEdgeData* edgeData, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphRemoveDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, const cudaGraphEdgeData* edgeData, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphDestroyNode(cudaGraphNode_t node) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphInstantiate(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphInstantiateWithFlags(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphInstantiateWithParams(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, cudaGraphInstantiateParams* instantiateParams) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphExecGetFlags(cudaGraphExec_t graphExec, unsigned long long* flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphExecKernelNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphExecMemcpyNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphExecMemcpyNodeSetParams1D(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphExecMemsetNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphExecHostNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphExecChildGraphNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, cudaGraph_t childGraph) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphExecEventRecordNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphExecEventWaitNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphExecExternalSemaphoresSignalNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphExecExternalSemaphoresWaitNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphNodeSetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int isEnabled) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphNodeGetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int* isEnabled) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphExecUpdate(cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphExecUpdateResultInfo* resultInfo) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphUpload(cudaGraphExec_t graphExec, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphLaunch(cudaGraphExec_t graphExec, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphExecDestroy(cudaGraphExec_t graphExec) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphDestroy(cudaGraph_t graph) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphDebugDotPrint(cudaGraph_t graph, const char* path, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaUserObjectCreate(cudaUserObject_t* object_out, void* ptr, cudaHostFn_t destroy, unsigned int initialRefcount, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaUserObjectRetain(cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaUserObjectRelease(cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphRetainUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphReleaseUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphAddNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphNodeSetParams(cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphExecNodeSetParams(cudaGraphExec_t graphExec, cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphConditionalHandleCreate(cudaGraphConditionalHandle* pHandle_out, cudaGraph_t graph, unsigned int defaultLaunchValue, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGetDriverEntryPoint(const char* symbol, void** funcPtr, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGetDriverEntryPointByVersion(const char* symbol, void** funcPtr, unsigned int cudaVersion, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaLibraryLoadData(cudaLibrary_t* library, const void* code, cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaLibraryLoadFromFile(cudaLibrary_t* library, const char* fileName, cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaLibraryUnload(cudaLibrary_t library) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaLibraryGetKernel(cudaKernel_t* pKernel, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaLibraryGetGlobal(void** dptr, size_t* bytes, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaLibraryGetManaged(void** dptr, size_t* bytes, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaLibraryGetUnifiedFunction(void** fptr, cudaLibrary_t library, const char* symbol) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaLibraryGetKernelCount(unsigned int* count, cudaLibrary_t lib) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaLibraryEnumerateKernels(cudaKernel_t* kernels, unsigned int numKernels, cudaLibrary_t lib) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaKernelSetAttributeForDevice(cudaKernel_t kernel, cudaFuncAttribute attr, int value, int device) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGetExportTable(const void** ppExportTable, const cudaUUID_t* pExportTableId) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGetKernel(cudaKernel_t* kernelPtr, const void* entryFuncAddr) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphicsEGLRegisterImage(cudaGraphicsResource** pCudaResource, EGLImageKHR image, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaEGLStreamConsumerConnect(cudaEglStreamConnection* conn, EGLStreamKHR eglStream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaEGLStreamConsumerConnectWithFlags(cudaEglStreamConnection* conn, EGLStreamKHR eglStream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaEGLStreamConsumerDisconnect(cudaEglStreamConnection* conn) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaEGLStreamConsumerAcquireFrame(cudaEglStreamConnection* conn, cudaGraphicsResource_t* pCudaResource, cudaStream_t* pStream, unsigned int timeout) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaEGLStreamConsumerReleaseFrame(cudaEglStreamConnection* conn, cudaGraphicsResource_t pCudaResource, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaEGLStreamProducerConnect(cudaEglStreamConnection* conn, EGLStreamKHR eglStream, EGLint width, EGLint height) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaEGLStreamProducerDisconnect(cudaEglStreamConnection* conn) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaEGLStreamProducerPresentFrame(cudaEglStreamConnection* conn, cudaEglFrame eglframe, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaEGLStreamProducerReturnFrame(cudaEglStreamConnection* conn, cudaEglFrame* eglframe, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphicsResourceGetMappedEglFrame(cudaEglFrame* eglFrame, cudaGraphicsResource_t resource, unsigned int index, unsigned int mipLevel) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaEventCreateFromEGLSync(cudaEvent_t* phEvent, EGLSyncKHR eglSync, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaProfilerStart() except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaProfilerStop() except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGLGetDevices(unsigned int* pCudaDeviceCount, int* pCudaDevices, unsigned int cudaDeviceCount, cudaGLDeviceList deviceList) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphicsGLRegisterImage(cudaGraphicsResource** resource, GLuint image, GLenum target, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphicsGLRegisterBuffer(cudaGraphicsResource** resource, GLuint buffer, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaVDPAUGetDevice(int* device, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaVDPAUSetVDPAUDevice(int device, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphicsVDPAURegisterVideoSurface(cudaGraphicsResource** resource, VdpVideoSurface vdpSurface, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphicsVDPAURegisterOutputSurface(cudaGraphicsResource** resource, VdpOutputSurface vdpSurface, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGetDeviceProperties(cudaDeviceProp* prop, int device) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaDeviceGetHostAtomicCapabilities(unsigned int* capabilities, const cudaAtomicOperation* operations, unsigned int count, int device) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaDeviceGetP2PAtomicCapabilities(unsigned int* capabilities, const cudaAtomicOperation* operations, unsigned int count, int srcDevice, int dstDevice) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaStreamGetCaptureInfo(cudaStream_t stream, cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out, cudaGraph_t* graph_out, const cudaGraphNode_t** dependencies_out, const cudaGraphEdgeData** edgeData_out, size_t* numDependencies_out) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaSignalExternalSemaphoresAsync(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreSignalParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaWaitExternalSemaphoresAsync(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreWaitParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemPrefetchBatchAsync(void** dptrs, size_t* sizes, size_t count, cudaMemLocation* prefetchLocs, size_t* prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemDiscardBatchAsync(void** dptrs, size_t* sizes, size_t count, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemDiscardAndPrefetchBatchAsync(void** dptrs, size_t* sizes, size_t count, cudaMemLocation* prefetchLocs, size_t* prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemGetDefaultMemPool(cudaMemPool_t* memPool, cudaMemLocation* location, cudaMemAllocationType type) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemGetMemPool(cudaMemPool_t* memPool, cudaMemLocation* location, cudaMemAllocationType type) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemSetMemPool(cudaMemLocation* location, cudaMemAllocationType type, cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaLogsRegisterCallback(cudaLogsCallback_t callbackFunc, void* userData, cudaLogsCallbackHandle* callback_out) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaLogsUnregisterCallback(cudaLogsCallbackHandle callback) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaLogsCurrent(cudaLogIterator* iterator_out, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaLogsDumpToFile(cudaLogIterator* iterator, const char* pathToFile, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaLogsDumpToMemory(cudaLogIterator* iterator, char* buffer, size_t* size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphNodeGetContainingGraph(cudaGraphNode_t hNode, cudaGraph_t* phGraph) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphNodeGetLocalId(cudaGraphNode_t hNode, unsigned int* nodeId) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphNodeGetToolsId(cudaGraphNode_t hNode, unsigned long long* toolsNodeId) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphGetId(cudaGraph_t hGraph, unsigned int* graphID) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphExecGetId(cudaGraphExec_t hGraphExec, unsigned int* graphID) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphConditionalHandleCreate_v2(cudaGraphConditionalHandle* pHandle_out, cudaGraph_t graph, cudaExecutionContext_t ctx, unsigned int defaultLaunchValue, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaDeviceGetDevResource(int device, cudaDevResource* resource, cudaDevResourceType type) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaDevSmResourceSplitByCount(cudaDevResource* result, unsigned int* nbGroups, const cudaDevResource* input, cudaDevResource* remaining, unsigned int flags, unsigned int minCount) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaDevSmResourceSplit(cudaDevResource* result, unsigned int nbGroups, const cudaDevResource* input, cudaDevResource* remainder, unsigned int flags, cudaDevSmResourceGroupParams* groupParams) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaDevResourceGenerateDesc(cudaDevResourceDesc_t* phDesc, cudaDevResource* resources, unsigned int nbResources) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGreenCtxCreate(cudaExecutionContext_t* phCtx, cudaDevResourceDesc_t desc, int device, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaExecutionCtxDestroy(cudaExecutionContext_t ctx) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaExecutionCtxGetDevResource(cudaExecutionContext_t ctx, cudaDevResource* resource, cudaDevResourceType type) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaExecutionCtxGetDevice(int* device, cudaExecutionContext_t ctx) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaExecutionCtxGetId(cudaExecutionContext_t ctx, unsigned long long* ctxId) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaExecutionCtxStreamCreate(cudaStream_t* phStream, cudaExecutionContext_t ctx, unsigned int flags, int priority) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaExecutionCtxSynchronize(cudaExecutionContext_t ctx) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaStreamGetDevResource(cudaStream_t hStream, cudaDevResource* resource, cudaDevResourceType type) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaExecutionCtxRecordEvent(cudaExecutionContext_t ctx, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaExecutionCtxWaitEvent(cudaExecutionContext_t ctx, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaDeviceGetExecutionCtx(cudaExecutionContext_t* ctx, int device) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaFuncGetParamCount(const void* func, size_t* paramCount) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaLaunchHostFunc_v2(cudaStream_t stream, cudaHostFn_t fn, void* userData, unsigned int syncMode) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemcpyWithAttributesAsync(void* dst, const void* src, size_t size, cudaMemcpyAttributes* attr, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaMemcpy3DWithAttributesAsync(cudaMemcpy3DBatchOp* op, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaGraphNodeGetParams(cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t cudaStreamBeginRecaptureToGraph(cudaStream_t stream, cudaStreamCaptureMode mode, cudaGraph_t graph, cudaGraphRecaptureCallbackData* callbackData) except ?cudaErrorCallRequiresNewerDriver nogil + +# C #define integer constants from driver_types.h required for ABI compat with lowpp layer +cdef extern from 'driver_types.h': + cdef enum: + cudaHostAllocDefault + cudaHostAllocPortable + cudaHostAllocMapped + cudaHostAllocWriteCombined + cudaHostRegisterDefault + cudaHostRegisterPortable + cudaHostRegisterMapped + cudaHostRegisterIoMemory + cudaHostRegisterReadOnly + cudaPeerAccessDefault + cudaStreamDefault + cudaStreamNonBlocking + cudaEventDefault + cudaEventBlockingSync + cudaEventDisableTiming + cudaEventInterprocess + cudaEventRecordDefault + cudaEventRecordExternal + cudaEventWaitDefault + cudaEventWaitExternal + cudaDeviceScheduleAuto + cudaDeviceScheduleSpin + cudaDeviceScheduleYield + cudaDeviceScheduleBlockingSync + cudaDeviceBlockingSync + cudaDeviceScheduleMask + cudaDeviceMapHost + cudaDeviceLmemResizeToMax + cudaDeviceSyncMemops + cudaDeviceMask + cudaArrayDefault + cudaArrayLayered + cudaArraySurfaceLoadStore + cudaArrayCubemap + cudaArrayTextureGather + cudaArrayColorAttachment + cudaArraySparse + cudaArrayDeferredMapping + cudaIpcMemLazyEnablePeerAccess + cudaMemAttachGlobal + cudaMemAttachHost + cudaMemAttachSingle + cudaOccupancyDefault + cudaOccupancyDisableCachingOverride + cudaCpuDeviceId + cudaInvalidDeviceId + cudaInitDeviceFlagsAreValid + cudaArraySparsePropertiesSingleMipTail + cudaMemPoolCreateUsageHwDecompress + CUDA_IPC_HANDLE_SIZE + cudaExternalMemoryDedicated + cudaExternalSemaphoreSignalSkipNvSciBufMemSync + cudaExternalSemaphoreWaitSkipNvSciBufMemSync + cudaNvSciSyncAttrSignal + cudaNvSciSyncAttrWait + cudaGraphKernelNodePortDefault + cudaGraphKernelNodePortProgrammatic + cudaGraphKernelNodePortLaunchCompletion + cudaStreamAttributeAccessPolicyWindow + cudaStreamAttributeSynchronizationPolicy + cudaStreamAttributeMemSyncDomainMap + cudaStreamAttributeMemSyncDomain + cudaStreamAttributePriority + cudaKernelNodeAttributeAccessPolicyWindow + cudaKernelNodeAttributeCooperative + cudaKernelNodeAttributePriority + cudaKernelNodeAttributeClusterDimension + cudaKernelNodeAttributeClusterSchedulingPolicyPreference + cudaKernelNodeAttributeMemSyncDomainMap + cudaKernelNodeAttributeMemSyncDomain + cudaKernelNodeAttributePreferredSharedMemoryCarveout + cudaKernelNodeAttributeDeviceUpdatableKernelNode + cudaKernelNodeAttributeNvlinkUtilCentricScheduling + +# cudaStreamLegacy/PerThread are pointer-cast macros: ((cudaStream_t)0x1/0x2); use integer values +cdef enum: + cudaStreamLegacy = 1 + cudaStreamPerThread = 2 + +# Surface and texture type constants +cdef extern from 'surface_types.h': + cdef enum: + cudaSurfaceType1D + cudaSurfaceType2D + cudaSurfaceType3D + cudaSurfaceTypeCubemap + cudaSurfaceType1DLayered + cudaSurfaceType2DLayered + cudaSurfaceTypeCubemapLayered + +cdef extern from 'texture_types.h': + cdef enum: + cudaTextureType1D + cudaTextureType2D + cudaTextureType3D + cudaTextureTypeCubemap + cudaTextureType1DLayered + cudaTextureType2DLayered + cudaTextureTypeCubemapLayered + +# Version constants +cdef extern from 'cuda_runtime.h': + cdef enum: + CUDART_VERSION + +cdef extern from 'cuda_runtime_api.h': + cdef enum: + __CUDART_API_VERSION + +# CUDA_EGL_MAX_PLANES is defined as 3 in cuda_egl_interop.h; hardcoded to avoid EGL deps +cdef enum: + CUDA_EGL_MAX_PLANES = 3 + +# libraryPropertyType_t (starts lowercase, outside type pattern) +cdef extern from 'library_types.h': + ctypedef enum libraryPropertyType_t 'libraryPropertyType_t': + MAJOR_VERSION + MINOR_VERSION + PATCH_LEVEL + + +# Static inline helpers from driver_functions.h — wrapped as cdef so the lowpp layer can cimport them. +cdef cudaPitchedPtr make_cudaPitchedPtr(void* d, size_t p, size_t xsz, size_t ysz) except* nogil +cdef cudaPos make_cudaPos(size_t x, size_t y, size_t z) except* nogil +cdef cudaExtent make_cudaExtent(size_t w, size_t h, size_t d) except* nogil + +cdef cudaError_t getLocalRuntimeVersion(int* runtimeVersion) except ?cudaErrorCallRequiresNewerDriver nogil diff --git a/cuda_bindings/cuda/bindings/cyruntime.pxd.in b/cuda_bindings/cuda/bindings/cyruntime.pxd.in deleted file mode 100644 index 952d5137f42..00000000000 --- a/cuda_bindings/cuda/bindings/cyruntime.pxd.in +++ /dev/null @@ -1,2095 +0,0 @@ -# SPDX-FileCopyrightText: Copyright (c) 2021-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-License-Identifier: Apache-2.0 - -# This code was automatically generated with version 13.3.0. Do not modify it directly. - -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=2d7f136277c2cc633450e22e7833a0cab63cdfc70e07719a2e46d3812cd11a2f -from libc.stdint cimport uint32_t, uint64_t - -include "cyruntime_types.pxi" - -ctypedef unsigned int GLenum - -ctypedef unsigned int GLuint - -cdef extern from "": - cdef struct void: - pass -ctypedef void* EGLImageKHR - -cdef extern from "": - cdef struct void: - pass -ctypedef void* EGLStreamKHR - -ctypedef unsigned int EGLint - -cdef extern from "": - cdef struct void: - pass -ctypedef void* EGLSyncKHR - -ctypedef uint32_t VdpDevice - -ctypedef unsigned long long VdpGetProcAddress - -ctypedef uint32_t VdpVideoSurface - -ctypedef uint32_t VdpOutputSurface - -cdef enum cudaEglFrameType_enum: - cudaEglFrameTypeArray = 0 - cudaEglFrameTypePitch = 1 - -ctypedef cudaEglFrameType_enum cudaEglFrameType - -cdef enum cudaEglResourceLocationFlags_enum: - cudaEglResourceLocationSysmem = 0 - cudaEglResourceLocationVidmem = 1 - -ctypedef cudaEglResourceLocationFlags_enum cudaEglResourceLocationFlags - -cdef enum cudaEglColorFormat_enum: - cudaEglColorFormatYUV420Planar = 0 - cudaEglColorFormatYUV420SemiPlanar = 1 - cudaEglColorFormatYUV422Planar = 2 - cudaEglColorFormatYUV422SemiPlanar = 3 - cudaEglColorFormatARGB = 6 - cudaEglColorFormatRGBA = 7 - cudaEglColorFormatL = 8 - cudaEglColorFormatR = 9 - cudaEglColorFormatYUV444Planar = 10 - cudaEglColorFormatYUV444SemiPlanar = 11 - cudaEglColorFormatYUYV422 = 12 - cudaEglColorFormatUYVY422 = 13 - cudaEglColorFormatABGR = 14 - cudaEglColorFormatBGRA = 15 - cudaEglColorFormatA = 16 - cudaEglColorFormatRG = 17 - cudaEglColorFormatAYUV = 18 - cudaEglColorFormatYVU444SemiPlanar = 19 - cudaEglColorFormatYVU422SemiPlanar = 20 - cudaEglColorFormatYVU420SemiPlanar = 21 - cudaEglColorFormatY10V10U10_444SemiPlanar = 22 - cudaEglColorFormatY10V10U10_420SemiPlanar = 23 - cudaEglColorFormatY12V12U12_444SemiPlanar = 24 - cudaEglColorFormatY12V12U12_420SemiPlanar = 25 - cudaEglColorFormatVYUY_ER = 26 - cudaEglColorFormatUYVY_ER = 27 - cudaEglColorFormatYUYV_ER = 28 - cudaEglColorFormatYVYU_ER = 29 - cudaEglColorFormatYUVA_ER = 31 - cudaEglColorFormatAYUV_ER = 32 - cudaEglColorFormatYUV444Planar_ER = 33 - cudaEglColorFormatYUV422Planar_ER = 34 - cudaEglColorFormatYUV420Planar_ER = 35 - cudaEglColorFormatYUV444SemiPlanar_ER = 36 - cudaEglColorFormatYUV422SemiPlanar_ER = 37 - cudaEglColorFormatYUV420SemiPlanar_ER = 38 - cudaEglColorFormatYVU444Planar_ER = 39 - cudaEglColorFormatYVU422Planar_ER = 40 - cudaEglColorFormatYVU420Planar_ER = 41 - cudaEglColorFormatYVU444SemiPlanar_ER = 42 - cudaEglColorFormatYVU422SemiPlanar_ER = 43 - cudaEglColorFormatYVU420SemiPlanar_ER = 44 - cudaEglColorFormatBayerRGGB = 45 - cudaEglColorFormatBayerBGGR = 46 - cudaEglColorFormatBayerGRBG = 47 - cudaEglColorFormatBayerGBRG = 48 - cudaEglColorFormatBayer10RGGB = 49 - cudaEglColorFormatBayer10BGGR = 50 - cudaEglColorFormatBayer10GRBG = 51 - cudaEglColorFormatBayer10GBRG = 52 - cudaEglColorFormatBayer12RGGB = 53 - cudaEglColorFormatBayer12BGGR = 54 - cudaEglColorFormatBayer12GRBG = 55 - cudaEglColorFormatBayer12GBRG = 56 - cudaEglColorFormatBayer14RGGB = 57 - cudaEglColorFormatBayer14BGGR = 58 - cudaEglColorFormatBayer14GRBG = 59 - cudaEglColorFormatBayer14GBRG = 60 - cudaEglColorFormatBayer20RGGB = 61 - cudaEglColorFormatBayer20BGGR = 62 - cudaEglColorFormatBayer20GRBG = 63 - cudaEglColorFormatBayer20GBRG = 64 - cudaEglColorFormatYVU444Planar = 65 - cudaEglColorFormatYVU422Planar = 66 - cudaEglColorFormatYVU420Planar = 67 - cudaEglColorFormatBayerIspRGGB = 68 - cudaEglColorFormatBayerIspBGGR = 69 - cudaEglColorFormatBayerIspGRBG = 70 - cudaEglColorFormatBayerIspGBRG = 71 - cudaEglColorFormatBayerBCCR = 72 - cudaEglColorFormatBayerRCCB = 73 - cudaEglColorFormatBayerCRBC = 74 - cudaEglColorFormatBayerCBRC = 75 - cudaEglColorFormatBayer10CCCC = 76 - cudaEglColorFormatBayer12BCCR = 77 - cudaEglColorFormatBayer12RCCB = 78 - cudaEglColorFormatBayer12CRBC = 79 - cudaEglColorFormatBayer12CBRC = 80 - cudaEglColorFormatBayer12CCCC = 81 - cudaEglColorFormatY = 82 - cudaEglColorFormatYUV420SemiPlanar_2020 = 83 - cudaEglColorFormatYVU420SemiPlanar_2020 = 84 - cudaEglColorFormatYUV420Planar_2020 = 85 - cudaEglColorFormatYVU420Planar_2020 = 86 - cudaEglColorFormatYUV420SemiPlanar_709 = 87 - cudaEglColorFormatYVU420SemiPlanar_709 = 88 - cudaEglColorFormatYUV420Planar_709 = 89 - cudaEglColorFormatYVU420Planar_709 = 90 - cudaEglColorFormatY10V10U10_420SemiPlanar_709 = 91 - cudaEglColorFormatY10V10U10_420SemiPlanar_2020 = 92 - cudaEglColorFormatY10V10U10_422SemiPlanar_2020 = 93 - cudaEglColorFormatY10V10U10_422SemiPlanar = 94 - cudaEglColorFormatY10V10U10_422SemiPlanar_709 = 95 - cudaEglColorFormatY_ER = 96 - cudaEglColorFormatY_709_ER = 97 - cudaEglColorFormatY10_ER = 98 - cudaEglColorFormatY10_709_ER = 99 - cudaEglColorFormatY12_ER = 100 - cudaEglColorFormatY12_709_ER = 101 - cudaEglColorFormatYUVA = 102 - cudaEglColorFormatYVYU = 104 - cudaEglColorFormatVYUY = 105 - cudaEglColorFormatY10V10U10_420SemiPlanar_ER = 106 - cudaEglColorFormatY10V10U10_420SemiPlanar_709_ER = 107 - cudaEglColorFormatY10V10U10_444SemiPlanar_ER = 108 - cudaEglColorFormatY10V10U10_444SemiPlanar_709_ER = 109 - cudaEglColorFormatY12V12U12_420SemiPlanar_ER = 110 - cudaEglColorFormatY12V12U12_420SemiPlanar_709_ER = 111 - cudaEglColorFormatY12V12U12_444SemiPlanar_ER = 112 - cudaEglColorFormatY12V12U12_444SemiPlanar_709_ER = 113 - cudaEglColorFormatUYVY709 = 114 - cudaEglColorFormatUYVY709_ER = 115 - cudaEglColorFormatUYVY2020 = 116 - -ctypedef cudaEglColorFormat_enum cudaEglColorFormat - -cdef struct cudaEglPlaneDesc_st: - unsigned int width - unsigned int height - unsigned int depth - unsigned int pitch - unsigned int numChannels - cudaChannelFormatDesc channelDesc - unsigned int reserved[4] - -ctypedef cudaEglPlaneDesc_st cudaEglPlaneDesc - -cdef union anon_union12: - cudaArray_t pArray[3] - cudaPitchedPtr pPitch[3] - -cdef struct cudaEglFrame_st: - anon_union12 frame - cudaEglPlaneDesc planeDesc[3] - unsigned int planeCount - cudaEglFrameType frameType - cudaEglColorFormat eglColorFormat - -ctypedef cudaEglFrame_st cudaEglFrame - -cdef extern from "": - cdef struct CUeglStreamConnection_st: - pass -ctypedef CUeglStreamConnection_st* cudaEglStreamConnection - -cdef enum cudaGLDeviceList: - cudaGLDeviceListAll = 1 - cudaGLDeviceListCurrentFrame = 2 - cudaGLDeviceListNextFrame = 3 - -cdef enum cudaGLMapFlags: - cudaGLMapFlagsNone = 0 - cudaGLMapFlagsReadOnly = 1 - cudaGLMapFlagsWriteDiscard = 2 - -{{if 'cudaDeviceReset' in found_functions}} - -cdef cudaError_t cudaDeviceReset() except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceSynchronize' in found_functions}} - -cdef cudaError_t cudaDeviceSynchronize() except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceSetLimit' in found_functions}} - -cdef cudaError_t cudaDeviceSetLimit(cudaLimit limit, size_t value) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetLimit' in found_functions}} - -cdef cudaError_t cudaDeviceGetLimit(size_t* pValue, cudaLimit limit) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetTexture1DLinearMaxWidth' in found_functions}} - -cdef cudaError_t cudaDeviceGetTexture1DLinearMaxWidth(size_t* maxWidthInElements, const cudaChannelFormatDesc* fmtDesc, int device) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetCacheConfig' in found_functions}} - -cdef cudaError_t cudaDeviceGetCacheConfig(cudaFuncCache* pCacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetStreamPriorityRange' in found_functions}} - -cdef cudaError_t cudaDeviceGetStreamPriorityRange(int* leastPriority, int* greatestPriority) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceSetCacheConfig' in found_functions}} - -cdef cudaError_t cudaDeviceSetCacheConfig(cudaFuncCache cacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetByPCIBusId' in found_functions}} - -cdef cudaError_t cudaDeviceGetByPCIBusId(int* device, const char* pciBusId) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetPCIBusId' in found_functions}} - -cdef cudaError_t cudaDeviceGetPCIBusId(char* pciBusId, int length, int device) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaIpcGetEventHandle' in found_functions}} - -cdef cudaError_t cudaIpcGetEventHandle(cudaIpcEventHandle_t* handle, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaIpcOpenEventHandle' in found_functions}} - -cdef cudaError_t cudaIpcOpenEventHandle(cudaEvent_t* event, cudaIpcEventHandle_t handle) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaIpcGetMemHandle' in found_functions}} - -cdef cudaError_t cudaIpcGetMemHandle(cudaIpcMemHandle_t* handle, void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaIpcOpenMemHandle' in found_functions}} - -cdef cudaError_t cudaIpcOpenMemHandle(void** devPtr, cudaIpcMemHandle_t handle, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaIpcCloseMemHandle' in found_functions}} - -cdef cudaError_t cudaIpcCloseMemHandle(void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceFlushGPUDirectRDMAWrites' in found_functions}} - -cdef cudaError_t cudaDeviceFlushGPUDirectRDMAWrites(cudaFlushGPUDirectRDMAWritesTarget target, cudaFlushGPUDirectRDMAWritesScope scope) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceRegisterAsyncNotification' in found_functions}} - -cdef cudaError_t cudaDeviceRegisterAsyncNotification(int device, cudaAsyncCallback callbackFunc, void* userData, cudaAsyncCallbackHandle_t* callback) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceUnregisterAsyncNotification' in found_functions}} - -cdef cudaError_t cudaDeviceUnregisterAsyncNotification(int device, cudaAsyncCallbackHandle_t callback) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetSharedMemConfig' in found_functions}} - -cdef cudaError_t cudaDeviceGetSharedMemConfig(cudaSharedMemConfig* pConfig) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceSetSharedMemConfig' in found_functions}} - -cdef cudaError_t cudaDeviceSetSharedMemConfig(cudaSharedMemConfig config) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGetLastError' in found_functions}} - -cdef cudaError_t cudaGetLastError() except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaPeekAtLastError' in found_functions}} - -cdef cudaError_t cudaPeekAtLastError() except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGetErrorName' in found_functions}} - -cdef const char* cudaGetErrorName(cudaError_t error) except ?NULL nogil -{{endif}} - -{{if 'cudaGetErrorString' in found_functions}} - -cdef const char* cudaGetErrorString(cudaError_t error) except ?NULL nogil -{{endif}} - -{{if 'cudaGetDeviceCount' in found_functions}} - -cdef cudaError_t cudaGetDeviceCount(int* count) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGetDeviceProperties' in found_functions}} - -cdef cudaError_t cudaGetDeviceProperties(cudaDeviceProp* prop, int device) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetAttribute' in found_functions}} - -cdef cudaError_t cudaDeviceGetAttribute(int* value, cudaDeviceAttr attr, int device) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetHostAtomicCapabilities' in found_functions}} - -cdef cudaError_t cudaDeviceGetHostAtomicCapabilities(unsigned int* capabilities, const cudaAtomicOperation* operations, unsigned int count, int device) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetDefaultMemPool' in found_functions}} - -cdef cudaError_t cudaDeviceGetDefaultMemPool(cudaMemPool_t* memPool, int device) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceSetMemPool' in found_functions}} - -cdef cudaError_t cudaDeviceSetMemPool(int device, cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetMemPool' in found_functions}} - -cdef cudaError_t cudaDeviceGetMemPool(cudaMemPool_t* memPool, int device) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetNvSciSyncAttributes' in found_functions}} - -cdef cudaError_t cudaDeviceGetNvSciSyncAttributes(void* nvSciSyncAttrList, int device, int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetP2PAttribute' in found_functions}} - -cdef cudaError_t cudaDeviceGetP2PAttribute(int* value, cudaDeviceP2PAttr attr, int srcDevice, int dstDevice) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetP2PAtomicCapabilities' in found_functions}} - -cdef cudaError_t cudaDeviceGetP2PAtomicCapabilities(unsigned int* capabilities, const cudaAtomicOperation* operations, unsigned int count, int srcDevice, int dstDevice) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaChooseDevice' in found_functions}} - -cdef cudaError_t cudaChooseDevice(int* device, const cudaDeviceProp* prop) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaInitDevice' in found_functions}} - -cdef cudaError_t cudaInitDevice(int device, unsigned int deviceFlags, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaSetDevice' in found_functions}} - -cdef cudaError_t cudaSetDevice(int device) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGetDevice' in found_functions}} - -cdef cudaError_t cudaGetDevice(int* device) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaSetDeviceFlags' in found_functions}} - -cdef cudaError_t cudaSetDeviceFlags(unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGetDeviceFlags' in found_functions}} - -cdef cudaError_t cudaGetDeviceFlags(unsigned int* flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamCreate' in found_functions}} - -cdef cudaError_t cudaStreamCreate(cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamCreateWithFlags' in found_functions}} - -cdef cudaError_t cudaStreamCreateWithFlags(cudaStream_t* pStream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamCreateWithPriority' in found_functions}} - -cdef cudaError_t cudaStreamCreateWithPriority(cudaStream_t* pStream, unsigned int flags, int priority) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamGetPriority' in found_functions}} - -cdef cudaError_t cudaStreamGetPriority(cudaStream_t hStream, int* priority) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamGetFlags' in found_functions}} - -cdef cudaError_t cudaStreamGetFlags(cudaStream_t hStream, unsigned int* flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamGetId' in found_functions}} - -cdef cudaError_t cudaStreamGetId(cudaStream_t hStream, unsigned long long* streamId) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamGetDevice' in found_functions}} - -cdef cudaError_t cudaStreamGetDevice(cudaStream_t hStream, int* device) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaCtxResetPersistingL2Cache' in found_functions}} - -cdef cudaError_t cudaCtxResetPersistingL2Cache() except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamCopyAttributes' in found_functions}} - -cdef cudaError_t cudaStreamCopyAttributes(cudaStream_t dst, cudaStream_t src) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamGetAttribute' in found_functions}} - -cdef cudaError_t cudaStreamGetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, cudaStreamAttrValue* value_out) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamSetAttribute' in found_functions}} - -cdef cudaError_t cudaStreamSetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, const cudaStreamAttrValue* value) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamDestroy' in found_functions}} - -cdef cudaError_t cudaStreamDestroy(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamWaitEvent' in found_functions}} - -cdef cudaError_t cudaStreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamAddCallback' in found_functions}} - -cdef cudaError_t cudaStreamAddCallback(cudaStream_t stream, cudaStreamCallback_t callback, void* userData, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamSynchronize' in found_functions}} - -cdef cudaError_t cudaStreamSynchronize(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamQuery' in found_functions}} - -cdef cudaError_t cudaStreamQuery(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamAttachMemAsync' in found_functions}} - -cdef cudaError_t cudaStreamAttachMemAsync(cudaStream_t stream, void* devPtr, size_t length, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamBeginCapture' in found_functions}} - -cdef cudaError_t cudaStreamBeginCapture(cudaStream_t stream, cudaStreamCaptureMode mode) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamBeginRecaptureToGraph' in found_functions}} - -cdef cudaError_t cudaStreamBeginRecaptureToGraph(cudaStream_t stream, cudaStreamCaptureMode mode, cudaGraph_t graph, cudaGraphRecaptureCallbackData* callbackData) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamBeginCaptureToGraph' in found_functions}} - -cdef cudaError_t cudaStreamBeginCaptureToGraph(cudaStream_t stream, cudaGraph_t graph, const cudaGraphNode_t* dependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, cudaStreamCaptureMode mode) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaThreadExchangeStreamCaptureMode' in found_functions}} - -cdef cudaError_t cudaThreadExchangeStreamCaptureMode(cudaStreamCaptureMode* mode) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamEndCapture' in found_functions}} - -cdef cudaError_t cudaStreamEndCapture(cudaStream_t stream, cudaGraph_t* pGraph) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamIsCapturing' in found_functions}} - -cdef cudaError_t cudaStreamIsCapturing(cudaStream_t stream, cudaStreamCaptureStatus* pCaptureStatus) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamGetCaptureInfo' in found_functions}} - -cdef cudaError_t cudaStreamGetCaptureInfo(cudaStream_t stream, cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out, cudaGraph_t* graph_out, const cudaGraphNode_t** dependencies_out, const cudaGraphEdgeData** edgeData_out, size_t* numDependencies_out) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamUpdateCaptureDependencies' in found_functions}} - -cdef cudaError_t cudaStreamUpdateCaptureDependencies(cudaStream_t stream, cudaGraphNode_t* dependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaEventCreate' in found_functions}} - -cdef cudaError_t cudaEventCreate(cudaEvent_t* event) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaEventCreateWithFlags' in found_functions}} - -cdef cudaError_t cudaEventCreateWithFlags(cudaEvent_t* event, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaEventRecord' in found_functions}} - -cdef cudaError_t cudaEventRecord(cudaEvent_t event, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaEventRecordWithFlags' in found_functions}} - -cdef cudaError_t cudaEventRecordWithFlags(cudaEvent_t event, cudaStream_t stream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaEventQuery' in found_functions}} - -cdef cudaError_t cudaEventQuery(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaEventSynchronize' in found_functions}} - -cdef cudaError_t cudaEventSynchronize(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaEventDestroy' in found_functions}} - -cdef cudaError_t cudaEventDestroy(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaEventElapsedTime' in found_functions}} - -cdef cudaError_t cudaEventElapsedTime(float* ms, cudaEvent_t start, cudaEvent_t end) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaImportExternalMemory' in found_functions}} - -cdef cudaError_t cudaImportExternalMemory(cudaExternalMemory_t* extMem_out, const cudaExternalMemoryHandleDesc* memHandleDesc) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaExternalMemoryGetMappedBuffer' in found_functions}} - -cdef cudaError_t cudaExternalMemoryGetMappedBuffer(void** devPtr, cudaExternalMemory_t extMem, const cudaExternalMemoryBufferDesc* bufferDesc) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaExternalMemoryGetMappedMipmappedArray' in found_functions}} - -cdef cudaError_t cudaExternalMemoryGetMappedMipmappedArray(cudaMipmappedArray_t* mipmap, cudaExternalMemory_t extMem, const cudaExternalMemoryMipmappedArrayDesc* mipmapDesc) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDestroyExternalMemory' in found_functions}} - -cdef cudaError_t cudaDestroyExternalMemory(cudaExternalMemory_t extMem) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaImportExternalSemaphore' in found_functions}} - -cdef cudaError_t cudaImportExternalSemaphore(cudaExternalSemaphore_t* extSem_out, const cudaExternalSemaphoreHandleDesc* semHandleDesc) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaSignalExternalSemaphoresAsync' in found_functions}} - -cdef cudaError_t cudaSignalExternalSemaphoresAsync(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreSignalParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaWaitExternalSemaphoresAsync' in found_functions}} - -cdef cudaError_t cudaWaitExternalSemaphoresAsync(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreWaitParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDestroyExternalSemaphore' in found_functions}} - -cdef cudaError_t cudaDestroyExternalSemaphore(cudaExternalSemaphore_t extSem) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaFuncSetCacheConfig' in found_functions}} - -cdef cudaError_t cudaFuncSetCacheConfig(const void* func, cudaFuncCache cacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaFuncGetAttributes' in found_functions}} - -cdef cudaError_t cudaFuncGetAttributes(cudaFuncAttributes* attr, const void* func) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaFuncSetAttribute' in found_functions}} - -cdef cudaError_t cudaFuncSetAttribute(const void* func, cudaFuncAttribute attr, int value) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaFuncGetParamCount' in found_functions}} - -cdef cudaError_t cudaFuncGetParamCount(const void* func, size_t* paramCount) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLaunchHostFunc' in found_functions}} - -cdef cudaError_t cudaLaunchHostFunc(cudaStream_t stream, cudaHostFn_t fn, void* userData) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLaunchHostFunc_v2' in found_functions}} - -cdef cudaError_t cudaLaunchHostFunc_v2(cudaStream_t stream, cudaHostFn_t fn, void* userData, unsigned int syncMode) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaFuncSetSharedMemConfig' in found_functions}} - -cdef cudaError_t cudaFuncSetSharedMemConfig(const void* func, cudaSharedMemConfig config) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaOccupancyMaxActiveBlocksPerMultiprocessor' in found_functions}} - -cdef cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessor(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaOccupancyAvailableDynamicSMemPerBlock' in found_functions}} - -cdef cudaError_t cudaOccupancyAvailableDynamicSMemPerBlock(size_t* dynamicSmemSize, const void* func, int numBlocks, int blockSize) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags' in found_functions}} - -cdef cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMallocManaged' in found_functions}} - -cdef cudaError_t cudaMallocManaged(void** devPtr, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMalloc' in found_functions}} - -cdef cudaError_t cudaMalloc(void** devPtr, size_t size) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMallocHost' in found_functions}} - -cdef cudaError_t cudaMallocHost(void** ptr, size_t size) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMallocPitch' in found_functions}} - -cdef cudaError_t cudaMallocPitch(void** devPtr, size_t* pitch, size_t width, size_t height) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMallocArray' in found_functions}} - -cdef cudaError_t cudaMallocArray(cudaArray_t* array, const cudaChannelFormatDesc* desc, size_t width, size_t height, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaFree' in found_functions}} - -cdef cudaError_t cudaFree(void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaFreeHost' in found_functions}} - -cdef cudaError_t cudaFreeHost(void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaFreeArray' in found_functions}} - -cdef cudaError_t cudaFreeArray(cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaFreeMipmappedArray' in found_functions}} - -cdef cudaError_t cudaFreeMipmappedArray(cudaMipmappedArray_t mipmappedArray) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaHostAlloc' in found_functions}} - -cdef cudaError_t cudaHostAlloc(void** pHost, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaHostRegister' in found_functions}} - -cdef cudaError_t cudaHostRegister(void* ptr, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaHostUnregister' in found_functions}} - -cdef cudaError_t cudaHostUnregister(void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaHostGetDevicePointer' in found_functions}} - -cdef cudaError_t cudaHostGetDevicePointer(void** pDevice, void* pHost, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaHostGetFlags' in found_functions}} - -cdef cudaError_t cudaHostGetFlags(unsigned int* pFlags, void* pHost) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMalloc3D' in found_functions}} - -cdef cudaError_t cudaMalloc3D(cudaPitchedPtr* pitchedDevPtr, cudaExtent extent) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMalloc3DArray' in found_functions}} - -cdef cudaError_t cudaMalloc3DArray(cudaArray_t* array, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMallocMipmappedArray' in found_functions}} - -cdef cudaError_t cudaMallocMipmappedArray(cudaMipmappedArray_t* mipmappedArray, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int numLevels, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGetMipmappedArrayLevel' in found_functions}} - -cdef cudaError_t cudaGetMipmappedArrayLevel(cudaArray_t* levelArray, cudaMipmappedArray_const_t mipmappedArray, unsigned int level) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpy3D' in found_functions}} - -cdef cudaError_t cudaMemcpy3D(const cudaMemcpy3DParms* p) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpy3DPeer' in found_functions}} - -cdef cudaError_t cudaMemcpy3DPeer(const cudaMemcpy3DPeerParms* p) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpy3DAsync' in found_functions}} - -cdef cudaError_t cudaMemcpy3DAsync(const cudaMemcpy3DParms* p, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpy3DPeerAsync' in found_functions}} - -cdef cudaError_t cudaMemcpy3DPeerAsync(const cudaMemcpy3DPeerParms* p, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemGetInfo' in found_functions}} - -cdef cudaError_t cudaMemGetInfo(size_t* free, size_t* total) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaArrayGetInfo' in found_functions}} - -cdef cudaError_t cudaArrayGetInfo(cudaChannelFormatDesc* desc, cudaExtent* extent, unsigned int* flags, cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaArrayGetPlane' in found_functions}} - -cdef cudaError_t cudaArrayGetPlane(cudaArray_t* pPlaneArray, cudaArray_t hArray, unsigned int planeIdx) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaArrayGetMemoryRequirements' in found_functions}} - -cdef cudaError_t cudaArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaArray_t array, int device) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMipmappedArrayGetMemoryRequirements' in found_functions}} - -cdef cudaError_t cudaMipmappedArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaMipmappedArray_t mipmap, int device) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaArrayGetSparseProperties' in found_functions}} - -cdef cudaError_t cudaArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMipmappedArrayGetSparseProperties' in found_functions}} - -cdef cudaError_t cudaMipmappedArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaMipmappedArray_t mipmap) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpy' in found_functions}} - -cdef cudaError_t cudaMemcpy(void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpyPeer' in found_functions}} - -cdef cudaError_t cudaMemcpyPeer(void* dst, int dstDevice, const void* src, int srcDevice, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpy2D' in found_functions}} - -cdef cudaError_t cudaMemcpy2D(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpy2DToArray' in found_functions}} - -cdef cudaError_t cudaMemcpy2DToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpy2DFromArray' in found_functions}} - -cdef cudaError_t cudaMemcpy2DFromArray(void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpy2DArrayToArray' in found_functions}} - -cdef cudaError_t cudaMemcpy2DArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpyAsync' in found_functions}} - -cdef cudaError_t cudaMemcpyAsync(void* dst, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpyPeerAsync' in found_functions}} - -cdef cudaError_t cudaMemcpyPeerAsync(void* dst, int dstDevice, const void* src, int srcDevice, size_t count, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpyBatchAsync' in found_functions}} - -cdef cudaError_t cudaMemcpyBatchAsync(const void** dsts, const void** srcs, const size_t* sizes, size_t count, cudaMemcpyAttributes* attrs, size_t* attrsIdxs, size_t numAttrs, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpy3DBatchAsync' in found_functions}} - -cdef cudaError_t cudaMemcpy3DBatchAsync(size_t numOps, cudaMemcpy3DBatchOp* opList, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpyWithAttributesAsync' in found_functions}} - -cdef cudaError_t cudaMemcpyWithAttributesAsync(void* dst, const void* src, size_t size, cudaMemcpyAttributes* attr, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpy3DWithAttributesAsync' in found_functions}} - -cdef cudaError_t cudaMemcpy3DWithAttributesAsync(cudaMemcpy3DBatchOp* op, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpy2DAsync' in found_functions}} - -cdef cudaError_t cudaMemcpy2DAsync(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpy2DToArrayAsync' in found_functions}} - -cdef cudaError_t cudaMemcpy2DToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpy2DFromArrayAsync' in found_functions}} - -cdef cudaError_t cudaMemcpy2DFromArrayAsync(void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemset' in found_functions}} - -cdef cudaError_t cudaMemset(void* devPtr, int value, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemset2D' in found_functions}} - -cdef cudaError_t cudaMemset2D(void* devPtr, size_t pitch, int value, size_t width, size_t height) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemset3D' in found_functions}} - -cdef cudaError_t cudaMemset3D(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemsetAsync' in found_functions}} - -cdef cudaError_t cudaMemsetAsync(void* devPtr, int value, size_t count, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemset2DAsync' in found_functions}} - -cdef cudaError_t cudaMemset2DAsync(void* devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemset3DAsync' in found_functions}} - -cdef cudaError_t cudaMemset3DAsync(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemPrefetchAsync' in found_functions}} - -cdef cudaError_t cudaMemPrefetchAsync(const void* devPtr, size_t count, cudaMemLocation location, unsigned int flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemPrefetchBatchAsync' in found_functions}} - -cdef cudaError_t cudaMemPrefetchBatchAsync(void** dptrs, size_t* sizes, size_t count, cudaMemLocation* prefetchLocs, size_t* prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemDiscardBatchAsync' in found_functions}} - -cdef cudaError_t cudaMemDiscardBatchAsync(void** dptrs, size_t* sizes, size_t count, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemDiscardAndPrefetchBatchAsync' in found_functions}} - -cdef cudaError_t cudaMemDiscardAndPrefetchBatchAsync(void** dptrs, size_t* sizes, size_t count, cudaMemLocation* prefetchLocs, size_t* prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemAdvise' in found_functions}} - -cdef cudaError_t cudaMemAdvise(const void* devPtr, size_t count, cudaMemoryAdvise advice, cudaMemLocation location) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemRangeGetAttribute' in found_functions}} - -cdef cudaError_t cudaMemRangeGetAttribute(void* data, size_t dataSize, cudaMemRangeAttribute attribute, const void* devPtr, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemRangeGetAttributes' in found_functions}} - -cdef cudaError_t cudaMemRangeGetAttributes(void** data, size_t* dataSizes, cudaMemRangeAttribute* attributes, size_t numAttributes, const void* devPtr, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpyToArray' in found_functions}} - -cdef cudaError_t cudaMemcpyToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpyFromArray' in found_functions}} - -cdef cudaError_t cudaMemcpyFromArray(void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpyArrayToArray' in found_functions}} - -cdef cudaError_t cudaMemcpyArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpyToArrayAsync' in found_functions}} - -cdef cudaError_t cudaMemcpyToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemcpyFromArrayAsync' in found_functions}} - -cdef cudaError_t cudaMemcpyFromArrayAsync(void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMallocAsync' in found_functions}} - -cdef cudaError_t cudaMallocAsync(void** devPtr, size_t size, cudaStream_t hStream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaFreeAsync' in found_functions}} - -cdef cudaError_t cudaFreeAsync(void* devPtr, cudaStream_t hStream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemPoolTrimTo' in found_functions}} - -cdef cudaError_t cudaMemPoolTrimTo(cudaMemPool_t memPool, size_t minBytesToKeep) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemPoolSetAttribute' in found_functions}} - -cdef cudaError_t cudaMemPoolSetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemPoolGetAttribute' in found_functions}} - -cdef cudaError_t cudaMemPoolGetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemPoolSetAccess' in found_functions}} - -cdef cudaError_t cudaMemPoolSetAccess(cudaMemPool_t memPool, const cudaMemAccessDesc* descList, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemPoolGetAccess' in found_functions}} - -cdef cudaError_t cudaMemPoolGetAccess(cudaMemAccessFlags* flags, cudaMemPool_t memPool, cudaMemLocation* location) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemPoolCreate' in found_functions}} - -cdef cudaError_t cudaMemPoolCreate(cudaMemPool_t* memPool, const cudaMemPoolProps* poolProps) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemPoolDestroy' in found_functions}} - -cdef cudaError_t cudaMemPoolDestroy(cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemGetDefaultMemPool' in found_functions}} - -cdef cudaError_t cudaMemGetDefaultMemPool(cudaMemPool_t* memPool, cudaMemLocation* location, cudaMemAllocationType typename) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemGetMemPool' in found_functions}} - -cdef cudaError_t cudaMemGetMemPool(cudaMemPool_t* memPool, cudaMemLocation* location, cudaMemAllocationType typename) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemSetMemPool' in found_functions}} - -cdef cudaError_t cudaMemSetMemPool(cudaMemLocation* location, cudaMemAllocationType typename, cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMallocFromPoolAsync' in found_functions}} - -cdef cudaError_t cudaMallocFromPoolAsync(void** ptr, size_t size, cudaMemPool_t memPool, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemPoolExportToShareableHandle' in found_functions}} - -cdef cudaError_t cudaMemPoolExportToShareableHandle(void* shareableHandle, cudaMemPool_t memPool, cudaMemAllocationHandleType handleType, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemPoolImportFromShareableHandle' in found_functions}} - -cdef cudaError_t cudaMemPoolImportFromShareableHandle(cudaMemPool_t* memPool, void* shareableHandle, cudaMemAllocationHandleType handleType, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemPoolExportPointer' in found_functions}} - -cdef cudaError_t cudaMemPoolExportPointer(cudaMemPoolPtrExportData* exportData, void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaMemPoolImportPointer' in found_functions}} - -cdef cudaError_t cudaMemPoolImportPointer(void** ptr, cudaMemPool_t memPool, cudaMemPoolPtrExportData* exportData) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaPointerGetAttributes' in found_functions}} - -cdef cudaError_t cudaPointerGetAttributes(cudaPointerAttributes* attributes, const void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceCanAccessPeer' in found_functions}} - -cdef cudaError_t cudaDeviceCanAccessPeer(int* canAccessPeer, int device, int peerDevice) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceEnablePeerAccess' in found_functions}} - -cdef cudaError_t cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceDisablePeerAccess' in found_functions}} - -cdef cudaError_t cudaDeviceDisablePeerAccess(int peerDevice) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphicsUnregisterResource' in found_functions}} - -cdef cudaError_t cudaGraphicsUnregisterResource(cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphicsResourceSetMapFlags' in found_functions}} - -cdef cudaError_t cudaGraphicsResourceSetMapFlags(cudaGraphicsResource_t resource, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphicsMapResources' in found_functions}} - -cdef cudaError_t cudaGraphicsMapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphicsUnmapResources' in found_functions}} - -cdef cudaError_t cudaGraphicsUnmapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphicsResourceGetMappedPointer' in found_functions}} - -cdef cudaError_t cudaGraphicsResourceGetMappedPointer(void** devPtr, size_t* size, cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphicsSubResourceGetMappedArray' in found_functions}} - -cdef cudaError_t cudaGraphicsSubResourceGetMappedArray(cudaArray_t* array, cudaGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphicsResourceGetMappedMipmappedArray' in found_functions}} - -cdef cudaError_t cudaGraphicsResourceGetMappedMipmappedArray(cudaMipmappedArray_t* mipmappedArray, cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGetChannelDesc' in found_functions}} - -cdef cudaError_t cudaGetChannelDesc(cudaChannelFormatDesc* desc, cudaArray_const_t array) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaCreateChannelDesc' in found_functions}} - -cdef cudaChannelFormatDesc cudaCreateChannelDesc(int x, int y, int z, int w, cudaChannelFormatKind f) except* nogil -{{endif}} - -{{if 'cudaCreateTextureObject' in found_functions}} - -cdef cudaError_t cudaCreateTextureObject(cudaTextureObject_t* pTexObject, const cudaResourceDesc* pResDesc, const cudaTextureDesc* pTexDesc, const cudaResourceViewDesc* pResViewDesc) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDestroyTextureObject' in found_functions}} - -cdef cudaError_t cudaDestroyTextureObject(cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGetTextureObjectResourceDesc' in found_functions}} - -cdef cudaError_t cudaGetTextureObjectResourceDesc(cudaResourceDesc* pResDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGetTextureObjectTextureDesc' in found_functions}} - -cdef cudaError_t cudaGetTextureObjectTextureDesc(cudaTextureDesc* pTexDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGetTextureObjectResourceViewDesc' in found_functions}} - -cdef cudaError_t cudaGetTextureObjectResourceViewDesc(cudaResourceViewDesc* pResViewDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaCreateSurfaceObject' in found_functions}} - -cdef cudaError_t cudaCreateSurfaceObject(cudaSurfaceObject_t* pSurfObject, const cudaResourceDesc* pResDesc) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDestroySurfaceObject' in found_functions}} - -cdef cudaError_t cudaDestroySurfaceObject(cudaSurfaceObject_t surfObject) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGetSurfaceObjectResourceDesc' in found_functions}} - -cdef cudaError_t cudaGetSurfaceObjectResourceDesc(cudaResourceDesc* pResDesc, cudaSurfaceObject_t surfObject) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDriverGetVersion' in found_functions}} - -cdef cudaError_t cudaDriverGetVersion(int* driverVersion) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaRuntimeGetVersion' in found_functions}} - -cdef cudaError_t cudaRuntimeGetVersion(int* runtimeVersion) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLogsRegisterCallback' in found_functions}} - -cdef cudaError_t cudaLogsRegisterCallback(cudaLogsCallback_t callbackFunc, void* userData, cudaLogsCallbackHandle* callback_out) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLogsUnregisterCallback' in found_functions}} - -cdef cudaError_t cudaLogsUnregisterCallback(cudaLogsCallbackHandle callback) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLogsCurrent' in found_functions}} - -cdef cudaError_t cudaLogsCurrent(cudaLogIterator* iterator_out, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLogsDumpToFile' in found_functions}} - -cdef cudaError_t cudaLogsDumpToFile(cudaLogIterator* iterator, const char* pathToFile, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLogsDumpToMemory' in found_functions}} - -cdef cudaError_t cudaLogsDumpToMemory(cudaLogIterator* iterator, char* buffer, size_t* size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphCreate' in found_functions}} - -cdef cudaError_t cudaGraphCreate(cudaGraph_t* pGraph, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphAddKernelNode' in found_functions}} - -cdef cudaError_t cudaGraphAddKernelNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphKernelNodeGetParams' in found_functions}} - -cdef cudaError_t cudaGraphKernelNodeGetParams(cudaGraphNode_t node, cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphKernelNodeSetParams' in found_functions}} - -cdef cudaError_t cudaGraphKernelNodeSetParams(cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphKernelNodeCopyAttributes' in found_functions}} - -cdef cudaError_t cudaGraphKernelNodeCopyAttributes(cudaGraphNode_t hDst, cudaGraphNode_t hSrc) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphKernelNodeGetAttribute' in found_functions}} - -cdef cudaError_t cudaGraphKernelNodeGetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, cudaKernelNodeAttrValue* value_out) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphKernelNodeSetAttribute' in found_functions}} - -cdef cudaError_t cudaGraphKernelNodeSetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, const cudaKernelNodeAttrValue* value) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphAddMemcpyNode' in found_functions}} - -cdef cudaError_t cudaGraphAddMemcpyNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemcpy3DParms* pCopyParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphAddMemcpyNode1D' in found_functions}} - -cdef cudaError_t cudaGraphAddMemcpyNode1D(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphMemcpyNodeGetParams' in found_functions}} - -cdef cudaError_t cudaGraphMemcpyNodeGetParams(cudaGraphNode_t node, cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphMemcpyNodeSetParams' in found_functions}} - -cdef cudaError_t cudaGraphMemcpyNodeSetParams(cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphMemcpyNodeSetParams1D' in found_functions}} - -cdef cudaError_t cudaGraphMemcpyNodeSetParams1D(cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphAddMemsetNode' in found_functions}} - -cdef cudaError_t cudaGraphAddMemsetNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemsetParams* pMemsetParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphMemsetNodeGetParams' in found_functions}} - -cdef cudaError_t cudaGraphMemsetNodeGetParams(cudaGraphNode_t node, cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphMemsetNodeSetParams' in found_functions}} - -cdef cudaError_t cudaGraphMemsetNodeSetParams(cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphAddHostNode' in found_functions}} - -cdef cudaError_t cudaGraphAddHostNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphHostNodeGetParams' in found_functions}} - -cdef cudaError_t cudaGraphHostNodeGetParams(cudaGraphNode_t node, cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphHostNodeSetParams' in found_functions}} - -cdef cudaError_t cudaGraphHostNodeSetParams(cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphAddChildGraphNode' in found_functions}} - -cdef cudaError_t cudaGraphAddChildGraphNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaGraph_t childGraph) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphChildGraphNodeGetGraph' in found_functions}} - -cdef cudaError_t cudaGraphChildGraphNodeGetGraph(cudaGraphNode_t node, cudaGraph_t* pGraph) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphAddEmptyNode' in found_functions}} - -cdef cudaError_t cudaGraphAddEmptyNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphAddEventRecordNode' in found_functions}} - -cdef cudaError_t cudaGraphAddEventRecordNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphEventRecordNodeGetEvent' in found_functions}} - -cdef cudaError_t cudaGraphEventRecordNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphEventRecordNodeSetEvent' in found_functions}} - -cdef cudaError_t cudaGraphEventRecordNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphAddEventWaitNode' in found_functions}} - -cdef cudaError_t cudaGraphAddEventWaitNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphEventWaitNodeGetEvent' in found_functions}} - -cdef cudaError_t cudaGraphEventWaitNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphEventWaitNodeSetEvent' in found_functions}} - -cdef cudaError_t cudaGraphEventWaitNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphAddExternalSemaphoresSignalNode' in found_functions}} - -cdef cudaError_t cudaGraphAddExternalSemaphoresSignalNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExternalSemaphoresSignalNodeGetParams' in found_functions}} - -cdef cudaError_t cudaGraphExternalSemaphoresSignalNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreSignalNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExternalSemaphoresSignalNodeSetParams' in found_functions}} - -cdef cudaError_t cudaGraphExternalSemaphoresSignalNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphAddExternalSemaphoresWaitNode' in found_functions}} - -cdef cudaError_t cudaGraphAddExternalSemaphoresWaitNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExternalSemaphoresWaitNodeGetParams' in found_functions}} - -cdef cudaError_t cudaGraphExternalSemaphoresWaitNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreWaitNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExternalSemaphoresWaitNodeSetParams' in found_functions}} - -cdef cudaError_t cudaGraphExternalSemaphoresWaitNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphAddMemAllocNode' in found_functions}} - -cdef cudaError_t cudaGraphAddMemAllocNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaMemAllocNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphMemAllocNodeGetParams' in found_functions}} - -cdef cudaError_t cudaGraphMemAllocNodeGetParams(cudaGraphNode_t node, cudaMemAllocNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphAddMemFreeNode' in found_functions}} - -cdef cudaError_t cudaGraphAddMemFreeNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dptr) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphMemFreeNodeGetParams' in found_functions}} - -cdef cudaError_t cudaGraphMemFreeNodeGetParams(cudaGraphNode_t node, void* dptr_out) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGraphMemTrim' in found_functions}} - -cdef cudaError_t cudaDeviceGraphMemTrim(int device) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetGraphMemAttribute' in found_functions}} - -cdef cudaError_t cudaDeviceGetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceSetGraphMemAttribute' in found_functions}} - -cdef cudaError_t cudaDeviceSetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphClone' in found_functions}} - -cdef cudaError_t cudaGraphClone(cudaGraph_t* pGraphClone, cudaGraph_t originalGraph) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphNodeFindInClone' in found_functions}} - -cdef cudaError_t cudaGraphNodeFindInClone(cudaGraphNode_t* pNode, cudaGraphNode_t originalNode, cudaGraph_t clonedGraph) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphNodeGetType' in found_functions}} - -cdef cudaError_t cudaGraphNodeGetType(cudaGraphNode_t node, cudaGraphNodeType* pType) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphNodeGetContainingGraph' in found_functions}} - -cdef cudaError_t cudaGraphNodeGetContainingGraph(cudaGraphNode_t hNode, cudaGraph_t* phGraph) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphNodeGetLocalId' in found_functions}} - -cdef cudaError_t cudaGraphNodeGetLocalId(cudaGraphNode_t hNode, unsigned int* nodeId) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphNodeGetToolsId' in found_functions}} - -cdef cudaError_t cudaGraphNodeGetToolsId(cudaGraphNode_t hNode, unsigned long long* toolsNodeId) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphGetId' in found_functions}} - -cdef cudaError_t cudaGraphGetId(cudaGraph_t hGraph, unsigned int* graphID) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExecGetId' in found_functions}} - -cdef cudaError_t cudaGraphExecGetId(cudaGraphExec_t hGraphExec, unsigned int* graphID) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphGetNodes' in found_functions}} - -cdef cudaError_t cudaGraphGetNodes(cudaGraph_t graph, cudaGraphNode_t* nodes, size_t* numNodes) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphGetRootNodes' in found_functions}} - -cdef cudaError_t cudaGraphGetRootNodes(cudaGraph_t graph, cudaGraphNode_t* pRootNodes, size_t* pNumRootNodes) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphGetEdges' in found_functions}} - -cdef cudaError_t cudaGraphGetEdges(cudaGraph_t graph, cudaGraphNode_t* from_, cudaGraphNode_t* to, cudaGraphEdgeData* edgeData, size_t* numEdges) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphNodeGetDependencies' in found_functions}} - -cdef cudaError_t cudaGraphNodeGetDependencies(cudaGraphNode_t node, cudaGraphNode_t* pDependencies, cudaGraphEdgeData* edgeData, size_t* pNumDependencies) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphNodeGetDependentNodes' in found_functions}} - -cdef cudaError_t cudaGraphNodeGetDependentNodes(cudaGraphNode_t node, cudaGraphNode_t* pDependentNodes, cudaGraphEdgeData* edgeData, size_t* pNumDependentNodes) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphAddDependencies' in found_functions}} - -cdef cudaError_t cudaGraphAddDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, const cudaGraphEdgeData* edgeData, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphRemoveDependencies' in found_functions}} - -cdef cudaError_t cudaGraphRemoveDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, const cudaGraphEdgeData* edgeData, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphDestroyNode' in found_functions}} - -cdef cudaError_t cudaGraphDestroyNode(cudaGraphNode_t node) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphInstantiate' in found_functions}} - -cdef cudaError_t cudaGraphInstantiate(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphInstantiateWithFlags' in found_functions}} - -cdef cudaError_t cudaGraphInstantiateWithFlags(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphInstantiateWithParams' in found_functions}} - -cdef cudaError_t cudaGraphInstantiateWithParams(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, cudaGraphInstantiateParams* instantiateParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExecGetFlags' in found_functions}} - -cdef cudaError_t cudaGraphExecGetFlags(cudaGraphExec_t graphExec, unsigned long long* flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExecKernelNodeSetParams' in found_functions}} - -cdef cudaError_t cudaGraphExecKernelNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExecMemcpyNodeSetParams' in found_functions}} - -cdef cudaError_t cudaGraphExecMemcpyNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExecMemcpyNodeSetParams1D' in found_functions}} - -cdef cudaError_t cudaGraphExecMemcpyNodeSetParams1D(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExecMemsetNodeSetParams' in found_functions}} - -cdef cudaError_t cudaGraphExecMemsetNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExecHostNodeSetParams' in found_functions}} - -cdef cudaError_t cudaGraphExecHostNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExecChildGraphNodeSetParams' in found_functions}} - -cdef cudaError_t cudaGraphExecChildGraphNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, cudaGraph_t childGraph) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExecEventRecordNodeSetEvent' in found_functions}} - -cdef cudaError_t cudaGraphExecEventRecordNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExecEventWaitNodeSetEvent' in found_functions}} - -cdef cudaError_t cudaGraphExecEventWaitNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExecExternalSemaphoresSignalNodeSetParams' in found_functions}} - -cdef cudaError_t cudaGraphExecExternalSemaphoresSignalNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExecExternalSemaphoresWaitNodeSetParams' in found_functions}} - -cdef cudaError_t cudaGraphExecExternalSemaphoresWaitNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphNodeSetEnabled' in found_functions}} - -cdef cudaError_t cudaGraphNodeSetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int isEnabled) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphNodeGetEnabled' in found_functions}} - -cdef cudaError_t cudaGraphNodeGetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int* isEnabled) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExecUpdate' in found_functions}} - -cdef cudaError_t cudaGraphExecUpdate(cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphExecUpdateResultInfo* resultInfo) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphUpload' in found_functions}} - -cdef cudaError_t cudaGraphUpload(cudaGraphExec_t graphExec, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphLaunch' in found_functions}} - -cdef cudaError_t cudaGraphLaunch(cudaGraphExec_t graphExec, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExecDestroy' in found_functions}} - -cdef cudaError_t cudaGraphExecDestroy(cudaGraphExec_t graphExec) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphDestroy' in found_functions}} - -cdef cudaError_t cudaGraphDestroy(cudaGraph_t graph) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphDebugDotPrint' in found_functions}} - -cdef cudaError_t cudaGraphDebugDotPrint(cudaGraph_t graph, const char* path, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaUserObjectCreate' in found_functions}} - -cdef cudaError_t cudaUserObjectCreate(cudaUserObject_t* object_out, void* ptr, cudaHostFn_t destroy, unsigned int initialRefcount, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaUserObjectRetain' in found_functions}} - -cdef cudaError_t cudaUserObjectRetain(cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaUserObjectRelease' in found_functions}} - -cdef cudaError_t cudaUserObjectRelease(cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphRetainUserObject' in found_functions}} - -cdef cudaError_t cudaGraphRetainUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphReleaseUserObject' in found_functions}} - -cdef cudaError_t cudaGraphReleaseUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphAddNode' in found_functions}} - -cdef cudaError_t cudaGraphAddNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphNodeSetParams' in found_functions}} - -cdef cudaError_t cudaGraphNodeSetParams(cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphNodeGetParams' in found_functions}} - -cdef cudaError_t cudaGraphNodeGetParams(cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphExecNodeSetParams' in found_functions}} - -cdef cudaError_t cudaGraphExecNodeSetParams(cudaGraphExec_t graphExec, cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphConditionalHandleCreate' in found_functions}} - -cdef cudaError_t cudaGraphConditionalHandleCreate(cudaGraphConditionalHandle* pHandle_out, cudaGraph_t graph, unsigned int defaultLaunchValue, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGraphConditionalHandleCreate_v2' in found_functions}} - -cdef cudaError_t cudaGraphConditionalHandleCreate_v2(cudaGraphConditionalHandle* pHandle_out, cudaGraph_t graph, cudaExecutionContext_t ctx, unsigned int defaultLaunchValue, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGetDriverEntryPoint' in found_functions}} - -cdef cudaError_t cudaGetDriverEntryPoint(const char* symbol, void** funcPtr, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGetDriverEntryPointByVersion' in found_functions}} - -cdef cudaError_t cudaGetDriverEntryPointByVersion(const char* symbol, void** funcPtr, unsigned int cudaVersion, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLibraryLoadData' in found_functions}} - -cdef cudaError_t cudaLibraryLoadData(cudaLibrary_t* library, const void* code, cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLibraryLoadFromFile' in found_functions}} - -cdef cudaError_t cudaLibraryLoadFromFile(cudaLibrary_t* library, const char* fileName, cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLibraryUnload' in found_functions}} - -cdef cudaError_t cudaLibraryUnload(cudaLibrary_t library) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLibraryGetKernel' in found_functions}} - -cdef cudaError_t cudaLibraryGetKernel(cudaKernel_t* pKernel, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLibraryGetGlobal' in found_functions}} - -cdef cudaError_t cudaLibraryGetGlobal(void** dptr, size_t* numbytes, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLibraryGetManaged' in found_functions}} - -cdef cudaError_t cudaLibraryGetManaged(void** dptr, size_t* numbytes, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLibraryGetUnifiedFunction' in found_functions}} - -cdef cudaError_t cudaLibraryGetUnifiedFunction(void** fptr, cudaLibrary_t library, const char* symbol) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLibraryGetKernelCount' in found_functions}} - -cdef cudaError_t cudaLibraryGetKernelCount(unsigned int* count, cudaLibrary_t lib) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaLibraryEnumerateKernels' in found_functions}} - -cdef cudaError_t cudaLibraryEnumerateKernels(cudaKernel_t* kernels, unsigned int numKernels, cudaLibrary_t lib) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaKernelSetAttributeForDevice' in found_functions}} - -cdef cudaError_t cudaKernelSetAttributeForDevice(cudaKernel_t kernel, cudaFuncAttribute attr, int value, int device) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetDevResource' in found_functions}} - -cdef cudaError_t cudaDeviceGetDevResource(int device, cudaDevResource* resource, cudaDevResourceType typename) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDevSmResourceSplitByCount' in found_functions}} - -cdef cudaError_t cudaDevSmResourceSplitByCount(cudaDevResource* result, unsigned int* nbGroups, const cudaDevResource* input, cudaDevResource* remaining, unsigned int flags, unsigned int minCount) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDevSmResourceSplit' in found_functions}} - -cdef cudaError_t cudaDevSmResourceSplit(cudaDevResource* result, unsigned int nbGroups, const cudaDevResource* input, cudaDevResource* remainder, unsigned int flags, cudaDevSmResourceGroupParams* groupParams) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDevResourceGenerateDesc' in found_functions}} - -cdef cudaError_t cudaDevResourceGenerateDesc(cudaDevResourceDesc_t* phDesc, cudaDevResource* resources, unsigned int nbResources) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGreenCtxCreate' in found_functions}} - -cdef cudaError_t cudaGreenCtxCreate(cudaExecutionContext_t* phCtx, cudaDevResourceDesc_t desc, int device, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaExecutionCtxDestroy' in found_functions}} - -cdef cudaError_t cudaExecutionCtxDestroy(cudaExecutionContext_t ctx) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaExecutionCtxGetDevResource' in found_functions}} - -cdef cudaError_t cudaExecutionCtxGetDevResource(cudaExecutionContext_t ctx, cudaDevResource* resource, cudaDevResourceType typename) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaExecutionCtxGetDevice' in found_functions}} - -cdef cudaError_t cudaExecutionCtxGetDevice(int* device, cudaExecutionContext_t ctx) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaExecutionCtxGetId' in found_functions}} - -cdef cudaError_t cudaExecutionCtxGetId(cudaExecutionContext_t ctx, unsigned long long* ctxId) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaExecutionCtxStreamCreate' in found_functions}} - -cdef cudaError_t cudaExecutionCtxStreamCreate(cudaStream_t* phStream, cudaExecutionContext_t ctx, unsigned int flags, int priority) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaExecutionCtxSynchronize' in found_functions}} - -cdef cudaError_t cudaExecutionCtxSynchronize(cudaExecutionContext_t ctx) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaStreamGetDevResource' in found_functions}} - -cdef cudaError_t cudaStreamGetDevResource(cudaStream_t hStream, cudaDevResource* resource, cudaDevResourceType typename) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaExecutionCtxRecordEvent' in found_functions}} - -cdef cudaError_t cudaExecutionCtxRecordEvent(cudaExecutionContext_t ctx, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaExecutionCtxWaitEvent' in found_functions}} - -cdef cudaError_t cudaExecutionCtxWaitEvent(cudaExecutionContext_t ctx, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaDeviceGetExecutionCtx' in found_functions}} - -cdef cudaError_t cudaDeviceGetExecutionCtx(cudaExecutionContext_t* ctx, int device) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGetExportTable' in found_functions}} - -cdef cudaError_t cudaGetExportTable(const void** ppExportTable, const cudaUUID_t* pExportTableId) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaGetKernel' in found_functions}} - -cdef cudaError_t cudaGetKernel(cudaKernel_t* kernelPtr, const void* entryFuncAddr) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'make_cudaPitchedPtr' in found_functions}} - -cdef cudaPitchedPtr make_cudaPitchedPtr(void* d, size_t p, size_t xsz, size_t ysz) except* nogil -{{endif}} - -{{if 'make_cudaPos' in found_functions}} - -cdef cudaPos make_cudaPos(size_t x, size_t y, size_t z) except* nogil -{{endif}} - -{{if 'make_cudaExtent' in found_functions}} - -cdef cudaExtent make_cudaExtent(size_t w, size_t h, size_t d) except* nogil -{{endif}} - -{{if True}} - -cdef cudaError_t cudaGraphicsEGLRegisterImage(cudaGraphicsResource** pCudaResource, EGLImageKHR image, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if True}} - -cdef cudaError_t cudaEGLStreamConsumerConnect(cudaEglStreamConnection* conn, EGLStreamKHR eglStream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if True}} - -cdef cudaError_t cudaEGLStreamConsumerConnectWithFlags(cudaEglStreamConnection* conn, EGLStreamKHR eglStream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if True}} - -cdef cudaError_t cudaEGLStreamConsumerDisconnect(cudaEglStreamConnection* conn) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if True}} - -cdef cudaError_t cudaEGLStreamConsumerAcquireFrame(cudaEglStreamConnection* conn, cudaGraphicsResource_t* pCudaResource, cudaStream_t* pStream, unsigned int timeout) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if True}} - -cdef cudaError_t cudaEGLStreamConsumerReleaseFrame(cudaEglStreamConnection* conn, cudaGraphicsResource_t pCudaResource, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if True}} - -cdef cudaError_t cudaEGLStreamProducerConnect(cudaEglStreamConnection* conn, EGLStreamKHR eglStream, EGLint width, EGLint height) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if True}} - -cdef cudaError_t cudaEGLStreamProducerDisconnect(cudaEglStreamConnection* conn) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if True}} - -cdef cudaError_t cudaEGLStreamProducerPresentFrame(cudaEglStreamConnection* conn, cudaEglFrame eglframe, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if True}} - -cdef cudaError_t cudaEGLStreamProducerReturnFrame(cudaEglStreamConnection* conn, cudaEglFrame* eglframe, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if True}} - -cdef cudaError_t cudaGraphicsResourceGetMappedEglFrame(cudaEglFrame* eglFrame, cudaGraphicsResource_t resource, unsigned int index, unsigned int mipLevel) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if True}} - -cdef cudaError_t cudaEventCreateFromEGLSync(cudaEvent_t* phEvent, EGLSyncKHR eglSync, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaProfilerStart' in found_functions}} - -cdef cudaError_t cudaProfilerStart() except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if 'cudaProfilerStop' in found_functions}} - -cdef cudaError_t cudaProfilerStop() except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if True}} - -cdef cudaError_t cudaGLGetDevices(unsigned int* pCudaDeviceCount, int* pCudaDevices, unsigned int cudaDeviceCount, cudaGLDeviceList deviceList) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if True}} - -cdef cudaError_t cudaGraphicsGLRegisterImage(cudaGraphicsResource** resource, GLuint image, GLenum target, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if True}} - -cdef cudaError_t cudaGraphicsGLRegisterBuffer(cudaGraphicsResource** resource, GLuint buffer, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if True}} - -cdef cudaError_t cudaVDPAUGetDevice(int* device, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if True}} - -cdef cudaError_t cudaVDPAUSetVDPAUDevice(int device, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if True}} - -cdef cudaError_t cudaGraphicsVDPAURegisterVideoSurface(cudaGraphicsResource** resource, VdpVideoSurface vdpSurface, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if True}} - -cdef cudaError_t cudaGraphicsVDPAURegisterOutputSurface(cudaGraphicsResource** resource, VdpOutputSurface vdpSurface, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -{{if True}} - -cdef cudaError_t getLocalRuntimeVersion(int* runtimeVersion) except ?cudaErrorCallRequiresNewerDriver nogil -{{endif}} - -cdef enum: cudaHostAllocDefault = 0 - -cdef enum: cudaHostAllocPortable = 1 - -cdef enum: cudaHostAllocMapped = 2 - -cdef enum: cudaHostAllocWriteCombined = 4 - -cdef enum: cudaHostRegisterDefault = 0 - -cdef enum: cudaHostRegisterPortable = 1 - -cdef enum: cudaHostRegisterMapped = 2 - -cdef enum: cudaHostRegisterIoMemory = 4 - -cdef enum: cudaHostRegisterReadOnly = 8 - -cdef enum: cudaPeerAccessDefault = 0 - -cdef enum: cudaStreamDefault = 0 - -cdef enum: cudaStreamNonBlocking = 1 - -cdef enum: cudaStreamLegacy = 1 - -cdef enum: cudaStreamPerThread = 2 - -cdef enum: cudaEventDefault = 0 - -cdef enum: cudaEventBlockingSync = 1 - -cdef enum: cudaEventDisableTiming = 2 - -cdef enum: cudaEventInterprocess = 4 - -cdef enum: cudaEventRecordDefault = 0 - -cdef enum: cudaEventRecordExternal = 1 - -cdef enum: cudaEventWaitDefault = 0 - -cdef enum: cudaEventWaitExternal = 1 - -cdef enum: cudaDeviceScheduleAuto = 0 - -cdef enum: cudaDeviceScheduleSpin = 1 - -cdef enum: cudaDeviceScheduleYield = 2 - -cdef enum: cudaDeviceScheduleBlockingSync = 4 - -cdef enum: cudaDeviceBlockingSync = 4 - -cdef enum: cudaDeviceScheduleMask = 7 - -cdef enum: cudaDeviceMapHost = 8 - -cdef enum: cudaDeviceLmemResizeToMax = 16 - -cdef enum: cudaDeviceSyncMemops = 128 - -cdef enum: cudaDeviceMask = 255 - -cdef enum: cudaArrayDefault = 0 - -cdef enum: cudaArrayLayered = 1 - -cdef enum: cudaArraySurfaceLoadStore = 2 - -cdef enum: cudaArrayCubemap = 4 - -cdef enum: cudaArrayTextureGather = 8 - -cdef enum: cudaArrayColorAttachment = 32 - -cdef enum: cudaArraySparse = 64 - -cdef enum: cudaArrayDeferredMapping = 128 - -cdef enum: cudaIpcMemLazyEnablePeerAccess = 1 - -cdef enum: cudaMemAttachGlobal = 1 - -cdef enum: cudaMemAttachHost = 2 - -cdef enum: cudaMemAttachSingle = 4 - -cdef enum: cudaOccupancyDefault = 0 - -cdef enum: cudaOccupancyDisableCachingOverride = 1 - -cdef enum: cudaCpuDeviceId = -1 - -cdef enum: cudaInvalidDeviceId = -2 - -cdef enum: cudaInitDeviceFlagsAreValid = 1 - -cdef enum: cudaArraySparsePropertiesSingleMipTail = 1 - -cdef enum: cudaMemPoolCreateUsageHwDecompress = 2 - -cdef enum: CUDA_IPC_HANDLE_SIZE = 64 - -cdef enum: cudaExternalMemoryDedicated = 1 - -cdef enum: cudaExternalSemaphoreSignalSkipNvSciBufMemSync = 1 - -cdef enum: cudaExternalSemaphoreWaitSkipNvSciBufMemSync = 2 - -cdef enum: cudaNvSciSyncAttrSignal = 1 - -cdef enum: cudaNvSciSyncAttrWait = 2 - -cdef enum: cudaGraphKernelNodePortDefault = 0 - -cdef enum: cudaGraphKernelNodePortProgrammatic = 1 - -cdef enum: cudaGraphKernelNodePortLaunchCompletion = 2 - -cdef enum: cudaStreamAttributeAccessPolicyWindow = 1 - -cdef enum: cudaStreamAttributeSynchronizationPolicy = 3 - -cdef enum: cudaStreamAttributeMemSyncDomainMap = 9 - -cdef enum: cudaStreamAttributeMemSyncDomain = 10 - -cdef enum: cudaStreamAttributePriority = 8 - -cdef enum: cudaKernelNodeAttributeAccessPolicyWindow = 1 - -cdef enum: cudaKernelNodeAttributeCooperative = 2 - -cdef enum: cudaKernelNodeAttributePriority = 8 - -cdef enum: cudaKernelNodeAttributeClusterDimension = 4 - -cdef enum: cudaKernelNodeAttributeClusterSchedulingPolicyPreference = 5 - -cdef enum: cudaKernelNodeAttributeMemSyncDomainMap = 9 - -cdef enum: cudaKernelNodeAttributeMemSyncDomain = 10 - -cdef enum: cudaKernelNodeAttributePreferredSharedMemoryCarveout = 14 - -cdef enum: cudaKernelNodeAttributeDeviceUpdatableKernelNode = 13 - -cdef enum: cudaKernelNodeAttributeNvlinkUtilCentricScheduling = 16 - -cdef enum: cudaSurfaceType1D = 1 - -cdef enum: cudaSurfaceType2D = 2 - -cdef enum: cudaSurfaceType3D = 3 - -cdef enum: cudaSurfaceTypeCubemap = 12 - -cdef enum: cudaSurfaceType1DLayered = 241 - -cdef enum: cudaSurfaceType2DLayered = 242 - -cdef enum: cudaSurfaceTypeCubemapLayered = 252 - -cdef enum: cudaTextureType1D = 1 - -cdef enum: cudaTextureType2D = 2 - -cdef enum: cudaTextureType3D = 3 - -cdef enum: cudaTextureTypeCubemap = 12 - -cdef enum: cudaTextureType1DLayered = 241 - -cdef enum: cudaTextureType2DLayered = 242 - -cdef enum: cudaTextureTypeCubemapLayered = 252 - -cdef enum: CUDART_VERSION = 13030 - -cdef enum: __CUDART_API_VERSION = 13030 - -cdef enum: CUDA_EGL_MAX_PLANES = 3 \ No newline at end of file diff --git a/cuda_bindings/cuda/bindings/cyruntime.pyx.in b/cuda_bindings/cuda/bindings/cyruntime.pyx similarity index 52% rename from cuda_bindings/cuda/bindings/cyruntime.pyx.in rename to cuda_bindings/cuda/bindings/cyruntime.pyx index 0d6e5c1b490..bc3f12896c8 100644 --- a/cuda_bindings/cuda/bindings/cyruntime.pyx.in +++ b/cuda_bindings/cuda/bindings/cyruntime.pyx @@ -1,2098 +1,1393 @@ # SPDX-FileCopyrightText: Copyright (c) 2021-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# # SPDX-License-Identifier: Apache-2.0 +# +# This code was automatically generated across versions from 12.9.0 to 13.3.0. Do not modify it directly. -# This code was automatically generated with version 13.3.0. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=8eaac6db08318ecc59f425f779f230fc18f12a64d077e6c9b3d0197725b747a4 -cimport cuda.bindings._bindings.cyruntime as cyruntime -cimport cython - -{{if 'cudaDeviceReset' in found_functions}} +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=034f6c5c936d547d3106aa249f8f85b67389eac8b90ab569aa74815f08d699af +from ._internal cimport runtime as _runtime cdef cudaError_t cudaDeviceReset() except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaDeviceReset() -{{endif}} + return _runtime._cudaDeviceReset() -{{if 'cudaDeviceSynchronize' in found_functions}} cdef cudaError_t cudaDeviceSynchronize() except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaDeviceSynchronize() -{{endif}} + return _runtime._cudaDeviceSynchronize() -{{if 'cudaDeviceSetLimit' in found_functions}} cdef cudaError_t cudaDeviceSetLimit(cudaLimit limit, size_t value) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaDeviceSetLimit(limit, value) -{{endif}} + return _runtime._cudaDeviceSetLimit(limit, value) -{{if 'cudaDeviceGetLimit' in found_functions}} cdef cudaError_t cudaDeviceGetLimit(size_t* pValue, cudaLimit limit) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaDeviceGetLimit(pValue, limit) -{{endif}} + return _runtime._cudaDeviceGetLimit(pValue, limit) -{{if 'cudaDeviceGetTexture1DLinearMaxWidth' in found_functions}} cdef cudaError_t cudaDeviceGetTexture1DLinearMaxWidth(size_t* maxWidthInElements, const cudaChannelFormatDesc* fmtDesc, int device) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaDeviceGetTexture1DLinearMaxWidth(maxWidthInElements, fmtDesc, device) -{{endif}} + return _runtime._cudaDeviceGetTexture1DLinearMaxWidth(maxWidthInElements, fmtDesc, device) -{{if 'cudaDeviceGetCacheConfig' in found_functions}} cdef cudaError_t cudaDeviceGetCacheConfig(cudaFuncCache* pCacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaDeviceGetCacheConfig(pCacheConfig) -{{endif}} + return _runtime._cudaDeviceGetCacheConfig(pCacheConfig) -{{if 'cudaDeviceGetStreamPriorityRange' in found_functions}} cdef cudaError_t cudaDeviceGetStreamPriorityRange(int* leastPriority, int* greatestPriority) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaDeviceGetStreamPriorityRange(leastPriority, greatestPriority) -{{endif}} + return _runtime._cudaDeviceGetStreamPriorityRange(leastPriority, greatestPriority) -{{if 'cudaDeviceSetCacheConfig' in found_functions}} cdef cudaError_t cudaDeviceSetCacheConfig(cudaFuncCache cacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaDeviceSetCacheConfig(cacheConfig) -{{endif}} + return _runtime._cudaDeviceSetCacheConfig(cacheConfig) -{{if 'cudaDeviceGetByPCIBusId' in found_functions}} cdef cudaError_t cudaDeviceGetByPCIBusId(int* device, const char* pciBusId) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaDeviceGetByPCIBusId(device, pciBusId) -{{endif}} + return _runtime._cudaDeviceGetByPCIBusId(device, pciBusId) -{{if 'cudaDeviceGetPCIBusId' in found_functions}} -cdef cudaError_t cudaDeviceGetPCIBusId(char* pciBusId, int length, int device) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaDeviceGetPCIBusId(pciBusId, length, device) -{{endif}} +cdef cudaError_t cudaDeviceGetPCIBusId(char* pciBusId, int len, int device) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaDeviceGetPCIBusId(pciBusId, len, device) -{{if 'cudaIpcGetEventHandle' in found_functions}} cdef cudaError_t cudaIpcGetEventHandle(cudaIpcEventHandle_t* handle, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaIpcGetEventHandle(handle, event) -{{endif}} + return _runtime._cudaIpcGetEventHandle(handle, event) -{{if 'cudaIpcOpenEventHandle' in found_functions}} cdef cudaError_t cudaIpcOpenEventHandle(cudaEvent_t* event, cudaIpcEventHandle_t handle) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaIpcOpenEventHandle(event, handle) -{{endif}} + return _runtime._cudaIpcOpenEventHandle(event, handle) -{{if 'cudaIpcGetMemHandle' in found_functions}} cdef cudaError_t cudaIpcGetMemHandle(cudaIpcMemHandle_t* handle, void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaIpcGetMemHandle(handle, devPtr) -{{endif}} + return _runtime._cudaIpcGetMemHandle(handle, devPtr) -{{if 'cudaIpcOpenMemHandle' in found_functions}} cdef cudaError_t cudaIpcOpenMemHandle(void** devPtr, cudaIpcMemHandle_t handle, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaIpcOpenMemHandle(devPtr, handle, flags) -{{endif}} + return _runtime._cudaIpcOpenMemHandle(devPtr, handle, flags) -{{if 'cudaIpcCloseMemHandle' in found_functions}} cdef cudaError_t cudaIpcCloseMemHandle(void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaIpcCloseMemHandle(devPtr) -{{endif}} + return _runtime._cudaIpcCloseMemHandle(devPtr) -{{if 'cudaDeviceFlushGPUDirectRDMAWrites' in found_functions}} cdef cudaError_t cudaDeviceFlushGPUDirectRDMAWrites(cudaFlushGPUDirectRDMAWritesTarget target, cudaFlushGPUDirectRDMAWritesScope scope) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaDeviceFlushGPUDirectRDMAWrites(target, scope) -{{endif}} + return _runtime._cudaDeviceFlushGPUDirectRDMAWrites(target, scope) -{{if 'cudaDeviceRegisterAsyncNotification' in found_functions}} cdef cudaError_t cudaDeviceRegisterAsyncNotification(int device, cudaAsyncCallback callbackFunc, void* userData, cudaAsyncCallbackHandle_t* callback) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaDeviceRegisterAsyncNotification(device, callbackFunc, userData, callback) -{{endif}} + return _runtime._cudaDeviceRegisterAsyncNotification(device, callbackFunc, userData, callback) -{{if 'cudaDeviceUnregisterAsyncNotification' in found_functions}} cdef cudaError_t cudaDeviceUnregisterAsyncNotification(int device, cudaAsyncCallbackHandle_t callback) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaDeviceUnregisterAsyncNotification(device, callback) -{{endif}} + return _runtime._cudaDeviceUnregisterAsyncNotification(device, callback) -{{if 'cudaDeviceGetSharedMemConfig' in found_functions}} cdef cudaError_t cudaDeviceGetSharedMemConfig(cudaSharedMemConfig* pConfig) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaDeviceGetSharedMemConfig(pConfig) -{{endif}} + return _runtime._cudaDeviceGetSharedMemConfig(pConfig) -{{if 'cudaDeviceSetSharedMemConfig' in found_functions}} cdef cudaError_t cudaDeviceSetSharedMemConfig(cudaSharedMemConfig config) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaDeviceSetSharedMemConfig(config) -{{endif}} + return _runtime._cudaDeviceSetSharedMemConfig(config) -{{if 'cudaGetLastError' in found_functions}} cdef cudaError_t cudaGetLastError() except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGetLastError() -{{endif}} + return _runtime._cudaGetLastError() -{{if 'cudaPeekAtLastError' in found_functions}} cdef cudaError_t cudaPeekAtLastError() except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaPeekAtLastError() -{{endif}} + return _runtime._cudaPeekAtLastError() -{{if 'cudaGetErrorName' in found_functions}} -cdef const char* cudaGetErrorName(cudaError_t error) except ?NULL nogil: - return cyruntime._cudaGetErrorName(error) -{{endif}} +cdef const char* cudaGetErrorName(cudaError_t error) except?NULL nogil: + return _runtime._cudaGetErrorName(error) -{{if 'cudaGetErrorString' in found_functions}} -cdef const char* cudaGetErrorString(cudaError_t error) except ?NULL nogil: - return cyruntime._cudaGetErrorString(error) -{{endif}} +cdef const char* cudaGetErrorString(cudaError_t error) except?NULL nogil: + return _runtime._cudaGetErrorString(error) -{{if 'cudaGetDeviceCount' in found_functions}} cdef cudaError_t cudaGetDeviceCount(int* count) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGetDeviceCount(count) -{{endif}} - -{{if 'cudaGetDeviceProperties' in found_functions}} - -cdef cudaError_t cudaGetDeviceProperties(cudaDeviceProp* prop, int device) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGetDeviceProperties(prop, device) -{{endif}} + return _runtime._cudaGetDeviceCount(count) -{{if 'cudaDeviceGetAttribute' in found_functions}} cdef cudaError_t cudaDeviceGetAttribute(int* value, cudaDeviceAttr attr, int device) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaDeviceGetAttribute(value, attr, device) -{{endif}} + return _runtime._cudaDeviceGetAttribute(value, attr, device) -{{if 'cudaDeviceGetHostAtomicCapabilities' in found_functions}} - -cdef cudaError_t cudaDeviceGetHostAtomicCapabilities(unsigned int* capabilities, const cudaAtomicOperation* operations, unsigned int count, int device) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaDeviceGetHostAtomicCapabilities(capabilities, operations, count, device) -{{endif}} - -{{if 'cudaDeviceGetDefaultMemPool' in found_functions}} cdef cudaError_t cudaDeviceGetDefaultMemPool(cudaMemPool_t* memPool, int device) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaDeviceGetDefaultMemPool(memPool, device) -{{endif}} + return _runtime._cudaDeviceGetDefaultMemPool(memPool, device) -{{if 'cudaDeviceSetMemPool' in found_functions}} cdef cudaError_t cudaDeviceSetMemPool(int device, cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaDeviceSetMemPool(device, memPool) -{{endif}} + return _runtime._cudaDeviceSetMemPool(device, memPool) -{{if 'cudaDeviceGetMemPool' in found_functions}} cdef cudaError_t cudaDeviceGetMemPool(cudaMemPool_t* memPool, int device) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaDeviceGetMemPool(memPool, device) -{{endif}} + return _runtime._cudaDeviceGetMemPool(memPool, device) -{{if 'cudaDeviceGetNvSciSyncAttributes' in found_functions}} cdef cudaError_t cudaDeviceGetNvSciSyncAttributes(void* nvSciSyncAttrList, int device, int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaDeviceGetNvSciSyncAttributes(nvSciSyncAttrList, device, flags) -{{endif}} + return _runtime._cudaDeviceGetNvSciSyncAttributes(nvSciSyncAttrList, device, flags) -{{if 'cudaDeviceGetP2PAttribute' in found_functions}} cdef cudaError_t cudaDeviceGetP2PAttribute(int* value, cudaDeviceP2PAttr attr, int srcDevice, int dstDevice) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaDeviceGetP2PAttribute(value, attr, srcDevice, dstDevice) -{{endif}} - -{{if 'cudaDeviceGetP2PAtomicCapabilities' in found_functions}} + return _runtime._cudaDeviceGetP2PAttribute(value, attr, srcDevice, dstDevice) -cdef cudaError_t cudaDeviceGetP2PAtomicCapabilities(unsigned int* capabilities, const cudaAtomicOperation* operations, unsigned int count, int srcDevice, int dstDevice) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaDeviceGetP2PAtomicCapabilities(capabilities, operations, count, srcDevice, dstDevice) -{{endif}} - -{{if 'cudaChooseDevice' in found_functions}} cdef cudaError_t cudaChooseDevice(int* device, const cudaDeviceProp* prop) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaChooseDevice(device, prop) -{{endif}} + return _runtime._cudaChooseDevice(device, prop) -{{if 'cudaInitDevice' in found_functions}} cdef cudaError_t cudaInitDevice(int device, unsigned int deviceFlags, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaInitDevice(device, deviceFlags, flags) -{{endif}} + return _runtime._cudaInitDevice(device, deviceFlags, flags) -{{if 'cudaSetDevice' in found_functions}} cdef cudaError_t cudaSetDevice(int device) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaSetDevice(device) -{{endif}} + return _runtime._cudaSetDevice(device) -{{if 'cudaGetDevice' in found_functions}} cdef cudaError_t cudaGetDevice(int* device) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGetDevice(device) -{{endif}} + return _runtime._cudaGetDevice(device) -{{if 'cudaSetDeviceFlags' in found_functions}} cdef cudaError_t cudaSetDeviceFlags(unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaSetDeviceFlags(flags) -{{endif}} + return _runtime._cudaSetDeviceFlags(flags) -{{if 'cudaGetDeviceFlags' in found_functions}} cdef cudaError_t cudaGetDeviceFlags(unsigned int* flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGetDeviceFlags(flags) -{{endif}} + return _runtime._cudaGetDeviceFlags(flags) -{{if 'cudaStreamCreate' in found_functions}} cdef cudaError_t cudaStreamCreate(cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaStreamCreate(pStream) -{{endif}} + return _runtime._cudaStreamCreate(pStream) -{{if 'cudaStreamCreateWithFlags' in found_functions}} cdef cudaError_t cudaStreamCreateWithFlags(cudaStream_t* pStream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaStreamCreateWithFlags(pStream, flags) -{{endif}} + return _runtime._cudaStreamCreateWithFlags(pStream, flags) -{{if 'cudaStreamCreateWithPriority' in found_functions}} cdef cudaError_t cudaStreamCreateWithPriority(cudaStream_t* pStream, unsigned int flags, int priority) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaStreamCreateWithPriority(pStream, flags, priority) -{{endif}} + return _runtime._cudaStreamCreateWithPriority(pStream, flags, priority) -{{if 'cudaStreamGetPriority' in found_functions}} cdef cudaError_t cudaStreamGetPriority(cudaStream_t hStream, int* priority) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaStreamGetPriority(hStream, priority) -{{endif}} + return _runtime._cudaStreamGetPriority(hStream, priority) -{{if 'cudaStreamGetFlags' in found_functions}} cdef cudaError_t cudaStreamGetFlags(cudaStream_t hStream, unsigned int* flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaStreamGetFlags(hStream, flags) -{{endif}} + return _runtime._cudaStreamGetFlags(hStream, flags) -{{if 'cudaStreamGetId' in found_functions}} cdef cudaError_t cudaStreamGetId(cudaStream_t hStream, unsigned long long* streamId) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaStreamGetId(hStream, streamId) -{{endif}} + return _runtime._cudaStreamGetId(hStream, streamId) -{{if 'cudaStreamGetDevice' in found_functions}} cdef cudaError_t cudaStreamGetDevice(cudaStream_t hStream, int* device) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaStreamGetDevice(hStream, device) -{{endif}} + return _runtime._cudaStreamGetDevice(hStream, device) -{{if 'cudaCtxResetPersistingL2Cache' in found_functions}} cdef cudaError_t cudaCtxResetPersistingL2Cache() except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaCtxResetPersistingL2Cache() -{{endif}} + return _runtime._cudaCtxResetPersistingL2Cache() -{{if 'cudaStreamCopyAttributes' in found_functions}} cdef cudaError_t cudaStreamCopyAttributes(cudaStream_t dst, cudaStream_t src) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaStreamCopyAttributes(dst, src) -{{endif}} + return _runtime._cudaStreamCopyAttributes(dst, src) -{{if 'cudaStreamGetAttribute' in found_functions}} cdef cudaError_t cudaStreamGetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, cudaStreamAttrValue* value_out) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaStreamGetAttribute(hStream, attr, value_out) -{{endif}} + return _runtime._cudaStreamGetAttribute(hStream, attr, value_out) -{{if 'cudaStreamSetAttribute' in found_functions}} cdef cudaError_t cudaStreamSetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, const cudaStreamAttrValue* value) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaStreamSetAttribute(hStream, attr, value) -{{endif}} + return _runtime._cudaStreamSetAttribute(hStream, attr, value) -{{if 'cudaStreamDestroy' in found_functions}} cdef cudaError_t cudaStreamDestroy(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaStreamDestroy(stream) -{{endif}} + return _runtime._cudaStreamDestroy(stream) -{{if 'cudaStreamWaitEvent' in found_functions}} cdef cudaError_t cudaStreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaStreamWaitEvent(stream, event, flags) -{{endif}} + return _runtime._cudaStreamWaitEvent(stream, event, flags) -{{if 'cudaStreamAddCallback' in found_functions}} cdef cudaError_t cudaStreamAddCallback(cudaStream_t stream, cudaStreamCallback_t callback, void* userData, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaStreamAddCallback(stream, callback, userData, flags) -{{endif}} + return _runtime._cudaStreamAddCallback(stream, callback, userData, flags) -{{if 'cudaStreamSynchronize' in found_functions}} cdef cudaError_t cudaStreamSynchronize(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaStreamSynchronize(stream) -{{endif}} + return _runtime._cudaStreamSynchronize(stream) -{{if 'cudaStreamQuery' in found_functions}} cdef cudaError_t cudaStreamQuery(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaStreamQuery(stream) -{{endif}} + return _runtime._cudaStreamQuery(stream) -{{if 'cudaStreamAttachMemAsync' in found_functions}} cdef cudaError_t cudaStreamAttachMemAsync(cudaStream_t stream, void* devPtr, size_t length, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaStreamAttachMemAsync(stream, devPtr, length, flags) -{{endif}} + return _runtime._cudaStreamAttachMemAsync(stream, devPtr, length, flags) -{{if 'cudaStreamBeginCapture' in found_functions}} cdef cudaError_t cudaStreamBeginCapture(cudaStream_t stream, cudaStreamCaptureMode mode) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaStreamBeginCapture(stream, mode) -{{endif}} - -{{if 'cudaStreamBeginRecaptureToGraph' in found_functions}} - -cdef cudaError_t cudaStreamBeginRecaptureToGraph(cudaStream_t stream, cudaStreamCaptureMode mode, cudaGraph_t graph, cudaGraphRecaptureCallbackData* callbackData) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaStreamBeginRecaptureToGraph(stream, mode, graph, callbackData) -{{endif}} + return _runtime._cudaStreamBeginCapture(stream, mode) -{{if 'cudaStreamBeginCaptureToGraph' in found_functions}} cdef cudaError_t cudaStreamBeginCaptureToGraph(cudaStream_t stream, cudaGraph_t graph, const cudaGraphNode_t* dependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, cudaStreamCaptureMode mode) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaStreamBeginCaptureToGraph(stream, graph, dependencies, dependencyData, numDependencies, mode) -{{endif}} + return _runtime._cudaStreamBeginCaptureToGraph(stream, graph, dependencies, dependencyData, numDependencies, mode) -{{if 'cudaThreadExchangeStreamCaptureMode' in found_functions}} cdef cudaError_t cudaThreadExchangeStreamCaptureMode(cudaStreamCaptureMode* mode) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaThreadExchangeStreamCaptureMode(mode) -{{endif}} + return _runtime._cudaThreadExchangeStreamCaptureMode(mode) -{{if 'cudaStreamEndCapture' in found_functions}} cdef cudaError_t cudaStreamEndCapture(cudaStream_t stream, cudaGraph_t* pGraph) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaStreamEndCapture(stream, pGraph) -{{endif}} + return _runtime._cudaStreamEndCapture(stream, pGraph) -{{if 'cudaStreamIsCapturing' in found_functions}} cdef cudaError_t cudaStreamIsCapturing(cudaStream_t stream, cudaStreamCaptureStatus* pCaptureStatus) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaStreamIsCapturing(stream, pCaptureStatus) -{{endif}} - -{{if 'cudaStreamGetCaptureInfo' in found_functions}} - -cdef cudaError_t cudaStreamGetCaptureInfo(cudaStream_t stream, cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out, cudaGraph_t* graph_out, const cudaGraphNode_t** dependencies_out, const cudaGraphEdgeData** edgeData_out, size_t* numDependencies_out) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaStreamGetCaptureInfo(stream, captureStatus_out, id_out, graph_out, dependencies_out, edgeData_out, numDependencies_out) -{{endif}} + return _runtime._cudaStreamIsCapturing(stream, pCaptureStatus) -{{if 'cudaStreamUpdateCaptureDependencies' in found_functions}} cdef cudaError_t cudaStreamUpdateCaptureDependencies(cudaStream_t stream, cudaGraphNode_t* dependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaStreamUpdateCaptureDependencies(stream, dependencies, dependencyData, numDependencies, flags) -{{endif}} + return _runtime._cudaStreamUpdateCaptureDependencies(stream, dependencies, dependencyData, numDependencies, flags) -{{if 'cudaEventCreate' in found_functions}} cdef cudaError_t cudaEventCreate(cudaEvent_t* event) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaEventCreate(event) -{{endif}} + return _runtime._cudaEventCreate(event) -{{if 'cudaEventCreateWithFlags' in found_functions}} cdef cudaError_t cudaEventCreateWithFlags(cudaEvent_t* event, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaEventCreateWithFlags(event, flags) -{{endif}} + return _runtime._cudaEventCreateWithFlags(event, flags) -{{if 'cudaEventRecord' in found_functions}} cdef cudaError_t cudaEventRecord(cudaEvent_t event, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaEventRecord(event, stream) -{{endif}} + return _runtime._cudaEventRecord(event, stream) -{{if 'cudaEventRecordWithFlags' in found_functions}} cdef cudaError_t cudaEventRecordWithFlags(cudaEvent_t event, cudaStream_t stream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaEventRecordWithFlags(event, stream, flags) -{{endif}} + return _runtime._cudaEventRecordWithFlags(event, stream, flags) -{{if 'cudaEventQuery' in found_functions}} cdef cudaError_t cudaEventQuery(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaEventQuery(event) -{{endif}} + return _runtime._cudaEventQuery(event) -{{if 'cudaEventSynchronize' in found_functions}} cdef cudaError_t cudaEventSynchronize(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaEventSynchronize(event) -{{endif}} + return _runtime._cudaEventSynchronize(event) -{{if 'cudaEventDestroy' in found_functions}} cdef cudaError_t cudaEventDestroy(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaEventDestroy(event) -{{endif}} + return _runtime._cudaEventDestroy(event) -{{if 'cudaEventElapsedTime' in found_functions}} cdef cudaError_t cudaEventElapsedTime(float* ms, cudaEvent_t start, cudaEvent_t end) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaEventElapsedTime(ms, start, end) -{{endif}} + return _runtime._cudaEventElapsedTime(ms, start, end) -{{if 'cudaImportExternalMemory' in found_functions}} cdef cudaError_t cudaImportExternalMemory(cudaExternalMemory_t* extMem_out, const cudaExternalMemoryHandleDesc* memHandleDesc) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaImportExternalMemory(extMem_out, memHandleDesc) -{{endif}} + return _runtime._cudaImportExternalMemory(extMem_out, memHandleDesc) -{{if 'cudaExternalMemoryGetMappedBuffer' in found_functions}} cdef cudaError_t cudaExternalMemoryGetMappedBuffer(void** devPtr, cudaExternalMemory_t extMem, const cudaExternalMemoryBufferDesc* bufferDesc) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaExternalMemoryGetMappedBuffer(devPtr, extMem, bufferDesc) -{{endif}} + return _runtime._cudaExternalMemoryGetMappedBuffer(devPtr, extMem, bufferDesc) -{{if 'cudaExternalMemoryGetMappedMipmappedArray' in found_functions}} cdef cudaError_t cudaExternalMemoryGetMappedMipmappedArray(cudaMipmappedArray_t* mipmap, cudaExternalMemory_t extMem, const cudaExternalMemoryMipmappedArrayDesc* mipmapDesc) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaExternalMemoryGetMappedMipmappedArray(mipmap, extMem, mipmapDesc) -{{endif}} + return _runtime._cudaExternalMemoryGetMappedMipmappedArray(mipmap, extMem, mipmapDesc) -{{if 'cudaDestroyExternalMemory' in found_functions}} cdef cudaError_t cudaDestroyExternalMemory(cudaExternalMemory_t extMem) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaDestroyExternalMemory(extMem) -{{endif}} + return _runtime._cudaDestroyExternalMemory(extMem) -{{if 'cudaImportExternalSemaphore' in found_functions}} cdef cudaError_t cudaImportExternalSemaphore(cudaExternalSemaphore_t* extSem_out, const cudaExternalSemaphoreHandleDesc* semHandleDesc) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaImportExternalSemaphore(extSem_out, semHandleDesc) -{{endif}} + return _runtime._cudaImportExternalSemaphore(extSem_out, semHandleDesc) -{{if 'cudaSignalExternalSemaphoresAsync' in found_functions}} - -cdef cudaError_t cudaSignalExternalSemaphoresAsync(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreSignalParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaSignalExternalSemaphoresAsync(extSemArray, paramsArray, numExtSems, stream) -{{endif}} - -{{if 'cudaWaitExternalSemaphoresAsync' in found_functions}} - -cdef cudaError_t cudaWaitExternalSemaphoresAsync(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreWaitParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaWaitExternalSemaphoresAsync(extSemArray, paramsArray, numExtSems, stream) -{{endif}} - -{{if 'cudaDestroyExternalSemaphore' in found_functions}} cdef cudaError_t cudaDestroyExternalSemaphore(cudaExternalSemaphore_t extSem) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaDestroyExternalSemaphore(extSem) -{{endif}} + return _runtime._cudaDestroyExternalSemaphore(extSem) -{{if 'cudaFuncSetCacheConfig' in found_functions}} cdef cudaError_t cudaFuncSetCacheConfig(const void* func, cudaFuncCache cacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaFuncSetCacheConfig(func, cacheConfig) -{{endif}} + return _runtime._cudaFuncSetCacheConfig(func, cacheConfig) -{{if 'cudaFuncGetAttributes' in found_functions}} cdef cudaError_t cudaFuncGetAttributes(cudaFuncAttributes* attr, const void* func) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaFuncGetAttributes(attr, func) -{{endif}} + return _runtime._cudaFuncGetAttributes(attr, func) -{{if 'cudaFuncSetAttribute' in found_functions}} cdef cudaError_t cudaFuncSetAttribute(const void* func, cudaFuncAttribute attr, int value) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaFuncSetAttribute(func, attr, value) -{{endif}} + return _runtime._cudaFuncSetAttribute(func, attr, value) -{{if 'cudaFuncGetParamCount' in found_functions}} -cdef cudaError_t cudaFuncGetParamCount(const void* func, size_t* paramCount) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaFuncGetParamCount(func, paramCount) -{{endif}} +cdef cudaError_t cudaFuncGetName(const char** name, const void* func) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaFuncGetName(name, func) -{{if 'cudaLaunchHostFunc' in found_functions}} -cdef cudaError_t cudaLaunchHostFunc(cudaStream_t stream, cudaHostFn_t fn, void* userData) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaLaunchHostFunc(stream, fn, userData) -{{endif}} +cdef cudaError_t cudaFuncGetParamInfo(const void* func, size_t paramIndex, size_t* paramOffset, size_t* paramSize) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaFuncGetParamInfo(func, paramIndex, paramOffset, paramSize) -{{if 'cudaLaunchHostFunc_v2' in found_functions}} -cdef cudaError_t cudaLaunchHostFunc_v2(cudaStream_t stream, cudaHostFn_t fn, void* userData, unsigned int syncMode) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaLaunchHostFunc_v2(stream, fn, userData, syncMode) -{{endif}} +cdef cudaError_t cudaLaunchHostFunc(cudaStream_t stream, cudaHostFn_t fn, void* userData) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaLaunchHostFunc(stream, fn, userData) -{{if 'cudaFuncSetSharedMemConfig' in found_functions}} cdef cudaError_t cudaFuncSetSharedMemConfig(const void* func, cudaSharedMemConfig config) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaFuncSetSharedMemConfig(func, config) -{{endif}} + return _runtime._cudaFuncSetSharedMemConfig(func, config) -{{if 'cudaOccupancyMaxActiveBlocksPerMultiprocessor' in found_functions}} cdef cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessor(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaOccupancyMaxActiveBlocksPerMultiprocessor(numBlocks, func, blockSize, dynamicSMemSize) -{{endif}} + return _runtime._cudaOccupancyMaxActiveBlocksPerMultiprocessor(numBlocks, func, blockSize, dynamicSMemSize) -{{if 'cudaOccupancyAvailableDynamicSMemPerBlock' in found_functions}} cdef cudaError_t cudaOccupancyAvailableDynamicSMemPerBlock(size_t* dynamicSmemSize, const void* func, int numBlocks, int blockSize) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaOccupancyAvailableDynamicSMemPerBlock(dynamicSmemSize, func, numBlocks, blockSize) -{{endif}} + return _runtime._cudaOccupancyAvailableDynamicSMemPerBlock(dynamicSmemSize, func, numBlocks, blockSize) -{{if 'cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags' in found_functions}} cdef cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(numBlocks, func, blockSize, dynamicSMemSize, flags) -{{endif}} + return _runtime._cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(numBlocks, func, blockSize, dynamicSMemSize, flags) -{{if 'cudaMallocManaged' in found_functions}} cdef cudaError_t cudaMallocManaged(void** devPtr, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMallocManaged(devPtr, size, flags) -{{endif}} + return _runtime._cudaMallocManaged(devPtr, size, flags) -{{if 'cudaMalloc' in found_functions}} cdef cudaError_t cudaMalloc(void** devPtr, size_t size) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMalloc(devPtr, size) -{{endif}} + return _runtime._cudaMalloc(devPtr, size) -{{if 'cudaMallocHost' in found_functions}} cdef cudaError_t cudaMallocHost(void** ptr, size_t size) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMallocHost(ptr, size) -{{endif}} + return _runtime._cudaMallocHost(ptr, size) -{{if 'cudaMallocPitch' in found_functions}} cdef cudaError_t cudaMallocPitch(void** devPtr, size_t* pitch, size_t width, size_t height) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMallocPitch(devPtr, pitch, width, height) -{{endif}} + return _runtime._cudaMallocPitch(devPtr, pitch, width, height) -{{if 'cudaMallocArray' in found_functions}} cdef cudaError_t cudaMallocArray(cudaArray_t* array, const cudaChannelFormatDesc* desc, size_t width, size_t height, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMallocArray(array, desc, width, height, flags) -{{endif}} + return _runtime._cudaMallocArray(array, desc, width, height, flags) -{{if 'cudaFree' in found_functions}} cdef cudaError_t cudaFree(void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaFree(devPtr) -{{endif}} + return _runtime._cudaFree(devPtr) -{{if 'cudaFreeHost' in found_functions}} cdef cudaError_t cudaFreeHost(void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaFreeHost(ptr) -{{endif}} + return _runtime._cudaFreeHost(ptr) -{{if 'cudaFreeArray' in found_functions}} cdef cudaError_t cudaFreeArray(cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaFreeArray(array) -{{endif}} + return _runtime._cudaFreeArray(array) -{{if 'cudaFreeMipmappedArray' in found_functions}} cdef cudaError_t cudaFreeMipmappedArray(cudaMipmappedArray_t mipmappedArray) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaFreeMipmappedArray(mipmappedArray) -{{endif}} + return _runtime._cudaFreeMipmappedArray(mipmappedArray) -{{if 'cudaHostAlloc' in found_functions}} cdef cudaError_t cudaHostAlloc(void** pHost, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaHostAlloc(pHost, size, flags) -{{endif}} + return _runtime._cudaHostAlloc(pHost, size, flags) -{{if 'cudaHostRegister' in found_functions}} cdef cudaError_t cudaHostRegister(void* ptr, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaHostRegister(ptr, size, flags) -{{endif}} + return _runtime._cudaHostRegister(ptr, size, flags) -{{if 'cudaHostUnregister' in found_functions}} cdef cudaError_t cudaHostUnregister(void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaHostUnregister(ptr) -{{endif}} + return _runtime._cudaHostUnregister(ptr) -{{if 'cudaHostGetDevicePointer' in found_functions}} cdef cudaError_t cudaHostGetDevicePointer(void** pDevice, void* pHost, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaHostGetDevicePointer(pDevice, pHost, flags) -{{endif}} + return _runtime._cudaHostGetDevicePointer(pDevice, pHost, flags) -{{if 'cudaHostGetFlags' in found_functions}} cdef cudaError_t cudaHostGetFlags(unsigned int* pFlags, void* pHost) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaHostGetFlags(pFlags, pHost) -{{endif}} + return _runtime._cudaHostGetFlags(pFlags, pHost) -{{if 'cudaMalloc3D' in found_functions}} cdef cudaError_t cudaMalloc3D(cudaPitchedPtr* pitchedDevPtr, cudaExtent extent) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMalloc3D(pitchedDevPtr, extent) -{{endif}} + return _runtime._cudaMalloc3D(pitchedDevPtr, extent) -{{if 'cudaMalloc3DArray' in found_functions}} cdef cudaError_t cudaMalloc3DArray(cudaArray_t* array, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMalloc3DArray(array, desc, extent, flags) -{{endif}} + return _runtime._cudaMalloc3DArray(array, desc, extent, flags) -{{if 'cudaMallocMipmappedArray' in found_functions}} cdef cudaError_t cudaMallocMipmappedArray(cudaMipmappedArray_t* mipmappedArray, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int numLevels, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMallocMipmappedArray(mipmappedArray, desc, extent, numLevels, flags) -{{endif}} + return _runtime._cudaMallocMipmappedArray(mipmappedArray, desc, extent, numLevels, flags) -{{if 'cudaGetMipmappedArrayLevel' in found_functions}} cdef cudaError_t cudaGetMipmappedArrayLevel(cudaArray_t* levelArray, cudaMipmappedArray_const_t mipmappedArray, unsigned int level) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGetMipmappedArrayLevel(levelArray, mipmappedArray, level) -{{endif}} + return _runtime._cudaGetMipmappedArrayLevel(levelArray, mipmappedArray, level) -{{if 'cudaMemcpy3D' in found_functions}} cdef cudaError_t cudaMemcpy3D(const cudaMemcpy3DParms* p) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemcpy3D(p) -{{endif}} + return _runtime._cudaMemcpy3D(p) -{{if 'cudaMemcpy3DPeer' in found_functions}} cdef cudaError_t cudaMemcpy3DPeer(const cudaMemcpy3DPeerParms* p) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemcpy3DPeer(p) -{{endif}} + return _runtime._cudaMemcpy3DPeer(p) -{{if 'cudaMemcpy3DAsync' in found_functions}} cdef cudaError_t cudaMemcpy3DAsync(const cudaMemcpy3DParms* p, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemcpy3DAsync(p, stream) -{{endif}} + return _runtime._cudaMemcpy3DAsync(p, stream) -{{if 'cudaMemcpy3DPeerAsync' in found_functions}} cdef cudaError_t cudaMemcpy3DPeerAsync(const cudaMemcpy3DPeerParms* p, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemcpy3DPeerAsync(p, stream) -{{endif}} + return _runtime._cudaMemcpy3DPeerAsync(p, stream) -{{if 'cudaMemGetInfo' in found_functions}} cdef cudaError_t cudaMemGetInfo(size_t* free, size_t* total) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemGetInfo(free, total) -{{endif}} + return _runtime._cudaMemGetInfo(free, total) -{{if 'cudaArrayGetInfo' in found_functions}} cdef cudaError_t cudaArrayGetInfo(cudaChannelFormatDesc* desc, cudaExtent* extent, unsigned int* flags, cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaArrayGetInfo(desc, extent, flags, array) -{{endif}} + return _runtime._cudaArrayGetInfo(desc, extent, flags, array) -{{if 'cudaArrayGetPlane' in found_functions}} cdef cudaError_t cudaArrayGetPlane(cudaArray_t* pPlaneArray, cudaArray_t hArray, unsigned int planeIdx) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaArrayGetPlane(pPlaneArray, hArray, planeIdx) -{{endif}} + return _runtime._cudaArrayGetPlane(pPlaneArray, hArray, planeIdx) -{{if 'cudaArrayGetMemoryRequirements' in found_functions}} cdef cudaError_t cudaArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaArray_t array, int device) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaArrayGetMemoryRequirements(memoryRequirements, array, device) -{{endif}} + return _runtime._cudaArrayGetMemoryRequirements(memoryRequirements, array, device) -{{if 'cudaMipmappedArrayGetMemoryRequirements' in found_functions}} cdef cudaError_t cudaMipmappedArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaMipmappedArray_t mipmap, int device) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMipmappedArrayGetMemoryRequirements(memoryRequirements, mipmap, device) -{{endif}} + return _runtime._cudaMipmappedArrayGetMemoryRequirements(memoryRequirements, mipmap, device) -{{if 'cudaArrayGetSparseProperties' in found_functions}} cdef cudaError_t cudaArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaArrayGetSparseProperties(sparseProperties, array) -{{endif}} + return _runtime._cudaArrayGetSparseProperties(sparseProperties, array) -{{if 'cudaMipmappedArrayGetSparseProperties' in found_functions}} cdef cudaError_t cudaMipmappedArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaMipmappedArray_t mipmap) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMipmappedArrayGetSparseProperties(sparseProperties, mipmap) -{{endif}} + return _runtime._cudaMipmappedArrayGetSparseProperties(sparseProperties, mipmap) -{{if 'cudaMemcpy' in found_functions}} cdef cudaError_t cudaMemcpy(void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemcpy(dst, src, count, kind) -{{endif}} + return _runtime._cudaMemcpy(dst, src, count, kind) -{{if 'cudaMemcpyPeer' in found_functions}} cdef cudaError_t cudaMemcpyPeer(void* dst, int dstDevice, const void* src, int srcDevice, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemcpyPeer(dst, dstDevice, src, srcDevice, count) -{{endif}} + return _runtime._cudaMemcpyPeer(dst, dstDevice, src, srcDevice, count) -{{if 'cudaMemcpy2D' in found_functions}} cdef cudaError_t cudaMemcpy2D(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemcpy2D(dst, dpitch, src, spitch, width, height, kind) -{{endif}} + return _runtime._cudaMemcpy2D(dst, dpitch, src, spitch, width, height, kind) -{{if 'cudaMemcpy2DToArray' in found_functions}} cdef cudaError_t cudaMemcpy2DToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemcpy2DToArray(dst, wOffset, hOffset, src, spitch, width, height, kind) -{{endif}} + return _runtime._cudaMemcpy2DToArray(dst, wOffset, hOffset, src, spitch, width, height, kind) -{{if 'cudaMemcpy2DFromArray' in found_functions}} cdef cudaError_t cudaMemcpy2DFromArray(void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemcpy2DFromArray(dst, dpitch, src, wOffset, hOffset, width, height, kind) -{{endif}} + return _runtime._cudaMemcpy2DFromArray(dst, dpitch, src, wOffset, hOffset, width, height, kind) -{{if 'cudaMemcpy2DArrayToArray' in found_functions}} cdef cudaError_t cudaMemcpy2DArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemcpy2DArrayToArray(dst, wOffsetDst, hOffsetDst, src, wOffsetSrc, hOffsetSrc, width, height, kind) -{{endif}} + return _runtime._cudaMemcpy2DArrayToArray(dst, wOffsetDst, hOffsetDst, src, wOffsetSrc, hOffsetSrc, width, height, kind) -{{if 'cudaMemcpyAsync' in found_functions}} cdef cudaError_t cudaMemcpyAsync(void* dst, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemcpyAsync(dst, src, count, kind, stream) -{{endif}} + return _runtime._cudaMemcpyAsync(dst, src, count, kind, stream) -{{if 'cudaMemcpyPeerAsync' in found_functions}} cdef cudaError_t cudaMemcpyPeerAsync(void* dst, int dstDevice, const void* src, int srcDevice, size_t count, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemcpyPeerAsync(dst, dstDevice, src, srcDevice, count, stream) -{{endif}} + return _runtime._cudaMemcpyPeerAsync(dst, dstDevice, src, srcDevice, count, stream) -{{if 'cudaMemcpyBatchAsync' in found_functions}} cdef cudaError_t cudaMemcpyBatchAsync(const void** dsts, const void** srcs, const size_t* sizes, size_t count, cudaMemcpyAttributes* attrs, size_t* attrsIdxs, size_t numAttrs, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemcpyBatchAsync(dsts, srcs, sizes, count, attrs, attrsIdxs, numAttrs, stream) -{{endif}} + return _runtime._cudaMemcpyBatchAsync(dsts, srcs, sizes, count, attrs, attrsIdxs, numAttrs, stream) -{{if 'cudaMemcpy3DBatchAsync' in found_functions}} cdef cudaError_t cudaMemcpy3DBatchAsync(size_t numOps, cudaMemcpy3DBatchOp* opList, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemcpy3DBatchAsync(numOps, opList, flags, stream) -{{endif}} - -{{if 'cudaMemcpyWithAttributesAsync' in found_functions}} - -cdef cudaError_t cudaMemcpyWithAttributesAsync(void* dst, const void* src, size_t size, cudaMemcpyAttributes* attr, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemcpyWithAttributesAsync(dst, src, size, attr, stream) -{{endif}} - -{{if 'cudaMemcpy3DWithAttributesAsync' in found_functions}} - -cdef cudaError_t cudaMemcpy3DWithAttributesAsync(cudaMemcpy3DBatchOp* op, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemcpy3DWithAttributesAsync(op, flags, stream) -{{endif}} + return _runtime._cudaMemcpy3DBatchAsync(numOps, opList, flags, stream) -{{if 'cudaMemcpy2DAsync' in found_functions}} cdef cudaError_t cudaMemcpy2DAsync(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemcpy2DAsync(dst, dpitch, src, spitch, width, height, kind, stream) -{{endif}} + return _runtime._cudaMemcpy2DAsync(dst, dpitch, src, spitch, width, height, kind, stream) -{{if 'cudaMemcpy2DToArrayAsync' in found_functions}} cdef cudaError_t cudaMemcpy2DToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemcpy2DToArrayAsync(dst, wOffset, hOffset, src, spitch, width, height, kind, stream) -{{endif}} + return _runtime._cudaMemcpy2DToArrayAsync(dst, wOffset, hOffset, src, spitch, width, height, kind, stream) -{{if 'cudaMemcpy2DFromArrayAsync' in found_functions}} cdef cudaError_t cudaMemcpy2DFromArrayAsync(void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemcpy2DFromArrayAsync(dst, dpitch, src, wOffset, hOffset, width, height, kind, stream) -{{endif}} + return _runtime._cudaMemcpy2DFromArrayAsync(dst, dpitch, src, wOffset, hOffset, width, height, kind, stream) -{{if 'cudaMemset' in found_functions}} cdef cudaError_t cudaMemset(void* devPtr, int value, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemset(devPtr, value, count) -{{endif}} + return _runtime._cudaMemset(devPtr, value, count) -{{if 'cudaMemset2D' in found_functions}} cdef cudaError_t cudaMemset2D(void* devPtr, size_t pitch, int value, size_t width, size_t height) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemset2D(devPtr, pitch, value, width, height) -{{endif}} + return _runtime._cudaMemset2D(devPtr, pitch, value, width, height) -{{if 'cudaMemset3D' in found_functions}} cdef cudaError_t cudaMemset3D(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemset3D(pitchedDevPtr, value, extent) -{{endif}} + return _runtime._cudaMemset3D(pitchedDevPtr, value, extent) -{{if 'cudaMemsetAsync' in found_functions}} cdef cudaError_t cudaMemsetAsync(void* devPtr, int value, size_t count, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemsetAsync(devPtr, value, count, stream) -{{endif}} + return _runtime._cudaMemsetAsync(devPtr, value, count, stream) -{{if 'cudaMemset2DAsync' in found_functions}} cdef cudaError_t cudaMemset2DAsync(void* devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemset2DAsync(devPtr, pitch, value, width, height, stream) -{{endif}} + return _runtime._cudaMemset2DAsync(devPtr, pitch, value, width, height, stream) -{{if 'cudaMemset3DAsync' in found_functions}} cdef cudaError_t cudaMemset3DAsync(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemset3DAsync(pitchedDevPtr, value, extent, stream) -{{endif}} + return _runtime._cudaMemset3DAsync(pitchedDevPtr, value, extent, stream) -{{if 'cudaMemPrefetchAsync' in found_functions}} cdef cudaError_t cudaMemPrefetchAsync(const void* devPtr, size_t count, cudaMemLocation location, unsigned int flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemPrefetchAsync(devPtr, count, location, flags, stream) -{{endif}} + return _runtime._cudaMemPrefetchAsync(devPtr, count, location, flags, stream) -{{if 'cudaMemPrefetchBatchAsync' in found_functions}} - -cdef cudaError_t cudaMemPrefetchBatchAsync(void** dptrs, size_t* sizes, size_t count, cudaMemLocation* prefetchLocs, size_t* prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemPrefetchBatchAsync(dptrs, sizes, count, prefetchLocs, prefetchLocIdxs, numPrefetchLocs, flags, stream) -{{endif}} - -{{if 'cudaMemDiscardBatchAsync' in found_functions}} - -cdef cudaError_t cudaMemDiscardBatchAsync(void** dptrs, size_t* sizes, size_t count, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemDiscardBatchAsync(dptrs, sizes, count, flags, stream) -{{endif}} - -{{if 'cudaMemDiscardAndPrefetchBatchAsync' in found_functions}} - -cdef cudaError_t cudaMemDiscardAndPrefetchBatchAsync(void** dptrs, size_t* sizes, size_t count, cudaMemLocation* prefetchLocs, size_t* prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemDiscardAndPrefetchBatchAsync(dptrs, sizes, count, prefetchLocs, prefetchLocIdxs, numPrefetchLocs, flags, stream) -{{endif}} - -{{if 'cudaMemAdvise' in found_functions}} cdef cudaError_t cudaMemAdvise(const void* devPtr, size_t count, cudaMemoryAdvise advice, cudaMemLocation location) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemAdvise(devPtr, count, advice, location) -{{endif}} + return _runtime._cudaMemAdvise(devPtr, count, advice, location) -{{if 'cudaMemRangeGetAttribute' in found_functions}} cdef cudaError_t cudaMemRangeGetAttribute(void* data, size_t dataSize, cudaMemRangeAttribute attribute, const void* devPtr, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemRangeGetAttribute(data, dataSize, attribute, devPtr, count) -{{endif}} + return _runtime._cudaMemRangeGetAttribute(data, dataSize, attribute, devPtr, count) -{{if 'cudaMemRangeGetAttributes' in found_functions}} cdef cudaError_t cudaMemRangeGetAttributes(void** data, size_t* dataSizes, cudaMemRangeAttribute* attributes, size_t numAttributes, const void* devPtr, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemRangeGetAttributes(data, dataSizes, attributes, numAttributes, devPtr, count) -{{endif}} + return _runtime._cudaMemRangeGetAttributes(data, dataSizes, attributes, numAttributes, devPtr, count) -{{if 'cudaMemcpyToArray' in found_functions}} cdef cudaError_t cudaMemcpyToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemcpyToArray(dst, wOffset, hOffset, src, count, kind) -{{endif}} + return _runtime._cudaMemcpyToArray(dst, wOffset, hOffset, src, count, kind) -{{if 'cudaMemcpyFromArray' in found_functions}} cdef cudaError_t cudaMemcpyFromArray(void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemcpyFromArray(dst, src, wOffset, hOffset, count, kind) -{{endif}} + return _runtime._cudaMemcpyFromArray(dst, src, wOffset, hOffset, count, kind) -{{if 'cudaMemcpyArrayToArray' in found_functions}} cdef cudaError_t cudaMemcpyArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemcpyArrayToArray(dst, wOffsetDst, hOffsetDst, src, wOffsetSrc, hOffsetSrc, count, kind) -{{endif}} + return _runtime._cudaMemcpyArrayToArray(dst, wOffsetDst, hOffsetDst, src, wOffsetSrc, hOffsetSrc, count, kind) -{{if 'cudaMemcpyToArrayAsync' in found_functions}} cdef cudaError_t cudaMemcpyToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemcpyToArrayAsync(dst, wOffset, hOffset, src, count, kind, stream) -{{endif}} + return _runtime._cudaMemcpyToArrayAsync(dst, wOffset, hOffset, src, count, kind, stream) -{{if 'cudaMemcpyFromArrayAsync' in found_functions}} cdef cudaError_t cudaMemcpyFromArrayAsync(void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemcpyFromArrayAsync(dst, src, wOffset, hOffset, count, kind, stream) -{{endif}} + return _runtime._cudaMemcpyFromArrayAsync(dst, src, wOffset, hOffset, count, kind, stream) -{{if 'cudaMallocAsync' in found_functions}} cdef cudaError_t cudaMallocAsync(void** devPtr, size_t size, cudaStream_t hStream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMallocAsync(devPtr, size, hStream) -{{endif}} + return _runtime._cudaMallocAsync(devPtr, size, hStream) -{{if 'cudaFreeAsync' in found_functions}} cdef cudaError_t cudaFreeAsync(void* devPtr, cudaStream_t hStream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaFreeAsync(devPtr, hStream) -{{endif}} + return _runtime._cudaFreeAsync(devPtr, hStream) -{{if 'cudaMemPoolTrimTo' in found_functions}} cdef cudaError_t cudaMemPoolTrimTo(cudaMemPool_t memPool, size_t minBytesToKeep) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemPoolTrimTo(memPool, minBytesToKeep) -{{endif}} + return _runtime._cudaMemPoolTrimTo(memPool, minBytesToKeep) -{{if 'cudaMemPoolSetAttribute' in found_functions}} cdef cudaError_t cudaMemPoolSetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemPoolSetAttribute(memPool, attr, value) -{{endif}} + return _runtime._cudaMemPoolSetAttribute(memPool, attr, value) -{{if 'cudaMemPoolGetAttribute' in found_functions}} cdef cudaError_t cudaMemPoolGetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemPoolGetAttribute(memPool, attr, value) -{{endif}} + return _runtime._cudaMemPoolGetAttribute(memPool, attr, value) -{{if 'cudaMemPoolSetAccess' in found_functions}} cdef cudaError_t cudaMemPoolSetAccess(cudaMemPool_t memPool, const cudaMemAccessDesc* descList, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemPoolSetAccess(memPool, descList, count) -{{endif}} + return _runtime._cudaMemPoolSetAccess(memPool, descList, count) -{{if 'cudaMemPoolGetAccess' in found_functions}} cdef cudaError_t cudaMemPoolGetAccess(cudaMemAccessFlags* flags, cudaMemPool_t memPool, cudaMemLocation* location) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemPoolGetAccess(flags, memPool, location) -{{endif}} + return _runtime._cudaMemPoolGetAccess(flags, memPool, location) -{{if 'cudaMemPoolCreate' in found_functions}} cdef cudaError_t cudaMemPoolCreate(cudaMemPool_t* memPool, const cudaMemPoolProps* poolProps) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemPoolCreate(memPool, poolProps) -{{endif}} + return _runtime._cudaMemPoolCreate(memPool, poolProps) -{{if 'cudaMemPoolDestroy' in found_functions}} cdef cudaError_t cudaMemPoolDestroy(cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemPoolDestroy(memPool) -{{endif}} - -{{if 'cudaMemGetDefaultMemPool' in found_functions}} - -cdef cudaError_t cudaMemGetDefaultMemPool(cudaMemPool_t* memPool, cudaMemLocation* location, cudaMemAllocationType typename) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemGetDefaultMemPool(memPool, location, typename) -{{endif}} - -{{if 'cudaMemGetMemPool' in found_functions}} + return _runtime._cudaMemPoolDestroy(memPool) -cdef cudaError_t cudaMemGetMemPool(cudaMemPool_t* memPool, cudaMemLocation* location, cudaMemAllocationType typename) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemGetMemPool(memPool, location, typename) -{{endif}} - -{{if 'cudaMemSetMemPool' in found_functions}} - -cdef cudaError_t cudaMemSetMemPool(cudaMemLocation* location, cudaMemAllocationType typename, cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemSetMemPool(location, typename, memPool) -{{endif}} - -{{if 'cudaMallocFromPoolAsync' in found_functions}} cdef cudaError_t cudaMallocFromPoolAsync(void** ptr, size_t size, cudaMemPool_t memPool, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMallocFromPoolAsync(ptr, size, memPool, stream) -{{endif}} + return _runtime._cudaMallocFromPoolAsync(ptr, size, memPool, stream) -{{if 'cudaMemPoolExportToShareableHandle' in found_functions}} cdef cudaError_t cudaMemPoolExportToShareableHandle(void* shareableHandle, cudaMemPool_t memPool, cudaMemAllocationHandleType handleType, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemPoolExportToShareableHandle(shareableHandle, memPool, handleType, flags) -{{endif}} + return _runtime._cudaMemPoolExportToShareableHandle(shareableHandle, memPool, handleType, flags) -{{if 'cudaMemPoolImportFromShareableHandle' in found_functions}} cdef cudaError_t cudaMemPoolImportFromShareableHandle(cudaMemPool_t* memPool, void* shareableHandle, cudaMemAllocationHandleType handleType, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemPoolImportFromShareableHandle(memPool, shareableHandle, handleType, flags) -{{endif}} + return _runtime._cudaMemPoolImportFromShareableHandle(memPool, shareableHandle, handleType, flags) -{{if 'cudaMemPoolExportPointer' in found_functions}} cdef cudaError_t cudaMemPoolExportPointer(cudaMemPoolPtrExportData* exportData, void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemPoolExportPointer(exportData, ptr) -{{endif}} + return _runtime._cudaMemPoolExportPointer(exportData, ptr) -{{if 'cudaMemPoolImportPointer' in found_functions}} cdef cudaError_t cudaMemPoolImportPointer(void** ptr, cudaMemPool_t memPool, cudaMemPoolPtrExportData* exportData) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaMemPoolImportPointer(ptr, memPool, exportData) -{{endif}} + return _runtime._cudaMemPoolImportPointer(ptr, memPool, exportData) -{{if 'cudaPointerGetAttributes' in found_functions}} cdef cudaError_t cudaPointerGetAttributes(cudaPointerAttributes* attributes, const void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaPointerGetAttributes(attributes, ptr) -{{endif}} + return _runtime._cudaPointerGetAttributes(attributes, ptr) -{{if 'cudaDeviceCanAccessPeer' in found_functions}} cdef cudaError_t cudaDeviceCanAccessPeer(int* canAccessPeer, int device, int peerDevice) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaDeviceCanAccessPeer(canAccessPeer, device, peerDevice) -{{endif}} + return _runtime._cudaDeviceCanAccessPeer(canAccessPeer, device, peerDevice) -{{if 'cudaDeviceEnablePeerAccess' in found_functions}} cdef cudaError_t cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaDeviceEnablePeerAccess(peerDevice, flags) -{{endif}} + return _runtime._cudaDeviceEnablePeerAccess(peerDevice, flags) -{{if 'cudaDeviceDisablePeerAccess' in found_functions}} cdef cudaError_t cudaDeviceDisablePeerAccess(int peerDevice) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaDeviceDisablePeerAccess(peerDevice) -{{endif}} + return _runtime._cudaDeviceDisablePeerAccess(peerDevice) -{{if 'cudaGraphicsUnregisterResource' in found_functions}} cdef cudaError_t cudaGraphicsUnregisterResource(cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphicsUnregisterResource(resource) -{{endif}} + return _runtime._cudaGraphicsUnregisterResource(resource) -{{if 'cudaGraphicsResourceSetMapFlags' in found_functions}} cdef cudaError_t cudaGraphicsResourceSetMapFlags(cudaGraphicsResource_t resource, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphicsResourceSetMapFlags(resource, flags) -{{endif}} + return _runtime._cudaGraphicsResourceSetMapFlags(resource, flags) -{{if 'cudaGraphicsMapResources' in found_functions}} cdef cudaError_t cudaGraphicsMapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphicsMapResources(count, resources, stream) -{{endif}} + return _runtime._cudaGraphicsMapResources(count, resources, stream) -{{if 'cudaGraphicsUnmapResources' in found_functions}} cdef cudaError_t cudaGraphicsUnmapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphicsUnmapResources(count, resources, stream) -{{endif}} + return _runtime._cudaGraphicsUnmapResources(count, resources, stream) -{{if 'cudaGraphicsResourceGetMappedPointer' in found_functions}} cdef cudaError_t cudaGraphicsResourceGetMappedPointer(void** devPtr, size_t* size, cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphicsResourceGetMappedPointer(devPtr, size, resource) -{{endif}} + return _runtime._cudaGraphicsResourceGetMappedPointer(devPtr, size, resource) -{{if 'cudaGraphicsSubResourceGetMappedArray' in found_functions}} cdef cudaError_t cudaGraphicsSubResourceGetMappedArray(cudaArray_t* array, cudaGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphicsSubResourceGetMappedArray(array, resource, arrayIndex, mipLevel) -{{endif}} + return _runtime._cudaGraphicsSubResourceGetMappedArray(array, resource, arrayIndex, mipLevel) -{{if 'cudaGraphicsResourceGetMappedMipmappedArray' in found_functions}} cdef cudaError_t cudaGraphicsResourceGetMappedMipmappedArray(cudaMipmappedArray_t* mipmappedArray, cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphicsResourceGetMappedMipmappedArray(mipmappedArray, resource) -{{endif}} + return _runtime._cudaGraphicsResourceGetMappedMipmappedArray(mipmappedArray, resource) -{{if 'cudaGetChannelDesc' in found_functions}} cdef cudaError_t cudaGetChannelDesc(cudaChannelFormatDesc* desc, cudaArray_const_t array) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGetChannelDesc(desc, array) -{{endif}} + return _runtime._cudaGetChannelDesc(desc, array) + -{{if 'cudaCreateChannelDesc' in found_functions}} -@cython.show_performance_hints(False) cdef cudaChannelFormatDesc cudaCreateChannelDesc(int x, int y, int z, int w, cudaChannelFormatKind f) except* nogil: - return cyruntime._cudaCreateChannelDesc(x, y, z, w, f) -{{endif}} + return _runtime._cudaCreateChannelDesc(x, y, z, w, f) -{{if 'cudaCreateTextureObject' in found_functions}} cdef cudaError_t cudaCreateTextureObject(cudaTextureObject_t* pTexObject, const cudaResourceDesc* pResDesc, const cudaTextureDesc* pTexDesc, const cudaResourceViewDesc* pResViewDesc) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaCreateTextureObject(pTexObject, pResDesc, pTexDesc, pResViewDesc) -{{endif}} + return _runtime._cudaCreateTextureObject(pTexObject, pResDesc, pTexDesc, pResViewDesc) -{{if 'cudaDestroyTextureObject' in found_functions}} cdef cudaError_t cudaDestroyTextureObject(cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaDestroyTextureObject(texObject) -{{endif}} + return _runtime._cudaDestroyTextureObject(texObject) -{{if 'cudaGetTextureObjectResourceDesc' in found_functions}} cdef cudaError_t cudaGetTextureObjectResourceDesc(cudaResourceDesc* pResDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGetTextureObjectResourceDesc(pResDesc, texObject) -{{endif}} + return _runtime._cudaGetTextureObjectResourceDesc(pResDesc, texObject) -{{if 'cudaGetTextureObjectTextureDesc' in found_functions}} cdef cudaError_t cudaGetTextureObjectTextureDesc(cudaTextureDesc* pTexDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGetTextureObjectTextureDesc(pTexDesc, texObject) -{{endif}} + return _runtime._cudaGetTextureObjectTextureDesc(pTexDesc, texObject) -{{if 'cudaGetTextureObjectResourceViewDesc' in found_functions}} cdef cudaError_t cudaGetTextureObjectResourceViewDesc(cudaResourceViewDesc* pResViewDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGetTextureObjectResourceViewDesc(pResViewDesc, texObject) -{{endif}} + return _runtime._cudaGetTextureObjectResourceViewDesc(pResViewDesc, texObject) -{{if 'cudaCreateSurfaceObject' in found_functions}} cdef cudaError_t cudaCreateSurfaceObject(cudaSurfaceObject_t* pSurfObject, const cudaResourceDesc* pResDesc) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaCreateSurfaceObject(pSurfObject, pResDesc) -{{endif}} + return _runtime._cudaCreateSurfaceObject(pSurfObject, pResDesc) -{{if 'cudaDestroySurfaceObject' in found_functions}} cdef cudaError_t cudaDestroySurfaceObject(cudaSurfaceObject_t surfObject) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaDestroySurfaceObject(surfObject) -{{endif}} + return _runtime._cudaDestroySurfaceObject(surfObject) -{{if 'cudaGetSurfaceObjectResourceDesc' in found_functions}} cdef cudaError_t cudaGetSurfaceObjectResourceDesc(cudaResourceDesc* pResDesc, cudaSurfaceObject_t surfObject) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGetSurfaceObjectResourceDesc(pResDesc, surfObject) -{{endif}} + return _runtime._cudaGetSurfaceObjectResourceDesc(pResDesc, surfObject) -{{if 'cudaDriverGetVersion' in found_functions}} cdef cudaError_t cudaDriverGetVersion(int* driverVersion) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaDriverGetVersion(driverVersion) -{{endif}} + return _runtime._cudaDriverGetVersion(driverVersion) -{{if 'cudaRuntimeGetVersion' in found_functions}} cdef cudaError_t cudaRuntimeGetVersion(int* runtimeVersion) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaRuntimeGetVersion(runtimeVersion) -{{endif}} - -{{if 'cudaLogsRegisterCallback' in found_functions}} - -cdef cudaError_t cudaLogsRegisterCallback(cudaLogsCallback_t callbackFunc, void* userData, cudaLogsCallbackHandle* callback_out) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaLogsRegisterCallback(callbackFunc, userData, callback_out) -{{endif}} - -{{if 'cudaLogsUnregisterCallback' in found_functions}} - -cdef cudaError_t cudaLogsUnregisterCallback(cudaLogsCallbackHandle callback) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaLogsUnregisterCallback(callback) -{{endif}} - -{{if 'cudaLogsCurrent' in found_functions}} - -cdef cudaError_t cudaLogsCurrent(cudaLogIterator* iterator_out, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaLogsCurrent(iterator_out, flags) -{{endif}} - -{{if 'cudaLogsDumpToFile' in found_functions}} - -cdef cudaError_t cudaLogsDumpToFile(cudaLogIterator* iterator, const char* pathToFile, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaLogsDumpToFile(iterator, pathToFile, flags) -{{endif}} - -{{if 'cudaLogsDumpToMemory' in found_functions}} - -cdef cudaError_t cudaLogsDumpToMemory(cudaLogIterator* iterator, char* buffer, size_t* size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaLogsDumpToMemory(iterator, buffer, size, flags) -{{endif}} + return _runtime._cudaRuntimeGetVersion(runtimeVersion) -{{if 'cudaGraphCreate' in found_functions}} cdef cudaError_t cudaGraphCreate(cudaGraph_t* pGraph, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphCreate(pGraph, flags) -{{endif}} + return _runtime._cudaGraphCreate(pGraph, flags) -{{if 'cudaGraphAddKernelNode' in found_functions}} cdef cudaError_t cudaGraphAddKernelNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphAddKernelNode(pGraphNode, graph, pDependencies, numDependencies, pNodeParams) -{{endif}} + return _runtime._cudaGraphAddKernelNode(pGraphNode, graph, pDependencies, numDependencies, pNodeParams) -{{if 'cudaGraphKernelNodeGetParams' in found_functions}} cdef cudaError_t cudaGraphKernelNodeGetParams(cudaGraphNode_t node, cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphKernelNodeGetParams(node, pNodeParams) -{{endif}} + return _runtime._cudaGraphKernelNodeGetParams(node, pNodeParams) -{{if 'cudaGraphKernelNodeSetParams' in found_functions}} cdef cudaError_t cudaGraphKernelNodeSetParams(cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphKernelNodeSetParams(node, pNodeParams) -{{endif}} + return _runtime._cudaGraphKernelNodeSetParams(node, pNodeParams) -{{if 'cudaGraphKernelNodeCopyAttributes' in found_functions}} cdef cudaError_t cudaGraphKernelNodeCopyAttributes(cudaGraphNode_t hDst, cudaGraphNode_t hSrc) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphKernelNodeCopyAttributes(hDst, hSrc) -{{endif}} + return _runtime._cudaGraphKernelNodeCopyAttributes(hDst, hSrc) -{{if 'cudaGraphKernelNodeGetAttribute' in found_functions}} cdef cudaError_t cudaGraphKernelNodeGetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, cudaKernelNodeAttrValue* value_out) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphKernelNodeGetAttribute(hNode, attr, value_out) -{{endif}} + return _runtime._cudaGraphKernelNodeGetAttribute(hNode, attr, value_out) -{{if 'cudaGraphKernelNodeSetAttribute' in found_functions}} cdef cudaError_t cudaGraphKernelNodeSetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, const cudaKernelNodeAttrValue* value) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphKernelNodeSetAttribute(hNode, attr, value) -{{endif}} + return _runtime._cudaGraphKernelNodeSetAttribute(hNode, attr, value) -{{if 'cudaGraphAddMemcpyNode' in found_functions}} cdef cudaError_t cudaGraphAddMemcpyNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemcpy3DParms* pCopyParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphAddMemcpyNode(pGraphNode, graph, pDependencies, numDependencies, pCopyParams) -{{endif}} + return _runtime._cudaGraphAddMemcpyNode(pGraphNode, graph, pDependencies, numDependencies, pCopyParams) -{{if 'cudaGraphAddMemcpyNode1D' in found_functions}} cdef cudaError_t cudaGraphAddMemcpyNode1D(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphAddMemcpyNode1D(pGraphNode, graph, pDependencies, numDependencies, dst, src, count, kind) -{{endif}} + return _runtime._cudaGraphAddMemcpyNode1D(pGraphNode, graph, pDependencies, numDependencies, dst, src, count, kind) -{{if 'cudaGraphMemcpyNodeGetParams' in found_functions}} cdef cudaError_t cudaGraphMemcpyNodeGetParams(cudaGraphNode_t node, cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphMemcpyNodeGetParams(node, pNodeParams) -{{endif}} + return _runtime._cudaGraphMemcpyNodeGetParams(node, pNodeParams) -{{if 'cudaGraphMemcpyNodeSetParams' in found_functions}} cdef cudaError_t cudaGraphMemcpyNodeSetParams(cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphMemcpyNodeSetParams(node, pNodeParams) -{{endif}} + return _runtime._cudaGraphMemcpyNodeSetParams(node, pNodeParams) -{{if 'cudaGraphMemcpyNodeSetParams1D' in found_functions}} cdef cudaError_t cudaGraphMemcpyNodeSetParams1D(cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphMemcpyNodeSetParams1D(node, dst, src, count, kind) -{{endif}} + return _runtime._cudaGraphMemcpyNodeSetParams1D(node, dst, src, count, kind) -{{if 'cudaGraphAddMemsetNode' in found_functions}} cdef cudaError_t cudaGraphAddMemsetNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemsetParams* pMemsetParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphAddMemsetNode(pGraphNode, graph, pDependencies, numDependencies, pMemsetParams) -{{endif}} + return _runtime._cudaGraphAddMemsetNode(pGraphNode, graph, pDependencies, numDependencies, pMemsetParams) -{{if 'cudaGraphMemsetNodeGetParams' in found_functions}} cdef cudaError_t cudaGraphMemsetNodeGetParams(cudaGraphNode_t node, cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphMemsetNodeGetParams(node, pNodeParams) -{{endif}} + return _runtime._cudaGraphMemsetNodeGetParams(node, pNodeParams) -{{if 'cudaGraphMemsetNodeSetParams' in found_functions}} cdef cudaError_t cudaGraphMemsetNodeSetParams(cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphMemsetNodeSetParams(node, pNodeParams) -{{endif}} + return _runtime._cudaGraphMemsetNodeSetParams(node, pNodeParams) -{{if 'cudaGraphAddHostNode' in found_functions}} cdef cudaError_t cudaGraphAddHostNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphAddHostNode(pGraphNode, graph, pDependencies, numDependencies, pNodeParams) -{{endif}} + return _runtime._cudaGraphAddHostNode(pGraphNode, graph, pDependencies, numDependencies, pNodeParams) -{{if 'cudaGraphHostNodeGetParams' in found_functions}} cdef cudaError_t cudaGraphHostNodeGetParams(cudaGraphNode_t node, cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphHostNodeGetParams(node, pNodeParams) -{{endif}} + return _runtime._cudaGraphHostNodeGetParams(node, pNodeParams) -{{if 'cudaGraphHostNodeSetParams' in found_functions}} cdef cudaError_t cudaGraphHostNodeSetParams(cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphHostNodeSetParams(node, pNodeParams) -{{endif}} + return _runtime._cudaGraphHostNodeSetParams(node, pNodeParams) -{{if 'cudaGraphAddChildGraphNode' in found_functions}} cdef cudaError_t cudaGraphAddChildGraphNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaGraph_t childGraph) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphAddChildGraphNode(pGraphNode, graph, pDependencies, numDependencies, childGraph) -{{endif}} + return _runtime._cudaGraphAddChildGraphNode(pGraphNode, graph, pDependencies, numDependencies, childGraph) -{{if 'cudaGraphChildGraphNodeGetGraph' in found_functions}} cdef cudaError_t cudaGraphChildGraphNodeGetGraph(cudaGraphNode_t node, cudaGraph_t* pGraph) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphChildGraphNodeGetGraph(node, pGraph) -{{endif}} + return _runtime._cudaGraphChildGraphNodeGetGraph(node, pGraph) -{{if 'cudaGraphAddEmptyNode' in found_functions}} cdef cudaError_t cudaGraphAddEmptyNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphAddEmptyNode(pGraphNode, graph, pDependencies, numDependencies) -{{endif}} + return _runtime._cudaGraphAddEmptyNode(pGraphNode, graph, pDependencies, numDependencies) -{{if 'cudaGraphAddEventRecordNode' in found_functions}} cdef cudaError_t cudaGraphAddEventRecordNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphAddEventRecordNode(pGraphNode, graph, pDependencies, numDependencies, event) -{{endif}} + return _runtime._cudaGraphAddEventRecordNode(pGraphNode, graph, pDependencies, numDependencies, event) -{{if 'cudaGraphEventRecordNodeGetEvent' in found_functions}} cdef cudaError_t cudaGraphEventRecordNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphEventRecordNodeGetEvent(node, event_out) -{{endif}} + return _runtime._cudaGraphEventRecordNodeGetEvent(node, event_out) -{{if 'cudaGraphEventRecordNodeSetEvent' in found_functions}} cdef cudaError_t cudaGraphEventRecordNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphEventRecordNodeSetEvent(node, event) -{{endif}} + return _runtime._cudaGraphEventRecordNodeSetEvent(node, event) -{{if 'cudaGraphAddEventWaitNode' in found_functions}} cdef cudaError_t cudaGraphAddEventWaitNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphAddEventWaitNode(pGraphNode, graph, pDependencies, numDependencies, event) -{{endif}} + return _runtime._cudaGraphAddEventWaitNode(pGraphNode, graph, pDependencies, numDependencies, event) -{{if 'cudaGraphEventWaitNodeGetEvent' in found_functions}} cdef cudaError_t cudaGraphEventWaitNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphEventWaitNodeGetEvent(node, event_out) -{{endif}} + return _runtime._cudaGraphEventWaitNodeGetEvent(node, event_out) -{{if 'cudaGraphEventWaitNodeSetEvent' in found_functions}} cdef cudaError_t cudaGraphEventWaitNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphEventWaitNodeSetEvent(node, event) -{{endif}} + return _runtime._cudaGraphEventWaitNodeSetEvent(node, event) -{{if 'cudaGraphAddExternalSemaphoresSignalNode' in found_functions}} cdef cudaError_t cudaGraphAddExternalSemaphoresSignalNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphAddExternalSemaphoresSignalNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams) -{{endif}} + return _runtime._cudaGraphAddExternalSemaphoresSignalNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams) -{{if 'cudaGraphExternalSemaphoresSignalNodeGetParams' in found_functions}} cdef cudaError_t cudaGraphExternalSemaphoresSignalNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreSignalNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphExternalSemaphoresSignalNodeGetParams(hNode, params_out) -{{endif}} + return _runtime._cudaGraphExternalSemaphoresSignalNodeGetParams(hNode, params_out) -{{if 'cudaGraphExternalSemaphoresSignalNodeSetParams' in found_functions}} cdef cudaError_t cudaGraphExternalSemaphoresSignalNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphExternalSemaphoresSignalNodeSetParams(hNode, nodeParams) -{{endif}} + return _runtime._cudaGraphExternalSemaphoresSignalNodeSetParams(hNode, nodeParams) -{{if 'cudaGraphAddExternalSemaphoresWaitNode' in found_functions}} cdef cudaError_t cudaGraphAddExternalSemaphoresWaitNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphAddExternalSemaphoresWaitNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams) -{{endif}} + return _runtime._cudaGraphAddExternalSemaphoresWaitNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams) -{{if 'cudaGraphExternalSemaphoresWaitNodeGetParams' in found_functions}} cdef cudaError_t cudaGraphExternalSemaphoresWaitNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreWaitNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphExternalSemaphoresWaitNodeGetParams(hNode, params_out) -{{endif}} + return _runtime._cudaGraphExternalSemaphoresWaitNodeGetParams(hNode, params_out) -{{if 'cudaGraphExternalSemaphoresWaitNodeSetParams' in found_functions}} cdef cudaError_t cudaGraphExternalSemaphoresWaitNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphExternalSemaphoresWaitNodeSetParams(hNode, nodeParams) -{{endif}} + return _runtime._cudaGraphExternalSemaphoresWaitNodeSetParams(hNode, nodeParams) -{{if 'cudaGraphAddMemAllocNode' in found_functions}} cdef cudaError_t cudaGraphAddMemAllocNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaMemAllocNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphAddMemAllocNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams) -{{endif}} + return _runtime._cudaGraphAddMemAllocNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams) -{{if 'cudaGraphMemAllocNodeGetParams' in found_functions}} cdef cudaError_t cudaGraphMemAllocNodeGetParams(cudaGraphNode_t node, cudaMemAllocNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphMemAllocNodeGetParams(node, params_out) -{{endif}} + return _runtime._cudaGraphMemAllocNodeGetParams(node, params_out) -{{if 'cudaGraphAddMemFreeNode' in found_functions}} cdef cudaError_t cudaGraphAddMemFreeNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dptr) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphAddMemFreeNode(pGraphNode, graph, pDependencies, numDependencies, dptr) -{{endif}} + return _runtime._cudaGraphAddMemFreeNode(pGraphNode, graph, pDependencies, numDependencies, dptr) -{{if 'cudaGraphMemFreeNodeGetParams' in found_functions}} cdef cudaError_t cudaGraphMemFreeNodeGetParams(cudaGraphNode_t node, void* dptr_out) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphMemFreeNodeGetParams(node, dptr_out) -{{endif}} + return _runtime._cudaGraphMemFreeNodeGetParams(node, dptr_out) -{{if 'cudaDeviceGraphMemTrim' in found_functions}} cdef cudaError_t cudaDeviceGraphMemTrim(int device) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaDeviceGraphMemTrim(device) -{{endif}} + return _runtime._cudaDeviceGraphMemTrim(device) -{{if 'cudaDeviceGetGraphMemAttribute' in found_functions}} cdef cudaError_t cudaDeviceGetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaDeviceGetGraphMemAttribute(device, attr, value) -{{endif}} + return _runtime._cudaDeviceGetGraphMemAttribute(device, attr, value) -{{if 'cudaDeviceSetGraphMemAttribute' in found_functions}} cdef cudaError_t cudaDeviceSetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaDeviceSetGraphMemAttribute(device, attr, value) -{{endif}} + return _runtime._cudaDeviceSetGraphMemAttribute(device, attr, value) -{{if 'cudaGraphClone' in found_functions}} cdef cudaError_t cudaGraphClone(cudaGraph_t* pGraphClone, cudaGraph_t originalGraph) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphClone(pGraphClone, originalGraph) -{{endif}} + return _runtime._cudaGraphClone(pGraphClone, originalGraph) -{{if 'cudaGraphNodeFindInClone' in found_functions}} cdef cudaError_t cudaGraphNodeFindInClone(cudaGraphNode_t* pNode, cudaGraphNode_t originalNode, cudaGraph_t clonedGraph) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphNodeFindInClone(pNode, originalNode, clonedGraph) -{{endif}} + return _runtime._cudaGraphNodeFindInClone(pNode, originalNode, clonedGraph) -{{if 'cudaGraphNodeGetType' in found_functions}} cdef cudaError_t cudaGraphNodeGetType(cudaGraphNode_t node, cudaGraphNodeType* pType) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphNodeGetType(node, pType) -{{endif}} + return _runtime._cudaGraphNodeGetType(node, pType) -{{if 'cudaGraphNodeGetContainingGraph' in found_functions}} - -cdef cudaError_t cudaGraphNodeGetContainingGraph(cudaGraphNode_t hNode, cudaGraph_t* phGraph) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphNodeGetContainingGraph(hNode, phGraph) -{{endif}} - -{{if 'cudaGraphNodeGetLocalId' in found_functions}} - -cdef cudaError_t cudaGraphNodeGetLocalId(cudaGraphNode_t hNode, unsigned int* nodeId) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphNodeGetLocalId(hNode, nodeId) -{{endif}} - -{{if 'cudaGraphNodeGetToolsId' in found_functions}} - -cdef cudaError_t cudaGraphNodeGetToolsId(cudaGraphNode_t hNode, unsigned long long* toolsNodeId) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphNodeGetToolsId(hNode, toolsNodeId) -{{endif}} - -{{if 'cudaGraphGetId' in found_functions}} - -cdef cudaError_t cudaGraphGetId(cudaGraph_t hGraph, unsigned int* graphID) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphGetId(hGraph, graphID) -{{endif}} - -{{if 'cudaGraphExecGetId' in found_functions}} - -cdef cudaError_t cudaGraphExecGetId(cudaGraphExec_t hGraphExec, unsigned int* graphID) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphExecGetId(hGraphExec, graphID) -{{endif}} - -{{if 'cudaGraphGetNodes' in found_functions}} cdef cudaError_t cudaGraphGetNodes(cudaGraph_t graph, cudaGraphNode_t* nodes, size_t* numNodes) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphGetNodes(graph, nodes, numNodes) -{{endif}} + return _runtime._cudaGraphGetNodes(graph, nodes, numNodes) -{{if 'cudaGraphGetRootNodes' in found_functions}} cdef cudaError_t cudaGraphGetRootNodes(cudaGraph_t graph, cudaGraphNode_t* pRootNodes, size_t* pNumRootNodes) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphGetRootNodes(graph, pRootNodes, pNumRootNodes) -{{endif}} + return _runtime._cudaGraphGetRootNodes(graph, pRootNodes, pNumRootNodes) -{{if 'cudaGraphGetEdges' in found_functions}} cdef cudaError_t cudaGraphGetEdges(cudaGraph_t graph, cudaGraphNode_t* from_, cudaGraphNode_t* to, cudaGraphEdgeData* edgeData, size_t* numEdges) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphGetEdges(graph, from_, to, edgeData, numEdges) -{{endif}} + return _runtime._cudaGraphGetEdges(graph, from_, to, edgeData, numEdges) -{{if 'cudaGraphNodeGetDependencies' in found_functions}} cdef cudaError_t cudaGraphNodeGetDependencies(cudaGraphNode_t node, cudaGraphNode_t* pDependencies, cudaGraphEdgeData* edgeData, size_t* pNumDependencies) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphNodeGetDependencies(node, pDependencies, edgeData, pNumDependencies) -{{endif}} + return _runtime._cudaGraphNodeGetDependencies(node, pDependencies, edgeData, pNumDependencies) -{{if 'cudaGraphNodeGetDependentNodes' in found_functions}} cdef cudaError_t cudaGraphNodeGetDependentNodes(cudaGraphNode_t node, cudaGraphNode_t* pDependentNodes, cudaGraphEdgeData* edgeData, size_t* pNumDependentNodes) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphNodeGetDependentNodes(node, pDependentNodes, edgeData, pNumDependentNodes) -{{endif}} + return _runtime._cudaGraphNodeGetDependentNodes(node, pDependentNodes, edgeData, pNumDependentNodes) -{{if 'cudaGraphAddDependencies' in found_functions}} cdef cudaError_t cudaGraphAddDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, const cudaGraphEdgeData* edgeData, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphAddDependencies(graph, from_, to, edgeData, numDependencies) -{{endif}} + return _runtime._cudaGraphAddDependencies(graph, from_, to, edgeData, numDependencies) -{{if 'cudaGraphRemoveDependencies' in found_functions}} cdef cudaError_t cudaGraphRemoveDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, const cudaGraphEdgeData* edgeData, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphRemoveDependencies(graph, from_, to, edgeData, numDependencies) -{{endif}} + return _runtime._cudaGraphRemoveDependencies(graph, from_, to, edgeData, numDependencies) -{{if 'cudaGraphDestroyNode' in found_functions}} cdef cudaError_t cudaGraphDestroyNode(cudaGraphNode_t node) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphDestroyNode(node) -{{endif}} + return _runtime._cudaGraphDestroyNode(node) -{{if 'cudaGraphInstantiate' in found_functions}} cdef cudaError_t cudaGraphInstantiate(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphInstantiate(pGraphExec, graph, flags) -{{endif}} + return _runtime._cudaGraphInstantiate(pGraphExec, graph, flags) -{{if 'cudaGraphInstantiateWithFlags' in found_functions}} cdef cudaError_t cudaGraphInstantiateWithFlags(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphInstantiateWithFlags(pGraphExec, graph, flags) -{{endif}} + return _runtime._cudaGraphInstantiateWithFlags(pGraphExec, graph, flags) -{{if 'cudaGraphInstantiateWithParams' in found_functions}} cdef cudaError_t cudaGraphInstantiateWithParams(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, cudaGraphInstantiateParams* instantiateParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphInstantiateWithParams(pGraphExec, graph, instantiateParams) -{{endif}} + return _runtime._cudaGraphInstantiateWithParams(pGraphExec, graph, instantiateParams) -{{if 'cudaGraphExecGetFlags' in found_functions}} cdef cudaError_t cudaGraphExecGetFlags(cudaGraphExec_t graphExec, unsigned long long* flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphExecGetFlags(graphExec, flags) -{{endif}} + return _runtime._cudaGraphExecGetFlags(graphExec, flags) -{{if 'cudaGraphExecKernelNodeSetParams' in found_functions}} cdef cudaError_t cudaGraphExecKernelNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphExecKernelNodeSetParams(hGraphExec, node, pNodeParams) -{{endif}} + return _runtime._cudaGraphExecKernelNodeSetParams(hGraphExec, node, pNodeParams) -{{if 'cudaGraphExecMemcpyNodeSetParams' in found_functions}} cdef cudaError_t cudaGraphExecMemcpyNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphExecMemcpyNodeSetParams(hGraphExec, node, pNodeParams) -{{endif}} + return _runtime._cudaGraphExecMemcpyNodeSetParams(hGraphExec, node, pNodeParams) -{{if 'cudaGraphExecMemcpyNodeSetParams1D' in found_functions}} cdef cudaError_t cudaGraphExecMemcpyNodeSetParams1D(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphExecMemcpyNodeSetParams1D(hGraphExec, node, dst, src, count, kind) -{{endif}} + return _runtime._cudaGraphExecMemcpyNodeSetParams1D(hGraphExec, node, dst, src, count, kind) -{{if 'cudaGraphExecMemsetNodeSetParams' in found_functions}} cdef cudaError_t cudaGraphExecMemsetNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphExecMemsetNodeSetParams(hGraphExec, node, pNodeParams) -{{endif}} + return _runtime._cudaGraphExecMemsetNodeSetParams(hGraphExec, node, pNodeParams) -{{if 'cudaGraphExecHostNodeSetParams' in found_functions}} cdef cudaError_t cudaGraphExecHostNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphExecHostNodeSetParams(hGraphExec, node, pNodeParams) -{{endif}} + return _runtime._cudaGraphExecHostNodeSetParams(hGraphExec, node, pNodeParams) -{{if 'cudaGraphExecChildGraphNodeSetParams' in found_functions}} cdef cudaError_t cudaGraphExecChildGraphNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, cudaGraph_t childGraph) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphExecChildGraphNodeSetParams(hGraphExec, node, childGraph) -{{endif}} + return _runtime._cudaGraphExecChildGraphNodeSetParams(hGraphExec, node, childGraph) -{{if 'cudaGraphExecEventRecordNodeSetEvent' in found_functions}} cdef cudaError_t cudaGraphExecEventRecordNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphExecEventRecordNodeSetEvent(hGraphExec, hNode, event) -{{endif}} + return _runtime._cudaGraphExecEventRecordNodeSetEvent(hGraphExec, hNode, event) -{{if 'cudaGraphExecEventWaitNodeSetEvent' in found_functions}} cdef cudaError_t cudaGraphExecEventWaitNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphExecEventWaitNodeSetEvent(hGraphExec, hNode, event) -{{endif}} + return _runtime._cudaGraphExecEventWaitNodeSetEvent(hGraphExec, hNode, event) -{{if 'cudaGraphExecExternalSemaphoresSignalNodeSetParams' in found_functions}} cdef cudaError_t cudaGraphExecExternalSemaphoresSignalNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphExecExternalSemaphoresSignalNodeSetParams(hGraphExec, hNode, nodeParams) -{{endif}} + return _runtime._cudaGraphExecExternalSemaphoresSignalNodeSetParams(hGraphExec, hNode, nodeParams) -{{if 'cudaGraphExecExternalSemaphoresWaitNodeSetParams' in found_functions}} cdef cudaError_t cudaGraphExecExternalSemaphoresWaitNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphExecExternalSemaphoresWaitNodeSetParams(hGraphExec, hNode, nodeParams) -{{endif}} + return _runtime._cudaGraphExecExternalSemaphoresWaitNodeSetParams(hGraphExec, hNode, nodeParams) -{{if 'cudaGraphNodeSetEnabled' in found_functions}} cdef cudaError_t cudaGraphNodeSetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int isEnabled) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphNodeSetEnabled(hGraphExec, hNode, isEnabled) -{{endif}} + return _runtime._cudaGraphNodeSetEnabled(hGraphExec, hNode, isEnabled) -{{if 'cudaGraphNodeGetEnabled' in found_functions}} cdef cudaError_t cudaGraphNodeGetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int* isEnabled) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphNodeGetEnabled(hGraphExec, hNode, isEnabled) -{{endif}} + return _runtime._cudaGraphNodeGetEnabled(hGraphExec, hNode, isEnabled) -{{if 'cudaGraphExecUpdate' in found_functions}} cdef cudaError_t cudaGraphExecUpdate(cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphExecUpdateResultInfo* resultInfo) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphExecUpdate(hGraphExec, hGraph, resultInfo) -{{endif}} + return _runtime._cudaGraphExecUpdate(hGraphExec, hGraph, resultInfo) -{{if 'cudaGraphUpload' in found_functions}} cdef cudaError_t cudaGraphUpload(cudaGraphExec_t graphExec, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphUpload(graphExec, stream) -{{endif}} + return _runtime._cudaGraphUpload(graphExec, stream) -{{if 'cudaGraphLaunch' in found_functions}} cdef cudaError_t cudaGraphLaunch(cudaGraphExec_t graphExec, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphLaunch(graphExec, stream) -{{endif}} + return _runtime._cudaGraphLaunch(graphExec, stream) -{{if 'cudaGraphExecDestroy' in found_functions}} cdef cudaError_t cudaGraphExecDestroy(cudaGraphExec_t graphExec) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphExecDestroy(graphExec) -{{endif}} + return _runtime._cudaGraphExecDestroy(graphExec) -{{if 'cudaGraphDestroy' in found_functions}} cdef cudaError_t cudaGraphDestroy(cudaGraph_t graph) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphDestroy(graph) -{{endif}} + return _runtime._cudaGraphDestroy(graph) -{{if 'cudaGraphDebugDotPrint' in found_functions}} cdef cudaError_t cudaGraphDebugDotPrint(cudaGraph_t graph, const char* path, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphDebugDotPrint(graph, path, flags) -{{endif}} + return _runtime._cudaGraphDebugDotPrint(graph, path, flags) -{{if 'cudaUserObjectCreate' in found_functions}} cdef cudaError_t cudaUserObjectCreate(cudaUserObject_t* object_out, void* ptr, cudaHostFn_t destroy, unsigned int initialRefcount, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaUserObjectCreate(object_out, ptr, destroy, initialRefcount, flags) -{{endif}} + return _runtime._cudaUserObjectCreate(object_out, ptr, destroy, initialRefcount, flags) -{{if 'cudaUserObjectRetain' in found_functions}} cdef cudaError_t cudaUserObjectRetain(cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaUserObjectRetain(object, count) -{{endif}} + return _runtime._cudaUserObjectRetain(object, count) -{{if 'cudaUserObjectRelease' in found_functions}} cdef cudaError_t cudaUserObjectRelease(cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaUserObjectRelease(object, count) -{{endif}} + return _runtime._cudaUserObjectRelease(object, count) -{{if 'cudaGraphRetainUserObject' in found_functions}} cdef cudaError_t cudaGraphRetainUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphRetainUserObject(graph, object, count, flags) -{{endif}} + return _runtime._cudaGraphRetainUserObject(graph, object, count, flags) -{{if 'cudaGraphReleaseUserObject' in found_functions}} cdef cudaError_t cudaGraphReleaseUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphReleaseUserObject(graph, object, count) -{{endif}} + return _runtime._cudaGraphReleaseUserObject(graph, object, count) -{{if 'cudaGraphAddNode' in found_functions}} cdef cudaError_t cudaGraphAddNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphAddNode(pGraphNode, graph, pDependencies, dependencyData, numDependencies, nodeParams) -{{endif}} + return _runtime._cudaGraphAddNode(pGraphNode, graph, pDependencies, dependencyData, numDependencies, nodeParams) -{{if 'cudaGraphNodeSetParams' in found_functions}} cdef cudaError_t cudaGraphNodeSetParams(cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphNodeSetParams(node, nodeParams) -{{endif}} + return _runtime._cudaGraphNodeSetParams(node, nodeParams) -{{if 'cudaGraphNodeGetParams' in found_functions}} - -cdef cudaError_t cudaGraphNodeGetParams(cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphNodeGetParams(node, nodeParams) -{{endif}} - -{{if 'cudaGraphExecNodeSetParams' in found_functions}} cdef cudaError_t cudaGraphExecNodeSetParams(cudaGraphExec_t graphExec, cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphExecNodeSetParams(graphExec, node, nodeParams) -{{endif}} + return _runtime._cudaGraphExecNodeSetParams(graphExec, node, nodeParams) -{{if 'cudaGraphConditionalHandleCreate' in found_functions}} cdef cudaError_t cudaGraphConditionalHandleCreate(cudaGraphConditionalHandle* pHandle_out, cudaGraph_t graph, unsigned int defaultLaunchValue, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphConditionalHandleCreate(pHandle_out, graph, defaultLaunchValue, flags) -{{endif}} - -{{if 'cudaGraphConditionalHandleCreate_v2' in found_functions}} - -cdef cudaError_t cudaGraphConditionalHandleCreate_v2(cudaGraphConditionalHandle* pHandle_out, cudaGraph_t graph, cudaExecutionContext_t ctx, unsigned int defaultLaunchValue, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphConditionalHandleCreate_v2(pHandle_out, graph, ctx, defaultLaunchValue, flags) -{{endif}} + return _runtime._cudaGraphConditionalHandleCreate(pHandle_out, graph, defaultLaunchValue, flags) -{{if 'cudaGetDriverEntryPoint' in found_functions}} cdef cudaError_t cudaGetDriverEntryPoint(const char* symbol, void** funcPtr, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGetDriverEntryPoint(symbol, funcPtr, flags, driverStatus) -{{endif}} + return _runtime._cudaGetDriverEntryPoint(symbol, funcPtr, flags, driverStatus) -{{if 'cudaGetDriverEntryPointByVersion' in found_functions}} cdef cudaError_t cudaGetDriverEntryPointByVersion(const char* symbol, void** funcPtr, unsigned int cudaVersion, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGetDriverEntryPointByVersion(symbol, funcPtr, cudaVersion, flags, driverStatus) -{{endif}} + return _runtime._cudaGetDriverEntryPointByVersion(symbol, funcPtr, cudaVersion, flags, driverStatus) -{{if 'cudaLibraryLoadData' in found_functions}} cdef cudaError_t cudaLibraryLoadData(cudaLibrary_t* library, const void* code, cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaLibraryLoadData(library, code, jitOptions, jitOptionsValues, numJitOptions, libraryOptions, libraryOptionValues, numLibraryOptions) -{{endif}} + return _runtime._cudaLibraryLoadData(library, code, jitOptions, jitOptionsValues, numJitOptions, libraryOptions, libraryOptionValues, numLibraryOptions) -{{if 'cudaLibraryLoadFromFile' in found_functions}} cdef cudaError_t cudaLibraryLoadFromFile(cudaLibrary_t* library, const char* fileName, cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaLibraryLoadFromFile(library, fileName, jitOptions, jitOptionsValues, numJitOptions, libraryOptions, libraryOptionValues, numLibraryOptions) -{{endif}} + return _runtime._cudaLibraryLoadFromFile(library, fileName, jitOptions, jitOptionsValues, numJitOptions, libraryOptions, libraryOptionValues, numLibraryOptions) -{{if 'cudaLibraryUnload' in found_functions}} cdef cudaError_t cudaLibraryUnload(cudaLibrary_t library) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaLibraryUnload(library) -{{endif}} + return _runtime._cudaLibraryUnload(library) -{{if 'cudaLibraryGetKernel' in found_functions}} cdef cudaError_t cudaLibraryGetKernel(cudaKernel_t* pKernel, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaLibraryGetKernel(pKernel, library, name) -{{endif}} + return _runtime._cudaLibraryGetKernel(pKernel, library, name) -{{if 'cudaLibraryGetGlobal' in found_functions}} -cdef cudaError_t cudaLibraryGetGlobal(void** dptr, size_t* numbytes, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaLibraryGetGlobal(dptr, numbytes, library, name) -{{endif}} +cdef cudaError_t cudaLibraryGetGlobal(void** dptr, size_t* bytes, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaLibraryGetGlobal(dptr, bytes, library, name) -{{if 'cudaLibraryGetManaged' in found_functions}} -cdef cudaError_t cudaLibraryGetManaged(void** dptr, size_t* numbytes, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaLibraryGetManaged(dptr, numbytes, library, name) -{{endif}} +cdef cudaError_t cudaLibraryGetManaged(void** dptr, size_t* bytes, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaLibraryGetManaged(dptr, bytes, library, name) -{{if 'cudaLibraryGetUnifiedFunction' in found_functions}} cdef cudaError_t cudaLibraryGetUnifiedFunction(void** fptr, cudaLibrary_t library, const char* symbol) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaLibraryGetUnifiedFunction(fptr, library, symbol) -{{endif}} + return _runtime._cudaLibraryGetUnifiedFunction(fptr, library, symbol) -{{if 'cudaLibraryGetKernelCount' in found_functions}} cdef cudaError_t cudaLibraryGetKernelCount(unsigned int* count, cudaLibrary_t lib) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaLibraryGetKernelCount(count, lib) -{{endif}} + return _runtime._cudaLibraryGetKernelCount(count, lib) -{{if 'cudaLibraryEnumerateKernels' in found_functions}} cdef cudaError_t cudaLibraryEnumerateKernels(cudaKernel_t* kernels, unsigned int numKernels, cudaLibrary_t lib) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaLibraryEnumerateKernels(kernels, numKernels, lib) -{{endif}} + return _runtime._cudaLibraryEnumerateKernels(kernels, numKernels, lib) -{{if 'cudaKernelSetAttributeForDevice' in found_functions}} cdef cudaError_t cudaKernelSetAttributeForDevice(cudaKernel_t kernel, cudaFuncAttribute attr, int value, int device) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaKernelSetAttributeForDevice(kernel, attr, value, device) -{{endif}} + return _runtime._cudaKernelSetAttributeForDevice(kernel, attr, value, device) -{{if 'cudaDeviceGetDevResource' in found_functions}} -cdef cudaError_t cudaDeviceGetDevResource(int device, cudaDevResource* resource, cudaDevResourceType typename) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaDeviceGetDevResource(device, resource, typename) -{{endif}} +cdef cudaError_t cudaGetExportTable(const void** ppExportTable, const cudaUUID_t* pExportTableId) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaGetExportTable(ppExportTable, pExportTableId) -{{if 'cudaDevSmResourceSplitByCount' in found_functions}} -cdef cudaError_t cudaDevSmResourceSplitByCount(cudaDevResource* result, unsigned int* nbGroups, const cudaDevResource* input, cudaDevResource* remaining, unsigned int flags, unsigned int minCount) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaDevSmResourceSplitByCount(result, nbGroups, input, remaining, flags, minCount) -{{endif}} +cdef cudaError_t cudaGetKernel(cudaKernel_t* kernelPtr, const void* entryFuncAddr) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaGetKernel(kernelPtr, entryFuncAddr) -{{if 'cudaDevSmResourceSplit' in found_functions}} -cdef cudaError_t cudaDevSmResourceSplit(cudaDevResource* result, unsigned int nbGroups, const cudaDevResource* input, cudaDevResource* remainder, unsigned int flags, cudaDevSmResourceGroupParams* groupParams) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaDevSmResourceSplit(result, nbGroups, input, remainder, flags, groupParams) -{{endif}} +cdef cudaError_t cudaGraphicsEGLRegisterImage(cudaGraphicsResource** pCudaResource, EGLImageKHR image, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaGraphicsEGLRegisterImage(pCudaResource, image, flags) -{{if 'cudaDevResourceGenerateDesc' in found_functions}} -cdef cudaError_t cudaDevResourceGenerateDesc(cudaDevResourceDesc_t* phDesc, cudaDevResource* resources, unsigned int nbResources) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaDevResourceGenerateDesc(phDesc, resources, nbResources) -{{endif}} +cdef cudaError_t cudaEGLStreamConsumerConnect(cudaEglStreamConnection* conn, EGLStreamKHR eglStream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaEGLStreamConsumerConnect(conn, eglStream) -{{if 'cudaGreenCtxCreate' in found_functions}} -cdef cudaError_t cudaGreenCtxCreate(cudaExecutionContext_t* phCtx, cudaDevResourceDesc_t desc, int device, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGreenCtxCreate(phCtx, desc, device, flags) -{{endif}} +cdef cudaError_t cudaEGLStreamConsumerConnectWithFlags(cudaEglStreamConnection* conn, EGLStreamKHR eglStream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaEGLStreamConsumerConnectWithFlags(conn, eglStream, flags) -{{if 'cudaExecutionCtxDestroy' in found_functions}} -cdef cudaError_t cudaExecutionCtxDestroy(cudaExecutionContext_t ctx) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaExecutionCtxDestroy(ctx) -{{endif}} +cdef cudaError_t cudaEGLStreamConsumerDisconnect(cudaEglStreamConnection* conn) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaEGLStreamConsumerDisconnect(conn) -{{if 'cudaExecutionCtxGetDevResource' in found_functions}} -cdef cudaError_t cudaExecutionCtxGetDevResource(cudaExecutionContext_t ctx, cudaDevResource* resource, cudaDevResourceType typename) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaExecutionCtxGetDevResource(ctx, resource, typename) -{{endif}} +cdef cudaError_t cudaEGLStreamConsumerAcquireFrame(cudaEglStreamConnection* conn, cudaGraphicsResource_t* pCudaResource, cudaStream_t* pStream, unsigned int timeout) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaEGLStreamConsumerAcquireFrame(conn, pCudaResource, pStream, timeout) -{{if 'cudaExecutionCtxGetDevice' in found_functions}} -cdef cudaError_t cudaExecutionCtxGetDevice(int* device, cudaExecutionContext_t ctx) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaExecutionCtxGetDevice(device, ctx) -{{endif}} +cdef cudaError_t cudaEGLStreamConsumerReleaseFrame(cudaEglStreamConnection* conn, cudaGraphicsResource_t pCudaResource, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaEGLStreamConsumerReleaseFrame(conn, pCudaResource, pStream) -{{if 'cudaExecutionCtxGetId' in found_functions}} -cdef cudaError_t cudaExecutionCtxGetId(cudaExecutionContext_t ctx, unsigned long long* ctxId) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaExecutionCtxGetId(ctx, ctxId) -{{endif}} +cdef cudaError_t cudaEGLStreamProducerConnect(cudaEglStreamConnection* conn, EGLStreamKHR eglStream, EGLint width, EGLint height) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaEGLStreamProducerConnect(conn, eglStream, width, height) -{{if 'cudaExecutionCtxStreamCreate' in found_functions}} -cdef cudaError_t cudaExecutionCtxStreamCreate(cudaStream_t* phStream, cudaExecutionContext_t ctx, unsigned int flags, int priority) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaExecutionCtxStreamCreate(phStream, ctx, flags, priority) -{{endif}} +cdef cudaError_t cudaEGLStreamProducerDisconnect(cudaEglStreamConnection* conn) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaEGLStreamProducerDisconnect(conn) -{{if 'cudaExecutionCtxSynchronize' in found_functions}} -cdef cudaError_t cudaExecutionCtxSynchronize(cudaExecutionContext_t ctx) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaExecutionCtxSynchronize(ctx) -{{endif}} +cdef cudaError_t cudaEGLStreamProducerPresentFrame(cudaEglStreamConnection* conn, cudaEglFrame eglframe, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaEGLStreamProducerPresentFrame(conn, eglframe, pStream) -{{if 'cudaStreamGetDevResource' in found_functions}} -cdef cudaError_t cudaStreamGetDevResource(cudaStream_t hStream, cudaDevResource* resource, cudaDevResourceType typename) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaStreamGetDevResource(hStream, resource, typename) -{{endif}} +cdef cudaError_t cudaEGLStreamProducerReturnFrame(cudaEglStreamConnection* conn, cudaEglFrame* eglframe, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaEGLStreamProducerReturnFrame(conn, eglframe, pStream) -{{if 'cudaExecutionCtxRecordEvent' in found_functions}} -cdef cudaError_t cudaExecutionCtxRecordEvent(cudaExecutionContext_t ctx, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaExecutionCtxRecordEvent(ctx, event) -{{endif}} +cdef cudaError_t cudaGraphicsResourceGetMappedEglFrame(cudaEglFrame* eglFrame, cudaGraphicsResource_t resource, unsigned int index, unsigned int mipLevel) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaGraphicsResourceGetMappedEglFrame(eglFrame, resource, index, mipLevel) -{{if 'cudaExecutionCtxWaitEvent' in found_functions}} -cdef cudaError_t cudaExecutionCtxWaitEvent(cudaExecutionContext_t ctx, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaExecutionCtxWaitEvent(ctx, event) -{{endif}} +cdef cudaError_t cudaEventCreateFromEGLSync(cudaEvent_t* phEvent, EGLSyncKHR eglSync, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaEventCreateFromEGLSync(phEvent, eglSync, flags) -{{if 'cudaDeviceGetExecutionCtx' in found_functions}} -cdef cudaError_t cudaDeviceGetExecutionCtx(cudaExecutionContext_t* ctx, int device) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaDeviceGetExecutionCtx(ctx, device) -{{endif}} +cdef cudaError_t cudaProfilerStart() except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaProfilerStart() -{{if 'cudaGetExportTable' in found_functions}} -cdef cudaError_t cudaGetExportTable(const void** ppExportTable, const cudaUUID_t* pExportTableId) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGetExportTable(ppExportTable, pExportTableId) -{{endif}} +cdef cudaError_t cudaProfilerStop() except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaProfilerStop() -{{if 'cudaGetKernel' in found_functions}} -cdef cudaError_t cudaGetKernel(cudaKernel_t* kernelPtr, const void* entryFuncAddr) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGetKernel(kernelPtr, entryFuncAddr) -{{endif}} +cdef cudaError_t cudaGLGetDevices(unsigned int* pCudaDeviceCount, int* pCudaDevices, unsigned int cudaDeviceCount, cudaGLDeviceList deviceList) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaGLGetDevices(pCudaDeviceCount, pCudaDevices, cudaDeviceCount, deviceList) -{{if 'make_cudaPitchedPtr' in found_functions}} -@cython.show_performance_hints(False) -cdef cudaPitchedPtr make_cudaPitchedPtr(void* d, size_t p, size_t xsz, size_t ysz) except* nogil: - return cyruntime._make_cudaPitchedPtr(d, p, xsz, ysz) -{{endif}} -{{if 'make_cudaPos' in found_functions}} -@cython.show_performance_hints(False) -cdef cudaPos make_cudaPos(size_t x, size_t y, size_t z) except* nogil: - return cyruntime._make_cudaPos(x, y, z) -{{endif}} +cdef cudaError_t cudaGraphicsGLRegisterImage(cudaGraphicsResource** resource, GLuint image, GLenum target, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaGraphicsGLRegisterImage(resource, image, target, flags) -{{if 'make_cudaExtent' in found_functions}} -@cython.show_performance_hints(False) -cdef cudaExtent make_cudaExtent(size_t w, size_t h, size_t d) except* nogil: - return cyruntime._make_cudaExtent(w, h, d) -{{endif}} -{{if True}} +cdef cudaError_t cudaGraphicsGLRegisterBuffer(cudaGraphicsResource** resource, GLuint buffer, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaGraphicsGLRegisterBuffer(resource, buffer, flags) -cdef cudaError_t cudaGraphicsEGLRegisterImage(cudaGraphicsResource** pCudaResource, EGLImageKHR image, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphicsEGLRegisterImage(pCudaResource, image, flags) -{{endif}} -{{if True}} +cdef cudaError_t cudaVDPAUGetDevice(int* device, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaVDPAUGetDevice(device, vdpDevice, vdpGetProcAddress) -cdef cudaError_t cudaEGLStreamConsumerConnect(cudaEglStreamConnection* conn, EGLStreamKHR eglStream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaEGLStreamConsumerConnect(conn, eglStream) -{{endif}} -{{if True}} +cdef cudaError_t cudaVDPAUSetVDPAUDevice(int device, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaVDPAUSetVDPAUDevice(device, vdpDevice, vdpGetProcAddress) -cdef cudaError_t cudaEGLStreamConsumerConnectWithFlags(cudaEglStreamConnection* conn, EGLStreamKHR eglStream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaEGLStreamConsumerConnectWithFlags(conn, eglStream, flags) -{{endif}} -{{if True}} +cdef cudaError_t cudaGraphicsVDPAURegisterVideoSurface(cudaGraphicsResource** resource, VdpVideoSurface vdpSurface, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaGraphicsVDPAURegisterVideoSurface(resource, vdpSurface, flags) -cdef cudaError_t cudaEGLStreamConsumerDisconnect(cudaEglStreamConnection* conn) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaEGLStreamConsumerDisconnect(conn) -{{endif}} -{{if True}} +cdef cudaError_t cudaGraphicsVDPAURegisterOutputSurface(cudaGraphicsResource** resource, VdpOutputSurface vdpSurface, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaGraphicsVDPAURegisterOutputSurface(resource, vdpSurface, flags) -cdef cudaError_t cudaEGLStreamConsumerAcquireFrame(cudaEglStreamConnection* conn, cudaGraphicsResource_t* pCudaResource, cudaStream_t* pStream, unsigned int timeout) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaEGLStreamConsumerAcquireFrame(conn, pCudaResource, pStream, timeout) -{{endif}} -{{if True}} +cdef cudaError_t cudaGetDeviceProperties(cudaDeviceProp* prop, int device) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaGetDeviceProperties(prop, device) -cdef cudaError_t cudaEGLStreamConsumerReleaseFrame(cudaEglStreamConnection* conn, cudaGraphicsResource_t pCudaResource, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaEGLStreamConsumerReleaseFrame(conn, pCudaResource, pStream) -{{endif}} -{{if True}} +cdef cudaError_t cudaDeviceGetHostAtomicCapabilities(unsigned int* capabilities, const cudaAtomicOperation* operations, unsigned int count, int device) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaDeviceGetHostAtomicCapabilities(capabilities, operations, count, device) -cdef cudaError_t cudaEGLStreamProducerConnect(cudaEglStreamConnection* conn, EGLStreamKHR eglStream, EGLint width, EGLint height) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaEGLStreamProducerConnect(conn, eglStream, width, height) -{{endif}} -{{if True}} +cdef cudaError_t cudaDeviceGetP2PAtomicCapabilities(unsigned int* capabilities, const cudaAtomicOperation* operations, unsigned int count, int srcDevice, int dstDevice) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaDeviceGetP2PAtomicCapabilities(capabilities, operations, count, srcDevice, dstDevice) -cdef cudaError_t cudaEGLStreamProducerDisconnect(cudaEglStreamConnection* conn) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaEGLStreamProducerDisconnect(conn) -{{endif}} -{{if True}} +cdef cudaError_t cudaStreamGetCaptureInfo(cudaStream_t stream, cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out, cudaGraph_t* graph_out, const cudaGraphNode_t** dependencies_out, const cudaGraphEdgeData** edgeData_out, size_t* numDependencies_out) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaStreamGetCaptureInfo(stream, captureStatus_out, id_out, graph_out, dependencies_out, edgeData_out, numDependencies_out) -cdef cudaError_t cudaEGLStreamProducerPresentFrame(cudaEglStreamConnection* conn, cudaEglFrame eglframe, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaEGLStreamProducerPresentFrame(conn, eglframe, pStream) -{{endif}} -{{if True}} +cdef cudaError_t cudaSignalExternalSemaphoresAsync(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreSignalParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaSignalExternalSemaphoresAsync(extSemArray, paramsArray, numExtSems, stream) -cdef cudaError_t cudaEGLStreamProducerReturnFrame(cudaEglStreamConnection* conn, cudaEglFrame* eglframe, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaEGLStreamProducerReturnFrame(conn, eglframe, pStream) -{{endif}} -{{if True}} +cdef cudaError_t cudaWaitExternalSemaphoresAsync(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreWaitParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaWaitExternalSemaphoresAsync(extSemArray, paramsArray, numExtSems, stream) -cdef cudaError_t cudaGraphicsResourceGetMappedEglFrame(cudaEglFrame* eglFrame, cudaGraphicsResource_t resource, unsigned int index, unsigned int mipLevel) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphicsResourceGetMappedEglFrame(eglFrame, resource, index, mipLevel) -{{endif}} -{{if True}} +cdef cudaError_t cudaMemPrefetchBatchAsync(void** dptrs, size_t* sizes, size_t count, cudaMemLocation* prefetchLocs, size_t* prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaMemPrefetchBatchAsync(dptrs, sizes, count, prefetchLocs, prefetchLocIdxs, numPrefetchLocs, flags, stream) -cdef cudaError_t cudaEventCreateFromEGLSync(cudaEvent_t* phEvent, EGLSyncKHR eglSync, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaEventCreateFromEGLSync(phEvent, eglSync, flags) -{{endif}} -{{if 'cudaProfilerStart' in found_functions}} +cdef cudaError_t cudaMemDiscardBatchAsync(void** dptrs, size_t* sizes, size_t count, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaMemDiscardBatchAsync(dptrs, sizes, count, flags, stream) -cdef cudaError_t cudaProfilerStart() except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaProfilerStart() -{{endif}} -{{if 'cudaProfilerStop' in found_functions}} +cdef cudaError_t cudaMemDiscardAndPrefetchBatchAsync(void** dptrs, size_t* sizes, size_t count, cudaMemLocation* prefetchLocs, size_t* prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaMemDiscardAndPrefetchBatchAsync(dptrs, sizes, count, prefetchLocs, prefetchLocIdxs, numPrefetchLocs, flags, stream) -cdef cudaError_t cudaProfilerStop() except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaProfilerStop() -{{endif}} -{{if True}} +cdef cudaError_t cudaMemGetDefaultMemPool(cudaMemPool_t* memPool, cudaMemLocation* location, cudaMemAllocationType type) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaMemGetDefaultMemPool(memPool, location, type) -cdef cudaError_t cudaGLGetDevices(unsigned int* pCudaDeviceCount, int* pCudaDevices, unsigned int cudaDeviceCount, cudaGLDeviceList deviceList) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGLGetDevices(pCudaDeviceCount, pCudaDevices, cudaDeviceCount, deviceList) -{{endif}} -{{if True}} +cdef cudaError_t cudaMemGetMemPool(cudaMemPool_t* memPool, cudaMemLocation* location, cudaMemAllocationType type) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaMemGetMemPool(memPool, location, type) -cdef cudaError_t cudaGraphicsGLRegisterImage(cudaGraphicsResource** resource, GLuint image, GLenum target, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphicsGLRegisterImage(resource, image, target, flags) -{{endif}} -{{if True}} +cdef cudaError_t cudaMemSetMemPool(cudaMemLocation* location, cudaMemAllocationType type, cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaMemSetMemPool(location, type, memPool) -cdef cudaError_t cudaGraphicsGLRegisterBuffer(cudaGraphicsResource** resource, GLuint buffer, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphicsGLRegisterBuffer(resource, buffer, flags) -{{endif}} -{{if True}} +cdef cudaError_t cudaLogsRegisterCallback(cudaLogsCallback_t callbackFunc, void* userData, cudaLogsCallbackHandle* callback_out) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaLogsRegisterCallback(callbackFunc, userData, callback_out) -cdef cudaError_t cudaVDPAUGetDevice(int* device, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaVDPAUGetDevice(device, vdpDevice, vdpGetProcAddress) -{{endif}} -{{if True}} +cdef cudaError_t cudaLogsUnregisterCallback(cudaLogsCallbackHandle callback) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaLogsUnregisterCallback(callback) -cdef cudaError_t cudaVDPAUSetVDPAUDevice(int device, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaVDPAUSetVDPAUDevice(device, vdpDevice, vdpGetProcAddress) -{{endif}} -{{if True}} +cdef cudaError_t cudaLogsCurrent(cudaLogIterator* iterator_out, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaLogsCurrent(iterator_out, flags) -cdef cudaError_t cudaGraphicsVDPAURegisterVideoSurface(cudaGraphicsResource** resource, VdpVideoSurface vdpSurface, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphicsVDPAURegisterVideoSurface(resource, vdpSurface, flags) -{{endif}} -{{if True}} +cdef cudaError_t cudaLogsDumpToFile(cudaLogIterator* iterator, const char* pathToFile, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaLogsDumpToFile(iterator, pathToFile, flags) -cdef cudaError_t cudaGraphicsVDPAURegisterOutputSurface(cudaGraphicsResource** resource, VdpOutputSurface vdpSurface, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: - return cyruntime._cudaGraphicsVDPAURegisterOutputSurface(resource, vdpSurface, flags) -{{endif}} -{{if True}} +cdef cudaError_t cudaLogsDumpToMemory(cudaLogIterator* iterator, char* buffer, size_t* size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaLogsDumpToMemory(iterator, buffer, size, flags) + + +cdef cudaError_t cudaGraphNodeGetContainingGraph(cudaGraphNode_t hNode, cudaGraph_t* phGraph) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaGraphNodeGetContainingGraph(hNode, phGraph) + + +cdef cudaError_t cudaGraphNodeGetLocalId(cudaGraphNode_t hNode, unsigned int* nodeId) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaGraphNodeGetLocalId(hNode, nodeId) + + +cdef cudaError_t cudaGraphNodeGetToolsId(cudaGraphNode_t hNode, unsigned long long* toolsNodeId) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaGraphNodeGetToolsId(hNode, toolsNodeId) + + +cdef cudaError_t cudaGraphGetId(cudaGraph_t hGraph, unsigned int* graphID) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaGraphGetId(hGraph, graphID) + + +cdef cudaError_t cudaGraphExecGetId(cudaGraphExec_t hGraphExec, unsigned int* graphID) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaGraphExecGetId(hGraphExec, graphID) + + +cdef cudaError_t cudaGraphConditionalHandleCreate_v2(cudaGraphConditionalHandle* pHandle_out, cudaGraph_t graph, cudaExecutionContext_t ctx, unsigned int defaultLaunchValue, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaGraphConditionalHandleCreate_v2(pHandle_out, graph, ctx, defaultLaunchValue, flags) + + +cdef cudaError_t cudaDeviceGetDevResource(int device, cudaDevResource* resource, cudaDevResourceType type) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaDeviceGetDevResource(device, resource, type) + + +cdef cudaError_t cudaDevSmResourceSplitByCount(cudaDevResource* result, unsigned int* nbGroups, const cudaDevResource* input, cudaDevResource* remaining, unsigned int flags, unsigned int minCount) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaDevSmResourceSplitByCount(result, nbGroups, input, remaining, flags, minCount) + + +cdef cudaError_t cudaDevSmResourceSplit(cudaDevResource* result, unsigned int nbGroups, const cudaDevResource* input, cudaDevResource* remainder, unsigned int flags, cudaDevSmResourceGroupParams* groupParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaDevSmResourceSplit(result, nbGroups, input, remainder, flags, groupParams) + + +cdef cudaError_t cudaDevResourceGenerateDesc(cudaDevResourceDesc_t* phDesc, cudaDevResource* resources, unsigned int nbResources) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaDevResourceGenerateDesc(phDesc, resources, nbResources) + + +cdef cudaError_t cudaGreenCtxCreate(cudaExecutionContext_t* phCtx, cudaDevResourceDesc_t desc, int device, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaGreenCtxCreate(phCtx, desc, device, flags) + + +cdef cudaError_t cudaExecutionCtxDestroy(cudaExecutionContext_t ctx) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaExecutionCtxDestroy(ctx) + + +cdef cudaError_t cudaExecutionCtxGetDevResource(cudaExecutionContext_t ctx, cudaDevResource* resource, cudaDevResourceType type) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaExecutionCtxGetDevResource(ctx, resource, type) + + +cdef cudaError_t cudaExecutionCtxGetDevice(int* device, cudaExecutionContext_t ctx) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaExecutionCtxGetDevice(device, ctx) + + +cdef cudaError_t cudaExecutionCtxGetId(cudaExecutionContext_t ctx, unsigned long long* ctxId) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaExecutionCtxGetId(ctx, ctxId) + + +cdef cudaError_t cudaExecutionCtxStreamCreate(cudaStream_t* phStream, cudaExecutionContext_t ctx, unsigned int flags, int priority) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaExecutionCtxStreamCreate(phStream, ctx, flags, priority) + + +cdef cudaError_t cudaExecutionCtxSynchronize(cudaExecutionContext_t ctx) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaExecutionCtxSynchronize(ctx) + + +cdef cudaError_t cudaStreamGetDevResource(cudaStream_t hStream, cudaDevResource* resource, cudaDevResourceType type) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaStreamGetDevResource(hStream, resource, type) + + +cdef cudaError_t cudaExecutionCtxRecordEvent(cudaExecutionContext_t ctx, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaExecutionCtxRecordEvent(ctx, event) + + +cdef cudaError_t cudaExecutionCtxWaitEvent(cudaExecutionContext_t ctx, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaExecutionCtxWaitEvent(ctx, event) + + +cdef cudaError_t cudaDeviceGetExecutionCtx(cudaExecutionContext_t* ctx, int device) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaDeviceGetExecutionCtx(ctx, device) + + +cdef cudaError_t cudaFuncGetParamCount(const void* func, size_t* paramCount) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaFuncGetParamCount(func, paramCount) + + +cdef cudaError_t cudaLaunchHostFunc_v2(cudaStream_t stream, cudaHostFn_t fn, void* userData, unsigned int syncMode) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaLaunchHostFunc_v2(stream, fn, userData, syncMode) + + +cdef cudaError_t cudaMemcpyWithAttributesAsync(void* dst, const void* src, size_t size, cudaMemcpyAttributes* attr, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaMemcpyWithAttributesAsync(dst, src, size, attr, stream) + + +cdef cudaError_t cudaMemcpy3DWithAttributesAsync(cudaMemcpy3DBatchOp* op, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaMemcpy3DWithAttributesAsync(op, flags, stream) + + +cdef cudaError_t cudaGraphNodeGetParams(cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaGraphNodeGetParams(node, nodeParams) + + +cdef cudaError_t cudaStreamBeginRecaptureToGraph(cudaStream_t stream, cudaStreamCaptureMode mode, cudaGraph_t graph, cudaGraphRecaptureCallbackData* callbackData) except ?cudaErrorCallRequiresNewerDriver nogil: + return _runtime._cudaStreamBeginRecaptureToGraph(stream, mode, graph, callbackData) + + +############################################################################### +# Static inline helpers from driver_functions.h +############################################################################### + +cdef extern from 'driver_functions.h': + cudaPitchedPtr _c_make_cudaPitchedPtr "make_cudaPitchedPtr"(void* d, size_t p, size_t xsz, size_t ysz) nogil + cudaPos _c_make_cudaPos "make_cudaPos"(size_t x, size_t y, size_t z) nogil + cudaExtent _c_make_cudaExtent "make_cudaExtent"(size_t w, size_t h, size_t d) nogil + + +cdef cudaPitchedPtr make_cudaPitchedPtr(void* d, size_t p, size_t xsz, size_t ysz) except* nogil: + return _c_make_cudaPitchedPtr(d, p, xsz, ysz) + + +cdef cudaPos make_cudaPos(size_t x, size_t y, size_t z) except* nogil: + return _c_make_cudaPos(x, y, z) + + +cdef cudaExtent make_cudaExtent(size_t w, size_t h, size_t d) except* nogil: + return _c_make_cudaExtent(w, h, d) + -from libc.stdint cimport uintptr_t -from cuda.pathfinder import load_nvidia_dynamic_lib -{{if 'Windows' == platform.system()}} -cimport cuda.bindings._lib.windll as windll -{{else}} -cimport cuda.bindings._lib.dlfcn as dlfcn -{{endif}} +############################################################################### +# getLocalRuntimeVersion +############################################################################### cdef cudaError_t getLocalRuntimeVersion(int* runtimeVersion) except ?cudaErrorCallRequiresNewerDriver nogil: - # Load - with gil: - loaded_dl = load_nvidia_dynamic_lib("cudart") - {{if 'Windows' == platform.system()}} - handle = loaded_dl._handle_uint - {{else}} - handle = loaded_dl._handle_uint - {{endif}} - - {{if 'Windows' == platform.system()}} - __cudaRuntimeGetVersion = windll.GetProcAddress(handle, b'cudaRuntimeGetVersion') - {{else}} - __cudaRuntimeGetVersion = dlfcn.dlsym(handle, 'cudaRuntimeGetVersion') - {{endif}} - - if __cudaRuntimeGetVersion == NULL: - with gil: - raise RuntimeError(f'Function "cudaRuntimeGetVersion" not found in {loaded_dl.abs_path}') - - # Call - cdef cudaError_t err = cudaSuccess - err = ( __cudaRuntimeGetVersion)(runtimeVersion) - - # We explicitly do *NOT* cleanup the library handle here, acknowledging - # that, yes, the handle leaks. The reason is that there's a - # `functools.cache` on the top-level caller of this function. - # - # This means this library would be opened once and then immediately closed, - # all the while remaining in the cache lurking there for people to call. - # - # Since we open the library one time (technically once per unique library name), - # there's not a ton of leakage, which we deem acceptable for the 1000x speedup - # achieved by caching (ultimately) `ctypes.CDLL` calls. - # - # Long(er)-term we can explore cleaning up the library using higher-level - # Python mechanisms, like `__del__` or `weakref.finalizer`s. - - return err -{{endif}} + return _runtime._getLocalRuntimeVersion(runtimeVersion) diff --git a/cuda_bindings/cuda/bindings/cyruntime_functions.pxi.in b/cuda_bindings/cuda/bindings/cyruntime_functions.pxi.in deleted file mode 100644 index 69c75821056..00000000000 --- a/cuda_bindings/cuda/bindings/cyruntime_functions.pxi.in +++ /dev/null @@ -1,1619 +0,0 @@ -# SPDX-FileCopyrightText: Copyright (c) 2021-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-License-Identifier: Apache-2.0 - -# This code was automatically generated with version 13.3.0. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=29630fb8d40658dc3ed853407f00b4618688984d4227aae877e2f32807fef519 -cdef extern from "cuda_runtime_api.h": - - {{if 'cudaDeviceReset' in found_functions}} - - cudaError_t cudaDeviceReset() nogil - - {{endif}} - {{if 'cudaDeviceSynchronize' in found_functions}} - - cudaError_t cudaDeviceSynchronize() nogil - - {{endif}} - {{if 'cudaDeviceSetLimit' in found_functions}} - - cudaError_t cudaDeviceSetLimit(cudaLimit limit, size_t value) nogil - - {{endif}} - {{if 'cudaDeviceGetLimit' in found_functions}} - - cudaError_t cudaDeviceGetLimit(size_t* pValue, cudaLimit limit) nogil - - {{endif}} - {{if 'cudaDeviceGetTexture1DLinearMaxWidth' in found_functions}} - - cudaError_t cudaDeviceGetTexture1DLinearMaxWidth(size_t* maxWidthInElements, const cudaChannelFormatDesc* fmtDesc, int device) nogil - - {{endif}} - {{if 'cudaDeviceGetCacheConfig' in found_functions}} - - cudaError_t cudaDeviceGetCacheConfig(cudaFuncCache* pCacheConfig) nogil - - {{endif}} - {{if 'cudaDeviceGetStreamPriorityRange' in found_functions}} - - cudaError_t cudaDeviceGetStreamPriorityRange(int* leastPriority, int* greatestPriority) nogil - - {{endif}} - {{if 'cudaDeviceSetCacheConfig' in found_functions}} - - cudaError_t cudaDeviceSetCacheConfig(cudaFuncCache cacheConfig) nogil - - {{endif}} - {{if 'cudaDeviceGetByPCIBusId' in found_functions}} - - cudaError_t cudaDeviceGetByPCIBusId(int* device, const char* pciBusId) nogil - - {{endif}} - {{if 'cudaDeviceGetPCIBusId' in found_functions}} - - cudaError_t cudaDeviceGetPCIBusId(char* pciBusId, int length, int device) nogil - - {{endif}} - {{if 'cudaIpcGetEventHandle' in found_functions}} - - cudaError_t cudaIpcGetEventHandle(cudaIpcEventHandle_t* handle, cudaEvent_t event) nogil - - {{endif}} - {{if 'cudaIpcOpenEventHandle' in found_functions}} - - cudaError_t cudaIpcOpenEventHandle(cudaEvent_t* event, cudaIpcEventHandle_t handle) nogil - - {{endif}} - {{if 'cudaIpcGetMemHandle' in found_functions}} - - cudaError_t cudaIpcGetMemHandle(cudaIpcMemHandle_t* handle, void* devPtr) nogil - - {{endif}} - {{if 'cudaIpcOpenMemHandle' in found_functions}} - - cudaError_t cudaIpcOpenMemHandle(void** devPtr, cudaIpcMemHandle_t handle, unsigned int flags) nogil - - {{endif}} - {{if 'cudaIpcCloseMemHandle' in found_functions}} - - cudaError_t cudaIpcCloseMemHandle(void* devPtr) nogil - - {{endif}} - {{if 'cudaDeviceFlushGPUDirectRDMAWrites' in found_functions}} - - cudaError_t cudaDeviceFlushGPUDirectRDMAWrites(cudaFlushGPUDirectRDMAWritesTarget target, cudaFlushGPUDirectRDMAWritesScope scope) nogil - - {{endif}} - {{if 'cudaDeviceRegisterAsyncNotification' in found_functions}} - - cudaError_t cudaDeviceRegisterAsyncNotification(int device, cudaAsyncCallback callbackFunc, void* userData, cudaAsyncCallbackHandle_t* callback) nogil - - {{endif}} - {{if 'cudaDeviceUnregisterAsyncNotification' in found_functions}} - - cudaError_t cudaDeviceUnregisterAsyncNotification(int device, cudaAsyncCallbackHandle_t callback) nogil - - {{endif}} - {{if 'cudaDeviceGetSharedMemConfig' in found_functions}} - - cudaError_t cudaDeviceGetSharedMemConfig(cudaSharedMemConfig* pConfig) nogil - - {{endif}} - {{if 'cudaDeviceSetSharedMemConfig' in found_functions}} - - cudaError_t cudaDeviceSetSharedMemConfig(cudaSharedMemConfig config) nogil - - {{endif}} - {{if 'cudaGetLastError' in found_functions}} - - cudaError_t cudaGetLastError() nogil - - {{endif}} - {{if 'cudaPeekAtLastError' in found_functions}} - - cudaError_t cudaPeekAtLastError() nogil - - {{endif}} - {{if 'cudaGetErrorName' in found_functions}} - - const char* cudaGetErrorName(cudaError_t error) nogil - - {{endif}} - {{if 'cudaGetErrorString' in found_functions}} - - const char* cudaGetErrorString(cudaError_t error) nogil - - {{endif}} - {{if 'cudaGetDeviceCount' in found_functions}} - - cudaError_t cudaGetDeviceCount(int* count) nogil - - {{endif}} - {{if 'cudaGetDeviceProperties' in found_functions}} - - cudaError_t cudaGetDeviceProperties(cudaDeviceProp* prop, int device) nogil - - {{endif}} - {{if 'cudaDeviceGetAttribute' in found_functions}} - - cudaError_t cudaDeviceGetAttribute(int* value, cudaDeviceAttr attr, int device) nogil - - {{endif}} - {{if 'cudaDeviceGetHostAtomicCapabilities' in found_functions}} - - cudaError_t cudaDeviceGetHostAtomicCapabilities(unsigned int* capabilities, const cudaAtomicOperation* operations, unsigned int count, int device) nogil - - {{endif}} - {{if 'cudaDeviceGetDefaultMemPool' in found_functions}} - - cudaError_t cudaDeviceGetDefaultMemPool(cudaMemPool_t* memPool, int device) nogil - - {{endif}} - {{if 'cudaDeviceSetMemPool' in found_functions}} - - cudaError_t cudaDeviceSetMemPool(int device, cudaMemPool_t memPool) nogil - - {{endif}} - {{if 'cudaDeviceGetMemPool' in found_functions}} - - cudaError_t cudaDeviceGetMemPool(cudaMemPool_t* memPool, int device) nogil - - {{endif}} - {{if 'cudaDeviceGetNvSciSyncAttributes' in found_functions}} - - cudaError_t cudaDeviceGetNvSciSyncAttributes(void* nvSciSyncAttrList, int device, int flags) nogil - - {{endif}} - {{if 'cudaDeviceGetP2PAttribute' in found_functions}} - - cudaError_t cudaDeviceGetP2PAttribute(int* value, cudaDeviceP2PAttr attr, int srcDevice, int dstDevice) nogil - - {{endif}} - {{if 'cudaDeviceGetP2PAtomicCapabilities' in found_functions}} - - cudaError_t cudaDeviceGetP2PAtomicCapabilities(unsigned int* capabilities, const cudaAtomicOperation* operations, unsigned int count, int srcDevice, int dstDevice) nogil - - {{endif}} - {{if 'cudaChooseDevice' in found_functions}} - - cudaError_t cudaChooseDevice(int* device, const cudaDeviceProp* prop) nogil - - {{endif}} - {{if 'cudaInitDevice' in found_functions}} - - cudaError_t cudaInitDevice(int device, unsigned int deviceFlags, unsigned int flags) nogil - - {{endif}} - {{if 'cudaSetDevice' in found_functions}} - - cudaError_t cudaSetDevice(int device) nogil - - {{endif}} - {{if 'cudaGetDevice' in found_functions}} - - cudaError_t cudaGetDevice(int* device) nogil - - {{endif}} - {{if 'cudaSetDeviceFlags' in found_functions}} - - cudaError_t cudaSetDeviceFlags(unsigned int flags) nogil - - {{endif}} - {{if 'cudaGetDeviceFlags' in found_functions}} - - cudaError_t cudaGetDeviceFlags(unsigned int* flags) nogil - - {{endif}} - {{if 'cudaStreamCreate' in found_functions}} - - cudaError_t cudaStreamCreate(cudaStream_t* pStream) nogil - - {{endif}} - {{if 'cudaStreamCreateWithFlags' in found_functions}} - - cudaError_t cudaStreamCreateWithFlags(cudaStream_t* pStream, unsigned int flags) nogil - - {{endif}} - {{if 'cudaStreamCreateWithPriority' in found_functions}} - - cudaError_t cudaStreamCreateWithPriority(cudaStream_t* pStream, unsigned int flags, int priority) nogil - - {{endif}} - {{if 'cudaStreamGetPriority' in found_functions}} - - cudaError_t cudaStreamGetPriority(cudaStream_t hStream, int* priority) nogil - - {{endif}} - {{if 'cudaStreamGetFlags' in found_functions}} - - cudaError_t cudaStreamGetFlags(cudaStream_t hStream, unsigned int* flags) nogil - - {{endif}} - {{if 'cudaStreamGetId' in found_functions}} - - cudaError_t cudaStreamGetId(cudaStream_t hStream, unsigned long long* streamId) nogil - - {{endif}} - {{if 'cudaStreamGetDevice' in found_functions}} - - cudaError_t cudaStreamGetDevice(cudaStream_t hStream, int* device) nogil - - {{endif}} - {{if 'cudaCtxResetPersistingL2Cache' in found_functions}} - - cudaError_t cudaCtxResetPersistingL2Cache() nogil - - {{endif}} - {{if 'cudaStreamCopyAttributes' in found_functions}} - - cudaError_t cudaStreamCopyAttributes(cudaStream_t dst, cudaStream_t src) nogil - - {{endif}} - {{if 'cudaStreamGetAttribute' in found_functions}} - - cudaError_t cudaStreamGetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, cudaStreamAttrValue* value_out) nogil - - {{endif}} - {{if 'cudaStreamSetAttribute' in found_functions}} - - cudaError_t cudaStreamSetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, const cudaStreamAttrValue* value) nogil - - {{endif}} - {{if 'cudaStreamDestroy' in found_functions}} - - cudaError_t cudaStreamDestroy(cudaStream_t stream) nogil - - {{endif}} - {{if 'cudaStreamWaitEvent' in found_functions}} - - cudaError_t cudaStreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned int flags) nogil - - {{endif}} - {{if 'cudaStreamAddCallback' in found_functions}} - - cudaError_t cudaStreamAddCallback(cudaStream_t stream, cudaStreamCallback_t callback, void* userData, unsigned int flags) nogil - - {{endif}} - {{if 'cudaStreamSynchronize' in found_functions}} - - cudaError_t cudaStreamSynchronize(cudaStream_t stream) nogil - - {{endif}} - {{if 'cudaStreamQuery' in found_functions}} - - cudaError_t cudaStreamQuery(cudaStream_t stream) nogil - - {{endif}} - {{if 'cudaStreamAttachMemAsync' in found_functions}} - - cudaError_t cudaStreamAttachMemAsync(cudaStream_t stream, void* devPtr, size_t length, unsigned int flags) nogil - - {{endif}} - {{if 'cudaStreamBeginCapture' in found_functions}} - - cudaError_t cudaStreamBeginCapture(cudaStream_t stream, cudaStreamCaptureMode mode) nogil - - {{endif}} - {{if 'cudaStreamBeginRecaptureToGraph' in found_functions}} - - cudaError_t cudaStreamBeginRecaptureToGraph(cudaStream_t stream, cudaStreamCaptureMode mode, cudaGraph_t graph, cudaGraphRecaptureCallbackData* callbackData) nogil - - {{endif}} - {{if 'cudaStreamBeginCaptureToGraph' in found_functions}} - - cudaError_t cudaStreamBeginCaptureToGraph(cudaStream_t stream, cudaGraph_t graph, const cudaGraphNode_t* dependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, cudaStreamCaptureMode mode) nogil - - {{endif}} - {{if 'cudaThreadExchangeStreamCaptureMode' in found_functions}} - - cudaError_t cudaThreadExchangeStreamCaptureMode(cudaStreamCaptureMode* mode) nogil - - {{endif}} - {{if 'cudaStreamEndCapture' in found_functions}} - - cudaError_t cudaStreamEndCapture(cudaStream_t stream, cudaGraph_t* pGraph) nogil - - {{endif}} - {{if 'cudaStreamIsCapturing' in found_functions}} - - cudaError_t cudaStreamIsCapturing(cudaStream_t stream, cudaStreamCaptureStatus* pCaptureStatus) nogil - - {{endif}} - {{if 'cudaStreamGetCaptureInfo' in found_functions}} - - cudaError_t cudaStreamGetCaptureInfo(cudaStream_t stream, cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out, cudaGraph_t* graph_out, const cudaGraphNode_t** dependencies_out, const cudaGraphEdgeData** edgeData_out, size_t* numDependencies_out) nogil - - {{endif}} - {{if 'cudaStreamUpdateCaptureDependencies' in found_functions}} - - cudaError_t cudaStreamUpdateCaptureDependencies(cudaStream_t stream, cudaGraphNode_t* dependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, unsigned int flags) nogil - - {{endif}} - {{if 'cudaEventCreate' in found_functions}} - - cudaError_t cudaEventCreate(cudaEvent_t* event) nogil - - {{endif}} - {{if 'cudaEventCreateWithFlags' in found_functions}} - - cudaError_t cudaEventCreateWithFlags(cudaEvent_t* event, unsigned int flags) nogil - - {{endif}} - {{if 'cudaEventRecord' in found_functions}} - - cudaError_t cudaEventRecord(cudaEvent_t event, cudaStream_t stream) nogil - - {{endif}} - {{if 'cudaEventRecordWithFlags' in found_functions}} - - cudaError_t cudaEventRecordWithFlags(cudaEvent_t event, cudaStream_t stream, unsigned int flags) nogil - - {{endif}} - {{if 'cudaEventQuery' in found_functions}} - - cudaError_t cudaEventQuery(cudaEvent_t event) nogil - - {{endif}} - {{if 'cudaEventSynchronize' in found_functions}} - - cudaError_t cudaEventSynchronize(cudaEvent_t event) nogil - - {{endif}} - {{if 'cudaEventDestroy' in found_functions}} - - cudaError_t cudaEventDestroy(cudaEvent_t event) nogil - - {{endif}} - {{if 'cudaEventElapsedTime' in found_functions}} - - cudaError_t cudaEventElapsedTime(float* ms, cudaEvent_t start, cudaEvent_t end) nogil - - {{endif}} - {{if 'cudaImportExternalMemory' in found_functions}} - - cudaError_t cudaImportExternalMemory(cudaExternalMemory_t* extMem_out, const cudaExternalMemoryHandleDesc* memHandleDesc) nogil - - {{endif}} - {{if 'cudaExternalMemoryGetMappedBuffer' in found_functions}} - - cudaError_t cudaExternalMemoryGetMappedBuffer(void** devPtr, cudaExternalMemory_t extMem, const cudaExternalMemoryBufferDesc* bufferDesc) nogil - - {{endif}} - {{if 'cudaExternalMemoryGetMappedMipmappedArray' in found_functions}} - - cudaError_t cudaExternalMemoryGetMappedMipmappedArray(cudaMipmappedArray_t* mipmap, cudaExternalMemory_t extMem, const cudaExternalMemoryMipmappedArrayDesc* mipmapDesc) nogil - - {{endif}} - {{if 'cudaDestroyExternalMemory' in found_functions}} - - cudaError_t cudaDestroyExternalMemory(cudaExternalMemory_t extMem) nogil - - {{endif}} - {{if 'cudaImportExternalSemaphore' in found_functions}} - - cudaError_t cudaImportExternalSemaphore(cudaExternalSemaphore_t* extSem_out, const cudaExternalSemaphoreHandleDesc* semHandleDesc) nogil - - {{endif}} - {{if 'cudaSignalExternalSemaphoresAsync' in found_functions}} - - cudaError_t cudaSignalExternalSemaphoresAsync(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreSignalParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) nogil - - {{endif}} - {{if 'cudaWaitExternalSemaphoresAsync' in found_functions}} - - cudaError_t cudaWaitExternalSemaphoresAsync(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreWaitParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) nogil - - {{endif}} - {{if 'cudaDestroyExternalSemaphore' in found_functions}} - - cudaError_t cudaDestroyExternalSemaphore(cudaExternalSemaphore_t extSem) nogil - - {{endif}} - {{if 'cudaFuncSetCacheConfig' in found_functions}} - - cudaError_t cudaFuncSetCacheConfig(const void* func, cudaFuncCache cacheConfig) nogil - - {{endif}} - {{if 'cudaFuncGetAttributes' in found_functions}} - - cudaError_t cudaFuncGetAttributes(cudaFuncAttributes* attr, const void* func) nogil - - {{endif}} - {{if 'cudaFuncSetAttribute' in found_functions}} - - cudaError_t cudaFuncSetAttribute(const void* func, cudaFuncAttribute attr, int value) nogil - - {{endif}} - {{if 'cudaFuncGetParamCount' in found_functions}} - - cudaError_t cudaFuncGetParamCount(const void* func, size_t* paramCount) nogil - - {{endif}} - {{if 'cudaLaunchHostFunc' in found_functions}} - - cudaError_t cudaLaunchHostFunc(cudaStream_t stream, cudaHostFn_t fn, void* userData) nogil - - {{endif}} - {{if 'cudaLaunchHostFunc_v2' in found_functions}} - - cudaError_t cudaLaunchHostFunc_v2(cudaStream_t stream, cudaHostFn_t fn, void* userData, unsigned int syncMode) nogil - - {{endif}} - {{if 'cudaFuncSetSharedMemConfig' in found_functions}} - - cudaError_t cudaFuncSetSharedMemConfig(const void* func, cudaSharedMemConfig config) nogil - - {{endif}} - {{if 'cudaOccupancyMaxActiveBlocksPerMultiprocessor' in found_functions}} - - cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessor(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize) nogil - - {{endif}} - {{if 'cudaOccupancyAvailableDynamicSMemPerBlock' in found_functions}} - - cudaError_t cudaOccupancyAvailableDynamicSMemPerBlock(size_t* dynamicSmemSize, const void* func, int numBlocks, int blockSize) nogil - - {{endif}} - {{if 'cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags' in found_functions}} - - cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize, unsigned int flags) nogil - - {{endif}} - {{if 'cudaMallocManaged' in found_functions}} - - cudaError_t cudaMallocManaged(void** devPtr, size_t size, unsigned int flags) nogil - - {{endif}} - {{if 'cudaMalloc' in found_functions}} - - cudaError_t cudaMalloc(void** devPtr, size_t size) nogil - - {{endif}} - {{if 'cudaMallocHost' in found_functions}} - - cudaError_t cudaMallocHost(void** ptr, size_t size) nogil - - {{endif}} - {{if 'cudaMallocPitch' in found_functions}} - - cudaError_t cudaMallocPitch(void** devPtr, size_t* pitch, size_t width, size_t height) nogil - - {{endif}} - {{if 'cudaMallocArray' in found_functions}} - - cudaError_t cudaMallocArray(cudaArray_t* array, const cudaChannelFormatDesc* desc, size_t width, size_t height, unsigned int flags) nogil - - {{endif}} - {{if 'cudaFree' in found_functions}} - - cudaError_t cudaFree(void* devPtr) nogil - - {{endif}} - {{if 'cudaFreeHost' in found_functions}} - - cudaError_t cudaFreeHost(void* ptr) nogil - - {{endif}} - {{if 'cudaFreeArray' in found_functions}} - - cudaError_t cudaFreeArray(cudaArray_t array) nogil - - {{endif}} - {{if 'cudaFreeMipmappedArray' in found_functions}} - - cudaError_t cudaFreeMipmappedArray(cudaMipmappedArray_t mipmappedArray) nogil - - {{endif}} - {{if 'cudaHostAlloc' in found_functions}} - - cudaError_t cudaHostAlloc(void** pHost, size_t size, unsigned int flags) nogil - - {{endif}} - {{if 'cudaHostRegister' in found_functions}} - - cudaError_t cudaHostRegister(void* ptr, size_t size, unsigned int flags) nogil - - {{endif}} - {{if 'cudaHostUnregister' in found_functions}} - - cudaError_t cudaHostUnregister(void* ptr) nogil - - {{endif}} - {{if 'cudaHostGetDevicePointer' in found_functions}} - - cudaError_t cudaHostGetDevicePointer(void** pDevice, void* pHost, unsigned int flags) nogil - - {{endif}} - {{if 'cudaHostGetFlags' in found_functions}} - - cudaError_t cudaHostGetFlags(unsigned int* pFlags, void* pHost) nogil - - {{endif}} - {{if 'cudaMalloc3D' in found_functions}} - - cudaError_t cudaMalloc3D(cudaPitchedPtr* pitchedDevPtr, cudaExtent extent) nogil - - {{endif}} - {{if 'cudaMalloc3DArray' in found_functions}} - - cudaError_t cudaMalloc3DArray(cudaArray_t* array, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int flags) nogil - - {{endif}} - {{if 'cudaMallocMipmappedArray' in found_functions}} - - cudaError_t cudaMallocMipmappedArray(cudaMipmappedArray_t* mipmappedArray, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int numLevels, unsigned int flags) nogil - - {{endif}} - {{if 'cudaGetMipmappedArrayLevel' in found_functions}} - - cudaError_t cudaGetMipmappedArrayLevel(cudaArray_t* levelArray, cudaMipmappedArray_const_t mipmappedArray, unsigned int level) nogil - - {{endif}} - {{if 'cudaMemcpy3D' in found_functions}} - - cudaError_t cudaMemcpy3D(const cudaMemcpy3DParms* p) nogil - - {{endif}} - {{if 'cudaMemcpy3DPeer' in found_functions}} - - cudaError_t cudaMemcpy3DPeer(const cudaMemcpy3DPeerParms* p) nogil - - {{endif}} - {{if 'cudaMemcpy3DAsync' in found_functions}} - - cudaError_t cudaMemcpy3DAsync(const cudaMemcpy3DParms* p, cudaStream_t stream) nogil - - {{endif}} - {{if 'cudaMemcpy3DPeerAsync' in found_functions}} - - cudaError_t cudaMemcpy3DPeerAsync(const cudaMemcpy3DPeerParms* p, cudaStream_t stream) nogil - - {{endif}} - {{if 'cudaMemGetInfo' in found_functions}} - - cudaError_t cudaMemGetInfo(size_t* free, size_t* total) nogil - - {{endif}} - {{if 'cudaArrayGetInfo' in found_functions}} - - cudaError_t cudaArrayGetInfo(cudaChannelFormatDesc* desc, cudaExtent* extent, unsigned int* flags, cudaArray_t array) nogil - - {{endif}} - {{if 'cudaArrayGetPlane' in found_functions}} - - cudaError_t cudaArrayGetPlane(cudaArray_t* pPlaneArray, cudaArray_t hArray, unsigned int planeIdx) nogil - - {{endif}} - {{if 'cudaArrayGetMemoryRequirements' in found_functions}} - - cudaError_t cudaArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaArray_t array, int device) nogil - - {{endif}} - {{if 'cudaMipmappedArrayGetMemoryRequirements' in found_functions}} - - cudaError_t cudaMipmappedArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaMipmappedArray_t mipmap, int device) nogil - - {{endif}} - {{if 'cudaArrayGetSparseProperties' in found_functions}} - - cudaError_t cudaArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaArray_t array) nogil - - {{endif}} - {{if 'cudaMipmappedArrayGetSparseProperties' in found_functions}} - - cudaError_t cudaMipmappedArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaMipmappedArray_t mipmap) nogil - - {{endif}} - {{if 'cudaMemcpy' in found_functions}} - - cudaError_t cudaMemcpy(void* dst, const void* src, size_t count, cudaMemcpyKind kind) nogil - - {{endif}} - {{if 'cudaMemcpyPeer' in found_functions}} - - cudaError_t cudaMemcpyPeer(void* dst, int dstDevice, const void* src, int srcDevice, size_t count) nogil - - {{endif}} - {{if 'cudaMemcpy2D' in found_functions}} - - cudaError_t cudaMemcpy2D(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) nogil - - {{endif}} - {{if 'cudaMemcpy2DToArray' in found_functions}} - - cudaError_t cudaMemcpy2DToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) nogil - - {{endif}} - {{if 'cudaMemcpy2DFromArray' in found_functions}} - - cudaError_t cudaMemcpy2DFromArray(void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind) nogil - - {{endif}} - {{if 'cudaMemcpy2DArrayToArray' in found_functions}} - - cudaError_t cudaMemcpy2DArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t width, size_t height, cudaMemcpyKind kind) nogil - - {{endif}} - {{if 'cudaMemcpyAsync' in found_functions}} - - cudaError_t cudaMemcpyAsync(void* dst, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) nogil - - {{endif}} - {{if 'cudaMemcpyPeerAsync' in found_functions}} - - cudaError_t cudaMemcpyPeerAsync(void* dst, int dstDevice, const void* src, int srcDevice, size_t count, cudaStream_t stream) nogil - - {{endif}} - {{if 'cudaMemcpyBatchAsync' in found_functions}} - - cudaError_t cudaMemcpyBatchAsync(const void** dsts, const void** srcs, const size_t* sizes, size_t count, cudaMemcpyAttributes* attrs, size_t* attrsIdxs, size_t numAttrs, cudaStream_t stream) nogil - - {{endif}} - {{if 'cudaMemcpy3DBatchAsync' in found_functions}} - - cudaError_t cudaMemcpy3DBatchAsync(size_t numOps, cudaMemcpy3DBatchOp* opList, unsigned long long flags, cudaStream_t stream) nogil - - {{endif}} - {{if 'cudaMemcpyWithAttributesAsync' in found_functions}} - - cudaError_t cudaMemcpyWithAttributesAsync(void* dst, const void* src, size_t size, cudaMemcpyAttributes* attr, cudaStream_t stream) nogil - - {{endif}} - {{if 'cudaMemcpy3DWithAttributesAsync' in found_functions}} - - cudaError_t cudaMemcpy3DWithAttributesAsync(cudaMemcpy3DBatchOp* op, unsigned long long flags, cudaStream_t stream) nogil - - {{endif}} - {{if 'cudaMemcpy2DAsync' in found_functions}} - - cudaError_t cudaMemcpy2DAsync(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) nogil - - {{endif}} - {{if 'cudaMemcpy2DToArrayAsync' in found_functions}} - - cudaError_t cudaMemcpy2DToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) nogil - - {{endif}} - {{if 'cudaMemcpy2DFromArrayAsync' in found_functions}} - - cudaError_t cudaMemcpy2DFromArrayAsync(void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) nogil - - {{endif}} - {{if 'cudaMemset' in found_functions}} - - cudaError_t cudaMemset(void* devPtr, int value, size_t count) nogil - - {{endif}} - {{if 'cudaMemset2D' in found_functions}} - - cudaError_t cudaMemset2D(void* devPtr, size_t pitch, int value, size_t width, size_t height) nogil - - {{endif}} - {{if 'cudaMemset3D' in found_functions}} - - cudaError_t cudaMemset3D(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent) nogil - - {{endif}} - {{if 'cudaMemsetAsync' in found_functions}} - - cudaError_t cudaMemsetAsync(void* devPtr, int value, size_t count, cudaStream_t stream) nogil - - {{endif}} - {{if 'cudaMemset2DAsync' in found_functions}} - - cudaError_t cudaMemset2DAsync(void* devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream) nogil - - {{endif}} - {{if 'cudaMemset3DAsync' in found_functions}} - - cudaError_t cudaMemset3DAsync(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent, cudaStream_t stream) nogil - - {{endif}} - {{if 'cudaMemPrefetchAsync' in found_functions}} - - cudaError_t cudaMemPrefetchAsync(const void* devPtr, size_t count, cudaMemLocation location, unsigned int flags, cudaStream_t stream) nogil - - {{endif}} - {{if 'cudaMemPrefetchBatchAsync' in found_functions}} - - cudaError_t cudaMemPrefetchBatchAsync(void** dptrs, size_t* sizes, size_t count, cudaMemLocation* prefetchLocs, size_t* prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, cudaStream_t stream) nogil - - {{endif}} - {{if 'cudaMemDiscardBatchAsync' in found_functions}} - - cudaError_t cudaMemDiscardBatchAsync(void** dptrs, size_t* sizes, size_t count, unsigned long long flags, cudaStream_t stream) nogil - - {{endif}} - {{if 'cudaMemDiscardAndPrefetchBatchAsync' in found_functions}} - - cudaError_t cudaMemDiscardAndPrefetchBatchAsync(void** dptrs, size_t* sizes, size_t count, cudaMemLocation* prefetchLocs, size_t* prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, cudaStream_t stream) nogil - - {{endif}} - {{if 'cudaMemAdvise' in found_functions}} - - cudaError_t cudaMemAdvise(const void* devPtr, size_t count, cudaMemoryAdvise advice, cudaMemLocation location) nogil - - {{endif}} - {{if 'cudaMemRangeGetAttribute' in found_functions}} - - cudaError_t cudaMemRangeGetAttribute(void* data, size_t dataSize, cudaMemRangeAttribute attribute, const void* devPtr, size_t count) nogil - - {{endif}} - {{if 'cudaMemRangeGetAttributes' in found_functions}} - - cudaError_t cudaMemRangeGetAttributes(void** data, size_t* dataSizes, cudaMemRangeAttribute* attributes, size_t numAttributes, const void* devPtr, size_t count) nogil - - {{endif}} - {{if 'cudaMemcpyToArray' in found_functions}} - - cudaError_t cudaMemcpyToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind) nogil - - {{endif}} - {{if 'cudaMemcpyFromArray' in found_functions}} - - cudaError_t cudaMemcpyFromArray(void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind) nogil - - {{endif}} - {{if 'cudaMemcpyArrayToArray' in found_functions}} - - cudaError_t cudaMemcpyArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t count, cudaMemcpyKind kind) nogil - - {{endif}} - {{if 'cudaMemcpyToArrayAsync' in found_functions}} - - cudaError_t cudaMemcpyToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) nogil - - {{endif}} - {{if 'cudaMemcpyFromArrayAsync' in found_functions}} - - cudaError_t cudaMemcpyFromArrayAsync(void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind, cudaStream_t stream) nogil - - {{endif}} - {{if 'cudaMallocAsync' in found_functions}} - - cudaError_t cudaMallocAsync(void** devPtr, size_t size, cudaStream_t hStream) nogil - - {{endif}} - {{if 'cudaFreeAsync' in found_functions}} - - cudaError_t cudaFreeAsync(void* devPtr, cudaStream_t hStream) nogil - - {{endif}} - {{if 'cudaMemPoolTrimTo' in found_functions}} - - cudaError_t cudaMemPoolTrimTo(cudaMemPool_t memPool, size_t minBytesToKeep) nogil - - {{endif}} - {{if 'cudaMemPoolSetAttribute' in found_functions}} - - cudaError_t cudaMemPoolSetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) nogil - - {{endif}} - {{if 'cudaMemPoolGetAttribute' in found_functions}} - - cudaError_t cudaMemPoolGetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) nogil - - {{endif}} - {{if 'cudaMemPoolSetAccess' in found_functions}} - - cudaError_t cudaMemPoolSetAccess(cudaMemPool_t memPool, const cudaMemAccessDesc* descList, size_t count) nogil - - {{endif}} - {{if 'cudaMemPoolGetAccess' in found_functions}} - - cudaError_t cudaMemPoolGetAccess(cudaMemAccessFlags* flags, cudaMemPool_t memPool, cudaMemLocation* location) nogil - - {{endif}} - {{if 'cudaMemPoolCreate' in found_functions}} - - cudaError_t cudaMemPoolCreate(cudaMemPool_t* memPool, const cudaMemPoolProps* poolProps) nogil - - {{endif}} - {{if 'cudaMemPoolDestroy' in found_functions}} - - cudaError_t cudaMemPoolDestroy(cudaMemPool_t memPool) nogil - - {{endif}} - {{if 'cudaMemGetDefaultMemPool' in found_functions}} - - cudaError_t cudaMemGetDefaultMemPool(cudaMemPool_t* memPool, cudaMemLocation* location, cudaMemAllocationType typename) nogil - - {{endif}} - {{if 'cudaMemGetMemPool' in found_functions}} - - cudaError_t cudaMemGetMemPool(cudaMemPool_t* memPool, cudaMemLocation* location, cudaMemAllocationType typename) nogil - - {{endif}} - {{if 'cudaMemSetMemPool' in found_functions}} - - cudaError_t cudaMemSetMemPool(cudaMemLocation* location, cudaMemAllocationType typename, cudaMemPool_t memPool) nogil - - {{endif}} - {{if 'cudaMallocFromPoolAsync' in found_functions}} - - cudaError_t cudaMallocFromPoolAsync(void** ptr, size_t size, cudaMemPool_t memPool, cudaStream_t stream) nogil - - {{endif}} - {{if 'cudaMemPoolExportToShareableHandle' in found_functions}} - - cudaError_t cudaMemPoolExportToShareableHandle(void* shareableHandle, cudaMemPool_t memPool, cudaMemAllocationHandleType handleType, unsigned int flags) nogil - - {{endif}} - {{if 'cudaMemPoolImportFromShareableHandle' in found_functions}} - - cudaError_t cudaMemPoolImportFromShareableHandle(cudaMemPool_t* memPool, void* shareableHandle, cudaMemAllocationHandleType handleType, unsigned int flags) nogil - - {{endif}} - {{if 'cudaMemPoolExportPointer' in found_functions}} - - cudaError_t cudaMemPoolExportPointer(cudaMemPoolPtrExportData* exportData, void* ptr) nogil - - {{endif}} - {{if 'cudaMemPoolImportPointer' in found_functions}} - - cudaError_t cudaMemPoolImportPointer(void** ptr, cudaMemPool_t memPool, cudaMemPoolPtrExportData* exportData) nogil - - {{endif}} - {{if 'cudaPointerGetAttributes' in found_functions}} - - cudaError_t cudaPointerGetAttributes(cudaPointerAttributes* attributes, const void* ptr) nogil - - {{endif}} - {{if 'cudaDeviceCanAccessPeer' in found_functions}} - - cudaError_t cudaDeviceCanAccessPeer(int* canAccessPeer, int device, int peerDevice) nogil - - {{endif}} - {{if 'cudaDeviceEnablePeerAccess' in found_functions}} - - cudaError_t cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags) nogil - - {{endif}} - {{if 'cudaDeviceDisablePeerAccess' in found_functions}} - - cudaError_t cudaDeviceDisablePeerAccess(int peerDevice) nogil - - {{endif}} - {{if 'cudaGraphicsUnregisterResource' in found_functions}} - - cudaError_t cudaGraphicsUnregisterResource(cudaGraphicsResource_t resource) nogil - - {{endif}} - {{if 'cudaGraphicsResourceSetMapFlags' in found_functions}} - - cudaError_t cudaGraphicsResourceSetMapFlags(cudaGraphicsResource_t resource, unsigned int flags) nogil - - {{endif}} - {{if 'cudaGraphicsMapResources' in found_functions}} - - cudaError_t cudaGraphicsMapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) nogil - - {{endif}} - {{if 'cudaGraphicsUnmapResources' in found_functions}} - - cudaError_t cudaGraphicsUnmapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) nogil - - {{endif}} - {{if 'cudaGraphicsResourceGetMappedPointer' in found_functions}} - - cudaError_t cudaGraphicsResourceGetMappedPointer(void** devPtr, size_t* size, cudaGraphicsResource_t resource) nogil - - {{endif}} - {{if 'cudaGraphicsSubResourceGetMappedArray' in found_functions}} - - cudaError_t cudaGraphicsSubResourceGetMappedArray(cudaArray_t* array, cudaGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel) nogil - - {{endif}} - {{if 'cudaGraphicsResourceGetMappedMipmappedArray' in found_functions}} - - cudaError_t cudaGraphicsResourceGetMappedMipmappedArray(cudaMipmappedArray_t* mipmappedArray, cudaGraphicsResource_t resource) nogil - - {{endif}} - {{if 'cudaGetChannelDesc' in found_functions}} - - cudaError_t cudaGetChannelDesc(cudaChannelFormatDesc* desc, cudaArray_const_t array) nogil - - {{endif}} - {{if 'cudaCreateChannelDesc' in found_functions}} - - cudaChannelFormatDesc cudaCreateChannelDesc(int x, int y, int z, int w, cudaChannelFormatKind f) nogil - - {{endif}} - {{if 'cudaCreateTextureObject' in found_functions}} - - cudaError_t cudaCreateTextureObject(cudaTextureObject_t* pTexObject, const cudaResourceDesc* pResDesc, const cudaTextureDesc* pTexDesc, const cudaResourceViewDesc* pResViewDesc) nogil - - {{endif}} - {{if 'cudaDestroyTextureObject' in found_functions}} - - cudaError_t cudaDestroyTextureObject(cudaTextureObject_t texObject) nogil - - {{endif}} - {{if 'cudaGetTextureObjectResourceDesc' in found_functions}} - - cudaError_t cudaGetTextureObjectResourceDesc(cudaResourceDesc* pResDesc, cudaTextureObject_t texObject) nogil - - {{endif}} - {{if 'cudaGetTextureObjectTextureDesc' in found_functions}} - - cudaError_t cudaGetTextureObjectTextureDesc(cudaTextureDesc* pTexDesc, cudaTextureObject_t texObject) nogil - - {{endif}} - {{if 'cudaGetTextureObjectResourceViewDesc' in found_functions}} - - cudaError_t cudaGetTextureObjectResourceViewDesc(cudaResourceViewDesc* pResViewDesc, cudaTextureObject_t texObject) nogil - - {{endif}} - {{if 'cudaCreateSurfaceObject' in found_functions}} - - cudaError_t cudaCreateSurfaceObject(cudaSurfaceObject_t* pSurfObject, const cudaResourceDesc* pResDesc) nogil - - {{endif}} - {{if 'cudaDestroySurfaceObject' in found_functions}} - - cudaError_t cudaDestroySurfaceObject(cudaSurfaceObject_t surfObject) nogil - - {{endif}} - {{if 'cudaGetSurfaceObjectResourceDesc' in found_functions}} - - cudaError_t cudaGetSurfaceObjectResourceDesc(cudaResourceDesc* pResDesc, cudaSurfaceObject_t surfObject) nogil - - {{endif}} - {{if 'cudaDriverGetVersion' in found_functions}} - - cudaError_t cudaDriverGetVersion(int* driverVersion) nogil - - {{endif}} - {{if 'cudaRuntimeGetVersion' in found_functions}} - - cudaError_t cudaRuntimeGetVersion(int* runtimeVersion) nogil - - {{endif}} - {{if 'cudaLogsRegisterCallback' in found_functions}} - - cudaError_t cudaLogsRegisterCallback(cudaLogsCallback_t callbackFunc, void* userData, cudaLogsCallbackHandle* callback_out) nogil - - {{endif}} - {{if 'cudaLogsUnregisterCallback' in found_functions}} - - cudaError_t cudaLogsUnregisterCallback(cudaLogsCallbackHandle callback) nogil - - {{endif}} - {{if 'cudaLogsCurrent' in found_functions}} - - cudaError_t cudaLogsCurrent(cudaLogIterator* iterator_out, unsigned int flags) nogil - - {{endif}} - {{if 'cudaLogsDumpToFile' in found_functions}} - - cudaError_t cudaLogsDumpToFile(cudaLogIterator* iterator, const char* pathToFile, unsigned int flags) nogil - - {{endif}} - {{if 'cudaLogsDumpToMemory' in found_functions}} - - cudaError_t cudaLogsDumpToMemory(cudaLogIterator* iterator, char* buffer, size_t* size, unsigned int flags) nogil - - {{endif}} - {{if 'cudaGraphCreate' in found_functions}} - - cudaError_t cudaGraphCreate(cudaGraph_t* pGraph, unsigned int flags) nogil - - {{endif}} - {{if 'cudaGraphAddKernelNode' in found_functions}} - - cudaError_t cudaGraphAddKernelNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaKernelNodeParams* pNodeParams) nogil - - {{endif}} - {{if 'cudaGraphKernelNodeGetParams' in found_functions}} - - cudaError_t cudaGraphKernelNodeGetParams(cudaGraphNode_t node, cudaKernelNodeParams* pNodeParams) nogil - - {{endif}} - {{if 'cudaGraphKernelNodeSetParams' in found_functions}} - - cudaError_t cudaGraphKernelNodeSetParams(cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) nogil - - {{endif}} - {{if 'cudaGraphKernelNodeCopyAttributes' in found_functions}} - - cudaError_t cudaGraphKernelNodeCopyAttributes(cudaGraphNode_t hDst, cudaGraphNode_t hSrc) nogil - - {{endif}} - {{if 'cudaGraphKernelNodeGetAttribute' in found_functions}} - - cudaError_t cudaGraphKernelNodeGetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, cudaKernelNodeAttrValue* value_out) nogil - - {{endif}} - {{if 'cudaGraphKernelNodeSetAttribute' in found_functions}} - - cudaError_t cudaGraphKernelNodeSetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, const cudaKernelNodeAttrValue* value) nogil - - {{endif}} - {{if 'cudaGraphAddMemcpyNode' in found_functions}} - - cudaError_t cudaGraphAddMemcpyNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemcpy3DParms* pCopyParams) nogil - - {{endif}} - {{if 'cudaGraphAddMemcpyNode1D' in found_functions}} - - cudaError_t cudaGraphAddMemcpyNode1D(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dst, const void* src, size_t count, cudaMemcpyKind kind) nogil - - {{endif}} - {{if 'cudaGraphMemcpyNodeGetParams' in found_functions}} - - cudaError_t cudaGraphMemcpyNodeGetParams(cudaGraphNode_t node, cudaMemcpy3DParms* pNodeParams) nogil - - {{endif}} - {{if 'cudaGraphMemcpyNodeSetParams' in found_functions}} - - cudaError_t cudaGraphMemcpyNodeSetParams(cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) nogil - - {{endif}} - {{if 'cudaGraphMemcpyNodeSetParams1D' in found_functions}} - - cudaError_t cudaGraphMemcpyNodeSetParams1D(cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) nogil - - {{endif}} - {{if 'cudaGraphAddMemsetNode' in found_functions}} - - cudaError_t cudaGraphAddMemsetNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemsetParams* pMemsetParams) nogil - - {{endif}} - {{if 'cudaGraphMemsetNodeGetParams' in found_functions}} - - cudaError_t cudaGraphMemsetNodeGetParams(cudaGraphNode_t node, cudaMemsetParams* pNodeParams) nogil - - {{endif}} - {{if 'cudaGraphMemsetNodeSetParams' in found_functions}} - - cudaError_t cudaGraphMemsetNodeSetParams(cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) nogil - - {{endif}} - {{if 'cudaGraphAddHostNode' in found_functions}} - - cudaError_t cudaGraphAddHostNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaHostNodeParams* pNodeParams) nogil - - {{endif}} - {{if 'cudaGraphHostNodeGetParams' in found_functions}} - - cudaError_t cudaGraphHostNodeGetParams(cudaGraphNode_t node, cudaHostNodeParams* pNodeParams) nogil - - {{endif}} - {{if 'cudaGraphHostNodeSetParams' in found_functions}} - - cudaError_t cudaGraphHostNodeSetParams(cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) nogil - - {{endif}} - {{if 'cudaGraphAddChildGraphNode' in found_functions}} - - cudaError_t cudaGraphAddChildGraphNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaGraph_t childGraph) nogil - - {{endif}} - {{if 'cudaGraphChildGraphNodeGetGraph' in found_functions}} - - cudaError_t cudaGraphChildGraphNodeGetGraph(cudaGraphNode_t node, cudaGraph_t* pGraph) nogil - - {{endif}} - {{if 'cudaGraphAddEmptyNode' in found_functions}} - - cudaError_t cudaGraphAddEmptyNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies) nogil - - {{endif}} - {{if 'cudaGraphAddEventRecordNode' in found_functions}} - - cudaError_t cudaGraphAddEventRecordNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) nogil - - {{endif}} - {{if 'cudaGraphEventRecordNodeGetEvent' in found_functions}} - - cudaError_t cudaGraphEventRecordNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) nogil - - {{endif}} - {{if 'cudaGraphEventRecordNodeSetEvent' in found_functions}} - - cudaError_t cudaGraphEventRecordNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) nogil - - {{endif}} - {{if 'cudaGraphAddEventWaitNode' in found_functions}} - - cudaError_t cudaGraphAddEventWaitNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) nogil - - {{endif}} - {{if 'cudaGraphEventWaitNodeGetEvent' in found_functions}} - - cudaError_t cudaGraphEventWaitNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) nogil - - {{endif}} - {{if 'cudaGraphEventWaitNodeSetEvent' in found_functions}} - - cudaError_t cudaGraphEventWaitNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) nogil - - {{endif}} - {{if 'cudaGraphAddExternalSemaphoresSignalNode' in found_functions}} - - cudaError_t cudaGraphAddExternalSemaphoresSignalNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreSignalNodeParams* nodeParams) nogil - - {{endif}} - {{if 'cudaGraphExternalSemaphoresSignalNodeGetParams' in found_functions}} - - cudaError_t cudaGraphExternalSemaphoresSignalNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreSignalNodeParams* params_out) nogil - - {{endif}} - {{if 'cudaGraphExternalSemaphoresSignalNodeSetParams' in found_functions}} - - cudaError_t cudaGraphExternalSemaphoresSignalNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) nogil - - {{endif}} - {{if 'cudaGraphAddExternalSemaphoresWaitNode' in found_functions}} - - cudaError_t cudaGraphAddExternalSemaphoresWaitNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreWaitNodeParams* nodeParams) nogil - - {{endif}} - {{if 'cudaGraphExternalSemaphoresWaitNodeGetParams' in found_functions}} - - cudaError_t cudaGraphExternalSemaphoresWaitNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreWaitNodeParams* params_out) nogil - - {{endif}} - {{if 'cudaGraphExternalSemaphoresWaitNodeSetParams' in found_functions}} - - cudaError_t cudaGraphExternalSemaphoresWaitNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) nogil - - {{endif}} - {{if 'cudaGraphAddMemAllocNode' in found_functions}} - - cudaError_t cudaGraphAddMemAllocNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaMemAllocNodeParams* nodeParams) nogil - - {{endif}} - {{if 'cudaGraphMemAllocNodeGetParams' in found_functions}} - - cudaError_t cudaGraphMemAllocNodeGetParams(cudaGraphNode_t node, cudaMemAllocNodeParams* params_out) nogil - - {{endif}} - {{if 'cudaGraphAddMemFreeNode' in found_functions}} - - cudaError_t cudaGraphAddMemFreeNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dptr) nogil - - {{endif}} - {{if 'cudaGraphMemFreeNodeGetParams' in found_functions}} - - cudaError_t cudaGraphMemFreeNodeGetParams(cudaGraphNode_t node, void* dptr_out) nogil - - {{endif}} - {{if 'cudaDeviceGraphMemTrim' in found_functions}} - - cudaError_t cudaDeviceGraphMemTrim(int device) nogil - - {{endif}} - {{if 'cudaDeviceGetGraphMemAttribute' in found_functions}} - - cudaError_t cudaDeviceGetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) nogil - - {{endif}} - {{if 'cudaDeviceSetGraphMemAttribute' in found_functions}} - - cudaError_t cudaDeviceSetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) nogil - - {{endif}} - {{if 'cudaGraphClone' in found_functions}} - - cudaError_t cudaGraphClone(cudaGraph_t* pGraphClone, cudaGraph_t originalGraph) nogil - - {{endif}} - {{if 'cudaGraphNodeFindInClone' in found_functions}} - - cudaError_t cudaGraphNodeFindInClone(cudaGraphNode_t* pNode, cudaGraphNode_t originalNode, cudaGraph_t clonedGraph) nogil - - {{endif}} - {{if 'cudaGraphNodeGetType' in found_functions}} - - cudaError_t cudaGraphNodeGetType(cudaGraphNode_t node, cudaGraphNodeType* pType) nogil - - {{endif}} - {{if 'cudaGraphNodeGetContainingGraph' in found_functions}} - - cudaError_t cudaGraphNodeGetContainingGraph(cudaGraphNode_t hNode, cudaGraph_t* phGraph) nogil - - {{endif}} - {{if 'cudaGraphNodeGetLocalId' in found_functions}} - - cudaError_t cudaGraphNodeGetLocalId(cudaGraphNode_t hNode, unsigned int* nodeId) nogil - - {{endif}} - {{if 'cudaGraphNodeGetToolsId' in found_functions}} - - cudaError_t cudaGraphNodeGetToolsId(cudaGraphNode_t hNode, unsigned long long* toolsNodeId) nogil - - {{endif}} - {{if 'cudaGraphGetId' in found_functions}} - - cudaError_t cudaGraphGetId(cudaGraph_t hGraph, unsigned int* graphID) nogil - - {{endif}} - {{if 'cudaGraphExecGetId' in found_functions}} - - cudaError_t cudaGraphExecGetId(cudaGraphExec_t hGraphExec, unsigned int* graphID) nogil - - {{endif}} - {{if 'cudaGraphGetNodes' in found_functions}} - - cudaError_t cudaGraphGetNodes(cudaGraph_t graph, cudaGraphNode_t* nodes, size_t* numNodes) nogil - - {{endif}} - {{if 'cudaGraphGetRootNodes' in found_functions}} - - cudaError_t cudaGraphGetRootNodes(cudaGraph_t graph, cudaGraphNode_t* pRootNodes, size_t* pNumRootNodes) nogil - - {{endif}} - {{if 'cudaGraphGetEdges' in found_functions}} - - cudaError_t cudaGraphGetEdges(cudaGraph_t graph, cudaGraphNode_t* from_, cudaGraphNode_t* to, cudaGraphEdgeData* edgeData, size_t* numEdges) nogil - - {{endif}} - {{if 'cudaGraphNodeGetDependencies' in found_functions}} - - cudaError_t cudaGraphNodeGetDependencies(cudaGraphNode_t node, cudaGraphNode_t* pDependencies, cudaGraphEdgeData* edgeData, size_t* pNumDependencies) nogil - - {{endif}} - {{if 'cudaGraphNodeGetDependentNodes' in found_functions}} - - cudaError_t cudaGraphNodeGetDependentNodes(cudaGraphNode_t node, cudaGraphNode_t* pDependentNodes, cudaGraphEdgeData* edgeData, size_t* pNumDependentNodes) nogil - - {{endif}} - {{if 'cudaGraphAddDependencies' in found_functions}} - - cudaError_t cudaGraphAddDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, const cudaGraphEdgeData* edgeData, size_t numDependencies) nogil - - {{endif}} - {{if 'cudaGraphRemoveDependencies' in found_functions}} - - cudaError_t cudaGraphRemoveDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, const cudaGraphEdgeData* edgeData, size_t numDependencies) nogil - - {{endif}} - {{if 'cudaGraphDestroyNode' in found_functions}} - - cudaError_t cudaGraphDestroyNode(cudaGraphNode_t node) nogil - - {{endif}} - {{if 'cudaGraphInstantiate' in found_functions}} - - cudaError_t cudaGraphInstantiate(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) nogil - - {{endif}} - {{if 'cudaGraphInstantiateWithFlags' in found_functions}} - - cudaError_t cudaGraphInstantiateWithFlags(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) nogil - - {{endif}} - {{if 'cudaGraphInstantiateWithParams' in found_functions}} - - cudaError_t cudaGraphInstantiateWithParams(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, cudaGraphInstantiateParams* instantiateParams) nogil - - {{endif}} - {{if 'cudaGraphExecGetFlags' in found_functions}} - - cudaError_t cudaGraphExecGetFlags(cudaGraphExec_t graphExec, unsigned long long* flags) nogil - - {{endif}} - {{if 'cudaGraphExecKernelNodeSetParams' in found_functions}} - - cudaError_t cudaGraphExecKernelNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) nogil - - {{endif}} - {{if 'cudaGraphExecMemcpyNodeSetParams' in found_functions}} - - cudaError_t cudaGraphExecMemcpyNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) nogil - - {{endif}} - {{if 'cudaGraphExecMemcpyNodeSetParams1D' in found_functions}} - - cudaError_t cudaGraphExecMemcpyNodeSetParams1D(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) nogil - - {{endif}} - {{if 'cudaGraphExecMemsetNodeSetParams' in found_functions}} - - cudaError_t cudaGraphExecMemsetNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) nogil - - {{endif}} - {{if 'cudaGraphExecHostNodeSetParams' in found_functions}} - - cudaError_t cudaGraphExecHostNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) nogil - - {{endif}} - {{if 'cudaGraphExecChildGraphNodeSetParams' in found_functions}} - - cudaError_t cudaGraphExecChildGraphNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, cudaGraph_t childGraph) nogil - - {{endif}} - {{if 'cudaGraphExecEventRecordNodeSetEvent' in found_functions}} - - cudaError_t cudaGraphExecEventRecordNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) nogil - - {{endif}} - {{if 'cudaGraphExecEventWaitNodeSetEvent' in found_functions}} - - cudaError_t cudaGraphExecEventWaitNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) nogil - - {{endif}} - {{if 'cudaGraphExecExternalSemaphoresSignalNodeSetParams' in found_functions}} - - cudaError_t cudaGraphExecExternalSemaphoresSignalNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) nogil - - {{endif}} - {{if 'cudaGraphExecExternalSemaphoresWaitNodeSetParams' in found_functions}} - - cudaError_t cudaGraphExecExternalSemaphoresWaitNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) nogil - - {{endif}} - {{if 'cudaGraphNodeSetEnabled' in found_functions}} - - cudaError_t cudaGraphNodeSetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int isEnabled) nogil - - {{endif}} - {{if 'cudaGraphNodeGetEnabled' in found_functions}} - - cudaError_t cudaGraphNodeGetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int* isEnabled) nogil - - {{endif}} - {{if 'cudaGraphExecUpdate' in found_functions}} - - cudaError_t cudaGraphExecUpdate(cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphExecUpdateResultInfo* resultInfo) nogil - - {{endif}} - {{if 'cudaGraphUpload' in found_functions}} - - cudaError_t cudaGraphUpload(cudaGraphExec_t graphExec, cudaStream_t stream) nogil - - {{endif}} - {{if 'cudaGraphLaunch' in found_functions}} - - cudaError_t cudaGraphLaunch(cudaGraphExec_t graphExec, cudaStream_t stream) nogil - - {{endif}} - {{if 'cudaGraphExecDestroy' in found_functions}} - - cudaError_t cudaGraphExecDestroy(cudaGraphExec_t graphExec) nogil - - {{endif}} - {{if 'cudaGraphDestroy' in found_functions}} - - cudaError_t cudaGraphDestroy(cudaGraph_t graph) nogil - - {{endif}} - {{if 'cudaGraphDebugDotPrint' in found_functions}} - - cudaError_t cudaGraphDebugDotPrint(cudaGraph_t graph, const char* path, unsigned int flags) nogil - - {{endif}} - {{if 'cudaUserObjectCreate' in found_functions}} - - cudaError_t cudaUserObjectCreate(cudaUserObject_t* object_out, void* ptr, cudaHostFn_t destroy, unsigned int initialRefcount, unsigned int flags) nogil - - {{endif}} - {{if 'cudaUserObjectRetain' in found_functions}} - - cudaError_t cudaUserObjectRetain(cudaUserObject_t object, unsigned int count) nogil - - {{endif}} - {{if 'cudaUserObjectRelease' in found_functions}} - - cudaError_t cudaUserObjectRelease(cudaUserObject_t object, unsigned int count) nogil - - {{endif}} - {{if 'cudaGraphRetainUserObject' in found_functions}} - - cudaError_t cudaGraphRetainUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count, unsigned int flags) nogil - - {{endif}} - {{if 'cudaGraphReleaseUserObject' in found_functions}} - - cudaError_t cudaGraphReleaseUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count) nogil - - {{endif}} - {{if 'cudaGraphAddNode' in found_functions}} - - cudaError_t cudaGraphAddNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, cudaGraphNodeParams* nodeParams) nogil - - {{endif}} - {{if 'cudaGraphNodeSetParams' in found_functions}} - - cudaError_t cudaGraphNodeSetParams(cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) nogil - - {{endif}} - {{if 'cudaGraphNodeGetParams' in found_functions}} - - cudaError_t cudaGraphNodeGetParams(cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) nogil - - {{endif}} - {{if 'cudaGraphExecNodeSetParams' in found_functions}} - - cudaError_t cudaGraphExecNodeSetParams(cudaGraphExec_t graphExec, cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) nogil - - {{endif}} - {{if 'cudaGraphConditionalHandleCreate' in found_functions}} - - cudaError_t cudaGraphConditionalHandleCreate(cudaGraphConditionalHandle* pHandle_out, cudaGraph_t graph, unsigned int defaultLaunchValue, unsigned int flags) nogil - - {{endif}} - {{if 'cudaGraphConditionalHandleCreate_v2' in found_functions}} - - cudaError_t cudaGraphConditionalHandleCreate_v2(cudaGraphConditionalHandle* pHandle_out, cudaGraph_t graph, cudaExecutionContext_t ctx, unsigned int defaultLaunchValue, unsigned int flags) nogil - - {{endif}} - {{if 'cudaGetDriverEntryPoint' in found_functions}} - - cudaError_t cudaGetDriverEntryPoint(const char* symbol, void** funcPtr, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) nogil - - {{endif}} - {{if 'cudaGetDriverEntryPointByVersion' in found_functions}} - - cudaError_t cudaGetDriverEntryPointByVersion(const char* symbol, void** funcPtr, unsigned int cudaVersion, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) nogil - - {{endif}} - {{if 'cudaLibraryLoadData' in found_functions}} - - cudaError_t cudaLibraryLoadData(cudaLibrary_t* library, const void* code, cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) nogil - - {{endif}} - {{if 'cudaLibraryLoadFromFile' in found_functions}} - - cudaError_t cudaLibraryLoadFromFile(cudaLibrary_t* library, const char* fileName, cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) nogil - - {{endif}} - {{if 'cudaLibraryUnload' in found_functions}} - - cudaError_t cudaLibraryUnload(cudaLibrary_t library) nogil - - {{endif}} - {{if 'cudaLibraryGetKernel' in found_functions}} - - cudaError_t cudaLibraryGetKernel(cudaKernel_t* pKernel, cudaLibrary_t library, const char* name) nogil - - {{endif}} - {{if 'cudaLibraryGetGlobal' in found_functions}} - - cudaError_t cudaLibraryGetGlobal(void** dptr, size_t* numbytes, cudaLibrary_t library, const char* name) nogil - - {{endif}} - {{if 'cudaLibraryGetManaged' in found_functions}} - - cudaError_t cudaLibraryGetManaged(void** dptr, size_t* numbytes, cudaLibrary_t library, const char* name) nogil - - {{endif}} - {{if 'cudaLibraryGetUnifiedFunction' in found_functions}} - - cudaError_t cudaLibraryGetUnifiedFunction(void** fptr, cudaLibrary_t library, const char* symbol) nogil - - {{endif}} - {{if 'cudaLibraryGetKernelCount' in found_functions}} - - cudaError_t cudaLibraryGetKernelCount(unsigned int* count, cudaLibrary_t lib) nogil - - {{endif}} - {{if 'cudaLibraryEnumerateKernels' in found_functions}} - - cudaError_t cudaLibraryEnumerateKernels(cudaKernel_t* kernels, unsigned int numKernels, cudaLibrary_t lib) nogil - - {{endif}} - {{if 'cudaKernelSetAttributeForDevice' in found_functions}} - - cudaError_t cudaKernelSetAttributeForDevice(cudaKernel_t kernel, cudaFuncAttribute attr, int value, int device) nogil - - {{endif}} - {{if 'cudaDeviceGetDevResource' in found_functions}} - - cudaError_t cudaDeviceGetDevResource(int device, cudaDevResource* resource, cudaDevResourceType typename) nogil - - {{endif}} - {{if 'cudaDevSmResourceSplitByCount' in found_functions}} - - cudaError_t cudaDevSmResourceSplitByCount(cudaDevResource* result, unsigned int* nbGroups, const cudaDevResource* input, cudaDevResource* remaining, unsigned int flags, unsigned int minCount) nogil - - {{endif}} - {{if 'cudaDevSmResourceSplit' in found_functions}} - - cudaError_t cudaDevSmResourceSplit(cudaDevResource* result, unsigned int nbGroups, const cudaDevResource* input, cudaDevResource* remainder, unsigned int flags, cudaDevSmResourceGroupParams* groupParams) nogil - - {{endif}} - {{if 'cudaDevResourceGenerateDesc' in found_functions}} - - cudaError_t cudaDevResourceGenerateDesc(cudaDevResourceDesc_t* phDesc, cudaDevResource* resources, unsigned int nbResources) nogil - - {{endif}} - {{if 'cudaGreenCtxCreate' in found_functions}} - - cudaError_t cudaGreenCtxCreate(cudaExecutionContext_t* phCtx, cudaDevResourceDesc_t desc, int device, unsigned int flags) nogil - - {{endif}} - {{if 'cudaExecutionCtxDestroy' in found_functions}} - - cudaError_t cudaExecutionCtxDestroy(cudaExecutionContext_t ctx) nogil - - {{endif}} - {{if 'cudaExecutionCtxGetDevResource' in found_functions}} - - cudaError_t cudaExecutionCtxGetDevResource(cudaExecutionContext_t ctx, cudaDevResource* resource, cudaDevResourceType typename) nogil - - {{endif}} - {{if 'cudaExecutionCtxGetDevice' in found_functions}} - - cudaError_t cudaExecutionCtxGetDevice(int* device, cudaExecutionContext_t ctx) nogil - - {{endif}} - {{if 'cudaExecutionCtxGetId' in found_functions}} - - cudaError_t cudaExecutionCtxGetId(cudaExecutionContext_t ctx, unsigned long long* ctxId) nogil - - {{endif}} - {{if 'cudaExecutionCtxStreamCreate' in found_functions}} - - cudaError_t cudaExecutionCtxStreamCreate(cudaStream_t* phStream, cudaExecutionContext_t ctx, unsigned int flags, int priority) nogil - - {{endif}} - {{if 'cudaExecutionCtxSynchronize' in found_functions}} - - cudaError_t cudaExecutionCtxSynchronize(cudaExecutionContext_t ctx) nogil - - {{endif}} - {{if 'cudaStreamGetDevResource' in found_functions}} - - cudaError_t cudaStreamGetDevResource(cudaStream_t hStream, cudaDevResource* resource, cudaDevResourceType typename) nogil - - {{endif}} - {{if 'cudaExecutionCtxRecordEvent' in found_functions}} - - cudaError_t cudaExecutionCtxRecordEvent(cudaExecutionContext_t ctx, cudaEvent_t event) nogil - - {{endif}} - {{if 'cudaExecutionCtxWaitEvent' in found_functions}} - - cudaError_t cudaExecutionCtxWaitEvent(cudaExecutionContext_t ctx, cudaEvent_t event) nogil - - {{endif}} - {{if 'cudaDeviceGetExecutionCtx' in found_functions}} - - cudaError_t cudaDeviceGetExecutionCtx(cudaExecutionContext_t* ctx, int device) nogil - - {{endif}} - {{if 'cudaGetExportTable' in found_functions}} - - cudaError_t cudaGetExportTable(const void** ppExportTable, const cudaUUID_t* pExportTableId) nogil - - {{endif}} - {{if 'cudaGetKernel' in found_functions}} - - cudaError_t cudaGetKernel(cudaKernel_t* kernelPtr, const void* entryFuncAddr) nogil - - {{endif}} - -cdef extern from "cuda_runtime.h": - - {{if 'make_cudaPitchedPtr' in found_functions}} - - cudaPitchedPtr make_cudaPitchedPtr(void* d, size_t p, size_t xsz, size_t ysz) nogil - - {{endif}} - {{if 'make_cudaPos' in found_functions}} - - cudaPos make_cudaPos(size_t x, size_t y, size_t z) nogil - - {{endif}} - {{if 'make_cudaExtent' in found_functions}} - - cudaExtent make_cudaExtent(size_t w, size_t h, size_t d) nogil - - {{endif}} - -cdef extern from "cuda_profiler_api.h": - - {{if 'cudaProfilerStart' in found_functions}} - - cudaError_t cudaProfilerStart() nogil - - {{endif}} - {{if 'cudaProfilerStop' in found_functions}} - - cudaError_t cudaProfilerStop() nogil - - {{endif}} - diff --git a/cuda_bindings/cuda/bindings/cyruntime_types.pxi.in b/cuda_bindings/cuda/bindings/cyruntime_types.pxi.in deleted file mode 100644 index fa881e951dc..00000000000 --- a/cuda_bindings/cuda/bindings/cyruntime_types.pxi.in +++ /dev/null @@ -1,1778 +0,0 @@ -# SPDX-FileCopyrightText: Copyright (c) 2021-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-License-Identifier: Apache-2.0 - -# This code was automatically generated with version 13.3.0. Do not modify it directly. - -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=93953ce179542f5c6172446b305a7568ce2b5190b3bfba1f1c9da282c3b965f0 -cdef extern from "vector_types.h": - - cdef struct dim3: - unsigned int x - unsigned int y - unsigned int z - -cdef extern from "driver_types.h": - - cdef enum cudaError: - cudaSuccess = 0 - cudaErrorInvalidValue = 1 - cudaErrorMemoryAllocation = 2 - cudaErrorInitializationError = 3 - cudaErrorCudartUnloading = 4 - cudaErrorProfilerDisabled = 5 - cudaErrorProfilerNotInitialized = 6 - cudaErrorProfilerAlreadyStarted = 7 - cudaErrorProfilerAlreadyStopped = 8 - cudaErrorInvalidConfiguration = 9 - cudaErrorVersionTranslation = 10 - cudaErrorInvalidPitchValue = 12 - cudaErrorInvalidSymbol = 13 - cudaErrorInvalidHostPointer = 16 - cudaErrorInvalidDevicePointer = 17 - cudaErrorInvalidTexture = 18 - cudaErrorInvalidTextureBinding = 19 - cudaErrorInvalidChannelDescriptor = 20 - cudaErrorInvalidMemcpyDirection = 21 - cudaErrorAddressOfConstant = 22 - cudaErrorTextureFetchFailed = 23 - cudaErrorTextureNotBound = 24 - cudaErrorSynchronizationError = 25 - cudaErrorInvalidFilterSetting = 26 - cudaErrorInvalidNormSetting = 27 - cudaErrorMixedDeviceExecution = 28 - cudaErrorNotYetImplemented = 31 - cudaErrorMemoryValueTooLarge = 32 - cudaErrorStubLibrary = 34 - cudaErrorInsufficientDriver = 35 - cudaErrorCallRequiresNewerDriver = 36 - cudaErrorInvalidSurface = 37 - cudaErrorDuplicateVariableName = 43 - cudaErrorDuplicateTextureName = 44 - cudaErrorDuplicateSurfaceName = 45 - cudaErrorDevicesUnavailable = 46 - cudaErrorIncompatibleDriverContext = 49 - cudaErrorMissingConfiguration = 52 - cudaErrorPriorLaunchFailure = 53 - cudaErrorLaunchMaxDepthExceeded = 65 - cudaErrorLaunchFileScopedTex = 66 - cudaErrorLaunchFileScopedSurf = 67 - cudaErrorSyncDepthExceeded = 68 - cudaErrorLaunchPendingCountExceeded = 69 - cudaErrorInvalidDeviceFunction = 98 - cudaErrorNoDevice = 100 - cudaErrorInvalidDevice = 101 - cudaErrorDeviceNotLicensed = 102 - cudaErrorSoftwareValidityNotEstablished = 103 - cudaErrorStartupFailure = 127 - cudaErrorInvalidKernelImage = 200 - cudaErrorDeviceUninitialized = 201 - cudaErrorMapBufferObjectFailed = 205 - cudaErrorUnmapBufferObjectFailed = 206 - cudaErrorArrayIsMapped = 207 - cudaErrorAlreadyMapped = 208 - cudaErrorNoKernelImageForDevice = 209 - cudaErrorAlreadyAcquired = 210 - cudaErrorNotMapped = 211 - cudaErrorNotMappedAsArray = 212 - cudaErrorNotMappedAsPointer = 213 - cudaErrorECCUncorrectable = 214 - cudaErrorUnsupportedLimit = 215 - cudaErrorDeviceAlreadyInUse = 216 - cudaErrorPeerAccessUnsupported = 217 - cudaErrorInvalidPtx = 218 - cudaErrorInvalidGraphicsContext = 219 - cudaErrorNvlinkUncorrectable = 220 - cudaErrorJitCompilerNotFound = 221 - cudaErrorUnsupportedPtxVersion = 222 - cudaErrorJitCompilationDisabled = 223 - cudaErrorUnsupportedExecAffinity = 224 - cudaErrorUnsupportedDevSideSync = 225 - cudaErrorContained = 226 - cudaErrorInvalidSource = 300 - cudaErrorFileNotFound = 301 - cudaErrorSharedObjectSymbolNotFound = 302 - cudaErrorSharedObjectInitFailed = 303 - cudaErrorOperatingSystem = 304 - cudaErrorInvalidResourceHandle = 400 - cudaErrorIllegalState = 401 - cudaErrorLossyQuery = 402 - cudaErrorSymbolNotFound = 500 - cudaErrorNotReady = 600 - cudaErrorIllegalAddress = 700 - cudaErrorLaunchOutOfResources = 701 - cudaErrorLaunchTimeout = 702 - cudaErrorLaunchIncompatibleTexturing = 703 - cudaErrorPeerAccessAlreadyEnabled = 704 - cudaErrorPeerAccessNotEnabled = 705 - cudaErrorSetOnActiveProcess = 708 - cudaErrorContextIsDestroyed = 709 - cudaErrorAssert = 710 - cudaErrorTooManyPeers = 711 - cudaErrorHostMemoryAlreadyRegistered = 712 - cudaErrorHostMemoryNotRegistered = 713 - cudaErrorHardwareStackError = 714 - cudaErrorIllegalInstruction = 715 - cudaErrorMisalignedAddress = 716 - cudaErrorInvalidAddressSpace = 717 - cudaErrorInvalidPc = 718 - cudaErrorLaunchFailure = 719 - cudaErrorCooperativeLaunchTooLarge = 720 - cudaErrorTensorMemoryLeak = 721 - cudaErrorNotPermitted = 800 - cudaErrorNotSupported = 801 - cudaErrorSystemNotReady = 802 - cudaErrorSystemDriverMismatch = 803 - cudaErrorCompatNotSupportedOnDevice = 804 - cudaErrorMpsConnectionFailed = 805 - cudaErrorMpsRpcFailure = 806 - cudaErrorMpsServerNotReady = 807 - cudaErrorMpsMaxClientsReached = 808 - cudaErrorMpsMaxConnectionsReached = 809 - cudaErrorMpsClientTerminated = 810 - cudaErrorCdpNotSupported = 811 - cudaErrorCdpVersionMismatch = 812 - cudaErrorStreamCaptureUnsupported = 900 - cudaErrorStreamCaptureInvalidated = 901 - cudaErrorStreamCaptureMerge = 902 - cudaErrorStreamCaptureUnmatched = 903 - cudaErrorStreamCaptureUnjoined = 904 - cudaErrorStreamCaptureIsolation = 905 - cudaErrorStreamCaptureImplicit = 906 - cudaErrorCapturedEvent = 907 - cudaErrorStreamCaptureWrongThread = 908 - cudaErrorTimeout = 909 - cudaErrorGraphExecUpdateFailure = 910 - cudaErrorExternalDevice = 911 - cudaErrorInvalidClusterSize = 912 - cudaErrorFunctionNotLoaded = 913 - cudaErrorInvalidResourceType = 914 - cudaErrorInvalidResourceConfiguration = 915 - cudaErrorStreamDetached = 917 - cudaErrorGraphRecaptureFailure = 918 - cudaErrorUnknown = 999 - cudaErrorApiFailureBase = 10000 - - ctypedef cudaError cudaError_t - - cdef struct CUdevResourceDesc_st: - pass - ctypedef CUdevResourceDesc_st* cudaDevResourceDesc_t - - cdef struct cudaExecutionContext_st: - pass - ctypedef cudaExecutionContext_st* cudaExecutionContext_t - - cdef struct cudaChannelFormatDesc: - int x - int y - int z - int w - cudaChannelFormatKind f - - cdef struct cudaArray: - pass - ctypedef cudaArray* cudaArray_t - - cdef struct cudaArray: - pass - ctypedef cudaArray* cudaArray_const_t - - cdef struct cudaMipmappedArray: - pass - ctypedef cudaMipmappedArray* cudaMipmappedArray_t - - cdef struct cudaMipmappedArray: - pass - ctypedef cudaMipmappedArray* cudaMipmappedArray_const_t - - cdef struct anon_struct0: - unsigned int width - unsigned int height - unsigned int depth - - cdef struct cudaArraySparseProperties: - anon_struct0 tileExtent - unsigned int miptailFirstLevel - unsigned long long miptailSize - unsigned int flags - unsigned int reserved[4] - - cdef struct cudaArrayMemoryRequirements: - size_t size - size_t alignment - unsigned int reserved[4] - - cdef struct cudaPitchedPtr: - void* ptr - size_t pitch - size_t xsize - size_t ysize - - cdef struct cudaExtent: - size_t width - size_t height - size_t depth - - cdef struct cudaPos: - size_t x - size_t y - size_t z - - cdef struct cudaMemcpy3DParms: - cudaArray_t srcArray - cudaPos srcPos - cudaPitchedPtr srcPtr - cudaArray_t dstArray - cudaPos dstPos - cudaPitchedPtr dstPtr - cudaExtent extent - cudaMemcpyKind kind - - cdef struct cudaMemcpyNodeParams: - int flags - int reserved - cudaExecutionContext_t ctx - cudaMemcpy3DParms copyParams - - cdef struct cudaMemcpy3DPeerParms: - cudaArray_t srcArray - cudaPos srcPos - cudaPitchedPtr srcPtr - int srcDevice - cudaArray_t dstArray - cudaPos dstPos - cudaPitchedPtr dstPtr - int dstDevice - cudaExtent extent - - cdef struct cudaMemsetParams: - void* dst - size_t pitch - unsigned int value - unsigned int elementSize - size_t width - size_t height - - cdef struct cudaMemsetParamsV2: - void* dst - size_t pitch - unsigned int value - unsigned int elementSize - size_t width - size_t height - cudaExecutionContext_t ctx - - cdef struct cudaAccessPolicyWindow: - void* base_ptr - size_t num_bytes - float hitRatio - cudaAccessProperty hitProp - cudaAccessProperty missProp - - ctypedef void (*cudaHostFn_t)(void* userData) - - cdef struct cudaHostNodeParams: - cudaHostFn_t fn - void* userData - - cdef struct cudaHostNodeParamsV2: - cudaHostFn_t fn - void* userData - unsigned int syncMode - - cdef struct anon_struct1: - cudaArray_t array - - cdef struct anon_struct2: - cudaMipmappedArray_t mipmap - - cdef struct anon_struct3: - void* devPtr - cudaChannelFormatDesc desc - size_t sizeInBytes - - cdef struct anon_struct4: - void* devPtr - cudaChannelFormatDesc desc - size_t width - size_t height - size_t pitchInBytes - - cdef struct anon_struct5: - int reserved[32] - - cdef union anon_union0: - anon_struct1 array - anon_struct2 mipmap - anon_struct3 linear - anon_struct4 pitch2D - anon_struct5 reserved - - cdef struct cudaResourceDesc: - cudaResourceType resType - anon_union0 res - unsigned int flags - - cdef struct cudaResourceViewDesc: - cudaResourceViewFormat format - size_t width - size_t height - size_t depth - unsigned int firstMipmapLevel - unsigned int lastMipmapLevel - unsigned int firstLayer - unsigned int lastLayer - unsigned int reserved[16] - - cdef enum cudaSharedMemoryMode: - cudaSharedMemoryModeDefault = 0 - cudaSharedMemoryModeRequirePortable = 1 - cudaSharedMemoryModeAllowNonPortable = 2 - - cdef struct cudaPointerAttributes: - cudaMemoryType type - int device - void* devicePointer - void* hostPointer - long reserved[8] - - cdef struct cudaFuncAttributes: - size_t sharedSizeBytes - size_t constSizeBytes - size_t localSizeBytes - int maxThreadsPerBlock - int numRegs - int ptxVersion - int binaryVersion - int cacheModeCA - int maxDynamicSharedSizeBytes - int preferredShmemCarveout - int clusterDimMustBeSet - int requiredClusterWidth - int requiredClusterHeight - int requiredClusterDepth - int clusterSchedulingPolicyPreference - int nonPortableClusterSizeAllowed - int deviceNodeUpdateStatus - int reserved1 - int reserved[14] - - cdef struct cudaMemLocation: - cudaMemLocationType type - int id - - cdef struct cudaMemAccessDesc: - cudaMemLocation location - cudaMemAccessFlags flags - - cdef struct cudaMemPoolProps: - cudaMemAllocationType allocType - cudaMemAllocationHandleType handleTypes - cudaMemLocation location - void* win32SecurityAttributes - size_t maxSize - unsigned short usage - unsigned char reserved[54] - - cdef struct cudaMemPoolPtrExportData: - unsigned char reserved[64] - - cdef struct cudaMemAllocNodeParams: - cudaMemPoolProps poolProps - const cudaMemAccessDesc* accessDescs - size_t accessDescCount - size_t bytesize - void* dptr - - cdef struct cudaMemAllocNodeParamsV2: - cudaMemPoolProps poolProps - const cudaMemAccessDesc* accessDescs - size_t accessDescCount - size_t bytesize - void* dptr - - cdef struct cudaMemFreeNodeParams: - void* dptr - - cdef struct cudaMemcpyAttributes: - cudaMemcpySrcAccessOrder srcAccessOrder - cudaMemLocation srcLocHint - cudaMemLocation dstLocHint - unsigned int flags - - cdef struct cudaOffset3D: - size_t x - size_t y - size_t z - - cdef struct anon_struct6: - void* ptr - size_t rowLength - size_t layerHeight - cudaMemLocation locHint - - cdef struct anon_struct7: - cudaArray_t array - cudaOffset3D offset - - cdef union anon_union2: - anon_struct6 ptr - anon_struct7 array - - cdef struct cudaMemcpy3DOperand: - cudaMemcpy3DOperandType type - anon_union2 op - - cdef struct cudaMemcpy3DBatchOp: - cudaMemcpy3DOperand src - cudaMemcpy3DOperand dst - cudaExtent extent - cudaMemcpySrcAccessOrder srcAccessOrder - unsigned int flags - - cdef struct CUuuid_st: - char bytes[16] - - ctypedef CUuuid_st CUuuid - - ctypedef CUuuid_st cudaUUID_t - - cdef struct cudaDeviceProp: - char name[256] - cudaUUID_t uuid - char luid[8] - unsigned int luidDeviceNodeMask - size_t totalGlobalMem - size_t sharedMemPerBlock - int regsPerBlock - int warpSize - size_t memPitch - int maxThreadsPerBlock - int maxThreadsDim[3] - int maxGridSize[3] - size_t totalConstMem - int major - int minor - size_t textureAlignment - size_t texturePitchAlignment - int multiProcessorCount - int integrated - int canMapHostMemory - int maxTexture1D - int maxTexture1DMipmap - int maxTexture2D[2] - int maxTexture2DMipmap[2] - int maxTexture2DLinear[3] - int maxTexture2DGather[2] - int maxTexture3D[3] - int maxTexture3DAlt[3] - int maxTextureCubemap - int maxTexture1DLayered[2] - int maxTexture2DLayered[3] - int maxTextureCubemapLayered[2] - int maxSurface1D - int maxSurface2D[2] - int maxSurface3D[3] - int maxSurface1DLayered[2] - int maxSurface2DLayered[3] - int maxSurfaceCubemap - int maxSurfaceCubemapLayered[2] - size_t surfaceAlignment - int concurrentKernels - int ECCEnabled - int pciBusID - int pciDeviceID - int pciDomainID - int tccDriver - int asyncEngineCount - int unifiedAddressing - int memoryBusWidth - int l2CacheSize - int persistingL2CacheMaxSize - int maxThreadsPerMultiProcessor - int streamPrioritiesSupported - int globalL1CacheSupported - int localL1CacheSupported - size_t sharedMemPerMultiprocessor - int regsPerMultiprocessor - int managedMemory - int isMultiGpuBoard - int multiGpuBoardGroupID - int hostNativeAtomicSupported - int pageableMemoryAccess - int concurrentManagedAccess - int computePreemptionSupported - int canUseHostPointerForRegisteredMem - int cooperativeLaunch - size_t sharedMemPerBlockOptin - int pageableMemoryAccessUsesHostPageTables - int directManagedMemAccessFromHost - int maxBlocksPerMultiProcessor - int accessPolicyMaxWindowSize - size_t reservedSharedMemPerBlock - int hostRegisterSupported - int sparseCudaArraySupported - int hostRegisterReadOnlySupported - int timelineSemaphoreInteropSupported - int memoryPoolsSupported - int gpuDirectRDMASupported - unsigned int gpuDirectRDMAFlushWritesOptions - int gpuDirectRDMAWritesOrdering - unsigned int memoryPoolSupportedHandleTypes - int deferredMappingCudaArraySupported - int ipcEventSupported - int clusterLaunch - int unifiedFunctionPointers - int deviceNumaConfig - int deviceNumaId - int mpsEnabled - int hostNumaId - unsigned int gpuPciDeviceID - unsigned int gpuPciSubsystemID - int hostNumaMultinodeIpcSupported - int reserved[56] - - cdef struct cudaIpcEventHandle_st: - char reserved[64] - - ctypedef cudaIpcEventHandle_st cudaIpcEventHandle_t - - cdef struct cudaIpcMemHandle_st: - char reserved[64] - - ctypedef cudaIpcMemHandle_st cudaIpcMemHandle_t - - cdef struct cudaMemFabricHandle_st: - char reserved[64] - - ctypedef cudaMemFabricHandle_st cudaMemFabricHandle_t - - cdef struct anon_struct8: - void* handle - const void* name - - cdef union anon_union3: - int fd - anon_struct8 win32 - const void* nvSciBufObject - - cdef struct cudaExternalMemoryHandleDesc: - cudaExternalMemoryHandleType type - anon_union3 handle - unsigned long long size - unsigned int flags - unsigned int reserved[16] - - cdef struct cudaExternalMemoryBufferDesc: - unsigned long long offset - unsigned long long size - unsigned int flags - unsigned int reserved[16] - - cdef struct cudaExternalMemoryMipmappedArrayDesc: - unsigned long long offset - cudaChannelFormatDesc formatDesc - cudaExtent extent - unsigned int flags - unsigned int numLevels - unsigned int reserved[16] - - cdef struct anon_struct9: - void* handle - const void* name - - cdef union anon_union4: - int fd - anon_struct9 win32 - const void* nvSciSyncObj - - cdef struct cudaExternalSemaphoreHandleDesc: - cudaExternalSemaphoreHandleType type - anon_union4 handle - unsigned int flags - unsigned int reserved[16] - - cdef struct anon_struct10: - unsigned long long value - - cdef union anon_union5: - void* fence - unsigned long long reserved - - cdef struct anon_struct11: - unsigned long long key - - cdef struct anon_struct12: - anon_struct10 fence - anon_union5 nvSciSync - anon_struct11 keyedMutex - unsigned int reserved[12] - - cdef struct cudaExternalSemaphoreSignalParams: - anon_struct12 params - unsigned int flags - unsigned int reserved[16] - - cdef struct anon_struct13: - unsigned long long value - - cdef union anon_union6: - void* fence - unsigned long long reserved - - cdef struct anon_struct14: - unsigned long long key - unsigned int timeoutMs - - cdef struct anon_struct15: - anon_struct13 fence - anon_union6 nvSciSync - anon_struct14 keyedMutex - unsigned int reserved[10] - - cdef struct cudaExternalSemaphoreWaitParams: - anon_struct15 params - unsigned int flags - unsigned int reserved[16] - - cdef struct cudaDevSmResource: - unsigned int smCount - unsigned int minSmPartitionSize - unsigned int smCoscheduledAlignment - unsigned int flags - - cdef struct cudaDevWorkqueueConfigResource: - int device - unsigned int wqConcurrencyLimit - cudaDevWorkqueueConfigScope sharingScope - - cdef struct cudaDevWorkqueueResource: - unsigned char reserved[40] - - cdef struct cudaDevSmResourceGroupParams_st: - unsigned int smCount - unsigned int coscheduledSmCount - unsigned int preferredCoscheduledSmCount - unsigned int flags - unsigned int reserved[12] - - ctypedef cudaDevSmResourceGroupParams_st cudaDevSmResourceGroupParams - - cdef struct cudaDevResource_st: - cudaDevResourceType type - unsigned char _internal_padding[92] - cudaDevSmResource sm - cudaDevWorkqueueConfigResource wqConfig - cudaDevWorkqueueResource wq - unsigned char _oversize[40] - cudaDevResource_st* nextResource - - ctypedef cudaDevResource_st cudaDevResource - - cdef struct CUstream_st: - pass - ctypedef CUstream_st* cudaStream_t - - cdef struct CUevent_st: - pass - ctypedef CUevent_st* cudaEvent_t - - cdef struct cudaGraphicsResource: - pass - ctypedef cudaGraphicsResource* cudaGraphicsResource_t - - cdef struct CUexternalMemory_st: - pass - ctypedef CUexternalMemory_st* cudaExternalMemory_t - - cdef struct CUexternalSemaphore_st: - pass - ctypedef CUexternalSemaphore_st* cudaExternalSemaphore_t - - cdef struct CUgraph_st: - pass - ctypedef CUgraph_st* cudaGraph_t - - cdef struct CUgraphNode_st: - pass - ctypedef CUgraphNode_st* cudaGraphNode_t - - cdef struct CUuserObject_st: - pass - ctypedef CUuserObject_st* cudaUserObject_t - - ctypedef unsigned long long cudaGraphConditionalHandle - - cdef struct CUfunc_st: - pass - ctypedef CUfunc_st* cudaFunction_t - - cdef struct CUkern_st: - pass - ctypedef CUkern_st* cudaKernel_t - - cdef struct cudalibraryHostUniversalFunctionAndDataTable: - void* functionTable - size_t functionWindowSize - void* dataTable - size_t dataWindowSize - - cdef struct CUlib_st: - pass - ctypedef CUlib_st* cudaLibrary_t - - cdef struct CUmemPoolHandle_st: - pass - ctypedef CUmemPoolHandle_st* cudaMemPool_t - - cdef struct cudaKernelNodeParams: - void* func - dim3 gridDim - dim3 blockDim - unsigned int sharedMemBytes - void** kernelParams - void** extra - - cdef struct cudaKernelNodeParamsV2: - void* func - cudaKernel_t kern - cudaFunction_t cuFunc - dim3 gridDim - dim3 blockDim - unsigned int sharedMemBytes - void** kernelParams - void** extra - cudaExecutionContext_t ctx - cudaKernelFunctionType functionType - - cdef struct cudaExternalSemaphoreSignalNodeParams: - cudaExternalSemaphore_t* extSemArray - const cudaExternalSemaphoreSignalParams* paramsArray - unsigned int numExtSems - - cdef struct cudaExternalSemaphoreSignalNodeParamsV2: - cudaExternalSemaphore_t* extSemArray - const cudaExternalSemaphoreSignalParams* paramsArray - unsigned int numExtSems - - cdef struct cudaExternalSemaphoreWaitNodeParams: - cudaExternalSemaphore_t* extSemArray - const cudaExternalSemaphoreWaitParams* paramsArray - unsigned int numExtSems - - cdef struct cudaExternalSemaphoreWaitNodeParamsV2: - cudaExternalSemaphore_t* extSemArray - const cudaExternalSemaphoreWaitParams* paramsArray - unsigned int numExtSems - - cdef struct cudaConditionalNodeParams: - cudaGraphConditionalHandle handle - cudaGraphConditionalNodeType type - unsigned int size - cudaGraph_t* phGraph_out - cudaExecutionContext_t ctx - - cdef struct cudaChildGraphNodeParams: - cudaGraph_t graph - cudaGraphChildGraphNodeOwnership ownership - - cdef struct cudaEventRecordNodeParams: - cudaEvent_t event - - cdef struct cudaEventWaitNodeParams: - cudaEvent_t event - - cdef struct cudaGraphNodeParams: - cudaGraphNodeType type - int reserved0[3] - long long reserved1[29] - cudaKernelNodeParamsV2 kernel - cudaMemcpyNodeParams memcpy - cudaMemsetParamsV2 memset - cudaHostNodeParamsV2 host - cudaChildGraphNodeParams graph - cudaEventWaitNodeParams eventWait - cudaEventRecordNodeParams eventRecord - cudaExternalSemaphoreSignalNodeParamsV2 extSemSignal - cudaExternalSemaphoreWaitNodeParamsV2 extSemWait - cudaMemAllocNodeParamsV2 alloc - cudaMemFreeNodeParams free - cudaConditionalNodeParams conditional - long long reserved2 - - cdef enum cudaGraphDependencyType_enum: - cudaGraphDependencyTypeDefault = 0 - cudaGraphDependencyTypeProgrammatic = 1 - - ctypedef cudaGraphDependencyType_enum cudaGraphDependencyType - - cdef struct cudaGraphEdgeData_st: - unsigned char from_port - unsigned char to_port - unsigned char type - unsigned char reserved[5] - - ctypedef cudaGraphEdgeData_st cudaGraphEdgeData - - cdef struct CUgraphExec_st: - pass - ctypedef CUgraphExec_st* cudaGraphExec_t - - cdef enum cudaGraphInstantiateResult: - cudaGraphInstantiateSuccess = 0 - cudaGraphInstantiateError = 1 - cudaGraphInstantiateInvalidStructure = 2 - cudaGraphInstantiateNodeOperationNotSupported = 3 - cudaGraphInstantiateMultipleDevicesNotSupported = 4 - cudaGraphInstantiateConditionalHandleUnused = 5 - - cdef struct cudaGraphInstantiateParams_st: - unsigned long long flags - cudaStream_t uploadStream - cudaGraphNode_t errNode_out - cudaGraphInstantiateResult result_out - - ctypedef cudaGraphInstantiateParams_st cudaGraphInstantiateParams - - cdef struct cudaGraphExecUpdateResultInfo_st: - cudaGraphExecUpdateResult result - cudaGraphNode_t errorNode - cudaGraphNode_t errorFromNode - - ctypedef cudaGraphExecUpdateResultInfo_st cudaGraphExecUpdateResultInfo - - cdef struct CUgraphDeviceUpdatableNode_st: - pass - ctypedef CUgraphDeviceUpdatableNode_st* cudaGraphDeviceNode_t - - cdef struct anon_struct16: - const void* pValue - size_t offset - size_t size - - cdef union anon_union10: - dim3 gridDim - anon_struct16 param - unsigned int isEnabled - - cdef struct cudaGraphKernelNodeUpdate: - cudaGraphDeviceNode_t node - cudaGraphKernelNodeField field - anon_union10 updateData - - cdef enum cudaLaunchMemSyncDomain: - cudaLaunchMemSyncDomainDefault = 0 - cudaLaunchMemSyncDomainRemote = 1 - - cdef struct cudaLaunchMemSyncDomainMap_st: - unsigned char default_ - unsigned char remote - - ctypedef cudaLaunchMemSyncDomainMap_st cudaLaunchMemSyncDomainMap - - cdef enum cudaLaunchAttributePortableClusterMode: - cudaLaunchPortableClusterModeDefault = 0 - cudaLaunchPortableClusterModeRequirePortable = 1 - cudaLaunchPortableClusterModeAllowNonPortable = 2 - - cdef enum cudaLaunchAttributeID: - cudaLaunchAttributeIgnore = 0 - cudaLaunchAttributeAccessPolicyWindow = 1 - cudaLaunchAttributeCooperative = 2 - cudaLaunchAttributeSynchronizationPolicy = 3 - cudaLaunchAttributeClusterDimension = 4 - cudaLaunchAttributeClusterSchedulingPolicyPreference = 5 - cudaLaunchAttributeProgrammaticStreamSerialization = 6 - cudaLaunchAttributeProgrammaticEvent = 7 - cudaLaunchAttributePriority = 8 - cudaLaunchAttributeMemSyncDomainMap = 9 - cudaLaunchAttributeMemSyncDomain = 10 - cudaLaunchAttributePreferredClusterDimension = 11 - cudaLaunchAttributeLaunchCompletionEvent = 12 - cudaLaunchAttributeDeviceUpdatableKernelNode = 13 - cudaLaunchAttributePreferredSharedMemoryCarveout = 14 - cudaLaunchAttributeNvlinkUtilCentricScheduling = 16 - cudaLaunchAttributePortableClusterSizeMode = 17 - cudaLaunchAttributeSharedMemoryMode = 18 - - cdef struct anon_struct17: - unsigned int x - unsigned int y - unsigned int z - - cdef struct anon_struct18: - cudaEvent_t event - int flags - int triggerAtBlockStart - - cdef struct anon_struct19: - unsigned int x - unsigned int y - unsigned int z - - cdef struct anon_struct20: - cudaEvent_t event - int flags - - cdef struct anon_struct21: - int deviceUpdatable - cudaGraphDeviceNode_t devNode - - cdef union cudaLaunchAttributeValue: - char pad[64] - cudaAccessPolicyWindow accessPolicyWindow - int cooperative - cudaSynchronizationPolicy syncPolicy - anon_struct17 clusterDim - cudaClusterSchedulingPolicy clusterSchedulingPolicyPreference - int programmaticStreamSerializationAllowed - anon_struct18 programmaticEvent - int priority - cudaLaunchMemSyncDomainMap memSyncDomainMap - cudaLaunchMemSyncDomain memSyncDomain - anon_struct19 preferredClusterDim - anon_struct20 launchCompletionEvent - anon_struct21 deviceUpdatableKernelNode - unsigned int sharedMemCarveout - unsigned int nvlinkUtilCentricScheduling - cudaLaunchAttributePortableClusterMode portableClusterSizeMode - cudaSharedMemoryMode sharedMemoryMode - - cdef struct cudaLaunchAttribute_st: - cudaLaunchAttributeID id - cudaLaunchAttributeValue val - - ctypedef cudaLaunchAttribute_st cudaLaunchAttribute - - cdef struct cudaAsyncCallbackEntry: - pass - ctypedef cudaAsyncCallbackEntry* cudaAsyncCallbackHandle_t - - cdef enum cudaAsyncNotificationType_enum: - cudaAsyncNotificationTypeOverBudget = 1 - - ctypedef cudaAsyncNotificationType_enum cudaAsyncNotificationType - - cdef struct anon_struct22: - unsigned long long bytesOverBudget - - cdef union anon_union11: - anon_struct22 overBudget - - cdef struct cudaAsyncNotificationInfo: - cudaAsyncNotificationType type - anon_union11 info - - ctypedef cudaAsyncNotificationInfo cudaAsyncNotificationInfo_t - - ctypedef void (*cudaAsyncCallback)(cudaAsyncNotificationInfo_t* , void* , cudaAsyncCallbackHandle_t ) - - cdef enum CUDAlogLevel_enum: - cudaLogLevelError = 0 - cudaLogLevelWarning = 1 - - ctypedef CUDAlogLevel_enum cudaLogLevel - - cdef struct CUlogsCallbackEntry_st: - pass - ctypedef CUlogsCallbackEntry_st* cudaLogsCallbackHandle - - ctypedef unsigned int cudaLogIterator - - cdef enum cudaChannelFormatKind: - cudaChannelFormatKindSigned = 0 - cudaChannelFormatKindUnsigned = 1 - cudaChannelFormatKindFloat = 2 - cudaChannelFormatKindNone = 3 - cudaChannelFormatKindNV12 = 4 - cudaChannelFormatKindUnsignedNormalized8X1 = 5 - cudaChannelFormatKindUnsignedNormalized8X2 = 6 - cudaChannelFormatKindUnsignedNormalized8X4 = 7 - cudaChannelFormatKindUnsignedNormalized16X1 = 8 - cudaChannelFormatKindUnsignedNormalized16X2 = 9 - cudaChannelFormatKindUnsignedNormalized16X4 = 10 - cudaChannelFormatKindSignedNormalized8X1 = 11 - cudaChannelFormatKindSignedNormalized8X2 = 12 - cudaChannelFormatKindSignedNormalized8X4 = 13 - cudaChannelFormatKindSignedNormalized16X1 = 14 - cudaChannelFormatKindSignedNormalized16X2 = 15 - cudaChannelFormatKindSignedNormalized16X4 = 16 - cudaChannelFormatKindUnsignedBlockCompressed1 = 17 - cudaChannelFormatKindUnsignedBlockCompressed1SRGB = 18 - cudaChannelFormatKindUnsignedBlockCompressed2 = 19 - cudaChannelFormatKindUnsignedBlockCompressed2SRGB = 20 - cudaChannelFormatKindUnsignedBlockCompressed3 = 21 - cudaChannelFormatKindUnsignedBlockCompressed3SRGB = 22 - cudaChannelFormatKindUnsignedBlockCompressed4 = 23 - cudaChannelFormatKindSignedBlockCompressed4 = 24 - cudaChannelFormatKindUnsignedBlockCompressed5 = 25 - cudaChannelFormatKindSignedBlockCompressed5 = 26 - cudaChannelFormatKindUnsignedBlockCompressed6H = 27 - cudaChannelFormatKindSignedBlockCompressed6H = 28 - cudaChannelFormatKindUnsignedBlockCompressed7 = 29 - cudaChannelFormatKindUnsignedBlockCompressed7SRGB = 30 - cudaChannelFormatKindUnsignedNormalized1010102 = 31 - cudaChannelFormatKindUnsigned8Packed422 = 32 - cudaChannelFormatKindUnsigned8Packed444 = 33 - cudaChannelFormatKindUnsigned8SemiPlanar420 = 34 - cudaChannelFormatKindUnsigned16SemiPlanar420 = 35 - cudaChannelFormatKindUnsigned8SemiPlanar422 = 36 - cudaChannelFormatKindUnsigned16SemiPlanar422 = 37 - cudaChannelFormatKindUnsigned8SemiPlanar444 = 38 - cudaChannelFormatKindUnsigned16SemiPlanar444 = 39 - cudaChannelFormatKindUnsigned8Planar420 = 40 - cudaChannelFormatKindUnsigned16Planar420 = 41 - cudaChannelFormatKindUnsigned8Planar422 = 42 - cudaChannelFormatKindUnsigned16Planar422 = 43 - cudaChannelFormatKindUnsigned8Planar444 = 44 - cudaChannelFormatKindUnsigned16Planar444 = 45 - - cdef enum cudaMemoryType: - cudaMemoryTypeUnregistered = 0 - cudaMemoryTypeHost = 1 - cudaMemoryTypeDevice = 2 - cudaMemoryTypeManaged = 3 - - cdef enum cudaMemcpyKind: - cudaMemcpyHostToHost = 0 - cudaMemcpyHostToDevice = 1 - cudaMemcpyDeviceToHost = 2 - cudaMemcpyDeviceToDevice = 3 - cudaMemcpyDefault = 4 - - cdef enum cudaAccessProperty: - cudaAccessPropertyNormal = 0 - cudaAccessPropertyStreaming = 1 - cudaAccessPropertyPersisting = 2 - - cdef enum cudaStreamCaptureStatus: - cudaStreamCaptureStatusNone = 0 - cudaStreamCaptureStatusActive = 1 - cudaStreamCaptureStatusInvalidated = 2 - - cdef enum cudaGraphRecaptureStatus: - cudaGraphRecaptureEligibleForUpdate = 0 - cudaGraphRecaptureIneligibleForUpdate = 1 - cudaGraphRecaptureError = 2 - - cdef enum cudaStreamCaptureMode: - cudaStreamCaptureModeGlobal = 0 - cudaStreamCaptureModeThreadLocal = 1 - cudaStreamCaptureModeRelaxed = 2 - - cdef enum cudaSynchronizationPolicy: - cudaSyncPolicyAuto = 1 - cudaSyncPolicySpin = 2 - cudaSyncPolicyYield = 3 - cudaSyncPolicyBlockingSync = 4 - - cdef enum cudaClusterSchedulingPolicy: - cudaClusterSchedulingPolicyDefault = 0 - cudaClusterSchedulingPolicySpread = 1 - cudaClusterSchedulingPolicyLoadBalancing = 2 - - cdef enum cudaStreamUpdateCaptureDependenciesFlags: - cudaStreamAddCaptureDependencies = 0 - cudaStreamSetCaptureDependencies = 1 - - cdef enum cudaUserObjectFlags: - cudaUserObjectNoDestructorSync = 1 - - cdef enum cudaUserObjectRetainFlags: - cudaGraphUserObjectMove = 1 - - cdef enum cudaHostTaskSyncMode: - cudaHostTaskBlocking = 0 - cudaHostTaskSpinWait = 1 - - cdef enum cudaGraphicsRegisterFlags: - cudaGraphicsRegisterFlagsNone = 0 - cudaGraphicsRegisterFlagsReadOnly = 1 - cudaGraphicsRegisterFlagsWriteDiscard = 2 - cudaGraphicsRegisterFlagsSurfaceLoadStore = 4 - cudaGraphicsRegisterFlagsTextureGather = 8 - - cdef enum cudaGraphicsMapFlags: - cudaGraphicsMapFlagsNone = 0 - cudaGraphicsMapFlagsReadOnly = 1 - cudaGraphicsMapFlagsWriteDiscard = 2 - - cdef enum cudaGraphicsCubeFace: - cudaGraphicsCubeFacePositiveX = 0 - cudaGraphicsCubeFaceNegativeX = 1 - cudaGraphicsCubeFacePositiveY = 2 - cudaGraphicsCubeFaceNegativeY = 3 - cudaGraphicsCubeFacePositiveZ = 4 - cudaGraphicsCubeFaceNegativeZ = 5 - - cdef enum cudaResourceType: - cudaResourceTypeArray = 0 - cudaResourceTypeMipmappedArray = 1 - cudaResourceTypeLinear = 2 - cudaResourceTypePitch2D = 3 - - cdef enum cudaResourceViewFormat: - cudaResViewFormatNone = 0 - cudaResViewFormatUnsignedChar1 = 1 - cudaResViewFormatUnsignedChar2 = 2 - cudaResViewFormatUnsignedChar4 = 3 - cudaResViewFormatSignedChar1 = 4 - cudaResViewFormatSignedChar2 = 5 - cudaResViewFormatSignedChar4 = 6 - cudaResViewFormatUnsignedShort1 = 7 - cudaResViewFormatUnsignedShort2 = 8 - cudaResViewFormatUnsignedShort4 = 9 - cudaResViewFormatSignedShort1 = 10 - cudaResViewFormatSignedShort2 = 11 - cudaResViewFormatSignedShort4 = 12 - cudaResViewFormatUnsignedInt1 = 13 - cudaResViewFormatUnsignedInt2 = 14 - cudaResViewFormatUnsignedInt4 = 15 - cudaResViewFormatSignedInt1 = 16 - cudaResViewFormatSignedInt2 = 17 - cudaResViewFormatSignedInt4 = 18 - cudaResViewFormatHalf1 = 19 - cudaResViewFormatHalf2 = 20 - cudaResViewFormatHalf4 = 21 - cudaResViewFormatFloat1 = 22 - cudaResViewFormatFloat2 = 23 - cudaResViewFormatFloat4 = 24 - cudaResViewFormatUnsignedBlockCompressed1 = 25 - cudaResViewFormatUnsignedBlockCompressed2 = 26 - cudaResViewFormatUnsignedBlockCompressed3 = 27 - cudaResViewFormatUnsignedBlockCompressed4 = 28 - cudaResViewFormatSignedBlockCompressed4 = 29 - cudaResViewFormatUnsignedBlockCompressed5 = 30 - cudaResViewFormatSignedBlockCompressed5 = 31 - cudaResViewFormatUnsignedBlockCompressed6H = 32 - cudaResViewFormatSignedBlockCompressed6H = 33 - cudaResViewFormatUnsignedBlockCompressed7 = 34 - - cdef enum cudaFuncAttribute: - cudaFuncAttributeMaxDynamicSharedMemorySize = 8 - cudaFuncAttributePreferredSharedMemoryCarveout = 9 - cudaFuncAttributeClusterDimMustBeSet = 10 - cudaFuncAttributeRequiredClusterWidth = 11 - cudaFuncAttributeRequiredClusterHeight = 12 - cudaFuncAttributeRequiredClusterDepth = 13 - cudaFuncAttributeNonPortableClusterSizeAllowed = 14 - cudaFuncAttributeClusterSchedulingPolicyPreference = 15 - cudaFuncAttributeMax = 16 - - cdef enum cudaFuncCache: - cudaFuncCachePreferNone = 0 - cudaFuncCachePreferShared = 1 - cudaFuncCachePreferL1 = 2 - cudaFuncCachePreferEqual = 3 - - cdef enum cudaSharedMemConfig: - cudaSharedMemBankSizeDefault = 0 - cudaSharedMemBankSizeFourByte = 1 - cudaSharedMemBankSizeEightByte = 2 - - cdef enum cudaSharedCarveout: - cudaSharedmemCarveoutDefault = -1 - cudaSharedmemCarveoutMaxL1 = 0 - cudaSharedmemCarveoutMaxShared = 100 - - cdef enum cudaComputeMode: - cudaComputeModeDefault = 0 - cudaComputeModeExclusive = 1 - cudaComputeModeProhibited = 2 - cudaComputeModeExclusiveProcess = 3 - - cdef enum cudaLimit: - cudaLimitStackSize = 0 - cudaLimitPrintfFifoSize = 1 - cudaLimitMallocHeapSize = 2 - cudaLimitDevRuntimeSyncDepth = 3 - cudaLimitDevRuntimePendingLaunchCount = 4 - cudaLimitMaxL2FetchGranularity = 5 - cudaLimitPersistingL2CacheSize = 6 - - cdef enum cudaMemoryAdvise: - cudaMemAdviseSetReadMostly = 1 - cudaMemAdviseUnsetReadMostly = 2 - cudaMemAdviseSetPreferredLocation = 3 - cudaMemAdviseUnsetPreferredLocation = 4 - cudaMemAdviseSetAccessedBy = 5 - cudaMemAdviseUnsetAccessedBy = 6 - - cdef enum cudaMemRangeAttribute: - cudaMemRangeAttributeReadMostly = 1 - cudaMemRangeAttributePreferredLocation = 2 - cudaMemRangeAttributeAccessedBy = 3 - cudaMemRangeAttributeLastPrefetchLocation = 4 - cudaMemRangeAttributePreferredLocationType = 5 - cudaMemRangeAttributePreferredLocationId = 6 - cudaMemRangeAttributeLastPrefetchLocationType = 7 - cudaMemRangeAttributeLastPrefetchLocationId = 8 - - cdef enum cudaFlushGPUDirectRDMAWritesOptions: - cudaFlushGPUDirectRDMAWritesOptionHost = 1 - cudaFlushGPUDirectRDMAWritesOptionMemOps = 2 - - cdef enum cudaGPUDirectRDMAWritesOrdering: - cudaGPUDirectRDMAWritesOrderingNone = 0 - cudaGPUDirectRDMAWritesOrderingOwner = 100 - cudaGPUDirectRDMAWritesOrderingAllDevices = 200 - - cdef enum cudaFlushGPUDirectRDMAWritesScope: - cudaFlushGPUDirectRDMAWritesToOwner = 100 - cudaFlushGPUDirectRDMAWritesToAllDevices = 200 - - cdef enum cudaFlushGPUDirectRDMAWritesTarget: - cudaFlushGPUDirectRDMAWritesTargetCurrentDevice = 0 - - cdef enum cudaDeviceAttr: - cudaDevAttrMaxThreadsPerBlock = 1 - cudaDevAttrMaxBlockDimX = 2 - cudaDevAttrMaxBlockDimY = 3 - cudaDevAttrMaxBlockDimZ = 4 - cudaDevAttrMaxGridDimX = 5 - cudaDevAttrMaxGridDimY = 6 - cudaDevAttrMaxGridDimZ = 7 - cudaDevAttrMaxSharedMemoryPerBlock = 8 - cudaDevAttrTotalConstantMemory = 9 - cudaDevAttrWarpSize = 10 - cudaDevAttrMaxPitch = 11 - cudaDevAttrMaxRegistersPerBlock = 12 - cudaDevAttrClockRate = 13 - cudaDevAttrTextureAlignment = 14 - cudaDevAttrGpuOverlap = 15 - cudaDevAttrMultiProcessorCount = 16 - cudaDevAttrKernelExecTimeout = 17 - cudaDevAttrIntegrated = 18 - cudaDevAttrCanMapHostMemory = 19 - cudaDevAttrComputeMode = 20 - cudaDevAttrMaxTexture1DWidth = 21 - cudaDevAttrMaxTexture2DWidth = 22 - cudaDevAttrMaxTexture2DHeight = 23 - cudaDevAttrMaxTexture3DWidth = 24 - cudaDevAttrMaxTexture3DHeight = 25 - cudaDevAttrMaxTexture3DDepth = 26 - cudaDevAttrMaxTexture2DLayeredWidth = 27 - cudaDevAttrMaxTexture2DLayeredHeight = 28 - cudaDevAttrMaxTexture2DLayeredLayers = 29 - cudaDevAttrSurfaceAlignment = 30 - cudaDevAttrConcurrentKernels = 31 - cudaDevAttrEccEnabled = 32 - cudaDevAttrPciBusId = 33 - cudaDevAttrPciDeviceId = 34 - cudaDevAttrTccDriver = 35 - cudaDevAttrMemoryClockRate = 36 - cudaDevAttrGlobalMemoryBusWidth = 37 - cudaDevAttrL2CacheSize = 38 - cudaDevAttrMaxThreadsPerMultiProcessor = 39 - cudaDevAttrAsyncEngineCount = 40 - cudaDevAttrUnifiedAddressing = 41 - cudaDevAttrMaxTexture1DLayeredWidth = 42 - cudaDevAttrMaxTexture1DLayeredLayers = 43 - cudaDevAttrMaxTexture2DGatherWidth = 45 - cudaDevAttrMaxTexture2DGatherHeight = 46 - cudaDevAttrMaxTexture3DWidthAlt = 47 - cudaDevAttrMaxTexture3DHeightAlt = 48 - cudaDevAttrMaxTexture3DDepthAlt = 49 - cudaDevAttrPciDomainId = 50 - cudaDevAttrTexturePitchAlignment = 51 - cudaDevAttrMaxTextureCubemapWidth = 52 - cudaDevAttrMaxTextureCubemapLayeredWidth = 53 - cudaDevAttrMaxTextureCubemapLayeredLayers = 54 - cudaDevAttrMaxSurface1DWidth = 55 - cudaDevAttrMaxSurface2DWidth = 56 - cudaDevAttrMaxSurface2DHeight = 57 - cudaDevAttrMaxSurface3DWidth = 58 - cudaDevAttrMaxSurface3DHeight = 59 - cudaDevAttrMaxSurface3DDepth = 60 - cudaDevAttrMaxSurface1DLayeredWidth = 61 - cudaDevAttrMaxSurface1DLayeredLayers = 62 - cudaDevAttrMaxSurface2DLayeredWidth = 63 - cudaDevAttrMaxSurface2DLayeredHeight = 64 - cudaDevAttrMaxSurface2DLayeredLayers = 65 - cudaDevAttrMaxSurfaceCubemapWidth = 66 - cudaDevAttrMaxSurfaceCubemapLayeredWidth = 67 - cudaDevAttrMaxSurfaceCubemapLayeredLayers = 68 - cudaDevAttrMaxTexture1DLinearWidth = 69 - cudaDevAttrMaxTexture2DLinearWidth = 70 - cudaDevAttrMaxTexture2DLinearHeight = 71 - cudaDevAttrMaxTexture2DLinearPitch = 72 - cudaDevAttrMaxTexture2DMipmappedWidth = 73 - cudaDevAttrMaxTexture2DMipmappedHeight = 74 - cudaDevAttrComputeCapabilityMajor = 75 - cudaDevAttrComputeCapabilityMinor = 76 - cudaDevAttrMaxTexture1DMipmappedWidth = 77 - cudaDevAttrStreamPrioritiesSupported = 78 - cudaDevAttrGlobalL1CacheSupported = 79 - cudaDevAttrLocalL1CacheSupported = 80 - cudaDevAttrMaxSharedMemoryPerMultiprocessor = 81 - cudaDevAttrMaxRegistersPerMultiprocessor = 82 - cudaDevAttrManagedMemory = 83 - cudaDevAttrIsMultiGpuBoard = 84 - cudaDevAttrMultiGpuBoardGroupID = 85 - cudaDevAttrHostNativeAtomicSupported = 86 - cudaDevAttrSingleToDoublePrecisionPerfRatio = 87 - cudaDevAttrPageableMemoryAccess = 88 - cudaDevAttrConcurrentManagedAccess = 89 - cudaDevAttrComputePreemptionSupported = 90 - cudaDevAttrCanUseHostPointerForRegisteredMem = 91 - cudaDevAttrReserved92 = 92 - cudaDevAttrReserved93 = 93 - cudaDevAttrReserved94 = 94 - cudaDevAttrCooperativeLaunch = 95 - cudaDevAttrReserved96 = 96 - cudaDevAttrMaxSharedMemoryPerBlockOptin = 97 - cudaDevAttrCanFlushRemoteWrites = 98 - cudaDevAttrHostRegisterSupported = 99 - cudaDevAttrPageableMemoryAccessUsesHostPageTables = 100 - cudaDevAttrDirectManagedMemAccessFromHost = 101 - cudaDevAttrMaxBlocksPerMultiprocessor = 106 - cudaDevAttrMaxPersistingL2CacheSize = 108 - cudaDevAttrMaxAccessPolicyWindowSize = 109 - cudaDevAttrReservedSharedMemoryPerBlock = 111 - cudaDevAttrSparseCudaArraySupported = 112 - cudaDevAttrHostRegisterReadOnlySupported = 113 - cudaDevAttrTimelineSemaphoreInteropSupported = 114 - cudaDevAttrMemoryPoolsSupported = 115 - cudaDevAttrGPUDirectRDMASupported = 116 - cudaDevAttrGPUDirectRDMAFlushWritesOptions = 117 - cudaDevAttrGPUDirectRDMAWritesOrdering = 118 - cudaDevAttrMemoryPoolSupportedHandleTypes = 119 - cudaDevAttrClusterLaunch = 120 - cudaDevAttrDeferredMappingCudaArraySupported = 121 - cudaDevAttrReserved122 = 122 - cudaDevAttrReserved123 = 123 - cudaDevAttrReserved124 = 124 - cudaDevAttrIpcEventSupport = 125 - cudaDevAttrMemSyncDomainCount = 126 - cudaDevAttrReserved127 = 127 - cudaDevAttrReserved128 = 128 - cudaDevAttrReserved129 = 129 - cudaDevAttrNumaConfig = 130 - cudaDevAttrNumaId = 131 - cudaDevAttrReserved132 = 132 - cudaDevAttrMpsEnabled = 133 - cudaDevAttrHostNumaId = 134 - cudaDevAttrD3D12CigSupported = 135 - cudaDevAttrVulkanCigSupported = 138 - cudaDevAttrGpuPciDeviceId = 139 - cudaDevAttrGpuPciSubsystemId = 140 - cudaDevAttrReserved141 = 141 - cudaDevAttrHostNumaMemoryPoolsSupported = 142 - cudaDevAttrHostNumaMultinodeIpcSupported = 143 - cudaDevAttrHostMemoryPoolsSupported = 144 - cudaDevAttrReserved145 = 145 - cudaDevAttrOnlyPartialHostNativeAtomicSupported = 147 - cudaDevAttrAtomicReductionSupported = 148 - cudaDevAttrCigStreamsSupported = 151 - cudaDevAttrMax = 152 - - cdef enum cudaMemPoolAttr: - cudaMemPoolReuseFollowEventDependencies = 1 - cudaMemPoolReuseAllowOpportunistic = 2 - cudaMemPoolReuseAllowInternalDependencies = 3 - cudaMemPoolAttrReleaseThreshold = 4 - cudaMemPoolAttrReservedMemCurrent = 5 - cudaMemPoolAttrReservedMemHigh = 6 - cudaMemPoolAttrUsedMemCurrent = 7 - cudaMemPoolAttrUsedMemHigh = 8 - cudaMemPoolAttrAllocationType = 9 - cudaMemPoolAttrExportHandleTypes = 10 - cudaMemPoolAttrLocationId = 11 - cudaMemPoolAttrLocationType = 12 - cudaMemPoolAttrMaxPoolSize = 13 - cudaMemPoolAttrHwDecompressEnabled = 14 - - cdef enum cudaMemLocationType: - cudaMemLocationTypeInvalid = 0 - cudaMemLocationTypeNone = 0 - cudaMemLocationTypeDevice = 1 - cudaMemLocationTypeHost = 2 - cudaMemLocationTypeHostNuma = 3 - cudaMemLocationTypeHostNumaCurrent = 4 - cudaMemLocationTypeInvisible = 5 - - cdef enum cudaMemAccessFlags: - cudaMemAccessFlagsProtNone = 0 - cudaMemAccessFlagsProtRead = 1 - cudaMemAccessFlagsProtReadWrite = 3 - - cdef enum cudaMemAllocationType: - cudaMemAllocationTypeInvalid = 0 - cudaMemAllocationTypePinned = 1 - cudaMemAllocationTypeManaged = 2 - cudaMemAllocationTypeMax = 2147483647 - - cdef enum cudaMemAllocationHandleType: - cudaMemHandleTypeNone = 0 - cudaMemHandleTypePosixFileDescriptor = 1 - cudaMemHandleTypeWin32 = 2 - cudaMemHandleTypeWin32Kmt = 4 - cudaMemHandleTypeFabric = 8 - - cdef enum cudaGraphMemAttributeType: - cudaGraphMemAttrUsedMemCurrent = 0 - cudaGraphMemAttrUsedMemHigh = 1 - cudaGraphMemAttrReservedMemCurrent = 2 - cudaGraphMemAttrReservedMemHigh = 3 - - cdef enum cudaMemcpyFlags: - cudaMemcpyFlagDefault = 0 - cudaMemcpyFlagPreferOverlapWithCompute = 1 - - cdef enum cudaMemcpySrcAccessOrder: - cudaMemcpySrcAccessOrderInvalid = 0 - cudaMemcpySrcAccessOrderStream = 1 - cudaMemcpySrcAccessOrderDuringApiCall = 2 - cudaMemcpySrcAccessOrderAny = 3 - cudaMemcpySrcAccessOrderMax = 2147483647 - - cdef enum cudaMemcpy3DOperandType: - cudaMemcpyOperandTypePointer = 1 - cudaMemcpyOperandTypeArray = 2 - cudaMemcpyOperandTypeMax = 2147483647 - - cdef enum cudaDeviceP2PAttr: - cudaDevP2PAttrPerformanceRank = 1 - cudaDevP2PAttrAccessSupported = 2 - cudaDevP2PAttrNativeAtomicSupported = 3 - cudaDevP2PAttrCudaArrayAccessSupported = 4 - cudaDevP2PAttrOnlyPartialNativeAtomicSupported = 5 - - cdef enum cudaAtomicOperation: - cudaAtomicOperationIntegerAdd = 0 - cudaAtomicOperationIntegerMin = 1 - cudaAtomicOperationIntegerMax = 2 - cudaAtomicOperationIntegerIncrement = 3 - cudaAtomicOperationIntegerDecrement = 4 - cudaAtomicOperationAnd = 5 - cudaAtomicOperationOr = 6 - cudaAtomicOperationXOR = 7 - cudaAtomicOperationExchange = 8 - cudaAtomicOperationCAS = 9 - cudaAtomicOperationFloatAdd = 10 - cudaAtomicOperationFloatMin = 11 - cudaAtomicOperationFloatMax = 12 - - cdef enum cudaAtomicOperationCapability: - cudaAtomicCapabilitySigned = 1 - cudaAtomicCapabilityUnsigned = 2 - cudaAtomicCapabilityReduction = 4 - cudaAtomicCapabilityScalar32 = 8 - cudaAtomicCapabilityScalar64 = 16 - cudaAtomicCapabilityScalar128 = 32 - cudaAtomicCapabilityVector32x4 = 64 - - cdef enum cudaExternalMemoryHandleType: - cudaExternalMemoryHandleTypeOpaqueFd = 1 - cudaExternalMemoryHandleTypeOpaqueWin32 = 2 - cudaExternalMemoryHandleTypeOpaqueWin32Kmt = 3 - cudaExternalMemoryHandleTypeD3D12Heap = 4 - cudaExternalMemoryHandleTypeD3D12Resource = 5 - cudaExternalMemoryHandleTypeD3D11Resource = 6 - cudaExternalMemoryHandleTypeD3D11ResourceKmt = 7 - cudaExternalMemoryHandleTypeNvSciBuf = 8 - - cdef enum cudaExternalSemaphoreHandleType: - cudaExternalSemaphoreHandleTypeOpaqueFd = 1 - cudaExternalSemaphoreHandleTypeOpaqueWin32 = 2 - cudaExternalSemaphoreHandleTypeOpaqueWin32Kmt = 3 - cudaExternalSemaphoreHandleTypeD3D12Fence = 4 - cudaExternalSemaphoreHandleTypeD3D11Fence = 5 - cudaExternalSemaphoreHandleTypeNvSciSync = 6 - cudaExternalSemaphoreHandleTypeKeyedMutex = 7 - cudaExternalSemaphoreHandleTypeKeyedMutexKmt = 8 - cudaExternalSemaphoreHandleTypeTimelineSemaphoreFd = 9 - cudaExternalSemaphoreHandleTypeTimelineSemaphoreWin32 = 10 - - cdef enum cudaDevSmResourceGroup_flags: - cudaDevSmResourceGroupDefault = 0 - cudaDevSmResourceGroupBackfill = 1 - - cdef enum cudaDevSmResourceSplitByCount_flags: - cudaDevSmResourceSplitIgnoreSmCoscheduling = 1 - cudaDevSmResourceSplitMaxPotentialClusterSize = 2 - - cdef enum cudaDevResourceType: - cudaDevResourceTypeInvalid = 0 - cudaDevResourceTypeSm = 1 - cudaDevResourceTypeWorkqueueConfig = 1000 - cudaDevResourceTypeWorkqueue = 10000 - - cdef enum cudaDevWorkqueueConfigScope: - cudaDevWorkqueueConfigScopeDeviceCtx = 0 - cudaDevWorkqueueConfigScopeGreenCtxBalanced = 1 - - cdef enum cudaJitOption: - cudaJitMaxRegisters = 0 - cudaJitThreadsPerBlock = 1 - cudaJitWallTime = 2 - cudaJitInfoLogBuffer = 3 - cudaJitInfoLogBufferSizeBytes = 4 - cudaJitErrorLogBuffer = 5 - cudaJitErrorLogBufferSizeBytes = 6 - cudaJitOptimizationLevel = 7 - cudaJitFallbackStrategy = 10 - cudaJitGenerateDebugInfo = 11 - cudaJitLogVerbose = 12 - cudaJitGenerateLineInfo = 13 - cudaJitCacheMode = 14 - cudaJitPositionIndependentCode = 30 - cudaJitMinCtaPerSm = 31 - cudaJitMaxThreadsPerBlock = 32 - cudaJitOverrideDirectiveValues = 33 - - cdef enum cudaLibraryOption: - cudaLibraryHostUniversalFunctionAndDataTable = 0 - cudaLibraryBinaryIsPreserved = 1 - - cdef enum cudaJit_CacheMode: - cudaJitCacheOptionNone = 0 - cudaJitCacheOptionCG = 1 - cudaJitCacheOptionCA = 2 - - cdef enum cudaJit_Fallback: - cudaPreferPtx = 0 - cudaPreferBinary = 1 - - cdef enum cudaCGScope: - cudaCGScopeInvalid = 0 - cudaCGScopeGrid = 1 - cudaCGScopeReserved = 2 - - cdef enum cudaKernelFunctionType: - cudaKernelFunctionTypeUnspecified = 0 - cudaKernelFunctionTypeDeviceEntry = 1 - cudaKernelFunctionTypeKernel = 2 - cudaKernelFunctionTypeFunction = 3 - - cdef enum cudaGraphConditionalHandleFlags: - cudaGraphCondAssignDefault = 1 - - cdef enum cudaGraphConditionalNodeType: - cudaGraphCondTypeIf = 0 - cudaGraphCondTypeWhile = 1 - cudaGraphCondTypeSwitch = 2 - - cdef enum cudaGraphNodeType: - cudaGraphNodeTypeKernel = 0 - cudaGraphNodeTypeMemcpy = 1 - cudaGraphNodeTypeMemset = 2 - cudaGraphNodeTypeHost = 3 - cudaGraphNodeTypeGraph = 4 - cudaGraphNodeTypeEmpty = 5 - cudaGraphNodeTypeWaitEvent = 6 - cudaGraphNodeTypeEventRecord = 7 - cudaGraphNodeTypeExtSemaphoreSignal = 8 - cudaGraphNodeTypeExtSemaphoreWait = 9 - cudaGraphNodeTypeMemAlloc = 10 - cudaGraphNodeTypeMemFree = 11 - cudaGraphNodeTypeConditional = 13 - cudaGraphNodeTypeReserved16 = 16 - cudaGraphNodeTypeCount = 17 - - cdef enum cudaGraphChildGraphNodeOwnership: - cudaGraphChildGraphOwnershipInvalid = -1 - cudaGraphChildGraphOwnershipClone = 0 - cudaGraphChildGraphOwnershipMove = 1 - - cdef enum cudaGraphExecUpdateResult: - cudaGraphExecUpdateSuccess = 0 - cudaGraphExecUpdateError = 1 - cudaGraphExecUpdateErrorTopologyChanged = 2 - cudaGraphExecUpdateErrorNodeTypeChanged = 3 - cudaGraphExecUpdateErrorFunctionChanged = 4 - cudaGraphExecUpdateErrorParametersChanged = 5 - cudaGraphExecUpdateErrorNotSupported = 6 - cudaGraphExecUpdateErrorUnsupportedFunctionChange = 7 - cudaGraphExecUpdateErrorAttributesChanged = 8 - - cdef enum cudaGraphKernelNodeField: - cudaGraphKernelNodeFieldInvalid = 0 - cudaGraphKernelNodeFieldGridDim = 1 - cudaGraphKernelNodeFieldParam = 2 - cudaGraphKernelNodeFieldEnabled = 3 - - cdef enum cudaGetDriverEntryPointFlags: - cudaEnableDefault = 0 - cudaEnableLegacyStream = 1 - cudaEnablePerThreadDefaultStream = 2 - - cdef enum cudaDriverEntryPointQueryResult: - cudaDriverEntryPointSuccess = 0 - cudaDriverEntryPointSymbolNotFound = 1 - cudaDriverEntryPointVersionNotSufficent = 2 - - cdef enum cudaGraphDebugDotFlags: - cudaGraphDebugDotFlagsVerbose = 1 - cudaGraphDebugDotFlagsKernelNodeParams = 4 - cudaGraphDebugDotFlagsMemcpyNodeParams = 8 - cudaGraphDebugDotFlagsMemsetNodeParams = 16 - cudaGraphDebugDotFlagsHostNodeParams = 32 - cudaGraphDebugDotFlagsEventNodeParams = 64 - cudaGraphDebugDotFlagsExtSemasSignalNodeParams = 128 - cudaGraphDebugDotFlagsExtSemasWaitNodeParams = 256 - cudaGraphDebugDotFlagsKernelNodeAttributes = 512 - cudaGraphDebugDotFlagsHandles = 1024 - cudaGraphDebugDotFlagsConditionalNodeParams = 32768 - - cdef enum cudaGraphInstantiateFlags: - cudaGraphInstantiateFlagAutoFreeOnLaunch = 1 - cudaGraphInstantiateFlagUpload = 2 - cudaGraphInstantiateFlagDeviceLaunch = 4 - cudaGraphInstantiateFlagUseNodePriority = 8 - - cdef enum cudaDeviceNumaConfig: - cudaDeviceNumaConfigNone = 0 - cudaDeviceNumaConfigNumaNode = 1 - - cdef enum cudaFabricOpStatusSource: - cudaFabricOpStatusSourceMbarrierV1 = 0 - cudaFabricOpStatusSourceMax = 2147483647 - - cdef enum cudaFabricOpStatusInfo: - cudaFabricOpStatusInfoSuccess = 0 - cudaFabricOpStatusInfoLast = 0 - cudaFabricOpStatusInfoMax = 2147483647 - -cdef extern from "surface_types.h": - - ctypedef unsigned long long cudaSurfaceObject_t - - cdef enum cudaSurfaceBoundaryMode: - cudaBoundaryModeZero = 0 - cudaBoundaryModeClamp = 1 - cudaBoundaryModeTrap = 2 - - cdef enum cudaSurfaceFormatMode: - cudaFormatModeForced = 0 - cudaFormatModeAuto = 1 - -cdef extern from "texture_types.h": - - cdef struct cudaTextureDesc: - cudaTextureAddressMode addressMode[3] - cudaTextureFilterMode filterMode - cudaTextureReadMode readMode - int sRGB - float borderColor[4] - int normalizedCoords - unsigned int maxAnisotropy - cudaTextureFilterMode mipmapFilterMode - float mipmapLevelBias - float minMipmapLevelClamp - float maxMipmapLevelClamp - int disableTrilinearOptimization - int seamlessCubemap - - ctypedef unsigned long long cudaTextureObject_t - - cdef enum cudaTextureAddressMode: - cudaAddressModeWrap = 0 - cudaAddressModeClamp = 1 - cudaAddressModeMirror = 2 - cudaAddressModeBorder = 3 - - cdef enum cudaTextureFilterMode: - cudaFilterModePoint = 0 - cudaFilterModeLinear = 1 - - cdef enum cudaTextureReadMode: - cudaReadModeElementType = 0 - cudaReadModeNormalizedFloat = 1 - -cdef extern from "library_types.h": - - cdef enum cudaDataType_t: - CUDA_R_32F = 0 - CUDA_R_64F = 1 - CUDA_R_16F = 2 - CUDA_R_8I = 3 - CUDA_C_32F = 4 - CUDA_C_64F = 5 - CUDA_C_16F = 6 - CUDA_C_8I = 7 - CUDA_R_8U = 8 - CUDA_C_8U = 9 - CUDA_R_32I = 10 - CUDA_C_32I = 11 - CUDA_R_32U = 12 - CUDA_C_32U = 13 - CUDA_R_16BF = 14 - CUDA_C_16BF = 15 - CUDA_R_4I = 16 - CUDA_C_4I = 17 - CUDA_R_4U = 18 - CUDA_C_4U = 19 - CUDA_R_16I = 20 - CUDA_C_16I = 21 - CUDA_R_16U = 22 - CUDA_C_16U = 23 - CUDA_R_64I = 24 - CUDA_C_64I = 25 - CUDA_R_64U = 26 - CUDA_C_64U = 27 - CUDA_R_8F_E4M3 = 28 - CUDA_R_8F_UE4M3 = 28 - CUDA_R_8F_E5M2 = 29 - CUDA_R_8F_UE8M0 = 30 - CUDA_R_6F_E2M3 = 31 - CUDA_R_6F_E3M2 = 32 - CUDA_R_4F_E2M1 = 33 - - ctypedef cudaDataType_t cudaDataType - - cdef enum cudaEmulationStrategy_t: - CUDA_EMULATION_STRATEGY_DEFAULT = 0 - CUDA_EMULATION_STRATEGY_PERFORMANT = 1 - CUDA_EMULATION_STRATEGY_EAGER = 2 - - ctypedef cudaEmulationStrategy_t cudaEmulationStrategy - - cdef enum cudaEmulationMantissaControl_t: - CUDA_EMULATION_MANTISSA_CONTROL_DYNAMIC = 0 - CUDA_EMULATION_MANTISSA_CONTROL_FIXED = 1 - - ctypedef cudaEmulationMantissaControl_t cudaEmulationMantissaControl - - cdef enum cudaEmulationSpecialValuesSupport_t: - CUDA_EMULATION_SPECIAL_VALUES_SUPPORT_NONE = 0 - CUDA_EMULATION_SPECIAL_VALUES_SUPPORT_INFINITY = 1 - CUDA_EMULATION_SPECIAL_VALUES_SUPPORT_NAN = 2 - CUDA_EMULATION_SPECIAL_VALUES_SUPPORT_DEFAULT = 65535 - - ctypedef cudaEmulationSpecialValuesSupport_t cudaEmulationSpecialValuesSupport - - cdef enum libraryPropertyType_t: - MAJOR_VERSION = 0 - MINOR_VERSION = 1 - PATCH_LEVEL = 2 - - ctypedef libraryPropertyType_t libraryPropertyType - -cdef extern from "cuda_runtime_api.h": - - ctypedef void (*cudaStreamCallback_t)(cudaStream_t stream, cudaError_t status, void* userData) - - ctypedef cudaError_t (*cudaGraphRecaptureCallback_t)(void* data, cudaGraphNode_t node, const cudaGraphNodeParams* originalParams, const cudaGraphNodeParams* recaptureParams, cudaGraphRecaptureStatus status) - - cdef struct cudaGraphRecaptureCallbackData: - cudaGraphRecaptureCallback_t callbackFunc - void* userData - - ctypedef void (*cudaLogsCallback_t)(void* data, cudaLogLevel logLevel, char* message, size_t length) - -cdef extern from "device_types.h": - - cdef enum cudaRoundMode: - cudaRoundNearest = 0 - cudaRoundZero = 1 - cudaRoundPosInf = 2 - cudaRoundMinInf = 3 - -ctypedef cudaLaunchAttributeID cudaStreamAttrID - -ctypedef cudaLaunchAttributeID cudaKernelNodeAttrID - -ctypedef cudaLaunchAttributeValue cudaStreamAttrValue - -ctypedef cudaLaunchAttributeValue cudaKernelNodeAttrValue diff --git a/cuda_bindings/cuda/bindings/runtime.pxd.in b/cuda_bindings/cuda/bindings/runtime.pxd similarity index 63% rename from cuda_bindings/cuda/bindings/runtime.pxd.in rename to cuda_bindings/cuda/bindings/runtime.pxd index 7881587683b..7cb680d1743 100644 --- a/cuda_bindings/cuda/bindings/runtime.pxd.in +++ b/cuda_bindings/cuda/bindings/runtime.pxd @@ -2,14 +2,12 @@ # SPDX-License-Identifier: Apache-2.0 # This code was automatically generated with version 13.3.0. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=532f673750b6344c789f7947449c1d99e3587792ba3b110e9dcc36396decbb67 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=0f2431380680008795336b7acb5ccd83dba7a6e05d0c81c2b5f825bc95576ccd cimport cuda.bindings.cyruntime as cyruntime include "_lib/utils.pxd" cimport cuda.bindings.driver as driver -{{if 'cudaDevResourceDesc_t' in found_types}} - cdef class cudaDevResourceDesc_t: """ @@ -23,9 +21,6 @@ cdef class cudaDevResourceDesc_t: """ cdef cyruntime.cudaDevResourceDesc_t _pvt_val cdef cyruntime.cudaDevResourceDesc_t* _pvt_ptr -{{endif}} - -{{if 'cudaExecutionContext_t' in found_types}} cdef class cudaExecutionContext_t: """ @@ -40,9 +35,6 @@ cdef class cudaExecutionContext_t: """ cdef cyruntime.cudaExecutionContext_t _pvt_val cdef cyruntime.cudaExecutionContext_t* _pvt_ptr -{{endif}} - -{{if 'cudaArray_t' in found_types}} cdef class cudaArray_t: """ @@ -57,9 +49,6 @@ cdef class cudaArray_t: """ cdef cyruntime.cudaArray_t _pvt_val cdef cyruntime.cudaArray_t* _pvt_ptr -{{endif}} - -{{if 'cudaArray_const_t' in found_types}} cdef class cudaArray_const_t: """ @@ -74,9 +63,6 @@ cdef class cudaArray_const_t: """ cdef cyruntime.cudaArray_const_t _pvt_val cdef cyruntime.cudaArray_const_t* _pvt_ptr -{{endif}} - -{{if 'cudaMipmappedArray_t' in found_types}} cdef class cudaMipmappedArray_t: """ @@ -91,9 +77,6 @@ cdef class cudaMipmappedArray_t: """ cdef cyruntime.cudaMipmappedArray_t _pvt_val cdef cyruntime.cudaMipmappedArray_t* _pvt_ptr -{{endif}} - -{{if 'cudaMipmappedArray_const_t' in found_types}} cdef class cudaMipmappedArray_const_t: """ @@ -108,9 +91,6 @@ cdef class cudaMipmappedArray_const_t: """ cdef cyruntime.cudaMipmappedArray_const_t _pvt_val cdef cyruntime.cudaMipmappedArray_const_t* _pvt_ptr -{{endif}} - -{{if 'cudaGraphicsResource_t' in found_types}} cdef class cudaGraphicsResource_t: """ @@ -125,9 +105,6 @@ cdef class cudaGraphicsResource_t: """ cdef cyruntime.cudaGraphicsResource_t _pvt_val cdef cyruntime.cudaGraphicsResource_t* _pvt_ptr -{{endif}} - -{{if 'cudaExternalMemory_t' in found_types}} cdef class cudaExternalMemory_t: """ @@ -142,9 +119,6 @@ cdef class cudaExternalMemory_t: """ cdef cyruntime.cudaExternalMemory_t _pvt_val cdef cyruntime.cudaExternalMemory_t* _pvt_ptr -{{endif}} - -{{if 'cudaExternalSemaphore_t' in found_types}} cdef class cudaExternalSemaphore_t: """ @@ -159,9 +133,6 @@ cdef class cudaExternalSemaphore_t: """ cdef cyruntime.cudaExternalSemaphore_t _pvt_val cdef cyruntime.cudaExternalSemaphore_t* _pvt_ptr -{{endif}} - -{{if 'cudaKernel_t' in found_types}} cdef class cudaKernel_t: """ @@ -176,9 +147,6 @@ cdef class cudaKernel_t: """ cdef cyruntime.cudaKernel_t _pvt_val cdef cyruntime.cudaKernel_t* _pvt_ptr -{{endif}} - -{{if 'cudaLibrary_t' in found_types}} cdef class cudaLibrary_t: """ @@ -193,9 +161,6 @@ cdef class cudaLibrary_t: """ cdef cyruntime.cudaLibrary_t _pvt_val cdef cyruntime.cudaLibrary_t* _pvt_ptr -{{endif}} - -{{if 'cudaGraphDeviceNode_t' in found_types}} cdef class cudaGraphDeviceNode_t: """ @@ -210,9 +175,6 @@ cdef class cudaGraphDeviceNode_t: """ cdef cyruntime.cudaGraphDeviceNode_t _pvt_val cdef cyruntime.cudaGraphDeviceNode_t* _pvt_ptr -{{endif}} - -{{if 'cudaAsyncCallbackHandle_t' in found_types}} cdef class cudaAsyncCallbackHandle_t: """ @@ -227,9 +189,6 @@ cdef class cudaAsyncCallbackHandle_t: """ cdef cyruntime.cudaAsyncCallbackHandle_t _pvt_val cdef cyruntime.cudaAsyncCallbackHandle_t* _pvt_ptr -{{endif}} - -{{if 'cudaLogsCallbackHandle' in found_types}} cdef class cudaLogsCallbackHandle: """ @@ -242,9 +201,6 @@ cdef class cudaLogsCallbackHandle: """ cdef cyruntime.cudaLogsCallbackHandle _pvt_val cdef cyruntime.cudaLogsCallbackHandle* _pvt_ptr -{{endif}} - -{{if True}} cdef class EGLImageKHR: """ @@ -257,9 +213,6 @@ cdef class EGLImageKHR: """ cdef cyruntime.EGLImageKHR _pvt_val cdef cyruntime.EGLImageKHR* _pvt_ptr -{{endif}} - -{{if True}} cdef class EGLStreamKHR: """ @@ -272,9 +225,6 @@ cdef class EGLStreamKHR: """ cdef cyruntime.EGLStreamKHR _pvt_val cdef cyruntime.EGLStreamKHR* _pvt_ptr -{{endif}} - -{{if True}} cdef class EGLSyncKHR: """ @@ -287,9 +237,6 @@ cdef class EGLSyncKHR: """ cdef cyruntime.EGLSyncKHR _pvt_val cdef cyruntime.EGLSyncKHR* _pvt_ptr -{{endif}} - -{{if 'cudaHostFn_t' in found_types}} cdef class cudaHostFn_t: """ @@ -302,9 +249,6 @@ cdef class cudaHostFn_t: """ cdef cyruntime.cudaHostFn_t _pvt_val cdef cyruntime.cudaHostFn_t* _pvt_ptr -{{endif}} - -{{if 'cudaAsyncCallback' in found_types}} cdef class cudaAsyncCallback: """ @@ -317,9 +261,6 @@ cdef class cudaAsyncCallback: """ cdef cyruntime.cudaAsyncCallback _pvt_val cdef cyruntime.cudaAsyncCallback* _pvt_ptr -{{endif}} - -{{if 'cudaStreamCallback_t' in found_types}} cdef class cudaStreamCallback_t: """ @@ -332,9 +273,6 @@ cdef class cudaStreamCallback_t: """ cdef cyruntime.cudaStreamCallback_t _pvt_val cdef cyruntime.cudaStreamCallback_t* _pvt_ptr -{{endif}} - -{{if 'cudaGraphRecaptureCallback_t' in found_types}} cdef class cudaGraphRecaptureCallback_t: """ @@ -347,9 +285,6 @@ cdef class cudaGraphRecaptureCallback_t: """ cdef cyruntime.cudaGraphRecaptureCallback_t _pvt_val cdef cyruntime.cudaGraphRecaptureCallback_t* _pvt_ptr -{{endif}} - -{{if 'cudaLogsCallback_t' in found_types}} cdef class cudaLogsCallback_t: """ @@ -362,26 +297,23 @@ cdef class cudaLogsCallback_t: """ cdef cyruntime.cudaLogsCallback_t _pvt_val cdef cyruntime.cudaLogsCallback_t* _pvt_ptr -{{endif}} - -{{if 'dim3' in found_struct}} cdef class dim3: """ Attributes ---------- - {{if 'dim3.x' in found_struct}} + x : unsigned int - {{endif}} - {{if 'dim3.y' in found_struct}} + + y : unsigned int - {{endif}} - {{if 'dim3.z' in found_struct}} + + z : unsigned int - {{endif}} + Methods ------- @@ -390,8 +322,6 @@ cdef class dim3: """ cdef cyruntime.dim3 _pvt_val cdef cyruntime.dim3* _pvt_ptr -{{endif}} -{{if 'cudaChannelFormatDesc' in found_struct}} cdef class cudaChannelFormatDesc: """ @@ -399,26 +329,26 @@ cdef class cudaChannelFormatDesc: Attributes ---------- - {{if 'cudaChannelFormatDesc.x' in found_struct}} + x : int x - {{endif}} - {{if 'cudaChannelFormatDesc.y' in found_struct}} + + y : int y - {{endif}} - {{if 'cudaChannelFormatDesc.z' in found_struct}} + + z : int z - {{endif}} - {{if 'cudaChannelFormatDesc.w' in found_struct}} + + w : int w - {{endif}} - {{if 'cudaChannelFormatDesc.f' in found_struct}} + + f : cudaChannelFormatKind Channel format kind - {{endif}} + Methods ------- @@ -427,25 +357,23 @@ cdef class cudaChannelFormatDesc: """ cdef cyruntime.cudaChannelFormatDesc _pvt_val cdef cyruntime.cudaChannelFormatDesc* _pvt_ptr -{{endif}} -{{if 'cudaArraySparseProperties.tileExtent' in found_struct}} cdef class anon_struct0: """ Attributes ---------- - {{if 'cudaArraySparseProperties.tileExtent.width' in found_struct}} + width : unsigned int - {{endif}} - {{if 'cudaArraySparseProperties.tileExtent.height' in found_struct}} + + height : unsigned int - {{endif}} - {{if 'cudaArraySparseProperties.tileExtent.depth' in found_struct}} + + depth : unsigned int - {{endif}} + Methods ------- @@ -453,8 +381,6 @@ cdef class anon_struct0: Get memory address of class instance """ cdef cyruntime.cudaArraySparseProperties* _pvt_ptr -{{endif}} -{{if 'cudaArraySparseProperties' in found_struct}} cdef class cudaArraySparseProperties: """ @@ -462,26 +388,26 @@ cdef class cudaArraySparseProperties: Attributes ---------- - {{if 'cudaArraySparseProperties.tileExtent' in found_struct}} + tileExtent : anon_struct0 - {{endif}} - {{if 'cudaArraySparseProperties.miptailFirstLevel' in found_struct}} + + miptailFirstLevel : unsigned int First mip level at which the mip tail begins - {{endif}} - {{if 'cudaArraySparseProperties.miptailSize' in found_struct}} + + miptailSize : unsigned long long Total size of the mip tail. - {{endif}} - {{if 'cudaArraySparseProperties.flags' in found_struct}} + + flags : unsigned int Flags will either be zero or cudaArraySparsePropertiesSingleMipTail - {{endif}} - {{if 'cudaArraySparseProperties.reserved' in found_struct}} + + reserved : list[unsigned int] - {{endif}} + Methods ------- @@ -490,11 +416,9 @@ cdef class cudaArraySparseProperties: """ cdef cyruntime.cudaArraySparseProperties _pvt_val cdef cyruntime.cudaArraySparseProperties* _pvt_ptr - {{if 'cudaArraySparseProperties.tileExtent' in found_struct}} + cdef anon_struct0 _tileExtent - {{endif}} -{{endif}} -{{if 'cudaArrayMemoryRequirements' in found_struct}} + cdef class cudaArrayMemoryRequirements: """ @@ -502,18 +426,18 @@ cdef class cudaArrayMemoryRequirements: Attributes ---------- - {{if 'cudaArrayMemoryRequirements.size' in found_struct}} + size : size_t Total size of the array. - {{endif}} - {{if 'cudaArrayMemoryRequirements.alignment' in found_struct}} + + alignment : size_t Alignment necessary for mapping the array. - {{endif}} - {{if 'cudaArrayMemoryRequirements.reserved' in found_struct}} + + reserved : list[unsigned int] - {{endif}} + Methods ------- @@ -522,8 +446,6 @@ cdef class cudaArrayMemoryRequirements: """ cdef cyruntime.cudaArrayMemoryRequirements _pvt_val cdef cyruntime.cudaArrayMemoryRequirements* _pvt_ptr -{{endif}} -{{if 'cudaPitchedPtr' in found_struct}} cdef class cudaPitchedPtr: """ @@ -531,22 +453,22 @@ cdef class cudaPitchedPtr: Attributes ---------- - {{if 'cudaPitchedPtr.ptr' in found_struct}} + ptr : Any Pointer to allocated memory - {{endif}} - {{if 'cudaPitchedPtr.pitch' in found_struct}} + + pitch : size_t Pitch of allocated memory in bytes - {{endif}} - {{if 'cudaPitchedPtr.xsize' in found_struct}} + + xsize : size_t Logical width of allocation in elements - {{endif}} - {{if 'cudaPitchedPtr.ysize' in found_struct}} + + ysize : size_t Logical height of allocation in elements - {{endif}} + Methods ------- @@ -555,11 +477,9 @@ cdef class cudaPitchedPtr: """ cdef cyruntime.cudaPitchedPtr _pvt_val cdef cyruntime.cudaPitchedPtr* _pvt_ptr - {{if 'cudaPitchedPtr.ptr' in found_struct}} + cdef _HelperInputVoidPtr _cyptr - {{endif}} -{{endif}} -{{if 'cudaExtent' in found_struct}} + cdef class cudaExtent: """ @@ -567,19 +487,19 @@ cdef class cudaExtent: Attributes ---------- - {{if 'cudaExtent.width' in found_struct}} + width : size_t Width in elements when referring to array memory, in bytes when referring to linear memory - {{endif}} - {{if 'cudaExtent.height' in found_struct}} + + height : size_t Height in elements - {{endif}} - {{if 'cudaExtent.depth' in found_struct}} + + depth : size_t Depth in elements - {{endif}} + Methods ------- @@ -588,8 +508,6 @@ cdef class cudaExtent: """ cdef cyruntime.cudaExtent _pvt_val cdef cyruntime.cudaExtent* _pvt_ptr -{{endif}} -{{if 'cudaPos' in found_struct}} cdef class cudaPos: """ @@ -597,18 +515,18 @@ cdef class cudaPos: Attributes ---------- - {{if 'cudaPos.x' in found_struct}} + x : size_t x - {{endif}} - {{if 'cudaPos.y' in found_struct}} + + y : size_t y - {{endif}} - {{if 'cudaPos.z' in found_struct}} + + z : size_t z - {{endif}} + Methods ------- @@ -617,8 +535,6 @@ cdef class cudaPos: """ cdef cyruntime.cudaPos _pvt_val cdef cyruntime.cudaPos* _pvt_ptr -{{endif}} -{{if 'cudaMemcpy3DParms' in found_struct}} cdef class cudaMemcpy3DParms: """ @@ -626,38 +542,38 @@ cdef class cudaMemcpy3DParms: Attributes ---------- - {{if 'cudaMemcpy3DParms.srcArray' in found_struct}} + srcArray : cudaArray_t Source memory address - {{endif}} - {{if 'cudaMemcpy3DParms.srcPos' in found_struct}} + + srcPos : cudaPos Source position offset - {{endif}} - {{if 'cudaMemcpy3DParms.srcPtr' in found_struct}} + + srcPtr : cudaPitchedPtr Pitched source memory address - {{endif}} - {{if 'cudaMemcpy3DParms.dstArray' in found_struct}} + + dstArray : cudaArray_t Destination memory address - {{endif}} - {{if 'cudaMemcpy3DParms.dstPos' in found_struct}} + + dstPos : cudaPos Destination position offset - {{endif}} - {{if 'cudaMemcpy3DParms.dstPtr' in found_struct}} + + dstPtr : cudaPitchedPtr Pitched destination memory address - {{endif}} - {{if 'cudaMemcpy3DParms.extent' in found_struct}} + + extent : cudaExtent Requested memory copy size - {{endif}} - {{if 'cudaMemcpy3DParms.kind' in found_struct}} + + kind : cudaMemcpyKind Type of transfer - {{endif}} + Methods ------- @@ -666,29 +582,27 @@ cdef class cudaMemcpy3DParms: """ cdef cyruntime.cudaMemcpy3DParms _pvt_val cdef cyruntime.cudaMemcpy3DParms* _pvt_ptr - {{if 'cudaMemcpy3DParms.srcArray' in found_struct}} + cdef cudaArray_t _srcArray - {{endif}} - {{if 'cudaMemcpy3DParms.srcPos' in found_struct}} + + cdef cudaPos _srcPos - {{endif}} - {{if 'cudaMemcpy3DParms.srcPtr' in found_struct}} + + cdef cudaPitchedPtr _srcPtr - {{endif}} - {{if 'cudaMemcpy3DParms.dstArray' in found_struct}} + + cdef cudaArray_t _dstArray - {{endif}} - {{if 'cudaMemcpy3DParms.dstPos' in found_struct}} + + cdef cudaPos _dstPos - {{endif}} - {{if 'cudaMemcpy3DParms.dstPtr' in found_struct}} + + cdef cudaPitchedPtr _dstPtr - {{endif}} - {{if 'cudaMemcpy3DParms.extent' in found_struct}} + + cdef cudaExtent _extent - {{endif}} -{{endif}} -{{if 'cudaMemcpyNodeParams' in found_struct}} + cdef class cudaMemcpyNodeParams: """ @@ -696,23 +610,23 @@ cdef class cudaMemcpyNodeParams: Attributes ---------- - {{if 'cudaMemcpyNodeParams.flags' in found_struct}} + flags : int Must be zero - {{endif}} - {{if 'cudaMemcpyNodeParams.reserved' in found_struct}} + + reserved : int Must be zero - {{endif}} - {{if 'cudaMemcpyNodeParams.ctx' in found_struct}} + + ctx : cudaExecutionContext_t Context in which to run the memcpy. If NULL will try to use the current context. - {{endif}} - {{if 'cudaMemcpyNodeParams.copyParams' in found_struct}} + + copyParams : cudaMemcpy3DParms Parameters for the memory copy - {{endif}} + Methods ------- @@ -721,14 +635,12 @@ cdef class cudaMemcpyNodeParams: """ cdef cyruntime.cudaMemcpyNodeParams _pvt_val cdef cyruntime.cudaMemcpyNodeParams* _pvt_ptr - {{if 'cudaMemcpyNodeParams.ctx' in found_struct}} + cdef cudaExecutionContext_t _ctx - {{endif}} - {{if 'cudaMemcpyNodeParams.copyParams' in found_struct}} + + cdef cudaMemcpy3DParms _copyParams - {{endif}} -{{endif}} -{{if 'cudaMemcpy3DPeerParms' in found_struct}} + cdef class cudaMemcpy3DPeerParms: """ @@ -736,42 +648,42 @@ cdef class cudaMemcpy3DPeerParms: Attributes ---------- - {{if 'cudaMemcpy3DPeerParms.srcArray' in found_struct}} + srcArray : cudaArray_t Source memory address - {{endif}} - {{if 'cudaMemcpy3DPeerParms.srcPos' in found_struct}} + + srcPos : cudaPos Source position offset - {{endif}} - {{if 'cudaMemcpy3DPeerParms.srcPtr' in found_struct}} + + srcPtr : cudaPitchedPtr Pitched source memory address - {{endif}} - {{if 'cudaMemcpy3DPeerParms.srcDevice' in found_struct}} + + srcDevice : int Source device - {{endif}} - {{if 'cudaMemcpy3DPeerParms.dstArray' in found_struct}} + + dstArray : cudaArray_t Destination memory address - {{endif}} - {{if 'cudaMemcpy3DPeerParms.dstPos' in found_struct}} + + dstPos : cudaPos Destination position offset - {{endif}} - {{if 'cudaMemcpy3DPeerParms.dstPtr' in found_struct}} + + dstPtr : cudaPitchedPtr Pitched destination memory address - {{endif}} - {{if 'cudaMemcpy3DPeerParms.dstDevice' in found_struct}} + + dstDevice : int Destination device - {{endif}} - {{if 'cudaMemcpy3DPeerParms.extent' in found_struct}} + + extent : cudaExtent Requested memory copy size - {{endif}} + Methods ------- @@ -780,29 +692,27 @@ cdef class cudaMemcpy3DPeerParms: """ cdef cyruntime.cudaMemcpy3DPeerParms _pvt_val cdef cyruntime.cudaMemcpy3DPeerParms* _pvt_ptr - {{if 'cudaMemcpy3DPeerParms.srcArray' in found_struct}} + cdef cudaArray_t _srcArray - {{endif}} - {{if 'cudaMemcpy3DPeerParms.srcPos' in found_struct}} + + cdef cudaPos _srcPos - {{endif}} - {{if 'cudaMemcpy3DPeerParms.srcPtr' in found_struct}} + + cdef cudaPitchedPtr _srcPtr - {{endif}} - {{if 'cudaMemcpy3DPeerParms.dstArray' in found_struct}} + + cdef cudaArray_t _dstArray - {{endif}} - {{if 'cudaMemcpy3DPeerParms.dstPos' in found_struct}} + + cdef cudaPos _dstPos - {{endif}} - {{if 'cudaMemcpy3DPeerParms.dstPtr' in found_struct}} + + cdef cudaPitchedPtr _dstPtr - {{endif}} - {{if 'cudaMemcpy3DPeerParms.extent' in found_struct}} + + cdef cudaExtent _extent - {{endif}} -{{endif}} -{{if 'cudaMemsetParams' in found_struct}} + cdef class cudaMemsetParams: """ @@ -810,30 +720,30 @@ cdef class cudaMemsetParams: Attributes ---------- - {{if 'cudaMemsetParams.dst' in found_struct}} + dst : Any Destination device pointer - {{endif}} - {{if 'cudaMemsetParams.pitch' in found_struct}} + + pitch : size_t Pitch of destination device pointer. Unused if height is 1 - {{endif}} - {{if 'cudaMemsetParams.value' in found_struct}} + + value : unsigned int Value to be set - {{endif}} - {{if 'cudaMemsetParams.elementSize' in found_struct}} + + elementSize : unsigned int Size of each element in bytes. Must be 1, 2, or 4. - {{endif}} - {{if 'cudaMemsetParams.width' in found_struct}} + + width : size_t Width of the row in elements - {{endif}} - {{if 'cudaMemsetParams.height' in found_struct}} + + height : size_t Number of rows - {{endif}} + Methods ------- @@ -842,11 +752,9 @@ cdef class cudaMemsetParams: """ cdef cyruntime.cudaMemsetParams _pvt_val cdef cyruntime.cudaMemsetParams* _pvt_ptr - {{if 'cudaMemsetParams.dst' in found_struct}} + cdef _HelperInputVoidPtr _cydst - {{endif}} -{{endif}} -{{if 'cudaMemsetParamsV2' in found_struct}} + cdef class cudaMemsetParamsV2: """ @@ -854,35 +762,35 @@ cdef class cudaMemsetParamsV2: Attributes ---------- - {{if 'cudaMemsetParamsV2.dst' in found_struct}} + dst : Any Destination device pointer - {{endif}} - {{if 'cudaMemsetParamsV2.pitch' in found_struct}} + + pitch : size_t Pitch of destination device pointer. Unused if height is 1 - {{endif}} - {{if 'cudaMemsetParamsV2.value' in found_struct}} + + value : unsigned int Value to be set - {{endif}} - {{if 'cudaMemsetParamsV2.elementSize' in found_struct}} + + elementSize : unsigned int Size of each element in bytes. Must be 1, 2, or 4. - {{endif}} - {{if 'cudaMemsetParamsV2.width' in found_struct}} + + width : size_t Width of the row in elements - {{endif}} - {{if 'cudaMemsetParamsV2.height' in found_struct}} + + height : size_t Number of rows - {{endif}} - {{if 'cudaMemsetParamsV2.ctx' in found_struct}} + + ctx : cudaExecutionContext_t Context in which to run the memset. If NULL will try to use the current context. - {{endif}} + Methods ------- @@ -891,14 +799,12 @@ cdef class cudaMemsetParamsV2: """ cdef cyruntime.cudaMemsetParamsV2 _pvt_val cdef cyruntime.cudaMemsetParamsV2* _pvt_ptr - {{if 'cudaMemsetParamsV2.dst' in found_struct}} + cdef _HelperInputVoidPtr _cydst - {{endif}} - {{if 'cudaMemsetParamsV2.ctx' in found_struct}} + + cdef cudaExecutionContext_t _ctx - {{endif}} -{{endif}} -{{if 'cudaAccessPolicyWindow' in found_struct}} + cdef class cudaAccessPolicyWindow: """ @@ -913,30 +819,30 @@ cdef class cudaAccessPolicyWindow: Attributes ---------- - {{if 'cudaAccessPolicyWindow.base_ptr' in found_struct}} + base_ptr : Any Starting address of the access policy window. CUDA driver may align it. - {{endif}} - {{if 'cudaAccessPolicyWindow.num_bytes' in found_struct}} + + num_bytes : size_t Size in bytes of the window policy. CUDA driver may restrict the maximum size and alignment. - {{endif}} - {{if 'cudaAccessPolicyWindow.hitRatio' in found_struct}} + + hitRatio : float hitRatio specifies percentage of lines assigned hitProp, rest are assigned missProp. - {{endif}} - {{if 'cudaAccessPolicyWindow.hitProp' in found_struct}} + + hitProp : cudaAccessProperty ::CUaccessProperty set for hit. - {{endif}} - {{if 'cudaAccessPolicyWindow.missProp' in found_struct}} + + missProp : cudaAccessProperty ::CUaccessProperty set for miss. Must be either NORMAL or STREAMING. - {{endif}} + Methods ------- @@ -945,11 +851,9 @@ cdef class cudaAccessPolicyWindow: """ cdef cyruntime.cudaAccessPolicyWindow _pvt_val cdef cyruntime.cudaAccessPolicyWindow* _pvt_ptr - {{if 'cudaAccessPolicyWindow.base_ptr' in found_struct}} + cdef _HelperInputVoidPtr _cybase_ptr - {{endif}} -{{endif}} -{{if 'cudaHostNodeParams' in found_struct}} + cdef class cudaHostNodeParams: """ @@ -957,14 +861,14 @@ cdef class cudaHostNodeParams: Attributes ---------- - {{if 'cudaHostNodeParams.fn' in found_struct}} + fn : cudaHostFn_t The function to call when the node executes - {{endif}} - {{if 'cudaHostNodeParams.userData' in found_struct}} + + userData : Any Argument to pass to the function - {{endif}} + Methods ------- @@ -973,14 +877,12 @@ cdef class cudaHostNodeParams: """ cdef cyruntime.cudaHostNodeParams _pvt_val cdef cyruntime.cudaHostNodeParams* _pvt_ptr - {{if 'cudaHostNodeParams.fn' in found_struct}} + cdef cudaHostFn_t _fn - {{endif}} - {{if 'cudaHostNodeParams.userData' in found_struct}} + + cdef _HelperInputVoidPtr _cyuserData - {{endif}} -{{endif}} -{{if 'cudaHostNodeParamsV2' in found_struct}} + cdef class cudaHostNodeParamsV2: """ @@ -988,18 +890,18 @@ cdef class cudaHostNodeParamsV2: Attributes ---------- - {{if 'cudaHostNodeParamsV2.fn' in found_struct}} + fn : cudaHostFn_t The function to call when the node executes - {{endif}} - {{if 'cudaHostNodeParamsV2.userData' in found_struct}} + + userData : Any Argument to pass to the function - {{endif}} - {{if 'cudaHostNodeParamsV2.syncMode' in found_struct}} + + syncMode : unsigned int The synchronization mode to use for the host task - {{endif}} + Methods ------- @@ -1008,23 +910,21 @@ cdef class cudaHostNodeParamsV2: """ cdef cyruntime.cudaHostNodeParamsV2 _pvt_val cdef cyruntime.cudaHostNodeParamsV2* _pvt_ptr - {{if 'cudaHostNodeParamsV2.fn' in found_struct}} + cdef cudaHostFn_t _fn - {{endif}} - {{if 'cudaHostNodeParamsV2.userData' in found_struct}} + + cdef _HelperInputVoidPtr _cyuserData - {{endif}} -{{endif}} -{{if 'cudaResourceDesc.res.array' in found_struct}} + cdef class anon_struct1: """ Attributes ---------- - {{if 'cudaResourceDesc.res.array.array' in found_struct}} + array : cudaArray_t - {{endif}} + Methods ------- @@ -1032,20 +932,18 @@ cdef class anon_struct1: Get memory address of class instance """ cdef cyruntime.cudaResourceDesc* _pvt_ptr - {{if 'cudaResourceDesc.res.array.array' in found_struct}} + cdef cudaArray_t _array - {{endif}} -{{endif}} -{{if 'cudaResourceDesc.res.mipmap' in found_struct}} + cdef class anon_struct2: """ Attributes ---------- - {{if 'cudaResourceDesc.res.mipmap.mipmap' in found_struct}} + mipmap : cudaMipmappedArray_t - {{endif}} + Methods ------- @@ -1053,28 +951,26 @@ cdef class anon_struct2: Get memory address of class instance """ cdef cyruntime.cudaResourceDesc* _pvt_ptr - {{if 'cudaResourceDesc.res.mipmap.mipmap' in found_struct}} + cdef cudaMipmappedArray_t _mipmap - {{endif}} -{{endif}} -{{if 'cudaResourceDesc.res.linear' in found_struct}} + cdef class anon_struct3: """ Attributes ---------- - {{if 'cudaResourceDesc.res.linear.devPtr' in found_struct}} + devPtr : Any - {{endif}} - {{if 'cudaResourceDesc.res.linear.desc' in found_struct}} + + desc : cudaChannelFormatDesc - {{endif}} - {{if 'cudaResourceDesc.res.linear.sizeInBytes' in found_struct}} + + sizeInBytes : size_t - {{endif}} + Methods ------- @@ -1082,39 +978,37 @@ cdef class anon_struct3: Get memory address of class instance """ cdef cyruntime.cudaResourceDesc* _pvt_ptr - {{if 'cudaResourceDesc.res.linear.devPtr' in found_struct}} + cdef _HelperInputVoidPtr _cydevPtr - {{endif}} - {{if 'cudaResourceDesc.res.linear.desc' in found_struct}} + + cdef cudaChannelFormatDesc _desc - {{endif}} -{{endif}} -{{if 'cudaResourceDesc.res.pitch2D' in found_struct}} + cdef class anon_struct4: """ Attributes ---------- - {{if 'cudaResourceDesc.res.pitch2D.devPtr' in found_struct}} + devPtr : Any - {{endif}} - {{if 'cudaResourceDesc.res.pitch2D.desc' in found_struct}} + + desc : cudaChannelFormatDesc - {{endif}} - {{if 'cudaResourceDesc.res.pitch2D.width' in found_struct}} + + width : size_t - {{endif}} - {{if 'cudaResourceDesc.res.pitch2D.height' in found_struct}} + + height : size_t - {{endif}} - {{if 'cudaResourceDesc.res.pitch2D.pitchInBytes' in found_struct}} + + pitchInBytes : size_t - {{endif}} + Methods ------- @@ -1122,23 +1016,21 @@ cdef class anon_struct4: Get memory address of class instance """ cdef cyruntime.cudaResourceDesc* _pvt_ptr - {{if 'cudaResourceDesc.res.pitch2D.devPtr' in found_struct}} + cdef _HelperInputVoidPtr _cydevPtr - {{endif}} - {{if 'cudaResourceDesc.res.pitch2D.desc' in found_struct}} + + cdef cudaChannelFormatDesc _desc - {{endif}} -{{endif}} -{{if 'cudaResourceDesc.res.reserved' in found_struct}} + cdef class anon_struct5: """ Attributes ---------- - {{if 'cudaResourceDesc.res.reserved.reserved' in found_struct}} + reserved : list[int] - {{endif}} + Methods ------- @@ -1146,33 +1038,31 @@ cdef class anon_struct5: Get memory address of class instance """ cdef cyruntime.cudaResourceDesc* _pvt_ptr -{{endif}} -{{if 'cudaResourceDesc.res' in found_struct}} cdef class anon_union0: """ Attributes ---------- - {{if 'cudaResourceDesc.res.array' in found_struct}} + array : anon_struct1 - {{endif}} - {{if 'cudaResourceDesc.res.mipmap' in found_struct}} + + mipmap : anon_struct2 - {{endif}} - {{if 'cudaResourceDesc.res.linear' in found_struct}} + + linear : anon_struct3 - {{endif}} - {{if 'cudaResourceDesc.res.pitch2D' in found_struct}} + + pitch2D : anon_struct4 - {{endif}} - {{if 'cudaResourceDesc.res.reserved' in found_struct}} + + reserved : anon_struct5 - {{endif}} + Methods ------- @@ -1180,23 +1070,21 @@ cdef class anon_union0: Get memory address of class instance """ cdef cyruntime.cudaResourceDesc* _pvt_ptr - {{if 'cudaResourceDesc.res.array' in found_struct}} + cdef anon_struct1 _array - {{endif}} - {{if 'cudaResourceDesc.res.mipmap' in found_struct}} + + cdef anon_struct2 _mipmap - {{endif}} - {{if 'cudaResourceDesc.res.linear' in found_struct}} + + cdef anon_struct3 _linear - {{endif}} - {{if 'cudaResourceDesc.res.pitch2D' in found_struct}} + + cdef anon_struct4 _pitch2D - {{endif}} - {{if 'cudaResourceDesc.res.reserved' in found_struct}} + + cdef anon_struct5 _reserved - {{endif}} -{{endif}} -{{if 'cudaResourceDesc' in found_struct}} + cdef class cudaResourceDesc: """ @@ -1204,18 +1092,18 @@ cdef class cudaResourceDesc: Attributes ---------- - {{if 'cudaResourceDesc.resType' in found_struct}} + resType : cudaResourceType Resource type - {{endif}} - {{if 'cudaResourceDesc.res' in found_struct}} + + res : anon_union0 - {{endif}} - {{if 'cudaResourceDesc.flags' in found_struct}} + + flags : unsigned int Flags (must be zero) - {{endif}} + Methods ------- @@ -1224,11 +1112,9 @@ cdef class cudaResourceDesc: """ cdef cyruntime.cudaResourceDesc* _val_ptr cdef cyruntime.cudaResourceDesc* _pvt_ptr - {{if 'cudaResourceDesc.res' in found_struct}} + cdef anon_union0 _res - {{endif}} -{{endif}} -{{if 'cudaResourceViewDesc' in found_struct}} + cdef class cudaResourceViewDesc: """ @@ -1236,42 +1122,42 @@ cdef class cudaResourceViewDesc: Attributes ---------- - {{if 'cudaResourceViewDesc.format' in found_struct}} + format : cudaResourceViewFormat Resource view format - {{endif}} - {{if 'cudaResourceViewDesc.width' in found_struct}} + + width : size_t Width of the resource view - {{endif}} - {{if 'cudaResourceViewDesc.height' in found_struct}} + + height : size_t Height of the resource view - {{endif}} - {{if 'cudaResourceViewDesc.depth' in found_struct}} + + depth : size_t Depth of the resource view - {{endif}} - {{if 'cudaResourceViewDesc.firstMipmapLevel' in found_struct}} + + firstMipmapLevel : unsigned int First defined mipmap level - {{endif}} - {{if 'cudaResourceViewDesc.lastMipmapLevel' in found_struct}} + + lastMipmapLevel : unsigned int Last defined mipmap level - {{endif}} - {{if 'cudaResourceViewDesc.firstLayer' in found_struct}} + + firstLayer : unsigned int First layer index - {{endif}} - {{if 'cudaResourceViewDesc.lastLayer' in found_struct}} + + lastLayer : unsigned int Last layer index - {{endif}} - {{if 'cudaResourceViewDesc.reserved' in found_struct}} + + reserved : list[unsigned int] Must be zero - {{endif}} + Methods ------- @@ -1280,8 +1166,6 @@ cdef class cudaResourceViewDesc: """ cdef cyruntime.cudaResourceViewDesc _pvt_val cdef cyruntime.cudaResourceViewDesc* _pvt_ptr -{{endif}} -{{if 'cudaPointerAttributes' in found_struct}} cdef class cudaPointerAttributes: """ @@ -1289,12 +1173,12 @@ cdef class cudaPointerAttributes: Attributes ---------- - {{if 'cudaPointerAttributes.type' in found_struct}} + type : cudaMemoryType The type of memory - cudaMemoryTypeUnregistered, cudaMemoryTypeHost, cudaMemoryTypeDevice or cudaMemoryTypeManaged. - {{endif}} - {{if 'cudaPointerAttributes.device' in found_struct}} + + device : int The device against which the memory was allocated or registered. If the memory type is cudaMemoryTypeDevice then this identifies the @@ -1303,23 +1187,23 @@ cdef class cudaPointerAttributes: this identifies the device which was current when the memory was allocated or registered (and if that device is deinitialized then this allocation will vanish with that device's state). - {{endif}} - {{if 'cudaPointerAttributes.devicePointer' in found_struct}} + + devicePointer : Any The address which may be dereferenced on the current device to access the memory or NULL if no such address exists. - {{endif}} - {{if 'cudaPointerAttributes.hostPointer' in found_struct}} + + hostPointer : Any The address which may be dereferenced on the host to access the memory or NULL if no such address exists. CUDA doesn't check if unregistered memory is allocated so this field may contain invalid pointer if an invalid pointer has been passed to CUDA. - {{endif}} - {{if 'cudaPointerAttributes.reserved' in found_struct}} + + reserved : list[long] Must be zero - {{endif}} + Methods ------- @@ -1328,14 +1212,12 @@ cdef class cudaPointerAttributes: """ cdef cyruntime.cudaPointerAttributes _pvt_val cdef cyruntime.cudaPointerAttributes* _pvt_ptr - {{if 'cudaPointerAttributes.devicePointer' in found_struct}} + cdef _HelperInputVoidPtr _cydevicePointer - {{endif}} - {{if 'cudaPointerAttributes.hostPointer' in found_struct}} + + cdef _HelperInputVoidPtr _cyhostPointer - {{endif}} -{{endif}} -{{if 'cudaFuncAttributes' in found_struct}} + cdef class cudaFuncAttributes: """ @@ -1343,57 +1225,57 @@ cdef class cudaFuncAttributes: Attributes ---------- - {{if 'cudaFuncAttributes.sharedSizeBytes' in found_struct}} + sharedSizeBytes : size_t The size in bytes of statically-allocated shared memory per block required by this function. This does not include dynamically- allocated shared memory requested by the user at runtime. - {{endif}} - {{if 'cudaFuncAttributes.constSizeBytes' in found_struct}} + + constSizeBytes : size_t The size in bytes of user-allocated constant memory required by this function. - {{endif}} - {{if 'cudaFuncAttributes.localSizeBytes' in found_struct}} + + localSizeBytes : size_t The size in bytes of local memory used by each thread of this function. - {{endif}} - {{if 'cudaFuncAttributes.maxThreadsPerBlock' in found_struct}} + + maxThreadsPerBlock : int The maximum number of threads per block, beyond which a launch of the function would fail. This number depends on both the function and the device on which the function is currently loaded. - {{endif}} - {{if 'cudaFuncAttributes.numRegs' in found_struct}} + + numRegs : int The number of registers used by each thread of this function. - {{endif}} - {{if 'cudaFuncAttributes.ptxVersion' in found_struct}} + + ptxVersion : int The PTX virtual architecture version for which the function was compiled. This value is the major PTX version * 10 + the minor PTX version, so a PTX version 1.3 function would return the value 13. - {{endif}} - {{if 'cudaFuncAttributes.binaryVersion' in found_struct}} + + binaryVersion : int The binary architecture version for which the function was compiled. This value is the major binary version * 10 + the minor binary version, so a binary version 1.3 function would return the value 13. - {{endif}} - {{if 'cudaFuncAttributes.cacheModeCA' in found_struct}} + + cacheModeCA : int The attribute to indicate whether the function has been compiled with user specified option "-Xptxas --dlcm=ca" set. - {{endif}} - {{if 'cudaFuncAttributes.maxDynamicSharedSizeBytes' in found_struct}} + + maxDynamicSharedSizeBytes : int The maximum size in bytes of dynamic shared memory per block for this function. Any launch must have a dynamic shared memory size smaller than this value. - {{endif}} - {{if 'cudaFuncAttributes.preferredShmemCarveout' in found_struct}} + + preferredShmemCarveout : int On devices where the L1 cache and shared memory use the same hardware resources, this sets the shared memory carveout @@ -1401,13 +1283,13 @@ cdef class cudaFuncAttributes: cudaDevAttrMaxSharedMemoryPerMultiprocessor. This is only a hint, and the driver can choose a different ratio if required to execute the function. See cudaFuncSetAttribute - {{endif}} - {{if 'cudaFuncAttributes.clusterDimMustBeSet' in found_struct}} + + clusterDimMustBeSet : int If this attribute is set, the kernel must launch with a valid cluster dimension specified. - {{endif}} - {{if 'cudaFuncAttributes.requiredClusterWidth' in found_struct}} + + requiredClusterWidth : int The required cluster width/height/depth in blocks. The values must either all be 0 or all be positive. The validity of the cluster @@ -1415,20 +1297,20 @@ cdef class cudaFuncAttributes: set during compile time, it cannot be set at runtime. Setting it at runtime should return cudaErrorNotPermitted. See cudaFuncSetAttribute - {{endif}} - {{if 'cudaFuncAttributes.requiredClusterHeight' in found_struct}} + + requiredClusterHeight : int - {{endif}} - {{if 'cudaFuncAttributes.requiredClusterDepth' in found_struct}} + + requiredClusterDepth : int - {{endif}} - {{if 'cudaFuncAttributes.clusterSchedulingPolicyPreference' in found_struct}} + + clusterSchedulingPolicyPreference : int The block scheduling policy of a function. See cudaFuncSetAttribute - {{endif}} - {{if 'cudaFuncAttributes.nonPortableClusterSizeAllowed' in found_struct}} + + nonPortableClusterSizeAllowed : int Whether the function can be launched with non-portable cluster size. 1 is allowed, 0 is disallowed. A non-portable cluster size @@ -1443,21 +1325,21 @@ cdef class cudaFuncAttributes: compute capabilities. The specific hardware unit may support higher cluster sizes that’s not guaranteed to be portable. See cudaFuncSetAttribute - {{endif}} - {{if 'cudaFuncAttributes.deviceNodeUpdateStatus' in found_struct}} + + deviceNodeUpdateStatus : int Whether the function can be updated on device. 1 means device node update is supported, 0 is unsupported or driver is too old to check the value. - {{endif}} - {{if 'cudaFuncAttributes.reserved1' in found_struct}} + + reserved1 : int - {{endif}} - {{if 'cudaFuncAttributes.reserved' in found_struct}} + + reserved : list[int] Reserved for future use. - {{endif}} + Methods ------- @@ -1466,8 +1348,6 @@ cdef class cudaFuncAttributes: """ cdef cyruntime.cudaFuncAttributes _pvt_val cdef cyruntime.cudaFuncAttributes* _pvt_ptr -{{endif}} -{{if 'cudaMemLocation' in found_struct}} cdef class cudaMemLocation: """ @@ -1478,16 +1358,16 @@ cdef class cudaMemLocation: Attributes ---------- - {{if 'cudaMemLocation.type' in found_struct}} + type : cudaMemLocationType Specifies the location type, which modifies the meaning of id. - {{endif}} - {{if 'cudaMemLocation.id' in found_struct}} + + id : int Identifier for cudaMemLocationType::cudaMemLocationTypeDevice, cudaMemLocationType::cudaMemLocationTypeHost, or cudaMemLocationType::cudaMemLocationTypeHostNuma. - {{endif}} + Methods ------- @@ -1496,8 +1376,6 @@ cdef class cudaMemLocation: """ cdef cyruntime.cudaMemLocation* _val_ptr cdef cyruntime.cudaMemLocation* _pvt_ptr -{{endif}} -{{if 'cudaMemAccessDesc' in found_struct}} cdef class cudaMemAccessDesc: """ @@ -1505,14 +1383,14 @@ cdef class cudaMemAccessDesc: Attributes ---------- - {{if 'cudaMemAccessDesc.location' in found_struct}} + location : cudaMemLocation Location on which the request is to change it's accessibility - {{endif}} - {{if 'cudaMemAccessDesc.flags' in found_struct}} + + flags : cudaMemAccessFlags ::CUmemProt accessibility flags to set on the request - {{endif}} + Methods ------- @@ -1521,11 +1399,9 @@ cdef class cudaMemAccessDesc: """ cdef cyruntime.cudaMemAccessDesc _pvt_val cdef cyruntime.cudaMemAccessDesc* _pvt_ptr - {{if 'cudaMemAccessDesc.location' in found_struct}} + cdef cudaMemLocation _location - {{endif}} -{{endif}} -{{if 'cudaMemPoolProps' in found_struct}} + cdef class cudaMemPoolProps: """ @@ -1533,40 +1409,40 @@ cdef class cudaMemPoolProps: Attributes ---------- - {{if 'cudaMemPoolProps.allocType' in found_struct}} + allocType : cudaMemAllocationType Allocation type. Currently must be specified as cudaMemAllocationTypePinned - {{endif}} - {{if 'cudaMemPoolProps.handleTypes' in found_struct}} + + handleTypes : cudaMemAllocationHandleType Handle types that will be supported by allocations from the pool. - {{endif}} - {{if 'cudaMemPoolProps.location' in found_struct}} + + location : cudaMemLocation Location allocations should reside. - {{endif}} - {{if 'cudaMemPoolProps.win32SecurityAttributes' in found_struct}} + + win32SecurityAttributes : Any Windows-specific LPSECURITYATTRIBUTES required when cudaMemHandleTypeWin32 is specified. This security attribute defines the scope of which exported allocations may be tranferred to other processes. In all other cases, this field is required to be zero. - {{endif}} - {{if 'cudaMemPoolProps.maxSize' in found_struct}} + + maxSize : size_t Maximum pool size. When set to 0, defaults to a system dependent value. - {{endif}} - {{if 'cudaMemPoolProps.usage' in found_struct}} + + usage : unsigned short Bitmask indicating intended usage for the pool. - {{endif}} - {{if 'cudaMemPoolProps.reserved' in found_struct}} + + reserved : bytes reserved for future use, must be 0 - {{endif}} + Methods ------- @@ -1575,14 +1451,12 @@ cdef class cudaMemPoolProps: """ cdef cyruntime.cudaMemPoolProps _pvt_val cdef cyruntime.cudaMemPoolProps* _pvt_ptr - {{if 'cudaMemPoolProps.location' in found_struct}} + cdef cudaMemLocation _location - {{endif}} - {{if 'cudaMemPoolProps.win32SecurityAttributes' in found_struct}} + + cdef _HelperInputVoidPtr _cywin32SecurityAttributes - {{endif}} -{{endif}} -{{if 'cudaMemPoolPtrExportData' in found_struct}} + cdef class cudaMemPoolPtrExportData: """ @@ -1590,10 +1464,10 @@ cdef class cudaMemPoolPtrExportData: Attributes ---------- - {{if 'cudaMemPoolPtrExportData.reserved' in found_struct}} + reserved : bytes - {{endif}} + Methods ------- @@ -1602,8 +1476,6 @@ cdef class cudaMemPoolPtrExportData: """ cdef cyruntime.cudaMemPoolPtrExportData _pvt_val cdef cyruntime.cudaMemPoolPtrExportData* _pvt_ptr -{{endif}} -{{if 'cudaMemAllocNodeParams' in found_struct}} cdef class cudaMemAllocNodeParams: """ @@ -1611,30 +1483,30 @@ cdef class cudaMemAllocNodeParams: Attributes ---------- - {{if 'cudaMemAllocNodeParams.poolProps' in found_struct}} + poolProps : cudaMemPoolProps in: location where the allocation should reside (specified in ::location). ::handleTypes must be cudaMemHandleTypeNone. IPC is not supported. in: array of memory access descriptors. Used to describe peer GPU access - {{endif}} - {{if 'cudaMemAllocNodeParams.accessDescs' in found_struct}} + + accessDescs : cudaMemAccessDesc in: number of memory access descriptors. Must not exceed the number of GPUs. - {{endif}} - {{if 'cudaMemAllocNodeParams.accessDescCount' in found_struct}} + + accessDescCount : size_t in: Number of `accessDescs`s - {{endif}} - {{if 'cudaMemAllocNodeParams.bytesize' in found_struct}} + + bytesize : size_t in: size in bytes of the requested allocation - {{endif}} - {{if 'cudaMemAllocNodeParams.dptr' in found_struct}} + + dptr : Any out: address of the allocation returned by CUDA - {{endif}} + Methods ------- @@ -1643,18 +1515,16 @@ cdef class cudaMemAllocNodeParams: """ cdef cyruntime.cudaMemAllocNodeParams _pvt_val cdef cyruntime.cudaMemAllocNodeParams* _pvt_ptr - {{if 'cudaMemAllocNodeParams.poolProps' in found_struct}} + cdef cudaMemPoolProps _poolProps - {{endif}} - {{if 'cudaMemAllocNodeParams.accessDescs' in found_struct}} + + cdef size_t _accessDescs_length cdef cyruntime.cudaMemAccessDesc* _accessDescs - {{endif}} - {{if 'cudaMemAllocNodeParams.dptr' in found_struct}} + + cdef _HelperInputVoidPtr _cydptr - {{endif}} -{{endif}} -{{if 'cudaMemAllocNodeParamsV2' in found_struct}} + cdef class cudaMemAllocNodeParamsV2: """ @@ -1662,30 +1532,30 @@ cdef class cudaMemAllocNodeParamsV2: Attributes ---------- - {{if 'cudaMemAllocNodeParamsV2.poolProps' in found_struct}} + poolProps : cudaMemPoolProps in: location where the allocation should reside (specified in ::location). ::handleTypes must be cudaMemHandleTypeNone. IPC is not supported. in: array of memory access descriptors. Used to describe peer GPU access - {{endif}} - {{if 'cudaMemAllocNodeParamsV2.accessDescs' in found_struct}} + + accessDescs : cudaMemAccessDesc in: number of memory access descriptors. Must not exceed the number of GPUs. - {{endif}} - {{if 'cudaMemAllocNodeParamsV2.accessDescCount' in found_struct}} + + accessDescCount : size_t in: Number of `accessDescs`s - {{endif}} - {{if 'cudaMemAllocNodeParamsV2.bytesize' in found_struct}} + + bytesize : size_t in: size in bytes of the requested allocation - {{endif}} - {{if 'cudaMemAllocNodeParamsV2.dptr' in found_struct}} + + dptr : Any out: address of the allocation returned by CUDA - {{endif}} + Methods ------- @@ -1694,18 +1564,16 @@ cdef class cudaMemAllocNodeParamsV2: """ cdef cyruntime.cudaMemAllocNodeParamsV2 _pvt_val cdef cyruntime.cudaMemAllocNodeParamsV2* _pvt_ptr - {{if 'cudaMemAllocNodeParamsV2.poolProps' in found_struct}} + cdef cudaMemPoolProps _poolProps - {{endif}} - {{if 'cudaMemAllocNodeParamsV2.accessDescs' in found_struct}} + + cdef size_t _accessDescs_length cdef cyruntime.cudaMemAccessDesc* _accessDescs - {{endif}} - {{if 'cudaMemAllocNodeParamsV2.dptr' in found_struct}} + + cdef _HelperInputVoidPtr _cydptr - {{endif}} -{{endif}} -{{if 'cudaMemFreeNodeParams' in found_struct}} + cdef class cudaMemFreeNodeParams: """ @@ -1713,10 +1581,10 @@ cdef class cudaMemFreeNodeParams: Attributes ---------- - {{if 'cudaMemFreeNodeParams.dptr' in found_struct}} + dptr : Any in: the pointer to free - {{endif}} + Methods ------- @@ -1725,11 +1593,9 @@ cdef class cudaMemFreeNodeParams: """ cdef cyruntime.cudaMemFreeNodeParams _pvt_val cdef cyruntime.cudaMemFreeNodeParams* _pvt_ptr - {{if 'cudaMemFreeNodeParams.dptr' in found_struct}} + cdef _HelperInputVoidPtr _cydptr - {{endif}} -{{endif}} -{{if 'cudaMemcpyAttributes' in found_struct}} + cdef class cudaMemcpyAttributes: """ @@ -1738,26 +1604,26 @@ cdef class cudaMemcpyAttributes: Attributes ---------- - {{if 'cudaMemcpyAttributes.srcAccessOrder' in found_struct}} + srcAccessOrder : cudaMemcpySrcAccessOrder Source access ordering to be observed for copies with this attribute. - {{endif}} - {{if 'cudaMemcpyAttributes.srcLocHint' in found_struct}} + + srcLocHint : cudaMemLocation Hint location for the source operand. Ignored when the pointers are not managed memory or memory allocated outside CUDA. - {{endif}} - {{if 'cudaMemcpyAttributes.dstLocHint' in found_struct}} + + dstLocHint : cudaMemLocation Hint location for the destination operand. Ignored when the pointers are not managed memory or memory allocated outside CUDA. - {{endif}} - {{if 'cudaMemcpyAttributes.flags' in found_struct}} + + flags : unsigned int Additional flags for copies with this attribute. See cudaMemcpyFlags. - {{endif}} + Methods ------- @@ -1766,14 +1632,12 @@ cdef class cudaMemcpyAttributes: """ cdef cyruntime.cudaMemcpyAttributes _pvt_val cdef cyruntime.cudaMemcpyAttributes* _pvt_ptr - {{if 'cudaMemcpyAttributes.srcLocHint' in found_struct}} + cdef cudaMemLocation _srcLocHint - {{endif}} - {{if 'cudaMemcpyAttributes.dstLocHint' in found_struct}} + + cdef cudaMemLocation _dstLocHint - {{endif}} -{{endif}} -{{if 'cudaOffset3D' in found_struct}} + cdef class cudaOffset3D: """ @@ -1781,18 +1645,18 @@ cdef class cudaOffset3D: Attributes ---------- - {{if 'cudaOffset3D.x' in found_struct}} + x : size_t - {{endif}} - {{if 'cudaOffset3D.y' in found_struct}} + + y : size_t - {{endif}} - {{if 'cudaOffset3D.z' in found_struct}} + + z : size_t - {{endif}} + Methods ------- @@ -1801,29 +1665,27 @@ cdef class cudaOffset3D: """ cdef cyruntime.cudaOffset3D _pvt_val cdef cyruntime.cudaOffset3D* _pvt_ptr -{{endif}} -{{if 'cudaMemcpy3DOperand.op.ptr' in found_struct}} cdef class anon_struct6: """ Attributes ---------- - {{if 'cudaMemcpy3DOperand.op.ptr.ptr' in found_struct}} + ptr : Any - {{endif}} - {{if 'cudaMemcpy3DOperand.op.ptr.rowLength' in found_struct}} + + rowLength : size_t - {{endif}} - {{if 'cudaMemcpy3DOperand.op.ptr.layerHeight' in found_struct}} + + layerHeight : size_t - {{endif}} - {{if 'cudaMemcpy3DOperand.op.ptr.locHint' in found_struct}} + + locHint : cudaMemLocation - {{endif}} + Methods ------- @@ -1831,27 +1693,25 @@ cdef class anon_struct6: Get memory address of class instance """ cdef cyruntime.cudaMemcpy3DOperand* _pvt_ptr - {{if 'cudaMemcpy3DOperand.op.ptr.ptr' in found_struct}} + cdef _HelperInputVoidPtr _cyptr - {{endif}} - {{if 'cudaMemcpy3DOperand.op.ptr.locHint' in found_struct}} + + cdef cudaMemLocation _locHint - {{endif}} -{{endif}} -{{if 'cudaMemcpy3DOperand.op.array' in found_struct}} + cdef class anon_struct7: """ Attributes ---------- - {{if 'cudaMemcpy3DOperand.op.array.array' in found_struct}} + array : cudaArray_t - {{endif}} - {{if 'cudaMemcpy3DOperand.op.array.offset' in found_struct}} + + offset : cudaOffset3D - {{endif}} + Methods ------- @@ -1859,27 +1719,25 @@ cdef class anon_struct7: Get memory address of class instance """ cdef cyruntime.cudaMemcpy3DOperand* _pvt_ptr - {{if 'cudaMemcpy3DOperand.op.array.array' in found_struct}} + cdef cudaArray_t _array - {{endif}} - {{if 'cudaMemcpy3DOperand.op.array.offset' in found_struct}} + + cdef cudaOffset3D _offset - {{endif}} -{{endif}} -{{if 'cudaMemcpy3DOperand.op' in found_struct}} + cdef class anon_union2: """ Attributes ---------- - {{if 'cudaMemcpy3DOperand.op.ptr' in found_struct}} + ptr : anon_struct6 - {{endif}} - {{if 'cudaMemcpy3DOperand.op.array' in found_struct}} + + array : anon_struct7 - {{endif}} + Methods ------- @@ -1887,14 +1745,12 @@ cdef class anon_union2: Get memory address of class instance """ cdef cyruntime.cudaMemcpy3DOperand* _pvt_ptr - {{if 'cudaMemcpy3DOperand.op.ptr' in found_struct}} + cdef anon_struct6 _ptr - {{endif}} - {{if 'cudaMemcpy3DOperand.op.array' in found_struct}} + + cdef anon_struct7 _array - {{endif}} -{{endif}} -{{if 'cudaMemcpy3DOperand' in found_struct}} + cdef class cudaMemcpy3DOperand: """ @@ -1902,14 +1758,14 @@ cdef class cudaMemcpy3DOperand: Attributes ---------- - {{if 'cudaMemcpy3DOperand.type' in found_struct}} + type : cudaMemcpy3DOperandType - {{endif}} - {{if 'cudaMemcpy3DOperand.op' in found_struct}} + + op : anon_union2 - {{endif}} + Methods ------- @@ -1918,37 +1774,35 @@ cdef class cudaMemcpy3DOperand: """ cdef cyruntime.cudaMemcpy3DOperand* _val_ptr cdef cyruntime.cudaMemcpy3DOperand* _pvt_ptr - {{if 'cudaMemcpy3DOperand.op' in found_struct}} + cdef anon_union2 _op - {{endif}} -{{endif}} -{{if 'cudaMemcpy3DBatchOp' in found_struct}} + cdef class cudaMemcpy3DBatchOp: """ Attributes ---------- - {{if 'cudaMemcpy3DBatchOp.src' in found_struct}} + src : cudaMemcpy3DOperand Source memcpy operand. - {{endif}} - {{if 'cudaMemcpy3DBatchOp.dst' in found_struct}} + + dst : cudaMemcpy3DOperand Destination memcpy operand. - {{endif}} - {{if 'cudaMemcpy3DBatchOp.extent' in found_struct}} + + extent : cudaExtent Extents of the memcpy between src and dst. The width, height and depth components must not be 0. - {{endif}} - {{if 'cudaMemcpy3DBatchOp.srcAccessOrder' in found_struct}} + + srcAccessOrder : cudaMemcpySrcAccessOrder Source access ordering to be observed for copy from src to dst. - {{endif}} - {{if 'cudaMemcpy3DBatchOp.flags' in found_struct}} + + flags : unsigned int Additional flags for copy from src to dst. See cudaMemcpyFlags. - {{endif}} + Methods ------- @@ -1957,26 +1811,24 @@ cdef class cudaMemcpy3DBatchOp: """ cdef cyruntime.cudaMemcpy3DBatchOp _pvt_val cdef cyruntime.cudaMemcpy3DBatchOp* _pvt_ptr - {{if 'cudaMemcpy3DBatchOp.src' in found_struct}} + cdef cudaMemcpy3DOperand _src - {{endif}} - {{if 'cudaMemcpy3DBatchOp.dst' in found_struct}} + + cdef cudaMemcpy3DOperand _dst - {{endif}} - {{if 'cudaMemcpy3DBatchOp.extent' in found_struct}} + + cdef cudaExtent _extent - {{endif}} -{{endif}} -{{if 'CUuuid_st' in found_struct}} + cdef class CUuuid_st: """ Attributes ---------- - {{if 'CUuuid_st.bytes' in found_struct}} + bytes : bytes < CUDA definition of UUID - {{endif}} + Methods ------- @@ -1985,8 +1837,6 @@ cdef class CUuuid_st: """ cdef cyruntime.CUuuid_st _pvt_val cdef cyruntime.CUuuid_st* _pvt_ptr -{{endif}} -{{if 'cudaDeviceProp' in found_struct}} cdef class cudaDeviceProp: """ @@ -1994,401 +1844,401 @@ cdef class cudaDeviceProp: Attributes ---------- - {{if 'cudaDeviceProp.name' in found_struct}} + name : bytes ASCII string identifying device - {{endif}} - {{if 'cudaDeviceProp.uuid' in found_struct}} + + uuid : cudaUUID_t 16-byte unique identifier - {{endif}} - {{if 'cudaDeviceProp.luid' in found_struct}} + + luid : bytes 8-byte locally unique identifier. Value is undefined on TCC and non-Windows platforms - {{endif}} - {{if 'cudaDeviceProp.luidDeviceNodeMask' in found_struct}} + + luidDeviceNodeMask : unsigned int LUID device node mask. Value is undefined on TCC and non-Windows platforms - {{endif}} - {{if 'cudaDeviceProp.totalGlobalMem' in found_struct}} + + totalGlobalMem : size_t Global memory available on device in bytes - {{endif}} - {{if 'cudaDeviceProp.sharedMemPerBlock' in found_struct}} + + sharedMemPerBlock : size_t Shared memory available per block in bytes - {{endif}} - {{if 'cudaDeviceProp.regsPerBlock' in found_struct}} + + regsPerBlock : int 32-bit registers available per block - {{endif}} - {{if 'cudaDeviceProp.warpSize' in found_struct}} + + warpSize : int Warp size in threads - {{endif}} - {{if 'cudaDeviceProp.memPitch' in found_struct}} + + memPitch : size_t Maximum pitch in bytes allowed by memory copies - {{endif}} - {{if 'cudaDeviceProp.maxThreadsPerBlock' in found_struct}} + + maxThreadsPerBlock : int Maximum number of threads per block - {{endif}} - {{if 'cudaDeviceProp.maxThreadsDim' in found_struct}} + + maxThreadsDim : list[int] Maximum size of each dimension of a block - {{endif}} - {{if 'cudaDeviceProp.maxGridSize' in found_struct}} + + maxGridSize : list[int] Maximum size of each dimension of a grid - {{endif}} - {{if 'cudaDeviceProp.totalConstMem' in found_struct}} + + totalConstMem : size_t Constant memory available on device in bytes - {{endif}} - {{if 'cudaDeviceProp.major' in found_struct}} + + major : int Major compute capability - {{endif}} - {{if 'cudaDeviceProp.minor' in found_struct}} + + minor : int Minor compute capability - {{endif}} - {{if 'cudaDeviceProp.textureAlignment' in found_struct}} + + textureAlignment : size_t Alignment requirement for textures - {{endif}} - {{if 'cudaDeviceProp.texturePitchAlignment' in found_struct}} + + texturePitchAlignment : size_t Pitch alignment requirement for texture references bound to pitched memory - {{endif}} - {{if 'cudaDeviceProp.multiProcessorCount' in found_struct}} + + multiProcessorCount : int Number of multiprocessors on device - {{endif}} - {{if 'cudaDeviceProp.integrated' in found_struct}} + + integrated : int Device is integrated as opposed to discrete - {{endif}} - {{if 'cudaDeviceProp.canMapHostMemory' in found_struct}} + + canMapHostMemory : int Device can map host memory with cudaHostAlloc/cudaHostGetDevicePointer - {{endif}} - {{if 'cudaDeviceProp.maxTexture1D' in found_struct}} + + maxTexture1D : int Maximum 1D texture size - {{endif}} - {{if 'cudaDeviceProp.maxTexture1DMipmap' in found_struct}} + + maxTexture1DMipmap : int Maximum 1D mipmapped texture size - {{endif}} - {{if 'cudaDeviceProp.maxTexture2D' in found_struct}} + + maxTexture2D : list[int] Maximum 2D texture dimensions - {{endif}} - {{if 'cudaDeviceProp.maxTexture2DMipmap' in found_struct}} + + maxTexture2DMipmap : list[int] Maximum 2D mipmapped texture dimensions - {{endif}} - {{if 'cudaDeviceProp.maxTexture2DLinear' in found_struct}} + + maxTexture2DLinear : list[int] Maximum dimensions (width, height, pitch) for 2D textures bound to pitched memory - {{endif}} - {{if 'cudaDeviceProp.maxTexture2DGather' in found_struct}} + + maxTexture2DGather : list[int] Maximum 2D texture dimensions if texture gather operations have to be performed - {{endif}} - {{if 'cudaDeviceProp.maxTexture3D' in found_struct}} + + maxTexture3D : list[int] Maximum 3D texture dimensions - {{endif}} - {{if 'cudaDeviceProp.maxTexture3DAlt' in found_struct}} + + maxTexture3DAlt : list[int] Maximum alternate 3D texture dimensions - {{endif}} - {{if 'cudaDeviceProp.maxTextureCubemap' in found_struct}} + + maxTextureCubemap : int Maximum Cubemap texture dimensions - {{endif}} - {{if 'cudaDeviceProp.maxTexture1DLayered' in found_struct}} + + maxTexture1DLayered : list[int] Maximum 1D layered texture dimensions - {{endif}} - {{if 'cudaDeviceProp.maxTexture2DLayered' in found_struct}} + + maxTexture2DLayered : list[int] Maximum 2D layered texture dimensions - {{endif}} - {{if 'cudaDeviceProp.maxTextureCubemapLayered' in found_struct}} + + maxTextureCubemapLayered : list[int] Maximum Cubemap layered texture dimensions - {{endif}} - {{if 'cudaDeviceProp.maxSurface1D' in found_struct}} + + maxSurface1D : int Maximum 1D surface size - {{endif}} - {{if 'cudaDeviceProp.maxSurface2D' in found_struct}} + + maxSurface2D : list[int] Maximum 2D surface dimensions - {{endif}} - {{if 'cudaDeviceProp.maxSurface3D' in found_struct}} + + maxSurface3D : list[int] Maximum 3D surface dimensions - {{endif}} - {{if 'cudaDeviceProp.maxSurface1DLayered' in found_struct}} + + maxSurface1DLayered : list[int] Maximum 1D layered surface dimensions - {{endif}} - {{if 'cudaDeviceProp.maxSurface2DLayered' in found_struct}} + + maxSurface2DLayered : list[int] Maximum 2D layered surface dimensions - {{endif}} - {{if 'cudaDeviceProp.maxSurfaceCubemap' in found_struct}} + + maxSurfaceCubemap : int Maximum Cubemap surface dimensions - {{endif}} - {{if 'cudaDeviceProp.maxSurfaceCubemapLayered' in found_struct}} + + maxSurfaceCubemapLayered : list[int] Maximum Cubemap layered surface dimensions - {{endif}} - {{if 'cudaDeviceProp.surfaceAlignment' in found_struct}} + + surfaceAlignment : size_t Alignment requirements for surfaces - {{endif}} - {{if 'cudaDeviceProp.concurrentKernels' in found_struct}} + + concurrentKernels : int Device can possibly execute multiple kernels concurrently - {{endif}} - {{if 'cudaDeviceProp.ECCEnabled' in found_struct}} + + ECCEnabled : int Device has ECC support enabled - {{endif}} - {{if 'cudaDeviceProp.pciBusID' in found_struct}} + + pciBusID : int PCI bus ID of the device - {{endif}} - {{if 'cudaDeviceProp.pciDeviceID' in found_struct}} + + pciDeviceID : int PCI device ID of the device - {{endif}} - {{if 'cudaDeviceProp.pciDomainID' in found_struct}} + + pciDomainID : int PCI domain ID of the device - {{endif}} - {{if 'cudaDeviceProp.tccDriver' in found_struct}} + + tccDriver : int 1 if device is a Tesla device using TCC driver, 0 otherwise - {{endif}} - {{if 'cudaDeviceProp.asyncEngineCount' in found_struct}} + + asyncEngineCount : int Number of asynchronous engines - {{endif}} - {{if 'cudaDeviceProp.unifiedAddressing' in found_struct}} + + unifiedAddressing : int Device shares a unified address space with the host - {{endif}} - {{if 'cudaDeviceProp.memoryBusWidth' in found_struct}} + + memoryBusWidth : int Global memory bus width in bits - {{endif}} - {{if 'cudaDeviceProp.l2CacheSize' in found_struct}} + + l2CacheSize : int Size of L2 cache in bytes - {{endif}} - {{if 'cudaDeviceProp.persistingL2CacheMaxSize' in found_struct}} + + persistingL2CacheMaxSize : int Device's maximum l2 persisting lines capacity setting in bytes - {{endif}} - {{if 'cudaDeviceProp.maxThreadsPerMultiProcessor' in found_struct}} + + maxThreadsPerMultiProcessor : int Maximum resident threads per multiprocessor - {{endif}} - {{if 'cudaDeviceProp.streamPrioritiesSupported' in found_struct}} + + streamPrioritiesSupported : int Device supports stream priorities - {{endif}} - {{if 'cudaDeviceProp.globalL1CacheSupported' in found_struct}} + + globalL1CacheSupported : int Device supports caching globals in L1 - {{endif}} - {{if 'cudaDeviceProp.localL1CacheSupported' in found_struct}} + + localL1CacheSupported : int Device supports caching locals in L1 - {{endif}} - {{if 'cudaDeviceProp.sharedMemPerMultiprocessor' in found_struct}} + + sharedMemPerMultiprocessor : size_t Shared memory available per multiprocessor in bytes - {{endif}} - {{if 'cudaDeviceProp.regsPerMultiprocessor' in found_struct}} + + regsPerMultiprocessor : int 32-bit registers available per multiprocessor - {{endif}} - {{if 'cudaDeviceProp.managedMemory' in found_struct}} + + managedMemory : int Device supports allocating managed memory on this system - {{endif}} - {{if 'cudaDeviceProp.isMultiGpuBoard' in found_struct}} + + isMultiGpuBoard : int Device is on a multi-GPU board - {{endif}} - {{if 'cudaDeviceProp.multiGpuBoardGroupID' in found_struct}} + + multiGpuBoardGroupID : int Unique identifier for a group of devices on the same multi-GPU board - {{endif}} - {{if 'cudaDeviceProp.hostNativeAtomicSupported' in found_struct}} + + hostNativeAtomicSupported : int Link between the device and the host supports native atomic operations - {{endif}} - {{if 'cudaDeviceProp.pageableMemoryAccess' in found_struct}} + + pageableMemoryAccess : int Device supports coherently accessing pageable memory without calling cudaHostRegister on it - {{endif}} - {{if 'cudaDeviceProp.concurrentManagedAccess' in found_struct}} + + concurrentManagedAccess : int Device can coherently access managed memory concurrently with the CPU - {{endif}} - {{if 'cudaDeviceProp.computePreemptionSupported' in found_struct}} + + computePreemptionSupported : int Device supports Compute Preemption - {{endif}} - {{if 'cudaDeviceProp.canUseHostPointerForRegisteredMem' in found_struct}} + + canUseHostPointerForRegisteredMem : int Device can access host registered memory at the same virtual address as the CPU - {{endif}} - {{if 'cudaDeviceProp.cooperativeLaunch' in found_struct}} + + cooperativeLaunch : int Device supports launching cooperative kernels via cudaLaunchCooperativeKernel - {{endif}} - {{if 'cudaDeviceProp.sharedMemPerBlockOptin' in found_struct}} + + sharedMemPerBlockOptin : size_t Per device maximum shared memory per block usable by special opt in - {{endif}} - {{if 'cudaDeviceProp.pageableMemoryAccessUsesHostPageTables' in found_struct}} + + pageableMemoryAccessUsesHostPageTables : int Device accesses pageable memory via the host's page tables - {{endif}} - {{if 'cudaDeviceProp.directManagedMemAccessFromHost' in found_struct}} + + directManagedMemAccessFromHost : int Host can directly access managed memory on the device without migration. - {{endif}} - {{if 'cudaDeviceProp.maxBlocksPerMultiProcessor' in found_struct}} + + maxBlocksPerMultiProcessor : int Maximum number of resident blocks per multiprocessor - {{endif}} - {{if 'cudaDeviceProp.accessPolicyMaxWindowSize' in found_struct}} + + accessPolicyMaxWindowSize : int The maximum value of cudaAccessPolicyWindow::num_bytes. - {{endif}} - {{if 'cudaDeviceProp.reservedSharedMemPerBlock' in found_struct}} + + reservedSharedMemPerBlock : size_t Shared memory reserved by CUDA driver per block in bytes - {{endif}} - {{if 'cudaDeviceProp.hostRegisterSupported' in found_struct}} + + hostRegisterSupported : int Device supports host memory registration via cudaHostRegister. - {{endif}} - {{if 'cudaDeviceProp.sparseCudaArraySupported' in found_struct}} + + sparseCudaArraySupported : int 1 if the device supports sparse CUDA arrays and sparse CUDA mipmapped arrays, 0 otherwise - {{endif}} - {{if 'cudaDeviceProp.hostRegisterReadOnlySupported' in found_struct}} + + hostRegisterReadOnlySupported : int Device supports using the cudaHostRegister flag cudaHostRegisterReadOnly to register memory that must be mapped as read-only to the GPU - {{endif}} - {{if 'cudaDeviceProp.timelineSemaphoreInteropSupported' in found_struct}} + + timelineSemaphoreInteropSupported : int External timeline semaphore interop is supported on the device - {{endif}} - {{if 'cudaDeviceProp.memoryPoolsSupported' in found_struct}} + + memoryPoolsSupported : int 1 if the device supports using the cudaMallocAsync and cudaMemPool family of APIs, 0 otherwise - {{endif}} - {{if 'cudaDeviceProp.gpuDirectRDMASupported' in found_struct}} + + gpuDirectRDMASupported : int 1 if the device supports GPUDirect RDMA APIs, 0 otherwise - {{endif}} - {{if 'cudaDeviceProp.gpuDirectRDMAFlushWritesOptions' in found_struct}} + + gpuDirectRDMAFlushWritesOptions : unsigned int Bitmask to be interpreted according to the cudaFlushGPUDirectRDMAWritesOptions enum - {{endif}} - {{if 'cudaDeviceProp.gpuDirectRDMAWritesOrdering' in found_struct}} + + gpuDirectRDMAWritesOrdering : int See the cudaGPUDirectRDMAWritesOrdering enum for numerical values - {{endif}} - {{if 'cudaDeviceProp.memoryPoolSupportedHandleTypes' in found_struct}} + + memoryPoolSupportedHandleTypes : unsigned int Bitmask of handle types supported with mempool-based IPC - {{endif}} - {{if 'cudaDeviceProp.deferredMappingCudaArraySupported' in found_struct}} + + deferredMappingCudaArraySupported : int 1 if the device supports deferred mapping CUDA arrays and CUDA mipmapped arrays - {{endif}} - {{if 'cudaDeviceProp.ipcEventSupported' in found_struct}} + + ipcEventSupported : int Device supports IPC Events. - {{endif}} - {{if 'cudaDeviceProp.clusterLaunch' in found_struct}} + + clusterLaunch : int Indicates device supports cluster launch - {{endif}} - {{if 'cudaDeviceProp.unifiedFunctionPointers' in found_struct}} + + unifiedFunctionPointers : int Indicates device supports unified pointers - {{endif}} - {{if 'cudaDeviceProp.deviceNumaConfig' in found_struct}} + + deviceNumaConfig : int NUMA configuration of a device: value is of type cudaDeviceNumaConfig enum - {{endif}} - {{if 'cudaDeviceProp.deviceNumaId' in found_struct}} + + deviceNumaId : int NUMA node ID of the GPU memory - {{endif}} - {{if 'cudaDeviceProp.mpsEnabled' in found_struct}} + + mpsEnabled : int Indicates if contexts created on this device will be shared via MPS - {{endif}} - {{if 'cudaDeviceProp.hostNumaId' in found_struct}} + + hostNumaId : int NUMA ID of the host node closest to the device or -1 when system does not support NUMA - {{endif}} - {{if 'cudaDeviceProp.gpuPciDeviceID' in found_struct}} + + gpuPciDeviceID : unsigned int The combined 16-bit PCI device ID and 16-bit PCI vendor ID - {{endif}} - {{if 'cudaDeviceProp.gpuPciSubsystemID' in found_struct}} + + gpuPciSubsystemID : unsigned int The combined 16-bit PCI subsystem ID and 16-bit PCI subsystem vendor ID - {{endif}} - {{if 'cudaDeviceProp.hostNumaMultinodeIpcSupported' in found_struct}} + + hostNumaMultinodeIpcSupported : int 1 if the device supports HostNuma location IPC between nodes in a multi-node system. - {{endif}} - {{if 'cudaDeviceProp.reserved' in found_struct}} + + reserved : list[int] Reserved for future use - {{endif}} + Methods ------- @@ -2397,11 +2247,9 @@ cdef class cudaDeviceProp: """ cdef cyruntime.cudaDeviceProp _pvt_val cdef cyruntime.cudaDeviceProp* _pvt_ptr - {{if 'cudaDeviceProp.uuid' in found_struct}} + cdef cudaUUID_t _uuid - {{endif}} -{{endif}} -{{if 'cudaIpcEventHandle_st' in found_struct}} + cdef class cudaIpcEventHandle_st: """ @@ -2409,10 +2257,10 @@ cdef class cudaIpcEventHandle_st: Attributes ---------- - {{if 'cudaIpcEventHandle_st.reserved' in found_struct}} + reserved : bytes - {{endif}} + Methods ------- @@ -2421,8 +2269,6 @@ cdef class cudaIpcEventHandle_st: """ cdef cyruntime.cudaIpcEventHandle_st _pvt_val cdef cyruntime.cudaIpcEventHandle_st* _pvt_ptr -{{endif}} -{{if 'cudaIpcMemHandle_st' in found_struct}} cdef class cudaIpcMemHandle_st: """ @@ -2430,10 +2276,10 @@ cdef class cudaIpcMemHandle_st: Attributes ---------- - {{if 'cudaIpcMemHandle_st.reserved' in found_struct}} + reserved : bytes - {{endif}} + Methods ------- @@ -2442,17 +2288,15 @@ cdef class cudaIpcMemHandle_st: """ cdef cyruntime.cudaIpcMemHandle_st _pvt_val cdef cyruntime.cudaIpcMemHandle_st* _pvt_ptr -{{endif}} -{{if 'cudaMemFabricHandle_st' in found_struct}} cdef class cudaMemFabricHandle_st: """ Attributes ---------- - {{if 'cudaMemFabricHandle_st.reserved' in found_struct}} + reserved : bytes - {{endif}} + Methods ------- @@ -2461,21 +2305,19 @@ cdef class cudaMemFabricHandle_st: """ cdef cyruntime.cudaMemFabricHandle_st _pvt_val cdef cyruntime.cudaMemFabricHandle_st* _pvt_ptr -{{endif}} -{{if 'cudaExternalMemoryHandleDesc.handle.win32' in found_struct}} cdef class anon_struct8: """ Attributes ---------- - {{if 'cudaExternalMemoryHandleDesc.handle.win32.handle' in found_struct}} + handle : Any - {{endif}} - {{if 'cudaExternalMemoryHandleDesc.handle.win32.name' in found_struct}} + + name : Any - {{endif}} + Methods ------- @@ -2483,31 +2325,29 @@ cdef class anon_struct8: Get memory address of class instance """ cdef cyruntime.cudaExternalMemoryHandleDesc* _pvt_ptr - {{if 'cudaExternalMemoryHandleDesc.handle.win32.handle' in found_struct}} + cdef _HelperInputVoidPtr _cyhandle - {{endif}} - {{if 'cudaExternalMemoryHandleDesc.handle.win32.name' in found_struct}} + + cdef _HelperInputVoidPtr _cyname - {{endif}} -{{endif}} -{{if 'cudaExternalMemoryHandleDesc.handle' in found_struct}} + cdef class anon_union3: """ Attributes ---------- - {{if 'cudaExternalMemoryHandleDesc.handle.fd' in found_struct}} + fd : int - {{endif}} - {{if 'cudaExternalMemoryHandleDesc.handle.win32' in found_struct}} + + win32 : anon_struct8 - {{endif}} - {{if 'cudaExternalMemoryHandleDesc.handle.nvSciBufObject' in found_struct}} + + nvSciBufObject : Any - {{endif}} + Methods ------- @@ -2515,14 +2355,12 @@ cdef class anon_union3: Get memory address of class instance """ cdef cyruntime.cudaExternalMemoryHandleDesc* _pvt_ptr - {{if 'cudaExternalMemoryHandleDesc.handle.win32' in found_struct}} + cdef anon_struct8 _win32 - {{endif}} - {{if 'cudaExternalMemoryHandleDesc.handle.nvSciBufObject' in found_struct}} + + cdef _HelperInputVoidPtr _cynvSciBufObject - {{endif}} -{{endif}} -{{if 'cudaExternalMemoryHandleDesc' in found_struct}} + cdef class cudaExternalMemoryHandleDesc: """ @@ -2530,26 +2368,26 @@ cdef class cudaExternalMemoryHandleDesc: Attributes ---------- - {{if 'cudaExternalMemoryHandleDesc.type' in found_struct}} + type : cudaExternalMemoryHandleType Type of the handle - {{endif}} - {{if 'cudaExternalMemoryHandleDesc.handle' in found_struct}} + + handle : anon_union3 - {{endif}} - {{if 'cudaExternalMemoryHandleDesc.size' in found_struct}} + + size : unsigned long long Size of the memory allocation - {{endif}} - {{if 'cudaExternalMemoryHandleDesc.flags' in found_struct}} + + flags : unsigned int Flags must either be zero or cudaExternalMemoryDedicated - {{endif}} - {{if 'cudaExternalMemoryHandleDesc.reserved' in found_struct}} + + reserved : list[unsigned int] Must be zero - {{endif}} + Methods ------- @@ -2558,11 +2396,9 @@ cdef class cudaExternalMemoryHandleDesc: """ cdef cyruntime.cudaExternalMemoryHandleDesc* _val_ptr cdef cyruntime.cudaExternalMemoryHandleDesc* _pvt_ptr - {{if 'cudaExternalMemoryHandleDesc.handle' in found_struct}} + cdef anon_union3 _handle - {{endif}} -{{endif}} -{{if 'cudaExternalMemoryBufferDesc' in found_struct}} + cdef class cudaExternalMemoryBufferDesc: """ @@ -2570,22 +2406,22 @@ cdef class cudaExternalMemoryBufferDesc: Attributes ---------- - {{if 'cudaExternalMemoryBufferDesc.offset' in found_struct}} + offset : unsigned long long Offset into the memory object where the buffer's base is - {{endif}} - {{if 'cudaExternalMemoryBufferDesc.size' in found_struct}} + + size : unsigned long long Size of the buffer - {{endif}} - {{if 'cudaExternalMemoryBufferDesc.flags' in found_struct}} + + flags : unsigned int Flags reserved for future use. Must be zero. - {{endif}} - {{if 'cudaExternalMemoryBufferDesc.reserved' in found_struct}} + + reserved : list[unsigned int] Must be zero - {{endif}} + Methods ------- @@ -2594,8 +2430,6 @@ cdef class cudaExternalMemoryBufferDesc: """ cdef cyruntime.cudaExternalMemoryBufferDesc _pvt_val cdef cyruntime.cudaExternalMemoryBufferDesc* _pvt_ptr -{{endif}} -{{if 'cudaExternalMemoryMipmappedArrayDesc' in found_struct}} cdef class cudaExternalMemoryMipmappedArrayDesc: """ @@ -2603,32 +2437,32 @@ cdef class cudaExternalMemoryMipmappedArrayDesc: Attributes ---------- - {{if 'cudaExternalMemoryMipmappedArrayDesc.offset' in found_struct}} + offset : unsigned long long Offset into the memory object where the base level of the mipmap chain is. - {{endif}} - {{if 'cudaExternalMemoryMipmappedArrayDesc.formatDesc' in found_struct}} + + formatDesc : cudaChannelFormatDesc Format of base level of the mipmap chain - {{endif}} - {{if 'cudaExternalMemoryMipmappedArrayDesc.extent' in found_struct}} + + extent : cudaExtent Dimensions of base level of the mipmap chain - {{endif}} - {{if 'cudaExternalMemoryMipmappedArrayDesc.flags' in found_struct}} + + flags : unsigned int Flags associated with CUDA mipmapped arrays. See cudaMallocMipmappedArray - {{endif}} - {{if 'cudaExternalMemoryMipmappedArrayDesc.numLevels' in found_struct}} + + numLevels : unsigned int Total number of levels in the mipmap chain - {{endif}} - {{if 'cudaExternalMemoryMipmappedArrayDesc.reserved' in found_struct}} + + reserved : list[unsigned int] Must be zero - {{endif}} + Methods ------- @@ -2637,27 +2471,25 @@ cdef class cudaExternalMemoryMipmappedArrayDesc: """ cdef cyruntime.cudaExternalMemoryMipmappedArrayDesc _pvt_val cdef cyruntime.cudaExternalMemoryMipmappedArrayDesc* _pvt_ptr - {{if 'cudaExternalMemoryMipmappedArrayDesc.formatDesc' in found_struct}} + cdef cudaChannelFormatDesc _formatDesc - {{endif}} - {{if 'cudaExternalMemoryMipmappedArrayDesc.extent' in found_struct}} + + cdef cudaExtent _extent - {{endif}} -{{endif}} -{{if 'cudaExternalSemaphoreHandleDesc.handle.win32' in found_struct}} + cdef class anon_struct9: """ Attributes ---------- - {{if 'cudaExternalSemaphoreHandleDesc.handle.win32.handle' in found_struct}} + handle : Any - {{endif}} - {{if 'cudaExternalSemaphoreHandleDesc.handle.win32.name' in found_struct}} + + name : Any - {{endif}} + Methods ------- @@ -2665,31 +2497,29 @@ cdef class anon_struct9: Get memory address of class instance """ cdef cyruntime.cudaExternalSemaphoreHandleDesc* _pvt_ptr - {{if 'cudaExternalSemaphoreHandleDesc.handle.win32.handle' in found_struct}} + cdef _HelperInputVoidPtr _cyhandle - {{endif}} - {{if 'cudaExternalSemaphoreHandleDesc.handle.win32.name' in found_struct}} + + cdef _HelperInputVoidPtr _cyname - {{endif}} -{{endif}} -{{if 'cudaExternalSemaphoreHandleDesc.handle' in found_struct}} + cdef class anon_union4: """ Attributes ---------- - {{if 'cudaExternalSemaphoreHandleDesc.handle.fd' in found_struct}} + fd : int - {{endif}} - {{if 'cudaExternalSemaphoreHandleDesc.handle.win32' in found_struct}} + + win32 : anon_struct9 - {{endif}} - {{if 'cudaExternalSemaphoreHandleDesc.handle.nvSciSyncObj' in found_struct}} + + nvSciSyncObj : Any - {{endif}} + Methods ------- @@ -2697,14 +2527,12 @@ cdef class anon_union4: Get memory address of class instance """ cdef cyruntime.cudaExternalSemaphoreHandleDesc* _pvt_ptr - {{if 'cudaExternalSemaphoreHandleDesc.handle.win32' in found_struct}} + cdef anon_struct9 _win32 - {{endif}} - {{if 'cudaExternalSemaphoreHandleDesc.handle.nvSciSyncObj' in found_struct}} + + cdef _HelperInputVoidPtr _cynvSciSyncObj - {{endif}} -{{endif}} -{{if 'cudaExternalSemaphoreHandleDesc' in found_struct}} + cdef class cudaExternalSemaphoreHandleDesc: """ @@ -2712,22 +2540,22 @@ cdef class cudaExternalSemaphoreHandleDesc: Attributes ---------- - {{if 'cudaExternalSemaphoreHandleDesc.type' in found_struct}} + type : cudaExternalSemaphoreHandleType Type of the handle - {{endif}} - {{if 'cudaExternalSemaphoreHandleDesc.handle' in found_struct}} + + handle : anon_union4 - {{endif}} - {{if 'cudaExternalSemaphoreHandleDesc.flags' in found_struct}} + + flags : unsigned int Flags reserved for the future. Must be zero. - {{endif}} - {{if 'cudaExternalSemaphoreHandleDesc.reserved' in found_struct}} + + reserved : list[unsigned int] Must be zero - {{endif}} + Methods ------- @@ -2736,20 +2564,18 @@ cdef class cudaExternalSemaphoreHandleDesc: """ cdef cyruntime.cudaExternalSemaphoreHandleDesc* _val_ptr cdef cyruntime.cudaExternalSemaphoreHandleDesc* _pvt_ptr - {{if 'cudaExternalSemaphoreHandleDesc.handle' in found_struct}} + cdef anon_union4 _handle - {{endif}} -{{endif}} -{{if 'cudaExternalSemaphoreSignalParams.params.fence' in found_struct}} + cdef class anon_struct10: """ Attributes ---------- - {{if 'cudaExternalSemaphoreSignalParams.params.fence.value' in found_struct}} + value : unsigned long long - {{endif}} + Methods ------- @@ -2757,21 +2583,19 @@ cdef class anon_struct10: Get memory address of class instance """ cdef cyruntime.cudaExternalSemaphoreSignalParams* _pvt_ptr -{{endif}} -{{if 'cudaExternalSemaphoreSignalParams.params.nvSciSync' in found_struct}} cdef class anon_union5: """ Attributes ---------- - {{if 'cudaExternalSemaphoreSignalParams.params.nvSciSync.fence' in found_struct}} + fence : Any - {{endif}} - {{if 'cudaExternalSemaphoreSignalParams.params.nvSciSync.reserved' in found_struct}} + + reserved : unsigned long long - {{endif}} + Methods ------- @@ -2779,20 +2603,18 @@ cdef class anon_union5: Get memory address of class instance """ cdef cyruntime.cudaExternalSemaphoreSignalParams* _pvt_ptr - {{if 'cudaExternalSemaphoreSignalParams.params.nvSciSync.fence' in found_struct}} + cdef _HelperInputVoidPtr _cyfence - {{endif}} -{{endif}} -{{if 'cudaExternalSemaphoreSignalParams.params.keyedMutex' in found_struct}} + cdef class anon_struct11: """ Attributes ---------- - {{if 'cudaExternalSemaphoreSignalParams.params.keyedMutex.key' in found_struct}} + key : unsigned long long - {{endif}} + Methods ------- @@ -2800,29 +2622,27 @@ cdef class anon_struct11: Get memory address of class instance """ cdef cyruntime.cudaExternalSemaphoreSignalParams* _pvt_ptr -{{endif}} -{{if 'cudaExternalSemaphoreSignalParams.params' in found_struct}} cdef class anon_struct12: """ Attributes ---------- - {{if 'cudaExternalSemaphoreSignalParams.params.fence' in found_struct}} + fence : anon_struct10 - {{endif}} - {{if 'cudaExternalSemaphoreSignalParams.params.nvSciSync' in found_struct}} + + nvSciSync : anon_union5 - {{endif}} - {{if 'cudaExternalSemaphoreSignalParams.params.keyedMutex' in found_struct}} + + keyedMutex : anon_struct11 - {{endif}} - {{if 'cudaExternalSemaphoreSignalParams.params.reserved' in found_struct}} + + reserved : list[unsigned int] - {{endif}} + Methods ------- @@ -2830,17 +2650,15 @@ cdef class anon_struct12: Get memory address of class instance """ cdef cyruntime.cudaExternalSemaphoreSignalParams* _pvt_ptr - {{if 'cudaExternalSemaphoreSignalParams.params.fence' in found_struct}} + cdef anon_struct10 _fence - {{endif}} - {{if 'cudaExternalSemaphoreSignalParams.params.nvSciSync' in found_struct}} + + cdef anon_union5 _nvSciSync - {{endif}} - {{if 'cudaExternalSemaphoreSignalParams.params.keyedMutex' in found_struct}} + + cdef anon_struct11 _keyedMutex - {{endif}} -{{endif}} -{{if 'cudaExternalSemaphoreSignalParams' in found_struct}} + cdef class cudaExternalSemaphoreSignalParams: """ @@ -2848,11 +2666,11 @@ cdef class cudaExternalSemaphoreSignalParams: Attributes ---------- - {{if 'cudaExternalSemaphoreSignalParams.params' in found_struct}} + params : anon_struct12 - {{endif}} - {{if 'cudaExternalSemaphoreSignalParams.flags' in found_struct}} + + flags : unsigned int Only when cudaExternalSemaphoreSignalParams is used to signal a cudaExternalSemaphore_t of type @@ -2862,11 +2680,11 @@ cdef class cudaExternalSemaphoreSignalParams: synchronization operations should be performed for any external memory object imported as cudaExternalMemoryHandleTypeNvSciBuf. For all other types of cudaExternalSemaphore_t, flags must be zero. - {{endif}} - {{if 'cudaExternalSemaphoreSignalParams.reserved' in found_struct}} + + reserved : list[unsigned int] - {{endif}} + Methods ------- @@ -2875,20 +2693,18 @@ cdef class cudaExternalSemaphoreSignalParams: """ cdef cyruntime.cudaExternalSemaphoreSignalParams _pvt_val cdef cyruntime.cudaExternalSemaphoreSignalParams* _pvt_ptr - {{if 'cudaExternalSemaphoreSignalParams.params' in found_struct}} + cdef anon_struct12 _params - {{endif}} -{{endif}} -{{if 'cudaExternalSemaphoreWaitParams.params.fence' in found_struct}} + cdef class anon_struct13: """ Attributes ---------- - {{if 'cudaExternalSemaphoreWaitParams.params.fence.value' in found_struct}} + value : unsigned long long - {{endif}} + Methods ------- @@ -2896,21 +2712,19 @@ cdef class anon_struct13: Get memory address of class instance """ cdef cyruntime.cudaExternalSemaphoreWaitParams* _pvt_ptr -{{endif}} -{{if 'cudaExternalSemaphoreWaitParams.params.nvSciSync' in found_struct}} cdef class anon_union6: """ Attributes ---------- - {{if 'cudaExternalSemaphoreWaitParams.params.nvSciSync.fence' in found_struct}} + fence : Any - {{endif}} - {{if 'cudaExternalSemaphoreWaitParams.params.nvSciSync.reserved' in found_struct}} + + reserved : unsigned long long - {{endif}} + Methods ------- @@ -2918,24 +2732,22 @@ cdef class anon_union6: Get memory address of class instance """ cdef cyruntime.cudaExternalSemaphoreWaitParams* _pvt_ptr - {{if 'cudaExternalSemaphoreWaitParams.params.nvSciSync.fence' in found_struct}} + cdef _HelperInputVoidPtr _cyfence - {{endif}} -{{endif}} -{{if 'cudaExternalSemaphoreWaitParams.params.keyedMutex' in found_struct}} + cdef class anon_struct14: """ Attributes ---------- - {{if 'cudaExternalSemaphoreWaitParams.params.keyedMutex.key' in found_struct}} + key : unsigned long long - {{endif}} - {{if 'cudaExternalSemaphoreWaitParams.params.keyedMutex.timeoutMs' in found_struct}} + + timeoutMs : unsigned int - {{endif}} + Methods ------- @@ -2943,29 +2755,27 @@ cdef class anon_struct14: Get memory address of class instance """ cdef cyruntime.cudaExternalSemaphoreWaitParams* _pvt_ptr -{{endif}} -{{if 'cudaExternalSemaphoreWaitParams.params' in found_struct}} cdef class anon_struct15: """ Attributes ---------- - {{if 'cudaExternalSemaphoreWaitParams.params.fence' in found_struct}} + fence : anon_struct13 - {{endif}} - {{if 'cudaExternalSemaphoreWaitParams.params.nvSciSync' in found_struct}} + + nvSciSync : anon_union6 - {{endif}} - {{if 'cudaExternalSemaphoreWaitParams.params.keyedMutex' in found_struct}} + + keyedMutex : anon_struct14 - {{endif}} - {{if 'cudaExternalSemaphoreWaitParams.params.reserved' in found_struct}} + + reserved : list[unsigned int] - {{endif}} + Methods ------- @@ -2973,17 +2783,15 @@ cdef class anon_struct15: Get memory address of class instance """ cdef cyruntime.cudaExternalSemaphoreWaitParams* _pvt_ptr - {{if 'cudaExternalSemaphoreWaitParams.params.fence' in found_struct}} + cdef anon_struct13 _fence - {{endif}} - {{if 'cudaExternalSemaphoreWaitParams.params.nvSciSync' in found_struct}} + + cdef anon_union6 _nvSciSync - {{endif}} - {{if 'cudaExternalSemaphoreWaitParams.params.keyedMutex' in found_struct}} + + cdef anon_struct14 _keyedMutex - {{endif}} -{{endif}} -{{if 'cudaExternalSemaphoreWaitParams' in found_struct}} + cdef class cudaExternalSemaphoreWaitParams: """ @@ -2991,11 +2799,11 @@ cdef class cudaExternalSemaphoreWaitParams: Attributes ---------- - {{if 'cudaExternalSemaphoreWaitParams.params' in found_struct}} + params : anon_struct15 - {{endif}} - {{if 'cudaExternalSemaphoreWaitParams.flags' in found_struct}} + + flags : unsigned int Only when cudaExternalSemaphoreSignalParams is used to signal a cudaExternalSemaphore_t of type @@ -3005,11 +2813,11 @@ cdef class cudaExternalSemaphoreWaitParams: synchronization operations should be performed for any external memory object imported as cudaExternalMemoryHandleTypeNvSciBuf. For all other types of cudaExternalSemaphore_t, flags must be zero. - {{endif}} - {{if 'cudaExternalSemaphoreWaitParams.reserved' in found_struct}} + + reserved : list[unsigned int] - {{endif}} + Methods ------- @@ -3018,11 +2826,9 @@ cdef class cudaExternalSemaphoreWaitParams: """ cdef cyruntime.cudaExternalSemaphoreWaitParams _pvt_val cdef cyruntime.cudaExternalSemaphoreWaitParams* _pvt_ptr - {{if 'cudaExternalSemaphoreWaitParams.params' in found_struct}} + cdef anon_struct15 _params - {{endif}} -{{endif}} -{{if 'cudaDevSmResource' in found_struct}} + cdef class cudaDevSmResource: """ @@ -3031,27 +2837,27 @@ cdef class cudaDevSmResource: Attributes ---------- - {{if 'cudaDevSmResource.smCount' in found_struct}} + smCount : unsigned int The amount of streaming multiprocessors available in this resource. - {{endif}} - {{if 'cudaDevSmResource.minSmPartitionSize' in found_struct}} + + minSmPartitionSize : unsigned int The minimum number of streaming multiprocessors required to partition this resource. - {{endif}} - {{if 'cudaDevSmResource.smCoscheduledAlignment' in found_struct}} + + smCoscheduledAlignment : unsigned int The number of streaming multiprocessors in this resource that are guaranteed to be co-scheduled on the same GPU processing cluster. smCount will be a multiple of this value, unless the backfill flag is set. - {{endif}} - {{if 'cudaDevSmResource.flags' in found_struct}} + + flags : unsigned int The flags set on this SM resource. For available flags see cudaDevSmResourceGroup_flags. - {{endif}} + Methods ------- @@ -3060,8 +2866,6 @@ cdef class cudaDevSmResource: """ cdef cyruntime.cudaDevSmResource _pvt_val cdef cyruntime.cudaDevSmResource* _pvt_ptr -{{endif}} -{{if 'cudaDevWorkqueueConfigResource' in found_struct}} cdef class cudaDevWorkqueueConfigResource: """ @@ -3069,18 +2873,18 @@ cdef class cudaDevWorkqueueConfigResource: Attributes ---------- - {{if 'cudaDevWorkqueueConfigResource.device' in found_struct}} + device : int The device on which the workqueue resources are available - {{endif}} - {{if 'cudaDevWorkqueueConfigResource.wqConcurrencyLimit' in found_struct}} + + wqConcurrencyLimit : unsigned int The expected maximum number of concurrent stream-ordered workloads - {{endif}} - {{if 'cudaDevWorkqueueConfigResource.sharingScope' in found_struct}} + + sharingScope : cudaDevWorkqueueConfigScope The sharing scope for the workqueue resources - {{endif}} + Methods ------- @@ -3089,8 +2893,6 @@ cdef class cudaDevWorkqueueConfigResource: """ cdef cyruntime.cudaDevWorkqueueConfigResource _pvt_val cdef cyruntime.cudaDevWorkqueueConfigResource* _pvt_ptr -{{endif}} -{{if 'cudaDevWorkqueueResource' in found_struct}} cdef class cudaDevWorkqueueResource: """ @@ -3098,10 +2900,10 @@ cdef class cudaDevWorkqueueResource: Attributes ---------- - {{if 'cudaDevWorkqueueResource.reserved' in found_struct}} + reserved : bytes Reserved for future use - {{endif}} + Methods ------- @@ -3110,8 +2912,6 @@ cdef class cudaDevWorkqueueResource: """ cdef cyruntime.cudaDevWorkqueueResource _pvt_val cdef cyruntime.cudaDevWorkqueueResource* _pvt_ptr -{{endif}} -{{if 'cudaDevSmResourceGroupParams_st' in found_struct}} cdef class cudaDevSmResourceGroupParams_st: """ @@ -3119,29 +2919,29 @@ cdef class cudaDevSmResourceGroupParams_st: Attributes ---------- - {{if 'cudaDevSmResourceGroupParams_st.smCount' in found_struct}} + smCount : unsigned int The amount of SMs available in this resource. - {{endif}} - {{if 'cudaDevSmResourceGroupParams_st.coscheduledSmCount' in found_struct}} + + coscheduledSmCount : unsigned int The amount of co-scheduled SMs grouped together for locality purposes. - {{endif}} - {{if 'cudaDevSmResourceGroupParams_st.preferredCoscheduledSmCount' in found_struct}} + + preferredCoscheduledSmCount : unsigned int When possible, combine co-scheduled groups together into larger groups of this size. - {{endif}} - {{if 'cudaDevSmResourceGroupParams_st.flags' in found_struct}} + + flags : unsigned int Combination of `cudaDevSmResourceGroup_flags` values to indicate this this group is created. - {{endif}} - {{if 'cudaDevSmResourceGroupParams_st.reserved' in found_struct}} + + reserved : list[unsigned int] Reserved for future use - ensure this is zero initialized. - {{endif}} + Methods ------- @@ -3150,8 +2950,6 @@ cdef class cudaDevSmResourceGroupParams_st: """ cdef cyruntime.cudaDevSmResourceGroupParams_st _pvt_val cdef cyruntime.cudaDevSmResourceGroupParams_st* _pvt_ptr -{{endif}} -{{if 'cudaDevResource_st' in found_struct}} cdef class cudaDevResource_st: """ @@ -3173,35 +2971,35 @@ cdef class cudaDevResource_st: Attributes ---------- - {{if 'cudaDevResource_st.type' in found_struct}} + type : cudaDevResourceType Type of resource, dictates which union field was last set - {{endif}} - {{if 'cudaDevResource_st._internal_padding' in found_struct}} + + _internal_padding : bytes - {{endif}} - {{if 'cudaDevResource_st.sm' in found_struct}} + + sm : cudaDevSmResource Resource corresponding to cudaDevResourceTypeSm `typename`. - {{endif}} - {{if 'cudaDevResource_st.wqConfig' in found_struct}} + + wqConfig : cudaDevWorkqueueConfigResource Resource corresponding to cudaDevResourceTypeWorkqueueConfig `typename`. - {{endif}} - {{if 'cudaDevResource_st.wq' in found_struct}} + + wq : cudaDevWorkqueueResource Resource corresponding to cudaDevResourceTypeWorkqueue `typename`. - {{endif}} - {{if 'cudaDevResource_st._oversize' in found_struct}} + + _oversize : bytes - {{endif}} - {{if 'cudaDevResource_st.nextResource' in found_struct}} + + nextResource : cudaDevResource_st - {{endif}} + Methods ------- @@ -3210,42 +3008,40 @@ cdef class cudaDevResource_st: """ cdef cyruntime.cudaDevResource_st* _val_ptr cdef cyruntime.cudaDevResource_st* _pvt_ptr - {{if 'cudaDevResource_st.sm' in found_struct}} + cdef cudaDevSmResource _sm - {{endif}} - {{if 'cudaDevResource_st.wqConfig' in found_struct}} + + cdef cudaDevWorkqueueConfigResource _wqConfig - {{endif}} - {{if 'cudaDevResource_st.wq' in found_struct}} + + cdef cudaDevWorkqueueResource _wq - {{endif}} - {{if 'cudaDevResource_st.nextResource' in found_struct}} + + cdef size_t _nextResource_length cdef cyruntime.cudaDevResource_st* _nextResource - {{endif}} -{{endif}} -{{if 'cudalibraryHostUniversalFunctionAndDataTable' in found_struct}} + cdef class cudalibraryHostUniversalFunctionAndDataTable: """ Attributes ---------- - {{if 'cudalibraryHostUniversalFunctionAndDataTable.functionTable' in found_struct}} + functionTable : Any - {{endif}} - {{if 'cudalibraryHostUniversalFunctionAndDataTable.functionWindowSize' in found_struct}} + + functionWindowSize : size_t - {{endif}} - {{if 'cudalibraryHostUniversalFunctionAndDataTable.dataTable' in found_struct}} + + dataTable : Any - {{endif}} - {{if 'cudalibraryHostUniversalFunctionAndDataTable.dataWindowSize' in found_struct}} + + dataWindowSize : size_t - {{endif}} + Methods ------- @@ -3254,14 +3050,12 @@ cdef class cudalibraryHostUniversalFunctionAndDataTable: """ cdef cyruntime.cudalibraryHostUniversalFunctionAndDataTable _pvt_val cdef cyruntime.cudalibraryHostUniversalFunctionAndDataTable* _pvt_ptr - {{if 'cudalibraryHostUniversalFunctionAndDataTable.functionTable' in found_struct}} + cdef _HelperInputVoidPtr _cyfunctionTable - {{endif}} - {{if 'cudalibraryHostUniversalFunctionAndDataTable.dataTable' in found_struct}} + + cdef _HelperInputVoidPtr _cydataTable - {{endif}} -{{endif}} -{{if 'cudaKernelNodeParams' in found_struct}} + cdef class cudaKernelNodeParams: """ @@ -3269,30 +3063,30 @@ cdef class cudaKernelNodeParams: Attributes ---------- - {{if 'cudaKernelNodeParams.func' in found_struct}} + func : Any Kernel to launch - {{endif}} - {{if 'cudaKernelNodeParams.gridDim' in found_struct}} + + gridDim : dim3 Grid dimensions - {{endif}} - {{if 'cudaKernelNodeParams.blockDim' in found_struct}} + + blockDim : dim3 Block dimensions - {{endif}} - {{if 'cudaKernelNodeParams.sharedMemBytes' in found_struct}} + + sharedMemBytes : unsigned int Dynamic shared-memory size per thread block in bytes - {{endif}} - {{if 'cudaKernelNodeParams.kernelParams' in found_struct}} + + kernelParams : Any Array of pointers to individual kernel arguments - {{endif}} - {{if 'cudaKernelNodeParams.extra' in found_struct}} + + extra : Any Pointer to kernel arguments in the "extra" format - {{endif}} + Methods ------- @@ -3301,20 +3095,18 @@ cdef class cudaKernelNodeParams: """ cdef cyruntime.cudaKernelNodeParams _pvt_val cdef cyruntime.cudaKernelNodeParams* _pvt_ptr - {{if 'cudaKernelNodeParams.func' in found_struct}} + cdef _HelperInputVoidPtr _cyfunc - {{endif}} - {{if 'cudaKernelNodeParams.gridDim' in found_struct}} + + cdef dim3 _gridDim - {{endif}} - {{if 'cudaKernelNodeParams.blockDim' in found_struct}} + + cdef dim3 _blockDim - {{endif}} - {{if 'cudaKernelNodeParams.kernelParams' in found_struct}} + + cdef _HelperKernelParams _cykernelParams - {{endif}} -{{endif}} -{{if 'cudaKernelNodeParamsV2' in found_struct}} + cdef class cudaKernelNodeParamsV2: """ @@ -3322,47 +3114,47 @@ cdef class cudaKernelNodeParamsV2: Attributes ---------- - {{if 'cudaKernelNodeParamsV2.func' in found_struct}} + func : Any functionType = cudaKernelFucntionTypeDevice - {{endif}} - {{if 'cudaKernelNodeParamsV2.kern' in found_struct}} + + kern : cudaKernel_t functionType = cudaKernelFucntionTypeKernel - {{endif}} - {{if 'cudaKernelNodeParamsV2.cuFunc' in found_struct}} + + cuFunc : cudaFunction_t functionType = cudaKernelFucntionTypeFunction - {{endif}} - {{if 'cudaKernelNodeParamsV2.gridDim' in found_struct}} + + gridDim : dim3 Grid dimensions - {{endif}} - {{if 'cudaKernelNodeParamsV2.blockDim' in found_struct}} + + blockDim : dim3 Block dimensions - {{endif}} - {{if 'cudaKernelNodeParamsV2.sharedMemBytes' in found_struct}} + + sharedMemBytes : unsigned int Dynamic shared-memory size per thread block in bytes - {{endif}} - {{if 'cudaKernelNodeParamsV2.kernelParams' in found_struct}} + + kernelParams : Any Array of pointers to individual kernel arguments - {{endif}} - {{if 'cudaKernelNodeParamsV2.extra' in found_struct}} + + extra : Any Pointer to kernel arguments in the "extra" format - {{endif}} - {{if 'cudaKernelNodeParamsV2.ctx' in found_struct}} + + ctx : cudaExecutionContext_t Context in which to run the kernel. If NULL will try to use the current context. - {{endif}} - {{if 'cudaKernelNodeParamsV2.functionType' in found_struct}} + + functionType : cudaKernelFunctionType Type of handle passed in the func/kern/cuFunc union above - {{endif}} + Methods ------- @@ -3371,29 +3163,27 @@ cdef class cudaKernelNodeParamsV2: """ cdef cyruntime.cudaKernelNodeParamsV2* _val_ptr cdef cyruntime.cudaKernelNodeParamsV2* _pvt_ptr - {{if 'cudaKernelNodeParamsV2.func' in found_struct}} + cdef _HelperInputVoidPtr _cyfunc - {{endif}} - {{if 'cudaKernelNodeParamsV2.kern' in found_struct}} + + cdef cudaKernel_t _kern - {{endif}} - {{if 'cudaKernelNodeParamsV2.cuFunc' in found_struct}} + + cdef cudaFunction_t _cuFunc - {{endif}} - {{if 'cudaKernelNodeParamsV2.gridDim' in found_struct}} + + cdef dim3 _gridDim - {{endif}} - {{if 'cudaKernelNodeParamsV2.blockDim' in found_struct}} + + cdef dim3 _blockDim - {{endif}} - {{if 'cudaKernelNodeParamsV2.kernelParams' in found_struct}} + + cdef _HelperKernelParams _cykernelParams - {{endif}} - {{if 'cudaKernelNodeParamsV2.ctx' in found_struct}} + + cdef cudaExecutionContext_t _ctx - {{endif}} -{{endif}} -{{if 'cudaExternalSemaphoreSignalNodeParams' in found_struct}} + cdef class cudaExternalSemaphoreSignalNodeParams: """ @@ -3401,19 +3191,19 @@ cdef class cudaExternalSemaphoreSignalNodeParams: Attributes ---------- - {{if 'cudaExternalSemaphoreSignalNodeParams.extSemArray' in found_struct}} + extSemArray : cudaExternalSemaphore_t Array of external semaphore handles. - {{endif}} - {{if 'cudaExternalSemaphoreSignalNodeParams.paramsArray' in found_struct}} + + paramsArray : cudaExternalSemaphoreSignalParams Array of external semaphore signal parameters. - {{endif}} - {{if 'cudaExternalSemaphoreSignalNodeParams.numExtSems' in found_struct}} + + numExtSems : unsigned int Number of handles and parameters supplied in extSemArray and paramsArray. - {{endif}} + Methods ------- @@ -3422,16 +3212,14 @@ cdef class cudaExternalSemaphoreSignalNodeParams: """ cdef cyruntime.cudaExternalSemaphoreSignalNodeParams _pvt_val cdef cyruntime.cudaExternalSemaphoreSignalNodeParams* _pvt_ptr - {{if 'cudaExternalSemaphoreSignalNodeParams.extSemArray' in found_struct}} + cdef size_t _extSemArray_length cdef cyruntime.cudaExternalSemaphore_t* _extSemArray - {{endif}} - {{if 'cudaExternalSemaphoreSignalNodeParams.paramsArray' in found_struct}} + + cdef size_t _paramsArray_length cdef cyruntime.cudaExternalSemaphoreSignalParams* _paramsArray - {{endif}} -{{endif}} -{{if 'cudaExternalSemaphoreSignalNodeParamsV2' in found_struct}} + cdef class cudaExternalSemaphoreSignalNodeParamsV2: """ @@ -3439,19 +3227,19 @@ cdef class cudaExternalSemaphoreSignalNodeParamsV2: Attributes ---------- - {{if 'cudaExternalSemaphoreSignalNodeParamsV2.extSemArray' in found_struct}} + extSemArray : cudaExternalSemaphore_t Array of external semaphore handles. - {{endif}} - {{if 'cudaExternalSemaphoreSignalNodeParamsV2.paramsArray' in found_struct}} + + paramsArray : cudaExternalSemaphoreSignalParams Array of external semaphore signal parameters. - {{endif}} - {{if 'cudaExternalSemaphoreSignalNodeParamsV2.numExtSems' in found_struct}} + + numExtSems : unsigned int Number of handles and parameters supplied in extSemArray and paramsArray. - {{endif}} + Methods ------- @@ -3460,16 +3248,14 @@ cdef class cudaExternalSemaphoreSignalNodeParamsV2: """ cdef cyruntime.cudaExternalSemaphoreSignalNodeParamsV2 _pvt_val cdef cyruntime.cudaExternalSemaphoreSignalNodeParamsV2* _pvt_ptr - {{if 'cudaExternalSemaphoreSignalNodeParamsV2.extSemArray' in found_struct}} + cdef size_t _extSemArray_length cdef cyruntime.cudaExternalSemaphore_t* _extSemArray - {{endif}} - {{if 'cudaExternalSemaphoreSignalNodeParamsV2.paramsArray' in found_struct}} + + cdef size_t _paramsArray_length cdef cyruntime.cudaExternalSemaphoreSignalParams* _paramsArray - {{endif}} -{{endif}} -{{if 'cudaExternalSemaphoreWaitNodeParams' in found_struct}} + cdef class cudaExternalSemaphoreWaitNodeParams: """ @@ -3477,19 +3263,19 @@ cdef class cudaExternalSemaphoreWaitNodeParams: Attributes ---------- - {{if 'cudaExternalSemaphoreWaitNodeParams.extSemArray' in found_struct}} + extSemArray : cudaExternalSemaphore_t Array of external semaphore handles. - {{endif}} - {{if 'cudaExternalSemaphoreWaitNodeParams.paramsArray' in found_struct}} + + paramsArray : cudaExternalSemaphoreWaitParams Array of external semaphore wait parameters. - {{endif}} - {{if 'cudaExternalSemaphoreWaitNodeParams.numExtSems' in found_struct}} + + numExtSems : unsigned int Number of handles and parameters supplied in extSemArray and paramsArray. - {{endif}} + Methods ------- @@ -3498,16 +3284,14 @@ cdef class cudaExternalSemaphoreWaitNodeParams: """ cdef cyruntime.cudaExternalSemaphoreWaitNodeParams _pvt_val cdef cyruntime.cudaExternalSemaphoreWaitNodeParams* _pvt_ptr - {{if 'cudaExternalSemaphoreWaitNodeParams.extSemArray' in found_struct}} + cdef size_t _extSemArray_length cdef cyruntime.cudaExternalSemaphore_t* _extSemArray - {{endif}} - {{if 'cudaExternalSemaphoreWaitNodeParams.paramsArray' in found_struct}} + + cdef size_t _paramsArray_length cdef cyruntime.cudaExternalSemaphoreWaitParams* _paramsArray - {{endif}} -{{endif}} -{{if 'cudaExternalSemaphoreWaitNodeParamsV2' in found_struct}} + cdef class cudaExternalSemaphoreWaitNodeParamsV2: """ @@ -3515,19 +3299,19 @@ cdef class cudaExternalSemaphoreWaitNodeParamsV2: Attributes ---------- - {{if 'cudaExternalSemaphoreWaitNodeParamsV2.extSemArray' in found_struct}} + extSemArray : cudaExternalSemaphore_t Array of external semaphore handles. - {{endif}} - {{if 'cudaExternalSemaphoreWaitNodeParamsV2.paramsArray' in found_struct}} + + paramsArray : cudaExternalSemaphoreWaitParams Array of external semaphore wait parameters. - {{endif}} - {{if 'cudaExternalSemaphoreWaitNodeParamsV2.numExtSems' in found_struct}} + + numExtSems : unsigned int Number of handles and parameters supplied in extSemArray and paramsArray. - {{endif}} + Methods ------- @@ -3536,16 +3320,14 @@ cdef class cudaExternalSemaphoreWaitNodeParamsV2: """ cdef cyruntime.cudaExternalSemaphoreWaitNodeParamsV2 _pvt_val cdef cyruntime.cudaExternalSemaphoreWaitNodeParamsV2* _pvt_ptr - {{if 'cudaExternalSemaphoreWaitNodeParamsV2.extSemArray' in found_struct}} + cdef size_t _extSemArray_length cdef cyruntime.cudaExternalSemaphore_t* _extSemArray - {{endif}} - {{if 'cudaExternalSemaphoreWaitNodeParamsV2.paramsArray' in found_struct}} + + cdef size_t _paramsArray_length cdef cyruntime.cudaExternalSemaphoreWaitParams* _paramsArray - {{endif}} -{{endif}} -{{if 'cudaConditionalNodeParams' in found_struct}} + cdef class cudaConditionalNodeParams: """ @@ -3553,22 +3335,22 @@ cdef class cudaConditionalNodeParams: Attributes ---------- - {{if 'cudaConditionalNodeParams.handle' in found_struct}} + handle : cudaGraphConditionalHandle Conditional node handle. Handles must be created in advance of creating the node using cudaGraphConditionalHandleCreate. - {{endif}} - {{if 'cudaConditionalNodeParams.type' in found_struct}} + + type : cudaGraphConditionalNodeType Type of conditional node. - {{endif}} - {{if 'cudaConditionalNodeParams.size' in found_struct}} + + size : unsigned int Size of graph output array. Allowed values are 1 for cudaGraphCondTypeWhile, 1 or 2 for cudaGraphCondTypeIf, or any value greater than zero for cudaGraphCondTypeSwitch. - {{endif}} - {{if 'cudaConditionalNodeParams.phGraph_out' in found_struct}} + + phGraph_out : cudaGraph_t CUDA-owned array populated with conditional node child graphs during creation of the node. Valid for the lifetime of the @@ -3586,11 +3368,11 @@ cdef class cudaConditionalNodeParams: condition is non-zero. cudaGraphCondTypeSwitch: phGraph_out[n] is executed when the condition is equal to n. If the condition >= `size`, no body graph is executed. - {{endif}} - {{if 'cudaConditionalNodeParams.ctx' in found_struct}} + + ctx : cudaExecutionContext_t CUDA Execution Context - {{endif}} + Methods ------- @@ -3599,18 +3381,16 @@ cdef class cudaConditionalNodeParams: """ cdef cyruntime.cudaConditionalNodeParams _pvt_val cdef cyruntime.cudaConditionalNodeParams* _pvt_ptr - {{if 'cudaConditionalNodeParams.handle' in found_struct}} + cdef cudaGraphConditionalHandle _handle - {{endif}} - {{if 'cudaConditionalNodeParams.phGraph_out' in found_struct}} + + cdef size_t _phGraph_out_length cdef cyruntime.cudaGraph_t* _phGraph_out - {{endif}} - {{if 'cudaConditionalNodeParams.ctx' in found_struct}} + + cdef cudaExecutionContext_t _ctx - {{endif}} -{{endif}} -{{if 'cudaChildGraphNodeParams' in found_struct}} + cdef class cudaChildGraphNodeParams: """ @@ -3618,18 +3398,18 @@ cdef class cudaChildGraphNodeParams: Attributes ---------- - {{if 'cudaChildGraphNodeParams.graph' in found_struct}} + graph : cudaGraph_t The child graph to clone into the node for node creation, or a handle to the graph owned by the node for node query. The graph must not contain conditional nodes. Graphs containing memory allocation or memory free nodes must set the ownership to be moved to the parent. - {{endif}} - {{if 'cudaChildGraphNodeParams.ownership' in found_struct}} + + ownership : cudaGraphChildGraphNodeOwnership The ownership relationship of the child graph node. - {{endif}} + Methods ------- @@ -3638,11 +3418,9 @@ cdef class cudaChildGraphNodeParams: """ cdef cyruntime.cudaChildGraphNodeParams _pvt_val cdef cyruntime.cudaChildGraphNodeParams* _pvt_ptr - {{if 'cudaChildGraphNodeParams.graph' in found_struct}} + cdef cudaGraph_t _graph - {{endif}} -{{endif}} -{{if 'cudaEventRecordNodeParams' in found_struct}} + cdef class cudaEventRecordNodeParams: """ @@ -3650,10 +3428,10 @@ cdef class cudaEventRecordNodeParams: Attributes ---------- - {{if 'cudaEventRecordNodeParams.event' in found_struct}} + event : cudaEvent_t The event to record when the node executes - {{endif}} + Methods ------- @@ -3662,11 +3440,9 @@ cdef class cudaEventRecordNodeParams: """ cdef cyruntime.cudaEventRecordNodeParams _pvt_val cdef cyruntime.cudaEventRecordNodeParams* _pvt_ptr - {{if 'cudaEventRecordNodeParams.event' in found_struct}} + cdef cudaEvent_t _event - {{endif}} -{{endif}} -{{if 'cudaEventWaitNodeParams' in found_struct}} + cdef class cudaEventWaitNodeParams: """ @@ -3674,10 +3450,10 @@ cdef class cudaEventWaitNodeParams: Attributes ---------- - {{if 'cudaEventWaitNodeParams.event' in found_struct}} + event : cudaEvent_t The event to wait on from the node - {{endif}} + Methods ------- @@ -3686,11 +3462,9 @@ cdef class cudaEventWaitNodeParams: """ cdef cyruntime.cudaEventWaitNodeParams _pvt_val cdef cyruntime.cudaEventWaitNodeParams* _pvt_ptr - {{if 'cudaEventWaitNodeParams.event' in found_struct}} + cdef cudaEvent_t _event - {{endif}} -{{endif}} -{{if 'cudaGraphNodeParams' in found_struct}} + cdef class cudaGraphNodeParams: """ @@ -3698,70 +3472,70 @@ cdef class cudaGraphNodeParams: Attributes ---------- - {{if 'cudaGraphNodeParams.type' in found_struct}} + type : cudaGraphNodeType Type of the node - {{endif}} - {{if 'cudaGraphNodeParams.reserved0' in found_struct}} + + reserved0 : list[int] Reserved. Must be zero. - {{endif}} - {{if 'cudaGraphNodeParams.reserved1' in found_struct}} + + reserved1 : list[long long] Padding. Unused bytes must be zero. - {{endif}} - {{if 'cudaGraphNodeParams.kernel' in found_struct}} + + kernel : cudaKernelNodeParamsV2 Kernel node parameters. - {{endif}} - {{if 'cudaGraphNodeParams.memcpy' in found_struct}} + + memcpy : cudaMemcpyNodeParams Memcpy node parameters. - {{endif}} - {{if 'cudaGraphNodeParams.memset' in found_struct}} + + memset : cudaMemsetParamsV2 Memset node parameters. - {{endif}} - {{if 'cudaGraphNodeParams.host' in found_struct}} + + host : cudaHostNodeParamsV2 Host node parameters. - {{endif}} - {{if 'cudaGraphNodeParams.graph' in found_struct}} + + graph : cudaChildGraphNodeParams Child graph node parameters. - {{endif}} - {{if 'cudaGraphNodeParams.eventWait' in found_struct}} + + eventWait : cudaEventWaitNodeParams Event wait node parameters. - {{endif}} - {{if 'cudaGraphNodeParams.eventRecord' in found_struct}} + + eventRecord : cudaEventRecordNodeParams Event record node parameters. - {{endif}} - {{if 'cudaGraphNodeParams.extSemSignal' in found_struct}} + + extSemSignal : cudaExternalSemaphoreSignalNodeParamsV2 External semaphore signal node parameters. - {{endif}} - {{if 'cudaGraphNodeParams.extSemWait' in found_struct}} + + extSemWait : cudaExternalSemaphoreWaitNodeParamsV2 External semaphore wait node parameters. - {{endif}} - {{if 'cudaGraphNodeParams.alloc' in found_struct}} + + alloc : cudaMemAllocNodeParamsV2 Memory allocation node parameters. - {{endif}} - {{if 'cudaGraphNodeParams.free' in found_struct}} + + free : cudaMemFreeNodeParams Memory free node parameters. - {{endif}} - {{if 'cudaGraphNodeParams.conditional' in found_struct}} + + conditional : cudaConditionalNodeParams Conditional node parameters. - {{endif}} - {{if 'cudaGraphNodeParams.reserved2' in found_struct}} + + reserved2 : long long Reserved bytes. Must be zero. - {{endif}} + Methods ------- @@ -3770,44 +3544,42 @@ cdef class cudaGraphNodeParams: """ cdef cyruntime.cudaGraphNodeParams* _val_ptr cdef cyruntime.cudaGraphNodeParams* _pvt_ptr - {{if 'cudaGraphNodeParams.kernel' in found_struct}} + cdef cudaKernelNodeParamsV2 _kernel - {{endif}} - {{if 'cudaGraphNodeParams.memcpy' in found_struct}} + + cdef cudaMemcpyNodeParams _memcpy - {{endif}} - {{if 'cudaGraphNodeParams.memset' in found_struct}} + + cdef cudaMemsetParamsV2 _memset - {{endif}} - {{if 'cudaGraphNodeParams.host' in found_struct}} + + cdef cudaHostNodeParamsV2 _host - {{endif}} - {{if 'cudaGraphNodeParams.graph' in found_struct}} + + cdef cudaChildGraphNodeParams _graph - {{endif}} - {{if 'cudaGraphNodeParams.eventWait' in found_struct}} + + cdef cudaEventWaitNodeParams _eventWait - {{endif}} - {{if 'cudaGraphNodeParams.eventRecord' in found_struct}} + + cdef cudaEventRecordNodeParams _eventRecord - {{endif}} - {{if 'cudaGraphNodeParams.extSemSignal' in found_struct}} + + cdef cudaExternalSemaphoreSignalNodeParamsV2 _extSemSignal - {{endif}} - {{if 'cudaGraphNodeParams.extSemWait' in found_struct}} + + cdef cudaExternalSemaphoreWaitNodeParamsV2 _extSemWait - {{endif}} - {{if 'cudaGraphNodeParams.alloc' in found_struct}} + + cdef cudaMemAllocNodeParamsV2 _alloc - {{endif}} - {{if 'cudaGraphNodeParams.free' in found_struct}} + + cdef cudaMemFreeNodeParams _free - {{endif}} - {{if 'cudaGraphNodeParams.conditional' in found_struct}} + + cdef cudaConditionalNodeParams _conditional - {{endif}} -{{endif}} -{{if 'cudaGraphEdgeData_st' in found_struct}} + cdef class cudaGraphEdgeData_st: """ @@ -3818,7 +3590,7 @@ cdef class cudaGraphEdgeData_st: Attributes ---------- - {{if 'cudaGraphEdgeData_st.from_port' in found_struct}} + from_port : bytes This indicates when the dependency is triggered from the upstream node on the edge. The meaning is specfic to the node type. A value @@ -3829,8 +3601,8 @@ cdef class cudaGraphEdgeData_st: cudaGraphKernelNodePortDefault, cudaGraphKernelNodePortProgrammatic, or cudaGraphKernelNodePortLaunchCompletion. - {{endif}} - {{if 'cudaGraphEdgeData_st.to_port' in found_struct}} + + to_port : bytes This indicates what portion of the downstream node is dependent on the upstream node or portion thereof (indicated by `from_port`). @@ -3838,18 +3610,18 @@ cdef class cudaGraphEdgeData_st: means the entirety of the downstream node is dependent on the upstream work. Currently no node types define non-zero ports. Accordingly, this field must be set to zero. - {{endif}} - {{if 'cudaGraphEdgeData_st.type' in found_struct}} + + type : bytes This should be populated with a value from cudaGraphDependencyType. (It is typed as char due to compiler-specific layout of bitfields.) See cudaGraphDependencyType. - {{endif}} - {{if 'cudaGraphEdgeData_st.reserved' in found_struct}} + + reserved : bytes These bytes are unused and must be zeroed. This ensures compatibility if additional fields are added in the future. - {{endif}} + Methods ------- @@ -3858,8 +3630,6 @@ cdef class cudaGraphEdgeData_st: """ cdef cyruntime.cudaGraphEdgeData_st _pvt_val cdef cyruntime.cudaGraphEdgeData_st* _pvt_ptr -{{endif}} -{{if 'cudaGraphInstantiateParams_st' in found_struct}} cdef class cudaGraphInstantiateParams_st: """ @@ -3867,22 +3637,22 @@ cdef class cudaGraphInstantiateParams_st: Attributes ---------- - {{if 'cudaGraphInstantiateParams_st.flags' in found_struct}} + flags : unsigned long long Instantiation flags - {{endif}} - {{if 'cudaGraphInstantiateParams_st.uploadStream' in found_struct}} + + uploadStream : cudaStream_t Upload stream - {{endif}} - {{if 'cudaGraphInstantiateParams_st.errNode_out' in found_struct}} + + errNode_out : cudaGraphNode_t The node which caused instantiation to fail, if any - {{endif}} - {{if 'cudaGraphInstantiateParams_st.result_out' in found_struct}} + + result_out : cudaGraphInstantiateResult Whether instantiation was successful. If it failed, the reason why - {{endif}} + Methods ------- @@ -3891,14 +3661,12 @@ cdef class cudaGraphInstantiateParams_st: """ cdef cyruntime.cudaGraphInstantiateParams_st _pvt_val cdef cyruntime.cudaGraphInstantiateParams_st* _pvt_ptr - {{if 'cudaGraphInstantiateParams_st.uploadStream' in found_struct}} + cdef cudaStream_t _uploadStream - {{endif}} - {{if 'cudaGraphInstantiateParams_st.errNode_out' in found_struct}} + + cdef cudaGraphNode_t _errNode_out - {{endif}} -{{endif}} -{{if 'cudaGraphExecUpdateResultInfo_st' in found_struct}} + cdef class cudaGraphExecUpdateResultInfo_st: """ @@ -3906,21 +3674,21 @@ cdef class cudaGraphExecUpdateResultInfo_st: Attributes ---------- - {{if 'cudaGraphExecUpdateResultInfo_st.result' in found_struct}} + result : cudaGraphExecUpdateResult Gives more specific detail when a cuda graph update fails. - {{endif}} - {{if 'cudaGraphExecUpdateResultInfo_st.errorNode' in found_struct}} + + errorNode : cudaGraphNode_t The "to node" of the error edge when the topologies do not match. The error node when the error is associated with a specific node. NULL when the error is generic. - {{endif}} - {{if 'cudaGraphExecUpdateResultInfo_st.errorFromNode' in found_struct}} + + errorFromNode : cudaGraphNode_t The from node of error edge when the topologies do not match. Otherwise NULL. - {{endif}} + Methods ------- @@ -3929,31 +3697,29 @@ cdef class cudaGraphExecUpdateResultInfo_st: """ cdef cyruntime.cudaGraphExecUpdateResultInfo_st _pvt_val cdef cyruntime.cudaGraphExecUpdateResultInfo_st* _pvt_ptr - {{if 'cudaGraphExecUpdateResultInfo_st.errorNode' in found_struct}} + cdef cudaGraphNode_t _errorNode - {{endif}} - {{if 'cudaGraphExecUpdateResultInfo_st.errorFromNode' in found_struct}} + + cdef cudaGraphNode_t _errorFromNode - {{endif}} -{{endif}} -{{if 'cudaGraphKernelNodeUpdate.updateData.param' in found_struct}} + cdef class anon_struct16: """ Attributes ---------- - {{if 'cudaGraphKernelNodeUpdate.updateData.param.pValue' in found_struct}} + pValue : Any - {{endif}} - {{if 'cudaGraphKernelNodeUpdate.updateData.param.offset' in found_struct}} + + offset : size_t - {{endif}} - {{if 'cudaGraphKernelNodeUpdate.updateData.param.size' in found_struct}} + + size : size_t - {{endif}} + Methods ------- @@ -3961,28 +3727,26 @@ cdef class anon_struct16: Get memory address of class instance """ cdef cyruntime.cudaGraphKernelNodeUpdate* _pvt_ptr - {{if 'cudaGraphKernelNodeUpdate.updateData.param.pValue' in found_struct}} + cdef _HelperInputVoidPtr _cypValue - {{endif}} -{{endif}} -{{if 'cudaGraphKernelNodeUpdate.updateData' in found_struct}} + cdef class anon_union10: """ Attributes ---------- - {{if 'cudaGraphKernelNodeUpdate.updateData.gridDim' in found_struct}} + gridDim : dim3 - {{endif}} - {{if 'cudaGraphKernelNodeUpdate.updateData.param' in found_struct}} + + param : anon_struct16 - {{endif}} - {{if 'cudaGraphKernelNodeUpdate.updateData.isEnabled' in found_struct}} + + isEnabled : unsigned int - {{endif}} + Methods ------- @@ -3990,14 +3754,12 @@ cdef class anon_union10: Get memory address of class instance """ cdef cyruntime.cudaGraphKernelNodeUpdate* _pvt_ptr - {{if 'cudaGraphKernelNodeUpdate.updateData.gridDim' in found_struct}} + cdef dim3 _gridDim - {{endif}} - {{if 'cudaGraphKernelNodeUpdate.updateData.param' in found_struct}} + + cdef anon_struct16 _param - {{endif}} -{{endif}} -{{if 'cudaGraphKernelNodeUpdate' in found_struct}} + cdef class cudaGraphKernelNodeUpdate: """ @@ -4006,19 +3768,19 @@ cdef class cudaGraphKernelNodeUpdate: Attributes ---------- - {{if 'cudaGraphKernelNodeUpdate.node' in found_struct}} + node : cudaGraphDeviceNode_t Node to update - {{endif}} - {{if 'cudaGraphKernelNodeUpdate.field' in found_struct}} + + field : cudaGraphKernelNodeField Which type of update to apply. Determines how updateData is interpreted - {{endif}} - {{if 'cudaGraphKernelNodeUpdate.updateData' in found_struct}} + + updateData : anon_union10 Update data to apply. Which field is used depends on field's value - {{endif}} + Methods ------- @@ -4027,14 +3789,12 @@ cdef class cudaGraphKernelNodeUpdate: """ cdef cyruntime.cudaGraphKernelNodeUpdate* _val_ptr cdef cyruntime.cudaGraphKernelNodeUpdate* _pvt_ptr - {{if 'cudaGraphKernelNodeUpdate.node' in found_struct}} + cdef cudaGraphDeviceNode_t _node - {{endif}} - {{if 'cudaGraphKernelNodeUpdate.updateData' in found_struct}} + + cdef anon_union10 _updateData - {{endif}} -{{endif}} -{{if 'cudaLaunchMemSyncDomainMap_st' in found_struct}} + cdef class cudaLaunchMemSyncDomainMap_st: """ @@ -4048,14 +3808,14 @@ cdef class cudaLaunchMemSyncDomainMap_st: Attributes ---------- - {{if 'cudaLaunchMemSyncDomainMap_st.default_' in found_struct}} + default_ : bytes The default domain ID to use for designated kernels - {{endif}} - {{if 'cudaLaunchMemSyncDomainMap_st.remote' in found_struct}} + + remote : bytes The remote domain ID to use for designated kernels - {{endif}} + Methods ------- @@ -4064,25 +3824,23 @@ cdef class cudaLaunchMemSyncDomainMap_st: """ cdef cyruntime.cudaLaunchMemSyncDomainMap_st _pvt_val cdef cyruntime.cudaLaunchMemSyncDomainMap_st* _pvt_ptr -{{endif}} -{{if 'cudaLaunchAttributeValue.clusterDim' in found_struct}} cdef class anon_struct17: """ Attributes ---------- - {{if 'cudaLaunchAttributeValue.clusterDim.x' in found_struct}} + x : unsigned int - {{endif}} - {{if 'cudaLaunchAttributeValue.clusterDim.y' in found_struct}} + + y : unsigned int - {{endif}} - {{if 'cudaLaunchAttributeValue.clusterDim.z' in found_struct}} + + z : unsigned int - {{endif}} + Methods ------- @@ -4090,25 +3848,23 @@ cdef class anon_struct17: Get memory address of class instance """ cdef cyruntime.cudaLaunchAttributeValue* _pvt_ptr -{{endif}} -{{if 'cudaLaunchAttributeValue.programmaticEvent' in found_struct}} cdef class anon_struct18: """ Attributes ---------- - {{if 'cudaLaunchAttributeValue.programmaticEvent.event' in found_struct}} + event : cudaEvent_t - {{endif}} - {{if 'cudaLaunchAttributeValue.programmaticEvent.flags' in found_struct}} + + flags : int - {{endif}} - {{if 'cudaLaunchAttributeValue.programmaticEvent.triggerAtBlockStart' in found_struct}} + + triggerAtBlockStart : int - {{endif}} + Methods ------- @@ -4116,28 +3872,26 @@ cdef class anon_struct18: Get memory address of class instance """ cdef cyruntime.cudaLaunchAttributeValue* _pvt_ptr - {{if 'cudaLaunchAttributeValue.programmaticEvent.event' in found_struct}} + cdef cudaEvent_t _event - {{endif}} -{{endif}} -{{if 'cudaLaunchAttributeValue.preferredClusterDim' in found_struct}} + cdef class anon_struct19: """ Attributes ---------- - {{if 'cudaLaunchAttributeValue.preferredClusterDim.x' in found_struct}} + x : unsigned int - {{endif}} - {{if 'cudaLaunchAttributeValue.preferredClusterDim.y' in found_struct}} + + y : unsigned int - {{endif}} - {{if 'cudaLaunchAttributeValue.preferredClusterDim.z' in found_struct}} + + z : unsigned int - {{endif}} + Methods ------- @@ -4145,21 +3899,19 @@ cdef class anon_struct19: Get memory address of class instance """ cdef cyruntime.cudaLaunchAttributeValue* _pvt_ptr -{{endif}} -{{if 'cudaLaunchAttributeValue.launchCompletionEvent' in found_struct}} cdef class anon_struct20: """ Attributes ---------- - {{if 'cudaLaunchAttributeValue.launchCompletionEvent.event' in found_struct}} + event : cudaEvent_t - {{endif}} - {{if 'cudaLaunchAttributeValue.launchCompletionEvent.flags' in found_struct}} + + flags : int - {{endif}} + Methods ------- @@ -4167,24 +3919,22 @@ cdef class anon_struct20: Get memory address of class instance """ cdef cyruntime.cudaLaunchAttributeValue* _pvt_ptr - {{if 'cudaLaunchAttributeValue.launchCompletionEvent.event' in found_struct}} + cdef cudaEvent_t _event - {{endif}} -{{endif}} -{{if 'cudaLaunchAttributeValue.deviceUpdatableKernelNode' in found_struct}} + cdef class anon_struct21: """ Attributes ---------- - {{if 'cudaLaunchAttributeValue.deviceUpdatableKernelNode.deviceUpdatable' in found_struct}} + deviceUpdatable : int - {{endif}} - {{if 'cudaLaunchAttributeValue.deviceUpdatableKernelNode.devNode' in found_struct}} + + devNode : cudaGraphDeviceNode_t - {{endif}} + Methods ------- @@ -4192,11 +3942,9 @@ cdef class anon_struct21: Get memory address of class instance """ cdef cyruntime.cudaLaunchAttributeValue* _pvt_ptr - {{if 'cudaLaunchAttributeValue.deviceUpdatableKernelNode.devNode' in found_struct}} + cdef cudaGraphDeviceNode_t _devNode - {{endif}} -{{endif}} -{{if 'cudaLaunchAttributeValue' in found_struct}} + cdef class cudaLaunchAttributeValue: """ @@ -4204,25 +3952,25 @@ cdef class cudaLaunchAttributeValue: Attributes ---------- - {{if 'cudaLaunchAttributeValue.pad' in found_struct}} + pad : bytes - {{endif}} - {{if 'cudaLaunchAttributeValue.accessPolicyWindow' in found_struct}} + + accessPolicyWindow : cudaAccessPolicyWindow Value of launch attribute cudaLaunchAttributeAccessPolicyWindow. - {{endif}} - {{if 'cudaLaunchAttributeValue.cooperative' in found_struct}} + + cooperative : int Value of launch attribute cudaLaunchAttributeCooperative. Nonzero indicates a cooperative kernel (see cudaLaunchCooperativeKernel). - {{endif}} - {{if 'cudaLaunchAttributeValue.syncPolicy' in found_struct}} + + syncPolicy : cudaSynchronizationPolicy Value of launch attribute cudaLaunchAttributeSynchronizationPolicy. cudaSynchronizationPolicy for work queued up in this stream. - {{endif}} - {{if 'cudaLaunchAttributeValue.clusterDim' in found_struct}} + + clusterDim : anon_struct17 Value of launch attribute cudaLaunchAttributeClusterDimension that represents the desired cluster dimensions for the kernel. Opaque @@ -4231,19 +3979,19 @@ cdef class cudaLaunchAttributeValue: `y` - The Y dimension of the cluster, in blocks. Must be a divisor of the grid Y dimension. - `z` - The Z dimension of the cluster, in blocks. Must be a divisor of the grid Z dimension. - {{endif}} - {{if 'cudaLaunchAttributeValue.clusterSchedulingPolicyPreference' in found_struct}} + + clusterSchedulingPolicyPreference : cudaClusterSchedulingPolicy Value of launch attribute cudaLaunchAttributeClusterSchedulingPolicyPreference. Cluster scheduling policy preference for the kernel. - {{endif}} - {{if 'cudaLaunchAttributeValue.programmaticStreamSerializationAllowed' in found_struct}} + + programmaticStreamSerializationAllowed : int Value of launch attribute cudaLaunchAttributeProgrammaticStreamSerialization. - {{endif}} - {{if 'cudaLaunchAttributeValue.programmaticEvent' in found_struct}} + + programmaticEvent : anon_struct18 Value of launch attribute cudaLaunchAttributeProgrammaticEvent with the following fields: - `cudaEvent_t` event - Event to fire when @@ -4251,23 +3999,23 @@ cdef class cudaLaunchAttributeValue: cudaEventRecordWithFlags. Does not accept cudaEventRecordExternal. - `int` triggerAtBlockStart - If this is set to non-0, each block launch will automatically trigger the event. - {{endif}} - {{if 'cudaLaunchAttributeValue.priority' in found_struct}} + + priority : int Value of launch attribute cudaLaunchAttributePriority. Execution priority of the kernel. - {{endif}} - {{if 'cudaLaunchAttributeValue.memSyncDomainMap' in found_struct}} + + memSyncDomainMap : cudaLaunchMemSyncDomainMap Value of launch attribute cudaLaunchAttributeMemSyncDomainMap. See cudaLaunchMemSyncDomainMap. - {{endif}} - {{if 'cudaLaunchAttributeValue.memSyncDomain' in found_struct}} + + memSyncDomain : cudaLaunchMemSyncDomain Value of launch attribute cudaLaunchAttributeMemSyncDomain. See cudaLaunchMemSyncDomain. - {{endif}} - {{if 'cudaLaunchAttributeValue.preferredClusterDim' in found_struct}} + + preferredClusterDim : anon_struct19 Value of launch attribute cudaLaunchAttributePreferredClusterDimension that represents the @@ -4281,16 +4029,16 @@ cdef class cudaLaunchAttributeValue: ::cudaLaunchAttributeValue::clusterDim. - `z` - The Z dimension of the preferred cluster, in blocks. Must be equal to the `z` field of ::cudaLaunchAttributeValue::clusterDim. - {{endif}} - {{if 'cudaLaunchAttributeValue.launchCompletionEvent' in found_struct}} + + launchCompletionEvent : anon_struct20 Value of launch attribute cudaLaunchAttributeLaunchCompletionEvent with the following fields: - `cudaEvent_t` event - Event to fire when the last block launches. - `int` flags - Event record flags, see cudaEventRecordWithFlags. Does not accept cudaEventRecordExternal. - {{endif}} - {{if 'cudaLaunchAttributeValue.deviceUpdatableKernelNode' in found_struct}} + + deviceUpdatableKernelNode : anon_struct21 Value of launch attribute cudaLaunchAttributeDeviceUpdatableKernelNode with the following @@ -4298,27 +4046,27 @@ cdef class cudaLaunchAttributeValue: kernel node should be device-updatable. - `cudaGraphDeviceNode_t` devNode - Returns a handle to pass to the various device-side update functions. - {{endif}} - {{if 'cudaLaunchAttributeValue.sharedMemCarveout' in found_struct}} + + sharedMemCarveout : unsigned int Value of launch attribute cudaLaunchAttributePreferredSharedMemoryCarveout. - {{endif}} - {{if 'cudaLaunchAttributeValue.nvlinkUtilCentricScheduling' in found_struct}} + + nvlinkUtilCentricScheduling : unsigned int Value of launch attribute cudaLaunchAttributeNvlinkUtilCentricScheduling. - {{endif}} - {{if 'cudaLaunchAttributeValue.portableClusterSizeMode' in found_struct}} + + portableClusterSizeMode : cudaLaunchAttributePortableClusterMode Value of launch attribute cudaLaunchAttributePortableClusterSizeMode - {{endif}} - {{if 'cudaLaunchAttributeValue.sharedMemoryMode' in found_struct}} + + sharedMemoryMode : cudaSharedMemoryMode Value of launch attribute cudaLaunchAttributeSharedMemoryMode. See cudaSharedMemoryMode for acceptable values. - {{endif}} + Methods ------- @@ -4327,29 +4075,27 @@ cdef class cudaLaunchAttributeValue: """ cdef cyruntime.cudaLaunchAttributeValue _pvt_val cdef cyruntime.cudaLaunchAttributeValue* _pvt_ptr - {{if 'cudaLaunchAttributeValue.accessPolicyWindow' in found_struct}} + cdef cudaAccessPolicyWindow _accessPolicyWindow - {{endif}} - {{if 'cudaLaunchAttributeValue.clusterDim' in found_struct}} + + cdef anon_struct17 _clusterDim - {{endif}} - {{if 'cudaLaunchAttributeValue.programmaticEvent' in found_struct}} + + cdef anon_struct18 _programmaticEvent - {{endif}} - {{if 'cudaLaunchAttributeValue.memSyncDomainMap' in found_struct}} + + cdef cudaLaunchMemSyncDomainMap _memSyncDomainMap - {{endif}} - {{if 'cudaLaunchAttributeValue.preferredClusterDim' in found_struct}} + + cdef anon_struct19 _preferredClusterDim - {{endif}} - {{if 'cudaLaunchAttributeValue.launchCompletionEvent' in found_struct}} + + cdef anon_struct20 _launchCompletionEvent - {{endif}} - {{if 'cudaLaunchAttributeValue.deviceUpdatableKernelNode' in found_struct}} + + cdef anon_struct21 _deviceUpdatableKernelNode - {{endif}} -{{endif}} -{{if 'cudaLaunchAttribute_st' in found_struct}} + cdef class cudaLaunchAttribute_st: """ @@ -4357,14 +4103,14 @@ cdef class cudaLaunchAttribute_st: Attributes ---------- - {{if 'cudaLaunchAttribute_st.id' in found_struct}} + id : cudaLaunchAttributeID Attribute to set - {{endif}} - {{if 'cudaLaunchAttribute_st.val' in found_struct}} + + val : cudaLaunchAttributeValue Value of the attribute - {{endif}} + Methods ------- @@ -4373,20 +4119,18 @@ cdef class cudaLaunchAttribute_st: """ cdef cyruntime.cudaLaunchAttribute_st _pvt_val cdef cyruntime.cudaLaunchAttribute_st* _pvt_ptr - {{if 'cudaLaunchAttribute_st.val' in found_struct}} + cdef cudaLaunchAttributeValue _val - {{endif}} -{{endif}} -{{if 'cudaAsyncNotificationInfo.info.overBudget' in found_struct}} + cdef class anon_struct22: """ Attributes ---------- - {{if 'cudaAsyncNotificationInfo.info.overBudget.bytesOverBudget' in found_struct}} + bytesOverBudget : unsigned long long - {{endif}} + Methods ------- @@ -4394,17 +4138,15 @@ cdef class anon_struct22: Get memory address of class instance """ cdef cyruntime.cudaAsyncNotificationInfo* _pvt_ptr -{{endif}} -{{if 'cudaAsyncNotificationInfo.info' in found_struct}} cdef class anon_union11: """ Attributes ---------- - {{if 'cudaAsyncNotificationInfo.info.overBudget' in found_struct}} + overBudget : anon_struct22 - {{endif}} + Methods ------- @@ -4412,11 +4154,9 @@ cdef class anon_union11: Get memory address of class instance """ cdef cyruntime.cudaAsyncNotificationInfo* _pvt_ptr - {{if 'cudaAsyncNotificationInfo.info.overBudget' in found_struct}} + cdef anon_struct22 _overBudget - {{endif}} -{{endif}} -{{if 'cudaAsyncNotificationInfo' in found_struct}} + cdef class cudaAsyncNotificationInfo: """ @@ -4424,15 +4164,15 @@ cdef class cudaAsyncNotificationInfo: Attributes ---------- - {{if 'cudaAsyncNotificationInfo.type' in found_struct}} + type : cudaAsyncNotificationType The type of notification being sent - {{endif}} - {{if 'cudaAsyncNotificationInfo.info' in found_struct}} + + info : anon_union11 Information about the notification. `typename` must be checked in order to interpret this field. - {{endif}} + Methods ------- @@ -4441,11 +4181,9 @@ cdef class cudaAsyncNotificationInfo: """ cdef cyruntime.cudaAsyncNotificationInfo* _val_ptr cdef cyruntime.cudaAsyncNotificationInfo* _pvt_ptr - {{if 'cudaAsyncNotificationInfo.info' in found_struct}} + cdef anon_union11 _info - {{endif}} -{{endif}} -{{if 'cudaTextureDesc' in found_struct}} + cdef class cudaTextureDesc: """ @@ -4453,58 +4191,58 @@ cdef class cudaTextureDesc: Attributes ---------- - {{if 'cudaTextureDesc.addressMode' in found_struct}} + addressMode : list[cudaTextureAddressMode] Texture address mode for up to 3 dimensions - {{endif}} - {{if 'cudaTextureDesc.filterMode' in found_struct}} + + filterMode : cudaTextureFilterMode Texture filter mode - {{endif}} - {{if 'cudaTextureDesc.readMode' in found_struct}} + + readMode : cudaTextureReadMode Texture read mode - {{endif}} - {{if 'cudaTextureDesc.sRGB' in found_struct}} + + sRGB : int Perform sRGB->linear conversion during texture read - {{endif}} - {{if 'cudaTextureDesc.borderColor' in found_struct}} + + borderColor : list[float] Texture Border Color - {{endif}} - {{if 'cudaTextureDesc.normalizedCoords' in found_struct}} + + normalizedCoords : int Indicates whether texture reads are normalized or not - {{endif}} - {{if 'cudaTextureDesc.maxAnisotropy' in found_struct}} + + maxAnisotropy : unsigned int Limit to the anisotropy ratio - {{endif}} - {{if 'cudaTextureDesc.mipmapFilterMode' in found_struct}} + + mipmapFilterMode : cudaTextureFilterMode Mipmap filter mode - {{endif}} - {{if 'cudaTextureDesc.mipmapLevelBias' in found_struct}} + + mipmapLevelBias : float Offset applied to the supplied mipmap level - {{endif}} - {{if 'cudaTextureDesc.minMipmapLevelClamp' in found_struct}} + + minMipmapLevelClamp : float Lower end of the mipmap level range to clamp access to - {{endif}} - {{if 'cudaTextureDesc.maxMipmapLevelClamp' in found_struct}} + + maxMipmapLevelClamp : float Upper end of the mipmap level range to clamp access to - {{endif}} - {{if 'cudaTextureDesc.disableTrilinearOptimization' in found_struct}} + + disableTrilinearOptimization : int Disable any trilinear filtering optimizations. - {{endif}} - {{if 'cudaTextureDesc.seamlessCubemap' in found_struct}} + + seamlessCubemap : int Enable seamless cube map filtering. - {{endif}} + Methods ------- @@ -4513,8 +4251,6 @@ cdef class cudaTextureDesc: """ cdef cyruntime.cudaTextureDesc _pvt_val cdef cyruntime.cudaTextureDesc* _pvt_ptr -{{endif}} -{{if 'cudaGraphRecaptureCallbackData' in found_struct}} cdef class cudaGraphRecaptureCallbackData: """ @@ -4523,14 +4259,14 @@ cdef class cudaGraphRecaptureCallbackData: Attributes ---------- - {{if 'cudaGraphRecaptureCallbackData.callbackFunc' in found_struct}} + callbackFunc : cudaGraphRecaptureCallback_t Callback function that will be invoked - {{endif}} - {{if 'cudaGraphRecaptureCallbackData.userData' in found_struct}} + + userData : Any Generic pointer that is passed to the callback function - {{endif}} + Methods ------- @@ -4539,14 +4275,12 @@ cdef class cudaGraphRecaptureCallbackData: """ cdef cyruntime.cudaGraphRecaptureCallbackData _pvt_val cdef cyruntime.cudaGraphRecaptureCallbackData* _pvt_ptr - {{if 'cudaGraphRecaptureCallbackData.callbackFunc' in found_struct}} + cdef cudaGraphRecaptureCallback_t _callbackFunc - {{endif}} - {{if 'cudaGraphRecaptureCallbackData.userData' in found_struct}} + + cdef _HelperInputVoidPtr _cyuserData - {{endif}} -{{endif}} -{{if True}} + cdef class cudaEglPlaneDesc_st: """ @@ -4555,34 +4289,34 @@ cdef class cudaEglPlaneDesc_st: Attributes ---------- - {{if True}} + width : unsigned int Width of plane - {{endif}} - {{if True}} + + height : unsigned int Height of plane - {{endif}} - {{if True}} + + depth : unsigned int Depth of plane - {{endif}} - {{if True}} + + pitch : unsigned int Pitch of plane - {{endif}} - {{if True}} + + numChannels : unsigned int Number of channels for the plane - {{endif}} - {{if True}} + + channelDesc : cudaChannelFormatDesc Channel Format Descriptor - {{endif}} - {{if True}} + + reserved : list[unsigned int] Reserved for future use - {{endif}} + Methods ------- @@ -4591,24 +4325,22 @@ cdef class cudaEglPlaneDesc_st: """ cdef cyruntime.cudaEglPlaneDesc_st _pvt_val cdef cyruntime.cudaEglPlaneDesc_st* _pvt_ptr - {{if True}} + cdef cudaChannelFormatDesc _channelDesc - {{endif}} -{{endif}} -{{if True}} + cdef class anon_union12: """ Attributes ---------- - {{if True}} + pArray : list[cudaArray_t] - {{endif}} - {{if True}} + + pPitch : list[cudaPitchedPtr] - {{endif}} + Methods ------- @@ -4616,8 +4348,6 @@ cdef class anon_union12: Get memory address of class instance """ cdef cyruntime.cudaEglFrame_st* _pvt_ptr -{{endif}} -{{if True}} cdef class cudaEglFrame_st: """ @@ -4632,26 +4362,26 @@ cdef class cudaEglFrame_st: Attributes ---------- - {{if True}} + frame : anon_union12 - {{endif}} - {{if True}} + + planeDesc : list[cudaEglPlaneDesc] CUDA EGL Plane Descriptor cudaEglPlaneDesc - {{endif}} - {{if True}} + + planeCount : unsigned int Number of planes - {{endif}} - {{if True}} + + frameType : cudaEglFrameType Array or Pitch - {{endif}} - {{if True}} + + eglColorFormat : cudaEglColorFormat CUDA EGL Color Format - {{endif}} + Methods ------- @@ -4660,20 +4390,18 @@ cdef class cudaEglFrame_st: """ cdef cyruntime.cudaEglFrame_st* _val_ptr cdef cyruntime.cudaEglFrame_st* _pvt_ptr - {{if True}} + cdef anon_union12 _frame - {{endif}} -{{endif}} -{{if 'CUuuid' in found_types}} + cdef class CUuuid(CUuuid_st): """ Attributes ---------- - {{if 'CUuuid_st.bytes' in found_struct}} + bytes : bytes < CUDA definition of UUID - {{endif}} + Methods ------- @@ -4681,17 +4409,15 @@ cdef class CUuuid(CUuuid_st): Get memory address of class instance """ pass -{{endif}} -{{if 'cudaUUID_t' in found_types}} cdef class cudaUUID_t(CUuuid_st): """ Attributes ---------- - {{if 'CUuuid_st.bytes' in found_struct}} + bytes : bytes < CUDA definition of UUID - {{endif}} + Methods ------- @@ -4699,8 +4425,6 @@ cdef class cudaUUID_t(CUuuid_st): Get memory address of class instance """ pass -{{endif}} -{{if 'cudaIpcEventHandle_t' in found_types}} cdef class cudaIpcEventHandle_t(cudaIpcEventHandle_st): """ @@ -4708,10 +4432,10 @@ cdef class cudaIpcEventHandle_t(cudaIpcEventHandle_st): Attributes ---------- - {{if 'cudaIpcEventHandle_st.reserved' in found_struct}} + reserved : bytes - {{endif}} + Methods ------- @@ -4719,8 +4443,6 @@ cdef class cudaIpcEventHandle_t(cudaIpcEventHandle_st): Get memory address of class instance """ pass -{{endif}} -{{if 'cudaIpcMemHandle_t' in found_types}} cdef class cudaIpcMemHandle_t(cudaIpcMemHandle_st): """ @@ -4728,10 +4450,10 @@ cdef class cudaIpcMemHandle_t(cudaIpcMemHandle_st): Attributes ---------- - {{if 'cudaIpcMemHandle_st.reserved' in found_struct}} + reserved : bytes - {{endif}} + Methods ------- @@ -4739,17 +4461,15 @@ cdef class cudaIpcMemHandle_t(cudaIpcMemHandle_st): Get memory address of class instance """ pass -{{endif}} -{{if 'cudaMemFabricHandle_t' in found_types}} cdef class cudaMemFabricHandle_t(cudaMemFabricHandle_st): """ Attributes ---------- - {{if 'cudaMemFabricHandle_st.reserved' in found_struct}} + reserved : bytes - {{endif}} + Methods ------- @@ -4757,8 +4477,6 @@ cdef class cudaMemFabricHandle_t(cudaMemFabricHandle_st): Get memory address of class instance """ pass -{{endif}} -{{if 'cudaDevSmResourceGroupParams' in found_types}} cdef class cudaDevSmResourceGroupParams(cudaDevSmResourceGroupParams_st): """ @@ -4766,29 +4484,29 @@ cdef class cudaDevSmResourceGroupParams(cudaDevSmResourceGroupParams_st): Attributes ---------- - {{if 'cudaDevSmResourceGroupParams_st.smCount' in found_struct}} + smCount : unsigned int The amount of SMs available in this resource. - {{endif}} - {{if 'cudaDevSmResourceGroupParams_st.coscheduledSmCount' in found_struct}} + + coscheduledSmCount : unsigned int The amount of co-scheduled SMs grouped together for locality purposes. - {{endif}} - {{if 'cudaDevSmResourceGroupParams_st.preferredCoscheduledSmCount' in found_struct}} + + preferredCoscheduledSmCount : unsigned int When possible, combine co-scheduled groups together into larger groups of this size. - {{endif}} - {{if 'cudaDevSmResourceGroupParams_st.flags' in found_struct}} + + flags : unsigned int Combination of `cudaDevSmResourceGroup_flags` values to indicate this this group is created. - {{endif}} - {{if 'cudaDevSmResourceGroupParams_st.reserved' in found_struct}} + + reserved : list[unsigned int] Reserved for future use - ensure this is zero initialized. - {{endif}} + Methods ------- @@ -4796,8 +4514,6 @@ cdef class cudaDevSmResourceGroupParams(cudaDevSmResourceGroupParams_st): Get memory address of class instance """ pass -{{endif}} -{{if 'cudaDevResource' in found_types}} cdef class cudaDevResource(cudaDevResource_st): """ @@ -4819,35 +4535,35 @@ cdef class cudaDevResource(cudaDevResource_st): Attributes ---------- - {{if 'cudaDevResource_st.type' in found_struct}} + type : cudaDevResourceType Type of resource, dictates which union field was last set - {{endif}} - {{if 'cudaDevResource_st._internal_padding' in found_struct}} + + _internal_padding : bytes - {{endif}} - {{if 'cudaDevResource_st.sm' in found_struct}} + + sm : cudaDevSmResource Resource corresponding to cudaDevResourceTypeSm `typename`. - {{endif}} - {{if 'cudaDevResource_st.wqConfig' in found_struct}} + + wqConfig : cudaDevWorkqueueConfigResource Resource corresponding to cudaDevResourceTypeWorkqueueConfig `typename`. - {{endif}} - {{if 'cudaDevResource_st.wq' in found_struct}} + + wq : cudaDevWorkqueueResource Resource corresponding to cudaDevResourceTypeWorkqueue `typename`. - {{endif}} - {{if 'cudaDevResource_st._oversize' in found_struct}} + + _oversize : bytes - {{endif}} - {{if 'cudaDevResource_st.nextResource' in found_struct}} + + nextResource : cudaDevResource_st - {{endif}} + Methods ------- @@ -4855,8 +4571,6 @@ cdef class cudaDevResource(cudaDevResource_st): Get memory address of class instance """ pass -{{endif}} -{{if 'cudaGraphEdgeData' in found_types}} cdef class cudaGraphEdgeData(cudaGraphEdgeData_st): """ @@ -4867,7 +4581,7 @@ cdef class cudaGraphEdgeData(cudaGraphEdgeData_st): Attributes ---------- - {{if 'cudaGraphEdgeData_st.from_port' in found_struct}} + from_port : bytes This indicates when the dependency is triggered from the upstream node on the edge. The meaning is specfic to the node type. A value @@ -4878,8 +4592,8 @@ cdef class cudaGraphEdgeData(cudaGraphEdgeData_st): cudaGraphKernelNodePortDefault, cudaGraphKernelNodePortProgrammatic, or cudaGraphKernelNodePortLaunchCompletion. - {{endif}} - {{if 'cudaGraphEdgeData_st.to_port' in found_struct}} + + to_port : bytes This indicates what portion of the downstream node is dependent on the upstream node or portion thereof (indicated by `from_port`). @@ -4887,18 +4601,18 @@ cdef class cudaGraphEdgeData(cudaGraphEdgeData_st): means the entirety of the downstream node is dependent on the upstream work. Currently no node types define non-zero ports. Accordingly, this field must be set to zero. - {{endif}} - {{if 'cudaGraphEdgeData_st.type' in found_struct}} + + type : bytes This should be populated with a value from cudaGraphDependencyType. (It is typed as char due to compiler-specific layout of bitfields.) See cudaGraphDependencyType. - {{endif}} - {{if 'cudaGraphEdgeData_st.reserved' in found_struct}} + + reserved : bytes These bytes are unused and must be zeroed. This ensures compatibility if additional fields are added in the future. - {{endif}} + Methods ------- @@ -4906,8 +4620,6 @@ cdef class cudaGraphEdgeData(cudaGraphEdgeData_st): Get memory address of class instance """ pass -{{endif}} -{{if 'cudaGraphInstantiateParams' in found_types}} cdef class cudaGraphInstantiateParams(cudaGraphInstantiateParams_st): """ @@ -4915,22 +4627,22 @@ cdef class cudaGraphInstantiateParams(cudaGraphInstantiateParams_st): Attributes ---------- - {{if 'cudaGraphInstantiateParams_st.flags' in found_struct}} + flags : unsigned long long Instantiation flags - {{endif}} - {{if 'cudaGraphInstantiateParams_st.uploadStream' in found_struct}} + + uploadStream : cudaStream_t Upload stream - {{endif}} - {{if 'cudaGraphInstantiateParams_st.errNode_out' in found_struct}} + + errNode_out : cudaGraphNode_t The node which caused instantiation to fail, if any - {{endif}} - {{if 'cudaGraphInstantiateParams_st.result_out' in found_struct}} + + result_out : cudaGraphInstantiateResult Whether instantiation was successful. If it failed, the reason why - {{endif}} + Methods ------- @@ -4938,8 +4650,6 @@ cdef class cudaGraphInstantiateParams(cudaGraphInstantiateParams_st): Get memory address of class instance """ pass -{{endif}} -{{if 'cudaGraphExecUpdateResultInfo' in found_types}} cdef class cudaGraphExecUpdateResultInfo(cudaGraphExecUpdateResultInfo_st): """ @@ -4947,21 +4657,21 @@ cdef class cudaGraphExecUpdateResultInfo(cudaGraphExecUpdateResultInfo_st): Attributes ---------- - {{if 'cudaGraphExecUpdateResultInfo_st.result' in found_struct}} + result : cudaGraphExecUpdateResult Gives more specific detail when a cuda graph update fails. - {{endif}} - {{if 'cudaGraphExecUpdateResultInfo_st.errorNode' in found_struct}} + + errorNode : cudaGraphNode_t The "to node" of the error edge when the topologies do not match. The error node when the error is associated with a specific node. NULL when the error is generic. - {{endif}} - {{if 'cudaGraphExecUpdateResultInfo_st.errorFromNode' in found_struct}} + + errorFromNode : cudaGraphNode_t The from node of error edge when the topologies do not match. Otherwise NULL. - {{endif}} + Methods ------- @@ -4969,8 +4679,6 @@ cdef class cudaGraphExecUpdateResultInfo(cudaGraphExecUpdateResultInfo_st): Get memory address of class instance """ pass -{{endif}} -{{if 'cudaLaunchMemSyncDomainMap' in found_types}} cdef class cudaLaunchMemSyncDomainMap(cudaLaunchMemSyncDomainMap_st): """ @@ -4984,14 +4692,14 @@ cdef class cudaLaunchMemSyncDomainMap(cudaLaunchMemSyncDomainMap_st): Attributes ---------- - {{if 'cudaLaunchMemSyncDomainMap_st.default_' in found_struct}} + default_ : bytes The default domain ID to use for designated kernels - {{endif}} - {{if 'cudaLaunchMemSyncDomainMap_st.remote' in found_struct}} + + remote : bytes The remote domain ID to use for designated kernels - {{endif}} + Methods ------- @@ -4999,8 +4707,6 @@ cdef class cudaLaunchMemSyncDomainMap(cudaLaunchMemSyncDomainMap_st): Get memory address of class instance """ pass -{{endif}} -{{if 'cudaLaunchAttribute' in found_types}} cdef class cudaLaunchAttribute(cudaLaunchAttribute_st): """ @@ -5008,14 +4714,14 @@ cdef class cudaLaunchAttribute(cudaLaunchAttribute_st): Attributes ---------- - {{if 'cudaLaunchAttribute_st.id' in found_struct}} + id : cudaLaunchAttributeID Attribute to set - {{endif}} - {{if 'cudaLaunchAttribute_st.val' in found_struct}} + + val : cudaLaunchAttributeValue Value of the attribute - {{endif}} + Methods ------- @@ -5023,8 +4729,6 @@ cdef class cudaLaunchAttribute(cudaLaunchAttribute_st): Get memory address of class instance """ pass -{{endif}} -{{if 'cudaAsyncNotificationInfo_t' in found_types}} cdef class cudaAsyncNotificationInfo_t(cudaAsyncNotificationInfo): """ @@ -5032,15 +4736,15 @@ cdef class cudaAsyncNotificationInfo_t(cudaAsyncNotificationInfo): Attributes ---------- - {{if 'cudaAsyncNotificationInfo.type' in found_struct}} + type : cudaAsyncNotificationType The type of notification being sent - {{endif}} - {{if 'cudaAsyncNotificationInfo.info' in found_struct}} + + info : anon_union11 Information about the notification. `typename` must be checked in order to interpret this field. - {{endif}} + Methods ------- @@ -5048,8 +4752,6 @@ cdef class cudaAsyncNotificationInfo_t(cudaAsyncNotificationInfo): Get memory address of class instance """ pass -{{endif}} -{{if True}} cdef class cudaStreamAttrValue(cudaLaunchAttributeValue): """ @@ -5057,25 +4759,25 @@ cdef class cudaStreamAttrValue(cudaLaunchAttributeValue): Attributes ---------- - {{if 'cudaLaunchAttributeValue.pad' in found_struct}} + pad : bytes - {{endif}} - {{if 'cudaLaunchAttributeValue.accessPolicyWindow' in found_struct}} + + accessPolicyWindow : cudaAccessPolicyWindow Value of launch attribute cudaLaunchAttributeAccessPolicyWindow. - {{endif}} - {{if 'cudaLaunchAttributeValue.cooperative' in found_struct}} + + cooperative : int Value of launch attribute cudaLaunchAttributeCooperative. Nonzero indicates a cooperative kernel (see cudaLaunchCooperativeKernel). - {{endif}} - {{if 'cudaLaunchAttributeValue.syncPolicy' in found_struct}} + + syncPolicy : cudaSynchronizationPolicy Value of launch attribute cudaLaunchAttributeSynchronizationPolicy. cudaSynchronizationPolicy for work queued up in this stream. - {{endif}} - {{if 'cudaLaunchAttributeValue.clusterDim' in found_struct}} + + clusterDim : anon_struct17 Value of launch attribute cudaLaunchAttributeClusterDimension that represents the desired cluster dimensions for the kernel. Opaque @@ -5084,19 +4786,19 @@ cdef class cudaStreamAttrValue(cudaLaunchAttributeValue): `y` - The Y dimension of the cluster, in blocks. Must be a divisor of the grid Y dimension. - `z` - The Z dimension of the cluster, in blocks. Must be a divisor of the grid Z dimension. - {{endif}} - {{if 'cudaLaunchAttributeValue.clusterSchedulingPolicyPreference' in found_struct}} + + clusterSchedulingPolicyPreference : cudaClusterSchedulingPolicy Value of launch attribute cudaLaunchAttributeClusterSchedulingPolicyPreference. Cluster scheduling policy preference for the kernel. - {{endif}} - {{if 'cudaLaunchAttributeValue.programmaticStreamSerializationAllowed' in found_struct}} + + programmaticStreamSerializationAllowed : int Value of launch attribute cudaLaunchAttributeProgrammaticStreamSerialization. - {{endif}} - {{if 'cudaLaunchAttributeValue.programmaticEvent' in found_struct}} + + programmaticEvent : anon_struct18 Value of launch attribute cudaLaunchAttributeProgrammaticEvent with the following fields: - `cudaEvent_t` event - Event to fire when @@ -5104,23 +4806,23 @@ cdef class cudaStreamAttrValue(cudaLaunchAttributeValue): cudaEventRecordWithFlags. Does not accept cudaEventRecordExternal. - `int` triggerAtBlockStart - If this is set to non-0, each block launch will automatically trigger the event. - {{endif}} - {{if 'cudaLaunchAttributeValue.priority' in found_struct}} + + priority : int Value of launch attribute cudaLaunchAttributePriority. Execution priority of the kernel. - {{endif}} - {{if 'cudaLaunchAttributeValue.memSyncDomainMap' in found_struct}} + + memSyncDomainMap : cudaLaunchMemSyncDomainMap Value of launch attribute cudaLaunchAttributeMemSyncDomainMap. See cudaLaunchMemSyncDomainMap. - {{endif}} - {{if 'cudaLaunchAttributeValue.memSyncDomain' in found_struct}} + + memSyncDomain : cudaLaunchMemSyncDomain Value of launch attribute cudaLaunchAttributeMemSyncDomain. See cudaLaunchMemSyncDomain. - {{endif}} - {{if 'cudaLaunchAttributeValue.preferredClusterDim' in found_struct}} + + preferredClusterDim : anon_struct19 Value of launch attribute cudaLaunchAttributePreferredClusterDimension that represents the @@ -5134,16 +4836,16 @@ cdef class cudaStreamAttrValue(cudaLaunchAttributeValue): ::cudaLaunchAttributeValue::clusterDim. - `z` - The Z dimension of the preferred cluster, in blocks. Must be equal to the `z` field of ::cudaLaunchAttributeValue::clusterDim. - {{endif}} - {{if 'cudaLaunchAttributeValue.launchCompletionEvent' in found_struct}} + + launchCompletionEvent : anon_struct20 Value of launch attribute cudaLaunchAttributeLaunchCompletionEvent with the following fields: - `cudaEvent_t` event - Event to fire when the last block launches. - `int` flags - Event record flags, see cudaEventRecordWithFlags. Does not accept cudaEventRecordExternal. - {{endif}} - {{if 'cudaLaunchAttributeValue.deviceUpdatableKernelNode' in found_struct}} + + deviceUpdatableKernelNode : anon_struct21 Value of launch attribute cudaLaunchAttributeDeviceUpdatableKernelNode with the following @@ -5151,27 +4853,27 @@ cdef class cudaStreamAttrValue(cudaLaunchAttributeValue): kernel node should be device-updatable. - `cudaGraphDeviceNode_t` devNode - Returns a handle to pass to the various device-side update functions. - {{endif}} - {{if 'cudaLaunchAttributeValue.sharedMemCarveout' in found_struct}} + + sharedMemCarveout : unsigned int Value of launch attribute cudaLaunchAttributePreferredSharedMemoryCarveout. - {{endif}} - {{if 'cudaLaunchAttributeValue.nvlinkUtilCentricScheduling' in found_struct}} + + nvlinkUtilCentricScheduling : unsigned int Value of launch attribute cudaLaunchAttributeNvlinkUtilCentricScheduling. - {{endif}} - {{if 'cudaLaunchAttributeValue.portableClusterSizeMode' in found_struct}} + + portableClusterSizeMode : cudaLaunchAttributePortableClusterMode Value of launch attribute cudaLaunchAttributePortableClusterSizeMode - {{endif}} - {{if 'cudaLaunchAttributeValue.sharedMemoryMode' in found_struct}} + + sharedMemoryMode : cudaSharedMemoryMode Value of launch attribute cudaLaunchAttributeSharedMemoryMode. See cudaSharedMemoryMode for acceptable values. - {{endif}} + Methods ------- @@ -5179,8 +4881,6 @@ cdef class cudaStreamAttrValue(cudaLaunchAttributeValue): Get memory address of class instance """ pass -{{endif}} -{{if True}} cdef class cudaKernelNodeAttrValue(cudaLaunchAttributeValue): """ @@ -5188,25 +4888,25 @@ cdef class cudaKernelNodeAttrValue(cudaLaunchAttributeValue): Attributes ---------- - {{if 'cudaLaunchAttributeValue.pad' in found_struct}} + pad : bytes - {{endif}} - {{if 'cudaLaunchAttributeValue.accessPolicyWindow' in found_struct}} + + accessPolicyWindow : cudaAccessPolicyWindow Value of launch attribute cudaLaunchAttributeAccessPolicyWindow. - {{endif}} - {{if 'cudaLaunchAttributeValue.cooperative' in found_struct}} + + cooperative : int Value of launch attribute cudaLaunchAttributeCooperative. Nonzero indicates a cooperative kernel (see cudaLaunchCooperativeKernel). - {{endif}} - {{if 'cudaLaunchAttributeValue.syncPolicy' in found_struct}} + + syncPolicy : cudaSynchronizationPolicy Value of launch attribute cudaLaunchAttributeSynchronizationPolicy. cudaSynchronizationPolicy for work queued up in this stream. - {{endif}} - {{if 'cudaLaunchAttributeValue.clusterDim' in found_struct}} + + clusterDim : anon_struct17 Value of launch attribute cudaLaunchAttributeClusterDimension that represents the desired cluster dimensions for the kernel. Opaque @@ -5215,19 +4915,19 @@ cdef class cudaKernelNodeAttrValue(cudaLaunchAttributeValue): `y` - The Y dimension of the cluster, in blocks. Must be a divisor of the grid Y dimension. - `z` - The Z dimension of the cluster, in blocks. Must be a divisor of the grid Z dimension. - {{endif}} - {{if 'cudaLaunchAttributeValue.clusterSchedulingPolicyPreference' in found_struct}} + + clusterSchedulingPolicyPreference : cudaClusterSchedulingPolicy Value of launch attribute cudaLaunchAttributeClusterSchedulingPolicyPreference. Cluster scheduling policy preference for the kernel. - {{endif}} - {{if 'cudaLaunchAttributeValue.programmaticStreamSerializationAllowed' in found_struct}} + + programmaticStreamSerializationAllowed : int Value of launch attribute cudaLaunchAttributeProgrammaticStreamSerialization. - {{endif}} - {{if 'cudaLaunchAttributeValue.programmaticEvent' in found_struct}} + + programmaticEvent : anon_struct18 Value of launch attribute cudaLaunchAttributeProgrammaticEvent with the following fields: - `cudaEvent_t` event - Event to fire when @@ -5235,23 +4935,23 @@ cdef class cudaKernelNodeAttrValue(cudaLaunchAttributeValue): cudaEventRecordWithFlags. Does not accept cudaEventRecordExternal. - `int` triggerAtBlockStart - If this is set to non-0, each block launch will automatically trigger the event. - {{endif}} - {{if 'cudaLaunchAttributeValue.priority' in found_struct}} + + priority : int Value of launch attribute cudaLaunchAttributePriority. Execution priority of the kernel. - {{endif}} - {{if 'cudaLaunchAttributeValue.memSyncDomainMap' in found_struct}} + + memSyncDomainMap : cudaLaunchMemSyncDomainMap Value of launch attribute cudaLaunchAttributeMemSyncDomainMap. See cudaLaunchMemSyncDomainMap. - {{endif}} - {{if 'cudaLaunchAttributeValue.memSyncDomain' in found_struct}} + + memSyncDomain : cudaLaunchMemSyncDomain Value of launch attribute cudaLaunchAttributeMemSyncDomain. See cudaLaunchMemSyncDomain. - {{endif}} - {{if 'cudaLaunchAttributeValue.preferredClusterDim' in found_struct}} + + preferredClusterDim : anon_struct19 Value of launch attribute cudaLaunchAttributePreferredClusterDimension that represents the @@ -5265,16 +4965,16 @@ cdef class cudaKernelNodeAttrValue(cudaLaunchAttributeValue): ::cudaLaunchAttributeValue::clusterDim. - `z` - The Z dimension of the preferred cluster, in blocks. Must be equal to the `z` field of ::cudaLaunchAttributeValue::clusterDim. - {{endif}} - {{if 'cudaLaunchAttributeValue.launchCompletionEvent' in found_struct}} + + launchCompletionEvent : anon_struct20 Value of launch attribute cudaLaunchAttributeLaunchCompletionEvent with the following fields: - `cudaEvent_t` event - Event to fire when the last block launches. - `int` flags - Event record flags, see cudaEventRecordWithFlags. Does not accept cudaEventRecordExternal. - {{endif}} - {{if 'cudaLaunchAttributeValue.deviceUpdatableKernelNode' in found_struct}} + + deviceUpdatableKernelNode : anon_struct21 Value of launch attribute cudaLaunchAttributeDeviceUpdatableKernelNode with the following @@ -5282,27 +4982,27 @@ cdef class cudaKernelNodeAttrValue(cudaLaunchAttributeValue): kernel node should be device-updatable. - `cudaGraphDeviceNode_t` devNode - Returns a handle to pass to the various device-side update functions. - {{endif}} - {{if 'cudaLaunchAttributeValue.sharedMemCarveout' in found_struct}} + + sharedMemCarveout : unsigned int Value of launch attribute cudaLaunchAttributePreferredSharedMemoryCarveout. - {{endif}} - {{if 'cudaLaunchAttributeValue.nvlinkUtilCentricScheduling' in found_struct}} + + nvlinkUtilCentricScheduling : unsigned int Value of launch attribute cudaLaunchAttributeNvlinkUtilCentricScheduling. - {{endif}} - {{if 'cudaLaunchAttributeValue.portableClusterSizeMode' in found_struct}} + + portableClusterSizeMode : cudaLaunchAttributePortableClusterMode Value of launch attribute cudaLaunchAttributePortableClusterSizeMode - {{endif}} - {{if 'cudaLaunchAttributeValue.sharedMemoryMode' in found_struct}} + + sharedMemoryMode : cudaSharedMemoryMode Value of launch attribute cudaLaunchAttributeSharedMemoryMode. See cudaSharedMemoryMode for acceptable values. - {{endif}} + Methods ------- @@ -5310,8 +5010,6 @@ cdef class cudaKernelNodeAttrValue(cudaLaunchAttributeValue): Get memory address of class instance """ pass -{{endif}} -{{if True}} cdef class cudaEglPlaneDesc(cudaEglPlaneDesc_st): """ @@ -5320,34 +5018,34 @@ cdef class cudaEglPlaneDesc(cudaEglPlaneDesc_st): Attributes ---------- - {{if True}} + width : unsigned int Width of plane - {{endif}} - {{if True}} + + height : unsigned int Height of plane - {{endif}} - {{if True}} + + depth : unsigned int Depth of plane - {{endif}} - {{if True}} + + pitch : unsigned int Pitch of plane - {{endif}} - {{if True}} + + numChannels : unsigned int Number of channels for the plane - {{endif}} - {{if True}} + + channelDesc : cudaChannelFormatDesc Channel Format Descriptor - {{endif}} - {{if True}} + + reserved : list[unsigned int] Reserved for future use - {{endif}} + Methods ------- @@ -5355,8 +5053,6 @@ cdef class cudaEglPlaneDesc(cudaEglPlaneDesc_st): Get memory address of class instance """ pass -{{endif}} -{{if True}} cdef class cudaEglFrame(cudaEglFrame_st): """ @@ -5371,26 +5067,26 @@ cdef class cudaEglFrame(cudaEglFrame_st): Attributes ---------- - {{if True}} + frame : anon_union12 - {{endif}} - {{if True}} + + planeDesc : list[cudaEglPlaneDesc] CUDA EGL Plane Descriptor cudaEglPlaneDesc - {{endif}} - {{if True}} + + planeCount : unsigned int Number of planes - {{endif}} - {{if True}} + + frameType : cudaEglFrameType Array or Pitch - {{endif}} - {{if True}} + + eglColorFormat : cudaEglColorFormat CUDA EGL Color Format - {{endif}} + Methods ------- @@ -5398,8 +5094,6 @@ cdef class cudaEglFrame(cudaEglFrame_st): Get memory address of class instance """ pass -{{endif}} -{{if 'cudaStream_t' in found_types}} cdef class cudaStream_t(driver.CUstream): """ @@ -5413,9 +5107,6 @@ cdef class cudaStream_t(driver.CUstream): """ pass -{{endif}} - -{{if 'cudaEvent_t' in found_types}} cdef class cudaEvent_t(driver.CUevent): """ @@ -5429,9 +5120,6 @@ cdef class cudaEvent_t(driver.CUevent): """ pass -{{endif}} - -{{if 'cudaGraph_t' in found_types}} cdef class cudaGraph_t(driver.CUgraph): """ @@ -5445,9 +5133,6 @@ cdef class cudaGraph_t(driver.CUgraph): """ pass -{{endif}} - -{{if 'cudaGraphNode_t' in found_types}} cdef class cudaGraphNode_t(driver.CUgraphNode): """ @@ -5461,9 +5146,6 @@ cdef class cudaGraphNode_t(driver.CUgraphNode): """ pass -{{endif}} - -{{if 'cudaUserObject_t' in found_types}} cdef class cudaUserObject_t(driver.CUuserObject): """ @@ -5477,9 +5159,6 @@ cdef class cudaUserObject_t(driver.CUuserObject): """ pass -{{endif}} - -{{if 'cudaFunction_t' in found_types}} cdef class cudaFunction_t(driver.CUfunction): """ @@ -5493,9 +5172,6 @@ cdef class cudaFunction_t(driver.CUfunction): """ pass -{{endif}} - -{{if 'cudaMemPool_t' in found_types}} cdef class cudaMemPool_t(driver.CUmemoryPool): """ @@ -5509,9 +5185,6 @@ cdef class cudaMemPool_t(driver.CUmemoryPool): """ pass -{{endif}} - -{{if 'cudaGraphExec_t' in found_types}} cdef class cudaGraphExec_t(driver.CUgraphExec): """ @@ -5525,9 +5198,6 @@ cdef class cudaGraphExec_t(driver.CUgraphExec): """ pass -{{endif}} - -{{if True}} cdef class cudaEglStreamConnection(driver.CUeglStreamConnection): """ @@ -5541,9 +5211,6 @@ cdef class cudaEglStreamConnection(driver.CUeglStreamConnection): """ pass -{{endif}} - -{{if 'cudaGraphConditionalHandle' in found_types}} cdef class cudaGraphConditionalHandle: """ @@ -5558,9 +5225,6 @@ cdef class cudaGraphConditionalHandle: """ cdef cyruntime.cudaGraphConditionalHandle _pvt_val cdef cyruntime.cudaGraphConditionalHandle* _pvt_ptr -{{endif}} - -{{if 'cudaLogIterator' in found_types}} cdef class cudaLogIterator: """ @@ -5573,9 +5237,6 @@ cdef class cudaLogIterator: """ cdef cyruntime.cudaLogIterator _pvt_val cdef cyruntime.cudaLogIterator* _pvt_ptr -{{endif}} - -{{if 'cudaSurfaceObject_t' in found_types}} cdef class cudaSurfaceObject_t: """ @@ -5590,9 +5251,6 @@ cdef class cudaSurfaceObject_t: """ cdef cyruntime.cudaSurfaceObject_t _pvt_val cdef cyruntime.cudaSurfaceObject_t* _pvt_ptr -{{endif}} - -{{if 'cudaTextureObject_t' in found_types}} cdef class cudaTextureObject_t: """ @@ -5607,9 +5265,6 @@ cdef class cudaTextureObject_t: """ cdef cyruntime.cudaTextureObject_t _pvt_val cdef cyruntime.cudaTextureObject_t* _pvt_ptr -{{endif}} - -{{if True}} cdef class GLenum: """ @@ -5622,9 +5277,6 @@ cdef class GLenum: """ cdef cyruntime.GLenum _pvt_val cdef cyruntime.GLenum* _pvt_ptr -{{endif}} - -{{if True}} cdef class GLuint: """ @@ -5637,9 +5289,6 @@ cdef class GLuint: """ cdef cyruntime.GLuint _pvt_val cdef cyruntime.GLuint* _pvt_ptr -{{endif}} - -{{if True}} cdef class EGLint: """ @@ -5652,9 +5301,6 @@ cdef class EGLint: """ cdef cyruntime.EGLint _pvt_val cdef cyruntime.EGLint* _pvt_ptr -{{endif}} - -{{if True}} cdef class VdpDevice: """ @@ -5667,9 +5313,6 @@ cdef class VdpDevice: """ cdef cyruntime.VdpDevice _pvt_val cdef cyruntime.VdpDevice* _pvt_ptr -{{endif}} - -{{if True}} cdef class VdpGetProcAddress: """ @@ -5682,9 +5325,6 @@ cdef class VdpGetProcAddress: """ cdef cyruntime.VdpGetProcAddress _pvt_val cdef cyruntime.VdpGetProcAddress* _pvt_ptr -{{endif}} - -{{if True}} cdef class VdpVideoSurface: """ @@ -5697,9 +5337,6 @@ cdef class VdpVideoSurface: """ cdef cyruntime.VdpVideoSurface _pvt_val cdef cyruntime.VdpVideoSurface* _pvt_ptr -{{endif}} - -{{if True}} cdef class VdpOutputSurface: """ @@ -5712,4 +5349,3 @@ cdef class VdpOutputSurface: """ cdef cyruntime.VdpOutputSurface _pvt_val cdef cyruntime.VdpOutputSurface* _pvt_ptr -{{endif}} diff --git a/cuda_bindings/cuda/bindings/runtime.pyx.in b/cuda_bindings/cuda/bindings/runtime.pyx similarity index 85% rename from cuda_bindings/cuda/bindings/runtime.pyx.in rename to cuda_bindings/cuda/bindings/runtime.pyx index a2cb9ed6b39..6e11bdfc932 100644 --- a/cuda_bindings/cuda/bindings/runtime.pyx.in +++ b/cuda_bindings/cuda/bindings/runtime.pyx @@ -2,7 +2,7 @@ # SPDX-License-Identifier: Apache-2.0 # This code was automatically generated with version 13.3.0. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=6fe2ed828d10a452e3b9a6c2b27e9f606eb6aec3dae2613d0a6eae475c7744a2 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=783d27cfa66fa4f5818edcf88141aeb96dcc0e27e73a77a36571f82f30f3bb47 from typing import Any, Optional import cython import ctypes @@ -339,76 +339,74 @@ __CUDART_API_VERSION = cyruntime.__CUDART_API_VERSION #: Maximum number of planes per frame CUDA_EGL_MAX_PLANES = cyruntime.CUDA_EGL_MAX_PLANES -{{if 'cudaError' in found_types}} - class cudaError_t(_FastEnum): """ impl_private CUDA error types """ - {{if 'cudaSuccess' in found_values}} + cudaSuccess = ( cyruntime.cudaError.cudaSuccess, 'The API call returned with no errors. In the case of query calls, this also\n' 'means that the operation being queried is complete (see\n' ':py:obj:`~.cudaEventQuery()` and :py:obj:`~.cudaStreamQuery()`).\n' - ){{endif}} - {{if 'cudaErrorInvalidValue' in found_values}} + ) + cudaErrorInvalidValue = ( cyruntime.cudaError.cudaErrorInvalidValue, 'This indicates that one or more of the parameters passed to the API call is\n' 'not within an acceptable range of values.\n' - ){{endif}} - {{if 'cudaErrorMemoryAllocation' in found_values}} + ) + cudaErrorMemoryAllocation = ( cyruntime.cudaError.cudaErrorMemoryAllocation, 'The API call failed because it was unable to allocate enough memory or\n' 'other resources to perform the requested operation.\n' - ){{endif}} - {{if 'cudaErrorInitializationError' in found_values}} + ) + cudaErrorInitializationError = ( cyruntime.cudaError.cudaErrorInitializationError, 'The API call failed because the CUDA driver and runtime could not be\n' 'initialized.\n' - ){{endif}} - {{if 'cudaErrorCudartUnloading' in found_values}} + ) + cudaErrorCudartUnloading = ( cyruntime.cudaError.cudaErrorCudartUnloading, 'This indicates that a CUDA Runtime API call cannot be executed because it\n' 'is being called during process shut down, at a point in time after CUDA\n' 'driver has been unloaded.\n' - ){{endif}} - {{if 'cudaErrorProfilerDisabled' in found_values}} + ) + cudaErrorProfilerDisabled = ( cyruntime.cudaError.cudaErrorProfilerDisabled, 'This indicates profiler is not initialized for this run. This can happen\n' 'when the application is running with external profiling tools like visual\n' 'profiler.\n' - ){{endif}} - {{if 'cudaErrorProfilerNotInitialized' in found_values}} + ) + cudaErrorProfilerNotInitialized = ( cyruntime.cudaError.cudaErrorProfilerNotInitialized, '[Deprecated]\n' - ){{endif}} - {{if 'cudaErrorProfilerAlreadyStarted' in found_values}} + ) + cudaErrorProfilerAlreadyStarted = ( cyruntime.cudaError.cudaErrorProfilerAlreadyStarted, '[Deprecated]\n' - ){{endif}} - {{if 'cudaErrorProfilerAlreadyStopped' in found_values}} + ) + cudaErrorProfilerAlreadyStopped = ( cyruntime.cudaError.cudaErrorProfilerAlreadyStopped, '[Deprecated]\n' - ){{endif}} - {{if 'cudaErrorInvalidConfiguration' in found_values}} + ) + cudaErrorInvalidConfiguration = ( cyruntime.cudaError.cudaErrorInvalidConfiguration, @@ -417,196 +415,196 @@ class cudaError_t(_FastEnum): 'than the device supports will trigger this error, as will requesting too\n' 'many threads or blocks. See :py:obj:`~.cudaDeviceProp` for more device\n' 'limitations.\n' - ){{endif}} - {{if 'cudaErrorVersionTranslation' in found_values}} + ) + cudaErrorVersionTranslation = ( cyruntime.cudaError.cudaErrorVersionTranslation, 'This indicates that the driver is newer than the runtime version and\n' 'returned graph node parameter information that the runtime does not\n' 'understand and is unable to translate.\n' - ){{endif}} - {{if 'cudaErrorInvalidPitchValue' in found_values}} + ) + cudaErrorInvalidPitchValue = ( cyruntime.cudaError.cudaErrorInvalidPitchValue, 'This indicates that one or more of the pitch-related parameters passed to\n' 'the API call is not within the acceptable range for pitch.\n' - ){{endif}} - {{if 'cudaErrorInvalidSymbol' in found_values}} + ) + cudaErrorInvalidSymbol = ( cyruntime.cudaError.cudaErrorInvalidSymbol, 'This indicates that the symbol name/identifier passed to the API call is\n' 'not a valid name or identifier.\n' - ){{endif}} - {{if 'cudaErrorInvalidHostPointer' in found_values}} + ) + cudaErrorInvalidHostPointer = ( cyruntime.cudaError.cudaErrorInvalidHostPointer, 'This indicates that at least one host pointer passed to the API call is not\n' 'a valid host pointer.\n' '[Deprecated]\n' - ){{endif}} - {{if 'cudaErrorInvalidDevicePointer' in found_values}} + ) + cudaErrorInvalidDevicePointer = ( cyruntime.cudaError.cudaErrorInvalidDevicePointer, 'This indicates that at least one device pointer passed to the API call is\n' 'not a valid device pointer.\n' '[Deprecated]\n' - ){{endif}} - {{if 'cudaErrorInvalidTexture' in found_values}} + ) + cudaErrorInvalidTexture = ( cyruntime.cudaError.cudaErrorInvalidTexture, 'This indicates that the texture passed to the API call is not a valid\n' 'texture.\n' - ){{endif}} - {{if 'cudaErrorInvalidTextureBinding' in found_values}} + ) + cudaErrorInvalidTextureBinding = ( cyruntime.cudaError.cudaErrorInvalidTextureBinding, 'This indicates that the texture binding is not valid. This occurs if you\n' 'call :py:obj:`~.cudaGetTextureAlignmentOffset()` with an unbound texture.\n' - ){{endif}} - {{if 'cudaErrorInvalidChannelDescriptor' in found_values}} + ) + cudaErrorInvalidChannelDescriptor = ( cyruntime.cudaError.cudaErrorInvalidChannelDescriptor, 'This indicates that the channel descriptor passed to the API call is not\n' 'valid. This occurs if the format is not one of the formats specified by\n' ':py:obj:`~.cudaChannelFormatKind`, or if one of the dimensions is invalid.\n' - ){{endif}} - {{if 'cudaErrorInvalidMemcpyDirection' in found_values}} + ) + cudaErrorInvalidMemcpyDirection = ( cyruntime.cudaError.cudaErrorInvalidMemcpyDirection, 'This indicates that the direction of the memcpy passed to the API call is\n' 'not one of the types specified by :py:obj:`~.cudaMemcpyKind`.\n' - ){{endif}} - {{if 'cudaErrorAddressOfConstant' in found_values}} + ) + cudaErrorAddressOfConstant = ( cyruntime.cudaError.cudaErrorAddressOfConstant, 'This indicated that the user has taken the address of a constant variable,\n' 'which was forbidden up until the CUDA 3.1 release.\n' '[Deprecated]\n' - ){{endif}} - {{if 'cudaErrorTextureFetchFailed' in found_values}} + ) + cudaErrorTextureFetchFailed = ( cyruntime.cudaError.cudaErrorTextureFetchFailed, 'This indicated that a texture fetch was not able to be performed. This was\n' 'previously used for device emulation of texture operations.\n' '[Deprecated]\n' - ){{endif}} - {{if 'cudaErrorTextureNotBound' in found_values}} + ) + cudaErrorTextureNotBound = ( cyruntime.cudaError.cudaErrorTextureNotBound, 'This indicated that a texture was not bound for access. This was previously\n' 'used for device emulation of texture operations.\n' '[Deprecated]\n' - ){{endif}} - {{if 'cudaErrorSynchronizationError' in found_values}} + ) + cudaErrorSynchronizationError = ( cyruntime.cudaError.cudaErrorSynchronizationError, 'This indicated that a synchronization operation had failed. This was\n' 'previously used for some device emulation functions.\n' '[Deprecated]\n' - ){{endif}} - {{if 'cudaErrorInvalidFilterSetting' in found_values}} + ) + cudaErrorInvalidFilterSetting = ( cyruntime.cudaError.cudaErrorInvalidFilterSetting, 'This indicates that a non-float texture was being accessed with linear\n' 'filtering. This is not supported by CUDA.\n' - ){{endif}} - {{if 'cudaErrorInvalidNormSetting' in found_values}} + ) + cudaErrorInvalidNormSetting = ( cyruntime.cudaError.cudaErrorInvalidNormSetting, 'This indicates that an attempt was made to read an unsupported data type as\n' 'a normalized float. This is not supported by CUDA.\n' - ){{endif}} - {{if 'cudaErrorMixedDeviceExecution' in found_values}} + ) + cudaErrorMixedDeviceExecution = ( cyruntime.cudaError.cudaErrorMixedDeviceExecution, 'Mixing of device and device emulation code was not allowed.\n' '[Deprecated]\n' - ){{endif}} - {{if 'cudaErrorNotYetImplemented' in found_values}} + ) + cudaErrorNotYetImplemented = ( cyruntime.cudaError.cudaErrorNotYetImplemented, 'This indicates that the API call is not yet implemented. Production\n' 'releases of CUDA will never return this error.\n' '[Deprecated]\n' - ){{endif}} - {{if 'cudaErrorMemoryValueTooLarge' in found_values}} + ) + cudaErrorMemoryValueTooLarge = ( cyruntime.cudaError.cudaErrorMemoryValueTooLarge, 'This indicated that an emulated device pointer exceeded the 32-bit address\n' 'range.\n' '[Deprecated]\n' - ){{endif}} - {{if 'cudaErrorStubLibrary' in found_values}} + ) + cudaErrorStubLibrary = ( cyruntime.cudaError.cudaErrorStubLibrary, 'This indicates that the CUDA driver that the application has loaded is a\n' 'stub library. Applications that run with the stub rather than a real driver\n' 'loaded will result in CUDA API returning this error.\n' - ){{endif}} - {{if 'cudaErrorInsufficientDriver' in found_values}} + ) + cudaErrorInsufficientDriver = ( cyruntime.cudaError.cudaErrorInsufficientDriver, 'This indicates that the installed NVIDIA CUDA driver is older than the CUDA\n' 'runtime library. This is not a supported configuration. Users should\n' 'install an updated NVIDIA display driver to allow the application to run.\n' - ){{endif}} - {{if 'cudaErrorCallRequiresNewerDriver' in found_values}} + ) + cudaErrorCallRequiresNewerDriver = ( cyruntime.cudaError.cudaErrorCallRequiresNewerDriver, 'This indicates that the API call requires a newer CUDA driver than the one\n' 'currently installed. Users should install an updated NVIDIA CUDA driver to\n' 'allow the API call to succeed.\n' - ){{endif}} - {{if 'cudaErrorInvalidSurface' in found_values}} + ) + cudaErrorInvalidSurface = ( cyruntime.cudaError.cudaErrorInvalidSurface, 'This indicates that the surface passed to the API call is not a valid\n' 'surface.\n' - ){{endif}} - {{if 'cudaErrorDuplicateVariableName' in found_values}} + ) + cudaErrorDuplicateVariableName = ( cyruntime.cudaError.cudaErrorDuplicateVariableName, 'This indicates that multiple global or constant variables (across separate\n' 'CUDA source files in the application) share the same string name.\n' - ){{endif}} - {{if 'cudaErrorDuplicateTextureName' in found_values}} + ) + cudaErrorDuplicateTextureName = ( cyruntime.cudaError.cudaErrorDuplicateTextureName, 'This indicates that multiple textures (across separate CUDA source files in\n' 'the application) share the same string name.\n' - ){{endif}} - {{if 'cudaErrorDuplicateSurfaceName' in found_values}} + ) + cudaErrorDuplicateSurfaceName = ( cyruntime.cudaError.cudaErrorDuplicateSurfaceName, 'This indicates that multiple surfaces (across separate CUDA source files in\n' 'the application) share the same string name.\n' - ){{endif}} - {{if 'cudaErrorDevicesUnavailable' in found_values}} + ) + cudaErrorDevicesUnavailable = ( cyruntime.cudaError.cudaErrorDevicesUnavailable, @@ -617,8 +615,8 @@ class cudaError_t(_FastEnum): 'kernels have filled up the GPU and are blocking new work from starting.\n' 'They can also be unavailable due to memory constraints on a device that\n' 'already has active CUDA work being performed.\n' - ){{endif}} - {{if 'cudaErrorIncompatibleDriverContext' in found_values}} + ) + cudaErrorIncompatibleDriverContext = ( cyruntime.cudaError.cudaErrorIncompatibleDriverContext, @@ -630,32 +628,32 @@ class cudaError_t(_FastEnum): 'Runtime API call expects a primary driver context and the Driver context is\n' 'not primary, or because the Driver context has been destroyed. Please see\n' ':py:obj:`~.Interactions with the CUDA Driver API` for more information.\n' - ){{endif}} - {{if 'cudaErrorMissingConfiguration' in found_values}} + ) + cudaErrorMissingConfiguration = ( cyruntime.cudaError.cudaErrorMissingConfiguration, 'The device function being invoked (usually via\n' ':py:obj:`~.cudaLaunchKernel()`) was not previously configured via the\n' ':py:obj:`~.cudaConfigureCall()` function.\n' - ){{endif}} - {{if 'cudaErrorPriorLaunchFailure' in found_values}} + ) + cudaErrorPriorLaunchFailure = ( cyruntime.cudaError.cudaErrorPriorLaunchFailure, 'This indicated that a previous kernel launch failed. This was previously\n' 'used for device emulation of kernel launches.\n' '[Deprecated]\n' - ){{endif}} - {{if 'cudaErrorLaunchMaxDepthExceeded' in found_values}} + ) + cudaErrorLaunchMaxDepthExceeded = ( cyruntime.cudaError.cudaErrorLaunchMaxDepthExceeded, 'This error indicates that a device runtime grid launch did not occur\n' 'because the depth of the child grid would exceed the maximum supported\n' 'number of nested grid launches.\n' - ){{endif}} - {{if 'cudaErrorLaunchFileScopedTex' in found_values}} + ) + cudaErrorLaunchFileScopedTex = ( cyruntime.cudaError.cudaErrorLaunchFileScopedTex, @@ -663,8 +661,8 @@ class cudaError_t(_FastEnum): 'uses file-scoped textures which are unsupported by the device runtime.\n' 'Kernels launched via the device runtime only support textures created with\n' "the Texture Object API's.\n" - ){{endif}} - {{if 'cudaErrorLaunchFileScopedSurf' in found_values}} + ) + cudaErrorLaunchFileScopedSurf = ( cyruntime.cudaError.cudaErrorLaunchFileScopedSurf, @@ -672,8 +670,8 @@ class cudaError_t(_FastEnum): 'uses file-scoped surfaces which are unsupported by the device runtime.\n' 'Kernels launched via the device runtime only support surfaces created with\n' "the Surface Object API's.\n" - ){{endif}} - {{if 'cudaErrorSyncDepthExceeded' in found_values}} + ) + cudaErrorSyncDepthExceeded = ( cyruntime.cudaError.cudaErrorSyncDepthExceeded, @@ -690,8 +688,8 @@ class cudaError_t(_FastEnum): 'be used for user allocations. Note that :py:obj:`~.cudaDeviceSynchronize`\n' 'made from device runtime is only supported on devices of compute capability\n' '< 9.0.\n' - ){{endif}} - {{if 'cudaErrorLaunchPendingCountExceeded' in found_values}} + ) + cudaErrorLaunchPendingCountExceeded = ( cyruntime.cudaError.cudaErrorLaunchPendingCountExceeded, @@ -704,36 +702,36 @@ class cudaError_t(_FastEnum): 'runtime. Keep in mind that raising the limit of pending device runtime\n' 'launches will require the runtime to reserve device memory that cannot be\n' 'used for user allocations.\n' - ){{endif}} - {{if 'cudaErrorInvalidDeviceFunction' in found_values}} + ) + cudaErrorInvalidDeviceFunction = ( cyruntime.cudaError.cudaErrorInvalidDeviceFunction, 'The requested device function does not exist or is not compiled for the\n' 'proper device architecture.\n' - ){{endif}} - {{if 'cudaErrorNoDevice' in found_values}} + ) + cudaErrorNoDevice = ( cyruntime.cudaError.cudaErrorNoDevice, 'This indicates that no CUDA-capable devices were detected by the installed\n' 'CUDA driver.\n' - ){{endif}} - {{if 'cudaErrorInvalidDevice' in found_values}} + ) + cudaErrorInvalidDevice = ( cyruntime.cudaError.cudaErrorInvalidDevice, 'This indicates that the device ordinal supplied by the user does not\n' 'correspond to a valid CUDA device or that the action requested is invalid\n' 'for the specified device.\n' - ){{endif}} - {{if 'cudaErrorDeviceNotLicensed' in found_values}} + ) + cudaErrorDeviceNotLicensed = ( cyruntime.cudaError.cudaErrorDeviceNotLicensed, "This indicates that the device doesn't have a valid Grid License.\n" - ){{endif}} - {{if 'cudaErrorSoftwareValidityNotEstablished' in found_values}} + ) + cudaErrorSoftwareValidityNotEstablished = ( cyruntime.cudaError.cudaErrorSoftwareValidityNotEstablished, @@ -742,20 +740,20 @@ class cudaError_t(_FastEnum): 'CUDA 11.2, this error return indicates that at least one of these tests has\n' 'failed and the validity of either the runtime or the driver could not be\n' 'established.\n' - ){{endif}} - {{if 'cudaErrorStartupFailure' in found_values}} + ) + cudaErrorStartupFailure = ( cyruntime.cudaError.cudaErrorStartupFailure, 'This indicates an internal startup failure in the CUDA runtime.\n' - ){{endif}} - {{if 'cudaErrorInvalidKernelImage' in found_values}} + ) + cudaErrorInvalidKernelImage = ( cyruntime.cudaError.cudaErrorInvalidKernelImage, 'This indicates that the device kernel image is invalid.\n' - ){{endif}} - {{if 'cudaErrorDeviceUninitialized' in found_values}} + ) + cudaErrorDeviceUninitialized = ( cyruntime.cudaError.cudaErrorDeviceUninitialized, @@ -765,33 +763,33 @@ class cudaError_t(_FastEnum): ':py:obj:`~.cuCtxDestroy()` invoked on it). This can also be returned if a\n' 'user mixes different API versions (i.e. 3010 context with 3020 API calls).\n' 'See :py:obj:`~.cuCtxGetApiVersion()` for more details.\n' - ){{endif}} - {{if 'cudaErrorMapBufferObjectFailed' in found_values}} + ) + cudaErrorMapBufferObjectFailed = ( cyruntime.cudaError.cudaErrorMapBufferObjectFailed, 'This indicates that the buffer object could not be mapped.\n' - ){{endif}} - {{if 'cudaErrorUnmapBufferObjectFailed' in found_values}} + ) + cudaErrorUnmapBufferObjectFailed = ( cyruntime.cudaError.cudaErrorUnmapBufferObjectFailed, 'This indicates that the buffer object could not be unmapped.\n' - ){{endif}} - {{if 'cudaErrorArrayIsMapped' in found_values}} + ) + cudaErrorArrayIsMapped = ( cyruntime.cudaError.cudaErrorArrayIsMapped, 'This indicates that the specified array is currently mapped and thus cannot\n' 'be destroyed.\n' - ){{endif}} - {{if 'cudaErrorAlreadyMapped' in found_values}} + ) + cudaErrorAlreadyMapped = ( cyruntime.cudaError.cudaErrorAlreadyMapped, 'This indicates that the resource is already mapped.\n' - ){{endif}} - {{if 'cudaErrorNoKernelImageForDevice' in found_values}} + ) + cudaErrorNoKernelImageForDevice = ( cyruntime.cudaError.cudaErrorNoKernelImageForDevice, @@ -799,82 +797,82 @@ class cudaError_t(_FastEnum): 'the device. This can occur when a user specifies code generation options\n' 'for a particular CUDA source file that do not include the corresponding\n' 'device configuration.\n' - ){{endif}} - {{if 'cudaErrorAlreadyAcquired' in found_values}} + ) + cudaErrorAlreadyAcquired = ( cyruntime.cudaError.cudaErrorAlreadyAcquired, 'This indicates that a resource has already been acquired.\n' - ){{endif}} - {{if 'cudaErrorNotMapped' in found_values}} + ) + cudaErrorNotMapped = ( cyruntime.cudaError.cudaErrorNotMapped, 'This indicates that a resource is not mapped.\n' - ){{endif}} - {{if 'cudaErrorNotMappedAsArray' in found_values}} + ) + cudaErrorNotMappedAsArray = ( cyruntime.cudaError.cudaErrorNotMappedAsArray, 'This indicates that a mapped resource is not available for access as an\n' 'array.\n' - ){{endif}} - {{if 'cudaErrorNotMappedAsPointer' in found_values}} + ) + cudaErrorNotMappedAsPointer = ( cyruntime.cudaError.cudaErrorNotMappedAsPointer, 'This indicates that a mapped resource is not available for access as a\n' 'pointer.\n' - ){{endif}} - {{if 'cudaErrorECCUncorrectable' in found_values}} + ) + cudaErrorECCUncorrectable = ( cyruntime.cudaError.cudaErrorECCUncorrectable, 'This indicates that an uncorrectable ECC error was detected during\n' 'execution.\n' - ){{endif}} - {{if 'cudaErrorUnsupportedLimit' in found_values}} + ) + cudaErrorUnsupportedLimit = ( cyruntime.cudaError.cudaErrorUnsupportedLimit, 'This indicates that the :py:obj:`~.cudaLimit` passed to the API call is not\n' 'supported by the active device.\n' - ){{endif}} - {{if 'cudaErrorDeviceAlreadyInUse' in found_values}} + ) + cudaErrorDeviceAlreadyInUse = ( cyruntime.cudaError.cudaErrorDeviceAlreadyInUse, 'This indicates that a call tried to access an exclusive-thread device that\n' 'is already in use by a different thread.\n' - ){{endif}} - {{if 'cudaErrorPeerAccessUnsupported' in found_values}} + ) + cudaErrorPeerAccessUnsupported = ( cyruntime.cudaError.cudaErrorPeerAccessUnsupported, 'This error indicates that P2P access is not supported across the given\n' 'devices.\n' - ){{endif}} - {{if 'cudaErrorInvalidPtx' in found_values}} + ) + cudaErrorInvalidPtx = ( cyruntime.cudaError.cudaErrorInvalidPtx, 'A PTX compilation failed. The runtime may fall back to compiling PTX if an\n' 'application does not contain a suitable binary for the current device.\n' - ){{endif}} - {{if 'cudaErrorInvalidGraphicsContext' in found_values}} + ) + cudaErrorInvalidGraphicsContext = ( cyruntime.cudaError.cudaErrorInvalidGraphicsContext, 'This indicates an error with the OpenGL or DirectX context.\n' - ){{endif}} - {{if 'cudaErrorNvlinkUncorrectable' in found_values}} + ) + cudaErrorNvlinkUncorrectable = ( cyruntime.cudaError.cudaErrorNvlinkUncorrectable, 'This indicates that an uncorrectable NVLink error was detected during the\n' 'execution.\n' - ){{endif}} - {{if 'cudaErrorJitCompilerNotFound' in found_values}} + ) + cudaErrorJitCompilerNotFound = ( cyruntime.cudaError.cudaErrorJitCompilerNotFound, @@ -882,8 +880,8 @@ class cudaError_t(_FastEnum): 'Compiler library is used for PTX compilation. The runtime may fall back to\n' 'compiling PTX if an application does not contain a suitable binary for the\n' 'current device.\n' - ){{endif}} - {{if 'cudaErrorUnsupportedPtxVersion' in found_values}} + ) + cudaErrorUnsupportedPtxVersion = ( cyruntime.cudaError.cudaErrorUnsupportedPtxVersion, @@ -891,30 +889,30 @@ class cudaError_t(_FastEnum): 'toolchain. The most common reason for this, is the PTX was generated by a\n' 'compiler newer than what is supported by the CUDA driver and PTX JIT\n' 'compiler.\n' - ){{endif}} - {{if 'cudaErrorJitCompilationDisabled' in found_values}} + ) + cudaErrorJitCompilationDisabled = ( cyruntime.cudaError.cudaErrorJitCompilationDisabled, 'This indicates that the JIT compilation was disabled. The JIT compilation\n' 'compiles PTX. The runtime may fall back to compiling PTX if an application\n' 'does not contain a suitable binary for the current device.\n' - ){{endif}} - {{if 'cudaErrorUnsupportedExecAffinity' in found_values}} + ) + cudaErrorUnsupportedExecAffinity = ( cyruntime.cudaError.cudaErrorUnsupportedExecAffinity, 'This indicates that the provided execution affinity is not supported by the\n' 'device.\n' - ){{endif}} - {{if 'cudaErrorUnsupportedDevSideSync' in found_values}} + ) + cudaErrorUnsupportedDevSideSync = ( cyruntime.cudaError.cudaErrorUnsupportedDevSideSync, 'This indicates that the code to be compiled by the PTX JIT contains\n' 'unsupported call to cudaDeviceSynchronize.\n' - ){{endif}} - {{if 'cudaErrorContained' in found_values}} + ) + cudaErrorContained = ( cyruntime.cudaError.cudaErrorContained, @@ -924,53 +922,53 @@ class cudaError_t(_FastEnum): 'classes of hardware errors This leaves the process in an inconsistent state\n' 'and any further CUDA work will return the same error. To continue using\n' 'CUDA, the process must be terminated and relaunched.\n' - ){{endif}} - {{if 'cudaErrorInvalidSource' in found_values}} + ) + cudaErrorInvalidSource = ( cyruntime.cudaError.cudaErrorInvalidSource, 'This indicates that the device kernel source is invalid.\n' - ){{endif}} - {{if 'cudaErrorFileNotFound' in found_values}} + ) + cudaErrorFileNotFound = ( cyruntime.cudaError.cudaErrorFileNotFound, 'This indicates that the file specified was not found.\n' - ){{endif}} - {{if 'cudaErrorSharedObjectSymbolNotFound' in found_values}} + ) + cudaErrorSharedObjectSymbolNotFound = ( cyruntime.cudaError.cudaErrorSharedObjectSymbolNotFound, 'This indicates that a link to a shared object failed to resolve.\n' - ){{endif}} - {{if 'cudaErrorSharedObjectInitFailed' in found_values}} + ) + cudaErrorSharedObjectInitFailed = ( cyruntime.cudaError.cudaErrorSharedObjectInitFailed, 'This indicates that initialization of a shared object failed.\n' - ){{endif}} - {{if 'cudaErrorOperatingSystem' in found_values}} + ) + cudaErrorOperatingSystem = ( cyruntime.cudaError.cudaErrorOperatingSystem, 'This error indicates that an OS call failed.\n' - ){{endif}} - {{if 'cudaErrorInvalidResourceHandle' in found_values}} + ) + cudaErrorInvalidResourceHandle = ( cyruntime.cudaError.cudaErrorInvalidResourceHandle, 'This indicates that a resource handle passed to the API call was not valid.\n' 'Resource handles are opaque types like :py:obj:`~.cudaStream_t` and\n' ':py:obj:`~.cudaEvent_t`.\n' - ){{endif}} - {{if 'cudaErrorIllegalState' in found_values}} + ) + cudaErrorIllegalState = ( cyruntime.cudaError.cudaErrorIllegalState, 'This indicates that a resource required by the API call is not in a valid\n' 'state to perform the requested operation.\n' - ){{endif}} - {{if 'cudaErrorLossyQuery' in found_values}} + ) + cudaErrorLossyQuery = ( cyruntime.cudaError.cudaErrorLossyQuery, @@ -978,16 +976,16 @@ class cudaError_t(_FastEnum): 'would discard semantically important information. This is either due to the\n' 'object using funtionality newer than the API version used to introspect it\n' 'or omission of optional return arguments.\n' - ){{endif}} - {{if 'cudaErrorSymbolNotFound' in found_values}} + ) + cudaErrorSymbolNotFound = ( cyruntime.cudaError.cudaErrorSymbolNotFound, 'This indicates that a named symbol was not found. Examples of symbols are\n' 'global/constant variable names, driver function names, texture names, and\n' 'surface names.\n' - ){{endif}} - {{if 'cudaErrorNotReady' in found_values}} + ) + cudaErrorNotReady = ( cyruntime.cudaError.cudaErrorNotReady, @@ -996,8 +994,8 @@ class cudaError_t(_FastEnum): 'differently than :py:obj:`~.cudaSuccess` (which indicates completion).\n' 'Calls that may return this value include :py:obj:`~.cudaEventQuery()` and\n' ':py:obj:`~.cudaStreamQuery()`.\n' - ){{endif}} - {{if 'cudaErrorIllegalAddress' in found_values}} + ) + cudaErrorIllegalAddress = ( cyruntime.cudaError.cudaErrorIllegalAddress, @@ -1005,8 +1003,8 @@ class cudaError_t(_FastEnum): 'address. This leaves the process in an inconsistent state and any further\n' 'CUDA work will return the same error. To continue using CUDA, the process\n' 'must be terminated and relaunched.\n' - ){{endif}} - {{if 'cudaErrorLaunchOutOfResources' in found_values}} + ) + cudaErrorLaunchOutOfResources = ( cyruntime.cudaError.cudaErrorLaunchOutOfResources, @@ -1016,8 +1014,8 @@ class cudaError_t(_FastEnum): 'that the user has attempted to pass too many arguments to the device\n' "kernel, or the kernel launch specifies too many threads for the kernel's\n" 'register count.\n' - ){{endif}} - {{if 'cudaErrorLaunchTimeout' in found_values}} + ) + cudaErrorLaunchTimeout = ( cyruntime.cudaError.cudaErrorLaunchTimeout, @@ -1027,31 +1025,31 @@ class cudaError_t(_FastEnum): 'the process in an inconsistent state and any further CUDA work will return\n' 'the same error. To continue using CUDA, the process must be terminated and\n' 'relaunched.\n' - ){{endif}} - {{if 'cudaErrorLaunchIncompatibleTexturing' in found_values}} + ) + cudaErrorLaunchIncompatibleTexturing = ( cyruntime.cudaError.cudaErrorLaunchIncompatibleTexturing, 'This error indicates a kernel launch that uses an incompatible texturing\n' 'mode.\n' - ){{endif}} - {{if 'cudaErrorPeerAccessAlreadyEnabled' in found_values}} + ) + cudaErrorPeerAccessAlreadyEnabled = ( cyruntime.cudaError.cudaErrorPeerAccessAlreadyEnabled, 'This error indicates that a call to\n' ':py:obj:`~.cudaDeviceEnablePeerAccess()` is trying to re-enable peer\n' 'addressing on from a context which has already had peer addressing enabled.\n' - ){{endif}} - {{if 'cudaErrorPeerAccessNotEnabled' in found_values}} + ) + cudaErrorPeerAccessNotEnabled = ( cyruntime.cudaError.cudaErrorPeerAccessNotEnabled, 'This error indicates that :py:obj:`~.cudaDeviceDisablePeerAccess()` is\n' 'trying to disable peer addressing which has not been enabled yet via\n' ':py:obj:`~.cudaDeviceEnablePeerAccess()`.\n' - ){{endif}} - {{if 'cudaErrorSetOnActiveProcess' in found_values}} + ) + cudaErrorSetOnActiveProcess = ( cyruntime.cudaError.cudaErrorSetOnActiveProcess, @@ -1064,47 +1062,47 @@ class cudaError_t(_FastEnum): 'launching kernels are examples of non-device management operations). This\n' 'error can also be returned if using runtime/driver interoperability and\n' 'there is an existing :py:obj:`~.CUcontext` active on the host thread.\n' - ){{endif}} - {{if 'cudaErrorContextIsDestroyed' in found_values}} + ) + cudaErrorContextIsDestroyed = ( cyruntime.cudaError.cudaErrorContextIsDestroyed, 'This error indicates that the context current to the calling thread has\n' 'been destroyed using :py:obj:`~.cuCtxDestroy`, or is a primary context\n' 'which has not yet been initialized.\n' - ){{endif}} - {{if 'cudaErrorAssert' in found_values}} + ) + cudaErrorAssert = ( cyruntime.cudaError.cudaErrorAssert, 'An assert triggered in device code during kernel execution. The device\n' 'cannot be used again. All existing allocations are invalid. To continue\n' 'using CUDA, the process must be terminated and relaunched.\n' - ){{endif}} - {{if 'cudaErrorTooManyPeers' in found_values}} + ) + cudaErrorTooManyPeers = ( cyruntime.cudaError.cudaErrorTooManyPeers, 'This error indicates that the hardware resources required to enable peer\n' 'access have been exhausted for one or more of the devices passed to\n' ':py:obj:`~.cudaEnablePeerAccess()`.\n' - ){{endif}} - {{if 'cudaErrorHostMemoryAlreadyRegistered' in found_values}} + ) + cudaErrorHostMemoryAlreadyRegistered = ( cyruntime.cudaError.cudaErrorHostMemoryAlreadyRegistered, 'This error indicates that the memory range passed to\n' ':py:obj:`~.cudaHostRegister()` has already been registered.\n' - ){{endif}} - {{if 'cudaErrorHostMemoryNotRegistered' in found_values}} + ) + cudaErrorHostMemoryNotRegistered = ( cyruntime.cudaError.cudaErrorHostMemoryNotRegistered, 'This error indicates that the pointer passed to\n' ':py:obj:`~.cudaHostUnregister()` does not correspond to any currently\n' 'registered memory region.\n' - ){{endif}} - {{if 'cudaErrorHardwareStackError' in found_values}} + ) + cudaErrorHardwareStackError = ( cyruntime.cudaError.cudaErrorHardwareStackError, @@ -1113,8 +1111,8 @@ class cudaError_t(_FastEnum): 'leaves the process in an inconsistent state and any further CUDA work will\n' 'return the same error. To continue using CUDA, the process must be\n' 'terminated and relaunched.\n' - ){{endif}} - {{if 'cudaErrorIllegalInstruction' in found_values}} + ) + cudaErrorIllegalInstruction = ( cyruntime.cudaError.cudaErrorIllegalInstruction, @@ -1122,8 +1120,8 @@ class cudaError_t(_FastEnum): 'leaves the process in an inconsistent state and any further CUDA work will\n' 'return the same error. To continue using CUDA, the process must be\n' 'terminated and relaunched.\n' - ){{endif}} - {{if 'cudaErrorMisalignedAddress' in found_values}} + ) + cudaErrorMisalignedAddress = ( cyruntime.cudaError.cudaErrorMisalignedAddress, @@ -1131,8 +1129,8 @@ class cudaError_t(_FastEnum): 'which is not aligned. This leaves the process in an inconsistent state and\n' 'any further CUDA work will return the same error. To continue using CUDA,\n' 'the process must be terminated and relaunched.\n' - ){{endif}} - {{if 'cudaErrorInvalidAddressSpace' in found_values}} + ) + cudaErrorInvalidAddressSpace = ( cyruntime.cudaError.cudaErrorInvalidAddressSpace, @@ -1142,8 +1140,8 @@ class cudaError_t(_FastEnum): 'address space. This leaves the process in an inconsistent state and any\n' 'further CUDA work will return the same error. To continue using CUDA, the\n' 'process must be terminated and relaunched.\n' - ){{endif}} - {{if 'cudaErrorInvalidPc' in found_values}} + ) + cudaErrorInvalidPc = ( cyruntime.cudaError.cudaErrorInvalidPc, @@ -1151,8 +1149,8 @@ class cudaError_t(_FastEnum): 'in an inconsistent state and any further CUDA work will return the same\n' 'error. To continue using CUDA, the process must be terminated and\n' 'relaunched.\n' - ){{endif}} - {{if 'cudaErrorLaunchFailure' in found_values}} + ) + cudaErrorLaunchFailure = ( cyruntime.cudaError.cudaErrorLaunchFailure, @@ -1163,8 +1161,8 @@ class cudaError_t(_FastEnum): 'leaves the process in an inconsistent state and any further CUDA work will\n' 'return the same error. To continue using CUDA, the process must be\n' 'terminated and relaunched.\n' - ){{endif}} - {{if 'cudaErrorCooperativeLaunchTooLarge' in found_values}} + ) + cudaErrorCooperativeLaunchTooLarge = ( cyruntime.cudaError.cudaErrorCooperativeLaunchTooLarge, @@ -1175,8 +1173,8 @@ class cudaError_t(_FastEnum): ':py:obj:`~.cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags` times\n' 'the number of multiprocessors as specified by the device attribute\n' ':py:obj:`~.cudaDevAttrMultiProcessorCount`.\n' - ){{endif}} - {{if 'cudaErrorTensorMemoryLeak' in found_values}} + ) + cudaErrorTensorMemoryLeak = ( cyruntime.cudaError.cudaErrorTensorMemoryLeak, @@ -1185,21 +1183,21 @@ class cudaError_t(_FastEnum): 'process in an inconsistent state and any further CUDA work will return the\n' 'same error. To continue using CUDA, the process must be terminated and\n' 'relaunched.\n' - ){{endif}} - {{if 'cudaErrorNotPermitted' in found_values}} + ) + cudaErrorNotPermitted = ( cyruntime.cudaError.cudaErrorNotPermitted, 'This error indicates the attempted operation is not permitted.\n' - ){{endif}} - {{if 'cudaErrorNotSupported' in found_values}} + ) + cudaErrorNotSupported = ( cyruntime.cudaError.cudaErrorNotSupported, 'This error indicates the attempted operation is not supported on the\n' 'current system or device.\n' - ){{endif}} - {{if 'cudaErrorSystemNotReady' in found_values}} + ) + cudaErrorSystemNotReady = ( cyruntime.cudaError.cudaErrorSystemNotReady, @@ -1208,16 +1206,16 @@ class cudaError_t(_FastEnum): 'state and all required driver daemons are actively running. More\n' 'information about this error can be found in the system specific user\n' 'guide.\n' - ){{endif}} - {{if 'cudaErrorSystemDriverMismatch' in found_values}} + ) + cudaErrorSystemDriverMismatch = ( cyruntime.cudaError.cudaErrorSystemDriverMismatch, 'This error indicates that there is a mismatch between the versions of the\n' 'display driver and the CUDA driver. Refer to the compatibility\n' 'documentation for supported versions.\n' - ){{endif}} - {{if 'cudaErrorCompatNotSupportedOnDevice' in found_values}} + ) + cudaErrorCompatNotSupportedOnDevice = ( cyruntime.cudaError.cudaErrorCompatNotSupportedOnDevice, @@ -1226,120 +1224,120 @@ class cudaError_t(_FastEnum): 'this configuration. Refer to the compatibility documentation for the\n' 'supported hardware matrix or ensure that only supported hardware is visible\n' 'during initialization via the CUDA_VISIBLE_DEVICES environment variable.\n' - ){{endif}} - {{if 'cudaErrorMpsConnectionFailed' in found_values}} + ) + cudaErrorMpsConnectionFailed = ( cyruntime.cudaError.cudaErrorMpsConnectionFailed, 'This error indicates that the MPS client failed to connect to the MPS\n' 'control daemon or the MPS server.\n' - ){{endif}} - {{if 'cudaErrorMpsRpcFailure' in found_values}} + ) + cudaErrorMpsRpcFailure = ( cyruntime.cudaError.cudaErrorMpsRpcFailure, 'This error indicates that the remote procedural call between the MPS server\n' 'and the MPS client failed.\n' - ){{endif}} - {{if 'cudaErrorMpsServerNotReady' in found_values}} + ) + cudaErrorMpsServerNotReady = ( cyruntime.cudaError.cudaErrorMpsServerNotReady, 'This error indicates that the MPS server is not ready to accept new MPS\n' 'client requests. This error can be returned when the MPS server is in the\n' 'process of recovering from a fatal failure.\n' - ){{endif}} - {{if 'cudaErrorMpsMaxClientsReached' in found_values}} + ) + cudaErrorMpsMaxClientsReached = ( cyruntime.cudaError.cudaErrorMpsMaxClientsReached, 'This error indicates that the hardware resources required to create MPS\n' 'client have been exhausted.\n' - ){{endif}} - {{if 'cudaErrorMpsMaxConnectionsReached' in found_values}} + ) + cudaErrorMpsMaxConnectionsReached = ( cyruntime.cudaError.cudaErrorMpsMaxConnectionsReached, 'This error indicates the the hardware resources required to device\n' 'connections have been exhausted.\n' - ){{endif}} - {{if 'cudaErrorMpsClientTerminated' in found_values}} + ) + cudaErrorMpsClientTerminated = ( cyruntime.cudaError.cudaErrorMpsClientTerminated, 'This error indicates that the MPS client has been terminated by the server.\n' 'To continue using CUDA, the process must be terminated and relaunched.\n' - ){{endif}} - {{if 'cudaErrorCdpNotSupported' in found_values}} + ) + cudaErrorCdpNotSupported = ( cyruntime.cudaError.cudaErrorCdpNotSupported, 'This error indicates, that the program is using CUDA Dynamic Parallelism,\n' 'but the current configuration, like MPS, does not support it.\n' - ){{endif}} - {{if 'cudaErrorCdpVersionMismatch' in found_values}} + ) + cudaErrorCdpVersionMismatch = ( cyruntime.cudaError.cudaErrorCdpVersionMismatch, 'This error indicates, that the program contains an unsupported interaction\n' 'between different versions of CUDA Dynamic Parallelism.\n' - ){{endif}} - {{if 'cudaErrorStreamCaptureUnsupported' in found_values}} + ) + cudaErrorStreamCaptureUnsupported = ( cyruntime.cudaError.cudaErrorStreamCaptureUnsupported, 'The operation is not permitted when the stream is capturing.\n' - ){{endif}} - {{if 'cudaErrorStreamCaptureInvalidated' in found_values}} + ) + cudaErrorStreamCaptureInvalidated = ( cyruntime.cudaError.cudaErrorStreamCaptureInvalidated, 'The current capture sequence on the stream has been invalidated due to a\n' 'previous error.\n' - ){{endif}} - {{if 'cudaErrorStreamCaptureMerge' in found_values}} + ) + cudaErrorStreamCaptureMerge = ( cyruntime.cudaError.cudaErrorStreamCaptureMerge, 'The operation would have resulted in a merge of two independent capture\n' 'sequences.\n' - ){{endif}} - {{if 'cudaErrorStreamCaptureUnmatched' in found_values}} + ) + cudaErrorStreamCaptureUnmatched = ( cyruntime.cudaError.cudaErrorStreamCaptureUnmatched, 'The capture was not initiated in this stream.\n' - ){{endif}} - {{if 'cudaErrorStreamCaptureUnjoined' in found_values}} + ) + cudaErrorStreamCaptureUnjoined = ( cyruntime.cudaError.cudaErrorStreamCaptureUnjoined, 'The capture sequence contains a fork that was not joined to the primary\n' 'stream.\n' - ){{endif}} - {{if 'cudaErrorStreamCaptureIsolation' in found_values}} + ) + cudaErrorStreamCaptureIsolation = ( cyruntime.cudaError.cudaErrorStreamCaptureIsolation, 'A dependency would have been created which crosses the capture sequence\n' 'boundary. Only implicit in-stream ordering dependencies are allowed to\n' 'cross the boundary.\n' - ){{endif}} - {{if 'cudaErrorStreamCaptureImplicit' in found_values}} + ) + cudaErrorStreamCaptureImplicit = ( cyruntime.cudaError.cudaErrorStreamCaptureImplicit, 'The operation would have resulted in a disallowed implicit dependency on a\n' 'current capture sequence from cudaStreamLegacy.\n' - ){{endif}} - {{if 'cudaErrorCapturedEvent' in found_values}} + ) + cudaErrorCapturedEvent = ( cyruntime.cudaError.cudaErrorCapturedEvent, 'The operation is not permitted on an event which was last recorded in a\n' 'capturing stream.\n' - ){{endif}} - {{if 'cudaErrorStreamCaptureWrongThread' in found_values}} + ) + cudaErrorStreamCaptureWrongThread = ( cyruntime.cudaError.cudaErrorStreamCaptureWrongThread, @@ -1347,22 +1345,22 @@ class cudaError_t(_FastEnum): ':py:obj:`~.cudaStreamCaptureModeRelaxed` argument to\n' ':py:obj:`~.cudaStreamBeginCapture` was passed to\n' ':py:obj:`~.cudaStreamEndCapture` in a different thread.\n' - ){{endif}} - {{if 'cudaErrorTimeout' in found_values}} + ) + cudaErrorTimeout = ( cyruntime.cudaError.cudaErrorTimeout, 'This indicates that the wait operation has timed out.\n' - ){{endif}} - {{if 'cudaErrorGraphExecUpdateFailure' in found_values}} + ) + cudaErrorGraphExecUpdateFailure = ( cyruntime.cudaError.cudaErrorGraphExecUpdateFailure, 'This error indicates that the graph update was not performed because it\n' 'included changes which violated constraints specific to instantiated graph\n' 'update.\n' - ){{endif}} - {{if 'cudaErrorExternalDevice' in found_values}} + ) + cudaErrorExternalDevice = ( cyruntime.cudaError.cudaErrorExternalDevice, @@ -1376,36 +1374,36 @@ class cudaError_t(_FastEnum): 'process must be terminated and relaunched. In case of synchronous error, it\n' 'means that one or more external devices have encountered an error and\n' 'cannot complete the operation.\n' - ){{endif}} - {{if 'cudaErrorInvalidClusterSize' in found_values}} + ) + cudaErrorInvalidClusterSize = ( cyruntime.cudaError.cudaErrorInvalidClusterSize, 'This indicates that a kernel launch error has occurred due to cluster\n' 'misconfiguration.\n' - ){{endif}} - {{if 'cudaErrorFunctionNotLoaded' in found_values}} + ) + cudaErrorFunctionNotLoaded = ( cyruntime.cudaError.cudaErrorFunctionNotLoaded, 'Indiciates a function handle is not loaded when calling an API that\n' 'requires a loaded function.\n' - ){{endif}} - {{if 'cudaErrorInvalidResourceType' in found_values}} + ) + cudaErrorInvalidResourceType = ( cyruntime.cudaError.cudaErrorInvalidResourceType, 'This error indicates one or more resources passed in are not valid resource\n' 'types for the operation.\n' - ){{endif}} - {{if 'cudaErrorInvalidResourceConfiguration' in found_values}} + ) + cudaErrorInvalidResourceConfiguration = ( cyruntime.cudaError.cudaErrorInvalidResourceConfiguration, 'This error indicates one or more resources are insufficient or non-\n' 'applicable for the operation.\n' - ){{endif}} - {{if 'cudaErrorStreamDetached' in found_values}} + ) + cudaErrorStreamDetached = ( cyruntime.cudaError.cudaErrorStreamDetached, @@ -1413,69 +1411,63 @@ class cudaError_t(_FastEnum): 'the stream is in a detached state. This can occur if the green context\n' "associated with the stream has been destroyed, limiting the stream's\n" 'operational capabilities.\n' - ){{endif}} - {{if 'cudaErrorGraphRecaptureFailure' in found_values}} + ) + cudaErrorGraphRecaptureFailure = ( cyruntime.cudaError.cudaErrorGraphRecaptureFailure, 'This error indicates that a graph recapture failed and had to be\n' 'terminated.\n' - ){{endif}} - {{if 'cudaErrorUnknown' in found_values}} + ) + cudaErrorUnknown = ( cyruntime.cudaError.cudaErrorUnknown, 'This indicates that an unknown internal error has occurred.\n' - ){{endif}} - {{if 'cudaErrorApiFailureBase' in found_values}} - cudaErrorApiFailureBase = cyruntime.cudaError.cudaErrorApiFailureBase{{endif}} + ) -{{endif}} -{{if 'cudaSharedMemoryMode' in found_types}} + cudaErrorApiFailureBase = cyruntime.cudaError.cudaErrorApiFailureBase class cudaSharedMemoryMode(_FastEnum): """ Shared memory related attributes for use with :py:obj:`~.cuLaunchKernelEx` """ - {{if 'cudaSharedMemoryModeDefault' in found_values}} + cudaSharedMemoryModeDefault = ( cyruntime.cudaSharedMemoryMode.cudaSharedMemoryModeDefault, 'The default to use for allowing non-portable shared memory size on launch -\n' 'uses current function attributes for\n' ':py:obj:`~.cudaFuncAttributeMaxDynamicSharedMemorySize`\n' - ){{endif}} - {{if 'cudaSharedMemoryModeRequirePortable' in found_values}} + ) + cudaSharedMemoryModeRequirePortable = ( cyruntime.cudaSharedMemoryMode.cudaSharedMemoryModeRequirePortable, 'Specifies that the shared memory size requested must be a portable size\n' 'within :py:obj:`~.cudaDevAttrMaxSharedMemoryPerBlock`\n' - ){{endif}} - {{if 'cudaSharedMemoryModeAllowNonPortable' in found_values}} + ) + cudaSharedMemoryModeAllowNonPortable = ( cyruntime.cudaSharedMemoryMode.cudaSharedMemoryModeAllowNonPortable, 'Specifies that the shared memory size requested may be a non-portable size\n' 'up to :py:obj:`~.cudaDevAttrMaxSharedMemoryPerBlockOptin`\n' - ){{endif}} - -{{endif}} -{{if 'cudaGraphDependencyType_enum' in found_types}} + ) class cudaGraphDependencyType(_FastEnum): """ Type annotations that can be applied to graph edges as part of :py:obj:`~.cudaGraphEdgeData`. """ - {{if 'cudaGraphDependencyTypeDefault' in found_values}} + cudaGraphDependencyTypeDefault = ( cyruntime.cudaGraphDependencyType_enum.cudaGraphDependencyTypeDefault, 'This is an ordinary dependency.\n' - ){{endif}} - {{if 'cudaGraphDependencyTypeProgrammatic' in found_values}} + ) + cudaGraphDependencyTypeProgrammatic = ( cyruntime.cudaGraphDependencyType_enum.cudaGraphDependencyTypeProgrammatic, @@ -1484,57 +1476,51 @@ class cudaGraphDependencyType(_FastEnum): 'nodes, and must be used with either the\n' ':py:obj:`~.cudaGraphKernelNodePortProgrammatic` or\n' ':py:obj:`~.cudaGraphKernelNodePortLaunchCompletion` outgoing port.\n' - ){{endif}} - -{{endif}} -{{if 'cudaGraphInstantiateResult' in found_types}} + ) class cudaGraphInstantiateResult(_FastEnum): """ Graph instantiation results """ - {{if 'cudaGraphInstantiateSuccess' in found_values}} + cudaGraphInstantiateSuccess = ( cyruntime.cudaGraphInstantiateResult.cudaGraphInstantiateSuccess, 'Instantiation succeeded\n' - ){{endif}} - {{if 'cudaGraphInstantiateError' in found_values}} + ) + cudaGraphInstantiateError = ( cyruntime.cudaGraphInstantiateResult.cudaGraphInstantiateError, 'Instantiation failed for an unexpected reason which is described in the\n' 'return value of the function\n' - ){{endif}} - {{if 'cudaGraphInstantiateInvalidStructure' in found_values}} + ) + cudaGraphInstantiateInvalidStructure = ( cyruntime.cudaGraphInstantiateResult.cudaGraphInstantiateInvalidStructure, 'Instantiation failed due to invalid structure, such as cycles\n' - ){{endif}} - {{if 'cudaGraphInstantiateNodeOperationNotSupported' in found_values}} + ) + cudaGraphInstantiateNodeOperationNotSupported = ( cyruntime.cudaGraphInstantiateResult.cudaGraphInstantiateNodeOperationNotSupported, 'Instantiation for device launch failed because the graph contained an\n' 'unsupported operation\n' - ){{endif}} - {{if 'cudaGraphInstantiateMultipleDevicesNotSupported' in found_values}} + ) + cudaGraphInstantiateMultipleDevicesNotSupported = ( cyruntime.cudaGraphInstantiateResult.cudaGraphInstantiateMultipleDevicesNotSupported, 'Instantiation for device launch failed due to the nodes belonging to\n' 'different contexts\n' - ){{endif}} - {{if 'cudaGraphInstantiateConditionalHandleUnused' in found_values}} + ) + cudaGraphInstantiateConditionalHandleUnused = ( cyruntime.cudaGraphInstantiateResult.cudaGraphInstantiateConditionalHandleUnused, 'One or more conditional handles are not associated with conditional nodes\n' - ){{endif}} - -{{endif}} -{{if 'cudaLaunchMemSyncDomain' in found_types}} + ) class cudaLaunchMemSyncDomain(_FastEnum): """ @@ -1557,97 +1543,91 @@ class cudaLaunchMemSyncDomain(_FastEnum): by kernels in another memory synchronization domain even if they are on the same GPU. """ - {{if 'cudaLaunchMemSyncDomainDefault' in found_values}} + cudaLaunchMemSyncDomainDefault = ( cyruntime.cudaLaunchMemSyncDomain.cudaLaunchMemSyncDomainDefault, 'Launch kernels in the default domain\n' - ){{endif}} - {{if 'cudaLaunchMemSyncDomainRemote' in found_values}} + ) + cudaLaunchMemSyncDomainRemote = ( cyruntime.cudaLaunchMemSyncDomain.cudaLaunchMemSyncDomainRemote, 'Launch kernels in the remote domain\n' - ){{endif}} - -{{endif}} -{{if 'cudaLaunchAttributePortableClusterMode' in found_types}} + ) class cudaLaunchAttributePortableClusterMode(_FastEnum): """ Enum for defining applicability of portable cluster size, used with :py:obj:`~.cudaLaunchKernelEx` """ - {{if 'cudaLaunchPortableClusterModeDefault' in found_values}} + cudaLaunchPortableClusterModeDefault = ( cyruntime.cudaLaunchAttributePortableClusterMode.cudaLaunchPortableClusterModeDefault, 'The default to use for allowing non-portable cluster size on launch - uses\n' 'current function attribute for\n' ':py:obj:`~.cudaFuncAttributeNonPortableClusterSizeAllowed`\n' - ){{endif}} - {{if 'cudaLaunchPortableClusterModeRequirePortable' in found_values}} + ) + cudaLaunchPortableClusterModeRequirePortable = ( cyruntime.cudaLaunchAttributePortableClusterMode.cudaLaunchPortableClusterModeRequirePortable, 'Specifies that the cluster size requested must be a portable size\n' - ){{endif}} - {{if 'cudaLaunchPortableClusterModeAllowNonPortable' in found_values}} + ) + cudaLaunchPortableClusterModeAllowNonPortable = ( cyruntime.cudaLaunchAttributePortableClusterMode.cudaLaunchPortableClusterModeAllowNonPortable, 'Specifies that the cluster size requested may be a non-portable size\n' - ){{endif}} - -{{endif}} -{{if 'cudaLaunchAttributeID' in found_types}} + ) class cudaLaunchAttributeID(_FastEnum): """ Launch attributes enum; used as id field of :py:obj:`~.cudaLaunchAttribute` """ - {{if 'cudaLaunchAttributeIgnore' in found_values}} + cudaLaunchAttributeIgnore = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeIgnore, 'Ignored entry, for convenient composition\n' - ){{endif}} - {{if 'cudaLaunchAttributeAccessPolicyWindow' in found_values}} + ) + cudaLaunchAttributeAccessPolicyWindow = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeAccessPolicyWindow, 'Valid for streams, graph nodes, launches. See\n' ':py:obj:`~.cudaLaunchAttributeValue.accessPolicyWindow`.\n' - ){{endif}} - {{if 'cudaLaunchAttributeCooperative' in found_values}} + ) + cudaLaunchAttributeCooperative = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeCooperative, 'Valid for graph nodes, launches. See\n' ':py:obj:`~.cudaLaunchAttributeValue.cooperative`.\n' - ){{endif}} - {{if 'cudaLaunchAttributeSynchronizationPolicy' in found_values}} + ) + cudaLaunchAttributeSynchronizationPolicy = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeSynchronizationPolicy, 'Valid for streams. See :py:obj:`~.cudaLaunchAttributeValue.syncPolicy`.\n' - ){{endif}} - {{if 'cudaLaunchAttributeClusterDimension' in found_values}} + ) + cudaLaunchAttributeClusterDimension = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeClusterDimension, 'Valid for graph nodes, launches. See\n' ':py:obj:`~.cudaLaunchAttributeValue.clusterDim`.\n' - ){{endif}} - {{if 'cudaLaunchAttributeClusterSchedulingPolicyPreference' in found_values}} + ) + cudaLaunchAttributeClusterSchedulingPolicyPreference = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeClusterSchedulingPolicyPreference, 'Valid for graph nodes, launches. See\n' ':py:obj:`~.cudaLaunchAttributeValue.clusterSchedulingPolicyPreference`.\n' - ){{endif}} - {{if 'cudaLaunchAttributeProgrammaticStreamSerialization' in found_values}} + ) + cudaLaunchAttributeProgrammaticStreamSerialization = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeProgrammaticStreamSerialization, @@ -1659,8 +1639,8 @@ class cudaLaunchAttributeID(_FastEnum): 'that kernel requests the overlap. The dependent launches can choose to wait\n' 'on the dependency using the programmatic sync\n' '(cudaGridDependencySynchronize() or equivalent PTX instructions).\n' - ){{endif}} - {{if 'cudaLaunchAttributeProgrammaticEvent' in found_values}} + ) + cudaLaunchAttributeProgrammaticEvent = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeProgrammaticEvent, @@ -1684,29 +1664,29 @@ class cudaLaunchAttributeID(_FastEnum): ' The event supplied must not be an interprocess or interop event. The event\n' 'must disable timing (i.e. must be created with the\n' ':py:obj:`~.cudaEventDisableTiming` flag set).\n' - ){{endif}} - {{if 'cudaLaunchAttributePriority' in found_values}} + ) + cudaLaunchAttributePriority = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributePriority, 'Valid for streams, graph nodes, launches. See\n' ':py:obj:`~.cudaLaunchAttributeValue.priority`.\n' - ){{endif}} - {{if 'cudaLaunchAttributeMemSyncDomainMap' in found_values}} + ) + cudaLaunchAttributeMemSyncDomainMap = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeMemSyncDomainMap, 'Valid for streams, graph nodes, launches. See\n' ':py:obj:`~.cudaLaunchAttributeValue.memSyncDomainMap`.\n' - ){{endif}} - {{if 'cudaLaunchAttributeMemSyncDomain' in found_values}} + ) + cudaLaunchAttributeMemSyncDomain = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeMemSyncDomain, 'Valid for streams, graph nodes, launches. See\n' ':py:obj:`~.cudaLaunchAttributeValue.memSyncDomain`.\n' - ){{endif}} - {{if 'cudaLaunchAttributePreferredClusterDimension' in found_values}} + ) + cudaLaunchAttributePreferredClusterDimension = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributePreferredClusterDimension, @@ -1739,8 +1719,8 @@ class cudaLaunchAttributeID(_FastEnum): 'than the maximum value the driver can support. Otherwise, setting this\n' 'attribute to a value physically unable to fit on any particular device is\n' 'permitted.\n' - ){{endif}} - {{if 'cudaLaunchAttributeLaunchCompletionEvent' in found_values}} + ) + cudaLaunchAttributeLaunchCompletionEvent = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeLaunchCompletionEvent, @@ -1761,8 +1741,8 @@ class cudaLaunchAttributeID(_FastEnum): ' The event supplied must not be an interprocess or interop event. The event\n' 'must disable timing (i.e. must be created with the\n' ':py:obj:`~.cudaEventDisableTiming` flag set).\n' - ){{endif}} - {{if 'cudaLaunchAttributeDeviceUpdatableKernelNode' in found_values}} + ) + cudaLaunchAttributeDeviceUpdatableKernelNode = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeDeviceUpdatableKernelNode, @@ -1793,8 +1773,8 @@ class cudaLaunchAttributeID(_FastEnum): ':py:obj:`~.cuGraphUpload` before it is launched. For such a graph, if host-\n' 'side executable graph updates are made to the device-updatable nodes, the\n' 'graph must be uploaded before it is launched again.\n' - ){{endif}} - {{if 'cudaLaunchAttributePreferredSharedMemoryCarveout' in found_values}} + ) + cudaLaunchAttributePreferredSharedMemoryCarveout = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributePreferredSharedMemoryCarveout, @@ -1806,8 +1786,8 @@ class cudaLaunchAttributeID(_FastEnum): 'precedence over :py:obj:`~.cudaFuncAttributePreferredSharedMemoryCarveout`.\n' 'This is only a hint, and the driver can choose a different configuration if\n' 'required for the launch.\n' - ){{endif}} - {{if 'cudaLaunchAttributeNvlinkUtilCentricScheduling' in found_values}} + ) + cudaLaunchAttributeNvlinkUtilCentricScheduling = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeNvlinkUtilCentricScheduling, @@ -1828,8 +1808,8 @@ class cudaLaunchAttributeID(_FastEnum): ' Valid values for\n' ':py:obj:`~.cudaLaunchAttributeValue.nvlinkUtilCentricScheduling` are 0\n' '(disabled) and 1 (enabled).\n' - ){{endif}} - {{if 'cudaLaunchAttributePortableClusterSizeMode' in found_values}} + ) + cudaLaunchAttributePortableClusterSizeMode = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributePortableClusterSizeMode, @@ -1838,244 +1818,217 @@ class cudaLaunchAttributeID(_FastEnum): ':py:obj:`~.cudaLaunchAttributeValue.portableClusterSizeMode` are values for\n' ':py:obj:`~.cudaLaunchAttributePortableClusterMode` Any other value will\n' 'return :py:obj:`~.cudaErrorInvalidValue`\n' - ){{endif}} - {{if 'cudaLaunchAttributeSharedMemoryMode' in found_values}} + ) + cudaLaunchAttributeSharedMemoryMode = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeSharedMemoryMode, 'Valid for graph nodes, launches. This indicates that the kernel launch is\n' 'allowed to use a non-portable shared memory mode.\n' - ){{endif}} - -{{endif}} -{{if 'cudaAsyncNotificationType_enum' in found_types}} + ) class cudaAsyncNotificationType(_FastEnum): """ Types of async notification that can occur """ - {{if 'cudaAsyncNotificationTypeOverBudget' in found_values}} + cudaAsyncNotificationTypeOverBudget = ( cyruntime.cudaAsyncNotificationType_enum.cudaAsyncNotificationTypeOverBudget, 'Sent when the process has exceeded its device memory budget\n' - ){{endif}} - -{{endif}} -{{if 'CUDAlogLevel_enum' in found_types}} + ) class cudaLogLevel(_FastEnum): """ """ - {{if 'cudaLogLevelError' in found_values}} - cudaLogLevelError = cyruntime.CUDAlogLevel_enum.cudaLogLevelError{{endif}} - {{if 'cudaLogLevelWarning' in found_values}} - cudaLogLevelWarning = cyruntime.CUDAlogLevel_enum.cudaLogLevelWarning{{endif}} -{{endif}} -{{if 'cudaDataType_t' in found_types}} + cudaLogLevelError = cyruntime.CUDAlogLevel_enum.cudaLogLevelError + + cudaLogLevelWarning = cyruntime.CUDAlogLevel_enum.cudaLogLevelWarning class cudaDataType(_FastEnum): """ """ - {{if 'CUDA_R_32F' in found_values}} - CUDA_R_32F = cyruntime.cudaDataType_t.CUDA_R_32F{{endif}} - {{if 'CUDA_R_64F' in found_values}} - CUDA_R_64F = cyruntime.cudaDataType_t.CUDA_R_64F{{endif}} - {{if 'CUDA_R_16F' in found_values}} - CUDA_R_16F = cyruntime.cudaDataType_t.CUDA_R_16F{{endif}} - {{if 'CUDA_R_8I' in found_values}} - CUDA_R_8I = cyruntime.cudaDataType_t.CUDA_R_8I{{endif}} - {{if 'CUDA_C_32F' in found_values}} - CUDA_C_32F = cyruntime.cudaDataType_t.CUDA_C_32F{{endif}} - {{if 'CUDA_C_64F' in found_values}} - CUDA_C_64F = cyruntime.cudaDataType_t.CUDA_C_64F{{endif}} - {{if 'CUDA_C_16F' in found_values}} - CUDA_C_16F = cyruntime.cudaDataType_t.CUDA_C_16F{{endif}} - {{if 'CUDA_C_8I' in found_values}} - CUDA_C_8I = cyruntime.cudaDataType_t.CUDA_C_8I{{endif}} - {{if 'CUDA_R_8U' in found_values}} - CUDA_R_8U = cyruntime.cudaDataType_t.CUDA_R_8U{{endif}} - {{if 'CUDA_C_8U' in found_values}} - CUDA_C_8U = cyruntime.cudaDataType_t.CUDA_C_8U{{endif}} - {{if 'CUDA_R_32I' in found_values}} - CUDA_R_32I = cyruntime.cudaDataType_t.CUDA_R_32I{{endif}} - {{if 'CUDA_C_32I' in found_values}} - CUDA_C_32I = cyruntime.cudaDataType_t.CUDA_C_32I{{endif}} - {{if 'CUDA_R_32U' in found_values}} - CUDA_R_32U = cyruntime.cudaDataType_t.CUDA_R_32U{{endif}} - {{if 'CUDA_C_32U' in found_values}} - CUDA_C_32U = cyruntime.cudaDataType_t.CUDA_C_32U{{endif}} - {{if 'CUDA_R_16BF' in found_values}} - CUDA_R_16BF = cyruntime.cudaDataType_t.CUDA_R_16BF{{endif}} - {{if 'CUDA_C_16BF' in found_values}} - CUDA_C_16BF = cyruntime.cudaDataType_t.CUDA_C_16BF{{endif}} - {{if 'CUDA_R_4I' in found_values}} - CUDA_R_4I = cyruntime.cudaDataType_t.CUDA_R_4I{{endif}} - {{if 'CUDA_C_4I' in found_values}} - CUDA_C_4I = cyruntime.cudaDataType_t.CUDA_C_4I{{endif}} - {{if 'CUDA_R_4U' in found_values}} - CUDA_R_4U = cyruntime.cudaDataType_t.CUDA_R_4U{{endif}} - {{if 'CUDA_C_4U' in found_values}} - CUDA_C_4U = cyruntime.cudaDataType_t.CUDA_C_4U{{endif}} - {{if 'CUDA_R_16I' in found_values}} - CUDA_R_16I = cyruntime.cudaDataType_t.CUDA_R_16I{{endif}} - {{if 'CUDA_C_16I' in found_values}} - CUDA_C_16I = cyruntime.cudaDataType_t.CUDA_C_16I{{endif}} - {{if 'CUDA_R_16U' in found_values}} - CUDA_R_16U = cyruntime.cudaDataType_t.CUDA_R_16U{{endif}} - {{if 'CUDA_C_16U' in found_values}} - CUDA_C_16U = cyruntime.cudaDataType_t.CUDA_C_16U{{endif}} - {{if 'CUDA_R_64I' in found_values}} - CUDA_R_64I = cyruntime.cudaDataType_t.CUDA_R_64I{{endif}} - {{if 'CUDA_C_64I' in found_values}} - CUDA_C_64I = cyruntime.cudaDataType_t.CUDA_C_64I{{endif}} - {{if 'CUDA_R_64U' in found_values}} - CUDA_R_64U = cyruntime.cudaDataType_t.CUDA_R_64U{{endif}} - {{if 'CUDA_C_64U' in found_values}} - CUDA_C_64U = cyruntime.cudaDataType_t.CUDA_C_64U{{endif}} - {{if 'CUDA_R_8F_E4M3' in found_values}} - CUDA_R_8F_E4M3 = cyruntime.cudaDataType_t.CUDA_R_8F_E4M3{{endif}} - {{if 'CUDA_R_8F_UE4M3' in found_values}} - CUDA_R_8F_UE4M3 = cyruntime.cudaDataType_t.CUDA_R_8F_UE4M3{{endif}} - {{if 'CUDA_R_8F_E5M2' in found_values}} - CUDA_R_8F_E5M2 = cyruntime.cudaDataType_t.CUDA_R_8F_E5M2{{endif}} - {{if 'CUDA_R_8F_UE8M0' in found_values}} - CUDA_R_8F_UE8M0 = cyruntime.cudaDataType_t.CUDA_R_8F_UE8M0{{endif}} - {{if 'CUDA_R_6F_E2M3' in found_values}} - CUDA_R_6F_E2M3 = cyruntime.cudaDataType_t.CUDA_R_6F_E2M3{{endif}} - {{if 'CUDA_R_6F_E3M2' in found_values}} - CUDA_R_6F_E3M2 = cyruntime.cudaDataType_t.CUDA_R_6F_E3M2{{endif}} - {{if 'CUDA_R_4F_E2M1' in found_values}} - CUDA_R_4F_E2M1 = cyruntime.cudaDataType_t.CUDA_R_4F_E2M1{{endif}} - -{{endif}} -{{if 'cudaEmulationStrategy_t' in found_types}} + + CUDA_R_32F = cyruntime.cudaDataType_t.CUDA_R_32F + + CUDA_R_64F = cyruntime.cudaDataType_t.CUDA_R_64F + + CUDA_R_16F = cyruntime.cudaDataType_t.CUDA_R_16F + + CUDA_R_8I = cyruntime.cudaDataType_t.CUDA_R_8I + + CUDA_C_32F = cyruntime.cudaDataType_t.CUDA_C_32F + + CUDA_C_64F = cyruntime.cudaDataType_t.CUDA_C_64F + + CUDA_C_16F = cyruntime.cudaDataType_t.CUDA_C_16F + + CUDA_C_8I = cyruntime.cudaDataType_t.CUDA_C_8I + + CUDA_R_8U = cyruntime.cudaDataType_t.CUDA_R_8U + + CUDA_C_8U = cyruntime.cudaDataType_t.CUDA_C_8U + + CUDA_R_32I = cyruntime.cudaDataType_t.CUDA_R_32I + + CUDA_C_32I = cyruntime.cudaDataType_t.CUDA_C_32I + + CUDA_R_32U = cyruntime.cudaDataType_t.CUDA_R_32U + + CUDA_C_32U = cyruntime.cudaDataType_t.CUDA_C_32U + + CUDA_R_16BF = cyruntime.cudaDataType_t.CUDA_R_16BF + + CUDA_C_16BF = cyruntime.cudaDataType_t.CUDA_C_16BF + + CUDA_R_4I = cyruntime.cudaDataType_t.CUDA_R_4I + + CUDA_C_4I = cyruntime.cudaDataType_t.CUDA_C_4I + + CUDA_R_4U = cyruntime.cudaDataType_t.CUDA_R_4U + + CUDA_C_4U = cyruntime.cudaDataType_t.CUDA_C_4U + + CUDA_R_16I = cyruntime.cudaDataType_t.CUDA_R_16I + + CUDA_C_16I = cyruntime.cudaDataType_t.CUDA_C_16I + + CUDA_R_16U = cyruntime.cudaDataType_t.CUDA_R_16U + + CUDA_C_16U = cyruntime.cudaDataType_t.CUDA_C_16U + + CUDA_R_64I = cyruntime.cudaDataType_t.CUDA_R_64I + + CUDA_C_64I = cyruntime.cudaDataType_t.CUDA_C_64I + + CUDA_R_64U = cyruntime.cudaDataType_t.CUDA_R_64U + + CUDA_C_64U = cyruntime.cudaDataType_t.CUDA_C_64U + + CUDA_R_8F_E4M3 = cyruntime.cudaDataType_t.CUDA_R_8F_E4M3 + + CUDA_R_8F_UE4M3 = cyruntime.cudaDataType_t.CUDA_R_8F_UE4M3 + + CUDA_R_8F_E5M2 = cyruntime.cudaDataType_t.CUDA_R_8F_E5M2 + + CUDA_R_8F_UE8M0 = cyruntime.cudaDataType_t.CUDA_R_8F_UE8M0 + + CUDA_R_6F_E2M3 = cyruntime.cudaDataType_t.CUDA_R_6F_E2M3 + + CUDA_R_6F_E3M2 = cyruntime.cudaDataType_t.CUDA_R_6F_E3M2 + + CUDA_R_4F_E2M1 = cyruntime.cudaDataType_t.CUDA_R_4F_E2M1 class cudaEmulationStrategy(_FastEnum): """ Enum for specifying how to leverage floating-point emulation algorithms """ - {{if 'CUDA_EMULATION_STRATEGY_DEFAULT' in found_values}} + CUDA_EMULATION_STRATEGY_DEFAULT = ( cyruntime.cudaEmulationStrategy_t.CUDA_EMULATION_STRATEGY_DEFAULT, 'The default emulation strategy. For emulated computations, this is\n' 'equivalent to CUDA_EMULATION_STRATEGY_PERFORMANT, unless a library\n' 'dependent environment variable is set\n' - ){{endif}} - {{if 'CUDA_EMULATION_STRATEGY_PERFORMANT' in found_values}} + ) + CUDA_EMULATION_STRATEGY_PERFORMANT = ( cyruntime.cudaEmulationStrategy_t.CUDA_EMULATION_STRATEGY_PERFORMANT, 'An emulation strategy which configures libraries to use emulation when it\n' 'provides a performance benefit\n' - ){{endif}} - {{if 'CUDA_EMULATION_STRATEGY_EAGER' in found_values}} + ) + CUDA_EMULATION_STRATEGY_EAGER = ( cyruntime.cudaEmulationStrategy_t.CUDA_EMULATION_STRATEGY_EAGER, 'An emulation strategy which configures libraries to use emulation whenever\n' 'possible\n' - ){{endif}} - -{{endif}} -{{if 'cudaEmulationMantissaControl_t' in found_types}} + ) class cudaEmulationMantissaControl(_FastEnum): """ Enum to configure the mantissa related parameters for floating- point emulation algorithms """ - {{if 'CUDA_EMULATION_MANTISSA_CONTROL_DYNAMIC' in found_values}} + CUDA_EMULATION_MANTISSA_CONTROL_DYNAMIC = ( cyruntime.cudaEmulationMantissaControl_t.CUDA_EMULATION_MANTISSA_CONTROL_DYNAMIC, 'The number of retained mantissa bits are computed at runtime to ensure the\n' 'same or better accuracy than the floating point representation being\n' 'emulated\n' - ){{endif}} - {{if 'CUDA_EMULATION_MANTISSA_CONTROL_FIXED' in found_values}} + ) + CUDA_EMULATION_MANTISSA_CONTROL_FIXED = ( cyruntime.cudaEmulationMantissaControl_t.CUDA_EMULATION_MANTISSA_CONTROL_FIXED, 'The number of retained mantissa bits are known at runtime\n' - ){{endif}} - -{{endif}} -{{if 'cudaEmulationSpecialValuesSupport_t' in found_types}} + ) class cudaEmulationSpecialValuesSupport(_FastEnum): """ Enum to configure how special floating-point values will be handled by emulation algorithms """ - {{if 'CUDA_EMULATION_SPECIAL_VALUES_SUPPORT_NONE' in found_values}} + CUDA_EMULATION_SPECIAL_VALUES_SUPPORT_NONE = ( cyruntime.cudaEmulationSpecialValuesSupport_t.CUDA_EMULATION_SPECIAL_VALUES_SUPPORT_NONE, 'There are no requirements for emulation algorithms to support special\n' 'values\n' - ){{endif}} - {{if 'CUDA_EMULATION_SPECIAL_VALUES_SUPPORT_INFINITY' in found_values}} + ) + CUDA_EMULATION_SPECIAL_VALUES_SUPPORT_INFINITY = ( cyruntime.cudaEmulationSpecialValuesSupport_t.CUDA_EMULATION_SPECIAL_VALUES_SUPPORT_INFINITY, 'Require emulation algorithms to handle signed infinity inputs and outputs\n' - ){{endif}} - {{if 'CUDA_EMULATION_SPECIAL_VALUES_SUPPORT_NAN' in found_values}} + ) + CUDA_EMULATION_SPECIAL_VALUES_SUPPORT_NAN = ( cyruntime.cudaEmulationSpecialValuesSupport_t.CUDA_EMULATION_SPECIAL_VALUES_SUPPORT_NAN, 'Require emulation algorithms to handle NaN inputs and outputs\n' - ){{endif}} - {{if 'CUDA_EMULATION_SPECIAL_VALUES_SUPPORT_DEFAULT' in found_values}} + ) + CUDA_EMULATION_SPECIAL_VALUES_SUPPORT_DEFAULT = ( cyruntime.cudaEmulationSpecialValuesSupport_t.CUDA_EMULATION_SPECIAL_VALUES_SUPPORT_DEFAULT, 'The default special value support mask which contains support for signed\n' 'infinities and NaN values\n' - ){{endif}} - -{{endif}} -{{if 'libraryPropertyType_t' in found_types}} + ) class libraryPropertyType(_FastEnum): """ """ - {{if 'MAJOR_VERSION' in found_values}} - MAJOR_VERSION = cyruntime.libraryPropertyType_t.MAJOR_VERSION{{endif}} - {{if 'MINOR_VERSION' in found_values}} - MINOR_VERSION = cyruntime.libraryPropertyType_t.MINOR_VERSION{{endif}} - {{if 'PATCH_LEVEL' in found_values}} - PATCH_LEVEL = cyruntime.libraryPropertyType_t.PATCH_LEVEL{{endif}} -{{endif}} -{{if True}} + MAJOR_VERSION = cyruntime.libraryPropertyType_t.MAJOR_VERSION + + MINOR_VERSION = cyruntime.libraryPropertyType_t.MINOR_VERSION + + PATCH_LEVEL = cyruntime.libraryPropertyType_t.PATCH_LEVEL class cudaEglFrameType(_FastEnum): """ CUDA EglFrame type - array or pointer """ - {{if True}} + cudaEglFrameTypeArray = ( cyruntime.cudaEglFrameType_enum.cudaEglFrameTypeArray, 'Frame type CUDA array\n' - ){{endif}} - {{if True}} + ) + cudaEglFrameTypePitch = ( cyruntime.cudaEglFrameType_enum.cudaEglFrameTypePitch, 'Frame type CUDA pointer\n' - ){{endif}} - -{{endif}} -{{if True}} + ) class cudaEglResourceLocationFlags(_FastEnum): """ @@ -2091,1227 +2044,1203 @@ class cudaEglResourceLocationFlags(_FastEnum): CUDA. There may be an additional latency due to new allocation and data migration, if the frame is produced on a different memory. """ - {{if True}} + cudaEglResourceLocationSysmem = ( cyruntime.cudaEglResourceLocationFlags_enum.cudaEglResourceLocationSysmem, 'Resource location sysmem\n' - ){{endif}} - {{if True}} + ) + cudaEglResourceLocationVidmem = ( cyruntime.cudaEglResourceLocationFlags_enum.cudaEglResourceLocationVidmem, 'Resource location vidmem\n' - ){{endif}} - -{{endif}} -{{if True}} + ) class cudaEglColorFormat(_FastEnum): """ CUDA EGL Color Format - The different planar and multiplanar formats currently supported for CUDA_EGL interops. """ - {{if True}} + cudaEglColorFormatYUV420Planar = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYUV420Planar, 'Y, U, V in three surfaces, each in a separate surface, U/V width = 1/2 Y\n' 'width, U/V height = 1/2 Y height.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatYUV420SemiPlanar = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYUV420SemiPlanar, 'Y, UV in two surfaces (UV as one surface) with VU byte ordering, width,\n' 'height ratio same as YUV420Planar.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatYUV422Planar = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYUV422Planar, 'Y, U, V each in a separate surface, U/V width = 1/2 Y width, U/V height = Y\n' 'height.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatYUV422SemiPlanar = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYUV422SemiPlanar, 'Y, UV in two surfaces with VU byte ordering, width, height ratio same as\n' 'YUV422Planar.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatARGB = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatARGB, 'R/G/B/A four channels in one surface with BGRA byte ordering.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatRGBA = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatRGBA, 'R/G/B/A four channels in one surface with ABGR byte ordering.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatL = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatL, 'single luminance channel in one surface.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatR = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatR, 'single color channel in one surface.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatYUV444Planar = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYUV444Planar, 'Y, U, V in three surfaces, each in a separate surface, U/V width = Y width,\n' 'U/V height = Y height.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatYUV444SemiPlanar = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYUV444SemiPlanar, 'Y, UV in two surfaces (UV as one surface) with VU byte ordering, width,\n' 'height ratio same as YUV444Planar.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatYUYV422 = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYUYV422, 'Y, U, V in one surface, interleaved as UYVY in one channel.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatUYVY422 = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatUYVY422, 'Y, U, V in one surface, interleaved as YUYV in one channel.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatABGR = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatABGR, 'R/G/B/A four channels in one surface with RGBA byte ordering.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatBGRA = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBGRA, 'R/G/B/A four channels in one surface with ARGB byte ordering.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatA = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatA, 'Alpha color format - one channel in one surface.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatRG = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatRG, 'R/G color format - two channels in one surface with GR byte ordering\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatAYUV = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatAYUV, 'Y, U, V, A four channels in one surface, interleaved as VUYA.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatYVU444SemiPlanar = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYVU444SemiPlanar, 'Y, VU in two surfaces (VU as one surface) with UV byte ordering, U/V width\n' '= Y width, U/V height = Y height.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatYVU422SemiPlanar = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYVU422SemiPlanar, 'Y, VU in two surfaces (VU as one surface) with UV byte ordering, U/V width\n' '= 1/2 Y width, U/V height = Y height.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatYVU420SemiPlanar = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYVU420SemiPlanar, 'Y, VU in two surfaces (VU as one surface) with UV byte ordering, U/V width\n' '= 1/2 Y width, U/V height = 1/2 Y height.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatY10V10U10_444SemiPlanar = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY10V10U10_444SemiPlanar, 'Y10, V10U10 in two surfaces (VU as one surface) with UV byte ordering, U/V\n' 'width = Y width, U/V height = Y height.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatY10V10U10_420SemiPlanar = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY10V10U10_420SemiPlanar, 'Y10, V10U10 in two surfaces (VU as one surface) with UV byte ordering, U/V\n' 'width = 1/2 Y width, U/V height = 1/2 Y height.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatY12V12U12_444SemiPlanar = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY12V12U12_444SemiPlanar, 'Y12, V12U12 in two surfaces (VU as one surface) with UV byte ordering, U/V\n' 'width = Y width, U/V height = Y height.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatY12V12U12_420SemiPlanar = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY12V12U12_420SemiPlanar, 'Y12, V12U12 in two surfaces (VU as one surface) with UV byte ordering, U/V\n' 'width = 1/2 Y width, U/V height = 1/2 Y height.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatVYUY_ER = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatVYUY_ER, 'Extended Range Y, U, V in one surface, interleaved as YVYU in one channel.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatUYVY_ER = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatUYVY_ER, 'Extended Range Y, U, V in one surface, interleaved as YUYV in one channel.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatYUYV_ER = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYUYV_ER, 'Extended Range Y, U, V in one surface, interleaved as UYVY in one channel.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatYVYU_ER = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYVYU_ER, 'Extended Range Y, U, V in one surface, interleaved as VYUY in one channel.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatYUVA_ER = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYUVA_ER, 'Extended Range Y, U, V, A four channels in one surface, interleaved as\n' 'AVUY.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatAYUV_ER = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatAYUV_ER, 'Extended Range Y, U, V, A four channels in one surface, interleaved as\n' 'VUYA.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatYUV444Planar_ER = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYUV444Planar_ER, 'Extended Range Y, U, V in three surfaces, U/V width = Y width, U/V height =\n' 'Y height.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatYUV422Planar_ER = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYUV422Planar_ER, 'Extended Range Y, U, V in three surfaces, U/V width = 1/2 Y width, U/V\n' 'height = Y height.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatYUV420Planar_ER = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYUV420Planar_ER, 'Extended Range Y, U, V in three surfaces, U/V width = 1/2 Y width, U/V\n' 'height = 1/2 Y height.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatYUV444SemiPlanar_ER = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYUV444SemiPlanar_ER, 'Extended Range Y, UV in two surfaces (UV as one surface) with VU byte\n' 'ordering, U/V width = Y width, U/V height = Y height.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatYUV422SemiPlanar_ER = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYUV422SemiPlanar_ER, 'Extended Range Y, UV in two surfaces (UV as one surface) with VU byte\n' 'ordering, U/V width = 1/2 Y width, U/V height = Y height.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatYUV420SemiPlanar_ER = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYUV420SemiPlanar_ER, 'Extended Range Y, UV in two surfaces (UV as one surface) with VU byte\n' 'ordering, U/V width = 1/2 Y width, U/V height = 1/2 Y height.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatYVU444Planar_ER = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYVU444Planar_ER, 'Extended Range Y, V, U in three surfaces, U/V width = Y width, U/V height =\n' 'Y height.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatYVU422Planar_ER = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYVU422Planar_ER, 'Extended Range Y, V, U in three surfaces, U/V width = 1/2 Y width, U/V\n' 'height = Y height.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatYVU420Planar_ER = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYVU420Planar_ER, 'Extended Range Y, V, U in three surfaces, U/V width = 1/2 Y width, U/V\n' 'height = 1/2 Y height.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatYVU444SemiPlanar_ER = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYVU444SemiPlanar_ER, 'Extended Range Y, VU in two surfaces (VU as one surface) with UV byte\n' 'ordering, U/V width = Y width, U/V height = Y height.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatYVU422SemiPlanar_ER = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYVU422SemiPlanar_ER, 'Extended Range Y, VU in two surfaces (VU as one surface) with UV byte\n' 'ordering, U/V width = 1/2 Y width, U/V height = Y height.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatYVU420SemiPlanar_ER = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYVU420SemiPlanar_ER, 'Extended Range Y, VU in two surfaces (VU as one surface) with UV byte\n' 'ordering, U/V width = 1/2 Y width, U/V height = 1/2 Y height.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatBayerRGGB = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayerRGGB, 'Bayer format - one channel in one surface with interleaved RGGB ordering.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatBayerBGGR = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayerBGGR, 'Bayer format - one channel in one surface with interleaved BGGR ordering.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatBayerGRBG = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayerGRBG, 'Bayer format - one channel in one surface with interleaved GRBG ordering.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatBayerGBRG = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayerGBRG, 'Bayer format - one channel in one surface with interleaved GBRG ordering.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatBayer10RGGB = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayer10RGGB, 'Bayer10 format - one channel in one surface with interleaved RGGB ordering.\n' 'Out of 16 bits, 10 bits used 6 bits No-op.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatBayer10BGGR = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayer10BGGR, 'Bayer10 format - one channel in one surface with interleaved BGGR ordering.\n' 'Out of 16 bits, 10 bits used 6 bits No-op.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatBayer10GRBG = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayer10GRBG, 'Bayer10 format - one channel in one surface with interleaved GRBG ordering.\n' 'Out of 16 bits, 10 bits used 6 bits No-op.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatBayer10GBRG = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayer10GBRG, 'Bayer10 format - one channel in one surface with interleaved GBRG ordering.\n' 'Out of 16 bits, 10 bits used 6 bits No-op.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatBayer12RGGB = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayer12RGGB, 'Bayer12 format - one channel in one surface with interleaved RGGB ordering.\n' 'Out of 16 bits, 12 bits used 4 bits No-op.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatBayer12BGGR = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayer12BGGR, 'Bayer12 format - one channel in one surface with interleaved BGGR ordering.\n' 'Out of 16 bits, 12 bits used 4 bits No-op.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatBayer12GRBG = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayer12GRBG, 'Bayer12 format - one channel in one surface with interleaved GRBG ordering.\n' 'Out of 16 bits, 12 bits used 4 bits No-op.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatBayer12GBRG = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayer12GBRG, 'Bayer12 format - one channel in one surface with interleaved GBRG ordering.\n' 'Out of 16 bits, 12 bits used 4 bits No-op.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatBayer14RGGB = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayer14RGGB, 'Bayer14 format - one channel in one surface with interleaved RGGB ordering.\n' 'Out of 16 bits, 14 bits used 2 bits No-op.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatBayer14BGGR = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayer14BGGR, 'Bayer14 format - one channel in one surface with interleaved BGGR ordering.\n' 'Out of 16 bits, 14 bits used 2 bits No-op.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatBayer14GRBG = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayer14GRBG, 'Bayer14 format - one channel in one surface with interleaved GRBG ordering.\n' 'Out of 16 bits, 14 bits used 2 bits No-op.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatBayer14GBRG = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayer14GBRG, 'Bayer14 format - one channel in one surface with interleaved GBRG ordering.\n' 'Out of 16 bits, 14 bits used 2 bits No-op.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatBayer20RGGB = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayer20RGGB, 'Bayer20 format - one channel in one surface with interleaved RGGB ordering.\n' 'Out of 32 bits, 20 bits used 12 bits No-op.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatBayer20BGGR = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayer20BGGR, 'Bayer20 format - one channel in one surface with interleaved BGGR ordering.\n' 'Out of 32 bits, 20 bits used 12 bits No-op.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatBayer20GRBG = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayer20GRBG, 'Bayer20 format - one channel in one surface with interleaved GRBG ordering.\n' 'Out of 32 bits, 20 bits used 12 bits No-op.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatBayer20GBRG = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayer20GBRG, 'Bayer20 format - one channel in one surface with interleaved GBRG ordering.\n' 'Out of 32 bits, 20 bits used 12 bits No-op.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatYVU444Planar = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYVU444Planar, 'Y, V, U in three surfaces, each in a separate surface, U/V width = Y width,\n' 'U/V height = Y height.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatYVU422Planar = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYVU422Planar, 'Y, V, U in three surfaces, each in a separate surface, U/V width = 1/2 Y\n' 'width, U/V height = Y height.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatYVU420Planar = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYVU420Planar, 'Y, V, U in three surfaces, each in a separate surface, U/V width = 1/2 Y\n' 'width, U/V height = 1/2 Y height.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatBayerIspRGGB = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayerIspRGGB, 'Nvidia proprietary Bayer ISP format - one channel in one surface with\n' 'interleaved RGGB ordering and mapped to opaque integer datatype.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatBayerIspBGGR = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayerIspBGGR, 'Nvidia proprietary Bayer ISP format - one channel in one surface with\n' 'interleaved BGGR ordering and mapped to opaque integer datatype.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatBayerIspGRBG = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayerIspGRBG, 'Nvidia proprietary Bayer ISP format - one channel in one surface with\n' 'interleaved GRBG ordering and mapped to opaque integer datatype.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatBayerIspGBRG = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayerIspGBRG, 'Nvidia proprietary Bayer ISP format - one channel in one surface with\n' 'interleaved GBRG ordering and mapped to opaque integer datatype.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatBayerBCCR = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayerBCCR, 'Bayer format - one channel in one surface with interleaved BCCR ordering.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatBayerRCCB = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayerRCCB, 'Bayer format - one channel in one surface with interleaved RCCB ordering.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatBayerCRBC = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayerCRBC, 'Bayer format - one channel in one surface with interleaved CRBC ordering.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatBayerCBRC = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayerCBRC, 'Bayer format - one channel in one surface with interleaved CBRC ordering.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatBayer10CCCC = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayer10CCCC, 'Bayer10 format - one channel in one surface with interleaved CCCC ordering.\n' 'Out of 16 bits, 10 bits used 6 bits No-op.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatBayer12BCCR = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayer12BCCR, 'Bayer12 format - one channel in one surface with interleaved BCCR ordering.\n' 'Out of 16 bits, 12 bits used 4 bits No-op.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatBayer12RCCB = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayer12RCCB, 'Bayer12 format - one channel in one surface with interleaved RCCB ordering.\n' 'Out of 16 bits, 12 bits used 4 bits No-op.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatBayer12CRBC = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayer12CRBC, 'Bayer12 format - one channel in one surface with interleaved CRBC ordering.\n' 'Out of 16 bits, 12 bits used 4 bits No-op.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatBayer12CBRC = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayer12CBRC, 'Bayer12 format - one channel in one surface with interleaved CBRC ordering.\n' 'Out of 16 bits, 12 bits used 4 bits No-op.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatBayer12CCCC = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayer12CCCC, 'Bayer12 format - one channel in one surface with interleaved CCCC ordering.\n' 'Out of 16 bits, 12 bits used 4 bits No-op.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatY = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY, 'Color format for single Y plane.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatYUV420SemiPlanar_2020 = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYUV420SemiPlanar_2020, 'Y, UV in two surfaces (UV as one surface) U/V width = 1/2 Y width, U/V\n' 'height = 1/2 Y height.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatYVU420SemiPlanar_2020 = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYVU420SemiPlanar_2020, 'Y, VU in two surfaces (VU as one surface) U/V width = 1/2 Y width, U/V\n' 'height = 1/2 Y height.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatYUV420Planar_2020 = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYUV420Planar_2020, 'Y, U, V in three surfaces, each in a separate surface, U/V width = 1/2 Y\n' 'width, U/V height = 1/2 Y height.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatYVU420Planar_2020 = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYVU420Planar_2020, 'Y, V, U in three surfaces, each in a separate surface, U/V width = 1/2 Y\n' 'width, U/V height = 1/2 Y height.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatYUV420SemiPlanar_709 = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYUV420SemiPlanar_709, 'Y, UV in two surfaces (UV as one surface) U/V width = 1/2 Y width, U/V\n' 'height = 1/2 Y height.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatYVU420SemiPlanar_709 = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYVU420SemiPlanar_709, 'Y, VU in two surfaces (VU as one surface) U/V width = 1/2 Y width, U/V\n' 'height = 1/2 Y height.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatYUV420Planar_709 = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYUV420Planar_709, 'Y, U, V in three surfaces, each in a separate surface, U/V width = 1/2 Y\n' 'width, U/V height = 1/2 Y height.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatYVU420Planar_709 = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYVU420Planar_709, 'Y, V, U in three surfaces, each in a separate surface, U/V width = 1/2 Y\n' 'width, U/V height = 1/2 Y height.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatY10V10U10_420SemiPlanar_709 = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY10V10U10_420SemiPlanar_709, 'Y10, V10U10 in two surfaces (VU as one surface) U/V width = 1/2 Y width,\n' 'U/V height = 1/2 Y height.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatY10V10U10_420SemiPlanar_2020 = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY10V10U10_420SemiPlanar_2020, 'Y10, V10U10 in two surfaces (VU as one surface) U/V width = 1/2 Y width,\n' 'U/V height = 1/2 Y height.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatY10V10U10_422SemiPlanar_2020 = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY10V10U10_422SemiPlanar_2020, 'Y10, V10U10 in two surfaces (VU as one surface) U/V width = 1/2 Y width,\n' 'U/V height = Y height.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatY10V10U10_422SemiPlanar = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY10V10U10_422SemiPlanar, 'Y10, V10U10 in two surfaces (VU as one surface) U/V width = 1/2 Y width,\n' 'U/V height = Y height.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatY10V10U10_422SemiPlanar_709 = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY10V10U10_422SemiPlanar_709, 'Y10, V10U10 in two surfaces (VU as one surface) U/V width = 1/2 Y width,\n' 'U/V height = Y height.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatY_ER = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY_ER, 'Extended Range Color format for single Y plane.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatY_709_ER = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY_709_ER, 'Extended Range Color format for single Y plane.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatY10_ER = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY10_ER, 'Extended Range Color format for single Y10 plane.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatY10_709_ER = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY10_709_ER, 'Extended Range Color format for single Y10 plane.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatY12_ER = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY12_ER, 'Extended Range Color format for single Y12 plane.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatY12_709_ER = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY12_709_ER, 'Extended Range Color format for single Y12 plane.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatYUVA = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYUVA, 'Y, U, V, A four channels in one surface, interleaved as AVUY.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatYVYU = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYVYU, 'Y, U, V in one surface, interleaved as YVYU in one channel.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatVYUY = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatVYUY, 'Y, U, V in one surface, interleaved as VYUY in one channel.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatY10V10U10_420SemiPlanar_ER = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY10V10U10_420SemiPlanar_ER, 'Extended Range Y10, V10U10 in two surfaces (VU as one surface) U/V width =\n' '1/2 Y width, U/V height = 1/2 Y height.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatY10V10U10_420SemiPlanar_709_ER = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY10V10U10_420SemiPlanar_709_ER, 'Extended Range Y10, V10U10 in two surfaces (VU as one surface) U/V width =\n' '1/2 Y width, U/V height = 1/2 Y height.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatY10V10U10_444SemiPlanar_ER = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY10V10U10_444SemiPlanar_ER, 'Extended Range Y10, V10U10 in two surfaces (VU as one surface) U/V width =\n' 'Y width, U/V height = Y height.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatY10V10U10_444SemiPlanar_709_ER = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY10V10U10_444SemiPlanar_709_ER, 'Extended Range Y10, V10U10 in two surfaces (VU as one surface) U/V width =\n' 'Y width, U/V height = Y height.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatY12V12U12_420SemiPlanar_ER = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY12V12U12_420SemiPlanar_ER, 'Extended Range Y12, V12U12 in two surfaces (VU as one surface) U/V width =\n' '1/2 Y width, U/V height = 1/2 Y height.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatY12V12U12_420SemiPlanar_709_ER = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY12V12U12_420SemiPlanar_709_ER, 'Extended Range Y12, V12U12 in two surfaces (VU as one surface) U/V width =\n' '1/2 Y width, U/V height = 1/2 Y height.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatY12V12U12_444SemiPlanar_ER = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY12V12U12_444SemiPlanar_ER, 'Extended Range Y12, V12U12 in two surfaces (VU as one surface) U/V width =\n' 'Y width, U/V height = Y height.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatY12V12U12_444SemiPlanar_709_ER = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY12V12U12_444SemiPlanar_709_ER, 'Extended Range Y12, V12U12 in two surfaces (VU as one surface) U/V width =\n' 'Y width, U/V height = Y height.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatUYVY709 = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatUYVY709, 'Y, U, V in one surface, interleaved as UYVY in one channel.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatUYVY709_ER = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatUYVY709_ER, 'Extended Range Y, U, V in one surface, interleaved as UYVY in one channel.\n' - ){{endif}} - {{if True}} + ) + cudaEglColorFormatUYVY2020 = ( cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatUYVY2020, 'Y, U, V in one surface, interleaved as UYVY in one channel.\n' - ){{endif}} - -{{endif}} -{{if 'cudaChannelFormatKind' in found_types}} + ) class cudaChannelFormatKind(_FastEnum): """ Channel format kind """ - {{if 'cudaChannelFormatKindSigned' in found_values}} + cudaChannelFormatKindSigned = ( cyruntime.cudaChannelFormatKind.cudaChannelFormatKindSigned, 'Signed channel format\n' - ){{endif}} - {{if 'cudaChannelFormatKindUnsigned' in found_values}} + ) + cudaChannelFormatKindUnsigned = ( cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsigned, 'Unsigned channel format\n' - ){{endif}} - {{if 'cudaChannelFormatKindFloat' in found_values}} + ) + cudaChannelFormatKindFloat = ( cyruntime.cudaChannelFormatKind.cudaChannelFormatKindFloat, 'Float channel format\n' - ){{endif}} - {{if 'cudaChannelFormatKindNone' in found_values}} + ) + cudaChannelFormatKindNone = ( cyruntime.cudaChannelFormatKind.cudaChannelFormatKindNone, 'No channel format\n' - ){{endif}} - {{if 'cudaChannelFormatKindNV12' in found_values}} + ) + cudaChannelFormatKindNV12 = ( cyruntime.cudaChannelFormatKind.cudaChannelFormatKindNV12, 'Unsigned 8-bit integers, planar 4:2:0 YUV format\n' - ){{endif}} - {{if 'cudaChannelFormatKindUnsignedNormalized8X1' in found_values}} + ) + cudaChannelFormatKindUnsignedNormalized8X1 = ( cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized8X1, '1 channel unsigned 8-bit normalized integer\n' - ){{endif}} - {{if 'cudaChannelFormatKindUnsignedNormalized8X2' in found_values}} + ) + cudaChannelFormatKindUnsignedNormalized8X2 = ( cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized8X2, '2 channel unsigned 8-bit normalized integer\n' - ){{endif}} - {{if 'cudaChannelFormatKindUnsignedNormalized8X4' in found_values}} + ) + cudaChannelFormatKindUnsignedNormalized8X4 = ( cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized8X4, '4 channel unsigned 8-bit normalized integer\n' - ){{endif}} - {{if 'cudaChannelFormatKindUnsignedNormalized16X1' in found_values}} + ) + cudaChannelFormatKindUnsignedNormalized16X1 = ( cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized16X1, '1 channel unsigned 16-bit normalized integer\n' - ){{endif}} - {{if 'cudaChannelFormatKindUnsignedNormalized16X2' in found_values}} + ) + cudaChannelFormatKindUnsignedNormalized16X2 = ( cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized16X2, '2 channel unsigned 16-bit normalized integer\n' - ){{endif}} - {{if 'cudaChannelFormatKindUnsignedNormalized16X4' in found_values}} + ) + cudaChannelFormatKindUnsignedNormalized16X4 = ( cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized16X4, '4 channel unsigned 16-bit normalized integer\n' - ){{endif}} - {{if 'cudaChannelFormatKindSignedNormalized8X1' in found_values}} + ) + cudaChannelFormatKindSignedNormalized8X1 = ( cyruntime.cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized8X1, '1 channel signed 8-bit normalized integer\n' - ){{endif}} - {{if 'cudaChannelFormatKindSignedNormalized8X2' in found_values}} + ) + cudaChannelFormatKindSignedNormalized8X2 = ( cyruntime.cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized8X2, '2 channel signed 8-bit normalized integer\n' - ){{endif}} - {{if 'cudaChannelFormatKindSignedNormalized8X4' in found_values}} + ) + cudaChannelFormatKindSignedNormalized8X4 = ( cyruntime.cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized8X4, '4 channel signed 8-bit normalized integer\n' - ){{endif}} - {{if 'cudaChannelFormatKindSignedNormalized16X1' in found_values}} + ) + cudaChannelFormatKindSignedNormalized16X1 = ( cyruntime.cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized16X1, '1 channel signed 16-bit normalized integer\n' - ){{endif}} - {{if 'cudaChannelFormatKindSignedNormalized16X2' in found_values}} + ) + cudaChannelFormatKindSignedNormalized16X2 = ( cyruntime.cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized16X2, '2 channel signed 16-bit normalized integer\n' - ){{endif}} - {{if 'cudaChannelFormatKindSignedNormalized16X4' in found_values}} + ) + cudaChannelFormatKindSignedNormalized16X4 = ( cyruntime.cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized16X4, '4 channel signed 16-bit normalized integer\n' - ){{endif}} - {{if 'cudaChannelFormatKindUnsignedBlockCompressed1' in found_values}} + ) + cudaChannelFormatKindUnsignedBlockCompressed1 = ( cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed1, '4 channel unsigned normalized block-compressed (BC1 compression) format\n' - ){{endif}} - {{if 'cudaChannelFormatKindUnsignedBlockCompressed1SRGB' in found_values}} + ) + cudaChannelFormatKindUnsignedBlockCompressed1SRGB = ( cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed1SRGB, '4 channel unsigned normalized block-compressed (BC1 compression) format\n' 'with sRGB encoding\n' - ){{endif}} - {{if 'cudaChannelFormatKindUnsignedBlockCompressed2' in found_values}} + ) + cudaChannelFormatKindUnsignedBlockCompressed2 = ( cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed2, '4 channel unsigned normalized block-compressed (BC2 compression) format\n' - ){{endif}} - {{if 'cudaChannelFormatKindUnsignedBlockCompressed2SRGB' in found_values}} + ) + cudaChannelFormatKindUnsignedBlockCompressed2SRGB = ( cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed2SRGB, '4 channel unsigned normalized block-compressed (BC2 compression) format\n' 'with sRGB encoding\n' - ){{endif}} - {{if 'cudaChannelFormatKindUnsignedBlockCompressed3' in found_values}} + ) + cudaChannelFormatKindUnsignedBlockCompressed3 = ( cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed3, '4 channel unsigned normalized block-compressed (BC3 compression) format\n' - ){{endif}} - {{if 'cudaChannelFormatKindUnsignedBlockCompressed3SRGB' in found_values}} + ) + cudaChannelFormatKindUnsignedBlockCompressed3SRGB = ( cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed3SRGB, '4 channel unsigned normalized block-compressed (BC3 compression) format\n' 'with sRGB encoding\n' - ){{endif}} - {{if 'cudaChannelFormatKindUnsignedBlockCompressed4' in found_values}} + ) + cudaChannelFormatKindUnsignedBlockCompressed4 = ( cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed4, '1 channel unsigned normalized block-compressed (BC4 compression) format\n' - ){{endif}} - {{if 'cudaChannelFormatKindSignedBlockCompressed4' in found_values}} + ) + cudaChannelFormatKindSignedBlockCompressed4 = ( cyruntime.cudaChannelFormatKind.cudaChannelFormatKindSignedBlockCompressed4, '1 channel signed normalized block-compressed (BC4 compression) format\n' - ){{endif}} - {{if 'cudaChannelFormatKindUnsignedBlockCompressed5' in found_values}} + ) + cudaChannelFormatKindUnsignedBlockCompressed5 = ( cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed5, '2 channel unsigned normalized block-compressed (BC5 compression) format\n' - ){{endif}} - {{if 'cudaChannelFormatKindSignedBlockCompressed5' in found_values}} + ) + cudaChannelFormatKindSignedBlockCompressed5 = ( cyruntime.cudaChannelFormatKind.cudaChannelFormatKindSignedBlockCompressed5, '2 channel signed normalized block-compressed (BC5 compression) format\n' - ){{endif}} - {{if 'cudaChannelFormatKindUnsignedBlockCompressed6H' in found_values}} + ) + cudaChannelFormatKindUnsignedBlockCompressed6H = ( cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed6H, '3 channel unsigned half-float block-compressed (BC6H compression) format\n' - ){{endif}} - {{if 'cudaChannelFormatKindSignedBlockCompressed6H' in found_values}} + ) + cudaChannelFormatKindSignedBlockCompressed6H = ( cyruntime.cudaChannelFormatKind.cudaChannelFormatKindSignedBlockCompressed6H, '3 channel signed half-float block-compressed (BC6H compression) format\n' - ){{endif}} - {{if 'cudaChannelFormatKindUnsignedBlockCompressed7' in found_values}} + ) + cudaChannelFormatKindUnsignedBlockCompressed7 = ( cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed7, '4 channel unsigned normalized block-compressed (BC7 compression) format\n' - ){{endif}} - {{if 'cudaChannelFormatKindUnsignedBlockCompressed7SRGB' in found_values}} + ) + cudaChannelFormatKindUnsignedBlockCompressed7SRGB = ( cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed7SRGB, '4 channel unsigned normalized block-compressed (BC7 compression) format\n' 'with sRGB encoding\n' - ){{endif}} - {{if 'cudaChannelFormatKindUnsignedNormalized1010102' in found_values}} + ) + cudaChannelFormatKindUnsignedNormalized1010102 = ( cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized1010102, '4 channel unsigned normalized (10-bit, 10-bit, 10-bit, 2-bit) format\n' - ){{endif}} - {{if 'cudaChannelFormatKindUnsigned8Packed422' in found_values}} + ) + cudaChannelFormatKindUnsigned8Packed422 = ( cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsigned8Packed422, '4 channel unsigned 8-bit packed format, with 4:2:2 sampling\n' - ){{endif}} - {{if 'cudaChannelFormatKindUnsigned8Packed444' in found_values}} + ) + cudaChannelFormatKindUnsigned8Packed444 = ( cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsigned8Packed444, '4 channel unsigned 8-bit packed format, with 4:4:4 sampling\n' - ){{endif}} - {{if 'cudaChannelFormatKindUnsigned8SemiPlanar420' in found_values}} + ) + cudaChannelFormatKindUnsigned8SemiPlanar420 = ( cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsigned8SemiPlanar420, '3 channel unsigned 8-bit semi-planar format, with 4:2:0 sampling\n' - ){{endif}} - {{if 'cudaChannelFormatKindUnsigned16SemiPlanar420' in found_values}} + ) + cudaChannelFormatKindUnsigned16SemiPlanar420 = ( cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsigned16SemiPlanar420, '3 channel unsigned 16-bit semi-planar format, with 4:2:0 sampling\n' - ){{endif}} - {{if 'cudaChannelFormatKindUnsigned8SemiPlanar422' in found_values}} + ) + cudaChannelFormatKindUnsigned8SemiPlanar422 = ( cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsigned8SemiPlanar422, '3 channel unsigned 8-bit semi-planar format, with 4:2:2 sampling\n' - ){{endif}} - {{if 'cudaChannelFormatKindUnsigned16SemiPlanar422' in found_values}} + ) + cudaChannelFormatKindUnsigned16SemiPlanar422 = ( cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsigned16SemiPlanar422, '3 channel unsigned 16-bit semi-planar format, with 4:2:2 sampling\n' - ){{endif}} - {{if 'cudaChannelFormatKindUnsigned8SemiPlanar444' in found_values}} + ) + cudaChannelFormatKindUnsigned8SemiPlanar444 = ( cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsigned8SemiPlanar444, '3 channel unsigned 8-bit semi-planar format, with 4:4:4 sampling\n' - ){{endif}} - {{if 'cudaChannelFormatKindUnsigned16SemiPlanar444' in found_values}} + ) + cudaChannelFormatKindUnsigned16SemiPlanar444 = ( cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsigned16SemiPlanar444, '3 channel unsigned 16-bit semi-planar format, with 4:4:4 sampling\n' - ){{endif}} - {{if 'cudaChannelFormatKindUnsigned8Planar420' in found_values}} + ) + cudaChannelFormatKindUnsigned8Planar420 = ( cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsigned8Planar420, '3 channel unsigned 8-bit planar format, with 4:2:0 sampling\n' - ){{endif}} - {{if 'cudaChannelFormatKindUnsigned16Planar420' in found_values}} + ) + cudaChannelFormatKindUnsigned16Planar420 = ( cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsigned16Planar420, '3 channel unsigned 16-bit planar format, with 4:2:0 sampling\n' - ){{endif}} - {{if 'cudaChannelFormatKindUnsigned8Planar422' in found_values}} + ) + cudaChannelFormatKindUnsigned8Planar422 = ( cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsigned8Planar422, '3 channel unsigned 8-bit planar format, with 4:2:2 sampling\n' - ){{endif}} - {{if 'cudaChannelFormatKindUnsigned16Planar422' in found_values}} + ) + cudaChannelFormatKindUnsigned16Planar422 = ( cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsigned16Planar422, '3 channel unsigned 16-bit planar format, with 4:2:2 sampling\n' - ){{endif}} - {{if 'cudaChannelFormatKindUnsigned8Planar444' in found_values}} + ) + cudaChannelFormatKindUnsigned8Planar444 = ( cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsigned8Planar444, '3 channel unsigned 8-bit planar format, with 4:4:4 sampling\n' - ){{endif}} - {{if 'cudaChannelFormatKindUnsigned16Planar444' in found_values}} + ) + cudaChannelFormatKindUnsigned16Planar444 = ( cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsigned16Planar444, '3 channel unsigned 16-bit planar format, with 4:4:4 sampling\n' - ){{endif}} - -{{endif}} -{{if 'cudaMemoryType' in found_types}} + ) class cudaMemoryType(_FastEnum): """ CUDA memory types """ - {{if 'cudaMemoryTypeUnregistered' in found_values}} + cudaMemoryTypeUnregistered = ( cyruntime.cudaMemoryType.cudaMemoryTypeUnregistered, 'Unregistered memory\n' - ){{endif}} - {{if 'cudaMemoryTypeHost' in found_values}} + ) + cudaMemoryTypeHost = ( cyruntime.cudaMemoryType.cudaMemoryTypeHost, 'Host memory\n' - ){{endif}} - {{if 'cudaMemoryTypeDevice' in found_values}} + ) + cudaMemoryTypeDevice = ( cyruntime.cudaMemoryType.cudaMemoryTypeDevice, 'Device memory\n' - ){{endif}} - {{if 'cudaMemoryTypeManaged' in found_values}} + ) + cudaMemoryTypeManaged = ( cyruntime.cudaMemoryType.cudaMemoryTypeManaged, 'Managed memory\n' - ){{endif}} - -{{endif}} -{{if 'cudaMemcpyKind' in found_types}} + ) class cudaMemcpyKind(_FastEnum): """ CUDA memory copy types """ - {{if 'cudaMemcpyHostToHost' in found_values}} + cudaMemcpyHostToHost = ( cyruntime.cudaMemcpyKind.cudaMemcpyHostToHost, 'Host -> Host\n' - ){{endif}} - {{if 'cudaMemcpyHostToDevice' in found_values}} + ) + cudaMemcpyHostToDevice = ( cyruntime.cudaMemcpyKind.cudaMemcpyHostToDevice, 'Host -> Device\n' - ){{endif}} - {{if 'cudaMemcpyDeviceToHost' in found_values}} + ) + cudaMemcpyDeviceToHost = ( cyruntime.cudaMemcpyKind.cudaMemcpyDeviceToHost, 'Device -> Host\n' - ){{endif}} - {{if 'cudaMemcpyDeviceToDevice' in found_values}} + ) + cudaMemcpyDeviceToDevice = ( cyruntime.cudaMemcpyKind.cudaMemcpyDeviceToDevice, 'Device -> Device\n' - ){{endif}} - {{if 'cudaMemcpyDefault' in found_values}} + ) + cudaMemcpyDefault = ( cyruntime.cudaMemcpyKind.cudaMemcpyDefault, 'Direction of the transfer is inferred from the pointer values. Requires\n' 'unified virtual addressing\n' - ){{endif}} - -{{endif}} -{{if 'cudaAccessProperty' in found_types}} + ) class cudaAccessProperty(_FastEnum): """ Specifies performance hint with :py:obj:`~.cudaAccessPolicyWindow` for hitProp and missProp members. """ - {{if 'cudaAccessPropertyNormal' in found_values}} + cudaAccessPropertyNormal = ( cyruntime.cudaAccessProperty.cudaAccessPropertyNormal, 'Normal cache persistence.\n' - ){{endif}} - {{if 'cudaAccessPropertyStreaming' in found_values}} + ) + cudaAccessPropertyStreaming = ( cyruntime.cudaAccessProperty.cudaAccessPropertyStreaming, 'Streaming access is less likely to persit from cache.\n' - ){{endif}} - {{if 'cudaAccessPropertyPersisting' in found_values}} + ) + cudaAccessPropertyPersisting = ( cyruntime.cudaAccessProperty.cudaAccessPropertyPersisting, 'Persisting access is more likely to persist in cache.\n' - ){{endif}} - -{{endif}} -{{if 'cudaStreamCaptureStatus' in found_types}} + ) class cudaStreamCaptureStatus(_FastEnum): """ Possible stream capture statuses returned by :py:obj:`~.cudaStreamIsCapturing` """ - {{if 'cudaStreamCaptureStatusNone' in found_values}} + cudaStreamCaptureStatusNone = ( cyruntime.cudaStreamCaptureStatus.cudaStreamCaptureStatusNone, 'Stream is not capturing\n' - ){{endif}} - {{if 'cudaStreamCaptureStatusActive' in found_values}} + ) + cudaStreamCaptureStatusActive = ( cyruntime.cudaStreamCaptureStatus.cudaStreamCaptureStatusActive, 'Stream is actively capturing\n' - ){{endif}} - {{if 'cudaStreamCaptureStatusInvalidated' in found_values}} + ) + cudaStreamCaptureStatusInvalidated = ( cyruntime.cudaStreamCaptureStatus.cudaStreamCaptureStatusInvalidated, 'Stream is part of a capture sequence that has been invalidated, but not\n' 'terminated\n' - ){{endif}} - -{{endif}} -{{if 'cudaGraphRecaptureStatus' in found_types}} + ) class cudaGraphRecaptureStatus(_FastEnum): """ Possible recapture statuses that can be returned to the user callback """ - {{if 'cudaGraphRecaptureEligibleForUpdate' in found_values}} + cudaGraphRecaptureEligibleForUpdate = ( cyruntime.cudaGraphRecaptureStatus.cudaGraphRecaptureEligibleForUpdate, 'Node is eligible for update in an instantiated graph.\n' - ){{endif}} - {{if 'cudaGraphRecaptureIneligibleForUpdate' in found_values}} + ) + cudaGraphRecaptureIneligibleForUpdate = ( cyruntime.cudaGraphRecaptureStatus.cudaGraphRecaptureIneligibleForUpdate, 'Parameter changes in the node cannot be applied to an instantiated graph.\n' - ){{endif}} - {{if 'cudaGraphRecaptureError' in found_values}} + ) + cudaGraphRecaptureError = ( cyruntime.cudaGraphRecaptureStatus.cudaGraphRecaptureError, 'Error while attempting to recapture the node. The recapture will be ended\n' 'regardless of the return value from the callback.\n' - ){{endif}} - -{{endif}} -{{if 'cudaStreamCaptureMode' in found_types}} + ) class cudaStreamCaptureMode(_FastEnum): """ @@ -3319,1548 +3248,1476 @@ class cudaStreamCaptureMode(_FastEnum): details see :py:obj:`~.cudaStreamBeginCapture` and :py:obj:`~.cudaThreadExchangeStreamCaptureMode` """ - {{if 'cudaStreamCaptureModeGlobal' in found_values}} - cudaStreamCaptureModeGlobal = cyruntime.cudaStreamCaptureMode.cudaStreamCaptureModeGlobal{{endif}} - {{if 'cudaStreamCaptureModeThreadLocal' in found_values}} - cudaStreamCaptureModeThreadLocal = cyruntime.cudaStreamCaptureMode.cudaStreamCaptureModeThreadLocal{{endif}} - {{if 'cudaStreamCaptureModeRelaxed' in found_values}} - cudaStreamCaptureModeRelaxed = cyruntime.cudaStreamCaptureMode.cudaStreamCaptureModeRelaxed{{endif}} -{{endif}} -{{if 'cudaSynchronizationPolicy' in found_types}} + cudaStreamCaptureModeGlobal = cyruntime.cudaStreamCaptureMode.cudaStreamCaptureModeGlobal + + cudaStreamCaptureModeThreadLocal = cyruntime.cudaStreamCaptureMode.cudaStreamCaptureModeThreadLocal + + cudaStreamCaptureModeRelaxed = cyruntime.cudaStreamCaptureMode.cudaStreamCaptureModeRelaxed class cudaSynchronizationPolicy(_FastEnum): """ """ - {{if 'cudaSyncPolicyAuto' in found_values}} - cudaSyncPolicyAuto = cyruntime.cudaSynchronizationPolicy.cudaSyncPolicyAuto{{endif}} - {{if 'cudaSyncPolicySpin' in found_values}} - cudaSyncPolicySpin = cyruntime.cudaSynchronizationPolicy.cudaSyncPolicySpin{{endif}} - {{if 'cudaSyncPolicyYield' in found_values}} - cudaSyncPolicyYield = cyruntime.cudaSynchronizationPolicy.cudaSyncPolicyYield{{endif}} - {{if 'cudaSyncPolicyBlockingSync' in found_values}} - cudaSyncPolicyBlockingSync = cyruntime.cudaSynchronizationPolicy.cudaSyncPolicyBlockingSync{{endif}} -{{endif}} -{{if 'cudaClusterSchedulingPolicy' in found_types}} + cudaSyncPolicyAuto = cyruntime.cudaSynchronizationPolicy.cudaSyncPolicyAuto + + cudaSyncPolicySpin = cyruntime.cudaSynchronizationPolicy.cudaSyncPolicySpin + + cudaSyncPolicyYield = cyruntime.cudaSynchronizationPolicy.cudaSyncPolicyYield + + cudaSyncPolicyBlockingSync = cyruntime.cudaSynchronizationPolicy.cudaSyncPolicyBlockingSync class cudaClusterSchedulingPolicy(_FastEnum): """ Cluster scheduling policies. These may be passed to :py:obj:`~.cudaFuncSetAttribute` """ - {{if 'cudaClusterSchedulingPolicyDefault' in found_values}} + cudaClusterSchedulingPolicyDefault = ( cyruntime.cudaClusterSchedulingPolicy.cudaClusterSchedulingPolicyDefault, 'the default policy\n' - ){{endif}} - {{if 'cudaClusterSchedulingPolicySpread' in found_values}} + ) + cudaClusterSchedulingPolicySpread = ( cyruntime.cudaClusterSchedulingPolicy.cudaClusterSchedulingPolicySpread, 'spread the blocks within a cluster to the SMs\n' - ){{endif}} - {{if 'cudaClusterSchedulingPolicyLoadBalancing' in found_values}} + ) + cudaClusterSchedulingPolicyLoadBalancing = ( cyruntime.cudaClusterSchedulingPolicy.cudaClusterSchedulingPolicyLoadBalancing, 'allow the hardware to load-balance the blocks in a cluster to the SMs\n' - ){{endif}} - -{{endif}} -{{if 'cudaStreamUpdateCaptureDependenciesFlags' in found_types}} + ) class cudaStreamUpdateCaptureDependenciesFlags(_FastEnum): """ Flags for :py:obj:`~.cudaStreamUpdateCaptureDependencies` """ - {{if 'cudaStreamAddCaptureDependencies' in found_values}} + cudaStreamAddCaptureDependencies = ( cyruntime.cudaStreamUpdateCaptureDependenciesFlags.cudaStreamAddCaptureDependencies, 'Add new nodes to the dependency set\n' - ){{endif}} - {{if 'cudaStreamSetCaptureDependencies' in found_values}} + ) + cudaStreamSetCaptureDependencies = ( cyruntime.cudaStreamUpdateCaptureDependenciesFlags.cudaStreamSetCaptureDependencies, 'Replace the dependency set with the new nodes\n' - ){{endif}} - -{{endif}} -{{if 'cudaUserObjectFlags' in found_types}} + ) class cudaUserObjectFlags(_FastEnum): """ Flags for user objects for graphs """ - {{if 'cudaUserObjectNoDestructorSync' in found_values}} + cudaUserObjectNoDestructorSync = ( cyruntime.cudaUserObjectFlags.cudaUserObjectNoDestructorSync, 'Indicates the destructor execution is not synchronized by any CUDA handle.\n' - ){{endif}} - -{{endif}} -{{if 'cudaUserObjectRetainFlags' in found_types}} + ) class cudaUserObjectRetainFlags(_FastEnum): """ Flags for retaining user object references for graphs """ - {{if 'cudaGraphUserObjectMove' in found_values}} + cudaGraphUserObjectMove = ( cyruntime.cudaUserObjectRetainFlags.cudaGraphUserObjectMove, 'Transfer references from the caller rather than creating new references.\n' - ){{endif}} - -{{endif}} -{{if 'cudaHostTaskSyncMode' in found_types}} + ) class cudaHostTaskSyncMode(_FastEnum): """ Flags for host task sync mode """ - {{if 'cudaHostTaskBlocking' in found_values}} - cudaHostTaskBlocking = cyruntime.cudaHostTaskSyncMode.cudaHostTaskBlocking{{endif}} - {{if 'cudaHostTaskSpinWait' in found_values}} - cudaHostTaskSpinWait = cyruntime.cudaHostTaskSyncMode.cudaHostTaskSpinWait{{endif}} -{{endif}} -{{if 'cudaGraphicsRegisterFlags' in found_types}} + cudaHostTaskBlocking = cyruntime.cudaHostTaskSyncMode.cudaHostTaskBlocking + + cudaHostTaskSpinWait = cyruntime.cudaHostTaskSyncMode.cudaHostTaskSpinWait class cudaGraphicsRegisterFlags(_FastEnum): """ CUDA graphics interop register flags """ - {{if 'cudaGraphicsRegisterFlagsNone' in found_values}} + cudaGraphicsRegisterFlagsNone = ( cyruntime.cudaGraphicsRegisterFlags.cudaGraphicsRegisterFlagsNone, 'Default\n' - ){{endif}} - {{if 'cudaGraphicsRegisterFlagsReadOnly' in found_values}} + ) + cudaGraphicsRegisterFlagsReadOnly = ( cyruntime.cudaGraphicsRegisterFlags.cudaGraphicsRegisterFlagsReadOnly, 'CUDA will not write to this resource\n' - ){{endif}} - {{if 'cudaGraphicsRegisterFlagsWriteDiscard' in found_values}} + ) + cudaGraphicsRegisterFlagsWriteDiscard = ( cyruntime.cudaGraphicsRegisterFlags.cudaGraphicsRegisterFlagsWriteDiscard, 'CUDA will only write to and will not read from this resource\n' - ){{endif}} - {{if 'cudaGraphicsRegisterFlagsSurfaceLoadStore' in found_values}} + ) + cudaGraphicsRegisterFlagsSurfaceLoadStore = ( cyruntime.cudaGraphicsRegisterFlags.cudaGraphicsRegisterFlagsSurfaceLoadStore, 'CUDA will bind this resource to a surface reference\n' - ){{endif}} - {{if 'cudaGraphicsRegisterFlagsTextureGather' in found_values}} + ) + cudaGraphicsRegisterFlagsTextureGather = ( cyruntime.cudaGraphicsRegisterFlags.cudaGraphicsRegisterFlagsTextureGather, 'CUDA will perform texture gather operations on this resource\n' - ){{endif}} - -{{endif}} -{{if 'cudaGraphicsMapFlags' in found_types}} + ) class cudaGraphicsMapFlags(_FastEnum): """ CUDA graphics interop map flags """ - {{if 'cudaGraphicsMapFlagsNone' in found_values}} + cudaGraphicsMapFlagsNone = ( cyruntime.cudaGraphicsMapFlags.cudaGraphicsMapFlagsNone, 'Default; Assume resource can be read/written\n' - ){{endif}} - {{if 'cudaGraphicsMapFlagsReadOnly' in found_values}} + ) + cudaGraphicsMapFlagsReadOnly = ( cyruntime.cudaGraphicsMapFlags.cudaGraphicsMapFlagsReadOnly, 'CUDA will not write to this resource\n' - ){{endif}} - {{if 'cudaGraphicsMapFlagsWriteDiscard' in found_values}} + ) + cudaGraphicsMapFlagsWriteDiscard = ( cyruntime.cudaGraphicsMapFlags.cudaGraphicsMapFlagsWriteDiscard, 'CUDA will only write to and will not read from this resource\n' - ){{endif}} - -{{endif}} -{{if 'cudaGraphicsCubeFace' in found_types}} + ) class cudaGraphicsCubeFace(_FastEnum): """ CUDA graphics interop array indices for cube maps """ - {{if 'cudaGraphicsCubeFacePositiveX' in found_values}} + cudaGraphicsCubeFacePositiveX = ( cyruntime.cudaGraphicsCubeFace.cudaGraphicsCubeFacePositiveX, 'Positive X face of cubemap\n' - ){{endif}} - {{if 'cudaGraphicsCubeFaceNegativeX' in found_values}} + ) + cudaGraphicsCubeFaceNegativeX = ( cyruntime.cudaGraphicsCubeFace.cudaGraphicsCubeFaceNegativeX, 'Negative X face of cubemap\n' - ){{endif}} - {{if 'cudaGraphicsCubeFacePositiveY' in found_values}} + ) + cudaGraphicsCubeFacePositiveY = ( cyruntime.cudaGraphicsCubeFace.cudaGraphicsCubeFacePositiveY, 'Positive Y face of cubemap\n' - ){{endif}} - {{if 'cudaGraphicsCubeFaceNegativeY' in found_values}} + ) + cudaGraphicsCubeFaceNegativeY = ( cyruntime.cudaGraphicsCubeFace.cudaGraphicsCubeFaceNegativeY, 'Negative Y face of cubemap\n' - ){{endif}} - {{if 'cudaGraphicsCubeFacePositiveZ' in found_values}} + ) + cudaGraphicsCubeFacePositiveZ = ( cyruntime.cudaGraphicsCubeFace.cudaGraphicsCubeFacePositiveZ, 'Positive Z face of cubemap\n' - ){{endif}} - {{if 'cudaGraphicsCubeFaceNegativeZ' in found_values}} + ) + cudaGraphicsCubeFaceNegativeZ = ( cyruntime.cudaGraphicsCubeFace.cudaGraphicsCubeFaceNegativeZ, 'Negative Z face of cubemap\n' - ){{endif}} - -{{endif}} -{{if 'cudaResourceType' in found_types}} + ) class cudaResourceType(_FastEnum): """ CUDA resource types """ - {{if 'cudaResourceTypeArray' in found_values}} + cudaResourceTypeArray = ( cyruntime.cudaResourceType.cudaResourceTypeArray, 'Array resource\n' - ){{endif}} - {{if 'cudaResourceTypeMipmappedArray' in found_values}} + ) + cudaResourceTypeMipmappedArray = ( cyruntime.cudaResourceType.cudaResourceTypeMipmappedArray, 'Mipmapped array resource\n' - ){{endif}} - {{if 'cudaResourceTypeLinear' in found_values}} + ) + cudaResourceTypeLinear = ( cyruntime.cudaResourceType.cudaResourceTypeLinear, 'Linear resource\n' - ){{endif}} - {{if 'cudaResourceTypePitch2D' in found_values}} + ) + cudaResourceTypePitch2D = ( cyruntime.cudaResourceType.cudaResourceTypePitch2D, 'Pitch 2D resource\n' - ){{endif}} - -{{endif}} -{{if 'cudaResourceViewFormat' in found_types}} + ) class cudaResourceViewFormat(_FastEnum): """ CUDA texture resource view formats """ - {{if 'cudaResViewFormatNone' in found_values}} + cudaResViewFormatNone = ( cyruntime.cudaResourceViewFormat.cudaResViewFormatNone, 'No resource view format (use underlying resource format)\n' - ){{endif}} - {{if 'cudaResViewFormatUnsignedChar1' in found_values}} + ) + cudaResViewFormatUnsignedChar1 = ( cyruntime.cudaResourceViewFormat.cudaResViewFormatUnsignedChar1, '1 channel unsigned 8-bit integers\n' - ){{endif}} - {{if 'cudaResViewFormatUnsignedChar2' in found_values}} + ) + cudaResViewFormatUnsignedChar2 = ( cyruntime.cudaResourceViewFormat.cudaResViewFormatUnsignedChar2, '2 channel unsigned 8-bit integers\n' - ){{endif}} - {{if 'cudaResViewFormatUnsignedChar4' in found_values}} + ) + cudaResViewFormatUnsignedChar4 = ( cyruntime.cudaResourceViewFormat.cudaResViewFormatUnsignedChar4, '4 channel unsigned 8-bit integers\n' - ){{endif}} - {{if 'cudaResViewFormatSignedChar1' in found_values}} + ) + cudaResViewFormatSignedChar1 = ( cyruntime.cudaResourceViewFormat.cudaResViewFormatSignedChar1, '1 channel signed 8-bit integers\n' - ){{endif}} - {{if 'cudaResViewFormatSignedChar2' in found_values}} + ) + cudaResViewFormatSignedChar2 = ( cyruntime.cudaResourceViewFormat.cudaResViewFormatSignedChar2, '2 channel signed 8-bit integers\n' - ){{endif}} - {{if 'cudaResViewFormatSignedChar4' in found_values}} + ) + cudaResViewFormatSignedChar4 = ( cyruntime.cudaResourceViewFormat.cudaResViewFormatSignedChar4, '4 channel signed 8-bit integers\n' - ){{endif}} - {{if 'cudaResViewFormatUnsignedShort1' in found_values}} + ) + cudaResViewFormatUnsignedShort1 = ( cyruntime.cudaResourceViewFormat.cudaResViewFormatUnsignedShort1, '1 channel unsigned 16-bit integers\n' - ){{endif}} - {{if 'cudaResViewFormatUnsignedShort2' in found_values}} + ) + cudaResViewFormatUnsignedShort2 = ( cyruntime.cudaResourceViewFormat.cudaResViewFormatUnsignedShort2, '2 channel unsigned 16-bit integers\n' - ){{endif}} - {{if 'cudaResViewFormatUnsignedShort4' in found_values}} + ) + cudaResViewFormatUnsignedShort4 = ( cyruntime.cudaResourceViewFormat.cudaResViewFormatUnsignedShort4, '4 channel unsigned 16-bit integers\n' - ){{endif}} - {{if 'cudaResViewFormatSignedShort1' in found_values}} + ) + cudaResViewFormatSignedShort1 = ( cyruntime.cudaResourceViewFormat.cudaResViewFormatSignedShort1, '1 channel signed 16-bit integers\n' - ){{endif}} - {{if 'cudaResViewFormatSignedShort2' in found_values}} + ) + cudaResViewFormatSignedShort2 = ( cyruntime.cudaResourceViewFormat.cudaResViewFormatSignedShort2, '2 channel signed 16-bit integers\n' - ){{endif}} - {{if 'cudaResViewFormatSignedShort4' in found_values}} + ) + cudaResViewFormatSignedShort4 = ( cyruntime.cudaResourceViewFormat.cudaResViewFormatSignedShort4, '4 channel signed 16-bit integers\n' - ){{endif}} - {{if 'cudaResViewFormatUnsignedInt1' in found_values}} + ) + cudaResViewFormatUnsignedInt1 = ( cyruntime.cudaResourceViewFormat.cudaResViewFormatUnsignedInt1, '1 channel unsigned 32-bit integers\n' - ){{endif}} - {{if 'cudaResViewFormatUnsignedInt2' in found_values}} + ) + cudaResViewFormatUnsignedInt2 = ( cyruntime.cudaResourceViewFormat.cudaResViewFormatUnsignedInt2, '2 channel unsigned 32-bit integers\n' - ){{endif}} - {{if 'cudaResViewFormatUnsignedInt4' in found_values}} + ) + cudaResViewFormatUnsignedInt4 = ( cyruntime.cudaResourceViewFormat.cudaResViewFormatUnsignedInt4, '4 channel unsigned 32-bit integers\n' - ){{endif}} - {{if 'cudaResViewFormatSignedInt1' in found_values}} + ) + cudaResViewFormatSignedInt1 = ( cyruntime.cudaResourceViewFormat.cudaResViewFormatSignedInt1, '1 channel signed 32-bit integers\n' - ){{endif}} - {{if 'cudaResViewFormatSignedInt2' in found_values}} + ) + cudaResViewFormatSignedInt2 = ( cyruntime.cudaResourceViewFormat.cudaResViewFormatSignedInt2, '2 channel signed 32-bit integers\n' - ){{endif}} - {{if 'cudaResViewFormatSignedInt4' in found_values}} + ) + cudaResViewFormatSignedInt4 = ( cyruntime.cudaResourceViewFormat.cudaResViewFormatSignedInt4, '4 channel signed 32-bit integers\n' - ){{endif}} - {{if 'cudaResViewFormatHalf1' in found_values}} + ) + cudaResViewFormatHalf1 = ( cyruntime.cudaResourceViewFormat.cudaResViewFormatHalf1, '1 channel 16-bit floating point\n' - ){{endif}} - {{if 'cudaResViewFormatHalf2' in found_values}} + ) + cudaResViewFormatHalf2 = ( cyruntime.cudaResourceViewFormat.cudaResViewFormatHalf2, '2 channel 16-bit floating point\n' - ){{endif}} - {{if 'cudaResViewFormatHalf4' in found_values}} + ) + cudaResViewFormatHalf4 = ( cyruntime.cudaResourceViewFormat.cudaResViewFormatHalf4, '4 channel 16-bit floating point\n' - ){{endif}} - {{if 'cudaResViewFormatFloat1' in found_values}} + ) + cudaResViewFormatFloat1 = ( cyruntime.cudaResourceViewFormat.cudaResViewFormatFloat1, '1 channel 32-bit floating point\n' - ){{endif}} - {{if 'cudaResViewFormatFloat2' in found_values}} + ) + cudaResViewFormatFloat2 = ( cyruntime.cudaResourceViewFormat.cudaResViewFormatFloat2, '2 channel 32-bit floating point\n' - ){{endif}} - {{if 'cudaResViewFormatFloat4' in found_values}} + ) + cudaResViewFormatFloat4 = ( cyruntime.cudaResourceViewFormat.cudaResViewFormatFloat4, '4 channel 32-bit floating point\n' - ){{endif}} - {{if 'cudaResViewFormatUnsignedBlockCompressed1' in found_values}} + ) + cudaResViewFormatUnsignedBlockCompressed1 = ( cyruntime.cudaResourceViewFormat.cudaResViewFormatUnsignedBlockCompressed1, 'Block compressed 1\n' - ){{endif}} - {{if 'cudaResViewFormatUnsignedBlockCompressed2' in found_values}} + ) + cudaResViewFormatUnsignedBlockCompressed2 = ( cyruntime.cudaResourceViewFormat.cudaResViewFormatUnsignedBlockCompressed2, 'Block compressed 2\n' - ){{endif}} - {{if 'cudaResViewFormatUnsignedBlockCompressed3' in found_values}} + ) + cudaResViewFormatUnsignedBlockCompressed3 = ( cyruntime.cudaResourceViewFormat.cudaResViewFormatUnsignedBlockCompressed3, 'Block compressed 3\n' - ){{endif}} - {{if 'cudaResViewFormatUnsignedBlockCompressed4' in found_values}} + ) + cudaResViewFormatUnsignedBlockCompressed4 = ( cyruntime.cudaResourceViewFormat.cudaResViewFormatUnsignedBlockCompressed4, 'Block compressed 4 unsigned\n' - ){{endif}} - {{if 'cudaResViewFormatSignedBlockCompressed4' in found_values}} + ) + cudaResViewFormatSignedBlockCompressed4 = ( cyruntime.cudaResourceViewFormat.cudaResViewFormatSignedBlockCompressed4, 'Block compressed 4 signed\n' - ){{endif}} - {{if 'cudaResViewFormatUnsignedBlockCompressed5' in found_values}} + ) + cudaResViewFormatUnsignedBlockCompressed5 = ( cyruntime.cudaResourceViewFormat.cudaResViewFormatUnsignedBlockCompressed5, 'Block compressed 5 unsigned\n' - ){{endif}} - {{if 'cudaResViewFormatSignedBlockCompressed5' in found_values}} + ) + cudaResViewFormatSignedBlockCompressed5 = ( cyruntime.cudaResourceViewFormat.cudaResViewFormatSignedBlockCompressed5, 'Block compressed 5 signed\n' - ){{endif}} - {{if 'cudaResViewFormatUnsignedBlockCompressed6H' in found_values}} + ) + cudaResViewFormatUnsignedBlockCompressed6H = ( cyruntime.cudaResourceViewFormat.cudaResViewFormatUnsignedBlockCompressed6H, 'Block compressed 6 unsigned half-float\n' - ){{endif}} - {{if 'cudaResViewFormatSignedBlockCompressed6H' in found_values}} + ) + cudaResViewFormatSignedBlockCompressed6H = ( cyruntime.cudaResourceViewFormat.cudaResViewFormatSignedBlockCompressed6H, 'Block compressed 6 signed half-float\n' - ){{endif}} - {{if 'cudaResViewFormatUnsignedBlockCompressed7' in found_values}} + ) + cudaResViewFormatUnsignedBlockCompressed7 = ( cyruntime.cudaResourceViewFormat.cudaResViewFormatUnsignedBlockCompressed7, 'Block compressed 7\n' - ){{endif}} - -{{endif}} -{{if 'cudaFuncAttribute' in found_types}} + ) class cudaFuncAttribute(_FastEnum): """ CUDA function attributes that can be set using :py:obj:`~.cudaFuncSetAttribute` """ - {{if 'cudaFuncAttributeMaxDynamicSharedMemorySize' in found_values}} + cudaFuncAttributeMaxDynamicSharedMemorySize = ( cyruntime.cudaFuncAttribute.cudaFuncAttributeMaxDynamicSharedMemorySize, 'Maximum dynamic shared memory size\n' - ){{endif}} - {{if 'cudaFuncAttributePreferredSharedMemoryCarveout' in found_values}} + ) + cudaFuncAttributePreferredSharedMemoryCarveout = ( cyruntime.cudaFuncAttribute.cudaFuncAttributePreferredSharedMemoryCarveout, 'Preferred shared memory-L1 cache split\n' - ){{endif}} - {{if 'cudaFuncAttributeClusterDimMustBeSet' in found_values}} + ) + cudaFuncAttributeClusterDimMustBeSet = ( cyruntime.cudaFuncAttribute.cudaFuncAttributeClusterDimMustBeSet, 'Indicator to enforce valid cluster dimension specification on kernel launch\n' - ){{endif}} - {{if 'cudaFuncAttributeRequiredClusterWidth' in found_values}} + ) + cudaFuncAttributeRequiredClusterWidth = ( cyruntime.cudaFuncAttribute.cudaFuncAttributeRequiredClusterWidth, 'Required cluster width\n' - ){{endif}} - {{if 'cudaFuncAttributeRequiredClusterHeight' in found_values}} + ) + cudaFuncAttributeRequiredClusterHeight = ( cyruntime.cudaFuncAttribute.cudaFuncAttributeRequiredClusterHeight, 'Required cluster height\n' - ){{endif}} - {{if 'cudaFuncAttributeRequiredClusterDepth' in found_values}} + ) + cudaFuncAttributeRequiredClusterDepth = ( cyruntime.cudaFuncAttribute.cudaFuncAttributeRequiredClusterDepth, 'Required cluster depth\n' - ){{endif}} - {{if 'cudaFuncAttributeNonPortableClusterSizeAllowed' in found_values}} + ) + cudaFuncAttributeNonPortableClusterSizeAllowed = ( cyruntime.cudaFuncAttribute.cudaFuncAttributeNonPortableClusterSizeAllowed, 'Whether non-portable cluster scheduling policy is supported\n' - ){{endif}} - {{if 'cudaFuncAttributeClusterSchedulingPolicyPreference' in found_values}} + ) + cudaFuncAttributeClusterSchedulingPolicyPreference = ( cyruntime.cudaFuncAttribute.cudaFuncAttributeClusterSchedulingPolicyPreference, 'Required cluster scheduling policy preference\n' - ){{endif}} - {{if 'cudaFuncAttributeMax' in found_values}} - cudaFuncAttributeMax = cyruntime.cudaFuncAttribute.cudaFuncAttributeMax{{endif}} + ) -{{endif}} -{{if 'cudaFuncCache' in found_types}} + cudaFuncAttributeMax = cyruntime.cudaFuncAttribute.cudaFuncAttributeMax class cudaFuncCache(_FastEnum): """ CUDA function cache configurations """ - {{if 'cudaFuncCachePreferNone' in found_values}} + cudaFuncCachePreferNone = ( cyruntime.cudaFuncCache.cudaFuncCachePreferNone, 'Default function cache configuration, no preference\n' - ){{endif}} - {{if 'cudaFuncCachePreferShared' in found_values}} + ) + cudaFuncCachePreferShared = ( cyruntime.cudaFuncCache.cudaFuncCachePreferShared, 'Prefer larger shared memory and smaller L1 cache\n' - ){{endif}} - {{if 'cudaFuncCachePreferL1' in found_values}} + ) + cudaFuncCachePreferL1 = ( cyruntime.cudaFuncCache.cudaFuncCachePreferL1, 'Prefer larger L1 cache and smaller shared memory\n' - ){{endif}} - {{if 'cudaFuncCachePreferEqual' in found_values}} + ) + cudaFuncCachePreferEqual = ( cyruntime.cudaFuncCache.cudaFuncCachePreferEqual, 'Prefer equal size L1 cache and shared memory\n' - ){{endif}} - -{{endif}} -{{if 'cudaSharedMemConfig' in found_types}} + ) class cudaSharedMemConfig(_FastEnum): """ CUDA shared memory configuration [Deprecated] """ - {{if 'cudaSharedMemBankSizeDefault' in found_values}} - cudaSharedMemBankSizeDefault = cyruntime.cudaSharedMemConfig.cudaSharedMemBankSizeDefault{{endif}} - {{if 'cudaSharedMemBankSizeFourByte' in found_values}} - cudaSharedMemBankSizeFourByte = cyruntime.cudaSharedMemConfig.cudaSharedMemBankSizeFourByte{{endif}} - {{if 'cudaSharedMemBankSizeEightByte' in found_values}} - cudaSharedMemBankSizeEightByte = cyruntime.cudaSharedMemConfig.cudaSharedMemBankSizeEightByte{{endif}} -{{endif}} -{{if 'cudaSharedCarveout' in found_types}} + cudaSharedMemBankSizeDefault = cyruntime.cudaSharedMemConfig.cudaSharedMemBankSizeDefault + + cudaSharedMemBankSizeFourByte = cyruntime.cudaSharedMemConfig.cudaSharedMemBankSizeFourByte + + cudaSharedMemBankSizeEightByte = cyruntime.cudaSharedMemConfig.cudaSharedMemBankSizeEightByte class cudaSharedCarveout(_FastEnum): """ Shared memory carveout configurations. These may be passed to cudaFuncSetAttribute """ - {{if 'cudaSharedmemCarveoutDefault' in found_values}} + cudaSharedmemCarveoutDefault = ( cyruntime.cudaSharedCarveout.cudaSharedmemCarveoutDefault, 'No preference for shared memory or L1 (default)\n' - ){{endif}} - {{if 'cudaSharedmemCarveoutMaxL1' in found_values}} + ) + cudaSharedmemCarveoutMaxL1 = ( cyruntime.cudaSharedCarveout.cudaSharedmemCarveoutMaxL1, 'Prefer maximum available L1 cache, minimum shared memory\n' - ){{endif}} - {{if 'cudaSharedmemCarveoutMaxShared' in found_values}} + ) + cudaSharedmemCarveoutMaxShared = ( cyruntime.cudaSharedCarveout.cudaSharedmemCarveoutMaxShared, 'Prefer maximum available shared memory, minimum L1 cache\n' - ){{endif}} - -{{endif}} -{{if 'cudaComputeMode' in found_types}} + ) class cudaComputeMode(_FastEnum): """ CUDA device compute modes """ - {{if 'cudaComputeModeDefault' in found_values}} + cudaComputeModeDefault = ( cyruntime.cudaComputeMode.cudaComputeModeDefault, 'Default compute mode (Multiple threads can use :py:obj:`~.cudaSetDevice()`\n' 'with this device)\n' - ){{endif}} - {{if 'cudaComputeModeExclusive' in found_values}} + ) + cudaComputeModeExclusive = ( cyruntime.cudaComputeMode.cudaComputeModeExclusive, 'Compute-exclusive-thread mode (Only one thread in one process will be able\n' 'to use :py:obj:`~.cudaSetDevice()` with this device)\n' - ){{endif}} - {{if 'cudaComputeModeProhibited' in found_values}} + ) + cudaComputeModeProhibited = ( cyruntime.cudaComputeMode.cudaComputeModeProhibited, 'Compute-prohibited mode (No threads can use :py:obj:`~.cudaSetDevice()`\n' 'with this device)\n' - ){{endif}} - {{if 'cudaComputeModeExclusiveProcess' in found_values}} + ) + cudaComputeModeExclusiveProcess = ( cyruntime.cudaComputeMode.cudaComputeModeExclusiveProcess, 'Compute-exclusive-process mode (Many threads in one process will be able to\n' 'use :py:obj:`~.cudaSetDevice()` with this device)\n' - ){{endif}} - -{{endif}} -{{if 'cudaLimit' in found_types}} + ) class cudaLimit(_FastEnum): """ CUDA Limits """ - {{if 'cudaLimitStackSize' in found_values}} + cudaLimitStackSize = ( cyruntime.cudaLimit.cudaLimitStackSize, 'GPU thread stack size\n' - ){{endif}} - {{if 'cudaLimitPrintfFifoSize' in found_values}} + ) + cudaLimitPrintfFifoSize = ( cyruntime.cudaLimit.cudaLimitPrintfFifoSize, 'GPU printf FIFO size\n' - ){{endif}} - {{if 'cudaLimitMallocHeapSize' in found_values}} + ) + cudaLimitMallocHeapSize = ( cyruntime.cudaLimit.cudaLimitMallocHeapSize, 'GPU malloc heap size\n' - ){{endif}} - {{if 'cudaLimitDevRuntimeSyncDepth' in found_values}} + ) + cudaLimitDevRuntimeSyncDepth = ( cyruntime.cudaLimit.cudaLimitDevRuntimeSyncDepth, 'GPU device runtime synchronize depth\n' - ){{endif}} - {{if 'cudaLimitDevRuntimePendingLaunchCount' in found_values}} + ) + cudaLimitDevRuntimePendingLaunchCount = ( cyruntime.cudaLimit.cudaLimitDevRuntimePendingLaunchCount, 'GPU device runtime pending launch count\n' - ){{endif}} - {{if 'cudaLimitMaxL2FetchGranularity' in found_values}} + ) + cudaLimitMaxL2FetchGranularity = ( cyruntime.cudaLimit.cudaLimitMaxL2FetchGranularity, 'A value between 0 and 128 that indicates the maximum fetch granularity of\n' 'L2 (in Bytes). This is a hint\n' - ){{endif}} - {{if 'cudaLimitPersistingL2CacheSize' in found_values}} + ) + cudaLimitPersistingL2CacheSize = ( cyruntime.cudaLimit.cudaLimitPersistingL2CacheSize, 'A size in bytes for L2 persisting lines cache size\n' - ){{endif}} - -{{endif}} -{{if 'cudaMemoryAdvise' in found_types}} + ) class cudaMemoryAdvise(_FastEnum): """ CUDA Memory Advise values """ - {{if 'cudaMemAdviseSetReadMostly' in found_values}} + cudaMemAdviseSetReadMostly = ( cyruntime.cudaMemoryAdvise.cudaMemAdviseSetReadMostly, 'Data will mostly be read and only occassionally be written to\n' - ){{endif}} - {{if 'cudaMemAdviseUnsetReadMostly' in found_values}} + ) + cudaMemAdviseUnsetReadMostly = ( cyruntime.cudaMemoryAdvise.cudaMemAdviseUnsetReadMostly, 'Undo the effect of :py:obj:`~.cudaMemAdviseSetReadMostly`\n' - ){{endif}} - {{if 'cudaMemAdviseSetPreferredLocation' in found_values}} + ) + cudaMemAdviseSetPreferredLocation = ( cyruntime.cudaMemoryAdvise.cudaMemAdviseSetPreferredLocation, 'Set the preferred location for the data as the specified device\n' - ){{endif}} - {{if 'cudaMemAdviseUnsetPreferredLocation' in found_values}} + ) + cudaMemAdviseUnsetPreferredLocation = ( cyruntime.cudaMemoryAdvise.cudaMemAdviseUnsetPreferredLocation, 'Clear the preferred location for the data\n' - ){{endif}} - {{if 'cudaMemAdviseSetAccessedBy' in found_values}} + ) + cudaMemAdviseSetAccessedBy = ( cyruntime.cudaMemoryAdvise.cudaMemAdviseSetAccessedBy, 'Data will be accessed by the specified device, so prevent page faults as\n' 'much as possible\n' - ){{endif}} - {{if 'cudaMemAdviseUnsetAccessedBy' in found_values}} + ) + cudaMemAdviseUnsetAccessedBy = ( cyruntime.cudaMemoryAdvise.cudaMemAdviseUnsetAccessedBy, 'Let the Unified Memory subsystem decide on the page faulting policy for the\n' 'specified device\n' - ){{endif}} - -{{endif}} -{{if 'cudaMemRangeAttribute' in found_types}} + ) class cudaMemRangeAttribute(_FastEnum): """ CUDA range attributes """ - {{if 'cudaMemRangeAttributeReadMostly' in found_values}} + cudaMemRangeAttributeReadMostly = ( cyruntime.cudaMemRangeAttribute.cudaMemRangeAttributeReadMostly, 'Whether the range will mostly be read and only occassionally be written to\n' - ){{endif}} - {{if 'cudaMemRangeAttributePreferredLocation' in found_values}} + ) + cudaMemRangeAttributePreferredLocation = ( cyruntime.cudaMemRangeAttribute.cudaMemRangeAttributePreferredLocation, 'The preferred location of the range\n' - ){{endif}} - {{if 'cudaMemRangeAttributeAccessedBy' in found_values}} + ) + cudaMemRangeAttributeAccessedBy = ( cyruntime.cudaMemRangeAttribute.cudaMemRangeAttributeAccessedBy, 'Memory range has :py:obj:`~.cudaMemAdviseSetAccessedBy` set for specified\n' 'device\n' - ){{endif}} - {{if 'cudaMemRangeAttributeLastPrefetchLocation' in found_values}} + ) + cudaMemRangeAttributeLastPrefetchLocation = ( cyruntime.cudaMemRangeAttribute.cudaMemRangeAttributeLastPrefetchLocation, 'The last location to which the range was prefetched\n' - ){{endif}} - {{if 'cudaMemRangeAttributePreferredLocationType' in found_values}} + ) + cudaMemRangeAttributePreferredLocationType = ( cyruntime.cudaMemRangeAttribute.cudaMemRangeAttributePreferredLocationType, 'The preferred location type of the range\n' - ){{endif}} - {{if 'cudaMemRangeAttributePreferredLocationId' in found_values}} + ) + cudaMemRangeAttributePreferredLocationId = ( cyruntime.cudaMemRangeAttribute.cudaMemRangeAttributePreferredLocationId, 'The preferred location id of the range\n' - ){{endif}} - {{if 'cudaMemRangeAttributeLastPrefetchLocationType' in found_values}} + ) + cudaMemRangeAttributeLastPrefetchLocationType = ( cyruntime.cudaMemRangeAttribute.cudaMemRangeAttributeLastPrefetchLocationType, 'The last location type to which the range was prefetched\n' - ){{endif}} - {{if 'cudaMemRangeAttributeLastPrefetchLocationId' in found_values}} + ) + cudaMemRangeAttributeLastPrefetchLocationId = ( cyruntime.cudaMemRangeAttribute.cudaMemRangeAttributeLastPrefetchLocationId, 'The last location id to which the range was prefetched\n' - ){{endif}} - -{{endif}} -{{if 'cudaFlushGPUDirectRDMAWritesOptions' in found_types}} + ) class cudaFlushGPUDirectRDMAWritesOptions(_FastEnum): """ CUDA GPUDirect RDMA flush writes APIs supported on the device """ - {{if 'cudaFlushGPUDirectRDMAWritesOptionHost' in found_values}} + cudaFlushGPUDirectRDMAWritesOptionHost = ( cyruntime.cudaFlushGPUDirectRDMAWritesOptions.cudaFlushGPUDirectRDMAWritesOptionHost, ':py:obj:`~.cudaDeviceFlushGPUDirectRDMAWrites()` and its CUDA Driver API\n' 'counterpart are supported on the device.\n' - ){{endif}} - {{if 'cudaFlushGPUDirectRDMAWritesOptionMemOps' in found_values}} + ) + cudaFlushGPUDirectRDMAWritesOptionMemOps = ( cyruntime.cudaFlushGPUDirectRDMAWritesOptions.cudaFlushGPUDirectRDMAWritesOptionMemOps, 'The :py:obj:`~.CU_STREAM_WAIT_VALUE_FLUSH` flag and the\n' ':py:obj:`~.CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES` MemOp are supported on the\n' 'CUDA device.\n' - ){{endif}} - -{{endif}} -{{if 'cudaGPUDirectRDMAWritesOrdering' in found_types}} + ) class cudaGPUDirectRDMAWritesOrdering(_FastEnum): """ CUDA GPUDirect RDMA flush writes ordering features of the device """ - {{if 'cudaGPUDirectRDMAWritesOrderingNone' in found_values}} + cudaGPUDirectRDMAWritesOrderingNone = ( cyruntime.cudaGPUDirectRDMAWritesOrdering.cudaGPUDirectRDMAWritesOrderingNone, 'The device does not natively support ordering of GPUDirect RDMA writes.\n' ':py:obj:`~.cudaFlushGPUDirectRDMAWrites()` can be leveraged if supported.\n' - ){{endif}} - {{if 'cudaGPUDirectRDMAWritesOrderingOwner' in found_values}} + ) + cudaGPUDirectRDMAWritesOrderingOwner = ( cyruntime.cudaGPUDirectRDMAWritesOrdering.cudaGPUDirectRDMAWritesOrderingOwner, 'Natively, the device can consistently consume GPUDirect RDMA writes,\n' 'although other CUDA devices may not.\n' - ){{endif}} - {{if 'cudaGPUDirectRDMAWritesOrderingAllDevices' in found_values}} + ) + cudaGPUDirectRDMAWritesOrderingAllDevices = ( cyruntime.cudaGPUDirectRDMAWritesOrdering.cudaGPUDirectRDMAWritesOrderingAllDevices, 'Any CUDA device in the system can consistently consume GPUDirect RDMA\n' 'writes to this device.\n' - ){{endif}} - -{{endif}} -{{if 'cudaFlushGPUDirectRDMAWritesScope' in found_types}} + ) class cudaFlushGPUDirectRDMAWritesScope(_FastEnum): """ CUDA GPUDirect RDMA flush writes scopes """ - {{if 'cudaFlushGPUDirectRDMAWritesToOwner' in found_values}} + cudaFlushGPUDirectRDMAWritesToOwner = ( cyruntime.cudaFlushGPUDirectRDMAWritesScope.cudaFlushGPUDirectRDMAWritesToOwner, 'Blocks until remote writes are visible to the CUDA device context owning\n' 'the data.\n' - ){{endif}} - {{if 'cudaFlushGPUDirectRDMAWritesToAllDevices' in found_values}} + ) + cudaFlushGPUDirectRDMAWritesToAllDevices = ( cyruntime.cudaFlushGPUDirectRDMAWritesScope.cudaFlushGPUDirectRDMAWritesToAllDevices, 'Blocks until remote writes are visible to all CUDA device contexts.\n' - ){{endif}} - -{{endif}} -{{if 'cudaFlushGPUDirectRDMAWritesTarget' in found_types}} + ) class cudaFlushGPUDirectRDMAWritesTarget(_FastEnum): """ CUDA GPUDirect RDMA flush writes targets """ - {{if 'cudaFlushGPUDirectRDMAWritesTargetCurrentDevice' in found_values}} + cudaFlushGPUDirectRDMAWritesTargetCurrentDevice = ( cyruntime.cudaFlushGPUDirectRDMAWritesTarget.cudaFlushGPUDirectRDMAWritesTargetCurrentDevice, 'Sets the target for :py:obj:`~.cudaDeviceFlushGPUDirectRDMAWrites()` to the\n' 'currently active CUDA device context.\n' - ){{endif}} - -{{endif}} -{{if 'cudaDeviceAttr' in found_types}} + ) class cudaDeviceAttr(_FastEnum): """ CUDA device attributes """ - {{if 'cudaDevAttrMaxThreadsPerBlock' in found_values}} + cudaDevAttrMaxThreadsPerBlock = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxThreadsPerBlock, 'Maximum number of threads per block\n' - ){{endif}} - {{if 'cudaDevAttrMaxBlockDimX' in found_values}} + ) + cudaDevAttrMaxBlockDimX = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxBlockDimX, 'Maximum block dimension X\n' - ){{endif}} - {{if 'cudaDevAttrMaxBlockDimY' in found_values}} + ) + cudaDevAttrMaxBlockDimY = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxBlockDimY, 'Maximum block dimension Y\n' - ){{endif}} - {{if 'cudaDevAttrMaxBlockDimZ' in found_values}} + ) + cudaDevAttrMaxBlockDimZ = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxBlockDimZ, 'Maximum block dimension Z\n' - ){{endif}} - {{if 'cudaDevAttrMaxGridDimX' in found_values}} + ) + cudaDevAttrMaxGridDimX = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxGridDimX, 'Maximum grid dimension X\n' - ){{endif}} - {{if 'cudaDevAttrMaxGridDimY' in found_values}} + ) + cudaDevAttrMaxGridDimY = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxGridDimY, 'Maximum grid dimension Y\n' - ){{endif}} - {{if 'cudaDevAttrMaxGridDimZ' in found_values}} + ) + cudaDevAttrMaxGridDimZ = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxGridDimZ, 'Maximum grid dimension Z\n' - ){{endif}} - {{if 'cudaDevAttrMaxSharedMemoryPerBlock' in found_values}} + ) + cudaDevAttrMaxSharedMemoryPerBlock = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxSharedMemoryPerBlock, 'Maximum shared memory available per block in bytes\n' - ){{endif}} - {{if 'cudaDevAttrTotalConstantMemory' in found_values}} + ) + cudaDevAttrTotalConstantMemory = ( cyruntime.cudaDeviceAttr.cudaDevAttrTotalConstantMemory, 'Memory available on device for constant variables in a CUDA C kernel in\n' 'bytes\n' - ){{endif}} - {{if 'cudaDevAttrWarpSize' in found_values}} + ) + cudaDevAttrWarpSize = ( cyruntime.cudaDeviceAttr.cudaDevAttrWarpSize, 'Warp size in threads\n' - ){{endif}} - {{if 'cudaDevAttrMaxPitch' in found_values}} + ) + cudaDevAttrMaxPitch = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxPitch, 'Maximum pitch in bytes allowed by memory copies\n' - ){{endif}} - {{if 'cudaDevAttrMaxRegistersPerBlock' in found_values}} + ) + cudaDevAttrMaxRegistersPerBlock = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxRegistersPerBlock, 'Maximum number of 32-bit registers available per block\n' - ){{endif}} - {{if 'cudaDevAttrClockRate' in found_values}} + ) + cudaDevAttrClockRate = ( cyruntime.cudaDeviceAttr.cudaDevAttrClockRate, 'Peak clock frequency in kilohertz\n' - ){{endif}} - {{if 'cudaDevAttrTextureAlignment' in found_values}} + ) + cudaDevAttrTextureAlignment = ( cyruntime.cudaDeviceAttr.cudaDevAttrTextureAlignment, 'Alignment requirement for textures\n' - ){{endif}} - {{if 'cudaDevAttrGpuOverlap' in found_values}} + ) + cudaDevAttrGpuOverlap = ( cyruntime.cudaDeviceAttr.cudaDevAttrGpuOverlap, 'Device can possibly copy memory and execute a kernel concurrently\n' - ){{endif}} - {{if 'cudaDevAttrMultiProcessorCount' in found_values}} + ) + cudaDevAttrMultiProcessorCount = ( cyruntime.cudaDeviceAttr.cudaDevAttrMultiProcessorCount, 'Number of multiprocessors on device\n' - ){{endif}} - {{if 'cudaDevAttrKernelExecTimeout' in found_values}} + ) + cudaDevAttrKernelExecTimeout = ( cyruntime.cudaDeviceAttr.cudaDevAttrKernelExecTimeout, 'Specifies whether there is a run time limit on kernels\n' - ){{endif}} - {{if 'cudaDevAttrIntegrated' in found_values}} + ) + cudaDevAttrIntegrated = ( cyruntime.cudaDeviceAttr.cudaDevAttrIntegrated, 'Device is integrated with host memory\n' - ){{endif}} - {{if 'cudaDevAttrCanMapHostMemory' in found_values}} + ) + cudaDevAttrCanMapHostMemory = ( cyruntime.cudaDeviceAttr.cudaDevAttrCanMapHostMemory, 'Device can map host memory into CUDA address space\n' - ){{endif}} - {{if 'cudaDevAttrComputeMode' in found_values}} + ) + cudaDevAttrComputeMode = ( cyruntime.cudaDeviceAttr.cudaDevAttrComputeMode, 'Compute mode (See :py:obj:`~.cudaComputeMode` for details)\n' - ){{endif}} - {{if 'cudaDevAttrMaxTexture1DWidth' in found_values}} + ) + cudaDevAttrMaxTexture1DWidth = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxTexture1DWidth, 'Maximum 1D texture width\n' - ){{endif}} - {{if 'cudaDevAttrMaxTexture2DWidth' in found_values}} + ) + cudaDevAttrMaxTexture2DWidth = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxTexture2DWidth, 'Maximum 2D texture width\n' - ){{endif}} - {{if 'cudaDevAttrMaxTexture2DHeight' in found_values}} + ) + cudaDevAttrMaxTexture2DHeight = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxTexture2DHeight, 'Maximum 2D texture height\n' - ){{endif}} - {{if 'cudaDevAttrMaxTexture3DWidth' in found_values}} + ) + cudaDevAttrMaxTexture3DWidth = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxTexture3DWidth, 'Maximum 3D texture width\n' - ){{endif}} - {{if 'cudaDevAttrMaxTexture3DHeight' in found_values}} + ) + cudaDevAttrMaxTexture3DHeight = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxTexture3DHeight, 'Maximum 3D texture height\n' - ){{endif}} - {{if 'cudaDevAttrMaxTexture3DDepth' in found_values}} + ) + cudaDevAttrMaxTexture3DDepth = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxTexture3DDepth, 'Maximum 3D texture depth\n' - ){{endif}} - {{if 'cudaDevAttrMaxTexture2DLayeredWidth' in found_values}} + ) + cudaDevAttrMaxTexture2DLayeredWidth = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxTexture2DLayeredWidth, 'Maximum 2D layered texture width\n' - ){{endif}} - {{if 'cudaDevAttrMaxTexture2DLayeredHeight' in found_values}} + ) + cudaDevAttrMaxTexture2DLayeredHeight = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxTexture2DLayeredHeight, 'Maximum 2D layered texture height\n' - ){{endif}} - {{if 'cudaDevAttrMaxTexture2DLayeredLayers' in found_values}} + ) + cudaDevAttrMaxTexture2DLayeredLayers = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxTexture2DLayeredLayers, 'Maximum layers in a 2D layered texture\n' - ){{endif}} - {{if 'cudaDevAttrSurfaceAlignment' in found_values}} + ) + cudaDevAttrSurfaceAlignment = ( cyruntime.cudaDeviceAttr.cudaDevAttrSurfaceAlignment, 'Alignment requirement for surfaces\n' - ){{endif}} - {{if 'cudaDevAttrConcurrentKernels' in found_values}} + ) + cudaDevAttrConcurrentKernels = ( cyruntime.cudaDeviceAttr.cudaDevAttrConcurrentKernels, 'Device can possibly execute multiple kernels concurrently\n' - ){{endif}} - {{if 'cudaDevAttrEccEnabled' in found_values}} + ) + cudaDevAttrEccEnabled = ( cyruntime.cudaDeviceAttr.cudaDevAttrEccEnabled, 'Device has ECC support enabled\n' - ){{endif}} - {{if 'cudaDevAttrPciBusId' in found_values}} + ) + cudaDevAttrPciBusId = ( cyruntime.cudaDeviceAttr.cudaDevAttrPciBusId, 'PCI bus ID of the device\n' - ){{endif}} - {{if 'cudaDevAttrPciDeviceId' in found_values}} + ) + cudaDevAttrPciDeviceId = ( cyruntime.cudaDeviceAttr.cudaDevAttrPciDeviceId, 'PCI device ID of the device\n' - ){{endif}} - {{if 'cudaDevAttrTccDriver' in found_values}} + ) + cudaDevAttrTccDriver = ( cyruntime.cudaDeviceAttr.cudaDevAttrTccDriver, 'Device is using TCC driver model\n' - ){{endif}} - {{if 'cudaDevAttrMemoryClockRate' in found_values}} + ) + cudaDevAttrMemoryClockRate = ( cyruntime.cudaDeviceAttr.cudaDevAttrMemoryClockRate, 'Peak memory clock frequency in kilohertz\n' - ){{endif}} - {{if 'cudaDevAttrGlobalMemoryBusWidth' in found_values}} + ) + cudaDevAttrGlobalMemoryBusWidth = ( cyruntime.cudaDeviceAttr.cudaDevAttrGlobalMemoryBusWidth, 'Global memory bus width in bits\n' - ){{endif}} - {{if 'cudaDevAttrL2CacheSize' in found_values}} + ) + cudaDevAttrL2CacheSize = ( cyruntime.cudaDeviceAttr.cudaDevAttrL2CacheSize, 'Size of L2 cache in bytes\n' - ){{endif}} - {{if 'cudaDevAttrMaxThreadsPerMultiProcessor' in found_values}} + ) + cudaDevAttrMaxThreadsPerMultiProcessor = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxThreadsPerMultiProcessor, 'Maximum resident threads per multiprocessor\n' - ){{endif}} - {{if 'cudaDevAttrAsyncEngineCount' in found_values}} + ) + cudaDevAttrAsyncEngineCount = ( cyruntime.cudaDeviceAttr.cudaDevAttrAsyncEngineCount, 'Number of asynchronous engines\n' - ){{endif}} - {{if 'cudaDevAttrUnifiedAddressing' in found_values}} + ) + cudaDevAttrUnifiedAddressing = ( cyruntime.cudaDeviceAttr.cudaDevAttrUnifiedAddressing, 'Device shares a unified address space with the host\n' - ){{endif}} - {{if 'cudaDevAttrMaxTexture1DLayeredWidth' in found_values}} + ) + cudaDevAttrMaxTexture1DLayeredWidth = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxTexture1DLayeredWidth, 'Maximum 1D layered texture width\n' - ){{endif}} - {{if 'cudaDevAttrMaxTexture1DLayeredLayers' in found_values}} + ) + cudaDevAttrMaxTexture1DLayeredLayers = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxTexture1DLayeredLayers, 'Maximum layers in a 1D layered texture\n' - ){{endif}} - {{if 'cudaDevAttrMaxTexture2DGatherWidth' in found_values}} + ) + cudaDevAttrMaxTexture2DGatherWidth = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxTexture2DGatherWidth, 'Maximum 2D texture width if cudaArrayTextureGather is set\n' - ){{endif}} - {{if 'cudaDevAttrMaxTexture2DGatherHeight' in found_values}} + ) + cudaDevAttrMaxTexture2DGatherHeight = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxTexture2DGatherHeight, 'Maximum 2D texture height if cudaArrayTextureGather is set\n' - ){{endif}} - {{if 'cudaDevAttrMaxTexture3DWidthAlt' in found_values}} + ) + cudaDevAttrMaxTexture3DWidthAlt = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxTexture3DWidthAlt, 'Alternate maximum 3D texture width\n' - ){{endif}} - {{if 'cudaDevAttrMaxTexture3DHeightAlt' in found_values}} + ) + cudaDevAttrMaxTexture3DHeightAlt = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxTexture3DHeightAlt, 'Alternate maximum 3D texture height\n' - ){{endif}} - {{if 'cudaDevAttrMaxTexture3DDepthAlt' in found_values}} + ) + cudaDevAttrMaxTexture3DDepthAlt = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxTexture3DDepthAlt, 'Alternate maximum 3D texture depth\n' - ){{endif}} - {{if 'cudaDevAttrPciDomainId' in found_values}} + ) + cudaDevAttrPciDomainId = ( cyruntime.cudaDeviceAttr.cudaDevAttrPciDomainId, 'PCI domain ID of the device\n' - ){{endif}} - {{if 'cudaDevAttrTexturePitchAlignment' in found_values}} + ) + cudaDevAttrTexturePitchAlignment = ( cyruntime.cudaDeviceAttr.cudaDevAttrTexturePitchAlignment, 'Pitch alignment requirement for textures\n' - ){{endif}} - {{if 'cudaDevAttrMaxTextureCubemapWidth' in found_values}} + ) + cudaDevAttrMaxTextureCubemapWidth = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxTextureCubemapWidth, 'Maximum cubemap texture width/height\n' - ){{endif}} - {{if 'cudaDevAttrMaxTextureCubemapLayeredWidth' in found_values}} + ) + cudaDevAttrMaxTextureCubemapLayeredWidth = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxTextureCubemapLayeredWidth, 'Maximum cubemap layered texture width/height\n' - ){{endif}} - {{if 'cudaDevAttrMaxTextureCubemapLayeredLayers' in found_values}} + ) + cudaDevAttrMaxTextureCubemapLayeredLayers = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxTextureCubemapLayeredLayers, 'Maximum layers in a cubemap layered texture\n' - ){{endif}} - {{if 'cudaDevAttrMaxSurface1DWidth' in found_values}} + ) + cudaDevAttrMaxSurface1DWidth = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxSurface1DWidth, 'Maximum 1D surface width\n' - ){{endif}} - {{if 'cudaDevAttrMaxSurface2DWidth' in found_values}} + ) + cudaDevAttrMaxSurface2DWidth = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxSurface2DWidth, 'Maximum 2D surface width\n' - ){{endif}} - {{if 'cudaDevAttrMaxSurface2DHeight' in found_values}} + ) + cudaDevAttrMaxSurface2DHeight = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxSurface2DHeight, 'Maximum 2D surface height\n' - ){{endif}} - {{if 'cudaDevAttrMaxSurface3DWidth' in found_values}} + ) + cudaDevAttrMaxSurface3DWidth = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxSurface3DWidth, 'Maximum 3D surface width\n' - ){{endif}} - {{if 'cudaDevAttrMaxSurface3DHeight' in found_values}} + ) + cudaDevAttrMaxSurface3DHeight = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxSurface3DHeight, 'Maximum 3D surface height\n' - ){{endif}} - {{if 'cudaDevAttrMaxSurface3DDepth' in found_values}} + ) + cudaDevAttrMaxSurface3DDepth = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxSurface3DDepth, 'Maximum 3D surface depth\n' - ){{endif}} - {{if 'cudaDevAttrMaxSurface1DLayeredWidth' in found_values}} + ) + cudaDevAttrMaxSurface1DLayeredWidth = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxSurface1DLayeredWidth, 'Maximum 1D layered surface width\n' - ){{endif}} - {{if 'cudaDevAttrMaxSurface1DLayeredLayers' in found_values}} + ) + cudaDevAttrMaxSurface1DLayeredLayers = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxSurface1DLayeredLayers, 'Maximum layers in a 1D layered surface\n' - ){{endif}} - {{if 'cudaDevAttrMaxSurface2DLayeredWidth' in found_values}} + ) + cudaDevAttrMaxSurface2DLayeredWidth = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxSurface2DLayeredWidth, 'Maximum 2D layered surface width\n' - ){{endif}} - {{if 'cudaDevAttrMaxSurface2DLayeredHeight' in found_values}} + ) + cudaDevAttrMaxSurface2DLayeredHeight = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxSurface2DLayeredHeight, 'Maximum 2D layered surface height\n' - ){{endif}} - {{if 'cudaDevAttrMaxSurface2DLayeredLayers' in found_values}} + ) + cudaDevAttrMaxSurface2DLayeredLayers = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxSurface2DLayeredLayers, 'Maximum layers in a 2D layered surface\n' - ){{endif}} - {{if 'cudaDevAttrMaxSurfaceCubemapWidth' in found_values}} + ) + cudaDevAttrMaxSurfaceCubemapWidth = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxSurfaceCubemapWidth, 'Maximum cubemap surface width\n' - ){{endif}} - {{if 'cudaDevAttrMaxSurfaceCubemapLayeredWidth' in found_values}} + ) + cudaDevAttrMaxSurfaceCubemapLayeredWidth = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxSurfaceCubemapLayeredWidth, 'Maximum cubemap layered surface width\n' - ){{endif}} - {{if 'cudaDevAttrMaxSurfaceCubemapLayeredLayers' in found_values}} + ) + cudaDevAttrMaxSurfaceCubemapLayeredLayers = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxSurfaceCubemapLayeredLayers, 'Maximum layers in a cubemap layered surface\n' - ){{endif}} - {{if 'cudaDevAttrMaxTexture1DLinearWidth' in found_values}} + ) + cudaDevAttrMaxTexture1DLinearWidth = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxTexture1DLinearWidth, 'Maximum 1D linear texture width\n' - ){{endif}} - {{if 'cudaDevAttrMaxTexture2DLinearWidth' in found_values}} + ) + cudaDevAttrMaxTexture2DLinearWidth = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxTexture2DLinearWidth, 'Maximum 2D linear texture width\n' - ){{endif}} - {{if 'cudaDevAttrMaxTexture2DLinearHeight' in found_values}} + ) + cudaDevAttrMaxTexture2DLinearHeight = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxTexture2DLinearHeight, 'Maximum 2D linear texture height\n' - ){{endif}} - {{if 'cudaDevAttrMaxTexture2DLinearPitch' in found_values}} + ) + cudaDevAttrMaxTexture2DLinearPitch = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxTexture2DLinearPitch, 'Maximum 2D linear texture pitch in bytes\n' - ){{endif}} - {{if 'cudaDevAttrMaxTexture2DMipmappedWidth' in found_values}} + ) + cudaDevAttrMaxTexture2DMipmappedWidth = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxTexture2DMipmappedWidth, 'Maximum mipmapped 2D texture width\n' - ){{endif}} - {{if 'cudaDevAttrMaxTexture2DMipmappedHeight' in found_values}} + ) + cudaDevAttrMaxTexture2DMipmappedHeight = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxTexture2DMipmappedHeight, 'Maximum mipmapped 2D texture height\n' - ){{endif}} - {{if 'cudaDevAttrComputeCapabilityMajor' in found_values}} + ) + cudaDevAttrComputeCapabilityMajor = ( cyruntime.cudaDeviceAttr.cudaDevAttrComputeCapabilityMajor, 'Major compute capability version number\n' - ){{endif}} - {{if 'cudaDevAttrComputeCapabilityMinor' in found_values}} + ) + cudaDevAttrComputeCapabilityMinor = ( cyruntime.cudaDeviceAttr.cudaDevAttrComputeCapabilityMinor, 'Minor compute capability version number\n' - ){{endif}} - {{if 'cudaDevAttrMaxTexture1DMipmappedWidth' in found_values}} + ) + cudaDevAttrMaxTexture1DMipmappedWidth = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxTexture1DMipmappedWidth, 'Maximum mipmapped 1D texture width\n' - ){{endif}} - {{if 'cudaDevAttrStreamPrioritiesSupported' in found_values}} + ) + cudaDevAttrStreamPrioritiesSupported = ( cyruntime.cudaDeviceAttr.cudaDevAttrStreamPrioritiesSupported, 'Device supports stream priorities\n' - ){{endif}} - {{if 'cudaDevAttrGlobalL1CacheSupported' in found_values}} + ) + cudaDevAttrGlobalL1CacheSupported = ( cyruntime.cudaDeviceAttr.cudaDevAttrGlobalL1CacheSupported, 'Device supports caching globals in L1\n' - ){{endif}} - {{if 'cudaDevAttrLocalL1CacheSupported' in found_values}} + ) + cudaDevAttrLocalL1CacheSupported = ( cyruntime.cudaDeviceAttr.cudaDevAttrLocalL1CacheSupported, 'Device supports caching locals in L1\n' - ){{endif}} - {{if 'cudaDevAttrMaxSharedMemoryPerMultiprocessor' in found_values}} + ) + cudaDevAttrMaxSharedMemoryPerMultiprocessor = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxSharedMemoryPerMultiprocessor, 'Maximum shared memory available per multiprocessor in bytes\n' - ){{endif}} - {{if 'cudaDevAttrMaxRegistersPerMultiprocessor' in found_values}} + ) + cudaDevAttrMaxRegistersPerMultiprocessor = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxRegistersPerMultiprocessor, 'Maximum number of 32-bit registers available per multiprocessor\n' - ){{endif}} - {{if 'cudaDevAttrManagedMemory' in found_values}} + ) + cudaDevAttrManagedMemory = ( cyruntime.cudaDeviceAttr.cudaDevAttrManagedMemory, 'Device can allocate managed memory on this system\n' - ){{endif}} - {{if 'cudaDevAttrIsMultiGpuBoard' in found_values}} + ) + cudaDevAttrIsMultiGpuBoard = ( cyruntime.cudaDeviceAttr.cudaDevAttrIsMultiGpuBoard, 'Device is on a multi-GPU board\n' - ){{endif}} - {{if 'cudaDevAttrMultiGpuBoardGroupID' in found_values}} + ) + cudaDevAttrMultiGpuBoardGroupID = ( cyruntime.cudaDeviceAttr.cudaDevAttrMultiGpuBoardGroupID, 'Unique identifier for a group of devices on the same multi-GPU board\n' - ){{endif}} - {{if 'cudaDevAttrHostNativeAtomicSupported' in found_values}} + ) + cudaDevAttrHostNativeAtomicSupported = ( cyruntime.cudaDeviceAttr.cudaDevAttrHostNativeAtomicSupported, 'Link between the device and the host supports native atomic operations\n' - ){{endif}} - {{if 'cudaDevAttrSingleToDoublePrecisionPerfRatio' in found_values}} + ) + cudaDevAttrSingleToDoublePrecisionPerfRatio = ( cyruntime.cudaDeviceAttr.cudaDevAttrSingleToDoublePrecisionPerfRatio, 'Ratio of single precision performance (in floating-point operations per\n' 'second) to double precision performance\n' - ){{endif}} - {{if 'cudaDevAttrPageableMemoryAccess' in found_values}} + ) + cudaDevAttrPageableMemoryAccess = ( cyruntime.cudaDeviceAttr.cudaDevAttrPageableMemoryAccess, 'Device supports coherently accessing pageable memory without calling\n' 'cudaHostRegister on it\n' - ){{endif}} - {{if 'cudaDevAttrConcurrentManagedAccess' in found_values}} + ) + cudaDevAttrConcurrentManagedAccess = ( cyruntime.cudaDeviceAttr.cudaDevAttrConcurrentManagedAccess, 'Device can coherently access managed memory concurrently with the CPU\n' - ){{endif}} - {{if 'cudaDevAttrComputePreemptionSupported' in found_values}} + ) + cudaDevAttrComputePreemptionSupported = ( cyruntime.cudaDeviceAttr.cudaDevAttrComputePreemptionSupported, 'Device supports Compute Preemption\n' - ){{endif}} - {{if 'cudaDevAttrCanUseHostPointerForRegisteredMem' in found_values}} + ) + cudaDevAttrCanUseHostPointerForRegisteredMem = ( cyruntime.cudaDeviceAttr.cudaDevAttrCanUseHostPointerForRegisteredMem, 'Device can access host registered memory at the same virtual address as the\n' 'CPU\n' - ){{endif}} - {{if 'cudaDevAttrReserved92' in found_values}} - cudaDevAttrReserved92 = cyruntime.cudaDeviceAttr.cudaDevAttrReserved92{{endif}} - {{if 'cudaDevAttrReserved93' in found_values}} - cudaDevAttrReserved93 = cyruntime.cudaDeviceAttr.cudaDevAttrReserved93{{endif}} - {{if 'cudaDevAttrReserved94' in found_values}} - cudaDevAttrReserved94 = cyruntime.cudaDeviceAttr.cudaDevAttrReserved94{{endif}} - {{if 'cudaDevAttrCooperativeLaunch' in found_values}} + ) + + cudaDevAttrReserved92 = cyruntime.cudaDeviceAttr.cudaDevAttrReserved92 + + cudaDevAttrReserved93 = cyruntime.cudaDeviceAttr.cudaDevAttrReserved93 + + cudaDevAttrReserved94 = cyruntime.cudaDeviceAttr.cudaDevAttrReserved94 + cudaDevAttrCooperativeLaunch = ( cyruntime.cudaDeviceAttr.cudaDevAttrCooperativeLaunch, 'Device supports launching cooperative kernels via\n' ':py:obj:`~.cudaLaunchCooperativeKernel`\n' - ){{endif}} - {{if 'cudaDevAttrReserved96' in found_values}} - cudaDevAttrReserved96 = cyruntime.cudaDeviceAttr.cudaDevAttrReserved96{{endif}} - {{if 'cudaDevAttrMaxSharedMemoryPerBlockOptin' in found_values}} + ) + + cudaDevAttrReserved96 = cyruntime.cudaDeviceAttr.cudaDevAttrReserved96 + cudaDevAttrMaxSharedMemoryPerBlockOptin = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxSharedMemoryPerBlockOptin, 'The maximum optin shared memory per block. This value may vary by chip. See\n' ':py:obj:`~.cudaFuncSetAttribute`\n' - ){{endif}} - {{if 'cudaDevAttrCanFlushRemoteWrites' in found_values}} + ) + cudaDevAttrCanFlushRemoteWrites = ( cyruntime.cudaDeviceAttr.cudaDevAttrCanFlushRemoteWrites, 'Device supports flushing of outstanding remote writes.\n' - ){{endif}} - {{if 'cudaDevAttrHostRegisterSupported' in found_values}} + ) + cudaDevAttrHostRegisterSupported = ( cyruntime.cudaDeviceAttr.cudaDevAttrHostRegisterSupported, 'Device supports host memory registration via :py:obj:`~.cudaHostRegister`.\n' - ){{endif}} - {{if 'cudaDevAttrPageableMemoryAccessUsesHostPageTables' in found_values}} + ) + cudaDevAttrPageableMemoryAccessUsesHostPageTables = ( cyruntime.cudaDeviceAttr.cudaDevAttrPageableMemoryAccessUsesHostPageTables, "Device accesses pageable memory via the host's page tables.\n" - ){{endif}} - {{if 'cudaDevAttrDirectManagedMemAccessFromHost' in found_values}} + ) + cudaDevAttrDirectManagedMemAccessFromHost = ( cyruntime.cudaDeviceAttr.cudaDevAttrDirectManagedMemAccessFromHost, 'Host can directly access managed memory on the device without migration.\n' - ){{endif}} - {{if 'cudaDevAttrMaxBlocksPerMultiprocessor' in found_values}} + ) + cudaDevAttrMaxBlocksPerMultiprocessor = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxBlocksPerMultiprocessor, 'Maximum number of blocks per multiprocessor\n' - ){{endif}} - {{if 'cudaDevAttrMaxPersistingL2CacheSize' in found_values}} + ) + cudaDevAttrMaxPersistingL2CacheSize = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxPersistingL2CacheSize, 'Maximum L2 persisting lines capacity setting in bytes.\n' - ){{endif}} - {{if 'cudaDevAttrMaxAccessPolicyWindowSize' in found_values}} + ) + cudaDevAttrMaxAccessPolicyWindowSize = ( cyruntime.cudaDeviceAttr.cudaDevAttrMaxAccessPolicyWindowSize, 'Maximum value of :py:obj:`~.cudaAccessPolicyWindow.num_bytes`.\n' - ){{endif}} - {{if 'cudaDevAttrReservedSharedMemoryPerBlock' in found_values}} + ) + cudaDevAttrReservedSharedMemoryPerBlock = ( cyruntime.cudaDeviceAttr.cudaDevAttrReservedSharedMemoryPerBlock, 'Shared memory reserved by CUDA driver per block in bytes\n' - ){{endif}} - {{if 'cudaDevAttrSparseCudaArraySupported' in found_values}} + ) + cudaDevAttrSparseCudaArraySupported = ( cyruntime.cudaDeviceAttr.cudaDevAttrSparseCudaArraySupported, 'Device supports sparse CUDA arrays and sparse CUDA mipmapped arrays\n' - ){{endif}} - {{if 'cudaDevAttrHostRegisterReadOnlySupported' in found_values}} + ) + cudaDevAttrHostRegisterReadOnlySupported = ( cyruntime.cudaDeviceAttr.cudaDevAttrHostRegisterReadOnlySupported, 'Device supports using the :py:obj:`~.cudaHostRegister` flag\n' 'cudaHostRegisterReadOnly to register memory that must be mapped as read-\n' 'only to the GPU\n' - ){{endif}} - {{if 'cudaDevAttrTimelineSemaphoreInteropSupported' in found_values}} + ) + cudaDevAttrTimelineSemaphoreInteropSupported = ( cyruntime.cudaDeviceAttr.cudaDevAttrTimelineSemaphoreInteropSupported, 'External timeline semaphore interop is supported on the device\n' - ){{endif}} - {{if 'cudaDevAttrMemoryPoolsSupported' in found_values}} + ) + cudaDevAttrMemoryPoolsSupported = ( cyruntime.cudaDeviceAttr.cudaDevAttrMemoryPoolsSupported, 'Device supports using the :py:obj:`~.cudaMallocAsync` and\n' ':py:obj:`~.cudaMemPool` family of APIs\n' - ){{endif}} - {{if 'cudaDevAttrGPUDirectRDMASupported' in found_values}} + ) + cudaDevAttrGPUDirectRDMASupported = ( cyruntime.cudaDeviceAttr.cudaDevAttrGPUDirectRDMASupported, 'Device supports GPUDirect RDMA APIs, like nvidia_p2p_get_pages (see\n' 'https://docs.nvidia.com/cuda/gpudirect-rdma for more information)\n' - ){{endif}} - {{if 'cudaDevAttrGPUDirectRDMAFlushWritesOptions' in found_values}} + ) + cudaDevAttrGPUDirectRDMAFlushWritesOptions = ( cyruntime.cudaDeviceAttr.cudaDevAttrGPUDirectRDMAFlushWritesOptions, 'The returned attribute shall be interpreted as a bitmask, where the\n' 'individual bits are listed in the\n' ':py:obj:`~.cudaFlushGPUDirectRDMAWritesOptions` enum\n' - ){{endif}} - {{if 'cudaDevAttrGPUDirectRDMAWritesOrdering' in found_values}} + ) + cudaDevAttrGPUDirectRDMAWritesOrdering = ( cyruntime.cudaDeviceAttr.cudaDevAttrGPUDirectRDMAWritesOrdering, @@ -4868,156 +4725,153 @@ class cudaDeviceAttr(_FastEnum): 'within the scope indicated by the returned attribute. See\n' ':py:obj:`~.cudaGPUDirectRDMAWritesOrdering` for the numerical values\n' 'returned here.\n' - ){{endif}} - {{if 'cudaDevAttrMemoryPoolSupportedHandleTypes' in found_values}} + ) + cudaDevAttrMemoryPoolSupportedHandleTypes = ( cyruntime.cudaDeviceAttr.cudaDevAttrMemoryPoolSupportedHandleTypes, 'Handle types supported with mempool based IPC\n' - ){{endif}} - {{if 'cudaDevAttrClusterLaunch' in found_values}} + ) + cudaDevAttrClusterLaunch = ( cyruntime.cudaDeviceAttr.cudaDevAttrClusterLaunch, 'Indicates device supports cluster launch\n' - ){{endif}} - {{if 'cudaDevAttrDeferredMappingCudaArraySupported' in found_values}} + ) + cudaDevAttrDeferredMappingCudaArraySupported = ( cyruntime.cudaDeviceAttr.cudaDevAttrDeferredMappingCudaArraySupported, 'Device supports deferred mapping CUDA arrays and CUDA mipmapped arrays\n' - ){{endif}} - {{if 'cudaDevAttrReserved122' in found_values}} - cudaDevAttrReserved122 = cyruntime.cudaDeviceAttr.cudaDevAttrReserved122{{endif}} - {{if 'cudaDevAttrReserved123' in found_values}} - cudaDevAttrReserved123 = cyruntime.cudaDeviceAttr.cudaDevAttrReserved123{{endif}} - {{if 'cudaDevAttrReserved124' in found_values}} - cudaDevAttrReserved124 = cyruntime.cudaDeviceAttr.cudaDevAttrReserved124{{endif}} - {{if 'cudaDevAttrIpcEventSupport' in found_values}} + ) + + cudaDevAttrReserved122 = cyruntime.cudaDeviceAttr.cudaDevAttrReserved122 + + cudaDevAttrReserved123 = cyruntime.cudaDeviceAttr.cudaDevAttrReserved123 + + cudaDevAttrReserved124 = cyruntime.cudaDeviceAttr.cudaDevAttrReserved124 + cudaDevAttrIpcEventSupport = ( cyruntime.cudaDeviceAttr.cudaDevAttrIpcEventSupport, 'Device supports IPC Events.\n' - ){{endif}} - {{if 'cudaDevAttrMemSyncDomainCount' in found_values}} + ) + cudaDevAttrMemSyncDomainCount = ( cyruntime.cudaDeviceAttr.cudaDevAttrMemSyncDomainCount, 'Number of memory synchronization domains the device supports.\n' - ){{endif}} - {{if 'cudaDevAttrReserved127' in found_values}} - cudaDevAttrReserved127 = cyruntime.cudaDeviceAttr.cudaDevAttrReserved127{{endif}} - {{if 'cudaDevAttrReserved128' in found_values}} - cudaDevAttrReserved128 = cyruntime.cudaDeviceAttr.cudaDevAttrReserved128{{endif}} - {{if 'cudaDevAttrReserved129' in found_values}} - cudaDevAttrReserved129 = cyruntime.cudaDeviceAttr.cudaDevAttrReserved129{{endif}} - {{if 'cudaDevAttrNumaConfig' in found_values}} + ) + + cudaDevAttrReserved127 = cyruntime.cudaDeviceAttr.cudaDevAttrReserved127 + + cudaDevAttrReserved128 = cyruntime.cudaDeviceAttr.cudaDevAttrReserved128 + + cudaDevAttrReserved129 = cyruntime.cudaDeviceAttr.cudaDevAttrReserved129 + cudaDevAttrNumaConfig = ( cyruntime.cudaDeviceAttr.cudaDevAttrNumaConfig, 'NUMA configuration of a device: value is of type\n' ':py:obj:`~.cudaDeviceNumaConfig` enum\n' - ){{endif}} - {{if 'cudaDevAttrNumaId' in found_values}} + ) + cudaDevAttrNumaId = ( cyruntime.cudaDeviceAttr.cudaDevAttrNumaId, 'NUMA node ID of the GPU memory\n' - ){{endif}} - {{if 'cudaDevAttrReserved132' in found_values}} - cudaDevAttrReserved132 = cyruntime.cudaDeviceAttr.cudaDevAttrReserved132{{endif}} - {{if 'cudaDevAttrMpsEnabled' in found_values}} + ) + + cudaDevAttrReserved132 = cyruntime.cudaDeviceAttr.cudaDevAttrReserved132 + cudaDevAttrMpsEnabled = ( cyruntime.cudaDeviceAttr.cudaDevAttrMpsEnabled, 'Contexts created on this device will be shared via MPS\n' - ){{endif}} - {{if 'cudaDevAttrHostNumaId' in found_values}} + ) + cudaDevAttrHostNumaId = ( cyruntime.cudaDeviceAttr.cudaDevAttrHostNumaId, 'NUMA ID of the host node closest to the device or -1 when system does not\n' 'support NUMA\n' - ){{endif}} - {{if 'cudaDevAttrD3D12CigSupported' in found_values}} + ) + cudaDevAttrD3D12CigSupported = ( cyruntime.cudaDeviceAttr.cudaDevAttrD3D12CigSupported, 'Device supports CIG with D3D12.\n' - ){{endif}} - {{if 'cudaDevAttrVulkanCigSupported' in found_values}} + ) + cudaDevAttrVulkanCigSupported = ( cyruntime.cudaDeviceAttr.cudaDevAttrVulkanCigSupported, 'Device supports CIG with Vulkan.\n' - ){{endif}} - {{if 'cudaDevAttrGpuPciDeviceId' in found_values}} + ) + cudaDevAttrGpuPciDeviceId = ( cyruntime.cudaDeviceAttr.cudaDevAttrGpuPciDeviceId, 'The combined 16-bit PCI device ID and 16-bit PCI vendor ID.\n' - ){{endif}} - {{if 'cudaDevAttrGpuPciSubsystemId' in found_values}} + ) + cudaDevAttrGpuPciSubsystemId = ( cyruntime.cudaDeviceAttr.cudaDevAttrGpuPciSubsystemId, 'The combined 16-bit PCI subsystem ID and 16-bit PCI subsystem vendor ID.\n' - ){{endif}} - {{if 'cudaDevAttrReserved141' in found_values}} - cudaDevAttrReserved141 = cyruntime.cudaDeviceAttr.cudaDevAttrReserved141{{endif}} - {{if 'cudaDevAttrHostNumaMemoryPoolsSupported' in found_values}} + ) + + cudaDevAttrReserved141 = cyruntime.cudaDeviceAttr.cudaDevAttrReserved141 + cudaDevAttrHostNumaMemoryPoolsSupported = ( cyruntime.cudaDeviceAttr.cudaDevAttrHostNumaMemoryPoolsSupported, 'Device supports HOST_NUMA location with the :py:obj:`~.cudaMallocAsync` and\n' ':py:obj:`~.cudaMemPool` family of APIs\n' - ){{endif}} - {{if 'cudaDevAttrHostNumaMultinodeIpcSupported' in found_values}} + ) + cudaDevAttrHostNumaMultinodeIpcSupported = ( cyruntime.cudaDeviceAttr.cudaDevAttrHostNumaMultinodeIpcSupported, 'Device supports HostNuma location IPC between nodes in a multi-node system.\n' - ){{endif}} - {{if 'cudaDevAttrHostMemoryPoolsSupported' in found_values}} + ) + cudaDevAttrHostMemoryPoolsSupported = ( cyruntime.cudaDeviceAttr.cudaDevAttrHostMemoryPoolsSupported, 'Device suports HOST location with the :py:obj:`~.cuMemAllocAsync` and\n' ':py:obj:`~.cuMemPool` family of APIs\n' - ){{endif}} - {{if 'cudaDevAttrReserved145' in found_values}} - cudaDevAttrReserved145 = cyruntime.cudaDeviceAttr.cudaDevAttrReserved145{{endif}} - {{if 'cudaDevAttrOnlyPartialHostNativeAtomicSupported' in found_values}} + ) + + cudaDevAttrReserved145 = cyruntime.cudaDeviceAttr.cudaDevAttrReserved145 + cudaDevAttrOnlyPartialHostNativeAtomicSupported = ( cyruntime.cudaDeviceAttr.cudaDevAttrOnlyPartialHostNativeAtomicSupported, 'Link between the device and the host supports only some native atomic\n' 'operations\n' - ){{endif}} - {{if 'cudaDevAttrAtomicReductionSupported' in found_values}} + ) + cudaDevAttrAtomicReductionSupported = ( cyruntime.cudaDeviceAttr.cudaDevAttrAtomicReductionSupported, 'Device supports atomic reduction operations in stream batch memory\n' 'operations\n' - ){{endif}} - {{if 'cudaDevAttrCigStreamsSupported' in found_values}} + ) + cudaDevAttrCigStreamsSupported = ( cyruntime.cudaDeviceAttr.cudaDevAttrCigStreamsSupported, 'Device supports CIG streams\n' - ){{endif}} - {{if 'cudaDevAttrMax' in found_values}} - cudaDevAttrMax = cyruntime.cudaDeviceAttr.cudaDevAttrMax{{endif}} + ) -{{endif}} -{{if 'cudaMemPoolAttr' in found_types}} + cudaDevAttrMax = cyruntime.cudaDeviceAttr.cudaDevAttrMax class cudaMemPoolAttr(_FastEnum): """ CUDA memory pool attributes """ - {{if 'cudaMemPoolReuseFollowEventDependencies' in found_values}} + cudaMemPoolReuseFollowEventDependencies = ( cyruntime.cudaMemPoolAttr.cudaMemPoolReuseFollowEventDependencies, @@ -5026,23 +4880,23 @@ class cudaMemPoolAttr(_FastEnum): 'allocating stream on the free action exists. Cuda events and null stream\n' 'interactions can create the required stream ordered dependencies. (default\n' 'enabled)\n' - ){{endif}} - {{if 'cudaMemPoolReuseAllowOpportunistic' in found_values}} + ) + cudaMemPoolReuseAllowOpportunistic = ( cyruntime.cudaMemPoolAttr.cudaMemPoolReuseAllowOpportunistic, '(value type = int) Allow reuse of already completed frees when there is no\n' 'dependency between the free and allocation. (default enabled)\n' - ){{endif}} - {{if 'cudaMemPoolReuseAllowInternalDependencies' in found_values}} + ) + cudaMemPoolReuseAllowInternalDependencies = ( cyruntime.cudaMemPoolAttr.cudaMemPoolReuseAllowInternalDependencies, '(value type = int) Allow cuMemAllocAsync to insert new stream dependencies\n' 'in order to establish the stream ordering required to reuse a piece of\n' 'memory released by cuFreeAsync (default enabled).\n' - ){{endif}} - {{if 'cudaMemPoolAttrReleaseThreshold' in found_values}} + ) + cudaMemPoolAttrReleaseThreshold = ( cyruntime.cudaMemPoolAttr.cudaMemPoolAttrReleaseThreshold, @@ -5051,61 +4905,61 @@ class cudaMemPoolAttr(_FastEnum): 'threshold bytes of memory are held by the memory pool, the allocator will\n' 'try to release memory back to the OS on the next call to stream, event or\n' 'context synchronize. (default 0)\n' - ){{endif}} - {{if 'cudaMemPoolAttrReservedMemCurrent' in found_values}} + ) + cudaMemPoolAttrReservedMemCurrent = ( cyruntime.cudaMemPoolAttr.cudaMemPoolAttrReservedMemCurrent, '(value type = cuuint64_t) Amount of backing memory currently allocated for\n' 'the mempool.\n' - ){{endif}} - {{if 'cudaMemPoolAttrReservedMemHigh' in found_values}} + ) + cudaMemPoolAttrReservedMemHigh = ( cyruntime.cudaMemPoolAttr.cudaMemPoolAttrReservedMemHigh, '(value type = cuuint64_t) High watermark of backing memory allocated for\n' 'the mempool since the last time it was reset. High watermark can only be\n' 'reset to zero.\n' - ){{endif}} - {{if 'cudaMemPoolAttrUsedMemCurrent' in found_values}} + ) + cudaMemPoolAttrUsedMemCurrent = ( cyruntime.cudaMemPoolAttr.cudaMemPoolAttrUsedMemCurrent, '(value type = cuuint64_t) Amount of memory from the pool that is currently\n' 'in use by the application.\n' - ){{endif}} - {{if 'cudaMemPoolAttrUsedMemHigh' in found_values}} + ) + cudaMemPoolAttrUsedMemHigh = ( cyruntime.cudaMemPoolAttr.cudaMemPoolAttrUsedMemHigh, '(value type = cuuint64_t) High watermark of the amount of memory from the\n' 'pool that was in use by the application since the last time it was reset.\n' 'High watermark can only be reset to zero.\n' - ){{endif}} - {{if 'cudaMemPoolAttrAllocationType' in found_values}} + ) + cudaMemPoolAttrAllocationType = ( cyruntime.cudaMemPoolAttr.cudaMemPoolAttrAllocationType, '(value type = :py:obj:`~.cudaMemAllocationType`) The allocation type of the\n' 'mempool\n' - ){{endif}} - {{if 'cudaMemPoolAttrExportHandleTypes' in found_values}} + ) + cudaMemPoolAttrExportHandleTypes = ( cyruntime.cudaMemPoolAttr.cudaMemPoolAttrExportHandleTypes, '(value type = :py:obj:`~.cudaMemAllocationHandleType`) Available export\n' 'handle types for the mempool. For imported pools this value is always\n' 'cudaMemHandleTypeNone as an imported pool cannot be re-exported\n' - ){{endif}} - {{if 'cudaMemPoolAttrLocationId' in found_values}} + ) + cudaMemPoolAttrLocationId = ( cyruntime.cudaMemPoolAttr.cudaMemPoolAttrLocationId, '(value type = int) The location id for the mempool. If the location type\n' 'for this pool is cudaMemLocationTypeInvisible then ID will be\n' 'cudaInvalidDeviceId\n' - ){{endif}} - {{if 'cudaMemPoolAttrLocationType' in found_values}} + ) + cudaMemPoolAttrLocationType = ( cyruntime.cudaMemPoolAttr.cudaMemPoolAttrLocationType, @@ -5113,8 +4967,8 @@ class cudaMemPoolAttr(_FastEnum): 'mempool. For imported memory pools where the device is not directly visible\n' 'to the importing process or pools imported via fabric handles across nodes\n' 'this will be cudaMemLocationTypeInvisible\n' - ){{endif}} - {{if 'cudaMemPoolAttrMaxPoolSize' in found_values}} + ) + cudaMemPoolAttrMaxPoolSize = ( cyruntime.cudaMemPoolAttr.cudaMemPoolAttrMaxPoolSize, @@ -5123,230 +4977,209 @@ class cudaMemPoolAttr(_FastEnum): 'alignment requirements. A value of 0 indicates no maximum size. For\n' 'cudaMemAllocationTypeManaged and IPC imported pools this value will be\n' 'system dependent.\n' - ){{endif}} - {{if 'cudaMemPoolAttrHwDecompressEnabled' in found_values}} + ) + cudaMemPoolAttrHwDecompressEnabled = ( cyruntime.cudaMemPoolAttr.cudaMemPoolAttrHwDecompressEnabled, '(value type = int) Indicates whether the pool has hardware compresssion\n' 'enabled\n' - ){{endif}} - -{{endif}} -{{if 'cudaMemLocationType' in found_types}} + ) class cudaMemLocationType(_FastEnum): """ Specifies the type of location """ - {{if 'cudaMemLocationTypeInvalid' in found_values}} - cudaMemLocationTypeInvalid = cyruntime.cudaMemLocationType.cudaMemLocationTypeInvalid{{endif}} - {{if 'cudaMemLocationTypeNone' in found_values}} + + cudaMemLocationTypeInvalid = cyruntime.cudaMemLocationType.cudaMemLocationTypeInvalid + cudaMemLocationTypeNone = ( cyruntime.cudaMemLocationType.cudaMemLocationTypeNone, 'Location is unspecified. This is used when creating a managed memory pool\n' 'to indicate no preferred location for the pool\n' - ){{endif}} - {{if 'cudaMemLocationTypeDevice' in found_values}} + ) + cudaMemLocationTypeDevice = ( cyruntime.cudaMemLocationType.cudaMemLocationTypeDevice, 'Location is a device location, thus id is a device ordinal\n' - ){{endif}} - {{if 'cudaMemLocationTypeHost' in found_values}} + ) + cudaMemLocationTypeHost = ( cyruntime.cudaMemLocationType.cudaMemLocationTypeHost, 'Location is host, id is ignored\n' - ){{endif}} - {{if 'cudaMemLocationTypeHostNuma' in found_values}} + ) + cudaMemLocationTypeHostNuma = ( cyruntime.cudaMemLocationType.cudaMemLocationTypeHostNuma, 'Location is a host NUMA node, thus id is a host NUMA node id\n' - ){{endif}} - {{if 'cudaMemLocationTypeHostNumaCurrent' in found_values}} + ) + cudaMemLocationTypeHostNumaCurrent = ( cyruntime.cudaMemLocationType.cudaMemLocationTypeHostNumaCurrent, "Location is the host NUMA node closest to the current thread's CPU, id is\n" 'ignored\n' - ){{endif}} - {{if 'cudaMemLocationTypeInvisible' in found_values}} + ) + cudaMemLocationTypeInvisible = ( cyruntime.cudaMemLocationType.cudaMemLocationTypeInvisible, 'Location is not visible but device is accessible, id is always\n' 'cudaInvalidDeviceId\n' - ){{endif}} - -{{endif}} -{{if 'cudaMemAccessFlags' in found_types}} + ) class cudaMemAccessFlags(_FastEnum): """ Specifies the memory protection flags for mapping. """ - {{if 'cudaMemAccessFlagsProtNone' in found_values}} + cudaMemAccessFlagsProtNone = ( cyruntime.cudaMemAccessFlags.cudaMemAccessFlagsProtNone, 'Default, make the address range not accessible\n' - ){{endif}} - {{if 'cudaMemAccessFlagsProtRead' in found_values}} + ) + cudaMemAccessFlagsProtRead = ( cyruntime.cudaMemAccessFlags.cudaMemAccessFlagsProtRead, 'Make the address range read accessible\n' - ){{endif}} - {{if 'cudaMemAccessFlagsProtReadWrite' in found_values}} + ) + cudaMemAccessFlagsProtReadWrite = ( cyruntime.cudaMemAccessFlags.cudaMemAccessFlagsProtReadWrite, 'Make the address range read-write accessible\n' - ){{endif}} - -{{endif}} -{{if 'cudaMemAllocationType' in found_types}} + ) class cudaMemAllocationType(_FastEnum): """ Defines the allocation types available """ - {{if 'cudaMemAllocationTypeInvalid' in found_values}} - cudaMemAllocationTypeInvalid = cyruntime.cudaMemAllocationType.cudaMemAllocationTypeInvalid{{endif}} - {{if 'cudaMemAllocationTypePinned' in found_values}} + + cudaMemAllocationTypeInvalid = cyruntime.cudaMemAllocationType.cudaMemAllocationTypeInvalid + cudaMemAllocationTypePinned = ( cyruntime.cudaMemAllocationType.cudaMemAllocationTypePinned, "This allocation type is 'pinned', i.e. cannot migrate from its current\n" 'location while the application is actively using it\n' - ){{endif}} - {{if 'cudaMemAllocationTypeManaged' in found_values}} + ) + cudaMemAllocationTypeManaged = ( cyruntime.cudaMemAllocationType.cudaMemAllocationTypeManaged, 'This allocation type is managed memory\n' - ){{endif}} - {{if 'cudaMemAllocationTypeMax' in found_values}} - cudaMemAllocationTypeMax = cyruntime.cudaMemAllocationType.cudaMemAllocationTypeMax{{endif}} + ) -{{endif}} -{{if 'cudaMemAllocationHandleType' in found_types}} + cudaMemAllocationTypeMax = cyruntime.cudaMemAllocationType.cudaMemAllocationTypeMax class cudaMemAllocationHandleType(_FastEnum): """ Flags for specifying particular handle types """ - {{if 'cudaMemHandleTypeNone' in found_values}} + cudaMemHandleTypeNone = ( cyruntime.cudaMemAllocationHandleType.cudaMemHandleTypeNone, 'Does not allow any export mechanism. >\n' - ){{endif}} - {{if 'cudaMemHandleTypePosixFileDescriptor' in found_values}} + ) + cudaMemHandleTypePosixFileDescriptor = ( cyruntime.cudaMemAllocationHandleType.cudaMemHandleTypePosixFileDescriptor, 'Allows a file descriptor to be used for exporting. Permitted only on POSIX\n' 'systems. (int)\n' - ){{endif}} - {{if 'cudaMemHandleTypeWin32' in found_values}} + ) + cudaMemHandleTypeWin32 = ( cyruntime.cudaMemAllocationHandleType.cudaMemHandleTypeWin32, 'Allows a Win32 NT handle to be used for exporting. (HANDLE)\n' - ){{endif}} - {{if 'cudaMemHandleTypeWin32Kmt' in found_values}} + ) + cudaMemHandleTypeWin32Kmt = ( cyruntime.cudaMemAllocationHandleType.cudaMemHandleTypeWin32Kmt, 'Allows a Win32 KMT handle to be used for exporting. (D3DKMT_HANDLE)\n' - ){{endif}} - {{if 'cudaMemHandleTypeFabric' in found_values}} + ) + cudaMemHandleTypeFabric = ( cyruntime.cudaMemAllocationHandleType.cudaMemHandleTypeFabric, 'Allows a fabric handle to be used for exporting.\n' '(:py:obj:`~.cudaMemFabricHandle_t`)\n' - ){{endif}} - -{{endif}} -{{if 'cudaGraphMemAttributeType' in found_types}} + ) class cudaGraphMemAttributeType(_FastEnum): """ Graph memory attributes """ - {{if 'cudaGraphMemAttrUsedMemCurrent' in found_values}} + cudaGraphMemAttrUsedMemCurrent = ( cyruntime.cudaGraphMemAttributeType.cudaGraphMemAttrUsedMemCurrent, '(value type = cuuint64_t) Amount of memory, in bytes, currently associated\n' 'with graphs.\n' - ){{endif}} - {{if 'cudaGraphMemAttrUsedMemHigh' in found_values}} + ) + cudaGraphMemAttrUsedMemHigh = ( cyruntime.cudaGraphMemAttributeType.cudaGraphMemAttrUsedMemHigh, '(value type = cuuint64_t) High watermark of memory, in bytes, associated\n' 'with graphs since the last time it was reset. High watermark can only be\n' 'reset to zero.\n' - ){{endif}} - {{if 'cudaGraphMemAttrReservedMemCurrent' in found_values}} + ) + cudaGraphMemAttrReservedMemCurrent = ( cyruntime.cudaGraphMemAttributeType.cudaGraphMemAttrReservedMemCurrent, '(value type = cuuint64_t) Amount of memory, in bytes, currently allocated\n' 'for use by the CUDA graphs asynchronous allocator.\n' - ){{endif}} - {{if 'cudaGraphMemAttrReservedMemHigh' in found_values}} + ) + cudaGraphMemAttrReservedMemHigh = ( cyruntime.cudaGraphMemAttributeType.cudaGraphMemAttrReservedMemHigh, '(value type = cuuint64_t) High watermark of memory, in bytes, currently\n' 'allocated for use by the CUDA graphs asynchronous allocator.\n' - ){{endif}} - -{{endif}} -{{if 'cudaMemcpyFlags' in found_types}} + ) class cudaMemcpyFlags(_FastEnum): """ Flags to specify for copies within a batch. For more details see :py:obj:`~.cudaMemcpyBatchAsync`. """ - {{if 'cudaMemcpyFlagDefault' in found_values}} - cudaMemcpyFlagDefault = cyruntime.cudaMemcpyFlags.cudaMemcpyFlagDefault{{endif}} - {{if 'cudaMemcpyFlagPreferOverlapWithCompute' in found_values}} + + cudaMemcpyFlagDefault = cyruntime.cudaMemcpyFlags.cudaMemcpyFlagDefault + cudaMemcpyFlagPreferOverlapWithCompute = ( cyruntime.cudaMemcpyFlags.cudaMemcpyFlagPreferOverlapWithCompute, 'Hint to the driver to try and overlap the copy with compute work on the\n' 'SMs.\n' - ){{endif}} - -{{endif}} -{{if 'cudaMemcpySrcAccessOrder' in found_types}} + ) class cudaMemcpySrcAccessOrder(_FastEnum): """ """ - {{if 'cudaMemcpySrcAccessOrderInvalid' in found_values}} + cudaMemcpySrcAccessOrderInvalid = ( cyruntime.cudaMemcpySrcAccessOrder.cudaMemcpySrcAccessOrderInvalid, 'Default invalid.\n' - ){{endif}} - {{if 'cudaMemcpySrcAccessOrderStream' in found_values}} + ) + cudaMemcpySrcAccessOrderStream = ( cyruntime.cudaMemcpySrcAccessOrder.cudaMemcpySrcAccessOrderStream, 'Indicates that access to the source pointer must be in stream order.\n' - ){{endif}} - {{if 'cudaMemcpySrcAccessOrderDuringApiCall' in found_values}} + ) + cudaMemcpySrcAccessOrderDuringApiCall = ( cyruntime.cudaMemcpySrcAccessOrder.cudaMemcpySrcAccessOrderDuringApiCall, @@ -5358,8 +5191,8 @@ class cudaMemcpySrcAccessOrder(_FastEnum): 'was declared in. Specifying this flag allows the driver to optimize the\n' 'copy and removes the need for the user to synchronize the stream after the\n' 'API call.\n' - ){{endif}} - {{if 'cudaMemcpySrcAccessOrderAny' in found_values}} + ) + cudaMemcpySrcAccessOrderAny = ( cyruntime.cudaMemcpySrcAccessOrder.cudaMemcpySrcAccessOrderAny, @@ -5369,345 +5202,312 @@ class cudaMemcpySrcAccessOrder(_FastEnum): 'known that no prior operations in the stream can be accessing the memory.\n' 'Specifying this flag allows the driver to optimize the copy on certain\n' 'platforms.\n' - ){{endif}} - {{if 'cudaMemcpySrcAccessOrderMax' in found_values}} - cudaMemcpySrcAccessOrderMax = cyruntime.cudaMemcpySrcAccessOrder.cudaMemcpySrcAccessOrderMax{{endif}} + ) -{{endif}} -{{if 'cudaMemcpy3DOperandType' in found_types}} + cudaMemcpySrcAccessOrderMax = cyruntime.cudaMemcpySrcAccessOrder.cudaMemcpySrcAccessOrderMax class cudaMemcpy3DOperandType(_FastEnum): """ These flags allow applications to convey the operand type for individual copies specified in :py:obj:`~.cudaMemcpy3DBatchAsync`. """ - {{if 'cudaMemcpyOperandTypePointer' in found_values}} + cudaMemcpyOperandTypePointer = ( cyruntime.cudaMemcpy3DOperandType.cudaMemcpyOperandTypePointer, 'Memcpy operand is a valid pointer.\n' - ){{endif}} - {{if 'cudaMemcpyOperandTypeArray' in found_values}} + ) + cudaMemcpyOperandTypeArray = ( cyruntime.cudaMemcpy3DOperandType.cudaMemcpyOperandTypeArray, 'Memcpy operand is a CUarray.\n' - ){{endif}} - {{if 'cudaMemcpyOperandTypeMax' in found_values}} - cudaMemcpyOperandTypeMax = cyruntime.cudaMemcpy3DOperandType.cudaMemcpyOperandTypeMax{{endif}} + ) -{{endif}} -{{if 'cudaDeviceP2PAttr' in found_types}} + cudaMemcpyOperandTypeMax = cyruntime.cudaMemcpy3DOperandType.cudaMemcpyOperandTypeMax class cudaDeviceP2PAttr(_FastEnum): """ CUDA device P2P attributes """ - {{if 'cudaDevP2PAttrPerformanceRank' in found_values}} + cudaDevP2PAttrPerformanceRank = ( cyruntime.cudaDeviceP2PAttr.cudaDevP2PAttrPerformanceRank, 'A relative value indicating the performance of the link between two devices\n' - ){{endif}} - {{if 'cudaDevP2PAttrAccessSupported' in found_values}} + ) + cudaDevP2PAttrAccessSupported = ( cyruntime.cudaDeviceP2PAttr.cudaDevP2PAttrAccessSupported, 'Peer access is enabled\n' - ){{endif}} - {{if 'cudaDevP2PAttrNativeAtomicSupported' in found_values}} + ) + cudaDevP2PAttrNativeAtomicSupported = ( cyruntime.cudaDeviceP2PAttr.cudaDevP2PAttrNativeAtomicSupported, 'Native atomic operation over the link supported\n' - ){{endif}} - {{if 'cudaDevP2PAttrCudaArrayAccessSupported' in found_values}} + ) + cudaDevP2PAttrCudaArrayAccessSupported = ( cyruntime.cudaDeviceP2PAttr.cudaDevP2PAttrCudaArrayAccessSupported, 'Accessing CUDA arrays over the link supported\n' - ){{endif}} - {{if 'cudaDevP2PAttrOnlyPartialNativeAtomicSupported' in found_values}} + ) + cudaDevP2PAttrOnlyPartialNativeAtomicSupported = ( cyruntime.cudaDeviceP2PAttr.cudaDevP2PAttrOnlyPartialNativeAtomicSupported, 'Only some CUDA-valid atomic operations over the link are supported.\n' - ){{endif}} - -{{endif}} -{{if 'cudaAtomicOperation' in found_types}} + ) class cudaAtomicOperation(_FastEnum): """ CUDA-valid Atomic Operations """ - {{if 'cudaAtomicOperationIntegerAdd' in found_values}} - cudaAtomicOperationIntegerAdd = cyruntime.cudaAtomicOperation.cudaAtomicOperationIntegerAdd{{endif}} - {{if 'cudaAtomicOperationIntegerMin' in found_values}} - cudaAtomicOperationIntegerMin = cyruntime.cudaAtomicOperation.cudaAtomicOperationIntegerMin{{endif}} - {{if 'cudaAtomicOperationIntegerMax' in found_values}} - cudaAtomicOperationIntegerMax = cyruntime.cudaAtomicOperation.cudaAtomicOperationIntegerMax{{endif}} - {{if 'cudaAtomicOperationIntegerIncrement' in found_values}} - cudaAtomicOperationIntegerIncrement = cyruntime.cudaAtomicOperation.cudaAtomicOperationIntegerIncrement{{endif}} - {{if 'cudaAtomicOperationIntegerDecrement' in found_values}} - cudaAtomicOperationIntegerDecrement = cyruntime.cudaAtomicOperation.cudaAtomicOperationIntegerDecrement{{endif}} - {{if 'cudaAtomicOperationAnd' in found_values}} - cudaAtomicOperationAnd = cyruntime.cudaAtomicOperation.cudaAtomicOperationAnd{{endif}} - {{if 'cudaAtomicOperationOr' in found_values}} - cudaAtomicOperationOr = cyruntime.cudaAtomicOperation.cudaAtomicOperationOr{{endif}} - {{if 'cudaAtomicOperationXOR' in found_values}} - cudaAtomicOperationXOR = cyruntime.cudaAtomicOperation.cudaAtomicOperationXOR{{endif}} - {{if 'cudaAtomicOperationExchange' in found_values}} - cudaAtomicOperationExchange = cyruntime.cudaAtomicOperation.cudaAtomicOperationExchange{{endif}} - {{if 'cudaAtomicOperationCAS' in found_values}} - cudaAtomicOperationCAS = cyruntime.cudaAtomicOperation.cudaAtomicOperationCAS{{endif}} - {{if 'cudaAtomicOperationFloatAdd' in found_values}} - cudaAtomicOperationFloatAdd = cyruntime.cudaAtomicOperation.cudaAtomicOperationFloatAdd{{endif}} - {{if 'cudaAtomicOperationFloatMin' in found_values}} - cudaAtomicOperationFloatMin = cyruntime.cudaAtomicOperation.cudaAtomicOperationFloatMin{{endif}} - {{if 'cudaAtomicOperationFloatMax' in found_values}} - cudaAtomicOperationFloatMax = cyruntime.cudaAtomicOperation.cudaAtomicOperationFloatMax{{endif}} - -{{endif}} -{{if 'cudaAtomicOperationCapability' in found_types}} + + cudaAtomicOperationIntegerAdd = cyruntime.cudaAtomicOperation.cudaAtomicOperationIntegerAdd + + cudaAtomicOperationIntegerMin = cyruntime.cudaAtomicOperation.cudaAtomicOperationIntegerMin + + cudaAtomicOperationIntegerMax = cyruntime.cudaAtomicOperation.cudaAtomicOperationIntegerMax + + cudaAtomicOperationIntegerIncrement = cyruntime.cudaAtomicOperation.cudaAtomicOperationIntegerIncrement + + cudaAtomicOperationIntegerDecrement = cyruntime.cudaAtomicOperation.cudaAtomicOperationIntegerDecrement + + cudaAtomicOperationAnd = cyruntime.cudaAtomicOperation.cudaAtomicOperationAnd + + cudaAtomicOperationOr = cyruntime.cudaAtomicOperation.cudaAtomicOperationOr + + cudaAtomicOperationXOR = cyruntime.cudaAtomicOperation.cudaAtomicOperationXOR + + cudaAtomicOperationExchange = cyruntime.cudaAtomicOperation.cudaAtomicOperationExchange + + cudaAtomicOperationCAS = cyruntime.cudaAtomicOperation.cudaAtomicOperationCAS + + cudaAtomicOperationFloatAdd = cyruntime.cudaAtomicOperation.cudaAtomicOperationFloatAdd + + cudaAtomicOperationFloatMin = cyruntime.cudaAtomicOperation.cudaAtomicOperationFloatMin + + cudaAtomicOperationFloatMax = cyruntime.cudaAtomicOperation.cudaAtomicOperationFloatMax class cudaAtomicOperationCapability(_FastEnum): """ CUDA-valid Atomic Operation capabilities """ - {{if 'cudaAtomicCapabilitySigned' in found_values}} - cudaAtomicCapabilitySigned = cyruntime.cudaAtomicOperationCapability.cudaAtomicCapabilitySigned{{endif}} - {{if 'cudaAtomicCapabilityUnsigned' in found_values}} - cudaAtomicCapabilityUnsigned = cyruntime.cudaAtomicOperationCapability.cudaAtomicCapabilityUnsigned{{endif}} - {{if 'cudaAtomicCapabilityReduction' in found_values}} - cudaAtomicCapabilityReduction = cyruntime.cudaAtomicOperationCapability.cudaAtomicCapabilityReduction{{endif}} - {{if 'cudaAtomicCapabilityScalar32' in found_values}} - cudaAtomicCapabilityScalar32 = cyruntime.cudaAtomicOperationCapability.cudaAtomicCapabilityScalar32{{endif}} - {{if 'cudaAtomicCapabilityScalar64' in found_values}} - cudaAtomicCapabilityScalar64 = cyruntime.cudaAtomicOperationCapability.cudaAtomicCapabilityScalar64{{endif}} - {{if 'cudaAtomicCapabilityScalar128' in found_values}} - cudaAtomicCapabilityScalar128 = cyruntime.cudaAtomicOperationCapability.cudaAtomicCapabilityScalar128{{endif}} - {{if 'cudaAtomicCapabilityVector32x4' in found_values}} - cudaAtomicCapabilityVector32x4 = cyruntime.cudaAtomicOperationCapability.cudaAtomicCapabilityVector32x4{{endif}} - -{{endif}} -{{if 'cudaExternalMemoryHandleType' in found_types}} + + cudaAtomicCapabilitySigned = cyruntime.cudaAtomicOperationCapability.cudaAtomicCapabilitySigned + + cudaAtomicCapabilityUnsigned = cyruntime.cudaAtomicOperationCapability.cudaAtomicCapabilityUnsigned + + cudaAtomicCapabilityReduction = cyruntime.cudaAtomicOperationCapability.cudaAtomicCapabilityReduction + + cudaAtomicCapabilityScalar32 = cyruntime.cudaAtomicOperationCapability.cudaAtomicCapabilityScalar32 + + cudaAtomicCapabilityScalar64 = cyruntime.cudaAtomicOperationCapability.cudaAtomicCapabilityScalar64 + + cudaAtomicCapabilityScalar128 = cyruntime.cudaAtomicOperationCapability.cudaAtomicCapabilityScalar128 + + cudaAtomicCapabilityVector32x4 = cyruntime.cudaAtomicOperationCapability.cudaAtomicCapabilityVector32x4 class cudaExternalMemoryHandleType(_FastEnum): """ External memory handle types """ - {{if 'cudaExternalMemoryHandleTypeOpaqueFd' in found_values}} + cudaExternalMemoryHandleTypeOpaqueFd = ( cyruntime.cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeOpaqueFd, 'Handle is an opaque file descriptor\n' - ){{endif}} - {{if 'cudaExternalMemoryHandleTypeOpaqueWin32' in found_values}} + ) + cudaExternalMemoryHandleTypeOpaqueWin32 = ( cyruntime.cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeOpaqueWin32, 'Handle is an opaque shared NT handle\n' - ){{endif}} - {{if 'cudaExternalMemoryHandleTypeOpaqueWin32Kmt' in found_values}} + ) + cudaExternalMemoryHandleTypeOpaqueWin32Kmt = ( cyruntime.cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeOpaqueWin32Kmt, 'Handle is an opaque, globally shared handle\n' - ){{endif}} - {{if 'cudaExternalMemoryHandleTypeD3D12Heap' in found_values}} + ) + cudaExternalMemoryHandleTypeD3D12Heap = ( cyruntime.cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeD3D12Heap, 'Handle is a D3D12 heap object\n' - ){{endif}} - {{if 'cudaExternalMemoryHandleTypeD3D12Resource' in found_values}} + ) + cudaExternalMemoryHandleTypeD3D12Resource = ( cyruntime.cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeD3D12Resource, 'Handle is a D3D12 committed resource\n' - ){{endif}} - {{if 'cudaExternalMemoryHandleTypeD3D11Resource' in found_values}} + ) + cudaExternalMemoryHandleTypeD3D11Resource = ( cyruntime.cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeD3D11Resource, 'Handle is a shared NT handle to a D3D11 resource\n' - ){{endif}} - {{if 'cudaExternalMemoryHandleTypeD3D11ResourceKmt' in found_values}} + ) + cudaExternalMemoryHandleTypeD3D11ResourceKmt = ( cyruntime.cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeD3D11ResourceKmt, 'Handle is a globally shared handle to a D3D11 resource\n' - ){{endif}} - {{if 'cudaExternalMemoryHandleTypeNvSciBuf' in found_values}} + ) + cudaExternalMemoryHandleTypeNvSciBuf = ( cyruntime.cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeNvSciBuf, 'Handle is an NvSciBuf object\n' - ){{endif}} - -{{endif}} -{{if 'cudaExternalSemaphoreHandleType' in found_types}} + ) class cudaExternalSemaphoreHandleType(_FastEnum): """ External semaphore handle types """ - {{if 'cudaExternalSemaphoreHandleTypeOpaqueFd' in found_values}} + cudaExternalSemaphoreHandleTypeOpaqueFd = ( cyruntime.cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeOpaqueFd, 'Handle is an opaque file descriptor\n' - ){{endif}} - {{if 'cudaExternalSemaphoreHandleTypeOpaqueWin32' in found_values}} + ) + cudaExternalSemaphoreHandleTypeOpaqueWin32 = ( cyruntime.cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeOpaqueWin32, 'Handle is an opaque shared NT handle\n' - ){{endif}} - {{if 'cudaExternalSemaphoreHandleTypeOpaqueWin32Kmt' in found_values}} + ) + cudaExternalSemaphoreHandleTypeOpaqueWin32Kmt = ( cyruntime.cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeOpaqueWin32Kmt, 'Handle is an opaque, globally shared handle\n' - ){{endif}} - {{if 'cudaExternalSemaphoreHandleTypeD3D12Fence' in found_values}} + ) + cudaExternalSemaphoreHandleTypeD3D12Fence = ( cyruntime.cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeD3D12Fence, 'Handle is a shared NT handle referencing a D3D12 fence object\n' - ){{endif}} - {{if 'cudaExternalSemaphoreHandleTypeD3D11Fence' in found_values}} + ) + cudaExternalSemaphoreHandleTypeD3D11Fence = ( cyruntime.cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeD3D11Fence, 'Handle is a shared NT handle referencing a D3D11 fence object\n' - ){{endif}} - {{if 'cudaExternalSemaphoreHandleTypeNvSciSync' in found_values}} + ) + cudaExternalSemaphoreHandleTypeNvSciSync = ( cyruntime.cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeNvSciSync, 'Opaque handle to NvSciSync Object\n' - ){{endif}} - {{if 'cudaExternalSemaphoreHandleTypeKeyedMutex' in found_values}} + ) + cudaExternalSemaphoreHandleTypeKeyedMutex = ( cyruntime.cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeKeyedMutex, 'Handle is a shared NT handle referencing a D3D11 keyed mutex object\n' - ){{endif}} - {{if 'cudaExternalSemaphoreHandleTypeKeyedMutexKmt' in found_values}} + ) + cudaExternalSemaphoreHandleTypeKeyedMutexKmt = ( cyruntime.cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeKeyedMutexKmt, 'Handle is a shared KMT handle referencing a D3D11 keyed mutex object\n' - ){{endif}} - {{if 'cudaExternalSemaphoreHandleTypeTimelineSemaphoreFd' in found_values}} + ) + cudaExternalSemaphoreHandleTypeTimelineSemaphoreFd = ( cyruntime.cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeTimelineSemaphoreFd, 'Handle is an opaque handle file descriptor referencing a timeline semaphore\n' - ){{endif}} - {{if 'cudaExternalSemaphoreHandleTypeTimelineSemaphoreWin32' in found_values}} + ) + cudaExternalSemaphoreHandleTypeTimelineSemaphoreWin32 = ( cyruntime.cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeTimelineSemaphoreWin32, 'Handle is an opaque handle file descriptor referencing a timeline semaphore\n' - ){{endif}} - -{{endif}} -{{if 'cudaDevSmResourceGroup_flags' in found_types}} + ) class cudaDevSmResourceGroup_flags(_FastEnum): """ Flags for a CUdevSmResource group """ - {{if 'cudaDevSmResourceGroupDefault' in found_values}} - cudaDevSmResourceGroupDefault = cyruntime.cudaDevSmResourceGroup_flags.cudaDevSmResourceGroupDefault{{endif}} - {{if 'cudaDevSmResourceGroupBackfill' in found_values}} + + cudaDevSmResourceGroupDefault = cyruntime.cudaDevSmResourceGroup_flags.cudaDevSmResourceGroupDefault + cudaDevSmResourceGroupBackfill = ( cyruntime.cudaDevSmResourceGroup_flags.cudaDevSmResourceGroupBackfill, 'Lets smCount be a non-multiple of minCoscheduledCount, filling the\n' 'difference with other SMs.\n' - ){{endif}} - -{{endif}} -{{if 'cudaDevSmResourceSplitByCount_flags' in found_types}} + ) class cudaDevSmResourceSplitByCount_flags(_FastEnum): """ """ - {{if 'cudaDevSmResourceSplitIgnoreSmCoscheduling' in found_values}} - cudaDevSmResourceSplitIgnoreSmCoscheduling = cyruntime.cudaDevSmResourceSplitByCount_flags.cudaDevSmResourceSplitIgnoreSmCoscheduling{{endif}} - {{if 'cudaDevSmResourceSplitMaxPotentialClusterSize' in found_values}} - cudaDevSmResourceSplitMaxPotentialClusterSize = cyruntime.cudaDevSmResourceSplitByCount_flags.cudaDevSmResourceSplitMaxPotentialClusterSize{{endif}} -{{endif}} -{{if 'cudaDevResourceType' in found_types}} + cudaDevSmResourceSplitIgnoreSmCoscheduling = cyruntime.cudaDevSmResourceSplitByCount_flags.cudaDevSmResourceSplitIgnoreSmCoscheduling + + cudaDevSmResourceSplitMaxPotentialClusterSize = cyruntime.cudaDevSmResourceSplitByCount_flags.cudaDevSmResourceSplitMaxPotentialClusterSize class cudaDevResourceType(_FastEnum): """ Type of resource """ - {{if 'cudaDevResourceTypeInvalid' in found_values}} - cudaDevResourceTypeInvalid = cyruntime.cudaDevResourceType.cudaDevResourceTypeInvalid{{endif}} - {{if 'cudaDevResourceTypeSm' in found_values}} + + cudaDevResourceTypeInvalid = cyruntime.cudaDevResourceType.cudaDevResourceTypeInvalid + cudaDevResourceTypeSm = ( cyruntime.cudaDevResourceType.cudaDevResourceTypeSm, 'Streaming multiprocessors related information\n' - ){{endif}} - {{if 'cudaDevResourceTypeWorkqueueConfig' in found_values}} + ) + cudaDevResourceTypeWorkqueueConfig = ( cyruntime.cudaDevResourceType.cudaDevResourceTypeWorkqueueConfig, 'Workqueue configuration related information\n' - ){{endif}} - {{if 'cudaDevResourceTypeWorkqueue' in found_values}} + ) + cudaDevResourceTypeWorkqueue = ( cyruntime.cudaDevResourceType.cudaDevResourceTypeWorkqueue, 'Pre-existing workqueue related information\n' - ){{endif}} - -{{endif}} -{{if 'cudaDevWorkqueueConfigScope' in found_types}} + ) class cudaDevWorkqueueConfigScope(_FastEnum): """ Sharing scope for workqueues """ - {{if 'cudaDevWorkqueueConfigScopeDeviceCtx' in found_values}} + cudaDevWorkqueueConfigScopeDeviceCtx = ( cyruntime.cudaDevWorkqueueConfigScope.cudaDevWorkqueueConfigScopeDeviceCtx, 'Use all shared workqueue resources on the device. Default driver behaviour.\n' - ){{endif}} - {{if 'cudaDevWorkqueueConfigScopeGreenCtxBalanced' in found_values}} + ) + cudaDevWorkqueueConfigScopeGreenCtxBalanced = ( cyruntime.cudaDevWorkqueueConfigScope.cudaDevWorkqueueConfigScopeGreenCtxBalanced, 'When possible, use non-overlapping workqueue resources with other balanced\n' 'green contexts.\n' - ){{endif}} - -{{endif}} -{{if 'cudaJitOption' in found_types}} + ) class cudaJitOption(_FastEnum): """ Online compiler and linker options """ - {{if 'cudaJitMaxRegisters' in found_values}} + cudaJitMaxRegisters = ( cyruntime.cudaJitOption.cudaJitMaxRegisters, 'Max number of registers that a thread may use.\n' 'Option type: unsigned int\n' 'Applies to: compiler only\n' - ){{endif}} - {{if 'cudaJitThreadsPerBlock' in found_values}} + ) + cudaJitThreadsPerBlock = ( cyruntime.cudaJitOption.cudaJitThreadsPerBlock, @@ -5720,8 +5520,8 @@ class cudaJitOption(_FastEnum): 'utilization.\n' 'Option type: unsigned int\n' 'Applies to: compiler only\n' - ){{endif}} - {{if 'cudaJitWallTime' in found_values}} + ) + cudaJitWallTime = ( cyruntime.cudaJitOption.cudaJitWallTime, @@ -5729,8 +5529,8 @@ class cudaJitOption(_FastEnum): 'milliseconds, spent in the compiler and linker\n' 'Option type: float\n' 'Applies to: compiler and linker\n' - ){{endif}} - {{if 'cudaJitInfoLogBuffer' in found_values}} + ) + cudaJitInfoLogBuffer = ( cyruntime.cudaJitOption.cudaJitInfoLogBuffer, @@ -5739,8 +5539,8 @@ class cudaJitOption(_FastEnum): ':py:obj:`~.cudaJitInfoLogBufferSizeBytes`)\n' 'Option type: char *\n' 'Applies to: compiler and linker\n' - ){{endif}} - {{if 'cudaJitInfoLogBufferSizeBytes' in found_values}} + ) + cudaJitInfoLogBufferSizeBytes = ( cyruntime.cudaJitOption.cudaJitInfoLogBufferSizeBytes, @@ -5749,8 +5549,8 @@ class cudaJitOption(_FastEnum): 'OUT: Amount of log buffer filled with messages\n' 'Option type: unsigned int\n' 'Applies to: compiler and linker\n' - ){{endif}} - {{if 'cudaJitErrorLogBuffer' in found_values}} + ) + cudaJitErrorLogBuffer = ( cyruntime.cudaJitOption.cudaJitErrorLogBuffer, @@ -5759,8 +5559,8 @@ class cudaJitOption(_FastEnum): ':py:obj:`~.cudaJitErrorLogBufferSizeBytes`)\n' 'Option type: char *\n' 'Applies to: compiler and linker\n' - ){{endif}} - {{if 'cudaJitErrorLogBufferSizeBytes' in found_values}} + ) + cudaJitErrorLogBufferSizeBytes = ( cyruntime.cudaJitOption.cudaJitErrorLogBufferSizeBytes, @@ -5769,8 +5569,8 @@ class cudaJitOption(_FastEnum): 'OUT: Amount of log buffer filled with messages\n' 'Option type: unsigned int\n' 'Applies to: compiler and linker\n' - ){{endif}} - {{if 'cudaJitOptimizationLevel' in found_values}} + ) + cudaJitOptimizationLevel = ( cyruntime.cudaJitOption.cudaJitOptimizationLevel, @@ -5778,8 +5578,8 @@ class cudaJitOption(_FastEnum): 'default and highest level of optimizations.\n' 'Option type: unsigned int\n' 'Applies to: compiler only\n' - ){{endif}} - {{if 'cudaJitFallbackStrategy' in found_values}} + ) + cudaJitFallbackStrategy = ( cyruntime.cudaJitOption.cudaJitFallbackStrategy, @@ -5787,8 +5587,8 @@ class cudaJitOption(_FastEnum): 'Choice is based on supplied :py:obj:`~.cudaJit_Fallback`. Option type:\n' 'unsigned int for enumerated type :py:obj:`~.cudaJit_Fallback`\n' 'Applies to: compiler only\n' - ){{endif}} - {{if 'cudaJitGenerateDebugInfo' in found_values}} + ) + cudaJitGenerateDebugInfo = ( cyruntime.cudaJitOption.cudaJitGenerateDebugInfo, @@ -5796,24 +5596,24 @@ class cudaJitOption(_FastEnum): 'default)\n' 'Option type: int\n' 'Applies to: compiler and linker\n' - ){{endif}} - {{if 'cudaJitLogVerbose' in found_values}} + ) + cudaJitLogVerbose = ( cyruntime.cudaJitOption.cudaJitLogVerbose, 'Generate verbose log messages (0: false, default)\n' 'Option type: int\n' 'Applies to: compiler and linker\n' - ){{endif}} - {{if 'cudaJitGenerateLineInfo' in found_values}} + ) + cudaJitGenerateLineInfo = ( cyruntime.cudaJitOption.cudaJitGenerateLineInfo, 'Generate line number information (-lineinfo) (0: false, default)\n' 'Option type: int\n' 'Applies to: compiler only\n' - ){{endif}} - {{if 'cudaJitCacheMode' in found_values}} + ) + cudaJitCacheMode = ( cyruntime.cudaJitOption.cudaJitCacheMode, @@ -5821,16 +5621,16 @@ class cudaJitOption(_FastEnum): 'Choice is based on supplied :py:obj:`~.cudaJit_CacheMode`.\n' 'Option type: unsigned int for enumerated type :py:obj:`~.cudaJit_CacheMode`\n' 'Applies to: compiler only\n' - ){{endif}} - {{if 'cudaJitPositionIndependentCode' in found_values}} + ) + cudaJitPositionIndependentCode = ( cyruntime.cudaJitOption.cudaJitPositionIndependentCode, 'Generate position independent code (0: false)\n' 'Option type: int\n' 'Applies to: compiler only\n' - ){{endif}} - {{if 'cudaJitMinCtaPerSm' in found_values}} + ) + cudaJitMinCtaPerSm = ( cyruntime.cudaJitOption.cudaJitMinCtaPerSm, @@ -5843,8 +5643,8 @@ class cudaJitOption(_FastEnum): 'default. Use :py:obj:`~.cudaJitOverrideDirectiveValues` to let this option\n' 'take precedence over the PTX directive. Option type: unsigned int\n' 'Applies to: compiler only\n' - ){{endif}} - {{if 'cudaJitMaxThreadsPerBlock' in found_values}} + ) + cudaJitMaxThreadsPerBlock = ( cyruntime.cudaJitOption.cudaJitMaxThreadsPerBlock, @@ -5856,8 +5656,8 @@ class cudaJitOption(_FastEnum): 'be ignored by default. Use :py:obj:`~.cudaJitOverrideDirectiveValues` to\n' 'let this option take precedence over the PTX directive. Option type: int\n' 'Applies to: compiler only\n' - ){{endif}} - {{if 'cudaJitOverrideDirectiveValues' in found_values}} + ) + cudaJitOverrideDirectiveValues = ( cyruntime.cudaJitOption.cudaJitOverrideDirectiveValues, @@ -5867,10 +5667,7 @@ class cudaJitOption(_FastEnum): 'take precedence over any PTX directives. (0: Disable, default; 1: Enable)\n' 'Option type: int\n' 'Applies to: compiler only\n' - ){{endif}} - -{{endif}} -{{if 'cudaLibraryOption' in found_types}} + ) class cudaLibraryOption(_FastEnum): """ @@ -5878,9 +5675,9 @@ class cudaLibraryOption(_FastEnum): :py:obj:`~.cudaLibraryLoadData()` or :py:obj:`~.cudaLibraryLoadFromFile()` """ - {{if 'cudaLibraryHostUniversalFunctionAndDataTable' in found_values}} - cudaLibraryHostUniversalFunctionAndDataTable = cyruntime.cudaLibraryOption.cudaLibraryHostUniversalFunctionAndDataTable{{endif}} - {{if 'cudaLibraryBinaryIsPreserved' in found_values}} + + cudaLibraryHostUniversalFunctionAndDataTable = cyruntime.cudaLibraryOption.cudaLibraryHostUniversalFunctionAndDataTable + cudaLibraryBinaryIsPreserved = ( cyruntime.cudaLibraryOption.cudaLibraryBinaryIsPreserved, @@ -5892,238 +5689,217 @@ class cudaLibraryOption(_FastEnum): 'memory usage optimization hint and the driver can choose to ignore it if\n' 'required. Specifying this option with :py:obj:`~.cudaLibraryLoadFromFile()`\n' 'is invalid and will return :py:obj:`~.cudaErrorInvalidValue`.\n' - ){{endif}} - -{{endif}} -{{if 'cudaJit_CacheMode' in found_types}} + ) class cudaJit_CacheMode(_FastEnum): """ Caching modes for dlcm """ - {{if 'cudaJitCacheOptionNone' in found_values}} + cudaJitCacheOptionNone = ( cyruntime.cudaJit_CacheMode.cudaJitCacheOptionNone, 'Compile with no -dlcm flag specified\n' - ){{endif}} - {{if 'cudaJitCacheOptionCG' in found_values}} + ) + cudaJitCacheOptionCG = ( cyruntime.cudaJit_CacheMode.cudaJitCacheOptionCG, 'Compile with L1 cache disabled\n' - ){{endif}} - {{if 'cudaJitCacheOptionCA' in found_values}} + ) + cudaJitCacheOptionCA = ( cyruntime.cudaJit_CacheMode.cudaJitCacheOptionCA, 'Compile with L1 cache enabled\n' - ){{endif}} - -{{endif}} -{{if 'cudaJit_Fallback' in found_types}} + ) class cudaJit_Fallback(_FastEnum): """ Cubin matching fallback strategies """ - {{if 'cudaPreferPtx' in found_values}} + cudaPreferPtx = ( cyruntime.cudaJit_Fallback.cudaPreferPtx, 'Prefer to compile ptx if exact binary match not found\n' - ){{endif}} - {{if 'cudaPreferBinary' in found_values}} + ) + cudaPreferBinary = ( cyruntime.cudaJit_Fallback.cudaPreferBinary, 'Prefer to fall back to compatible binary code if exact match not found\n' - ){{endif}} - -{{endif}} -{{if 'cudaCGScope' in found_types}} + ) class cudaCGScope(_FastEnum): """ CUDA cooperative group scope """ - {{if 'cudaCGScopeInvalid' in found_values}} + cudaCGScopeInvalid = ( cyruntime.cudaCGScope.cudaCGScopeInvalid, 'Invalid cooperative group scope\n' - ){{endif}} - {{if 'cudaCGScopeGrid' in found_values}} + ) + cudaCGScopeGrid = ( cyruntime.cudaCGScope.cudaCGScopeGrid, 'Scope represented by a grid_group\n' - ){{endif}} - {{if 'cudaCGScopeReserved' in found_values}} + ) + cudaCGScopeReserved = ( cyruntime.cudaCGScope.cudaCGScopeReserved, 'Reserved\n' - ){{endif}} - -{{endif}} -{{if 'cudaKernelFunctionType' in found_types}} + ) class cudaKernelFunctionType(_FastEnum): """ CUDA Kernel Function Handle Type """ - {{if 'cudaKernelFunctionTypeUnspecified' in found_values}} + cudaKernelFunctionTypeUnspecified = ( cyruntime.cudaKernelFunctionType.cudaKernelFunctionTypeUnspecified, 'CUDA will attempt to deduce the type of the function handle\n' - ){{endif}} - {{if 'cudaKernelFunctionTypeDeviceEntry' in found_values}} + ) + cudaKernelFunctionTypeDeviceEntry = ( cyruntime.cudaKernelFunctionType.cudaKernelFunctionTypeDeviceEntry, 'Function handle is a device-entry function pointer(i.e. global function\n' 'pointer)\n' - ){{endif}} - {{if 'cudaKernelFunctionTypeKernel' in found_values}} + ) + cudaKernelFunctionTypeKernel = ( cyruntime.cudaKernelFunctionType.cudaKernelFunctionTypeKernel, 'Function handle is a :py:obj:`~.cudaKernel_t`\n' - ){{endif}} - {{if 'cudaKernelFunctionTypeFunction' in found_values}} + ) + cudaKernelFunctionTypeFunction = ( cyruntime.cudaKernelFunctionType.cudaKernelFunctionTypeFunction, 'Function handle is a :py:obj:`~.cudaFunction_t`\n' - ){{endif}} - -{{endif}} -{{if 'cudaGraphConditionalHandleFlags' in found_types}} + ) class cudaGraphConditionalHandleFlags(_FastEnum): """ """ - {{if 'cudaGraphCondAssignDefault' in found_values}} + cudaGraphCondAssignDefault = ( cyruntime.cudaGraphConditionalHandleFlags.cudaGraphCondAssignDefault, 'Apply default handle value when graph is launched.\n' - ){{endif}} - -{{endif}} -{{if 'cudaGraphConditionalNodeType' in found_types}} + ) class cudaGraphConditionalNodeType(_FastEnum): """ CUDA conditional node types """ - {{if 'cudaGraphCondTypeIf' in found_values}} + cudaGraphCondTypeIf = ( cyruntime.cudaGraphConditionalNodeType.cudaGraphCondTypeIf, "Conditional 'if/else' Node. Body[0] executed if condition is non-zero. If\n" '`size` == 2, an optional ELSE graph is created and this is executed if the\n' 'condition is zero.\n' - ){{endif}} - {{if 'cudaGraphCondTypeWhile' in found_values}} + ) + cudaGraphCondTypeWhile = ( cyruntime.cudaGraphConditionalNodeType.cudaGraphCondTypeWhile, "Conditional 'while' Node. Body executed repeatedly while condition value is\n" 'non-zero.\n' - ){{endif}} - {{if 'cudaGraphCondTypeSwitch' in found_values}} + ) + cudaGraphCondTypeSwitch = ( cyruntime.cudaGraphConditionalNodeType.cudaGraphCondTypeSwitch, "Conditional 'switch' Node. Body[n] is executed once, where 'n' is the value\n" 'of the condition. If the condition does not match a body index, no body is\n' 'launched.\n' - ){{endif}} - -{{endif}} -{{if 'cudaGraphNodeType' in found_types}} + ) class cudaGraphNodeType(_FastEnum): """ CUDA Graph node types """ - {{if 'cudaGraphNodeTypeKernel' in found_values}} + cudaGraphNodeTypeKernel = ( cyruntime.cudaGraphNodeType.cudaGraphNodeTypeKernel, 'GPU kernel node\n' - ){{endif}} - {{if 'cudaGraphNodeTypeMemcpy' in found_values}} + ) + cudaGraphNodeTypeMemcpy = ( cyruntime.cudaGraphNodeType.cudaGraphNodeTypeMemcpy, 'Memcpy node\n' - ){{endif}} - {{if 'cudaGraphNodeTypeMemset' in found_values}} + ) + cudaGraphNodeTypeMemset = ( cyruntime.cudaGraphNodeType.cudaGraphNodeTypeMemset, 'Memset node\n' - ){{endif}} - {{if 'cudaGraphNodeTypeHost' in found_values}} + ) + cudaGraphNodeTypeHost = ( cyruntime.cudaGraphNodeType.cudaGraphNodeTypeHost, 'Host (executable) node\n' - ){{endif}} - {{if 'cudaGraphNodeTypeGraph' in found_values}} + ) + cudaGraphNodeTypeGraph = ( cyruntime.cudaGraphNodeType.cudaGraphNodeTypeGraph, 'Node which executes an embedded graph\n' - ){{endif}} - {{if 'cudaGraphNodeTypeEmpty' in found_values}} + ) + cudaGraphNodeTypeEmpty = ( cyruntime.cudaGraphNodeType.cudaGraphNodeTypeEmpty, 'Empty (no-op) node\n' - ){{endif}} - {{if 'cudaGraphNodeTypeWaitEvent' in found_values}} + ) + cudaGraphNodeTypeWaitEvent = ( cyruntime.cudaGraphNodeType.cudaGraphNodeTypeWaitEvent, 'External event wait node\n' - ){{endif}} - {{if 'cudaGraphNodeTypeEventRecord' in found_values}} + ) + cudaGraphNodeTypeEventRecord = ( cyruntime.cudaGraphNodeType.cudaGraphNodeTypeEventRecord, 'External event record node\n' - ){{endif}} - {{if 'cudaGraphNodeTypeExtSemaphoreSignal' in found_values}} + ) + cudaGraphNodeTypeExtSemaphoreSignal = ( cyruntime.cudaGraphNodeType.cudaGraphNodeTypeExtSemaphoreSignal, 'External semaphore signal node\n' - ){{endif}} - {{if 'cudaGraphNodeTypeExtSemaphoreWait' in found_values}} + ) + cudaGraphNodeTypeExtSemaphoreWait = ( cyruntime.cudaGraphNodeType.cudaGraphNodeTypeExtSemaphoreWait, 'External semaphore wait node\n' - ){{endif}} - {{if 'cudaGraphNodeTypeMemAlloc' in found_values}} + ) + cudaGraphNodeTypeMemAlloc = ( cyruntime.cudaGraphNodeType.cudaGraphNodeTypeMemAlloc, 'Memory allocation node\n' - ){{endif}} - {{if 'cudaGraphNodeTypeMemFree' in found_values}} + ) + cudaGraphNodeTypeMemFree = ( cyruntime.cudaGraphNodeType.cudaGraphNodeTypeMemFree, 'Memory free node\n' - ){{endif}} - {{if 'cudaGraphNodeTypeConditional' in found_values}} + ) + cudaGraphNodeTypeConditional = ( cyruntime.cudaGraphNodeType.cudaGraphNodeTypeConditional, @@ -6149,39 +5925,36 @@ class cudaGraphNodeType(_FastEnum): 'default value when creating the handle and/or\n' ' call :py:obj:`~.cudaGraphSetConditional`\n' 'from device code.\n' - ){{endif}} - {{if 'cudaGraphNodeTypeReserved16' in found_values}} + ) + cudaGraphNodeTypeReserved16 = ( cyruntime.cudaGraphNodeType.cudaGraphNodeTypeReserved16, 'Reserved.\n' - ){{endif}} - {{if 'cudaGraphNodeTypeCount' in found_values}} - cudaGraphNodeTypeCount = cyruntime.cudaGraphNodeType.cudaGraphNodeTypeCount{{endif}} + ) -{{endif}} -{{if 'cudaGraphChildGraphNodeOwnership' in found_types}} + cudaGraphNodeTypeCount = cyruntime.cudaGraphNodeType.cudaGraphNodeTypeCount class cudaGraphChildGraphNodeOwnership(_FastEnum): """ Child graph node ownership """ - {{if 'cudaGraphChildGraphOwnershipInvalid' in found_values}} + cudaGraphChildGraphOwnershipInvalid = ( cyruntime.cudaGraphChildGraphNodeOwnership.cudaGraphChildGraphOwnershipInvalid, 'Invalid ownership flag. Set when params are queried to prevent accidentally\n' 'reusing the driver-owned graph object\n' - ){{endif}} - {{if 'cudaGraphChildGraphOwnershipClone' in found_values}} + ) + cudaGraphChildGraphOwnershipClone = ( cyruntime.cudaGraphChildGraphNodeOwnership.cudaGraphChildGraphOwnershipClone, 'Default behavior for a child graph node. Child graph is cloned into the\n' "parent and memory allocation/free nodes can't be present in the child\n" 'graph.\n' - ){{endif}} - {{if 'cudaGraphChildGraphOwnershipMove' in found_values}} + ) + cudaGraphChildGraphOwnershipMove = ( cyruntime.cudaGraphChildGraphNodeOwnership.cudaGraphChildGraphOwnershipMove, @@ -6192,110 +5965,101 @@ class cudaGraphChildGraphNodeOwnership(_FastEnum): 'as a child graph of a separate parent graph; Cannot be used as an argument\n' 'to cudaGraphExecUpdate; Cannot have additional memory allocation or free\n' 'nodes added.\n' - ){{endif}} - -{{endif}} -{{if 'cudaGraphExecUpdateResult' in found_types}} + ) class cudaGraphExecUpdateResult(_FastEnum): """ CUDA Graph Update error types """ - {{if 'cudaGraphExecUpdateSuccess' in found_values}} + cudaGraphExecUpdateSuccess = ( cyruntime.cudaGraphExecUpdateResult.cudaGraphExecUpdateSuccess, 'The update succeeded\n' - ){{endif}} - {{if 'cudaGraphExecUpdateError' in found_values}} + ) + cudaGraphExecUpdateError = ( cyruntime.cudaGraphExecUpdateResult.cudaGraphExecUpdateError, 'The update failed for an unexpected reason which is described in the return\n' 'value of the function\n' - ){{endif}} - {{if 'cudaGraphExecUpdateErrorTopologyChanged' in found_values}} + ) + cudaGraphExecUpdateErrorTopologyChanged = ( cyruntime.cudaGraphExecUpdateResult.cudaGraphExecUpdateErrorTopologyChanged, 'The update failed because the topology changed\n' - ){{endif}} - {{if 'cudaGraphExecUpdateErrorNodeTypeChanged' in found_values}} + ) + cudaGraphExecUpdateErrorNodeTypeChanged = ( cyruntime.cudaGraphExecUpdateResult.cudaGraphExecUpdateErrorNodeTypeChanged, 'The update failed because a node type changed\n' - ){{endif}} - {{if 'cudaGraphExecUpdateErrorFunctionChanged' in found_values}} + ) + cudaGraphExecUpdateErrorFunctionChanged = ( cyruntime.cudaGraphExecUpdateResult.cudaGraphExecUpdateErrorFunctionChanged, 'The update failed because the function of a kernel node changed (CUDA\n' 'driver < 11.2)\n' - ){{endif}} - {{if 'cudaGraphExecUpdateErrorParametersChanged' in found_values}} + ) + cudaGraphExecUpdateErrorParametersChanged = ( cyruntime.cudaGraphExecUpdateResult.cudaGraphExecUpdateErrorParametersChanged, 'The update failed because the parameters changed in a way that is not\n' 'supported\n' - ){{endif}} - {{if 'cudaGraphExecUpdateErrorNotSupported' in found_values}} + ) + cudaGraphExecUpdateErrorNotSupported = ( cyruntime.cudaGraphExecUpdateResult.cudaGraphExecUpdateErrorNotSupported, 'The update failed because something about the node is not supported\n' - ){{endif}} - {{if 'cudaGraphExecUpdateErrorUnsupportedFunctionChange' in found_values}} + ) + cudaGraphExecUpdateErrorUnsupportedFunctionChange = ( cyruntime.cudaGraphExecUpdateResult.cudaGraphExecUpdateErrorUnsupportedFunctionChange, 'The update failed because the function of a kernel node changed in an\n' 'unsupported way\n' - ){{endif}} - {{if 'cudaGraphExecUpdateErrorAttributesChanged' in found_values}} + ) + cudaGraphExecUpdateErrorAttributesChanged = ( cyruntime.cudaGraphExecUpdateResult.cudaGraphExecUpdateErrorAttributesChanged, 'The update failed because the node attributes changed in a way that is not\n' 'supported\n' - ){{endif}} - -{{endif}} -{{if 'cudaGraphKernelNodeField' in found_types}} + ) class cudaGraphKernelNodeField(_FastEnum): """ Specifies the field to update when performing multiple node updates from the device """ - {{if 'cudaGraphKernelNodeFieldInvalid' in found_values}} + cudaGraphKernelNodeFieldInvalid = ( cyruntime.cudaGraphKernelNodeField.cudaGraphKernelNodeFieldInvalid, 'Invalid field\n' - ){{endif}} - {{if 'cudaGraphKernelNodeFieldGridDim' in found_values}} + ) + cudaGraphKernelNodeFieldGridDim = ( cyruntime.cudaGraphKernelNodeField.cudaGraphKernelNodeFieldGridDim, 'Grid dimension update\n' - ){{endif}} - {{if 'cudaGraphKernelNodeFieldParam' in found_values}} + ) + cudaGraphKernelNodeFieldParam = ( cyruntime.cudaGraphKernelNodeField.cudaGraphKernelNodeFieldParam, 'Kernel parameter update\n' - ){{endif}} - {{if 'cudaGraphKernelNodeFieldEnabled' in found_values}} + ) + cudaGraphKernelNodeFieldEnabled = ( cyruntime.cudaGraphKernelNodeField.cudaGraphKernelNodeFieldEnabled, 'Node enable/disable\n' - ){{endif}} - -{{endif}} -{{if 'cudaGetDriverEntryPointFlags' in found_types}} + ) class cudaGetDriverEntryPointFlags(_FastEnum): """ @@ -6303,140 +6067,131 @@ class cudaGetDriverEntryPointFlags(_FastEnum): :py:obj:`~.cudaGetDriverEntryPoint` For more details see :py:obj:`~.cuGetProcAddress` """ - {{if 'cudaEnableDefault' in found_values}} + cudaEnableDefault = ( cyruntime.cudaGetDriverEntryPointFlags.cudaEnableDefault, 'Default search mode for driver symbols.\n' - ){{endif}} - {{if 'cudaEnableLegacyStream' in found_values}} + ) + cudaEnableLegacyStream = ( cyruntime.cudaGetDriverEntryPointFlags.cudaEnableLegacyStream, 'Search for legacy versions of driver symbols.\n' - ){{endif}} - {{if 'cudaEnablePerThreadDefaultStream' in found_values}} + ) + cudaEnablePerThreadDefaultStream = ( cyruntime.cudaGetDriverEntryPointFlags.cudaEnablePerThreadDefaultStream, 'Search for per-thread versions of driver symbols.\n' - ){{endif}} - -{{endif}} -{{if 'cudaDriverEntryPointQueryResult' in found_types}} + ) class cudaDriverEntryPointQueryResult(_FastEnum): """ Enum for status from obtaining driver entry points, used with :py:obj:`~.cudaApiGetDriverEntryPoint` """ - {{if 'cudaDriverEntryPointSuccess' in found_values}} + cudaDriverEntryPointSuccess = ( cyruntime.cudaDriverEntryPointQueryResult.cudaDriverEntryPointSuccess, 'Search for symbol found a match\n' - ){{endif}} - {{if 'cudaDriverEntryPointSymbolNotFound' in found_values}} + ) + cudaDriverEntryPointSymbolNotFound = ( cyruntime.cudaDriverEntryPointQueryResult.cudaDriverEntryPointSymbolNotFound, 'Search for symbol was not found\n' - ){{endif}} - {{if 'cudaDriverEntryPointVersionNotSufficent' in found_values}} + ) + cudaDriverEntryPointVersionNotSufficent = ( cyruntime.cudaDriverEntryPointQueryResult.cudaDriverEntryPointVersionNotSufficent, "Search for symbol was found but version wasn't great enough\n" - ){{endif}} - -{{endif}} -{{if 'cudaGraphDebugDotFlags' in found_types}} + ) class cudaGraphDebugDotFlags(_FastEnum): """ CUDA Graph debug write options """ - {{if 'cudaGraphDebugDotFlagsVerbose' in found_values}} + cudaGraphDebugDotFlagsVerbose = ( cyruntime.cudaGraphDebugDotFlags.cudaGraphDebugDotFlagsVerbose, 'Output all debug data as if every debug flag is enabled\n' - ){{endif}} - {{if 'cudaGraphDebugDotFlagsKernelNodeParams' in found_values}} + ) + cudaGraphDebugDotFlagsKernelNodeParams = ( cyruntime.cudaGraphDebugDotFlags.cudaGraphDebugDotFlagsKernelNodeParams, 'Adds :py:obj:`~.cudaKernelNodeParams` to output\n' - ){{endif}} - {{if 'cudaGraphDebugDotFlagsMemcpyNodeParams' in found_values}} + ) + cudaGraphDebugDotFlagsMemcpyNodeParams = ( cyruntime.cudaGraphDebugDotFlags.cudaGraphDebugDotFlagsMemcpyNodeParams, 'Adds :py:obj:`~.cudaMemcpy3DParms` to output\n' - ){{endif}} - {{if 'cudaGraphDebugDotFlagsMemsetNodeParams' in found_values}} + ) + cudaGraphDebugDotFlagsMemsetNodeParams = ( cyruntime.cudaGraphDebugDotFlags.cudaGraphDebugDotFlagsMemsetNodeParams, 'Adds :py:obj:`~.cudaMemsetParams` to output\n' - ){{endif}} - {{if 'cudaGraphDebugDotFlagsHostNodeParams' in found_values}} + ) + cudaGraphDebugDotFlagsHostNodeParams = ( cyruntime.cudaGraphDebugDotFlags.cudaGraphDebugDotFlagsHostNodeParams, 'Adds :py:obj:`~.cudaHostNodeParams` to output\n' - ){{endif}} - {{if 'cudaGraphDebugDotFlagsEventNodeParams' in found_values}} + ) + cudaGraphDebugDotFlagsEventNodeParams = ( cyruntime.cudaGraphDebugDotFlags.cudaGraphDebugDotFlagsEventNodeParams, 'Adds :py:obj:`~.cudaEvent_t` handle from record and wait nodes to output\n' - ){{endif}} - {{if 'cudaGraphDebugDotFlagsExtSemasSignalNodeParams' in found_values}} + ) + cudaGraphDebugDotFlagsExtSemasSignalNodeParams = ( cyruntime.cudaGraphDebugDotFlags.cudaGraphDebugDotFlagsExtSemasSignalNodeParams, 'Adds :py:obj:`~.cudaExternalSemaphoreSignalNodeParams` values to output\n' - ){{endif}} - {{if 'cudaGraphDebugDotFlagsExtSemasWaitNodeParams' in found_values}} + ) + cudaGraphDebugDotFlagsExtSemasWaitNodeParams = ( cyruntime.cudaGraphDebugDotFlags.cudaGraphDebugDotFlagsExtSemasWaitNodeParams, 'Adds :py:obj:`~.cudaExternalSemaphoreWaitNodeParams` to output\n' - ){{endif}} - {{if 'cudaGraphDebugDotFlagsKernelNodeAttributes' in found_values}} + ) + cudaGraphDebugDotFlagsKernelNodeAttributes = ( cyruntime.cudaGraphDebugDotFlags.cudaGraphDebugDotFlagsKernelNodeAttributes, 'Adds cudaKernelNodeAttrID values to output\n' - ){{endif}} - {{if 'cudaGraphDebugDotFlagsHandles' in found_values}} + ) + cudaGraphDebugDotFlagsHandles = ( cyruntime.cudaGraphDebugDotFlags.cudaGraphDebugDotFlagsHandles, 'Adds node handles and every kernel function handle to output\n' - ){{endif}} - {{if 'cudaGraphDebugDotFlagsConditionalNodeParams' in found_values}} + ) + cudaGraphDebugDotFlagsConditionalNodeParams = ( cyruntime.cudaGraphDebugDotFlags.cudaGraphDebugDotFlagsConditionalNodeParams, 'Adds :py:obj:`~.cudaConditionalNodeParams` to output\n' - ){{endif}} - -{{endif}} -{{if 'cudaGraphInstantiateFlags' in found_types}} + ) class cudaGraphInstantiateFlags(_FastEnum): """ Flags for instantiating a graph """ - {{if 'cudaGraphInstantiateFlagAutoFreeOnLaunch' in found_values}} + cudaGraphInstantiateFlagAutoFreeOnLaunch = ( cyruntime.cudaGraphInstantiateFlags.cudaGraphInstantiateFlagAutoFreeOnLaunch, 'Automatically free memory allocated in a graph before relaunching.\n' - ){{endif}} - {{if 'cudaGraphInstantiateFlagUpload' in found_values}} + ) + cudaGraphInstantiateFlagUpload = ( cyruntime.cudaGraphInstantiateFlags.cudaGraphInstantiateFlagUpload, @@ -6444,316 +6199,277 @@ class cudaGraphInstantiateFlags(_FastEnum): ' :py:obj:`~.cudaGraphInstantiateWithParams`. The upload will be performed\n' 'using the\n' ' stream provided in `instantiateParams`.\n' - ){{endif}} - {{if 'cudaGraphInstantiateFlagDeviceLaunch' in found_values}} + ) + cudaGraphInstantiateFlagDeviceLaunch = ( cyruntime.cudaGraphInstantiateFlags.cudaGraphInstantiateFlagDeviceLaunch, 'Instantiate the graph to be launchable from the device. This flag can only\n' ' be used on platforms which support unified addressing. This flag cannot be\n' ' used in conjunction with cudaGraphInstantiateFlagAutoFreeOnLaunch.\n' - ){{endif}} - {{if 'cudaGraphInstantiateFlagUseNodePriority' in found_values}} + ) + cudaGraphInstantiateFlagUseNodePriority = ( cyruntime.cudaGraphInstantiateFlags.cudaGraphInstantiateFlagUseNodePriority, 'Run the graph using the per-node priority attributes rather than the\n' 'priority of the stream it is launched into.\n' - ){{endif}} - -{{endif}} -{{if 'cudaDeviceNumaConfig' in found_types}} + ) class cudaDeviceNumaConfig(_FastEnum): """ CUDA device NUMA config """ - {{if 'cudaDeviceNumaConfigNone' in found_values}} + cudaDeviceNumaConfigNone = ( cyruntime.cudaDeviceNumaConfig.cudaDeviceNumaConfigNone, 'The GPU is not a NUMA node\n' - ){{endif}} - {{if 'cudaDeviceNumaConfigNumaNode' in found_values}} + ) + cudaDeviceNumaConfigNumaNode = ( cyruntime.cudaDeviceNumaConfig.cudaDeviceNumaConfigNumaNode, 'The GPU is a NUMA node, cudaDevAttrNumaId contains its NUMA ID\n' - ){{endif}} - -{{endif}} -{{if 'cudaFabricOpStatusSource' in found_types}} + ) class cudaFabricOpStatusSource(_FastEnum): """ Fabric operation status source """ - {{if 'cudaFabricOpStatusSourceMbarrierV1' in found_values}} + cudaFabricOpStatusSourceMbarrierV1 = ( cyruntime.cudaFabricOpStatusSource.cudaFabricOpStatusSourceMbarrierV1, '1B-aligned 1B-wide status from an mbarrier.layout::v1\n' - ){{endif}} - {{if 'cudaFabricOpStatusSourceMax' in found_values}} - cudaFabricOpStatusSourceMax = cyruntime.cudaFabricOpStatusSource.cudaFabricOpStatusSourceMax{{endif}} + ) -{{endif}} -{{if 'cudaFabricOpStatusInfo' in found_types}} + cudaFabricOpStatusSourceMax = cyruntime.cudaFabricOpStatusSource.cudaFabricOpStatusSourceMax class cudaFabricOpStatusInfo(_FastEnum): """ Fabric operation status info """ - {{if 'cudaFabricOpStatusInfoSuccess' in found_values}} - cudaFabricOpStatusInfoSuccess = cyruntime.cudaFabricOpStatusInfo.cudaFabricOpStatusInfoSuccess{{endif}} - {{if 'cudaFabricOpStatusInfoLast' in found_values}} - cudaFabricOpStatusInfoLast = cyruntime.cudaFabricOpStatusInfo.cudaFabricOpStatusInfoLast{{endif}} - {{if 'cudaFabricOpStatusInfoMax' in found_values}} - cudaFabricOpStatusInfoMax = cyruntime.cudaFabricOpStatusInfo.cudaFabricOpStatusInfoMax{{endif}} -{{endif}} -{{if 'cudaSurfaceBoundaryMode' in found_types}} + cudaFabricOpStatusInfoSuccess = cyruntime.cudaFabricOpStatusInfo.cudaFabricOpStatusInfoSuccess + + cudaFabricOpStatusInfoLast = cyruntime.cudaFabricOpStatusInfo.cudaFabricOpStatusInfoLast + + cudaFabricOpStatusInfoMax = cyruntime.cudaFabricOpStatusInfo.cudaFabricOpStatusInfoMax class cudaSurfaceBoundaryMode(_FastEnum): """ CUDA Surface boundary modes """ - {{if 'cudaBoundaryModeZero' in found_values}} + cudaBoundaryModeZero = ( cyruntime.cudaSurfaceBoundaryMode.cudaBoundaryModeZero, 'Zero boundary mode\n' - ){{endif}} - {{if 'cudaBoundaryModeClamp' in found_values}} + ) + cudaBoundaryModeClamp = ( cyruntime.cudaSurfaceBoundaryMode.cudaBoundaryModeClamp, 'Clamp boundary mode\n' - ){{endif}} - {{if 'cudaBoundaryModeTrap' in found_values}} + ) + cudaBoundaryModeTrap = ( cyruntime.cudaSurfaceBoundaryMode.cudaBoundaryModeTrap, 'Trap boundary mode\n' - ){{endif}} - -{{endif}} -{{if 'cudaSurfaceFormatMode' in found_types}} + ) class cudaSurfaceFormatMode(_FastEnum): """ CUDA Surface format modes """ - {{if 'cudaFormatModeForced' in found_values}} + cudaFormatModeForced = ( cyruntime.cudaSurfaceFormatMode.cudaFormatModeForced, 'Forced format mode\n' - ){{endif}} - {{if 'cudaFormatModeAuto' in found_values}} + ) + cudaFormatModeAuto = ( cyruntime.cudaSurfaceFormatMode.cudaFormatModeAuto, 'Auto format mode\n' - ){{endif}} - -{{endif}} -{{if 'cudaTextureAddressMode' in found_types}} + ) class cudaTextureAddressMode(_FastEnum): """ CUDA texture address modes """ - {{if 'cudaAddressModeWrap' in found_values}} + cudaAddressModeWrap = ( cyruntime.cudaTextureAddressMode.cudaAddressModeWrap, 'Wrapping address mode\n' - ){{endif}} - {{if 'cudaAddressModeClamp' in found_values}} + ) + cudaAddressModeClamp = ( cyruntime.cudaTextureAddressMode.cudaAddressModeClamp, 'Clamp to edge address mode\n' - ){{endif}} - {{if 'cudaAddressModeMirror' in found_values}} + ) + cudaAddressModeMirror = ( cyruntime.cudaTextureAddressMode.cudaAddressModeMirror, 'Mirror address mode\n' - ){{endif}} - {{if 'cudaAddressModeBorder' in found_values}} + ) + cudaAddressModeBorder = ( cyruntime.cudaTextureAddressMode.cudaAddressModeBorder, 'Border address mode\n' - ){{endif}} - -{{endif}} -{{if 'cudaTextureFilterMode' in found_types}} + ) class cudaTextureFilterMode(_FastEnum): """ CUDA texture filter modes """ - {{if 'cudaFilterModePoint' in found_values}} + cudaFilterModePoint = ( cyruntime.cudaTextureFilterMode.cudaFilterModePoint, 'Point filter mode\n' - ){{endif}} - {{if 'cudaFilterModeLinear' in found_values}} + ) + cudaFilterModeLinear = ( cyruntime.cudaTextureFilterMode.cudaFilterModeLinear, 'Linear filter mode\n' - ){{endif}} - -{{endif}} -{{if 'cudaTextureReadMode' in found_types}} + ) class cudaTextureReadMode(_FastEnum): """ CUDA texture read modes """ - {{if 'cudaReadModeElementType' in found_values}} + cudaReadModeElementType = ( cyruntime.cudaTextureReadMode.cudaReadModeElementType, 'Read texture as specified element type\n' - ){{endif}} - {{if 'cudaReadModeNormalizedFloat' in found_values}} + ) + cudaReadModeNormalizedFloat = ( cyruntime.cudaTextureReadMode.cudaReadModeNormalizedFloat, 'Read texture as normalized float\n' - ){{endif}} - -{{endif}} -{{if 'cudaRoundMode' in found_types}} + ) class cudaRoundMode(_FastEnum): """ """ - {{if 'cudaRoundNearest' in found_values}} - cudaRoundNearest = cyruntime.cudaRoundMode.cudaRoundNearest{{endif}} - {{if 'cudaRoundZero' in found_values}} - cudaRoundZero = cyruntime.cudaRoundMode.cudaRoundZero{{endif}} - {{if 'cudaRoundPosInf' in found_values}} - cudaRoundPosInf = cyruntime.cudaRoundMode.cudaRoundPosInf{{endif}} - {{if 'cudaRoundMinInf' in found_values}} - cudaRoundMinInf = cyruntime.cudaRoundMode.cudaRoundMinInf{{endif}} -{{endif}} -{{if True}} + cudaRoundNearest = cyruntime.cudaRoundMode.cudaRoundNearest + + cudaRoundZero = cyruntime.cudaRoundMode.cudaRoundZero + + cudaRoundPosInf = cyruntime.cudaRoundMode.cudaRoundPosInf + + cudaRoundMinInf = cyruntime.cudaRoundMode.cudaRoundMinInf class cudaGLDeviceList(_FastEnum): """ CUDA devices corresponding to the current OpenGL context """ - {{if True}} + cudaGLDeviceListAll = ( cyruntime.cudaGLDeviceList.cudaGLDeviceListAll, 'The CUDA devices for all GPUs used by the current OpenGL context\n' - ){{endif}} - {{if True}} + ) + cudaGLDeviceListCurrentFrame = ( cyruntime.cudaGLDeviceList.cudaGLDeviceListCurrentFrame, 'The CUDA devices for the GPUs used by the current OpenGL context in its\n' 'currently rendering frame\n' - ){{endif}} - {{if True}} + ) + cudaGLDeviceListNextFrame = ( cyruntime.cudaGLDeviceList.cudaGLDeviceListNextFrame, 'The CUDA devices for the GPUs to be used by the current OpenGL context in\n' 'the next frame\n' - ){{endif}} - -{{endif}} -{{if True}} + ) class cudaGLMapFlags(_FastEnum): """ CUDA GL Map Flags """ - {{if True}} + cudaGLMapFlagsNone = ( cyruntime.cudaGLMapFlags.cudaGLMapFlagsNone, 'Default; Assume resource can be read/written\n' - ){{endif}} - {{if True}} + ) + cudaGLMapFlagsReadOnly = ( cyruntime.cudaGLMapFlags.cudaGLMapFlagsReadOnly, 'CUDA kernels will not write to this resource\n' - ){{endif}} - {{if True}} + ) + cudaGLMapFlagsWriteDiscard = ( cyruntime.cudaGLMapFlags.cudaGLMapFlagsWriteDiscard, 'CUDA kernels will only write to and will not read from this resource\n' - ){{endif}} - -{{endif}} + ) cdef object _cudaError_t = cudaError_t cdef object _cudaError_t_SUCCESS = cudaError_t.cudaSuccess - - -{{if 'cudaLaunchAttributeID' in found_types}} - class cudaStreamAttrID(_FastEnum): """ Launch attributes enum; used as id field of :py:obj:`~.cudaLaunchAttribute` """ - {{if 'cudaLaunchAttributeIgnore' in found_values}} + cudaLaunchAttributeIgnore = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeIgnore, 'Ignored entry, for convenient composition\n' - ){{endif}} - {{if 'cudaLaunchAttributeAccessPolicyWindow' in found_values}} + ) + cudaLaunchAttributeAccessPolicyWindow = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeAccessPolicyWindow, 'Valid for streams, graph nodes, launches. See\n' ':py:obj:`~.cudaLaunchAttributeValue.accessPolicyWindow`.\n' - ){{endif}} - {{if 'cudaLaunchAttributeCooperative' in found_values}} + ) + cudaLaunchAttributeCooperative = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeCooperative, 'Valid for graph nodes, launches. See\n' ':py:obj:`~.cudaLaunchAttributeValue.cooperative`.\n' - ){{endif}} - {{if 'cudaLaunchAttributeSynchronizationPolicy' in found_values}} + ) + cudaLaunchAttributeSynchronizationPolicy = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeSynchronizationPolicy, 'Valid for streams. See :py:obj:`~.cudaLaunchAttributeValue.syncPolicy`.\n' - ){{endif}} - {{if 'cudaLaunchAttributeClusterDimension' in found_values}} + ) + cudaLaunchAttributeClusterDimension = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeClusterDimension, 'Valid for graph nodes, launches. See\n' ':py:obj:`~.cudaLaunchAttributeValue.clusterDim`.\n' - ){{endif}} - {{if 'cudaLaunchAttributeClusterSchedulingPolicyPreference' in found_values}} + ) + cudaLaunchAttributeClusterSchedulingPolicyPreference = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeClusterSchedulingPolicyPreference, 'Valid for graph nodes, launches. See\n' ':py:obj:`~.cudaLaunchAttributeValue.clusterSchedulingPolicyPreference`.\n' - ){{endif}} - {{if 'cudaLaunchAttributeProgrammaticStreamSerialization' in found_values}} + ) + cudaLaunchAttributeProgrammaticStreamSerialization = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeProgrammaticStreamSerialization, @@ -6765,8 +6481,8 @@ class cudaStreamAttrID(_FastEnum): 'that kernel requests the overlap. The dependent launches can choose to wait\n' 'on the dependency using the programmatic sync\n' '(cudaGridDependencySynchronize() or equivalent PTX instructions).\n' - ){{endif}} - {{if 'cudaLaunchAttributeProgrammaticEvent' in found_values}} + ) + cudaLaunchAttributeProgrammaticEvent = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeProgrammaticEvent, @@ -6790,29 +6506,29 @@ class cudaStreamAttrID(_FastEnum): ' The event supplied must not be an interprocess or interop event. The event\n' 'must disable timing (i.e. must be created with the\n' ':py:obj:`~.cudaEventDisableTiming` flag set).\n' - ){{endif}} - {{if 'cudaLaunchAttributePriority' in found_values}} + ) + cudaLaunchAttributePriority = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributePriority, 'Valid for streams, graph nodes, launches. See\n' ':py:obj:`~.cudaLaunchAttributeValue.priority`.\n' - ){{endif}} - {{if 'cudaLaunchAttributeMemSyncDomainMap' in found_values}} + ) + cudaLaunchAttributeMemSyncDomainMap = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeMemSyncDomainMap, 'Valid for streams, graph nodes, launches. See\n' ':py:obj:`~.cudaLaunchAttributeValue.memSyncDomainMap`.\n' - ){{endif}} - {{if 'cudaLaunchAttributeMemSyncDomain' in found_values}} + ) + cudaLaunchAttributeMemSyncDomain = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeMemSyncDomain, 'Valid for streams, graph nodes, launches. See\n' ':py:obj:`~.cudaLaunchAttributeValue.memSyncDomain`.\n' - ){{endif}} - {{if 'cudaLaunchAttributePreferredClusterDimension' in found_values}} + ) + cudaLaunchAttributePreferredClusterDimension = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributePreferredClusterDimension, @@ -6845,8 +6561,8 @@ class cudaStreamAttrID(_FastEnum): 'than the maximum value the driver can support. Otherwise, setting this\n' 'attribute to a value physically unable to fit on any particular device is\n' 'permitted.\n' - ){{endif}} - {{if 'cudaLaunchAttributeLaunchCompletionEvent' in found_values}} + ) + cudaLaunchAttributeLaunchCompletionEvent = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeLaunchCompletionEvent, @@ -6867,8 +6583,8 @@ class cudaStreamAttrID(_FastEnum): ' The event supplied must not be an interprocess or interop event. The event\n' 'must disable timing (i.e. must be created with the\n' ':py:obj:`~.cudaEventDisableTiming` flag set).\n' - ){{endif}} - {{if 'cudaLaunchAttributeDeviceUpdatableKernelNode' in found_values}} + ) + cudaLaunchAttributeDeviceUpdatableKernelNode = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeDeviceUpdatableKernelNode, @@ -6899,8 +6615,8 @@ class cudaStreamAttrID(_FastEnum): ':py:obj:`~.cuGraphUpload` before it is launched. For such a graph, if host-\n' 'side executable graph updates are made to the device-updatable nodes, the\n' 'graph must be uploaded before it is launched again.\n' - ){{endif}} - {{if 'cudaLaunchAttributePreferredSharedMemoryCarveout' in found_values}} + ) + cudaLaunchAttributePreferredSharedMemoryCarveout = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributePreferredSharedMemoryCarveout, @@ -6912,8 +6628,8 @@ class cudaStreamAttrID(_FastEnum): 'precedence over :py:obj:`~.cudaFuncAttributePreferredSharedMemoryCarveout`.\n' 'This is only a hint, and the driver can choose a different configuration if\n' 'required for the launch.\n' - ){{endif}} - {{if 'cudaLaunchAttributeNvlinkUtilCentricScheduling' in found_values}} + ) + cudaLaunchAttributeNvlinkUtilCentricScheduling = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeNvlinkUtilCentricScheduling, @@ -6934,8 +6650,8 @@ class cudaStreamAttrID(_FastEnum): ' Valid values for\n' ':py:obj:`~.cudaLaunchAttributeValue.nvlinkUtilCentricScheduling` are 0\n' '(disabled) and 1 (enabled).\n' - ){{endif}} - {{if 'cudaLaunchAttributePortableClusterSizeMode' in found_values}} + ) + cudaLaunchAttributePortableClusterSizeMode = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributePortableClusterSizeMode, @@ -6944,64 +6660,61 @@ class cudaStreamAttrID(_FastEnum): ':py:obj:`~.cudaLaunchAttributeValue.portableClusterSizeMode` are values for\n' ':py:obj:`~.cudaLaunchAttributePortableClusterMode` Any other value will\n' 'return :py:obj:`~.cudaErrorInvalidValue`\n' - ){{endif}} - {{if 'cudaLaunchAttributeSharedMemoryMode' in found_values}} + ) + cudaLaunchAttributeSharedMemoryMode = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeSharedMemoryMode, 'Valid for graph nodes, launches. This indicates that the kernel launch is\n' 'allowed to use a non-portable shared memory mode.\n' - ){{endif}} - -{{endif}} -{{if 'cudaLaunchAttributeID' in found_types}} + ) class cudaKernelNodeAttrID(_FastEnum): """ Launch attributes enum; used as id field of :py:obj:`~.cudaLaunchAttribute` """ - {{if 'cudaLaunchAttributeIgnore' in found_values}} + cudaLaunchAttributeIgnore = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeIgnore, 'Ignored entry, for convenient composition\n' - ){{endif}} - {{if 'cudaLaunchAttributeAccessPolicyWindow' in found_values}} + ) + cudaLaunchAttributeAccessPolicyWindow = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeAccessPolicyWindow, 'Valid for streams, graph nodes, launches. See\n' ':py:obj:`~.cudaLaunchAttributeValue.accessPolicyWindow`.\n' - ){{endif}} - {{if 'cudaLaunchAttributeCooperative' in found_values}} + ) + cudaLaunchAttributeCooperative = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeCooperative, 'Valid for graph nodes, launches. See\n' ':py:obj:`~.cudaLaunchAttributeValue.cooperative`.\n' - ){{endif}} - {{if 'cudaLaunchAttributeSynchronizationPolicy' in found_values}} + ) + cudaLaunchAttributeSynchronizationPolicy = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeSynchronizationPolicy, 'Valid for streams. See :py:obj:`~.cudaLaunchAttributeValue.syncPolicy`.\n' - ){{endif}} - {{if 'cudaLaunchAttributeClusterDimension' in found_values}} + ) + cudaLaunchAttributeClusterDimension = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeClusterDimension, 'Valid for graph nodes, launches. See\n' ':py:obj:`~.cudaLaunchAttributeValue.clusterDim`.\n' - ){{endif}} - {{if 'cudaLaunchAttributeClusterSchedulingPolicyPreference' in found_values}} + ) + cudaLaunchAttributeClusterSchedulingPolicyPreference = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeClusterSchedulingPolicyPreference, 'Valid for graph nodes, launches. See\n' ':py:obj:`~.cudaLaunchAttributeValue.clusterSchedulingPolicyPreference`.\n' - ){{endif}} - {{if 'cudaLaunchAttributeProgrammaticStreamSerialization' in found_values}} + ) + cudaLaunchAttributeProgrammaticStreamSerialization = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeProgrammaticStreamSerialization, @@ -7013,8 +6726,8 @@ class cudaKernelNodeAttrID(_FastEnum): 'that kernel requests the overlap. The dependent launches can choose to wait\n' 'on the dependency using the programmatic sync\n' '(cudaGridDependencySynchronize() or equivalent PTX instructions).\n' - ){{endif}} - {{if 'cudaLaunchAttributeProgrammaticEvent' in found_values}} + ) + cudaLaunchAttributeProgrammaticEvent = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeProgrammaticEvent, @@ -7038,29 +6751,29 @@ class cudaKernelNodeAttrID(_FastEnum): ' The event supplied must not be an interprocess or interop event. The event\n' 'must disable timing (i.e. must be created with the\n' ':py:obj:`~.cudaEventDisableTiming` flag set).\n' - ){{endif}} - {{if 'cudaLaunchAttributePriority' in found_values}} + ) + cudaLaunchAttributePriority = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributePriority, 'Valid for streams, graph nodes, launches. See\n' ':py:obj:`~.cudaLaunchAttributeValue.priority`.\n' - ){{endif}} - {{if 'cudaLaunchAttributeMemSyncDomainMap' in found_values}} + ) + cudaLaunchAttributeMemSyncDomainMap = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeMemSyncDomainMap, 'Valid for streams, graph nodes, launches. See\n' ':py:obj:`~.cudaLaunchAttributeValue.memSyncDomainMap`.\n' - ){{endif}} - {{if 'cudaLaunchAttributeMemSyncDomain' in found_values}} + ) + cudaLaunchAttributeMemSyncDomain = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeMemSyncDomain, 'Valid for streams, graph nodes, launches. See\n' ':py:obj:`~.cudaLaunchAttributeValue.memSyncDomain`.\n' - ){{endif}} - {{if 'cudaLaunchAttributePreferredClusterDimension' in found_values}} + ) + cudaLaunchAttributePreferredClusterDimension = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributePreferredClusterDimension, @@ -7093,8 +6806,8 @@ class cudaKernelNodeAttrID(_FastEnum): 'than the maximum value the driver can support. Otherwise, setting this\n' 'attribute to a value physically unable to fit on any particular device is\n' 'permitted.\n' - ){{endif}} - {{if 'cudaLaunchAttributeLaunchCompletionEvent' in found_values}} + ) + cudaLaunchAttributeLaunchCompletionEvent = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeLaunchCompletionEvent, @@ -7115,8 +6828,8 @@ class cudaKernelNodeAttrID(_FastEnum): ' The event supplied must not be an interprocess or interop event. The event\n' 'must disable timing (i.e. must be created with the\n' ':py:obj:`~.cudaEventDisableTiming` flag set).\n' - ){{endif}} - {{if 'cudaLaunchAttributeDeviceUpdatableKernelNode' in found_values}} + ) + cudaLaunchAttributeDeviceUpdatableKernelNode = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeDeviceUpdatableKernelNode, @@ -7147,8 +6860,8 @@ class cudaKernelNodeAttrID(_FastEnum): ':py:obj:`~.cuGraphUpload` before it is launched. For such a graph, if host-\n' 'side executable graph updates are made to the device-updatable nodes, the\n' 'graph must be uploaded before it is launched again.\n' - ){{endif}} - {{if 'cudaLaunchAttributePreferredSharedMemoryCarveout' in found_values}} + ) + cudaLaunchAttributePreferredSharedMemoryCarveout = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributePreferredSharedMemoryCarveout, @@ -7160,8 +6873,8 @@ class cudaKernelNodeAttrID(_FastEnum): 'precedence over :py:obj:`~.cudaFuncAttributePreferredSharedMemoryCarveout`.\n' 'This is only a hint, and the driver can choose a different configuration if\n' 'required for the launch.\n' - ){{endif}} - {{if 'cudaLaunchAttributeNvlinkUtilCentricScheduling' in found_values}} + ) + cudaLaunchAttributeNvlinkUtilCentricScheduling = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeNvlinkUtilCentricScheduling, @@ -7182,8 +6895,8 @@ class cudaKernelNodeAttrID(_FastEnum): ' Valid values for\n' ':py:obj:`~.cudaLaunchAttributeValue.nvlinkUtilCentricScheduling` are 0\n' '(disabled) and 1 (enabled).\n' - ){{endif}} - {{if 'cudaLaunchAttributePortableClusterSizeMode' in found_values}} + ) + cudaLaunchAttributePortableClusterSizeMode = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributePortableClusterSizeMode, @@ -7192,17 +6905,14 @@ class cudaKernelNodeAttrID(_FastEnum): ':py:obj:`~.cudaLaunchAttributeValue.portableClusterSizeMode` are values for\n' ':py:obj:`~.cudaLaunchAttributePortableClusterMode` Any other value will\n' 'return :py:obj:`~.cudaErrorInvalidValue`\n' - ){{endif}} - {{if 'cudaLaunchAttributeSharedMemoryMode' in found_values}} + ) + cudaLaunchAttributeSharedMemoryMode = ( cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeSharedMemoryMode, 'Valid for graph nodes, launches. This indicates that the kernel launch is\n' 'allowed to use a non-portable shared memory mode.\n' - ){{endif}} - -{{endif}} -{{if 'cudaDevResourceDesc_t' in found_types}} + ) cdef class cudaDevResourceDesc_t: """ @@ -7237,9 +6947,6 @@ cdef class cudaDevResourceDesc_t: return self._pvt_ptr[0] def getPtr(self): return self._pvt_ptr -{{endif}} - -{{if 'cudaExecutionContext_t' in found_types}} cdef class cudaExecutionContext_t: """ @@ -7274,9 +6981,6 @@ cdef class cudaExecutionContext_t: return self._pvt_ptr[0] def getPtr(self): return self._pvt_ptr -{{endif}} - -{{if 'cudaArray_t' in found_types}} cdef class cudaArray_t: """ @@ -7311,9 +7015,6 @@ cdef class cudaArray_t: return self._pvt_ptr[0] def getPtr(self): return self._pvt_ptr -{{endif}} - -{{if 'cudaArray_const_t' in found_types}} cdef class cudaArray_const_t: """ @@ -7348,9 +7049,6 @@ cdef class cudaArray_const_t: return self._pvt_ptr[0] def getPtr(self): return self._pvt_ptr -{{endif}} - -{{if 'cudaMipmappedArray_t' in found_types}} cdef class cudaMipmappedArray_t: """ @@ -7385,9 +7083,6 @@ cdef class cudaMipmappedArray_t: return self._pvt_ptr[0] def getPtr(self): return self._pvt_ptr -{{endif}} - -{{if 'cudaMipmappedArray_const_t' in found_types}} cdef class cudaMipmappedArray_const_t: """ @@ -7422,9 +7117,6 @@ cdef class cudaMipmappedArray_const_t: return self._pvt_ptr[0] def getPtr(self): return self._pvt_ptr -{{endif}} - -{{if 'cudaGraphicsResource_t' in found_types}} cdef class cudaGraphicsResource_t: """ @@ -7459,9 +7151,6 @@ cdef class cudaGraphicsResource_t: return self._pvt_ptr[0] def getPtr(self): return self._pvt_ptr -{{endif}} - -{{if 'cudaExternalMemory_t' in found_types}} cdef class cudaExternalMemory_t: """ @@ -7496,9 +7185,6 @@ cdef class cudaExternalMemory_t: return self._pvt_ptr[0] def getPtr(self): return self._pvt_ptr -{{endif}} - -{{if 'cudaExternalSemaphore_t' in found_types}} cdef class cudaExternalSemaphore_t: """ @@ -7533,9 +7219,6 @@ cdef class cudaExternalSemaphore_t: return self._pvt_ptr[0] def getPtr(self): return self._pvt_ptr -{{endif}} - -{{if 'cudaKernel_t' in found_types}} cdef class cudaKernel_t: """ @@ -7570,9 +7253,6 @@ cdef class cudaKernel_t: return self._pvt_ptr[0] def getPtr(self): return self._pvt_ptr -{{endif}} - -{{if 'cudaLibrary_t' in found_types}} cdef class cudaLibrary_t: """ @@ -7607,9 +7287,6 @@ cdef class cudaLibrary_t: return self._pvt_ptr[0] def getPtr(self): return self._pvt_ptr -{{endif}} - -{{if 'cudaGraphDeviceNode_t' in found_types}} cdef class cudaGraphDeviceNode_t: """ @@ -7644,9 +7321,6 @@ cdef class cudaGraphDeviceNode_t: return self._pvt_ptr[0] def getPtr(self): return self._pvt_ptr -{{endif}} - -{{if 'cudaAsyncCallbackHandle_t' in found_types}} cdef class cudaAsyncCallbackHandle_t: """ @@ -7681,9 +7355,6 @@ cdef class cudaAsyncCallbackHandle_t: return self._pvt_ptr[0] def getPtr(self): return self._pvt_ptr -{{endif}} - -{{if 'cudaLogsCallbackHandle' in found_types}} cdef class cudaLogsCallbackHandle: """ @@ -7716,9 +7387,6 @@ cdef class cudaLogsCallbackHandle: return self._pvt_ptr[0] def getPtr(self): return self._pvt_ptr -{{endif}} - -{{if True}} cdef class EGLImageKHR: """ @@ -7751,9 +7419,6 @@ cdef class EGLImageKHR: return self._pvt_ptr[0] def getPtr(self): return self._pvt_ptr -{{endif}} - -{{if True}} cdef class EGLStreamKHR: """ @@ -7786,9 +7451,6 @@ cdef class EGLStreamKHR: return self._pvt_ptr[0] def getPtr(self): return self._pvt_ptr -{{endif}} - -{{if True}} cdef class EGLSyncKHR: """ @@ -7821,9 +7483,6 @@ cdef class EGLSyncKHR: return self._pvt_ptr[0] def getPtr(self): return self._pvt_ptr -{{endif}} - -{{if 'cudaHostFn_t' in found_types}} cdef class cudaHostFn_t: """ @@ -7850,9 +7509,6 @@ cdef class cudaHostFn_t: return self._pvt_ptr[0] def getPtr(self): return self._pvt_ptr -{{endif}} - -{{if 'cudaAsyncCallback' in found_types}} cdef class cudaAsyncCallback: """ @@ -7879,9 +7535,6 @@ cdef class cudaAsyncCallback: return self._pvt_ptr[0] def getPtr(self): return self._pvt_ptr -{{endif}} - -{{if 'cudaStreamCallback_t' in found_types}} cdef class cudaStreamCallback_t: """ @@ -7908,9 +7561,6 @@ cdef class cudaStreamCallback_t: return self._pvt_ptr[0] def getPtr(self): return self._pvt_ptr -{{endif}} - -{{if 'cudaGraphRecaptureCallback_t' in found_types}} cdef class cudaGraphRecaptureCallback_t: """ @@ -7937,9 +7587,6 @@ cdef class cudaGraphRecaptureCallback_t: return self._pvt_ptr[0] def getPtr(self): return self._pvt_ptr -{{endif}} - -{{if 'cudaLogsCallback_t' in found_types}} cdef class cudaLogsCallback_t: """ @@ -7966,26 +7613,23 @@ cdef class cudaLogsCallback_t: return self._pvt_ptr[0] def getPtr(self): return self._pvt_ptr -{{endif}} - -{{if 'dim3' in found_struct}} cdef class dim3: """ Attributes ---------- - {{if 'dim3.x' in found_struct}} + x : unsigned int - {{endif}} - {{if 'dim3.y' in found_struct}} + + y : unsigned int - {{endif}} - {{if 'dim3.z' in found_struct}} + + z : unsigned int - {{endif}} + Methods ------- @@ -8006,53 +7650,51 @@ cdef class dim3: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'dim3.x' in found_struct}} + try: str_list += ['x : ' + str(self.x)] except ValueError: str_list += ['x : '] - {{endif}} - {{if 'dim3.y' in found_struct}} + + try: str_list += ['y : ' + str(self.y)] except ValueError: str_list += ['y : '] - {{endif}} - {{if 'dim3.z' in found_struct}} + + try: str_list += ['z : ' + str(self.z)] except ValueError: str_list += ['z : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'dim3.x' in found_struct}} + @property def x(self): return self._pvt_ptr[0].x @x.setter def x(self, unsigned int x): self._pvt_ptr[0].x = x - {{endif}} - {{if 'dim3.y' in found_struct}} + + @property def y(self): return self._pvt_ptr[0].y @y.setter def y(self, unsigned int y): self._pvt_ptr[0].y = y - {{endif}} - {{if 'dim3.z' in found_struct}} + + @property def z(self): return self._pvt_ptr[0].z @z.setter def z(self, unsigned int z): self._pvt_ptr[0].z = z - {{endif}} -{{endif}} -{{if 'cudaChannelFormatDesc' in found_struct}} + cdef class cudaChannelFormatDesc: """ @@ -8060,26 +7702,26 @@ cdef class cudaChannelFormatDesc: Attributes ---------- - {{if 'cudaChannelFormatDesc.x' in found_struct}} + x : int x - {{endif}} - {{if 'cudaChannelFormatDesc.y' in found_struct}} + + y : int y - {{endif}} - {{if 'cudaChannelFormatDesc.z' in found_struct}} + + z : int z - {{endif}} - {{if 'cudaChannelFormatDesc.w' in found_struct}} + + w : int w - {{endif}} - {{if 'cudaChannelFormatDesc.f' in found_struct}} + + f : cudaChannelFormatKind Channel format kind - {{endif}} + Methods ------- @@ -8100,98 +7742,96 @@ cdef class cudaChannelFormatDesc: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaChannelFormatDesc.x' in found_struct}} + try: str_list += ['x : ' + str(self.x)] except ValueError: str_list += ['x : '] - {{endif}} - {{if 'cudaChannelFormatDesc.y' in found_struct}} + + try: str_list += ['y : ' + str(self.y)] except ValueError: str_list += ['y : '] - {{endif}} - {{if 'cudaChannelFormatDesc.z' in found_struct}} + + try: str_list += ['z : ' + str(self.z)] except ValueError: str_list += ['z : '] - {{endif}} - {{if 'cudaChannelFormatDesc.w' in found_struct}} + + try: str_list += ['w : ' + str(self.w)] except ValueError: str_list += ['w : '] - {{endif}} - {{if 'cudaChannelFormatDesc.f' in found_struct}} + + try: str_list += ['f : ' + str(self.f)] except ValueError: str_list += ['f : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaChannelFormatDesc.x' in found_struct}} + @property def x(self): return self._pvt_ptr[0].x @x.setter def x(self, int x): self._pvt_ptr[0].x = x - {{endif}} - {{if 'cudaChannelFormatDesc.y' in found_struct}} + + @property def y(self): return self._pvt_ptr[0].y @y.setter def y(self, int y): self._pvt_ptr[0].y = y - {{endif}} - {{if 'cudaChannelFormatDesc.z' in found_struct}} + + @property def z(self): return self._pvt_ptr[0].z @z.setter def z(self, int z): self._pvt_ptr[0].z = z - {{endif}} - {{if 'cudaChannelFormatDesc.w' in found_struct}} + + @property def w(self): return self._pvt_ptr[0].w @w.setter def w(self, int w): self._pvt_ptr[0].w = w - {{endif}} - {{if 'cudaChannelFormatDesc.f' in found_struct}} + + @property def f(self): return cudaChannelFormatKind(self._pvt_ptr[0].f) @f.setter def f(self, f not None : cudaChannelFormatKind): - self._pvt_ptr[0].f = int(f) - {{endif}} -{{endif}} -{{if 'cudaArraySparseProperties.tileExtent' in found_struct}} + self._pvt_ptr[0].f = int(f) + cdef class anon_struct0: """ Attributes ---------- - {{if 'cudaArraySparseProperties.tileExtent.width' in found_struct}} + width : unsigned int - {{endif}} - {{if 'cudaArraySparseProperties.tileExtent.height' in found_struct}} + + height : unsigned int - {{endif}} - {{if 'cudaArraySparseProperties.tileExtent.depth' in found_struct}} + + depth : unsigned int - {{endif}} + Methods ------- @@ -8210,53 +7850,51 @@ cdef class anon_struct0: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaArraySparseProperties.tileExtent.width' in found_struct}} + try: str_list += ['width : ' + str(self.width)] except ValueError: str_list += ['width : '] - {{endif}} - {{if 'cudaArraySparseProperties.tileExtent.height' in found_struct}} + + try: str_list += ['height : ' + str(self.height)] except ValueError: str_list += ['height : '] - {{endif}} - {{if 'cudaArraySparseProperties.tileExtent.depth' in found_struct}} + + try: str_list += ['depth : ' + str(self.depth)] except ValueError: str_list += ['depth : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaArraySparseProperties.tileExtent.width' in found_struct}} + @property def width(self): return self._pvt_ptr[0].tileExtent.width @width.setter def width(self, unsigned int width): self._pvt_ptr[0].tileExtent.width = width - {{endif}} - {{if 'cudaArraySparseProperties.tileExtent.height' in found_struct}} + + @property def height(self): return self._pvt_ptr[0].tileExtent.height @height.setter def height(self, unsigned int height): self._pvt_ptr[0].tileExtent.height = height - {{endif}} - {{if 'cudaArraySparseProperties.tileExtent.depth' in found_struct}} + + @property def depth(self): return self._pvt_ptr[0].tileExtent.depth @depth.setter def depth(self, unsigned int depth): self._pvt_ptr[0].tileExtent.depth = depth - {{endif}} -{{endif}} -{{if 'cudaArraySparseProperties' in found_struct}} + cdef class cudaArraySparseProperties: """ @@ -8264,26 +7902,26 @@ cdef class cudaArraySparseProperties: Attributes ---------- - {{if 'cudaArraySparseProperties.tileExtent' in found_struct}} + tileExtent : anon_struct0 - {{endif}} - {{if 'cudaArraySparseProperties.miptailFirstLevel' in found_struct}} + + miptailFirstLevel : unsigned int First mip level at which the mip tail begins - {{endif}} - {{if 'cudaArraySparseProperties.miptailSize' in found_struct}} + + miptailSize : unsigned long long Total size of the mip tail. - {{endif}} - {{if 'cudaArraySparseProperties.flags' in found_struct}} + + flags : unsigned int Flags will either be zero or cudaArraySparsePropertiesSingleMipTail - {{endif}} - {{if 'cudaArraySparseProperties.reserved' in found_struct}} + + reserved : list[unsigned int] - {{endif}} + Methods ------- @@ -8297,9 +7935,9 @@ cdef class cudaArraySparseProperties: self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass - {{if 'cudaArraySparseProperties.tileExtent' in found_struct}} + self._tileExtent = anon_struct0(_ptr=self._pvt_ptr) - {{endif}} + def __dealloc__(self): pass def getPtr(self): @@ -8307,81 +7945,79 @@ cdef class cudaArraySparseProperties: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaArraySparseProperties.tileExtent' in found_struct}} + try: str_list += ['tileExtent :\n' + '\n'.join([' ' + line for line in str(self.tileExtent).splitlines()])] except ValueError: str_list += ['tileExtent : '] - {{endif}} - {{if 'cudaArraySparseProperties.miptailFirstLevel' in found_struct}} + + try: str_list += ['miptailFirstLevel : ' + str(self.miptailFirstLevel)] except ValueError: str_list += ['miptailFirstLevel : '] - {{endif}} - {{if 'cudaArraySparseProperties.miptailSize' in found_struct}} + + try: str_list += ['miptailSize : ' + str(self.miptailSize)] except ValueError: str_list += ['miptailSize : '] - {{endif}} - {{if 'cudaArraySparseProperties.flags' in found_struct}} + + try: str_list += ['flags : ' + str(self.flags)] except ValueError: str_list += ['flags : '] - {{endif}} - {{if 'cudaArraySparseProperties.reserved' in found_struct}} + + try: str_list += ['reserved : ' + str(self.reserved)] except ValueError: str_list += ['reserved : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaArraySparseProperties.tileExtent' in found_struct}} + @property def tileExtent(self): return self._tileExtent @tileExtent.setter def tileExtent(self, tileExtent not None : anon_struct0): string.memcpy(&self._pvt_ptr[0].tileExtent, tileExtent.getPtr(), sizeof(self._pvt_ptr[0].tileExtent)) - {{endif}} - {{if 'cudaArraySparseProperties.miptailFirstLevel' in found_struct}} + + @property def miptailFirstLevel(self): return self._pvt_ptr[0].miptailFirstLevel @miptailFirstLevel.setter def miptailFirstLevel(self, unsigned int miptailFirstLevel): self._pvt_ptr[0].miptailFirstLevel = miptailFirstLevel - {{endif}} - {{if 'cudaArraySparseProperties.miptailSize' in found_struct}} + + @property def miptailSize(self): return self._pvt_ptr[0].miptailSize @miptailSize.setter def miptailSize(self, unsigned long long miptailSize): self._pvt_ptr[0].miptailSize = miptailSize - {{endif}} - {{if 'cudaArraySparseProperties.flags' in found_struct}} + + @property def flags(self): return self._pvt_ptr[0].flags @flags.setter def flags(self, unsigned int flags): self._pvt_ptr[0].flags = flags - {{endif}} - {{if 'cudaArraySparseProperties.reserved' in found_struct}} + + @property def reserved(self): return self._pvt_ptr[0].reserved @reserved.setter def reserved(self, reserved): self._pvt_ptr[0].reserved = reserved - {{endif}} -{{endif}} -{{if 'cudaArrayMemoryRequirements' in found_struct}} + cdef class cudaArrayMemoryRequirements: """ @@ -8389,18 +8025,18 @@ cdef class cudaArrayMemoryRequirements: Attributes ---------- - {{if 'cudaArrayMemoryRequirements.size' in found_struct}} + size : size_t Total size of the array. - {{endif}} - {{if 'cudaArrayMemoryRequirements.alignment' in found_struct}} + + alignment : size_t Alignment necessary for mapping the array. - {{endif}} - {{if 'cudaArrayMemoryRequirements.reserved' in found_struct}} + + reserved : list[unsigned int] - {{endif}} + Methods ------- @@ -8421,53 +8057,51 @@ cdef class cudaArrayMemoryRequirements: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaArrayMemoryRequirements.size' in found_struct}} + try: str_list += ['size : ' + str(self.size)] except ValueError: str_list += ['size : '] - {{endif}} - {{if 'cudaArrayMemoryRequirements.alignment' in found_struct}} + + try: str_list += ['alignment : ' + str(self.alignment)] except ValueError: str_list += ['alignment : '] - {{endif}} - {{if 'cudaArrayMemoryRequirements.reserved' in found_struct}} + + try: str_list += ['reserved : ' + str(self.reserved)] except ValueError: str_list += ['reserved : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaArrayMemoryRequirements.size' in found_struct}} + @property def size(self): return self._pvt_ptr[0].size @size.setter def size(self, size_t size): self._pvt_ptr[0].size = size - {{endif}} - {{if 'cudaArrayMemoryRequirements.alignment' in found_struct}} + + @property def alignment(self): return self._pvt_ptr[0].alignment @alignment.setter def alignment(self, size_t alignment): self._pvt_ptr[0].alignment = alignment - {{endif}} - {{if 'cudaArrayMemoryRequirements.reserved' in found_struct}} + + @property def reserved(self): return self._pvt_ptr[0].reserved @reserved.setter def reserved(self, reserved): self._pvt_ptr[0].reserved = reserved - {{endif}} -{{endif}} -{{if 'cudaPitchedPtr' in found_struct}} + cdef class cudaPitchedPtr: """ @@ -8475,22 +8109,22 @@ cdef class cudaPitchedPtr: Attributes ---------- - {{if 'cudaPitchedPtr.ptr' in found_struct}} + ptr : Any Pointer to allocated memory - {{endif}} - {{if 'cudaPitchedPtr.pitch' in found_struct}} + + pitch : size_t Pitch of allocated memory in bytes - {{endif}} - {{if 'cudaPitchedPtr.xsize' in found_struct}} + + xsize : size_t Logical width of allocation in elements - {{endif}} - {{if 'cudaPitchedPtr.ysize' in found_struct}} + + ysize : size_t Logical height of allocation in elements - {{endif}} + Methods ------- @@ -8511,34 +8145,34 @@ cdef class cudaPitchedPtr: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaPitchedPtr.ptr' in found_struct}} + try: str_list += ['ptr : ' + hex(self.ptr)] except ValueError: str_list += ['ptr : '] - {{endif}} - {{if 'cudaPitchedPtr.pitch' in found_struct}} + + try: str_list += ['pitch : ' + str(self.pitch)] except ValueError: str_list += ['pitch : '] - {{endif}} - {{if 'cudaPitchedPtr.xsize' in found_struct}} + + try: str_list += ['xsize : ' + str(self.xsize)] except ValueError: str_list += ['xsize : '] - {{endif}} - {{if 'cudaPitchedPtr.ysize' in found_struct}} + + try: str_list += ['ysize : ' + str(self.ysize)] except ValueError: str_list += ['ysize : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaPitchedPtr.ptr' in found_struct}} + @property def ptr(self): return self._pvt_ptr[0].ptr @@ -8546,33 +8180,31 @@ cdef class cudaPitchedPtr: def ptr(self, ptr): self._cyptr = _HelperInputVoidPtr(ptr) self._pvt_ptr[0].ptr = self._cyptr.cptr - {{endif}} - {{if 'cudaPitchedPtr.pitch' in found_struct}} + + @property def pitch(self): return self._pvt_ptr[0].pitch @pitch.setter def pitch(self, size_t pitch): self._pvt_ptr[0].pitch = pitch - {{endif}} - {{if 'cudaPitchedPtr.xsize' in found_struct}} + + @property def xsize(self): return self._pvt_ptr[0].xsize @xsize.setter def xsize(self, size_t xsize): self._pvt_ptr[0].xsize = xsize - {{endif}} - {{if 'cudaPitchedPtr.ysize' in found_struct}} + + @property def ysize(self): return self._pvt_ptr[0].ysize @ysize.setter def ysize(self, size_t ysize): self._pvt_ptr[0].ysize = ysize - {{endif}} -{{endif}} -{{if 'cudaExtent' in found_struct}} + cdef class cudaExtent: """ @@ -8580,19 +8212,19 @@ cdef class cudaExtent: Attributes ---------- - {{if 'cudaExtent.width' in found_struct}} + width : size_t Width in elements when referring to array memory, in bytes when referring to linear memory - {{endif}} - {{if 'cudaExtent.height' in found_struct}} + + height : size_t Height in elements - {{endif}} - {{if 'cudaExtent.depth' in found_struct}} + + depth : size_t Depth in elements - {{endif}} + Methods ------- @@ -8613,53 +8245,51 @@ cdef class cudaExtent: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaExtent.width' in found_struct}} + try: str_list += ['width : ' + str(self.width)] except ValueError: str_list += ['width : '] - {{endif}} - {{if 'cudaExtent.height' in found_struct}} + + try: str_list += ['height : ' + str(self.height)] except ValueError: str_list += ['height : '] - {{endif}} - {{if 'cudaExtent.depth' in found_struct}} + + try: str_list += ['depth : ' + str(self.depth)] except ValueError: str_list += ['depth : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaExtent.width' in found_struct}} + @property def width(self): return self._pvt_ptr[0].width @width.setter def width(self, size_t width): self._pvt_ptr[0].width = width - {{endif}} - {{if 'cudaExtent.height' in found_struct}} + + @property def height(self): return self._pvt_ptr[0].height @height.setter def height(self, size_t height): self._pvt_ptr[0].height = height - {{endif}} - {{if 'cudaExtent.depth' in found_struct}} + + @property def depth(self): return self._pvt_ptr[0].depth @depth.setter def depth(self, size_t depth): self._pvt_ptr[0].depth = depth - {{endif}} -{{endif}} -{{if 'cudaPos' in found_struct}} + cdef class cudaPos: """ @@ -8667,18 +8297,18 @@ cdef class cudaPos: Attributes ---------- - {{if 'cudaPos.x' in found_struct}} + x : size_t x - {{endif}} - {{if 'cudaPos.y' in found_struct}} + + y : size_t y - {{endif}} - {{if 'cudaPos.z' in found_struct}} + + z : size_t z - {{endif}} + Methods ------- @@ -8699,53 +8329,51 @@ cdef class cudaPos: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaPos.x' in found_struct}} + try: str_list += ['x : ' + str(self.x)] except ValueError: str_list += ['x : '] - {{endif}} - {{if 'cudaPos.y' in found_struct}} + + try: str_list += ['y : ' + str(self.y)] except ValueError: str_list += ['y : '] - {{endif}} - {{if 'cudaPos.z' in found_struct}} + + try: str_list += ['z : ' + str(self.z)] except ValueError: str_list += ['z : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaPos.x' in found_struct}} + @property def x(self): return self._pvt_ptr[0].x @x.setter def x(self, size_t x): self._pvt_ptr[0].x = x - {{endif}} - {{if 'cudaPos.y' in found_struct}} + + @property def y(self): return self._pvt_ptr[0].y @y.setter def y(self, size_t y): self._pvt_ptr[0].y = y - {{endif}} - {{if 'cudaPos.z' in found_struct}} + + @property def z(self): return self._pvt_ptr[0].z @z.setter def z(self, size_t z): self._pvt_ptr[0].z = z - {{endif}} -{{endif}} -{{if 'cudaMemcpy3DParms' in found_struct}} + cdef class cudaMemcpy3DParms: """ @@ -8753,38 +8381,38 @@ cdef class cudaMemcpy3DParms: Attributes ---------- - {{if 'cudaMemcpy3DParms.srcArray' in found_struct}} + srcArray : cudaArray_t Source memory address - {{endif}} - {{if 'cudaMemcpy3DParms.srcPos' in found_struct}} + + srcPos : cudaPos Source position offset - {{endif}} - {{if 'cudaMemcpy3DParms.srcPtr' in found_struct}} + + srcPtr : cudaPitchedPtr Pitched source memory address - {{endif}} - {{if 'cudaMemcpy3DParms.dstArray' in found_struct}} + + dstArray : cudaArray_t Destination memory address - {{endif}} - {{if 'cudaMemcpy3DParms.dstPos' in found_struct}} + + dstPos : cudaPos Destination position offset - {{endif}} - {{if 'cudaMemcpy3DParms.dstPtr' in found_struct}} + + dstPtr : cudaPitchedPtr Pitched destination memory address - {{endif}} - {{if 'cudaMemcpy3DParms.extent' in found_struct}} + + extent : cudaExtent Requested memory copy size - {{endif}} - {{if 'cudaMemcpy3DParms.kind' in found_struct}} + + kind : cudaMemcpyKind Type of transfer - {{endif}} + Methods ------- @@ -8798,27 +8426,27 @@ cdef class cudaMemcpy3DParms: self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass - {{if 'cudaMemcpy3DParms.srcArray' in found_struct}} + self._srcArray = cudaArray_t(_ptr=&self._pvt_ptr[0].srcArray) - {{endif}} - {{if 'cudaMemcpy3DParms.srcPos' in found_struct}} + + self._srcPos = cudaPos(_ptr=&self._pvt_ptr[0].srcPos) - {{endif}} - {{if 'cudaMemcpy3DParms.srcPtr' in found_struct}} + + self._srcPtr = cudaPitchedPtr(_ptr=&self._pvt_ptr[0].srcPtr) - {{endif}} - {{if 'cudaMemcpy3DParms.dstArray' in found_struct}} + + self._dstArray = cudaArray_t(_ptr=&self._pvt_ptr[0].dstArray) - {{endif}} - {{if 'cudaMemcpy3DParms.dstPos' in found_struct}} + + self._dstPos = cudaPos(_ptr=&self._pvt_ptr[0].dstPos) - {{endif}} - {{if 'cudaMemcpy3DParms.dstPtr' in found_struct}} + + self._dstPtr = cudaPitchedPtr(_ptr=&self._pvt_ptr[0].dstPtr) - {{endif}} - {{if 'cudaMemcpy3DParms.extent' in found_struct}} + + self._extent = cudaExtent(_ptr=&self._pvt_ptr[0].extent) - {{endif}} + def __dealloc__(self): pass def getPtr(self): @@ -8826,58 +8454,58 @@ cdef class cudaMemcpy3DParms: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaMemcpy3DParms.srcArray' in found_struct}} + try: str_list += ['srcArray : ' + str(self.srcArray)] except ValueError: str_list += ['srcArray : '] - {{endif}} - {{if 'cudaMemcpy3DParms.srcPos' in found_struct}} + + try: str_list += ['srcPos :\n' + '\n'.join([' ' + line for line in str(self.srcPos).splitlines()])] except ValueError: str_list += ['srcPos : '] - {{endif}} - {{if 'cudaMemcpy3DParms.srcPtr' in found_struct}} + + try: str_list += ['srcPtr :\n' + '\n'.join([' ' + line for line in str(self.srcPtr).splitlines()])] except ValueError: str_list += ['srcPtr : '] - {{endif}} - {{if 'cudaMemcpy3DParms.dstArray' in found_struct}} + + try: str_list += ['dstArray : ' + str(self.dstArray)] except ValueError: str_list += ['dstArray : '] - {{endif}} - {{if 'cudaMemcpy3DParms.dstPos' in found_struct}} + + try: str_list += ['dstPos :\n' + '\n'.join([' ' + line for line in str(self.dstPos).splitlines()])] except ValueError: str_list += ['dstPos : '] - {{endif}} - {{if 'cudaMemcpy3DParms.dstPtr' in found_struct}} + + try: str_list += ['dstPtr :\n' + '\n'.join([' ' + line for line in str(self.dstPtr).splitlines()])] except ValueError: str_list += ['dstPtr : '] - {{endif}} - {{if 'cudaMemcpy3DParms.extent' in found_struct}} + + try: str_list += ['extent :\n' + '\n'.join([' ' + line for line in str(self.extent).splitlines()])] except ValueError: str_list += ['extent : '] - {{endif}} - {{if 'cudaMemcpy3DParms.kind' in found_struct}} + + try: str_list += ['kind : ' + str(self.kind)] except ValueError: str_list += ['kind : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaMemcpy3DParms.srcArray' in found_struct}} + @property def srcArray(self): return self._srcArray @@ -8893,24 +8521,24 @@ cdef class cudaMemcpy3DParms: psrcArray = int(cudaArray_t(srcArray)) cysrcArray = psrcArray self._srcArray._pvt_ptr[0] = cysrcArray - {{endif}} - {{if 'cudaMemcpy3DParms.srcPos' in found_struct}} + + @property def srcPos(self): return self._srcPos @srcPos.setter def srcPos(self, srcPos not None : cudaPos): string.memcpy(&self._pvt_ptr[0].srcPos, srcPos.getPtr(), sizeof(self._pvt_ptr[0].srcPos)) - {{endif}} - {{if 'cudaMemcpy3DParms.srcPtr' in found_struct}} + + @property def srcPtr(self): return self._srcPtr @srcPtr.setter def srcPtr(self, srcPtr not None : cudaPitchedPtr): string.memcpy(&self._pvt_ptr[0].srcPtr, srcPtr.getPtr(), sizeof(self._pvt_ptr[0].srcPtr)) - {{endif}} - {{if 'cudaMemcpy3DParms.dstArray' in found_struct}} + + @property def dstArray(self): return self._dstArray @@ -8926,41 +8554,39 @@ cdef class cudaMemcpy3DParms: pdstArray = int(cudaArray_t(dstArray)) cydstArray = pdstArray self._dstArray._pvt_ptr[0] = cydstArray - {{endif}} - {{if 'cudaMemcpy3DParms.dstPos' in found_struct}} + + @property def dstPos(self): return self._dstPos @dstPos.setter def dstPos(self, dstPos not None : cudaPos): string.memcpy(&self._pvt_ptr[0].dstPos, dstPos.getPtr(), sizeof(self._pvt_ptr[0].dstPos)) - {{endif}} - {{if 'cudaMemcpy3DParms.dstPtr' in found_struct}} + + @property def dstPtr(self): return self._dstPtr @dstPtr.setter def dstPtr(self, dstPtr not None : cudaPitchedPtr): string.memcpy(&self._pvt_ptr[0].dstPtr, dstPtr.getPtr(), sizeof(self._pvt_ptr[0].dstPtr)) - {{endif}} - {{if 'cudaMemcpy3DParms.extent' in found_struct}} + + @property def extent(self): return self._extent @extent.setter def extent(self, extent not None : cudaExtent): string.memcpy(&self._pvt_ptr[0].extent, extent.getPtr(), sizeof(self._pvt_ptr[0].extent)) - {{endif}} - {{if 'cudaMemcpy3DParms.kind' in found_struct}} + + @property def kind(self): return cudaMemcpyKind(self._pvt_ptr[0].kind) @kind.setter def kind(self, kind not None : cudaMemcpyKind): - self._pvt_ptr[0].kind = int(kind) - {{endif}} -{{endif}} -{{if 'cudaMemcpyNodeParams' in found_struct}} + self._pvt_ptr[0].kind = int(kind) + cdef class cudaMemcpyNodeParams: """ @@ -8968,23 +8594,23 @@ cdef class cudaMemcpyNodeParams: Attributes ---------- - {{if 'cudaMemcpyNodeParams.flags' in found_struct}} + flags : int Must be zero - {{endif}} - {{if 'cudaMemcpyNodeParams.reserved' in found_struct}} + + reserved : int Must be zero - {{endif}} - {{if 'cudaMemcpyNodeParams.ctx' in found_struct}} + + ctx : cudaExecutionContext_t Context in which to run the memcpy. If NULL will try to use the current context. - {{endif}} - {{if 'cudaMemcpyNodeParams.copyParams' in found_struct}} + + copyParams : cudaMemcpy3DParms Parameters for the memory copy - {{endif}} + Methods ------- @@ -8998,12 +8624,12 @@ cdef class cudaMemcpyNodeParams: self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass - {{if 'cudaMemcpyNodeParams.ctx' in found_struct}} + self._ctx = cudaExecutionContext_t(_ptr=&self._pvt_ptr[0].ctx) - {{endif}} - {{if 'cudaMemcpyNodeParams.copyParams' in found_struct}} + + self._copyParams = cudaMemcpy3DParms(_ptr=&self._pvt_ptr[0].copyParams) - {{endif}} + def __dealloc__(self): pass def getPtr(self): @@ -9011,50 +8637,50 @@ cdef class cudaMemcpyNodeParams: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaMemcpyNodeParams.flags' in found_struct}} + try: str_list += ['flags : ' + str(self.flags)] except ValueError: str_list += ['flags : '] - {{endif}} - {{if 'cudaMemcpyNodeParams.reserved' in found_struct}} + + try: str_list += ['reserved : ' + str(self.reserved)] except ValueError: str_list += ['reserved : '] - {{endif}} - {{if 'cudaMemcpyNodeParams.ctx' in found_struct}} + + try: str_list += ['ctx : ' + str(self.ctx)] except ValueError: str_list += ['ctx : '] - {{endif}} - {{if 'cudaMemcpyNodeParams.copyParams' in found_struct}} + + try: str_list += ['copyParams :\n' + '\n'.join([' ' + line for line in str(self.copyParams).splitlines()])] except ValueError: str_list += ['copyParams : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaMemcpyNodeParams.flags' in found_struct}} + @property def flags(self): return self._pvt_ptr[0].flags @flags.setter def flags(self, int flags): self._pvt_ptr[0].flags = flags - {{endif}} - {{if 'cudaMemcpyNodeParams.reserved' in found_struct}} + + @property def reserved(self): return self._pvt_ptr[0].reserved @reserved.setter def reserved(self, int reserved): self._pvt_ptr[0].reserved = reserved - {{endif}} - {{if 'cudaMemcpyNodeParams.ctx' in found_struct}} + + @property def ctx(self): return self._ctx @@ -9070,17 +8696,15 @@ cdef class cudaMemcpyNodeParams: pctx = int(cudaExecutionContext_t(ctx)) cyctx = pctx self._ctx._pvt_ptr[0] = cyctx - {{endif}} - {{if 'cudaMemcpyNodeParams.copyParams' in found_struct}} + + @property def copyParams(self): return self._copyParams @copyParams.setter def copyParams(self, copyParams not None : cudaMemcpy3DParms): string.memcpy(&self._pvt_ptr[0].copyParams, copyParams.getPtr(), sizeof(self._pvt_ptr[0].copyParams)) - {{endif}} -{{endif}} -{{if 'cudaMemcpy3DPeerParms' in found_struct}} + cdef class cudaMemcpy3DPeerParms: """ @@ -9088,42 +8712,42 @@ cdef class cudaMemcpy3DPeerParms: Attributes ---------- - {{if 'cudaMemcpy3DPeerParms.srcArray' in found_struct}} + srcArray : cudaArray_t Source memory address - {{endif}} - {{if 'cudaMemcpy3DPeerParms.srcPos' in found_struct}} + + srcPos : cudaPos Source position offset - {{endif}} - {{if 'cudaMemcpy3DPeerParms.srcPtr' in found_struct}} + + srcPtr : cudaPitchedPtr Pitched source memory address - {{endif}} - {{if 'cudaMemcpy3DPeerParms.srcDevice' in found_struct}} + + srcDevice : int Source device - {{endif}} - {{if 'cudaMemcpy3DPeerParms.dstArray' in found_struct}} + + dstArray : cudaArray_t Destination memory address - {{endif}} - {{if 'cudaMemcpy3DPeerParms.dstPos' in found_struct}} + + dstPos : cudaPos Destination position offset - {{endif}} - {{if 'cudaMemcpy3DPeerParms.dstPtr' in found_struct}} + + dstPtr : cudaPitchedPtr Pitched destination memory address - {{endif}} - {{if 'cudaMemcpy3DPeerParms.dstDevice' in found_struct}} + + dstDevice : int Destination device - {{endif}} - {{if 'cudaMemcpy3DPeerParms.extent' in found_struct}} + + extent : cudaExtent Requested memory copy size - {{endif}} + Methods ------- @@ -9137,27 +8761,27 @@ cdef class cudaMemcpy3DPeerParms: self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass - {{if 'cudaMemcpy3DPeerParms.srcArray' in found_struct}} + self._srcArray = cudaArray_t(_ptr=&self._pvt_ptr[0].srcArray) - {{endif}} - {{if 'cudaMemcpy3DPeerParms.srcPos' in found_struct}} + + self._srcPos = cudaPos(_ptr=&self._pvt_ptr[0].srcPos) - {{endif}} - {{if 'cudaMemcpy3DPeerParms.srcPtr' in found_struct}} + + self._srcPtr = cudaPitchedPtr(_ptr=&self._pvt_ptr[0].srcPtr) - {{endif}} - {{if 'cudaMemcpy3DPeerParms.dstArray' in found_struct}} + + self._dstArray = cudaArray_t(_ptr=&self._pvt_ptr[0].dstArray) - {{endif}} - {{if 'cudaMemcpy3DPeerParms.dstPos' in found_struct}} + + self._dstPos = cudaPos(_ptr=&self._pvt_ptr[0].dstPos) - {{endif}} - {{if 'cudaMemcpy3DPeerParms.dstPtr' in found_struct}} + + self._dstPtr = cudaPitchedPtr(_ptr=&self._pvt_ptr[0].dstPtr) - {{endif}} - {{if 'cudaMemcpy3DPeerParms.extent' in found_struct}} + + self._extent = cudaExtent(_ptr=&self._pvt_ptr[0].extent) - {{endif}} + def __dealloc__(self): pass def getPtr(self): @@ -9165,64 +8789,64 @@ cdef class cudaMemcpy3DPeerParms: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaMemcpy3DPeerParms.srcArray' in found_struct}} + try: str_list += ['srcArray : ' + str(self.srcArray)] except ValueError: str_list += ['srcArray : '] - {{endif}} - {{if 'cudaMemcpy3DPeerParms.srcPos' in found_struct}} + + try: str_list += ['srcPos :\n' + '\n'.join([' ' + line for line in str(self.srcPos).splitlines()])] except ValueError: str_list += ['srcPos : '] - {{endif}} - {{if 'cudaMemcpy3DPeerParms.srcPtr' in found_struct}} + + try: str_list += ['srcPtr :\n' + '\n'.join([' ' + line for line in str(self.srcPtr).splitlines()])] except ValueError: str_list += ['srcPtr : '] - {{endif}} - {{if 'cudaMemcpy3DPeerParms.srcDevice' in found_struct}} + + try: str_list += ['srcDevice : ' + str(self.srcDevice)] except ValueError: str_list += ['srcDevice : '] - {{endif}} - {{if 'cudaMemcpy3DPeerParms.dstArray' in found_struct}} + + try: str_list += ['dstArray : ' + str(self.dstArray)] except ValueError: str_list += ['dstArray : '] - {{endif}} - {{if 'cudaMemcpy3DPeerParms.dstPos' in found_struct}} + + try: str_list += ['dstPos :\n' + '\n'.join([' ' + line for line in str(self.dstPos).splitlines()])] except ValueError: str_list += ['dstPos : '] - {{endif}} - {{if 'cudaMemcpy3DPeerParms.dstPtr' in found_struct}} + + try: str_list += ['dstPtr :\n' + '\n'.join([' ' + line for line in str(self.dstPtr).splitlines()])] except ValueError: str_list += ['dstPtr : '] - {{endif}} - {{if 'cudaMemcpy3DPeerParms.dstDevice' in found_struct}} + + try: str_list += ['dstDevice : ' + str(self.dstDevice)] except ValueError: str_list += ['dstDevice : '] - {{endif}} - {{if 'cudaMemcpy3DPeerParms.extent' in found_struct}} + + try: str_list += ['extent :\n' + '\n'.join([' ' + line for line in str(self.extent).splitlines()])] except ValueError: str_list += ['extent : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaMemcpy3DPeerParms.srcArray' in found_struct}} + @property def srcArray(self): return self._srcArray @@ -9238,32 +8862,32 @@ cdef class cudaMemcpy3DPeerParms: psrcArray = int(cudaArray_t(srcArray)) cysrcArray = psrcArray self._srcArray._pvt_ptr[0] = cysrcArray - {{endif}} - {{if 'cudaMemcpy3DPeerParms.srcPos' in found_struct}} + + @property def srcPos(self): return self._srcPos @srcPos.setter def srcPos(self, srcPos not None : cudaPos): string.memcpy(&self._pvt_ptr[0].srcPos, srcPos.getPtr(), sizeof(self._pvt_ptr[0].srcPos)) - {{endif}} - {{if 'cudaMemcpy3DPeerParms.srcPtr' in found_struct}} + + @property def srcPtr(self): return self._srcPtr @srcPtr.setter def srcPtr(self, srcPtr not None : cudaPitchedPtr): string.memcpy(&self._pvt_ptr[0].srcPtr, srcPtr.getPtr(), sizeof(self._pvt_ptr[0].srcPtr)) - {{endif}} - {{if 'cudaMemcpy3DPeerParms.srcDevice' in found_struct}} + + @property def srcDevice(self): return self._pvt_ptr[0].srcDevice @srcDevice.setter def srcDevice(self, int srcDevice): self._pvt_ptr[0].srcDevice = srcDevice - {{endif}} - {{if 'cudaMemcpy3DPeerParms.dstArray' in found_struct}} + + @property def dstArray(self): return self._dstArray @@ -9279,41 +8903,39 @@ cdef class cudaMemcpy3DPeerParms: pdstArray = int(cudaArray_t(dstArray)) cydstArray = pdstArray self._dstArray._pvt_ptr[0] = cydstArray - {{endif}} - {{if 'cudaMemcpy3DPeerParms.dstPos' in found_struct}} + + @property def dstPos(self): return self._dstPos @dstPos.setter def dstPos(self, dstPos not None : cudaPos): string.memcpy(&self._pvt_ptr[0].dstPos, dstPos.getPtr(), sizeof(self._pvt_ptr[0].dstPos)) - {{endif}} - {{if 'cudaMemcpy3DPeerParms.dstPtr' in found_struct}} + + @property def dstPtr(self): return self._dstPtr @dstPtr.setter def dstPtr(self, dstPtr not None : cudaPitchedPtr): string.memcpy(&self._pvt_ptr[0].dstPtr, dstPtr.getPtr(), sizeof(self._pvt_ptr[0].dstPtr)) - {{endif}} - {{if 'cudaMemcpy3DPeerParms.dstDevice' in found_struct}} + + @property def dstDevice(self): return self._pvt_ptr[0].dstDevice @dstDevice.setter def dstDevice(self, int dstDevice): self._pvt_ptr[0].dstDevice = dstDevice - {{endif}} - {{if 'cudaMemcpy3DPeerParms.extent' in found_struct}} + + @property def extent(self): return self._extent @extent.setter def extent(self, extent not None : cudaExtent): string.memcpy(&self._pvt_ptr[0].extent, extent.getPtr(), sizeof(self._pvt_ptr[0].extent)) - {{endif}} -{{endif}} -{{if 'cudaMemsetParams' in found_struct}} + cdef class cudaMemsetParams: """ @@ -9321,30 +8943,30 @@ cdef class cudaMemsetParams: Attributes ---------- - {{if 'cudaMemsetParams.dst' in found_struct}} + dst : Any Destination device pointer - {{endif}} - {{if 'cudaMemsetParams.pitch' in found_struct}} + + pitch : size_t Pitch of destination device pointer. Unused if height is 1 - {{endif}} - {{if 'cudaMemsetParams.value' in found_struct}} + + value : unsigned int Value to be set - {{endif}} - {{if 'cudaMemsetParams.elementSize' in found_struct}} + + elementSize : unsigned int Size of each element in bytes. Must be 1, 2, or 4. - {{endif}} - {{if 'cudaMemsetParams.width' in found_struct}} + + width : size_t Width of the row in elements - {{endif}} - {{if 'cudaMemsetParams.height' in found_struct}} + + height : size_t Number of rows - {{endif}} + Methods ------- @@ -9365,46 +8987,46 @@ cdef class cudaMemsetParams: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaMemsetParams.dst' in found_struct}} + try: str_list += ['dst : ' + hex(self.dst)] except ValueError: str_list += ['dst : '] - {{endif}} - {{if 'cudaMemsetParams.pitch' in found_struct}} + + try: str_list += ['pitch : ' + str(self.pitch)] except ValueError: str_list += ['pitch : '] - {{endif}} - {{if 'cudaMemsetParams.value' in found_struct}} + + try: str_list += ['value : ' + str(self.value)] except ValueError: str_list += ['value : '] - {{endif}} - {{if 'cudaMemsetParams.elementSize' in found_struct}} + + try: str_list += ['elementSize : ' + str(self.elementSize)] except ValueError: str_list += ['elementSize : '] - {{endif}} - {{if 'cudaMemsetParams.width' in found_struct}} + + try: str_list += ['width : ' + str(self.width)] except ValueError: str_list += ['width : '] - {{endif}} - {{if 'cudaMemsetParams.height' in found_struct}} + + try: str_list += ['height : ' + str(self.height)] except ValueError: str_list += ['height : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaMemsetParams.dst' in found_struct}} + @property def dst(self): return self._pvt_ptr[0].dst @@ -9412,49 +9034,47 @@ cdef class cudaMemsetParams: def dst(self, dst): self._cydst = _HelperInputVoidPtr(dst) self._pvt_ptr[0].dst = self._cydst.cptr - {{endif}} - {{if 'cudaMemsetParams.pitch' in found_struct}} + + @property def pitch(self): return self._pvt_ptr[0].pitch @pitch.setter def pitch(self, size_t pitch): self._pvt_ptr[0].pitch = pitch - {{endif}} - {{if 'cudaMemsetParams.value' in found_struct}} + + @property def value(self): return self._pvt_ptr[0].value @value.setter def value(self, unsigned int value): self._pvt_ptr[0].value = value - {{endif}} - {{if 'cudaMemsetParams.elementSize' in found_struct}} + + @property def elementSize(self): return self._pvt_ptr[0].elementSize @elementSize.setter def elementSize(self, unsigned int elementSize): self._pvt_ptr[0].elementSize = elementSize - {{endif}} - {{if 'cudaMemsetParams.width' in found_struct}} + + @property def width(self): return self._pvt_ptr[0].width @width.setter def width(self, size_t width): self._pvt_ptr[0].width = width - {{endif}} - {{if 'cudaMemsetParams.height' in found_struct}} + + @property def height(self): return self._pvt_ptr[0].height @height.setter def height(self, size_t height): self._pvt_ptr[0].height = height - {{endif}} -{{endif}} -{{if 'cudaMemsetParamsV2' in found_struct}} + cdef class cudaMemsetParamsV2: """ @@ -9462,35 +9082,35 @@ cdef class cudaMemsetParamsV2: Attributes ---------- - {{if 'cudaMemsetParamsV2.dst' in found_struct}} + dst : Any Destination device pointer - {{endif}} - {{if 'cudaMemsetParamsV2.pitch' in found_struct}} + + pitch : size_t Pitch of destination device pointer. Unused if height is 1 - {{endif}} - {{if 'cudaMemsetParamsV2.value' in found_struct}} + + value : unsigned int Value to be set - {{endif}} - {{if 'cudaMemsetParamsV2.elementSize' in found_struct}} + + elementSize : unsigned int Size of each element in bytes. Must be 1, 2, or 4. - {{endif}} - {{if 'cudaMemsetParamsV2.width' in found_struct}} + + width : size_t Width of the row in elements - {{endif}} - {{if 'cudaMemsetParamsV2.height' in found_struct}} + + height : size_t Number of rows - {{endif}} - {{if 'cudaMemsetParamsV2.ctx' in found_struct}} + + ctx : cudaExecutionContext_t Context in which to run the memset. If NULL will try to use the current context. - {{endif}} + Methods ------- @@ -9504,9 +9124,9 @@ cdef class cudaMemsetParamsV2: self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass - {{if 'cudaMemsetParamsV2.ctx' in found_struct}} + self._ctx = cudaExecutionContext_t(_ptr=&self._pvt_ptr[0].ctx) - {{endif}} + def __dealloc__(self): pass def getPtr(self): @@ -9514,52 +9134,52 @@ cdef class cudaMemsetParamsV2: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaMemsetParamsV2.dst' in found_struct}} + try: str_list += ['dst : ' + hex(self.dst)] except ValueError: str_list += ['dst : '] - {{endif}} - {{if 'cudaMemsetParamsV2.pitch' in found_struct}} + + try: str_list += ['pitch : ' + str(self.pitch)] except ValueError: str_list += ['pitch : '] - {{endif}} - {{if 'cudaMemsetParamsV2.value' in found_struct}} + + try: str_list += ['value : ' + str(self.value)] except ValueError: str_list += ['value : '] - {{endif}} - {{if 'cudaMemsetParamsV2.elementSize' in found_struct}} + + try: str_list += ['elementSize : ' + str(self.elementSize)] except ValueError: str_list += ['elementSize : '] - {{endif}} - {{if 'cudaMemsetParamsV2.width' in found_struct}} + + try: str_list += ['width : ' + str(self.width)] except ValueError: str_list += ['width : '] - {{endif}} - {{if 'cudaMemsetParamsV2.height' in found_struct}} + + try: str_list += ['height : ' + str(self.height)] except ValueError: str_list += ['height : '] - {{endif}} - {{if 'cudaMemsetParamsV2.ctx' in found_struct}} + + try: str_list += ['ctx : ' + str(self.ctx)] except ValueError: str_list += ['ctx : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaMemsetParamsV2.dst' in found_struct}} + @property def dst(self): return self._pvt_ptr[0].dst @@ -9567,48 +9187,48 @@ cdef class cudaMemsetParamsV2: def dst(self, dst): self._cydst = _HelperInputVoidPtr(dst) self._pvt_ptr[0].dst = self._cydst.cptr - {{endif}} - {{if 'cudaMemsetParamsV2.pitch' in found_struct}} + + @property def pitch(self): return self._pvt_ptr[0].pitch @pitch.setter def pitch(self, size_t pitch): self._pvt_ptr[0].pitch = pitch - {{endif}} - {{if 'cudaMemsetParamsV2.value' in found_struct}} + + @property def value(self): return self._pvt_ptr[0].value @value.setter def value(self, unsigned int value): self._pvt_ptr[0].value = value - {{endif}} - {{if 'cudaMemsetParamsV2.elementSize' in found_struct}} + + @property def elementSize(self): return self._pvt_ptr[0].elementSize @elementSize.setter def elementSize(self, unsigned int elementSize): self._pvt_ptr[0].elementSize = elementSize - {{endif}} - {{if 'cudaMemsetParamsV2.width' in found_struct}} + + @property def width(self): return self._pvt_ptr[0].width @width.setter def width(self, size_t width): self._pvt_ptr[0].width = width - {{endif}} - {{if 'cudaMemsetParamsV2.height' in found_struct}} + + @property def height(self): return self._pvt_ptr[0].height @height.setter def height(self, size_t height): self._pvt_ptr[0].height = height - {{endif}} - {{if 'cudaMemsetParamsV2.ctx' in found_struct}} + + @property def ctx(self): return self._ctx @@ -9624,9 +9244,7 @@ cdef class cudaMemsetParamsV2: pctx = int(cudaExecutionContext_t(ctx)) cyctx = pctx self._ctx._pvt_ptr[0] = cyctx - {{endif}} -{{endif}} -{{if 'cudaAccessPolicyWindow' in found_struct}} + cdef class cudaAccessPolicyWindow: """ @@ -9641,30 +9259,30 @@ cdef class cudaAccessPolicyWindow: Attributes ---------- - {{if 'cudaAccessPolicyWindow.base_ptr' in found_struct}} + base_ptr : Any Starting address of the access policy window. CUDA driver may align it. - {{endif}} - {{if 'cudaAccessPolicyWindow.num_bytes' in found_struct}} + + num_bytes : size_t Size in bytes of the window policy. CUDA driver may restrict the maximum size and alignment. - {{endif}} - {{if 'cudaAccessPolicyWindow.hitRatio' in found_struct}} + + hitRatio : float hitRatio specifies percentage of lines assigned hitProp, rest are assigned missProp. - {{endif}} - {{if 'cudaAccessPolicyWindow.hitProp' in found_struct}} + + hitProp : cudaAccessProperty ::CUaccessProperty set for hit. - {{endif}} - {{if 'cudaAccessPolicyWindow.missProp' in found_struct}} + + missProp : cudaAccessProperty ::CUaccessProperty set for miss. Must be either NORMAL or STREAMING. - {{endif}} + Methods ------- @@ -9685,40 +9303,40 @@ cdef class cudaAccessPolicyWindow: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaAccessPolicyWindow.base_ptr' in found_struct}} + try: str_list += ['base_ptr : ' + hex(self.base_ptr)] except ValueError: str_list += ['base_ptr : '] - {{endif}} - {{if 'cudaAccessPolicyWindow.num_bytes' in found_struct}} + + try: str_list += ['num_bytes : ' + str(self.num_bytes)] except ValueError: str_list += ['num_bytes : '] - {{endif}} - {{if 'cudaAccessPolicyWindow.hitRatio' in found_struct}} + + try: str_list += ['hitRatio : ' + str(self.hitRatio)] except ValueError: str_list += ['hitRatio : '] - {{endif}} - {{if 'cudaAccessPolicyWindow.hitProp' in found_struct}} + + try: str_list += ['hitProp : ' + str(self.hitProp)] except ValueError: str_list += ['hitProp : '] - {{endif}} - {{if 'cudaAccessPolicyWindow.missProp' in found_struct}} + + try: str_list += ['missProp : ' + str(self.missProp)] except ValueError: str_list += ['missProp : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaAccessPolicyWindow.base_ptr' in found_struct}} + @property def base_ptr(self): return self._pvt_ptr[0].base_ptr @@ -9726,41 +9344,39 @@ cdef class cudaAccessPolicyWindow: def base_ptr(self, base_ptr): self._cybase_ptr = _HelperInputVoidPtr(base_ptr) self._pvt_ptr[0].base_ptr = self._cybase_ptr.cptr - {{endif}} - {{if 'cudaAccessPolicyWindow.num_bytes' in found_struct}} + + @property def num_bytes(self): return self._pvt_ptr[0].num_bytes @num_bytes.setter def num_bytes(self, size_t num_bytes): self._pvt_ptr[0].num_bytes = num_bytes - {{endif}} - {{if 'cudaAccessPolicyWindow.hitRatio' in found_struct}} + + @property def hitRatio(self): return self._pvt_ptr[0].hitRatio @hitRatio.setter def hitRatio(self, float hitRatio): self._pvt_ptr[0].hitRatio = hitRatio - {{endif}} - {{if 'cudaAccessPolicyWindow.hitProp' in found_struct}} + + @property def hitProp(self): return cudaAccessProperty(self._pvt_ptr[0].hitProp) @hitProp.setter def hitProp(self, hitProp not None : cudaAccessProperty): - self._pvt_ptr[0].hitProp = int(hitProp) - {{endif}} - {{if 'cudaAccessPolicyWindow.missProp' in found_struct}} + self._pvt_ptr[0].hitProp = int(hitProp) + + @property def missProp(self): return cudaAccessProperty(self._pvt_ptr[0].missProp) @missProp.setter def missProp(self, missProp not None : cudaAccessProperty): - self._pvt_ptr[0].missProp = int(missProp) - {{endif}} -{{endif}} -{{if 'cudaHostNodeParams' in found_struct}} + self._pvt_ptr[0].missProp = int(missProp) + cdef class cudaHostNodeParams: """ @@ -9768,14 +9384,14 @@ cdef class cudaHostNodeParams: Attributes ---------- - {{if 'cudaHostNodeParams.fn' in found_struct}} + fn : cudaHostFn_t The function to call when the node executes - {{endif}} - {{if 'cudaHostNodeParams.userData' in found_struct}} + + userData : Any Argument to pass to the function - {{endif}} + Methods ------- @@ -9789,9 +9405,9 @@ cdef class cudaHostNodeParams: self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass - {{if 'cudaHostNodeParams.fn' in found_struct}} + self._fn = cudaHostFn_t(_ptr=&self._pvt_ptr[0].fn) - {{endif}} + def __dealloc__(self): pass def getPtr(self): @@ -9799,22 +9415,22 @@ cdef class cudaHostNodeParams: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaHostNodeParams.fn' in found_struct}} + try: str_list += ['fn : ' + str(self.fn)] except ValueError: str_list += ['fn : '] - {{endif}} - {{if 'cudaHostNodeParams.userData' in found_struct}} + + try: str_list += ['userData : ' + hex(self.userData)] except ValueError: str_list += ['userData : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaHostNodeParams.fn' in found_struct}} + @property def fn(self): return self._fn @@ -9830,8 +9446,8 @@ cdef class cudaHostNodeParams: pfn = int(cudaHostFn_t(fn)) cyfn = pfn self._fn._pvt_ptr[0] = cyfn - {{endif}} - {{if 'cudaHostNodeParams.userData' in found_struct}} + + @property def userData(self): return self._pvt_ptr[0].userData @@ -9839,9 +9455,7 @@ cdef class cudaHostNodeParams: def userData(self, userData): self._cyuserData = _HelperInputVoidPtr(userData) self._pvt_ptr[0].userData = self._cyuserData.cptr - {{endif}} -{{endif}} -{{if 'cudaHostNodeParamsV2' in found_struct}} + cdef class cudaHostNodeParamsV2: """ @@ -9849,18 +9463,18 @@ cdef class cudaHostNodeParamsV2: Attributes ---------- - {{if 'cudaHostNodeParamsV2.fn' in found_struct}} + fn : cudaHostFn_t The function to call when the node executes - {{endif}} - {{if 'cudaHostNodeParamsV2.userData' in found_struct}} + + userData : Any Argument to pass to the function - {{endif}} - {{if 'cudaHostNodeParamsV2.syncMode' in found_struct}} + + syncMode : unsigned int The synchronization mode to use for the host task - {{endif}} + Methods ------- @@ -9874,9 +9488,9 @@ cdef class cudaHostNodeParamsV2: self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass - {{if 'cudaHostNodeParamsV2.fn' in found_struct}} + self._fn = cudaHostFn_t(_ptr=&self._pvt_ptr[0].fn) - {{endif}} + def __dealloc__(self): pass def getPtr(self): @@ -9884,28 +9498,28 @@ cdef class cudaHostNodeParamsV2: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaHostNodeParamsV2.fn' in found_struct}} + try: str_list += ['fn : ' + str(self.fn)] except ValueError: str_list += ['fn : '] - {{endif}} - {{if 'cudaHostNodeParamsV2.userData' in found_struct}} + + try: str_list += ['userData : ' + hex(self.userData)] except ValueError: str_list += ['userData : '] - {{endif}} - {{if 'cudaHostNodeParamsV2.syncMode' in found_struct}} + + try: str_list += ['syncMode : ' + str(self.syncMode)] except ValueError: str_list += ['syncMode : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaHostNodeParamsV2.fn' in found_struct}} + @property def fn(self): return self._fn @@ -9921,8 +9535,8 @@ cdef class cudaHostNodeParamsV2: pfn = int(cudaHostFn_t(fn)) cyfn = pfn self._fn._pvt_ptr[0] = cyfn - {{endif}} - {{if 'cudaHostNodeParamsV2.userData' in found_struct}} + + @property def userData(self): return self._pvt_ptr[0].userData @@ -9930,26 +9544,24 @@ cdef class cudaHostNodeParamsV2: def userData(self, userData): self._cyuserData = _HelperInputVoidPtr(userData) self._pvt_ptr[0].userData = self._cyuserData.cptr - {{endif}} - {{if 'cudaHostNodeParamsV2.syncMode' in found_struct}} + + @property def syncMode(self): return self._pvt_ptr[0].syncMode @syncMode.setter def syncMode(self, unsigned int syncMode): self._pvt_ptr[0].syncMode = syncMode - {{endif}} -{{endif}} -{{if 'cudaResourceDesc.res.array' in found_struct}} + cdef class anon_struct1: """ Attributes ---------- - {{if 'cudaResourceDesc.res.array.array' in found_struct}} + array : cudaArray_t - {{endif}} + Methods ------- @@ -9961,9 +9573,9 @@ cdef class anon_struct1: def __init__(self, void_ptr _ptr): pass - {{if 'cudaResourceDesc.res.array.array' in found_struct}} + self._array = cudaArray_t(_ptr=&self._pvt_ptr[0].res.array.array) - {{endif}} + def __dealloc__(self): pass def getPtr(self): @@ -9971,16 +9583,16 @@ cdef class anon_struct1: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaResourceDesc.res.array.array' in found_struct}} + try: str_list += ['array : ' + str(self.array)] except ValueError: str_list += ['array : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaResourceDesc.res.array.array' in found_struct}} + @property def array(self): return self._array @@ -9996,18 +9608,16 @@ cdef class anon_struct1: parray = int(cudaArray_t(array)) cyarray = parray self._array._pvt_ptr[0] = cyarray - {{endif}} -{{endif}} -{{if 'cudaResourceDesc.res.mipmap' in found_struct}} + cdef class anon_struct2: """ Attributes ---------- - {{if 'cudaResourceDesc.res.mipmap.mipmap' in found_struct}} + mipmap : cudaMipmappedArray_t - {{endif}} + Methods ------- @@ -10019,9 +9629,9 @@ cdef class anon_struct2: def __init__(self, void_ptr _ptr): pass - {{if 'cudaResourceDesc.res.mipmap.mipmap' in found_struct}} + self._mipmap = cudaMipmappedArray_t(_ptr=&self._pvt_ptr[0].res.mipmap.mipmap) - {{endif}} + def __dealloc__(self): pass def getPtr(self): @@ -10029,16 +9639,16 @@ cdef class anon_struct2: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaResourceDesc.res.mipmap.mipmap' in found_struct}} + try: str_list += ['mipmap : ' + str(self.mipmap)] except ValueError: str_list += ['mipmap : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaResourceDesc.res.mipmap.mipmap' in found_struct}} + @property def mipmap(self): return self._mipmap @@ -10054,26 +9664,24 @@ cdef class anon_struct2: pmipmap = int(cudaMipmappedArray_t(mipmap)) cymipmap = pmipmap self._mipmap._pvt_ptr[0] = cymipmap - {{endif}} -{{endif}} -{{if 'cudaResourceDesc.res.linear' in found_struct}} + cdef class anon_struct3: """ Attributes ---------- - {{if 'cudaResourceDesc.res.linear.devPtr' in found_struct}} + devPtr : Any - {{endif}} - {{if 'cudaResourceDesc.res.linear.desc' in found_struct}} + + desc : cudaChannelFormatDesc - {{endif}} - {{if 'cudaResourceDesc.res.linear.sizeInBytes' in found_struct}} + + sizeInBytes : size_t - {{endif}} + Methods ------- @@ -10085,9 +9693,9 @@ cdef class anon_struct3: def __init__(self, void_ptr _ptr): pass - {{if 'cudaResourceDesc.res.linear.desc' in found_struct}} + self._desc = cudaChannelFormatDesc(_ptr=&self._pvt_ptr[0].res.linear.desc) - {{endif}} + def __dealloc__(self): pass def getPtr(self): @@ -10095,28 +9703,28 @@ cdef class anon_struct3: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaResourceDesc.res.linear.devPtr' in found_struct}} + try: str_list += ['devPtr : ' + hex(self.devPtr)] except ValueError: str_list += ['devPtr : '] - {{endif}} - {{if 'cudaResourceDesc.res.linear.desc' in found_struct}} + + try: str_list += ['desc :\n' + '\n'.join([' ' + line for line in str(self.desc).splitlines()])] except ValueError: str_list += ['desc : '] - {{endif}} - {{if 'cudaResourceDesc.res.linear.sizeInBytes' in found_struct}} + + try: str_list += ['sizeInBytes : ' + str(self.sizeInBytes)] except ValueError: str_list += ['sizeInBytes : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaResourceDesc.res.linear.devPtr' in found_struct}} + @property def devPtr(self): return self._pvt_ptr[0].res.linear.devPtr @@ -10124,50 +9732,48 @@ cdef class anon_struct3: def devPtr(self, devPtr): self._cydevPtr = _HelperInputVoidPtr(devPtr) self._pvt_ptr[0].res.linear.devPtr = self._cydevPtr.cptr - {{endif}} - {{if 'cudaResourceDesc.res.linear.desc' in found_struct}} + + @property def desc(self): return self._desc @desc.setter def desc(self, desc not None : cudaChannelFormatDesc): string.memcpy(&self._pvt_ptr[0].res.linear.desc, desc.getPtr(), sizeof(self._pvt_ptr[0].res.linear.desc)) - {{endif}} - {{if 'cudaResourceDesc.res.linear.sizeInBytes' in found_struct}} + + @property def sizeInBytes(self): return self._pvt_ptr[0].res.linear.sizeInBytes @sizeInBytes.setter def sizeInBytes(self, size_t sizeInBytes): self._pvt_ptr[0].res.linear.sizeInBytes = sizeInBytes - {{endif}} -{{endif}} -{{if 'cudaResourceDesc.res.pitch2D' in found_struct}} + cdef class anon_struct4: """ Attributes ---------- - {{if 'cudaResourceDesc.res.pitch2D.devPtr' in found_struct}} + devPtr : Any - {{endif}} - {{if 'cudaResourceDesc.res.pitch2D.desc' in found_struct}} + + desc : cudaChannelFormatDesc - {{endif}} - {{if 'cudaResourceDesc.res.pitch2D.width' in found_struct}} + + width : size_t - {{endif}} - {{if 'cudaResourceDesc.res.pitch2D.height' in found_struct}} + + height : size_t - {{endif}} - {{if 'cudaResourceDesc.res.pitch2D.pitchInBytes' in found_struct}} + + pitchInBytes : size_t - {{endif}} + Methods ------- @@ -10179,9 +9785,9 @@ cdef class anon_struct4: def __init__(self, void_ptr _ptr): pass - {{if 'cudaResourceDesc.res.pitch2D.desc' in found_struct}} + self._desc = cudaChannelFormatDesc(_ptr=&self._pvt_ptr[0].res.pitch2D.desc) - {{endif}} + def __dealloc__(self): pass def getPtr(self): @@ -10189,40 +9795,40 @@ cdef class anon_struct4: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaResourceDesc.res.pitch2D.devPtr' in found_struct}} + try: str_list += ['devPtr : ' + hex(self.devPtr)] except ValueError: str_list += ['devPtr : '] - {{endif}} - {{if 'cudaResourceDesc.res.pitch2D.desc' in found_struct}} + + try: str_list += ['desc :\n' + '\n'.join([' ' + line for line in str(self.desc).splitlines()])] except ValueError: str_list += ['desc : '] - {{endif}} - {{if 'cudaResourceDesc.res.pitch2D.width' in found_struct}} + + try: str_list += ['width : ' + str(self.width)] except ValueError: str_list += ['width : '] - {{endif}} - {{if 'cudaResourceDesc.res.pitch2D.height' in found_struct}} + + try: str_list += ['height : ' + str(self.height)] except ValueError: str_list += ['height : '] - {{endif}} - {{if 'cudaResourceDesc.res.pitch2D.pitchInBytes' in found_struct}} + + try: str_list += ['pitchInBytes : ' + str(self.pitchInBytes)] except ValueError: str_list += ['pitchInBytes : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaResourceDesc.res.pitch2D.devPtr' in found_struct}} + @property def devPtr(self): return self._pvt_ptr[0].res.pitch2D.devPtr @@ -10230,50 +9836,48 @@ cdef class anon_struct4: def devPtr(self, devPtr): self._cydevPtr = _HelperInputVoidPtr(devPtr) self._pvt_ptr[0].res.pitch2D.devPtr = self._cydevPtr.cptr - {{endif}} - {{if 'cudaResourceDesc.res.pitch2D.desc' in found_struct}} + + @property def desc(self): return self._desc @desc.setter def desc(self, desc not None : cudaChannelFormatDesc): string.memcpy(&self._pvt_ptr[0].res.pitch2D.desc, desc.getPtr(), sizeof(self._pvt_ptr[0].res.pitch2D.desc)) - {{endif}} - {{if 'cudaResourceDesc.res.pitch2D.width' in found_struct}} + + @property def width(self): return self._pvt_ptr[0].res.pitch2D.width @width.setter def width(self, size_t width): self._pvt_ptr[0].res.pitch2D.width = width - {{endif}} - {{if 'cudaResourceDesc.res.pitch2D.height' in found_struct}} + + @property def height(self): return self._pvt_ptr[0].res.pitch2D.height @height.setter def height(self, size_t height): self._pvt_ptr[0].res.pitch2D.height = height - {{endif}} - {{if 'cudaResourceDesc.res.pitch2D.pitchInBytes' in found_struct}} + + @property def pitchInBytes(self): return self._pvt_ptr[0].res.pitch2D.pitchInBytes @pitchInBytes.setter def pitchInBytes(self, size_t pitchInBytes): self._pvt_ptr[0].res.pitch2D.pitchInBytes = pitchInBytes - {{endif}} -{{endif}} -{{if 'cudaResourceDesc.res.reserved' in found_struct}} + cdef class anon_struct5: """ Attributes ---------- - {{if 'cudaResourceDesc.res.reserved.reserved' in found_struct}} + reserved : list[int] - {{endif}} + Methods ------- @@ -10292,50 +9896,48 @@ cdef class anon_struct5: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaResourceDesc.res.reserved.reserved' in found_struct}} + try: str_list += ['reserved : ' + str(self.reserved)] except ValueError: str_list += ['reserved : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaResourceDesc.res.reserved.reserved' in found_struct}} + @property def reserved(self): return self._pvt_ptr[0].res.reserved.reserved @reserved.setter def reserved(self, reserved): self._pvt_ptr[0].res.reserved.reserved = reserved - {{endif}} -{{endif}} -{{if 'cudaResourceDesc.res' in found_struct}} + cdef class anon_union0: """ Attributes ---------- - {{if 'cudaResourceDesc.res.array' in found_struct}} + array : anon_struct1 - {{endif}} - {{if 'cudaResourceDesc.res.mipmap' in found_struct}} + + mipmap : anon_struct2 - {{endif}} - {{if 'cudaResourceDesc.res.linear' in found_struct}} + + linear : anon_struct3 - {{endif}} - {{if 'cudaResourceDesc.res.pitch2D' in found_struct}} + + pitch2D : anon_struct4 - {{endif}} - {{if 'cudaResourceDesc.res.reserved' in found_struct}} + + reserved : anon_struct5 - {{endif}} + Methods ------- @@ -10347,21 +9949,21 @@ cdef class anon_union0: def __init__(self, void_ptr _ptr): pass - {{if 'cudaResourceDesc.res.array' in found_struct}} + self._array = anon_struct1(_ptr=self._pvt_ptr) - {{endif}} - {{if 'cudaResourceDesc.res.mipmap' in found_struct}} + + self._mipmap = anon_struct2(_ptr=self._pvt_ptr) - {{endif}} - {{if 'cudaResourceDesc.res.linear' in found_struct}} + + self._linear = anon_struct3(_ptr=self._pvt_ptr) - {{endif}} - {{if 'cudaResourceDesc.res.pitch2D' in found_struct}} + + self._pitch2D = anon_struct4(_ptr=self._pvt_ptr) - {{endif}} - {{if 'cudaResourceDesc.res.reserved' in found_struct}} + + self._reserved = anon_struct5(_ptr=self._pvt_ptr) - {{endif}} + def __dealloc__(self): pass def getPtr(self): @@ -10369,81 +9971,79 @@ cdef class anon_union0: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaResourceDesc.res.array' in found_struct}} + try: str_list += ['array :\n' + '\n'.join([' ' + line for line in str(self.array).splitlines()])] except ValueError: str_list += ['array : '] - {{endif}} - {{if 'cudaResourceDesc.res.mipmap' in found_struct}} + + try: str_list += ['mipmap :\n' + '\n'.join([' ' + line for line in str(self.mipmap).splitlines()])] except ValueError: str_list += ['mipmap : '] - {{endif}} - {{if 'cudaResourceDesc.res.linear' in found_struct}} + + try: str_list += ['linear :\n' + '\n'.join([' ' + line for line in str(self.linear).splitlines()])] except ValueError: str_list += ['linear : '] - {{endif}} - {{if 'cudaResourceDesc.res.pitch2D' in found_struct}} + + try: str_list += ['pitch2D :\n' + '\n'.join([' ' + line for line in str(self.pitch2D).splitlines()])] except ValueError: str_list += ['pitch2D : '] - {{endif}} - {{if 'cudaResourceDesc.res.reserved' in found_struct}} + + try: str_list += ['reserved :\n' + '\n'.join([' ' + line for line in str(self.reserved).splitlines()])] except ValueError: str_list += ['reserved : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaResourceDesc.res.array' in found_struct}} + @property def array(self): return self._array @array.setter def array(self, array not None : anon_struct1): string.memcpy(&self._pvt_ptr[0].res.array, array.getPtr(), sizeof(self._pvt_ptr[0].res.array)) - {{endif}} - {{if 'cudaResourceDesc.res.mipmap' in found_struct}} + + @property def mipmap(self): return self._mipmap @mipmap.setter def mipmap(self, mipmap not None : anon_struct2): string.memcpy(&self._pvt_ptr[0].res.mipmap, mipmap.getPtr(), sizeof(self._pvt_ptr[0].res.mipmap)) - {{endif}} - {{if 'cudaResourceDesc.res.linear' in found_struct}} + + @property def linear(self): return self._linear @linear.setter def linear(self, linear not None : anon_struct3): string.memcpy(&self._pvt_ptr[0].res.linear, linear.getPtr(), sizeof(self._pvt_ptr[0].res.linear)) - {{endif}} - {{if 'cudaResourceDesc.res.pitch2D' in found_struct}} + + @property def pitch2D(self): return self._pitch2D @pitch2D.setter def pitch2D(self, pitch2D not None : anon_struct4): string.memcpy(&self._pvt_ptr[0].res.pitch2D, pitch2D.getPtr(), sizeof(self._pvt_ptr[0].res.pitch2D)) - {{endif}} - {{if 'cudaResourceDesc.res.reserved' in found_struct}} + + @property def reserved(self): return self._reserved @reserved.setter def reserved(self, reserved not None : anon_struct5): string.memcpy(&self._pvt_ptr[0].res.reserved, reserved.getPtr(), sizeof(self._pvt_ptr[0].res.reserved)) - {{endif}} -{{endif}} -{{if 'cudaResourceDesc' in found_struct}} + cdef class cudaResourceDesc: """ @@ -10451,18 +10051,18 @@ cdef class cudaResourceDesc: Attributes ---------- - {{if 'cudaResourceDesc.resType' in found_struct}} + resType : cudaResourceType Resource type - {{endif}} - {{if 'cudaResourceDesc.res' in found_struct}} + + res : anon_union0 - {{endif}} - {{if 'cudaResourceDesc.flags' in found_struct}} + + flags : unsigned int Flags (must be zero) - {{endif}} + Methods ------- @@ -10477,9 +10077,9 @@ cdef class cudaResourceDesc: self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass - {{if 'cudaResourceDesc.res' in found_struct}} + self._res = anon_union0(_ptr=self._pvt_ptr) - {{endif}} + def __dealloc__(self): if self._val_ptr is not NULL: free(self._val_ptr) @@ -10488,53 +10088,51 @@ cdef class cudaResourceDesc: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaResourceDesc.resType' in found_struct}} + try: str_list += ['resType : ' + str(self.resType)] except ValueError: str_list += ['resType : '] - {{endif}} - {{if 'cudaResourceDesc.res' in found_struct}} + + try: str_list += ['res :\n' + '\n'.join([' ' + line for line in str(self.res).splitlines()])] except ValueError: str_list += ['res : '] - {{endif}} - {{if 'cudaResourceDesc.flags' in found_struct}} + + try: str_list += ['flags : ' + str(self.flags)] except ValueError: str_list += ['flags : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaResourceDesc.resType' in found_struct}} + @property def resType(self): return cudaResourceType(self._pvt_ptr[0].resType) @resType.setter def resType(self, resType not None : cudaResourceType): - self._pvt_ptr[0].resType = int(resType) - {{endif}} - {{if 'cudaResourceDesc.res' in found_struct}} + self._pvt_ptr[0].resType = int(resType) + + @property def res(self): return self._res @res.setter def res(self, res not None : anon_union0): string.memcpy(&self._pvt_ptr[0].res, res.getPtr(), sizeof(self._pvt_ptr[0].res)) - {{endif}} - {{if 'cudaResourceDesc.flags' in found_struct}} + + @property def flags(self): return self._pvt_ptr[0].flags @flags.setter def flags(self, unsigned int flags): self._pvt_ptr[0].flags = flags - {{endif}} -{{endif}} -{{if 'cudaResourceViewDesc' in found_struct}} + cdef class cudaResourceViewDesc: """ @@ -10542,42 +10140,42 @@ cdef class cudaResourceViewDesc: Attributes ---------- - {{if 'cudaResourceViewDesc.format' in found_struct}} + format : cudaResourceViewFormat Resource view format - {{endif}} - {{if 'cudaResourceViewDesc.width' in found_struct}} + + width : size_t Width of the resource view - {{endif}} - {{if 'cudaResourceViewDesc.height' in found_struct}} + + height : size_t Height of the resource view - {{endif}} - {{if 'cudaResourceViewDesc.depth' in found_struct}} + + depth : size_t Depth of the resource view - {{endif}} - {{if 'cudaResourceViewDesc.firstMipmapLevel' in found_struct}} + + firstMipmapLevel : unsigned int First defined mipmap level - {{endif}} - {{if 'cudaResourceViewDesc.lastMipmapLevel' in found_struct}} + + lastMipmapLevel : unsigned int Last defined mipmap level - {{endif}} - {{if 'cudaResourceViewDesc.firstLayer' in found_struct}} + + firstLayer : unsigned int First layer index - {{endif}} - {{if 'cudaResourceViewDesc.lastLayer' in found_struct}} + + lastLayer : unsigned int Last layer index - {{endif}} - {{if 'cudaResourceViewDesc.reserved' in found_struct}} + + reserved : list[unsigned int] Must be zero - {{endif}} + Methods ------- @@ -10598,137 +10196,135 @@ cdef class cudaResourceViewDesc: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaResourceViewDesc.format' in found_struct}} + try: str_list += ['format : ' + str(self.format)] except ValueError: str_list += ['format : '] - {{endif}} - {{if 'cudaResourceViewDesc.width' in found_struct}} + + try: str_list += ['width : ' + str(self.width)] except ValueError: str_list += ['width : '] - {{endif}} - {{if 'cudaResourceViewDesc.height' in found_struct}} + + try: str_list += ['height : ' + str(self.height)] except ValueError: str_list += ['height : '] - {{endif}} - {{if 'cudaResourceViewDesc.depth' in found_struct}} + + try: str_list += ['depth : ' + str(self.depth)] except ValueError: str_list += ['depth : '] - {{endif}} - {{if 'cudaResourceViewDesc.firstMipmapLevel' in found_struct}} + + try: str_list += ['firstMipmapLevel : ' + str(self.firstMipmapLevel)] except ValueError: str_list += ['firstMipmapLevel : '] - {{endif}} - {{if 'cudaResourceViewDesc.lastMipmapLevel' in found_struct}} + + try: str_list += ['lastMipmapLevel : ' + str(self.lastMipmapLevel)] except ValueError: str_list += ['lastMipmapLevel : '] - {{endif}} - {{if 'cudaResourceViewDesc.firstLayer' in found_struct}} + + try: str_list += ['firstLayer : ' + str(self.firstLayer)] except ValueError: str_list += ['firstLayer : '] - {{endif}} - {{if 'cudaResourceViewDesc.lastLayer' in found_struct}} + + try: str_list += ['lastLayer : ' + str(self.lastLayer)] except ValueError: str_list += ['lastLayer : '] - {{endif}} - {{if 'cudaResourceViewDesc.reserved' in found_struct}} + + try: str_list += ['reserved : ' + str(self.reserved)] except ValueError: str_list += ['reserved : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaResourceViewDesc.format' in found_struct}} + @property def format(self): return cudaResourceViewFormat(self._pvt_ptr[0].format) @format.setter def format(self, format not None : cudaResourceViewFormat): - self._pvt_ptr[0].format = int(format) - {{endif}} - {{if 'cudaResourceViewDesc.width' in found_struct}} + self._pvt_ptr[0].format = int(format) + + @property def width(self): return self._pvt_ptr[0].width @width.setter def width(self, size_t width): self._pvt_ptr[0].width = width - {{endif}} - {{if 'cudaResourceViewDesc.height' in found_struct}} + + @property def height(self): return self._pvt_ptr[0].height @height.setter def height(self, size_t height): self._pvt_ptr[0].height = height - {{endif}} - {{if 'cudaResourceViewDesc.depth' in found_struct}} + + @property def depth(self): return self._pvt_ptr[0].depth @depth.setter def depth(self, size_t depth): self._pvt_ptr[0].depth = depth - {{endif}} - {{if 'cudaResourceViewDesc.firstMipmapLevel' in found_struct}} + + @property def firstMipmapLevel(self): return self._pvt_ptr[0].firstMipmapLevel @firstMipmapLevel.setter def firstMipmapLevel(self, unsigned int firstMipmapLevel): self._pvt_ptr[0].firstMipmapLevel = firstMipmapLevel - {{endif}} - {{if 'cudaResourceViewDesc.lastMipmapLevel' in found_struct}} + + @property def lastMipmapLevel(self): return self._pvt_ptr[0].lastMipmapLevel @lastMipmapLevel.setter def lastMipmapLevel(self, unsigned int lastMipmapLevel): self._pvt_ptr[0].lastMipmapLevel = lastMipmapLevel - {{endif}} - {{if 'cudaResourceViewDesc.firstLayer' in found_struct}} + + @property def firstLayer(self): return self._pvt_ptr[0].firstLayer @firstLayer.setter def firstLayer(self, unsigned int firstLayer): self._pvt_ptr[0].firstLayer = firstLayer - {{endif}} - {{if 'cudaResourceViewDesc.lastLayer' in found_struct}} + + @property def lastLayer(self): return self._pvt_ptr[0].lastLayer @lastLayer.setter def lastLayer(self, unsigned int lastLayer): self._pvt_ptr[0].lastLayer = lastLayer - {{endif}} - {{if 'cudaResourceViewDesc.reserved' in found_struct}} + + @property def reserved(self): return self._pvt_ptr[0].reserved @reserved.setter def reserved(self, reserved): self._pvt_ptr[0].reserved = reserved - {{endif}} -{{endif}} -{{if 'cudaPointerAttributes' in found_struct}} + cdef class cudaPointerAttributes: """ @@ -10736,12 +10332,12 @@ cdef class cudaPointerAttributes: Attributes ---------- - {{if 'cudaPointerAttributes.type' in found_struct}} + type : cudaMemoryType The type of memory - cudaMemoryTypeUnregistered, cudaMemoryTypeHost, cudaMemoryTypeDevice or cudaMemoryTypeManaged. - {{endif}} - {{if 'cudaPointerAttributes.device' in found_struct}} + + device : int The device against which the memory was allocated or registered. If the memory type is cudaMemoryTypeDevice then this identifies the @@ -10750,23 +10346,23 @@ cdef class cudaPointerAttributes: this identifies the device which was current when the memory was allocated or registered (and if that device is deinitialized then this allocation will vanish with that device's state). - {{endif}} - {{if 'cudaPointerAttributes.devicePointer' in found_struct}} + + devicePointer : Any The address which may be dereferenced on the current device to access the memory or NULL if no such address exists. - {{endif}} - {{if 'cudaPointerAttributes.hostPointer' in found_struct}} + + hostPointer : Any The address which may be dereferenced on the host to access the memory or NULL if no such address exists. CUDA doesn't check if unregistered memory is allocated so this field may contain invalid pointer if an invalid pointer has been passed to CUDA. - {{endif}} - {{if 'cudaPointerAttributes.reserved' in found_struct}} + + reserved : list[long] Must be zero - {{endif}} + Methods ------- @@ -10787,56 +10383,56 @@ cdef class cudaPointerAttributes: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaPointerAttributes.type' in found_struct}} + try: str_list += ['type : ' + str(self.type)] except ValueError: str_list += ['type : '] - {{endif}} - {{if 'cudaPointerAttributes.device' in found_struct}} + + try: str_list += ['device : ' + str(self.device)] except ValueError: str_list += ['device : '] - {{endif}} - {{if 'cudaPointerAttributes.devicePointer' in found_struct}} + + try: str_list += ['devicePointer : ' + hex(self.devicePointer)] except ValueError: str_list += ['devicePointer : '] - {{endif}} - {{if 'cudaPointerAttributes.hostPointer' in found_struct}} + + try: str_list += ['hostPointer : ' + hex(self.hostPointer)] except ValueError: str_list += ['hostPointer : '] - {{endif}} - {{if 'cudaPointerAttributes.reserved' in found_struct}} + + try: str_list += ['reserved : ' + str(self.reserved)] except ValueError: str_list += ['reserved : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaPointerAttributes.type' in found_struct}} + @property def type(self): return cudaMemoryType(self._pvt_ptr[0].type) @type.setter def type(self, type not None : cudaMemoryType): - self._pvt_ptr[0].type = int(type) - {{endif}} - {{if 'cudaPointerAttributes.device' in found_struct}} + self._pvt_ptr[0].type = int(type) + + @property def device(self): return self._pvt_ptr[0].device @device.setter def device(self, int device): self._pvt_ptr[0].device = device - {{endif}} - {{if 'cudaPointerAttributes.devicePointer' in found_struct}} + + @property def devicePointer(self): return self._pvt_ptr[0].devicePointer @@ -10844,8 +10440,8 @@ cdef class cudaPointerAttributes: def devicePointer(self, devicePointer): self._cydevicePointer = _HelperInputVoidPtr(devicePointer) self._pvt_ptr[0].devicePointer = self._cydevicePointer.cptr - {{endif}} - {{if 'cudaPointerAttributes.hostPointer' in found_struct}} + + @property def hostPointer(self): return self._pvt_ptr[0].hostPointer @@ -10853,17 +10449,15 @@ cdef class cudaPointerAttributes: def hostPointer(self, hostPointer): self._cyhostPointer = _HelperInputVoidPtr(hostPointer) self._pvt_ptr[0].hostPointer = self._cyhostPointer.cptr - {{endif}} - {{if 'cudaPointerAttributes.reserved' in found_struct}} + + @property def reserved(self): return self._pvt_ptr[0].reserved @reserved.setter def reserved(self, reserved): self._pvt_ptr[0].reserved = reserved - {{endif}} -{{endif}} -{{if 'cudaFuncAttributes' in found_struct}} + cdef class cudaFuncAttributes: """ @@ -10871,57 +10465,57 @@ cdef class cudaFuncAttributes: Attributes ---------- - {{if 'cudaFuncAttributes.sharedSizeBytes' in found_struct}} + sharedSizeBytes : size_t The size in bytes of statically-allocated shared memory per block required by this function. This does not include dynamically- allocated shared memory requested by the user at runtime. - {{endif}} - {{if 'cudaFuncAttributes.constSizeBytes' in found_struct}} + + constSizeBytes : size_t The size in bytes of user-allocated constant memory required by this function. - {{endif}} - {{if 'cudaFuncAttributes.localSizeBytes' in found_struct}} + + localSizeBytes : size_t The size in bytes of local memory used by each thread of this function. - {{endif}} - {{if 'cudaFuncAttributes.maxThreadsPerBlock' in found_struct}} + + maxThreadsPerBlock : int The maximum number of threads per block, beyond which a launch of the function would fail. This number depends on both the function and the device on which the function is currently loaded. - {{endif}} - {{if 'cudaFuncAttributes.numRegs' in found_struct}} + + numRegs : int The number of registers used by each thread of this function. - {{endif}} - {{if 'cudaFuncAttributes.ptxVersion' in found_struct}} + + ptxVersion : int The PTX virtual architecture version for which the function was compiled. This value is the major PTX version * 10 + the minor PTX version, so a PTX version 1.3 function would return the value 13. - {{endif}} - {{if 'cudaFuncAttributes.binaryVersion' in found_struct}} + + binaryVersion : int The binary architecture version for which the function was compiled. This value is the major binary version * 10 + the minor binary version, so a binary version 1.3 function would return the value 13. - {{endif}} - {{if 'cudaFuncAttributes.cacheModeCA' in found_struct}} + + cacheModeCA : int The attribute to indicate whether the function has been compiled with user specified option "-Xptxas --dlcm=ca" set. - {{endif}} - {{if 'cudaFuncAttributes.maxDynamicSharedSizeBytes' in found_struct}} + + maxDynamicSharedSizeBytes : int The maximum size in bytes of dynamic shared memory per block for this function. Any launch must have a dynamic shared memory size smaller than this value. - {{endif}} - {{if 'cudaFuncAttributes.preferredShmemCarveout' in found_struct}} + + preferredShmemCarveout : int On devices where the L1 cache and shared memory use the same hardware resources, this sets the shared memory carveout @@ -10929,13 +10523,13 @@ cdef class cudaFuncAttributes: cudaDevAttrMaxSharedMemoryPerMultiprocessor. This is only a hint, and the driver can choose a different ratio if required to execute the function. See cudaFuncSetAttribute - {{endif}} - {{if 'cudaFuncAttributes.clusterDimMustBeSet' in found_struct}} + + clusterDimMustBeSet : int If this attribute is set, the kernel must launch with a valid cluster dimension specified. - {{endif}} - {{if 'cudaFuncAttributes.requiredClusterWidth' in found_struct}} + + requiredClusterWidth : int The required cluster width/height/depth in blocks. The values must either all be 0 or all be positive. The validity of the cluster @@ -10943,20 +10537,20 @@ cdef class cudaFuncAttributes: set during compile time, it cannot be set at runtime. Setting it at runtime should return cudaErrorNotPermitted. See cudaFuncSetAttribute - {{endif}} - {{if 'cudaFuncAttributes.requiredClusterHeight' in found_struct}} + + requiredClusterHeight : int - {{endif}} - {{if 'cudaFuncAttributes.requiredClusterDepth' in found_struct}} + + requiredClusterDepth : int - {{endif}} - {{if 'cudaFuncAttributes.clusterSchedulingPolicyPreference' in found_struct}} + + clusterSchedulingPolicyPreference : int The block scheduling policy of a function. See cudaFuncSetAttribute - {{endif}} - {{if 'cudaFuncAttributes.nonPortableClusterSizeAllowed' in found_struct}} + + nonPortableClusterSizeAllowed : int Whether the function can be launched with non-portable cluster size. 1 is allowed, 0 is disallowed. A non-portable cluster size @@ -10971,21 +10565,21 @@ cdef class cudaFuncAttributes: compute capabilities. The specific hardware unit may support higher cluster sizes that’s not guaranteed to be portable. See cudaFuncSetAttribute - {{endif}} - {{if 'cudaFuncAttributes.deviceNodeUpdateStatus' in found_struct}} + + deviceNodeUpdateStatus : int Whether the function can be updated on device. 1 means device node update is supported, 0 is unsupported or driver is too old to check the value. - {{endif}} - {{if 'cudaFuncAttributes.reserved1' in found_struct}} + + reserved1 : int - {{endif}} - {{if 'cudaFuncAttributes.reserved' in found_struct}} + + reserved : list[int] Reserved for future use. - {{endif}} + Methods ------- @@ -11006,277 +10600,275 @@ cdef class cudaFuncAttributes: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaFuncAttributes.sharedSizeBytes' in found_struct}} + try: str_list += ['sharedSizeBytes : ' + str(self.sharedSizeBytes)] except ValueError: str_list += ['sharedSizeBytes : '] - {{endif}} - {{if 'cudaFuncAttributes.constSizeBytes' in found_struct}} + + try: str_list += ['constSizeBytes : ' + str(self.constSizeBytes)] except ValueError: str_list += ['constSizeBytes : '] - {{endif}} - {{if 'cudaFuncAttributes.localSizeBytes' in found_struct}} + + try: str_list += ['localSizeBytes : ' + str(self.localSizeBytes)] except ValueError: str_list += ['localSizeBytes : '] - {{endif}} - {{if 'cudaFuncAttributes.maxThreadsPerBlock' in found_struct}} + + try: str_list += ['maxThreadsPerBlock : ' + str(self.maxThreadsPerBlock)] except ValueError: str_list += ['maxThreadsPerBlock : '] - {{endif}} - {{if 'cudaFuncAttributes.numRegs' in found_struct}} + + try: str_list += ['numRegs : ' + str(self.numRegs)] except ValueError: str_list += ['numRegs : '] - {{endif}} - {{if 'cudaFuncAttributes.ptxVersion' in found_struct}} + + try: str_list += ['ptxVersion : ' + str(self.ptxVersion)] except ValueError: str_list += ['ptxVersion : '] - {{endif}} - {{if 'cudaFuncAttributes.binaryVersion' in found_struct}} + + try: str_list += ['binaryVersion : ' + str(self.binaryVersion)] except ValueError: str_list += ['binaryVersion : '] - {{endif}} - {{if 'cudaFuncAttributes.cacheModeCA' in found_struct}} + + try: str_list += ['cacheModeCA : ' + str(self.cacheModeCA)] except ValueError: str_list += ['cacheModeCA : '] - {{endif}} - {{if 'cudaFuncAttributes.maxDynamicSharedSizeBytes' in found_struct}} + + try: str_list += ['maxDynamicSharedSizeBytes : ' + str(self.maxDynamicSharedSizeBytes)] except ValueError: str_list += ['maxDynamicSharedSizeBytes : '] - {{endif}} - {{if 'cudaFuncAttributes.preferredShmemCarveout' in found_struct}} + + try: str_list += ['preferredShmemCarveout : ' + str(self.preferredShmemCarveout)] except ValueError: str_list += ['preferredShmemCarveout : '] - {{endif}} - {{if 'cudaFuncAttributes.clusterDimMustBeSet' in found_struct}} + + try: str_list += ['clusterDimMustBeSet : ' + str(self.clusterDimMustBeSet)] except ValueError: str_list += ['clusterDimMustBeSet : '] - {{endif}} - {{if 'cudaFuncAttributes.requiredClusterWidth' in found_struct}} + + try: str_list += ['requiredClusterWidth : ' + str(self.requiredClusterWidth)] except ValueError: str_list += ['requiredClusterWidth : '] - {{endif}} - {{if 'cudaFuncAttributes.requiredClusterHeight' in found_struct}} + + try: str_list += ['requiredClusterHeight : ' + str(self.requiredClusterHeight)] except ValueError: str_list += ['requiredClusterHeight : '] - {{endif}} - {{if 'cudaFuncAttributes.requiredClusterDepth' in found_struct}} + + try: str_list += ['requiredClusterDepth : ' + str(self.requiredClusterDepth)] except ValueError: str_list += ['requiredClusterDepth : '] - {{endif}} - {{if 'cudaFuncAttributes.clusterSchedulingPolicyPreference' in found_struct}} + + try: str_list += ['clusterSchedulingPolicyPreference : ' + str(self.clusterSchedulingPolicyPreference)] except ValueError: str_list += ['clusterSchedulingPolicyPreference : '] - {{endif}} - {{if 'cudaFuncAttributes.nonPortableClusterSizeAllowed' in found_struct}} + + try: str_list += ['nonPortableClusterSizeAllowed : ' + str(self.nonPortableClusterSizeAllowed)] except ValueError: str_list += ['nonPortableClusterSizeAllowed : '] - {{endif}} - {{if 'cudaFuncAttributes.deviceNodeUpdateStatus' in found_struct}} + + try: str_list += ['deviceNodeUpdateStatus : ' + str(self.deviceNodeUpdateStatus)] except ValueError: str_list += ['deviceNodeUpdateStatus : '] - {{endif}} - {{if 'cudaFuncAttributes.reserved1' in found_struct}} + + try: str_list += ['reserved1 : ' + str(self.reserved1)] except ValueError: str_list += ['reserved1 : '] - {{endif}} - {{if 'cudaFuncAttributes.reserved' in found_struct}} + + try: str_list += ['reserved : ' + str(self.reserved)] except ValueError: str_list += ['reserved : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaFuncAttributes.sharedSizeBytes' in found_struct}} + @property def sharedSizeBytes(self): return self._pvt_ptr[0].sharedSizeBytes @sharedSizeBytes.setter def sharedSizeBytes(self, size_t sharedSizeBytes): self._pvt_ptr[0].sharedSizeBytes = sharedSizeBytes - {{endif}} - {{if 'cudaFuncAttributes.constSizeBytes' in found_struct}} + + @property def constSizeBytes(self): return self._pvt_ptr[0].constSizeBytes @constSizeBytes.setter def constSizeBytes(self, size_t constSizeBytes): self._pvt_ptr[0].constSizeBytes = constSizeBytes - {{endif}} - {{if 'cudaFuncAttributes.localSizeBytes' in found_struct}} + + @property def localSizeBytes(self): return self._pvt_ptr[0].localSizeBytes @localSizeBytes.setter def localSizeBytes(self, size_t localSizeBytes): self._pvt_ptr[0].localSizeBytes = localSizeBytes - {{endif}} - {{if 'cudaFuncAttributes.maxThreadsPerBlock' in found_struct}} + + @property def maxThreadsPerBlock(self): return self._pvt_ptr[0].maxThreadsPerBlock @maxThreadsPerBlock.setter def maxThreadsPerBlock(self, int maxThreadsPerBlock): self._pvt_ptr[0].maxThreadsPerBlock = maxThreadsPerBlock - {{endif}} - {{if 'cudaFuncAttributes.numRegs' in found_struct}} + + @property def numRegs(self): return self._pvt_ptr[0].numRegs @numRegs.setter def numRegs(self, int numRegs): self._pvt_ptr[0].numRegs = numRegs - {{endif}} - {{if 'cudaFuncAttributes.ptxVersion' in found_struct}} + + @property def ptxVersion(self): return self._pvt_ptr[0].ptxVersion @ptxVersion.setter def ptxVersion(self, int ptxVersion): self._pvt_ptr[0].ptxVersion = ptxVersion - {{endif}} - {{if 'cudaFuncAttributes.binaryVersion' in found_struct}} + + @property def binaryVersion(self): return self._pvt_ptr[0].binaryVersion @binaryVersion.setter def binaryVersion(self, int binaryVersion): self._pvt_ptr[0].binaryVersion = binaryVersion - {{endif}} - {{if 'cudaFuncAttributes.cacheModeCA' in found_struct}} + + @property def cacheModeCA(self): return self._pvt_ptr[0].cacheModeCA @cacheModeCA.setter def cacheModeCA(self, int cacheModeCA): self._pvt_ptr[0].cacheModeCA = cacheModeCA - {{endif}} - {{if 'cudaFuncAttributes.maxDynamicSharedSizeBytes' in found_struct}} + + @property def maxDynamicSharedSizeBytes(self): return self._pvt_ptr[0].maxDynamicSharedSizeBytes @maxDynamicSharedSizeBytes.setter def maxDynamicSharedSizeBytes(self, int maxDynamicSharedSizeBytes): self._pvt_ptr[0].maxDynamicSharedSizeBytes = maxDynamicSharedSizeBytes - {{endif}} - {{if 'cudaFuncAttributes.preferredShmemCarveout' in found_struct}} + + @property def preferredShmemCarveout(self): return self._pvt_ptr[0].preferredShmemCarveout @preferredShmemCarveout.setter def preferredShmemCarveout(self, int preferredShmemCarveout): self._pvt_ptr[0].preferredShmemCarveout = preferredShmemCarveout - {{endif}} - {{if 'cudaFuncAttributes.clusterDimMustBeSet' in found_struct}} + + @property def clusterDimMustBeSet(self): return self._pvt_ptr[0].clusterDimMustBeSet @clusterDimMustBeSet.setter def clusterDimMustBeSet(self, int clusterDimMustBeSet): self._pvt_ptr[0].clusterDimMustBeSet = clusterDimMustBeSet - {{endif}} - {{if 'cudaFuncAttributes.requiredClusterWidth' in found_struct}} + + @property def requiredClusterWidth(self): return self._pvt_ptr[0].requiredClusterWidth @requiredClusterWidth.setter def requiredClusterWidth(self, int requiredClusterWidth): self._pvt_ptr[0].requiredClusterWidth = requiredClusterWidth - {{endif}} - {{if 'cudaFuncAttributes.requiredClusterHeight' in found_struct}} + + @property def requiredClusterHeight(self): return self._pvt_ptr[0].requiredClusterHeight @requiredClusterHeight.setter def requiredClusterHeight(self, int requiredClusterHeight): self._pvt_ptr[0].requiredClusterHeight = requiredClusterHeight - {{endif}} - {{if 'cudaFuncAttributes.requiredClusterDepth' in found_struct}} + + @property def requiredClusterDepth(self): return self._pvt_ptr[0].requiredClusterDepth @requiredClusterDepth.setter def requiredClusterDepth(self, int requiredClusterDepth): self._pvt_ptr[0].requiredClusterDepth = requiredClusterDepth - {{endif}} - {{if 'cudaFuncAttributes.clusterSchedulingPolicyPreference' in found_struct}} + + @property def clusterSchedulingPolicyPreference(self): return self._pvt_ptr[0].clusterSchedulingPolicyPreference @clusterSchedulingPolicyPreference.setter def clusterSchedulingPolicyPreference(self, int clusterSchedulingPolicyPreference): self._pvt_ptr[0].clusterSchedulingPolicyPreference = clusterSchedulingPolicyPreference - {{endif}} - {{if 'cudaFuncAttributes.nonPortableClusterSizeAllowed' in found_struct}} + + @property def nonPortableClusterSizeAllowed(self): return self._pvt_ptr[0].nonPortableClusterSizeAllowed @nonPortableClusterSizeAllowed.setter def nonPortableClusterSizeAllowed(self, int nonPortableClusterSizeAllowed): self._pvt_ptr[0].nonPortableClusterSizeAllowed = nonPortableClusterSizeAllowed - {{endif}} - {{if 'cudaFuncAttributes.deviceNodeUpdateStatus' in found_struct}} + + @property def deviceNodeUpdateStatus(self): return self._pvt_ptr[0].deviceNodeUpdateStatus @deviceNodeUpdateStatus.setter def deviceNodeUpdateStatus(self, int deviceNodeUpdateStatus): self._pvt_ptr[0].deviceNodeUpdateStatus = deviceNodeUpdateStatus - {{endif}} - {{if 'cudaFuncAttributes.reserved1' in found_struct}} + + @property def reserved1(self): return self._pvt_ptr[0].reserved1 @reserved1.setter def reserved1(self, int reserved1): self._pvt_ptr[0].reserved1 = reserved1 - {{endif}} - {{if 'cudaFuncAttributes.reserved' in found_struct}} + + @property def reserved(self): return self._pvt_ptr[0].reserved @reserved.setter def reserved(self, reserved): self._pvt_ptr[0].reserved = reserved - {{endif}} -{{endif}} -{{if 'cudaMemLocation' in found_struct}} + cdef class cudaMemLocation: """ @@ -11287,16 +10879,16 @@ cdef class cudaMemLocation: Attributes ---------- - {{if 'cudaMemLocation.type' in found_struct}} + type : cudaMemLocationType Specifies the location type, which modifies the meaning of id. - {{endif}} - {{if 'cudaMemLocation.id' in found_struct}} + + id : int Identifier for cudaMemLocationType::cudaMemLocationTypeDevice, cudaMemLocationType::cudaMemLocationTypeHost, or cudaMemLocationType::cudaMemLocationTypeHostNuma. - {{endif}} + Methods ------- @@ -11319,39 +10911,37 @@ cdef class cudaMemLocation: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaMemLocation.type' in found_struct}} + try: str_list += ['type : ' + str(self.type)] except ValueError: str_list += ['type : '] - {{endif}} - {{if 'cudaMemLocation.id' in found_struct}} + + try: str_list += ['id : ' + str(self.id)] except ValueError: str_list += ['id : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaMemLocation.type' in found_struct}} + @property def type(self): return cudaMemLocationType(self._pvt_ptr[0].type) @type.setter def type(self, type not None : cudaMemLocationType): - self._pvt_ptr[0].type = int(type) - {{endif}} - {{if 'cudaMemLocation.id' in found_struct}} + self._pvt_ptr[0].type = int(type) + + @property def id(self): return self._pvt_ptr[0].id @id.setter def id(self, int id): self._pvt_ptr[0].id = id - {{endif}} -{{endif}} -{{if 'cudaMemAccessDesc' in found_struct}} + cdef class cudaMemAccessDesc: """ @@ -11359,14 +10949,14 @@ cdef class cudaMemAccessDesc: Attributes ---------- - {{if 'cudaMemAccessDesc.location' in found_struct}} + location : cudaMemLocation Location on which the request is to change it's accessibility - {{endif}} - {{if 'cudaMemAccessDesc.flags' in found_struct}} + + flags : cudaMemAccessFlags ::CUmemProt accessibility flags to set on the request - {{endif}} + Methods ------- @@ -11380,9 +10970,9 @@ cdef class cudaMemAccessDesc: self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass - {{if 'cudaMemAccessDesc.location' in found_struct}} + self._location = cudaMemLocation(_ptr=&self._pvt_ptr[0].location) - {{endif}} + def __dealloc__(self): pass def getPtr(self): @@ -11390,39 +10980,37 @@ cdef class cudaMemAccessDesc: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaMemAccessDesc.location' in found_struct}} + try: str_list += ['location :\n' + '\n'.join([' ' + line for line in str(self.location).splitlines()])] except ValueError: str_list += ['location : '] - {{endif}} - {{if 'cudaMemAccessDesc.flags' in found_struct}} + + try: str_list += ['flags : ' + str(self.flags)] except ValueError: str_list += ['flags : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaMemAccessDesc.location' in found_struct}} + @property def location(self): return self._location @location.setter def location(self, location not None : cudaMemLocation): string.memcpy(&self._pvt_ptr[0].location, location.getPtr(), sizeof(self._pvt_ptr[0].location)) - {{endif}} - {{if 'cudaMemAccessDesc.flags' in found_struct}} + + @property def flags(self): return cudaMemAccessFlags(self._pvt_ptr[0].flags) @flags.setter def flags(self, flags not None : cudaMemAccessFlags): - self._pvt_ptr[0].flags = int(flags) - {{endif}} -{{endif}} -{{if 'cudaMemPoolProps' in found_struct}} + self._pvt_ptr[0].flags = int(flags) + cdef class cudaMemPoolProps: """ @@ -11430,40 +11018,40 @@ cdef class cudaMemPoolProps: Attributes ---------- - {{if 'cudaMemPoolProps.allocType' in found_struct}} + allocType : cudaMemAllocationType Allocation type. Currently must be specified as cudaMemAllocationTypePinned - {{endif}} - {{if 'cudaMemPoolProps.handleTypes' in found_struct}} + + handleTypes : cudaMemAllocationHandleType Handle types that will be supported by allocations from the pool. - {{endif}} - {{if 'cudaMemPoolProps.location' in found_struct}} + + location : cudaMemLocation Location allocations should reside. - {{endif}} - {{if 'cudaMemPoolProps.win32SecurityAttributes' in found_struct}} + + win32SecurityAttributes : Any Windows-specific LPSECURITYATTRIBUTES required when cudaMemHandleTypeWin32 is specified. This security attribute defines the scope of which exported allocations may be tranferred to other processes. In all other cases, this field is required to be zero. - {{endif}} - {{if 'cudaMemPoolProps.maxSize' in found_struct}} + + maxSize : size_t Maximum pool size. When set to 0, defaults to a system dependent value. - {{endif}} - {{if 'cudaMemPoolProps.usage' in found_struct}} + + usage : unsigned short Bitmask indicating intended usage for the pool. - {{endif}} - {{if 'cudaMemPoolProps.reserved' in found_struct}} + + reserved : bytes reserved for future use, must be 0 - {{endif}} + Methods ------- @@ -11477,9 +11065,9 @@ cdef class cudaMemPoolProps: self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass - {{if 'cudaMemPoolProps.location' in found_struct}} + self._location = cudaMemLocation(_ptr=&self._pvt_ptr[0].location) - {{endif}} + def __dealloc__(self): pass def getPtr(self): @@ -11487,76 +11075,76 @@ cdef class cudaMemPoolProps: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaMemPoolProps.allocType' in found_struct}} + try: str_list += ['allocType : ' + str(self.allocType)] except ValueError: str_list += ['allocType : '] - {{endif}} - {{if 'cudaMemPoolProps.handleTypes' in found_struct}} + + try: str_list += ['handleTypes : ' + str(self.handleTypes)] except ValueError: str_list += ['handleTypes : '] - {{endif}} - {{if 'cudaMemPoolProps.location' in found_struct}} + + try: str_list += ['location :\n' + '\n'.join([' ' + line for line in str(self.location).splitlines()])] except ValueError: str_list += ['location : '] - {{endif}} - {{if 'cudaMemPoolProps.win32SecurityAttributes' in found_struct}} + + try: str_list += ['win32SecurityAttributes : ' + hex(self.win32SecurityAttributes)] except ValueError: str_list += ['win32SecurityAttributes : '] - {{endif}} - {{if 'cudaMemPoolProps.maxSize' in found_struct}} + + try: str_list += ['maxSize : ' + str(self.maxSize)] except ValueError: str_list += ['maxSize : '] - {{endif}} - {{if 'cudaMemPoolProps.usage' in found_struct}} + + try: str_list += ['usage : ' + str(self.usage)] except ValueError: str_list += ['usage : '] - {{endif}} - {{if 'cudaMemPoolProps.reserved' in found_struct}} + + try: str_list += ['reserved : ' + str(self.reserved)] except ValueError: str_list += ['reserved : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaMemPoolProps.allocType' in found_struct}} + @property def allocType(self): return cudaMemAllocationType(self._pvt_ptr[0].allocType) @allocType.setter def allocType(self, allocType not None : cudaMemAllocationType): - self._pvt_ptr[0].allocType = int(allocType) - {{endif}} - {{if 'cudaMemPoolProps.handleTypes' in found_struct}} + self._pvt_ptr[0].allocType = int(allocType) + + @property def handleTypes(self): return cudaMemAllocationHandleType(self._pvt_ptr[0].handleTypes) @handleTypes.setter def handleTypes(self, handleTypes not None : cudaMemAllocationHandleType): - self._pvt_ptr[0].handleTypes = int(handleTypes) - {{endif}} - {{if 'cudaMemPoolProps.location' in found_struct}} + self._pvt_ptr[0].handleTypes = int(handleTypes) + + @property def location(self): return self._location @location.setter def location(self, location not None : cudaMemLocation): string.memcpy(&self._pvt_ptr[0].location, location.getPtr(), sizeof(self._pvt_ptr[0].location)) - {{endif}} - {{if 'cudaMemPoolProps.win32SecurityAttributes' in found_struct}} + + @property def win32SecurityAttributes(self): return self._pvt_ptr[0].win32SecurityAttributes @@ -11564,24 +11152,24 @@ cdef class cudaMemPoolProps: def win32SecurityAttributes(self, win32SecurityAttributes): self._cywin32SecurityAttributes = _HelperInputVoidPtr(win32SecurityAttributes) self._pvt_ptr[0].win32SecurityAttributes = self._cywin32SecurityAttributes.cptr - {{endif}} - {{if 'cudaMemPoolProps.maxSize' in found_struct}} + + @property def maxSize(self): return self._pvt_ptr[0].maxSize @maxSize.setter def maxSize(self, size_t maxSize): self._pvt_ptr[0].maxSize = maxSize - {{endif}} - {{if 'cudaMemPoolProps.usage' in found_struct}} + + @property def usage(self): return self._pvt_ptr[0].usage @usage.setter def usage(self, unsigned short usage): self._pvt_ptr[0].usage = usage - {{endif}} - {{if 'cudaMemPoolProps.reserved' in found_struct}} + + @property def reserved(self): return PyBytes_FromStringAndSize(self._pvt_ptr[0].reserved, 54) @@ -11591,9 +11179,7 @@ cdef class cudaMemPoolProps: raise ValueError("reserved length must be 54, is " + str(len(reserved))) for i, b in enumerate(reserved): self._pvt_ptr[0].reserved[i] = b - {{endif}} -{{endif}} -{{if 'cudaMemPoolPtrExportData' in found_struct}} + cdef class cudaMemPoolPtrExportData: """ @@ -11601,10 +11187,10 @@ cdef class cudaMemPoolPtrExportData: Attributes ---------- - {{if 'cudaMemPoolPtrExportData.reserved' in found_struct}} + reserved : bytes - {{endif}} + Methods ------- @@ -11625,16 +11211,16 @@ cdef class cudaMemPoolPtrExportData: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaMemPoolPtrExportData.reserved' in found_struct}} + try: str_list += ['reserved : ' + str(self.reserved)] except ValueError: str_list += ['reserved : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaMemPoolPtrExportData.reserved' in found_struct}} + @property def reserved(self): return PyBytes_FromStringAndSize(self._pvt_ptr[0].reserved, 64) @@ -11644,9 +11230,7 @@ cdef class cudaMemPoolPtrExportData: raise ValueError("reserved length must be 64, is " + str(len(reserved))) for i, b in enumerate(reserved): self._pvt_ptr[0].reserved[i] = b - {{endif}} -{{endif}} -{{if 'cudaMemAllocNodeParams' in found_struct}} + cdef class cudaMemAllocNodeParams: """ @@ -11654,30 +11238,30 @@ cdef class cudaMemAllocNodeParams: Attributes ---------- - {{if 'cudaMemAllocNodeParams.poolProps' in found_struct}} + poolProps : cudaMemPoolProps in: location where the allocation should reside (specified in ::location). ::handleTypes must be cudaMemHandleTypeNone. IPC is not supported. in: array of memory access descriptors. Used to describe peer GPU access - {{endif}} - {{if 'cudaMemAllocNodeParams.accessDescs' in found_struct}} + + accessDescs : cudaMemAccessDesc in: number of memory access descriptors. Must not exceed the number of GPUs. - {{endif}} - {{if 'cudaMemAllocNodeParams.accessDescCount' in found_struct}} + + accessDescCount : size_t in: Number of `accessDescs`s - {{endif}} - {{if 'cudaMemAllocNodeParams.bytesize' in found_struct}} + + bytesize : size_t in: size in bytes of the requested allocation - {{endif}} - {{if 'cudaMemAllocNodeParams.dptr' in found_struct}} + + dptr : Any out: address of the allocation returned by CUDA - {{endif}} + Methods ------- @@ -11691,63 +11275,63 @@ cdef class cudaMemAllocNodeParams: self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass - {{if 'cudaMemAllocNodeParams.poolProps' in found_struct}} + self._poolProps = cudaMemPoolProps(_ptr=&self._pvt_ptr[0].poolProps) - {{endif}} + def __dealloc__(self): pass - {{if 'cudaMemAllocNodeParams.accessDescs' in found_struct}} + if self._accessDescs is not NULL: free(self._accessDescs) self._pvt_ptr[0].accessDescs = NULL - {{endif}} + def getPtr(self): return self._pvt_ptr def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaMemAllocNodeParams.poolProps' in found_struct}} + try: str_list += ['poolProps :\n' + '\n'.join([' ' + line for line in str(self.poolProps).splitlines()])] except ValueError: str_list += ['poolProps : '] - {{endif}} - {{if 'cudaMemAllocNodeParams.accessDescs' in found_struct}} + + try: str_list += ['accessDescs : ' + str(self.accessDescs)] except ValueError: str_list += ['accessDescs : '] - {{endif}} - {{if 'cudaMemAllocNodeParams.accessDescCount' in found_struct}} + + try: str_list += ['accessDescCount : ' + str(self.accessDescCount)] except ValueError: str_list += ['accessDescCount : '] - {{endif}} - {{if 'cudaMemAllocNodeParams.bytesize' in found_struct}} + + try: str_list += ['bytesize : ' + str(self.bytesize)] except ValueError: str_list += ['bytesize : '] - {{endif}} - {{if 'cudaMemAllocNodeParams.dptr' in found_struct}} + + try: str_list += ['dptr : ' + hex(self.dptr)] except ValueError: str_list += ['dptr : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaMemAllocNodeParams.poolProps' in found_struct}} + @property def poolProps(self): return self._poolProps @poolProps.setter def poolProps(self, poolProps not None : cudaMemPoolProps): string.memcpy(&self._pvt_ptr[0].poolProps, poolProps.getPtr(), sizeof(self._pvt_ptr[0].poolProps)) - {{endif}} - {{if 'cudaMemAllocNodeParams.accessDescs' in found_struct}} + + @property def accessDescs(self): arrs = [self._pvt_ptr[0].accessDescs + x*sizeof(cyruntime.cudaMemAccessDesc) for x in range(self._accessDescs_length)] @@ -11770,24 +11354,24 @@ cdef class cudaMemAllocNodeParams: for idx in range(len(val)): string.memcpy(&self._accessDescs[idx], (val[idx])._pvt_ptr, sizeof(cyruntime.cudaMemAccessDesc)) - {{endif}} - {{if 'cudaMemAllocNodeParams.accessDescCount' in found_struct}} + + @property def accessDescCount(self): return self._pvt_ptr[0].accessDescCount @accessDescCount.setter def accessDescCount(self, size_t accessDescCount): self._pvt_ptr[0].accessDescCount = accessDescCount - {{endif}} - {{if 'cudaMemAllocNodeParams.bytesize' in found_struct}} + + @property def bytesize(self): return self._pvt_ptr[0].bytesize @bytesize.setter def bytesize(self, size_t bytesize): self._pvt_ptr[0].bytesize = bytesize - {{endif}} - {{if 'cudaMemAllocNodeParams.dptr' in found_struct}} + + @property def dptr(self): return self._pvt_ptr[0].dptr @@ -11795,9 +11379,7 @@ cdef class cudaMemAllocNodeParams: def dptr(self, dptr): self._cydptr = _HelperInputVoidPtr(dptr) self._pvt_ptr[0].dptr = self._cydptr.cptr - {{endif}} -{{endif}} -{{if 'cudaMemAllocNodeParamsV2' in found_struct}} + cdef class cudaMemAllocNodeParamsV2: """ @@ -11805,30 +11387,30 @@ cdef class cudaMemAllocNodeParamsV2: Attributes ---------- - {{if 'cudaMemAllocNodeParamsV2.poolProps' in found_struct}} + poolProps : cudaMemPoolProps in: location where the allocation should reside (specified in ::location). ::handleTypes must be cudaMemHandleTypeNone. IPC is not supported. in: array of memory access descriptors. Used to describe peer GPU access - {{endif}} - {{if 'cudaMemAllocNodeParamsV2.accessDescs' in found_struct}} + + accessDescs : cudaMemAccessDesc in: number of memory access descriptors. Must not exceed the number of GPUs. - {{endif}} - {{if 'cudaMemAllocNodeParamsV2.accessDescCount' in found_struct}} + + accessDescCount : size_t in: Number of `accessDescs`s - {{endif}} - {{if 'cudaMemAllocNodeParamsV2.bytesize' in found_struct}} + + bytesize : size_t in: size in bytes of the requested allocation - {{endif}} - {{if 'cudaMemAllocNodeParamsV2.dptr' in found_struct}} + + dptr : Any out: address of the allocation returned by CUDA - {{endif}} + Methods ------- @@ -11842,63 +11424,63 @@ cdef class cudaMemAllocNodeParamsV2: self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass - {{if 'cudaMemAllocNodeParamsV2.poolProps' in found_struct}} + self._poolProps = cudaMemPoolProps(_ptr=&self._pvt_ptr[0].poolProps) - {{endif}} + def __dealloc__(self): pass - {{if 'cudaMemAllocNodeParamsV2.accessDescs' in found_struct}} + if self._accessDescs is not NULL: free(self._accessDescs) self._pvt_ptr[0].accessDescs = NULL - {{endif}} + def getPtr(self): return self._pvt_ptr def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaMemAllocNodeParamsV2.poolProps' in found_struct}} + try: str_list += ['poolProps :\n' + '\n'.join([' ' + line for line in str(self.poolProps).splitlines()])] except ValueError: str_list += ['poolProps : '] - {{endif}} - {{if 'cudaMemAllocNodeParamsV2.accessDescs' in found_struct}} + + try: str_list += ['accessDescs : ' + str(self.accessDescs)] except ValueError: str_list += ['accessDescs : '] - {{endif}} - {{if 'cudaMemAllocNodeParamsV2.accessDescCount' in found_struct}} + + try: str_list += ['accessDescCount : ' + str(self.accessDescCount)] except ValueError: str_list += ['accessDescCount : '] - {{endif}} - {{if 'cudaMemAllocNodeParamsV2.bytesize' in found_struct}} + + try: str_list += ['bytesize : ' + str(self.bytesize)] except ValueError: str_list += ['bytesize : '] - {{endif}} - {{if 'cudaMemAllocNodeParamsV2.dptr' in found_struct}} + + try: str_list += ['dptr : ' + hex(self.dptr)] except ValueError: str_list += ['dptr : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaMemAllocNodeParamsV2.poolProps' in found_struct}} + @property def poolProps(self): return self._poolProps @poolProps.setter def poolProps(self, poolProps not None : cudaMemPoolProps): string.memcpy(&self._pvt_ptr[0].poolProps, poolProps.getPtr(), sizeof(self._pvt_ptr[0].poolProps)) - {{endif}} - {{if 'cudaMemAllocNodeParamsV2.accessDescs' in found_struct}} + + @property def accessDescs(self): arrs = [self._pvt_ptr[0].accessDescs + x*sizeof(cyruntime.cudaMemAccessDesc) for x in range(self._accessDescs_length)] @@ -11921,24 +11503,24 @@ cdef class cudaMemAllocNodeParamsV2: for idx in range(len(val)): string.memcpy(&self._accessDescs[idx], (val[idx])._pvt_ptr, sizeof(cyruntime.cudaMemAccessDesc)) - {{endif}} - {{if 'cudaMemAllocNodeParamsV2.accessDescCount' in found_struct}} + + @property def accessDescCount(self): return self._pvt_ptr[0].accessDescCount @accessDescCount.setter def accessDescCount(self, size_t accessDescCount): self._pvt_ptr[0].accessDescCount = accessDescCount - {{endif}} - {{if 'cudaMemAllocNodeParamsV2.bytesize' in found_struct}} + + @property def bytesize(self): return self._pvt_ptr[0].bytesize @bytesize.setter def bytesize(self, size_t bytesize): self._pvt_ptr[0].bytesize = bytesize - {{endif}} - {{if 'cudaMemAllocNodeParamsV2.dptr' in found_struct}} + + @property def dptr(self): return self._pvt_ptr[0].dptr @@ -11946,9 +11528,7 @@ cdef class cudaMemAllocNodeParamsV2: def dptr(self, dptr): self._cydptr = _HelperInputVoidPtr(dptr) self._pvt_ptr[0].dptr = self._cydptr.cptr - {{endif}} -{{endif}} -{{if 'cudaMemFreeNodeParams' in found_struct}} + cdef class cudaMemFreeNodeParams: """ @@ -11956,10 +11536,10 @@ cdef class cudaMemFreeNodeParams: Attributes ---------- - {{if 'cudaMemFreeNodeParams.dptr' in found_struct}} + dptr : Any in: the pointer to free - {{endif}} + Methods ------- @@ -11980,16 +11560,16 @@ cdef class cudaMemFreeNodeParams: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaMemFreeNodeParams.dptr' in found_struct}} + try: str_list += ['dptr : ' + hex(self.dptr)] except ValueError: str_list += ['dptr : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaMemFreeNodeParams.dptr' in found_struct}} + @property def dptr(self): return self._pvt_ptr[0].dptr @@ -11997,9 +11577,7 @@ cdef class cudaMemFreeNodeParams: def dptr(self, dptr): self._cydptr = _HelperInputVoidPtr(dptr) self._pvt_ptr[0].dptr = self._cydptr.cptr - {{endif}} -{{endif}} -{{if 'cudaMemcpyAttributes' in found_struct}} + cdef class cudaMemcpyAttributes: """ @@ -12008,26 +11586,26 @@ cdef class cudaMemcpyAttributes: Attributes ---------- - {{if 'cudaMemcpyAttributes.srcAccessOrder' in found_struct}} + srcAccessOrder : cudaMemcpySrcAccessOrder Source access ordering to be observed for copies with this attribute. - {{endif}} - {{if 'cudaMemcpyAttributes.srcLocHint' in found_struct}} + + srcLocHint : cudaMemLocation Hint location for the source operand. Ignored when the pointers are not managed memory or memory allocated outside CUDA. - {{endif}} - {{if 'cudaMemcpyAttributes.dstLocHint' in found_struct}} + + dstLocHint : cudaMemLocation Hint location for the destination operand. Ignored when the pointers are not managed memory or memory allocated outside CUDA. - {{endif}} - {{if 'cudaMemcpyAttributes.flags' in found_struct}} + + flags : unsigned int Additional flags for copies with this attribute. See cudaMemcpyFlags. - {{endif}} + Methods ------- @@ -12041,12 +11619,12 @@ cdef class cudaMemcpyAttributes: self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass - {{if 'cudaMemcpyAttributes.srcLocHint' in found_struct}} + self._srcLocHint = cudaMemLocation(_ptr=&self._pvt_ptr[0].srcLocHint) - {{endif}} - {{if 'cudaMemcpyAttributes.dstLocHint' in found_struct}} + + self._dstLocHint = cudaMemLocation(_ptr=&self._pvt_ptr[0].dstLocHint) - {{endif}} + def __dealloc__(self): pass def getPtr(self): @@ -12054,67 +11632,65 @@ cdef class cudaMemcpyAttributes: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaMemcpyAttributes.srcAccessOrder' in found_struct}} + try: str_list += ['srcAccessOrder : ' + str(self.srcAccessOrder)] except ValueError: str_list += ['srcAccessOrder : '] - {{endif}} - {{if 'cudaMemcpyAttributes.srcLocHint' in found_struct}} + + try: str_list += ['srcLocHint :\n' + '\n'.join([' ' + line for line in str(self.srcLocHint).splitlines()])] except ValueError: str_list += ['srcLocHint : '] - {{endif}} - {{if 'cudaMemcpyAttributes.dstLocHint' in found_struct}} + + try: str_list += ['dstLocHint :\n' + '\n'.join([' ' + line for line in str(self.dstLocHint).splitlines()])] except ValueError: str_list += ['dstLocHint : '] - {{endif}} - {{if 'cudaMemcpyAttributes.flags' in found_struct}} + + try: str_list += ['flags : ' + str(self.flags)] except ValueError: str_list += ['flags : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaMemcpyAttributes.srcAccessOrder' in found_struct}} + @property def srcAccessOrder(self): return cudaMemcpySrcAccessOrder(self._pvt_ptr[0].srcAccessOrder) @srcAccessOrder.setter def srcAccessOrder(self, srcAccessOrder not None : cudaMemcpySrcAccessOrder): - self._pvt_ptr[0].srcAccessOrder = int(srcAccessOrder) - {{endif}} - {{if 'cudaMemcpyAttributes.srcLocHint' in found_struct}} + self._pvt_ptr[0].srcAccessOrder = int(srcAccessOrder) + + @property def srcLocHint(self): return self._srcLocHint @srcLocHint.setter def srcLocHint(self, srcLocHint not None : cudaMemLocation): string.memcpy(&self._pvt_ptr[0].srcLocHint, srcLocHint.getPtr(), sizeof(self._pvt_ptr[0].srcLocHint)) - {{endif}} - {{if 'cudaMemcpyAttributes.dstLocHint' in found_struct}} + + @property def dstLocHint(self): return self._dstLocHint @dstLocHint.setter def dstLocHint(self, dstLocHint not None : cudaMemLocation): string.memcpy(&self._pvt_ptr[0].dstLocHint, dstLocHint.getPtr(), sizeof(self._pvt_ptr[0].dstLocHint)) - {{endif}} - {{if 'cudaMemcpyAttributes.flags' in found_struct}} + + @property def flags(self): return self._pvt_ptr[0].flags @flags.setter def flags(self, unsigned int flags): self._pvt_ptr[0].flags = flags - {{endif}} -{{endif}} -{{if 'cudaOffset3D' in found_struct}} + cdef class cudaOffset3D: """ @@ -12122,18 +11698,18 @@ cdef class cudaOffset3D: Attributes ---------- - {{if 'cudaOffset3D.x' in found_struct}} + x : size_t - {{endif}} - {{if 'cudaOffset3D.y' in found_struct}} + + y : size_t - {{endif}} - {{if 'cudaOffset3D.z' in found_struct}} + + z : size_t - {{endif}} + Methods ------- @@ -12154,74 +11730,72 @@ cdef class cudaOffset3D: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaOffset3D.x' in found_struct}} + try: str_list += ['x : ' + str(self.x)] except ValueError: str_list += ['x : '] - {{endif}} - {{if 'cudaOffset3D.y' in found_struct}} + + try: str_list += ['y : ' + str(self.y)] except ValueError: str_list += ['y : '] - {{endif}} - {{if 'cudaOffset3D.z' in found_struct}} + + try: str_list += ['z : ' + str(self.z)] except ValueError: str_list += ['z : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaOffset3D.x' in found_struct}} + @property def x(self): return self._pvt_ptr[0].x @x.setter def x(self, size_t x): self._pvt_ptr[0].x = x - {{endif}} - {{if 'cudaOffset3D.y' in found_struct}} + + @property def y(self): return self._pvt_ptr[0].y @y.setter def y(self, size_t y): self._pvt_ptr[0].y = y - {{endif}} - {{if 'cudaOffset3D.z' in found_struct}} + + @property def z(self): return self._pvt_ptr[0].z @z.setter def z(self, size_t z): self._pvt_ptr[0].z = z - {{endif}} -{{endif}} -{{if 'cudaMemcpy3DOperand.op.ptr' in found_struct}} + cdef class anon_struct6: """ Attributes ---------- - {{if 'cudaMemcpy3DOperand.op.ptr.ptr' in found_struct}} + ptr : Any - {{endif}} - {{if 'cudaMemcpy3DOperand.op.ptr.rowLength' in found_struct}} + + rowLength : size_t - {{endif}} - {{if 'cudaMemcpy3DOperand.op.ptr.layerHeight' in found_struct}} + + layerHeight : size_t - {{endif}} - {{if 'cudaMemcpy3DOperand.op.ptr.locHint' in found_struct}} + + locHint : cudaMemLocation - {{endif}} + Methods ------- @@ -12233,9 +11807,9 @@ cdef class anon_struct6: def __init__(self, void_ptr _ptr): pass - {{if 'cudaMemcpy3DOperand.op.ptr.locHint' in found_struct}} + self._locHint = cudaMemLocation(_ptr=&self._pvt_ptr[0].op.ptr.locHint) - {{endif}} + def __dealloc__(self): pass def getPtr(self): @@ -12243,34 +11817,34 @@ cdef class anon_struct6: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaMemcpy3DOperand.op.ptr.ptr' in found_struct}} + try: str_list += ['ptr : ' + hex(self.ptr)] except ValueError: str_list += ['ptr : '] - {{endif}} - {{if 'cudaMemcpy3DOperand.op.ptr.rowLength' in found_struct}} + + try: str_list += ['rowLength : ' + str(self.rowLength)] except ValueError: str_list += ['rowLength : '] - {{endif}} - {{if 'cudaMemcpy3DOperand.op.ptr.layerHeight' in found_struct}} + + try: str_list += ['layerHeight : ' + str(self.layerHeight)] except ValueError: str_list += ['layerHeight : '] - {{endif}} - {{if 'cudaMemcpy3DOperand.op.ptr.locHint' in found_struct}} + + try: str_list += ['locHint :\n' + '\n'.join([' ' + line for line in str(self.locHint).splitlines()])] except ValueError: str_list += ['locHint : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaMemcpy3DOperand.op.ptr.ptr' in found_struct}} + @property def ptr(self): return self._pvt_ptr[0].op.ptr.ptr @@ -12278,46 +11852,44 @@ cdef class anon_struct6: def ptr(self, ptr): self._cyptr = _HelperInputVoidPtr(ptr) self._pvt_ptr[0].op.ptr.ptr = self._cyptr.cptr - {{endif}} - {{if 'cudaMemcpy3DOperand.op.ptr.rowLength' in found_struct}} + + @property def rowLength(self): return self._pvt_ptr[0].op.ptr.rowLength @rowLength.setter def rowLength(self, size_t rowLength): self._pvt_ptr[0].op.ptr.rowLength = rowLength - {{endif}} - {{if 'cudaMemcpy3DOperand.op.ptr.layerHeight' in found_struct}} + + @property def layerHeight(self): return self._pvt_ptr[0].op.ptr.layerHeight @layerHeight.setter def layerHeight(self, size_t layerHeight): self._pvt_ptr[0].op.ptr.layerHeight = layerHeight - {{endif}} - {{if 'cudaMemcpy3DOperand.op.ptr.locHint' in found_struct}} + + @property def locHint(self): return self._locHint @locHint.setter def locHint(self, locHint not None : cudaMemLocation): string.memcpy(&self._pvt_ptr[0].op.ptr.locHint, locHint.getPtr(), sizeof(self._pvt_ptr[0].op.ptr.locHint)) - {{endif}} -{{endif}} -{{if 'cudaMemcpy3DOperand.op.array' in found_struct}} + cdef class anon_struct7: """ Attributes ---------- - {{if 'cudaMemcpy3DOperand.op.array.array' in found_struct}} + array : cudaArray_t - {{endif}} - {{if 'cudaMemcpy3DOperand.op.array.offset' in found_struct}} + + offset : cudaOffset3D - {{endif}} + Methods ------- @@ -12329,12 +11901,12 @@ cdef class anon_struct7: def __init__(self, void_ptr _ptr): pass - {{if 'cudaMemcpy3DOperand.op.array.array' in found_struct}} + self._array = cudaArray_t(_ptr=&self._pvt_ptr[0].op.array.array) - {{endif}} - {{if 'cudaMemcpy3DOperand.op.array.offset' in found_struct}} + + self._offset = cudaOffset3D(_ptr=&self._pvt_ptr[0].op.array.offset) - {{endif}} + def __dealloc__(self): pass def getPtr(self): @@ -12342,22 +11914,22 @@ cdef class anon_struct7: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaMemcpy3DOperand.op.array.array' in found_struct}} + try: str_list += ['array : ' + str(self.array)] except ValueError: str_list += ['array : '] - {{endif}} - {{if 'cudaMemcpy3DOperand.op.array.offset' in found_struct}} + + try: str_list += ['offset :\n' + '\n'.join([' ' + line for line in str(self.offset).splitlines()])] except ValueError: str_list += ['offset : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaMemcpy3DOperand.op.array.array' in found_struct}} + @property def array(self): return self._array @@ -12373,30 +11945,28 @@ cdef class anon_struct7: parray = int(cudaArray_t(array)) cyarray = parray self._array._pvt_ptr[0] = cyarray - {{endif}} - {{if 'cudaMemcpy3DOperand.op.array.offset' in found_struct}} + + @property def offset(self): return self._offset @offset.setter def offset(self, offset not None : cudaOffset3D): string.memcpy(&self._pvt_ptr[0].op.array.offset, offset.getPtr(), sizeof(self._pvt_ptr[0].op.array.offset)) - {{endif}} -{{endif}} -{{if 'cudaMemcpy3DOperand.op' in found_struct}} + cdef class anon_union2: """ Attributes ---------- - {{if 'cudaMemcpy3DOperand.op.ptr' in found_struct}} + ptr : anon_struct6 - {{endif}} - {{if 'cudaMemcpy3DOperand.op.array' in found_struct}} + + array : anon_struct7 - {{endif}} + Methods ------- @@ -12408,12 +11978,12 @@ cdef class anon_union2: def __init__(self, void_ptr _ptr): pass - {{if 'cudaMemcpy3DOperand.op.ptr' in found_struct}} + self._ptr = anon_struct6(_ptr=self._pvt_ptr) - {{endif}} - {{if 'cudaMemcpy3DOperand.op.array' in found_struct}} + + self._array = anon_struct7(_ptr=self._pvt_ptr) - {{endif}} + def __dealloc__(self): pass def getPtr(self): @@ -12421,39 +11991,37 @@ cdef class anon_union2: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaMemcpy3DOperand.op.ptr' in found_struct}} + try: str_list += ['ptr :\n' + '\n'.join([' ' + line for line in str(self.ptr).splitlines()])] except ValueError: str_list += ['ptr : '] - {{endif}} - {{if 'cudaMemcpy3DOperand.op.array' in found_struct}} + + try: str_list += ['array :\n' + '\n'.join([' ' + line for line in str(self.array).splitlines()])] except ValueError: str_list += ['array : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaMemcpy3DOperand.op.ptr' in found_struct}} + @property def ptr(self): return self._ptr @ptr.setter def ptr(self, ptr not None : anon_struct6): string.memcpy(&self._pvt_ptr[0].op.ptr, ptr.getPtr(), sizeof(self._pvt_ptr[0].op.ptr)) - {{endif}} - {{if 'cudaMemcpy3DOperand.op.array' in found_struct}} + + @property def array(self): return self._array @array.setter def array(self, array not None : anon_struct7): string.memcpy(&self._pvt_ptr[0].op.array, array.getPtr(), sizeof(self._pvt_ptr[0].op.array)) - {{endif}} -{{endif}} -{{if 'cudaMemcpy3DOperand' in found_struct}} + cdef class cudaMemcpy3DOperand: """ @@ -12461,14 +12029,14 @@ cdef class cudaMemcpy3DOperand: Attributes ---------- - {{if 'cudaMemcpy3DOperand.type' in found_struct}} + type : cudaMemcpy3DOperandType - {{endif}} - {{if 'cudaMemcpy3DOperand.op' in found_struct}} + + op : anon_union2 - {{endif}} + Methods ------- @@ -12483,9 +12051,9 @@ cdef class cudaMemcpy3DOperand: self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass - {{if 'cudaMemcpy3DOperand.op' in found_struct}} + self._op = anon_union2(_ptr=self._pvt_ptr) - {{endif}} + def __dealloc__(self): if self._val_ptr is not NULL: free(self._val_ptr) @@ -12494,65 +12062,63 @@ cdef class cudaMemcpy3DOperand: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaMemcpy3DOperand.type' in found_struct}} + try: str_list += ['type : ' + str(self.type)] except ValueError: str_list += ['type : '] - {{endif}} - {{if 'cudaMemcpy3DOperand.op' in found_struct}} + + try: str_list += ['op :\n' + '\n'.join([' ' + line for line in str(self.op).splitlines()])] except ValueError: str_list += ['op : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaMemcpy3DOperand.type' in found_struct}} + @property def type(self): return cudaMemcpy3DOperandType(self._pvt_ptr[0].type) @type.setter def type(self, type not None : cudaMemcpy3DOperandType): - self._pvt_ptr[0].type = int(type) - {{endif}} - {{if 'cudaMemcpy3DOperand.op' in found_struct}} + self._pvt_ptr[0].type = int(type) + + @property def op(self): return self._op @op.setter def op(self, op not None : anon_union2): string.memcpy(&self._pvt_ptr[0].op, op.getPtr(), sizeof(self._pvt_ptr[0].op)) - {{endif}} -{{endif}} -{{if 'cudaMemcpy3DBatchOp' in found_struct}} + cdef class cudaMemcpy3DBatchOp: """ Attributes ---------- - {{if 'cudaMemcpy3DBatchOp.src' in found_struct}} + src : cudaMemcpy3DOperand Source memcpy operand. - {{endif}} - {{if 'cudaMemcpy3DBatchOp.dst' in found_struct}} + + dst : cudaMemcpy3DOperand Destination memcpy operand. - {{endif}} - {{if 'cudaMemcpy3DBatchOp.extent' in found_struct}} + + extent : cudaExtent Extents of the memcpy between src and dst. The width, height and depth components must not be 0. - {{endif}} - {{if 'cudaMemcpy3DBatchOp.srcAccessOrder' in found_struct}} + + srcAccessOrder : cudaMemcpySrcAccessOrder Source access ordering to be observed for copy from src to dst. - {{endif}} - {{if 'cudaMemcpy3DBatchOp.flags' in found_struct}} + + flags : unsigned int Additional flags for copy from src to dst. See cudaMemcpyFlags. - {{endif}} + Methods ------- @@ -12566,15 +12132,15 @@ cdef class cudaMemcpy3DBatchOp: self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass - {{if 'cudaMemcpy3DBatchOp.src' in found_struct}} + self._src = cudaMemcpy3DOperand(_ptr=&self._pvt_ptr[0].src) - {{endif}} - {{if 'cudaMemcpy3DBatchOp.dst' in found_struct}} + + self._dst = cudaMemcpy3DOperand(_ptr=&self._pvt_ptr[0].dst) - {{endif}} - {{if 'cudaMemcpy3DBatchOp.extent' in found_struct}} + + self._extent = cudaExtent(_ptr=&self._pvt_ptr[0].extent) - {{endif}} + def __dealloc__(self): pass def getPtr(self): @@ -12582,90 +12148,88 @@ cdef class cudaMemcpy3DBatchOp: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaMemcpy3DBatchOp.src' in found_struct}} + try: str_list += ['src :\n' + '\n'.join([' ' + line for line in str(self.src).splitlines()])] except ValueError: str_list += ['src : '] - {{endif}} - {{if 'cudaMemcpy3DBatchOp.dst' in found_struct}} + + try: str_list += ['dst :\n' + '\n'.join([' ' + line for line in str(self.dst).splitlines()])] except ValueError: str_list += ['dst : '] - {{endif}} - {{if 'cudaMemcpy3DBatchOp.extent' in found_struct}} + + try: str_list += ['extent :\n' + '\n'.join([' ' + line for line in str(self.extent).splitlines()])] except ValueError: str_list += ['extent : '] - {{endif}} - {{if 'cudaMemcpy3DBatchOp.srcAccessOrder' in found_struct}} + + try: str_list += ['srcAccessOrder : ' + str(self.srcAccessOrder)] except ValueError: str_list += ['srcAccessOrder : '] - {{endif}} - {{if 'cudaMemcpy3DBatchOp.flags' in found_struct}} + + try: str_list += ['flags : ' + str(self.flags)] except ValueError: str_list += ['flags : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaMemcpy3DBatchOp.src' in found_struct}} + @property def src(self): return self._src @src.setter def src(self, src not None : cudaMemcpy3DOperand): string.memcpy(&self._pvt_ptr[0].src, src.getPtr(), sizeof(self._pvt_ptr[0].src)) - {{endif}} - {{if 'cudaMemcpy3DBatchOp.dst' in found_struct}} + + @property def dst(self): return self._dst @dst.setter def dst(self, dst not None : cudaMemcpy3DOperand): string.memcpy(&self._pvt_ptr[0].dst, dst.getPtr(), sizeof(self._pvt_ptr[0].dst)) - {{endif}} - {{if 'cudaMemcpy3DBatchOp.extent' in found_struct}} + + @property def extent(self): return self._extent @extent.setter def extent(self, extent not None : cudaExtent): string.memcpy(&self._pvt_ptr[0].extent, extent.getPtr(), sizeof(self._pvt_ptr[0].extent)) - {{endif}} - {{if 'cudaMemcpy3DBatchOp.srcAccessOrder' in found_struct}} + + @property def srcAccessOrder(self): return cudaMemcpySrcAccessOrder(self._pvt_ptr[0].srcAccessOrder) @srcAccessOrder.setter def srcAccessOrder(self, srcAccessOrder not None : cudaMemcpySrcAccessOrder): - self._pvt_ptr[0].srcAccessOrder = int(srcAccessOrder) - {{endif}} - {{if 'cudaMemcpy3DBatchOp.flags' in found_struct}} + self._pvt_ptr[0].srcAccessOrder = int(srcAccessOrder) + + @property def flags(self): return self._pvt_ptr[0].flags @flags.setter def flags(self, unsigned int flags): self._pvt_ptr[0].flags = flags - {{endif}} -{{endif}} -{{if 'CUuuid_st' in found_struct}} + cdef class CUuuid_st: """ Attributes ---------- - {{if 'CUuuid_st.bytes' in found_struct}} + bytes : bytes < CUDA definition of UUID - {{endif}} + Methods ------- @@ -12686,22 +12250,20 @@ cdef class CUuuid_st: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'CUuuid_st.bytes' in found_struct}} + try: str_list += ['bytes : ' + str(self.bytes.hex())] except ValueError: str_list += ['bytes : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'CUuuid_st.bytes' in found_struct}} + @property def bytes(self): return PyBytes_FromStringAndSize(self._pvt_ptr[0].bytes, 16) - {{endif}} -{{endif}} -{{if 'cudaDeviceProp' in found_struct}} + cdef class cudaDeviceProp: """ @@ -12709,401 +12271,401 @@ cdef class cudaDeviceProp: Attributes ---------- - {{if 'cudaDeviceProp.name' in found_struct}} + name : bytes ASCII string identifying device - {{endif}} - {{if 'cudaDeviceProp.uuid' in found_struct}} + + uuid : cudaUUID_t 16-byte unique identifier - {{endif}} - {{if 'cudaDeviceProp.luid' in found_struct}} + + luid : bytes 8-byte locally unique identifier. Value is undefined on TCC and non-Windows platforms - {{endif}} - {{if 'cudaDeviceProp.luidDeviceNodeMask' in found_struct}} + + luidDeviceNodeMask : unsigned int LUID device node mask. Value is undefined on TCC and non-Windows platforms - {{endif}} - {{if 'cudaDeviceProp.totalGlobalMem' in found_struct}} + + totalGlobalMem : size_t Global memory available on device in bytes - {{endif}} - {{if 'cudaDeviceProp.sharedMemPerBlock' in found_struct}} + + sharedMemPerBlock : size_t Shared memory available per block in bytes - {{endif}} - {{if 'cudaDeviceProp.regsPerBlock' in found_struct}} + + regsPerBlock : int 32-bit registers available per block - {{endif}} - {{if 'cudaDeviceProp.warpSize' in found_struct}} + + warpSize : int Warp size in threads - {{endif}} - {{if 'cudaDeviceProp.memPitch' in found_struct}} + + memPitch : size_t Maximum pitch in bytes allowed by memory copies - {{endif}} - {{if 'cudaDeviceProp.maxThreadsPerBlock' in found_struct}} + + maxThreadsPerBlock : int Maximum number of threads per block - {{endif}} - {{if 'cudaDeviceProp.maxThreadsDim' in found_struct}} + + maxThreadsDim : list[int] Maximum size of each dimension of a block - {{endif}} - {{if 'cudaDeviceProp.maxGridSize' in found_struct}} + + maxGridSize : list[int] Maximum size of each dimension of a grid - {{endif}} - {{if 'cudaDeviceProp.totalConstMem' in found_struct}} + + totalConstMem : size_t Constant memory available on device in bytes - {{endif}} - {{if 'cudaDeviceProp.major' in found_struct}} + + major : int Major compute capability - {{endif}} - {{if 'cudaDeviceProp.minor' in found_struct}} + + minor : int Minor compute capability - {{endif}} - {{if 'cudaDeviceProp.textureAlignment' in found_struct}} + + textureAlignment : size_t Alignment requirement for textures - {{endif}} - {{if 'cudaDeviceProp.texturePitchAlignment' in found_struct}} + + texturePitchAlignment : size_t Pitch alignment requirement for texture references bound to pitched memory - {{endif}} - {{if 'cudaDeviceProp.multiProcessorCount' in found_struct}} + + multiProcessorCount : int Number of multiprocessors on device - {{endif}} - {{if 'cudaDeviceProp.integrated' in found_struct}} + + integrated : int Device is integrated as opposed to discrete - {{endif}} - {{if 'cudaDeviceProp.canMapHostMemory' in found_struct}} + + canMapHostMemory : int Device can map host memory with cudaHostAlloc/cudaHostGetDevicePointer - {{endif}} - {{if 'cudaDeviceProp.maxTexture1D' in found_struct}} + + maxTexture1D : int Maximum 1D texture size - {{endif}} - {{if 'cudaDeviceProp.maxTexture1DMipmap' in found_struct}} + + maxTexture1DMipmap : int Maximum 1D mipmapped texture size - {{endif}} - {{if 'cudaDeviceProp.maxTexture2D' in found_struct}} + + maxTexture2D : list[int] Maximum 2D texture dimensions - {{endif}} - {{if 'cudaDeviceProp.maxTexture2DMipmap' in found_struct}} + + maxTexture2DMipmap : list[int] Maximum 2D mipmapped texture dimensions - {{endif}} - {{if 'cudaDeviceProp.maxTexture2DLinear' in found_struct}} + + maxTexture2DLinear : list[int] Maximum dimensions (width, height, pitch) for 2D textures bound to pitched memory - {{endif}} - {{if 'cudaDeviceProp.maxTexture2DGather' in found_struct}} + + maxTexture2DGather : list[int] Maximum 2D texture dimensions if texture gather operations have to be performed - {{endif}} - {{if 'cudaDeviceProp.maxTexture3D' in found_struct}} + + maxTexture3D : list[int] Maximum 3D texture dimensions - {{endif}} - {{if 'cudaDeviceProp.maxTexture3DAlt' in found_struct}} + + maxTexture3DAlt : list[int] Maximum alternate 3D texture dimensions - {{endif}} - {{if 'cudaDeviceProp.maxTextureCubemap' in found_struct}} + + maxTextureCubemap : int Maximum Cubemap texture dimensions - {{endif}} - {{if 'cudaDeviceProp.maxTexture1DLayered' in found_struct}} + + maxTexture1DLayered : list[int] Maximum 1D layered texture dimensions - {{endif}} - {{if 'cudaDeviceProp.maxTexture2DLayered' in found_struct}} + + maxTexture2DLayered : list[int] Maximum 2D layered texture dimensions - {{endif}} - {{if 'cudaDeviceProp.maxTextureCubemapLayered' in found_struct}} + + maxTextureCubemapLayered : list[int] Maximum Cubemap layered texture dimensions - {{endif}} - {{if 'cudaDeviceProp.maxSurface1D' in found_struct}} + + maxSurface1D : int Maximum 1D surface size - {{endif}} - {{if 'cudaDeviceProp.maxSurface2D' in found_struct}} + + maxSurface2D : list[int] Maximum 2D surface dimensions - {{endif}} - {{if 'cudaDeviceProp.maxSurface3D' in found_struct}} + + maxSurface3D : list[int] Maximum 3D surface dimensions - {{endif}} - {{if 'cudaDeviceProp.maxSurface1DLayered' in found_struct}} + + maxSurface1DLayered : list[int] Maximum 1D layered surface dimensions - {{endif}} - {{if 'cudaDeviceProp.maxSurface2DLayered' in found_struct}} + + maxSurface2DLayered : list[int] Maximum 2D layered surface dimensions - {{endif}} - {{if 'cudaDeviceProp.maxSurfaceCubemap' in found_struct}} + + maxSurfaceCubemap : int Maximum Cubemap surface dimensions - {{endif}} - {{if 'cudaDeviceProp.maxSurfaceCubemapLayered' in found_struct}} + + maxSurfaceCubemapLayered : list[int] Maximum Cubemap layered surface dimensions - {{endif}} - {{if 'cudaDeviceProp.surfaceAlignment' in found_struct}} + + surfaceAlignment : size_t Alignment requirements for surfaces - {{endif}} - {{if 'cudaDeviceProp.concurrentKernels' in found_struct}} + + concurrentKernels : int Device can possibly execute multiple kernels concurrently - {{endif}} - {{if 'cudaDeviceProp.ECCEnabled' in found_struct}} + + ECCEnabled : int Device has ECC support enabled - {{endif}} - {{if 'cudaDeviceProp.pciBusID' in found_struct}} + + pciBusID : int PCI bus ID of the device - {{endif}} - {{if 'cudaDeviceProp.pciDeviceID' in found_struct}} + + pciDeviceID : int PCI device ID of the device - {{endif}} - {{if 'cudaDeviceProp.pciDomainID' in found_struct}} + + pciDomainID : int PCI domain ID of the device - {{endif}} - {{if 'cudaDeviceProp.tccDriver' in found_struct}} + + tccDriver : int 1 if device is a Tesla device using TCC driver, 0 otherwise - {{endif}} - {{if 'cudaDeviceProp.asyncEngineCount' in found_struct}} + + asyncEngineCount : int Number of asynchronous engines - {{endif}} - {{if 'cudaDeviceProp.unifiedAddressing' in found_struct}} + + unifiedAddressing : int Device shares a unified address space with the host - {{endif}} - {{if 'cudaDeviceProp.memoryBusWidth' in found_struct}} + + memoryBusWidth : int Global memory bus width in bits - {{endif}} - {{if 'cudaDeviceProp.l2CacheSize' in found_struct}} + + l2CacheSize : int Size of L2 cache in bytes - {{endif}} - {{if 'cudaDeviceProp.persistingL2CacheMaxSize' in found_struct}} + + persistingL2CacheMaxSize : int Device's maximum l2 persisting lines capacity setting in bytes - {{endif}} - {{if 'cudaDeviceProp.maxThreadsPerMultiProcessor' in found_struct}} + + maxThreadsPerMultiProcessor : int Maximum resident threads per multiprocessor - {{endif}} - {{if 'cudaDeviceProp.streamPrioritiesSupported' in found_struct}} + + streamPrioritiesSupported : int Device supports stream priorities - {{endif}} - {{if 'cudaDeviceProp.globalL1CacheSupported' in found_struct}} + + globalL1CacheSupported : int Device supports caching globals in L1 - {{endif}} - {{if 'cudaDeviceProp.localL1CacheSupported' in found_struct}} + + localL1CacheSupported : int Device supports caching locals in L1 - {{endif}} - {{if 'cudaDeviceProp.sharedMemPerMultiprocessor' in found_struct}} + + sharedMemPerMultiprocessor : size_t Shared memory available per multiprocessor in bytes - {{endif}} - {{if 'cudaDeviceProp.regsPerMultiprocessor' in found_struct}} + + regsPerMultiprocessor : int 32-bit registers available per multiprocessor - {{endif}} - {{if 'cudaDeviceProp.managedMemory' in found_struct}} + + managedMemory : int Device supports allocating managed memory on this system - {{endif}} - {{if 'cudaDeviceProp.isMultiGpuBoard' in found_struct}} + + isMultiGpuBoard : int Device is on a multi-GPU board - {{endif}} - {{if 'cudaDeviceProp.multiGpuBoardGroupID' in found_struct}} + + multiGpuBoardGroupID : int Unique identifier for a group of devices on the same multi-GPU board - {{endif}} - {{if 'cudaDeviceProp.hostNativeAtomicSupported' in found_struct}} + + hostNativeAtomicSupported : int Link between the device and the host supports native atomic operations - {{endif}} - {{if 'cudaDeviceProp.pageableMemoryAccess' in found_struct}} + + pageableMemoryAccess : int Device supports coherently accessing pageable memory without calling cudaHostRegister on it - {{endif}} - {{if 'cudaDeviceProp.concurrentManagedAccess' in found_struct}} + + concurrentManagedAccess : int Device can coherently access managed memory concurrently with the CPU - {{endif}} - {{if 'cudaDeviceProp.computePreemptionSupported' in found_struct}} + + computePreemptionSupported : int Device supports Compute Preemption - {{endif}} - {{if 'cudaDeviceProp.canUseHostPointerForRegisteredMem' in found_struct}} + + canUseHostPointerForRegisteredMem : int Device can access host registered memory at the same virtual address as the CPU - {{endif}} - {{if 'cudaDeviceProp.cooperativeLaunch' in found_struct}} + + cooperativeLaunch : int Device supports launching cooperative kernels via cudaLaunchCooperativeKernel - {{endif}} - {{if 'cudaDeviceProp.sharedMemPerBlockOptin' in found_struct}} + + sharedMemPerBlockOptin : size_t Per device maximum shared memory per block usable by special opt in - {{endif}} - {{if 'cudaDeviceProp.pageableMemoryAccessUsesHostPageTables' in found_struct}} + + pageableMemoryAccessUsesHostPageTables : int Device accesses pageable memory via the host's page tables - {{endif}} - {{if 'cudaDeviceProp.directManagedMemAccessFromHost' in found_struct}} + + directManagedMemAccessFromHost : int Host can directly access managed memory on the device without migration. - {{endif}} - {{if 'cudaDeviceProp.maxBlocksPerMultiProcessor' in found_struct}} + + maxBlocksPerMultiProcessor : int Maximum number of resident blocks per multiprocessor - {{endif}} - {{if 'cudaDeviceProp.accessPolicyMaxWindowSize' in found_struct}} + + accessPolicyMaxWindowSize : int The maximum value of cudaAccessPolicyWindow::num_bytes. - {{endif}} - {{if 'cudaDeviceProp.reservedSharedMemPerBlock' in found_struct}} + + reservedSharedMemPerBlock : size_t Shared memory reserved by CUDA driver per block in bytes - {{endif}} - {{if 'cudaDeviceProp.hostRegisterSupported' in found_struct}} + + hostRegisterSupported : int Device supports host memory registration via cudaHostRegister. - {{endif}} - {{if 'cudaDeviceProp.sparseCudaArraySupported' in found_struct}} + + sparseCudaArraySupported : int 1 if the device supports sparse CUDA arrays and sparse CUDA mipmapped arrays, 0 otherwise - {{endif}} - {{if 'cudaDeviceProp.hostRegisterReadOnlySupported' in found_struct}} + + hostRegisterReadOnlySupported : int Device supports using the cudaHostRegister flag cudaHostRegisterReadOnly to register memory that must be mapped as read-only to the GPU - {{endif}} - {{if 'cudaDeviceProp.timelineSemaphoreInteropSupported' in found_struct}} + + timelineSemaphoreInteropSupported : int External timeline semaphore interop is supported on the device - {{endif}} - {{if 'cudaDeviceProp.memoryPoolsSupported' in found_struct}} + + memoryPoolsSupported : int 1 if the device supports using the cudaMallocAsync and cudaMemPool family of APIs, 0 otherwise - {{endif}} - {{if 'cudaDeviceProp.gpuDirectRDMASupported' in found_struct}} + + gpuDirectRDMASupported : int 1 if the device supports GPUDirect RDMA APIs, 0 otherwise - {{endif}} - {{if 'cudaDeviceProp.gpuDirectRDMAFlushWritesOptions' in found_struct}} + + gpuDirectRDMAFlushWritesOptions : unsigned int Bitmask to be interpreted according to the cudaFlushGPUDirectRDMAWritesOptions enum - {{endif}} - {{if 'cudaDeviceProp.gpuDirectRDMAWritesOrdering' in found_struct}} + + gpuDirectRDMAWritesOrdering : int See the cudaGPUDirectRDMAWritesOrdering enum for numerical values - {{endif}} - {{if 'cudaDeviceProp.memoryPoolSupportedHandleTypes' in found_struct}} + + memoryPoolSupportedHandleTypes : unsigned int Bitmask of handle types supported with mempool-based IPC - {{endif}} - {{if 'cudaDeviceProp.deferredMappingCudaArraySupported' in found_struct}} + + deferredMappingCudaArraySupported : int 1 if the device supports deferred mapping CUDA arrays and CUDA mipmapped arrays - {{endif}} - {{if 'cudaDeviceProp.ipcEventSupported' in found_struct}} + + ipcEventSupported : int Device supports IPC Events. - {{endif}} - {{if 'cudaDeviceProp.clusterLaunch' in found_struct}} + + clusterLaunch : int Indicates device supports cluster launch - {{endif}} - {{if 'cudaDeviceProp.unifiedFunctionPointers' in found_struct}} + + unifiedFunctionPointers : int Indicates device supports unified pointers - {{endif}} - {{if 'cudaDeviceProp.deviceNumaConfig' in found_struct}} + + deviceNumaConfig : int NUMA configuration of a device: value is of type cudaDeviceNumaConfig enum - {{endif}} - {{if 'cudaDeviceProp.deviceNumaId' in found_struct}} + + deviceNumaId : int NUMA node ID of the GPU memory - {{endif}} - {{if 'cudaDeviceProp.mpsEnabled' in found_struct}} + + mpsEnabled : int Indicates if contexts created on this device will be shared via MPS - {{endif}} - {{if 'cudaDeviceProp.hostNumaId' in found_struct}} + + hostNumaId : int NUMA ID of the host node closest to the device or -1 when system does not support NUMA - {{endif}} - {{if 'cudaDeviceProp.gpuPciDeviceID' in found_struct}} + + gpuPciDeviceID : unsigned int The combined 16-bit PCI device ID and 16-bit PCI vendor ID - {{endif}} - {{if 'cudaDeviceProp.gpuPciSubsystemID' in found_struct}} + + gpuPciSubsystemID : unsigned int The combined 16-bit PCI subsystem ID and 16-bit PCI subsystem vendor ID - {{endif}} - {{if 'cudaDeviceProp.hostNumaMultinodeIpcSupported' in found_struct}} + + hostNumaMultinodeIpcSupported : int 1 if the device supports HostNuma location IPC between nodes in a multi-node system. - {{endif}} - {{if 'cudaDeviceProp.reserved' in found_struct}} + + reserved : list[int] Reserved for future use - {{endif}} + Methods ------- @@ -13117,9 +12679,9 @@ cdef class cudaDeviceProp: self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass - {{if 'cudaDeviceProp.uuid' in found_struct}} + self._uuid = cudaUUID_t(_ptr=&self._pvt_ptr[0].uuid) - {{endif}} + def __dealloc__(self): pass def getPtr(self): @@ -13127,568 +12689,568 @@ cdef class cudaDeviceProp: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaDeviceProp.name' in found_struct}} + try: str_list += ['name : ' + self.name.decode('utf-8')] except ValueError: str_list += ['name : '] - {{endif}} - {{if 'cudaDeviceProp.uuid' in found_struct}} + + try: str_list += ['uuid :\n' + '\n'.join([' ' + line for line in str(self.uuid).splitlines()])] except ValueError: str_list += ['uuid : '] - {{endif}} - {{if 'cudaDeviceProp.luid' in found_struct}} + + try: str_list += ['luid : ' + self.luid.hex()] except ValueError: str_list += ['luid : '] - {{endif}} - {{if 'cudaDeviceProp.luidDeviceNodeMask' in found_struct}} + + try: str_list += ['luidDeviceNodeMask : ' + str(self.luidDeviceNodeMask)] except ValueError: str_list += ['luidDeviceNodeMask : '] - {{endif}} - {{if 'cudaDeviceProp.totalGlobalMem' in found_struct}} + + try: str_list += ['totalGlobalMem : ' + str(self.totalGlobalMem)] except ValueError: str_list += ['totalGlobalMem : '] - {{endif}} - {{if 'cudaDeviceProp.sharedMemPerBlock' in found_struct}} + + try: str_list += ['sharedMemPerBlock : ' + str(self.sharedMemPerBlock)] except ValueError: str_list += ['sharedMemPerBlock : '] - {{endif}} - {{if 'cudaDeviceProp.regsPerBlock' in found_struct}} + + try: str_list += ['regsPerBlock : ' + str(self.regsPerBlock)] except ValueError: str_list += ['regsPerBlock : '] - {{endif}} - {{if 'cudaDeviceProp.warpSize' in found_struct}} + + try: str_list += ['warpSize : ' + str(self.warpSize)] except ValueError: str_list += ['warpSize : '] - {{endif}} - {{if 'cudaDeviceProp.memPitch' in found_struct}} + + try: str_list += ['memPitch : ' + str(self.memPitch)] except ValueError: str_list += ['memPitch : '] - {{endif}} - {{if 'cudaDeviceProp.maxThreadsPerBlock' in found_struct}} + + try: str_list += ['maxThreadsPerBlock : ' + str(self.maxThreadsPerBlock)] except ValueError: str_list += ['maxThreadsPerBlock : '] - {{endif}} - {{if 'cudaDeviceProp.maxThreadsDim' in found_struct}} + + try: str_list += ['maxThreadsDim : ' + str(self.maxThreadsDim)] except ValueError: str_list += ['maxThreadsDim : '] - {{endif}} - {{if 'cudaDeviceProp.maxGridSize' in found_struct}} + + try: str_list += ['maxGridSize : ' + str(self.maxGridSize)] except ValueError: str_list += ['maxGridSize : '] - {{endif}} - {{if 'cudaDeviceProp.totalConstMem' in found_struct}} + + try: str_list += ['totalConstMem : ' + str(self.totalConstMem)] except ValueError: str_list += ['totalConstMem : '] - {{endif}} - {{if 'cudaDeviceProp.major' in found_struct}} + + try: str_list += ['major : ' + str(self.major)] except ValueError: str_list += ['major : '] - {{endif}} - {{if 'cudaDeviceProp.minor' in found_struct}} + + try: str_list += ['minor : ' + str(self.minor)] except ValueError: str_list += ['minor : '] - {{endif}} - {{if 'cudaDeviceProp.textureAlignment' in found_struct}} + + try: str_list += ['textureAlignment : ' + str(self.textureAlignment)] except ValueError: str_list += ['textureAlignment : '] - {{endif}} - {{if 'cudaDeviceProp.texturePitchAlignment' in found_struct}} + + try: str_list += ['texturePitchAlignment : ' + str(self.texturePitchAlignment)] except ValueError: str_list += ['texturePitchAlignment : '] - {{endif}} - {{if 'cudaDeviceProp.multiProcessorCount' in found_struct}} + + try: str_list += ['multiProcessorCount : ' + str(self.multiProcessorCount)] except ValueError: str_list += ['multiProcessorCount : '] - {{endif}} - {{if 'cudaDeviceProp.integrated' in found_struct}} + + try: str_list += ['integrated : ' + str(self.integrated)] except ValueError: str_list += ['integrated : '] - {{endif}} - {{if 'cudaDeviceProp.canMapHostMemory' in found_struct}} + + try: str_list += ['canMapHostMemory : ' + str(self.canMapHostMemory)] except ValueError: str_list += ['canMapHostMemory : '] - {{endif}} - {{if 'cudaDeviceProp.maxTexture1D' in found_struct}} + + try: str_list += ['maxTexture1D : ' + str(self.maxTexture1D)] except ValueError: str_list += ['maxTexture1D : '] - {{endif}} - {{if 'cudaDeviceProp.maxTexture1DMipmap' in found_struct}} + + try: str_list += ['maxTexture1DMipmap : ' + str(self.maxTexture1DMipmap)] except ValueError: str_list += ['maxTexture1DMipmap : '] - {{endif}} - {{if 'cudaDeviceProp.maxTexture2D' in found_struct}} + + try: str_list += ['maxTexture2D : ' + str(self.maxTexture2D)] except ValueError: str_list += ['maxTexture2D : '] - {{endif}} - {{if 'cudaDeviceProp.maxTexture2DMipmap' in found_struct}} + + try: str_list += ['maxTexture2DMipmap : ' + str(self.maxTexture2DMipmap)] except ValueError: str_list += ['maxTexture2DMipmap : '] - {{endif}} - {{if 'cudaDeviceProp.maxTexture2DLinear' in found_struct}} + + try: str_list += ['maxTexture2DLinear : ' + str(self.maxTexture2DLinear)] except ValueError: str_list += ['maxTexture2DLinear : '] - {{endif}} - {{if 'cudaDeviceProp.maxTexture2DGather' in found_struct}} + + try: str_list += ['maxTexture2DGather : ' + str(self.maxTexture2DGather)] except ValueError: str_list += ['maxTexture2DGather : '] - {{endif}} - {{if 'cudaDeviceProp.maxTexture3D' in found_struct}} + + try: str_list += ['maxTexture3D : ' + str(self.maxTexture3D)] except ValueError: str_list += ['maxTexture3D : '] - {{endif}} - {{if 'cudaDeviceProp.maxTexture3DAlt' in found_struct}} + + try: str_list += ['maxTexture3DAlt : ' + str(self.maxTexture3DAlt)] except ValueError: str_list += ['maxTexture3DAlt : '] - {{endif}} - {{if 'cudaDeviceProp.maxTextureCubemap' in found_struct}} + + try: str_list += ['maxTextureCubemap : ' + str(self.maxTextureCubemap)] except ValueError: str_list += ['maxTextureCubemap : '] - {{endif}} - {{if 'cudaDeviceProp.maxTexture1DLayered' in found_struct}} + + try: str_list += ['maxTexture1DLayered : ' + str(self.maxTexture1DLayered)] except ValueError: str_list += ['maxTexture1DLayered : '] - {{endif}} - {{if 'cudaDeviceProp.maxTexture2DLayered' in found_struct}} + + try: str_list += ['maxTexture2DLayered : ' + str(self.maxTexture2DLayered)] except ValueError: str_list += ['maxTexture2DLayered : '] - {{endif}} - {{if 'cudaDeviceProp.maxTextureCubemapLayered' in found_struct}} + + try: str_list += ['maxTextureCubemapLayered : ' + str(self.maxTextureCubemapLayered)] except ValueError: str_list += ['maxTextureCubemapLayered : '] - {{endif}} - {{if 'cudaDeviceProp.maxSurface1D' in found_struct}} + + try: str_list += ['maxSurface1D : ' + str(self.maxSurface1D)] except ValueError: str_list += ['maxSurface1D : '] - {{endif}} - {{if 'cudaDeviceProp.maxSurface2D' in found_struct}} + + try: str_list += ['maxSurface2D : ' + str(self.maxSurface2D)] except ValueError: str_list += ['maxSurface2D : '] - {{endif}} - {{if 'cudaDeviceProp.maxSurface3D' in found_struct}} + + try: str_list += ['maxSurface3D : ' + str(self.maxSurface3D)] except ValueError: str_list += ['maxSurface3D : '] - {{endif}} - {{if 'cudaDeviceProp.maxSurface1DLayered' in found_struct}} + + try: str_list += ['maxSurface1DLayered : ' + str(self.maxSurface1DLayered)] except ValueError: str_list += ['maxSurface1DLayered : '] - {{endif}} - {{if 'cudaDeviceProp.maxSurface2DLayered' in found_struct}} + + try: str_list += ['maxSurface2DLayered : ' + str(self.maxSurface2DLayered)] except ValueError: str_list += ['maxSurface2DLayered : '] - {{endif}} - {{if 'cudaDeviceProp.maxSurfaceCubemap' in found_struct}} + + try: str_list += ['maxSurfaceCubemap : ' + str(self.maxSurfaceCubemap)] except ValueError: str_list += ['maxSurfaceCubemap : '] - {{endif}} - {{if 'cudaDeviceProp.maxSurfaceCubemapLayered' in found_struct}} + + try: str_list += ['maxSurfaceCubemapLayered : ' + str(self.maxSurfaceCubemapLayered)] except ValueError: str_list += ['maxSurfaceCubemapLayered : '] - {{endif}} - {{if 'cudaDeviceProp.surfaceAlignment' in found_struct}} + + try: str_list += ['surfaceAlignment : ' + str(self.surfaceAlignment)] except ValueError: str_list += ['surfaceAlignment : '] - {{endif}} - {{if 'cudaDeviceProp.concurrentKernels' in found_struct}} + + try: str_list += ['concurrentKernels : ' + str(self.concurrentKernels)] except ValueError: str_list += ['concurrentKernels : '] - {{endif}} - {{if 'cudaDeviceProp.ECCEnabled' in found_struct}} + + try: str_list += ['ECCEnabled : ' + str(self.ECCEnabled)] except ValueError: str_list += ['ECCEnabled : '] - {{endif}} - {{if 'cudaDeviceProp.pciBusID' in found_struct}} + + try: str_list += ['pciBusID : ' + str(self.pciBusID)] except ValueError: str_list += ['pciBusID : '] - {{endif}} - {{if 'cudaDeviceProp.pciDeviceID' in found_struct}} + + try: str_list += ['pciDeviceID : ' + str(self.pciDeviceID)] except ValueError: str_list += ['pciDeviceID : '] - {{endif}} - {{if 'cudaDeviceProp.pciDomainID' in found_struct}} + + try: str_list += ['pciDomainID : ' + str(self.pciDomainID)] except ValueError: str_list += ['pciDomainID : '] - {{endif}} - {{if 'cudaDeviceProp.tccDriver' in found_struct}} + + try: str_list += ['tccDriver : ' + str(self.tccDriver)] except ValueError: str_list += ['tccDriver : '] - {{endif}} - {{if 'cudaDeviceProp.asyncEngineCount' in found_struct}} + + try: str_list += ['asyncEngineCount : ' + str(self.asyncEngineCount)] except ValueError: str_list += ['asyncEngineCount : '] - {{endif}} - {{if 'cudaDeviceProp.unifiedAddressing' in found_struct}} + + try: str_list += ['unifiedAddressing : ' + str(self.unifiedAddressing)] except ValueError: str_list += ['unifiedAddressing : '] - {{endif}} - {{if 'cudaDeviceProp.memoryBusWidth' in found_struct}} + + try: str_list += ['memoryBusWidth : ' + str(self.memoryBusWidth)] except ValueError: str_list += ['memoryBusWidth : '] - {{endif}} - {{if 'cudaDeviceProp.l2CacheSize' in found_struct}} + + try: str_list += ['l2CacheSize : ' + str(self.l2CacheSize)] except ValueError: str_list += ['l2CacheSize : '] - {{endif}} - {{if 'cudaDeviceProp.persistingL2CacheMaxSize' in found_struct}} + + try: str_list += ['persistingL2CacheMaxSize : ' + str(self.persistingL2CacheMaxSize)] except ValueError: str_list += ['persistingL2CacheMaxSize : '] - {{endif}} - {{if 'cudaDeviceProp.maxThreadsPerMultiProcessor' in found_struct}} + + try: str_list += ['maxThreadsPerMultiProcessor : ' + str(self.maxThreadsPerMultiProcessor)] except ValueError: str_list += ['maxThreadsPerMultiProcessor : '] - {{endif}} - {{if 'cudaDeviceProp.streamPrioritiesSupported' in found_struct}} + + try: str_list += ['streamPrioritiesSupported : ' + str(self.streamPrioritiesSupported)] except ValueError: str_list += ['streamPrioritiesSupported : '] - {{endif}} - {{if 'cudaDeviceProp.globalL1CacheSupported' in found_struct}} + + try: str_list += ['globalL1CacheSupported : ' + str(self.globalL1CacheSupported)] except ValueError: str_list += ['globalL1CacheSupported : '] - {{endif}} - {{if 'cudaDeviceProp.localL1CacheSupported' in found_struct}} + + try: str_list += ['localL1CacheSupported : ' + str(self.localL1CacheSupported)] except ValueError: str_list += ['localL1CacheSupported : '] - {{endif}} - {{if 'cudaDeviceProp.sharedMemPerMultiprocessor' in found_struct}} + + try: str_list += ['sharedMemPerMultiprocessor : ' + str(self.sharedMemPerMultiprocessor)] except ValueError: str_list += ['sharedMemPerMultiprocessor : '] - {{endif}} - {{if 'cudaDeviceProp.regsPerMultiprocessor' in found_struct}} + + try: str_list += ['regsPerMultiprocessor : ' + str(self.regsPerMultiprocessor)] except ValueError: str_list += ['regsPerMultiprocessor : '] - {{endif}} - {{if 'cudaDeviceProp.managedMemory' in found_struct}} + + try: str_list += ['managedMemory : ' + str(self.managedMemory)] except ValueError: str_list += ['managedMemory : '] - {{endif}} - {{if 'cudaDeviceProp.isMultiGpuBoard' in found_struct}} + + try: str_list += ['isMultiGpuBoard : ' + str(self.isMultiGpuBoard)] except ValueError: str_list += ['isMultiGpuBoard : '] - {{endif}} - {{if 'cudaDeviceProp.multiGpuBoardGroupID' in found_struct}} + + try: str_list += ['multiGpuBoardGroupID : ' + str(self.multiGpuBoardGroupID)] except ValueError: str_list += ['multiGpuBoardGroupID : '] - {{endif}} - {{if 'cudaDeviceProp.hostNativeAtomicSupported' in found_struct}} + + try: str_list += ['hostNativeAtomicSupported : ' + str(self.hostNativeAtomicSupported)] except ValueError: str_list += ['hostNativeAtomicSupported : '] - {{endif}} - {{if 'cudaDeviceProp.pageableMemoryAccess' in found_struct}} + + try: str_list += ['pageableMemoryAccess : ' + str(self.pageableMemoryAccess)] except ValueError: str_list += ['pageableMemoryAccess : '] - {{endif}} - {{if 'cudaDeviceProp.concurrentManagedAccess' in found_struct}} + + try: str_list += ['concurrentManagedAccess : ' + str(self.concurrentManagedAccess)] except ValueError: str_list += ['concurrentManagedAccess : '] - {{endif}} - {{if 'cudaDeviceProp.computePreemptionSupported' in found_struct}} + + try: str_list += ['computePreemptionSupported : ' + str(self.computePreemptionSupported)] except ValueError: str_list += ['computePreemptionSupported : '] - {{endif}} - {{if 'cudaDeviceProp.canUseHostPointerForRegisteredMem' in found_struct}} + + try: str_list += ['canUseHostPointerForRegisteredMem : ' + str(self.canUseHostPointerForRegisteredMem)] except ValueError: str_list += ['canUseHostPointerForRegisteredMem : '] - {{endif}} - {{if 'cudaDeviceProp.cooperativeLaunch' in found_struct}} + + try: str_list += ['cooperativeLaunch : ' + str(self.cooperativeLaunch)] except ValueError: str_list += ['cooperativeLaunch : '] - {{endif}} - {{if 'cudaDeviceProp.sharedMemPerBlockOptin' in found_struct}} + + try: str_list += ['sharedMemPerBlockOptin : ' + str(self.sharedMemPerBlockOptin)] except ValueError: str_list += ['sharedMemPerBlockOptin : '] - {{endif}} - {{if 'cudaDeviceProp.pageableMemoryAccessUsesHostPageTables' in found_struct}} + + try: str_list += ['pageableMemoryAccessUsesHostPageTables : ' + str(self.pageableMemoryAccessUsesHostPageTables)] except ValueError: str_list += ['pageableMemoryAccessUsesHostPageTables : '] - {{endif}} - {{if 'cudaDeviceProp.directManagedMemAccessFromHost' in found_struct}} + + try: str_list += ['directManagedMemAccessFromHost : ' + str(self.directManagedMemAccessFromHost)] except ValueError: str_list += ['directManagedMemAccessFromHost : '] - {{endif}} - {{if 'cudaDeviceProp.maxBlocksPerMultiProcessor' in found_struct}} + + try: str_list += ['maxBlocksPerMultiProcessor : ' + str(self.maxBlocksPerMultiProcessor)] except ValueError: str_list += ['maxBlocksPerMultiProcessor : '] - {{endif}} - {{if 'cudaDeviceProp.accessPolicyMaxWindowSize' in found_struct}} + + try: str_list += ['accessPolicyMaxWindowSize : ' + str(self.accessPolicyMaxWindowSize)] except ValueError: str_list += ['accessPolicyMaxWindowSize : '] - {{endif}} - {{if 'cudaDeviceProp.reservedSharedMemPerBlock' in found_struct}} + + try: str_list += ['reservedSharedMemPerBlock : ' + str(self.reservedSharedMemPerBlock)] except ValueError: str_list += ['reservedSharedMemPerBlock : '] - {{endif}} - {{if 'cudaDeviceProp.hostRegisterSupported' in found_struct}} + + try: str_list += ['hostRegisterSupported : ' + str(self.hostRegisterSupported)] except ValueError: str_list += ['hostRegisterSupported : '] - {{endif}} - {{if 'cudaDeviceProp.sparseCudaArraySupported' in found_struct}} + + try: str_list += ['sparseCudaArraySupported : ' + str(self.sparseCudaArraySupported)] except ValueError: str_list += ['sparseCudaArraySupported : '] - {{endif}} - {{if 'cudaDeviceProp.hostRegisterReadOnlySupported' in found_struct}} + + try: str_list += ['hostRegisterReadOnlySupported : ' + str(self.hostRegisterReadOnlySupported)] except ValueError: str_list += ['hostRegisterReadOnlySupported : '] - {{endif}} - {{if 'cudaDeviceProp.timelineSemaphoreInteropSupported' in found_struct}} + + try: str_list += ['timelineSemaphoreInteropSupported : ' + str(self.timelineSemaphoreInteropSupported)] except ValueError: str_list += ['timelineSemaphoreInteropSupported : '] - {{endif}} - {{if 'cudaDeviceProp.memoryPoolsSupported' in found_struct}} + + try: str_list += ['memoryPoolsSupported : ' + str(self.memoryPoolsSupported)] except ValueError: str_list += ['memoryPoolsSupported : '] - {{endif}} - {{if 'cudaDeviceProp.gpuDirectRDMASupported' in found_struct}} + + try: str_list += ['gpuDirectRDMASupported : ' + str(self.gpuDirectRDMASupported)] except ValueError: str_list += ['gpuDirectRDMASupported : '] - {{endif}} - {{if 'cudaDeviceProp.gpuDirectRDMAFlushWritesOptions' in found_struct}} + + try: str_list += ['gpuDirectRDMAFlushWritesOptions : ' + str(self.gpuDirectRDMAFlushWritesOptions)] except ValueError: str_list += ['gpuDirectRDMAFlushWritesOptions : '] - {{endif}} - {{if 'cudaDeviceProp.gpuDirectRDMAWritesOrdering' in found_struct}} + + try: str_list += ['gpuDirectRDMAWritesOrdering : ' + str(self.gpuDirectRDMAWritesOrdering)] except ValueError: str_list += ['gpuDirectRDMAWritesOrdering : '] - {{endif}} - {{if 'cudaDeviceProp.memoryPoolSupportedHandleTypes' in found_struct}} + + try: str_list += ['memoryPoolSupportedHandleTypes : ' + str(self.memoryPoolSupportedHandleTypes)] except ValueError: str_list += ['memoryPoolSupportedHandleTypes : '] - {{endif}} - {{if 'cudaDeviceProp.deferredMappingCudaArraySupported' in found_struct}} + + try: str_list += ['deferredMappingCudaArraySupported : ' + str(self.deferredMappingCudaArraySupported)] except ValueError: str_list += ['deferredMappingCudaArraySupported : '] - {{endif}} - {{if 'cudaDeviceProp.ipcEventSupported' in found_struct}} + + try: str_list += ['ipcEventSupported : ' + str(self.ipcEventSupported)] except ValueError: str_list += ['ipcEventSupported : '] - {{endif}} - {{if 'cudaDeviceProp.clusterLaunch' in found_struct}} + + try: str_list += ['clusterLaunch : ' + str(self.clusterLaunch)] except ValueError: str_list += ['clusterLaunch : '] - {{endif}} - {{if 'cudaDeviceProp.unifiedFunctionPointers' in found_struct}} + + try: str_list += ['unifiedFunctionPointers : ' + str(self.unifiedFunctionPointers)] except ValueError: str_list += ['unifiedFunctionPointers : '] - {{endif}} - {{if 'cudaDeviceProp.deviceNumaConfig' in found_struct}} + + try: str_list += ['deviceNumaConfig : ' + str(self.deviceNumaConfig)] except ValueError: str_list += ['deviceNumaConfig : '] - {{endif}} - {{if 'cudaDeviceProp.deviceNumaId' in found_struct}} + + try: str_list += ['deviceNumaId : ' + str(self.deviceNumaId)] except ValueError: str_list += ['deviceNumaId : '] - {{endif}} - {{if 'cudaDeviceProp.mpsEnabled' in found_struct}} + + try: str_list += ['mpsEnabled : ' + str(self.mpsEnabled)] except ValueError: str_list += ['mpsEnabled : '] - {{endif}} - {{if 'cudaDeviceProp.hostNumaId' in found_struct}} + + try: str_list += ['hostNumaId : ' + str(self.hostNumaId)] except ValueError: str_list += ['hostNumaId : '] - {{endif}} - {{if 'cudaDeviceProp.gpuPciDeviceID' in found_struct}} + + try: str_list += ['gpuPciDeviceID : ' + str(self.gpuPciDeviceID)] except ValueError: str_list += ['gpuPciDeviceID : '] - {{endif}} - {{if 'cudaDeviceProp.gpuPciSubsystemID' in found_struct}} + + try: str_list += ['gpuPciSubsystemID : ' + str(self.gpuPciSubsystemID)] except ValueError: str_list += ['gpuPciSubsystemID : '] - {{endif}} - {{if 'cudaDeviceProp.hostNumaMultinodeIpcSupported' in found_struct}} + + try: str_list += ['hostNumaMultinodeIpcSupported : ' + str(self.hostNumaMultinodeIpcSupported)] except ValueError: str_list += ['hostNumaMultinodeIpcSupported : '] - {{endif}} - {{if 'cudaDeviceProp.reserved' in found_struct}} + + try: str_list += ['reserved : ' + str(self.reserved)] except ValueError: str_list += ['reserved : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaDeviceProp.name' in found_struct}} + @property def name(self): return self._pvt_ptr[0].name @@ -13696,16 +13258,16 @@ cdef class cudaDeviceProp: def name(self, name): pass self._pvt_ptr[0].name = name - {{endif}} - {{if 'cudaDeviceProp.uuid' in found_struct}} + + @property def uuid(self): return self._uuid @uuid.setter def uuid(self, uuid not None : cudaUUID_t): string.memcpy(&self._pvt_ptr[0].uuid, uuid.getPtr(), sizeof(self._pvt_ptr[0].uuid)) - {{endif}} - {{if 'cudaDeviceProp.luid' in found_struct}} + + @property def luid(self): return PyBytes_FromStringAndSize(self._pvt_ptr[0].luid, 8) @@ -13723,729 +13285,727 @@ cdef class cudaDeviceProp: if b > 127 and b < 256: b = b - 256 self._pvt_ptr[0].luid[i] = b - {{endif}} - {{if 'cudaDeviceProp.luidDeviceNodeMask' in found_struct}} + + @property def luidDeviceNodeMask(self): return self._pvt_ptr[0].luidDeviceNodeMask @luidDeviceNodeMask.setter def luidDeviceNodeMask(self, unsigned int luidDeviceNodeMask): self._pvt_ptr[0].luidDeviceNodeMask = luidDeviceNodeMask - {{endif}} - {{if 'cudaDeviceProp.totalGlobalMem' in found_struct}} + + @property def totalGlobalMem(self): return self._pvt_ptr[0].totalGlobalMem @totalGlobalMem.setter def totalGlobalMem(self, size_t totalGlobalMem): self._pvt_ptr[0].totalGlobalMem = totalGlobalMem - {{endif}} - {{if 'cudaDeviceProp.sharedMemPerBlock' in found_struct}} + + @property def sharedMemPerBlock(self): return self._pvt_ptr[0].sharedMemPerBlock @sharedMemPerBlock.setter def sharedMemPerBlock(self, size_t sharedMemPerBlock): self._pvt_ptr[0].sharedMemPerBlock = sharedMemPerBlock - {{endif}} - {{if 'cudaDeviceProp.regsPerBlock' in found_struct}} + + @property def regsPerBlock(self): return self._pvt_ptr[0].regsPerBlock @regsPerBlock.setter def regsPerBlock(self, int regsPerBlock): self._pvt_ptr[0].regsPerBlock = regsPerBlock - {{endif}} - {{if 'cudaDeviceProp.warpSize' in found_struct}} + + @property def warpSize(self): return self._pvt_ptr[0].warpSize @warpSize.setter def warpSize(self, int warpSize): self._pvt_ptr[0].warpSize = warpSize - {{endif}} - {{if 'cudaDeviceProp.memPitch' in found_struct}} + + @property def memPitch(self): return self._pvt_ptr[0].memPitch @memPitch.setter def memPitch(self, size_t memPitch): self._pvt_ptr[0].memPitch = memPitch - {{endif}} - {{if 'cudaDeviceProp.maxThreadsPerBlock' in found_struct}} + + @property def maxThreadsPerBlock(self): return self._pvt_ptr[0].maxThreadsPerBlock @maxThreadsPerBlock.setter def maxThreadsPerBlock(self, int maxThreadsPerBlock): self._pvt_ptr[0].maxThreadsPerBlock = maxThreadsPerBlock - {{endif}} - {{if 'cudaDeviceProp.maxThreadsDim' in found_struct}} + + @property def maxThreadsDim(self): return self._pvt_ptr[0].maxThreadsDim @maxThreadsDim.setter def maxThreadsDim(self, maxThreadsDim): self._pvt_ptr[0].maxThreadsDim = maxThreadsDim - {{endif}} - {{if 'cudaDeviceProp.maxGridSize' in found_struct}} + + @property def maxGridSize(self): return self._pvt_ptr[0].maxGridSize @maxGridSize.setter def maxGridSize(self, maxGridSize): self._pvt_ptr[0].maxGridSize = maxGridSize - {{endif}} - {{if 'cudaDeviceProp.totalConstMem' in found_struct}} + + @property def totalConstMem(self): return self._pvt_ptr[0].totalConstMem @totalConstMem.setter def totalConstMem(self, size_t totalConstMem): self._pvt_ptr[0].totalConstMem = totalConstMem - {{endif}} - {{if 'cudaDeviceProp.major' in found_struct}} + + @property def major(self): return self._pvt_ptr[0].major @major.setter def major(self, int major): self._pvt_ptr[0].major = major - {{endif}} - {{if 'cudaDeviceProp.minor' in found_struct}} + + @property def minor(self): return self._pvt_ptr[0].minor @minor.setter def minor(self, int minor): self._pvt_ptr[0].minor = minor - {{endif}} - {{if 'cudaDeviceProp.textureAlignment' in found_struct}} + + @property def textureAlignment(self): return self._pvt_ptr[0].textureAlignment @textureAlignment.setter def textureAlignment(self, size_t textureAlignment): self._pvt_ptr[0].textureAlignment = textureAlignment - {{endif}} - {{if 'cudaDeviceProp.texturePitchAlignment' in found_struct}} + + @property def texturePitchAlignment(self): return self._pvt_ptr[0].texturePitchAlignment @texturePitchAlignment.setter def texturePitchAlignment(self, size_t texturePitchAlignment): self._pvt_ptr[0].texturePitchAlignment = texturePitchAlignment - {{endif}} - {{if 'cudaDeviceProp.multiProcessorCount' in found_struct}} + + @property def multiProcessorCount(self): return self._pvt_ptr[0].multiProcessorCount @multiProcessorCount.setter def multiProcessorCount(self, int multiProcessorCount): self._pvt_ptr[0].multiProcessorCount = multiProcessorCount - {{endif}} - {{if 'cudaDeviceProp.integrated' in found_struct}} + + @property def integrated(self): return self._pvt_ptr[0].integrated @integrated.setter def integrated(self, int integrated): self._pvt_ptr[0].integrated = integrated - {{endif}} - {{if 'cudaDeviceProp.canMapHostMemory' in found_struct}} + + @property def canMapHostMemory(self): return self._pvt_ptr[0].canMapHostMemory @canMapHostMemory.setter def canMapHostMemory(self, int canMapHostMemory): self._pvt_ptr[0].canMapHostMemory = canMapHostMemory - {{endif}} - {{if 'cudaDeviceProp.maxTexture1D' in found_struct}} + + @property def maxTexture1D(self): return self._pvt_ptr[0].maxTexture1D @maxTexture1D.setter def maxTexture1D(self, int maxTexture1D): self._pvt_ptr[0].maxTexture1D = maxTexture1D - {{endif}} - {{if 'cudaDeviceProp.maxTexture1DMipmap' in found_struct}} + + @property def maxTexture1DMipmap(self): return self._pvt_ptr[0].maxTexture1DMipmap @maxTexture1DMipmap.setter def maxTexture1DMipmap(self, int maxTexture1DMipmap): self._pvt_ptr[0].maxTexture1DMipmap = maxTexture1DMipmap - {{endif}} - {{if 'cudaDeviceProp.maxTexture2D' in found_struct}} + + @property def maxTexture2D(self): return self._pvt_ptr[0].maxTexture2D @maxTexture2D.setter def maxTexture2D(self, maxTexture2D): self._pvt_ptr[0].maxTexture2D = maxTexture2D - {{endif}} - {{if 'cudaDeviceProp.maxTexture2DMipmap' in found_struct}} + + @property def maxTexture2DMipmap(self): return self._pvt_ptr[0].maxTexture2DMipmap @maxTexture2DMipmap.setter def maxTexture2DMipmap(self, maxTexture2DMipmap): self._pvt_ptr[0].maxTexture2DMipmap = maxTexture2DMipmap - {{endif}} - {{if 'cudaDeviceProp.maxTexture2DLinear' in found_struct}} + + @property def maxTexture2DLinear(self): return self._pvt_ptr[0].maxTexture2DLinear @maxTexture2DLinear.setter def maxTexture2DLinear(self, maxTexture2DLinear): self._pvt_ptr[0].maxTexture2DLinear = maxTexture2DLinear - {{endif}} - {{if 'cudaDeviceProp.maxTexture2DGather' in found_struct}} + + @property def maxTexture2DGather(self): return self._pvt_ptr[0].maxTexture2DGather @maxTexture2DGather.setter def maxTexture2DGather(self, maxTexture2DGather): self._pvt_ptr[0].maxTexture2DGather = maxTexture2DGather - {{endif}} - {{if 'cudaDeviceProp.maxTexture3D' in found_struct}} + + @property def maxTexture3D(self): return self._pvt_ptr[0].maxTexture3D @maxTexture3D.setter def maxTexture3D(self, maxTexture3D): self._pvt_ptr[0].maxTexture3D = maxTexture3D - {{endif}} - {{if 'cudaDeviceProp.maxTexture3DAlt' in found_struct}} + + @property def maxTexture3DAlt(self): return self._pvt_ptr[0].maxTexture3DAlt @maxTexture3DAlt.setter def maxTexture3DAlt(self, maxTexture3DAlt): self._pvt_ptr[0].maxTexture3DAlt = maxTexture3DAlt - {{endif}} - {{if 'cudaDeviceProp.maxTextureCubemap' in found_struct}} + + @property def maxTextureCubemap(self): return self._pvt_ptr[0].maxTextureCubemap @maxTextureCubemap.setter def maxTextureCubemap(self, int maxTextureCubemap): self._pvt_ptr[0].maxTextureCubemap = maxTextureCubemap - {{endif}} - {{if 'cudaDeviceProp.maxTexture1DLayered' in found_struct}} + + @property def maxTexture1DLayered(self): return self._pvt_ptr[0].maxTexture1DLayered @maxTexture1DLayered.setter def maxTexture1DLayered(self, maxTexture1DLayered): self._pvt_ptr[0].maxTexture1DLayered = maxTexture1DLayered - {{endif}} - {{if 'cudaDeviceProp.maxTexture2DLayered' in found_struct}} + + @property def maxTexture2DLayered(self): return self._pvt_ptr[0].maxTexture2DLayered @maxTexture2DLayered.setter def maxTexture2DLayered(self, maxTexture2DLayered): self._pvt_ptr[0].maxTexture2DLayered = maxTexture2DLayered - {{endif}} - {{if 'cudaDeviceProp.maxTextureCubemapLayered' in found_struct}} + + @property def maxTextureCubemapLayered(self): return self._pvt_ptr[0].maxTextureCubemapLayered @maxTextureCubemapLayered.setter def maxTextureCubemapLayered(self, maxTextureCubemapLayered): self._pvt_ptr[0].maxTextureCubemapLayered = maxTextureCubemapLayered - {{endif}} - {{if 'cudaDeviceProp.maxSurface1D' in found_struct}} + + @property def maxSurface1D(self): return self._pvt_ptr[0].maxSurface1D @maxSurface1D.setter def maxSurface1D(self, int maxSurface1D): self._pvt_ptr[0].maxSurface1D = maxSurface1D - {{endif}} - {{if 'cudaDeviceProp.maxSurface2D' in found_struct}} + + @property def maxSurface2D(self): return self._pvt_ptr[0].maxSurface2D @maxSurface2D.setter def maxSurface2D(self, maxSurface2D): self._pvt_ptr[0].maxSurface2D = maxSurface2D - {{endif}} - {{if 'cudaDeviceProp.maxSurface3D' in found_struct}} + + @property def maxSurface3D(self): return self._pvt_ptr[0].maxSurface3D @maxSurface3D.setter def maxSurface3D(self, maxSurface3D): self._pvt_ptr[0].maxSurface3D = maxSurface3D - {{endif}} - {{if 'cudaDeviceProp.maxSurface1DLayered' in found_struct}} + + @property def maxSurface1DLayered(self): return self._pvt_ptr[0].maxSurface1DLayered @maxSurface1DLayered.setter def maxSurface1DLayered(self, maxSurface1DLayered): self._pvt_ptr[0].maxSurface1DLayered = maxSurface1DLayered - {{endif}} - {{if 'cudaDeviceProp.maxSurface2DLayered' in found_struct}} + + @property def maxSurface2DLayered(self): return self._pvt_ptr[0].maxSurface2DLayered @maxSurface2DLayered.setter def maxSurface2DLayered(self, maxSurface2DLayered): self._pvt_ptr[0].maxSurface2DLayered = maxSurface2DLayered - {{endif}} - {{if 'cudaDeviceProp.maxSurfaceCubemap' in found_struct}} + + @property def maxSurfaceCubemap(self): return self._pvt_ptr[0].maxSurfaceCubemap @maxSurfaceCubemap.setter def maxSurfaceCubemap(self, int maxSurfaceCubemap): self._pvt_ptr[0].maxSurfaceCubemap = maxSurfaceCubemap - {{endif}} - {{if 'cudaDeviceProp.maxSurfaceCubemapLayered' in found_struct}} + + @property def maxSurfaceCubemapLayered(self): return self._pvt_ptr[0].maxSurfaceCubemapLayered @maxSurfaceCubemapLayered.setter def maxSurfaceCubemapLayered(self, maxSurfaceCubemapLayered): self._pvt_ptr[0].maxSurfaceCubemapLayered = maxSurfaceCubemapLayered - {{endif}} - {{if 'cudaDeviceProp.surfaceAlignment' in found_struct}} + + @property def surfaceAlignment(self): return self._pvt_ptr[0].surfaceAlignment @surfaceAlignment.setter def surfaceAlignment(self, size_t surfaceAlignment): self._pvt_ptr[0].surfaceAlignment = surfaceAlignment - {{endif}} - {{if 'cudaDeviceProp.concurrentKernels' in found_struct}} + + @property def concurrentKernels(self): return self._pvt_ptr[0].concurrentKernels @concurrentKernels.setter def concurrentKernels(self, int concurrentKernels): self._pvt_ptr[0].concurrentKernels = concurrentKernels - {{endif}} - {{if 'cudaDeviceProp.ECCEnabled' in found_struct}} + + @property def ECCEnabled(self): return self._pvt_ptr[0].ECCEnabled @ECCEnabled.setter def ECCEnabled(self, int ECCEnabled): self._pvt_ptr[0].ECCEnabled = ECCEnabled - {{endif}} - {{if 'cudaDeviceProp.pciBusID' in found_struct}} + + @property def pciBusID(self): return self._pvt_ptr[0].pciBusID @pciBusID.setter def pciBusID(self, int pciBusID): self._pvt_ptr[0].pciBusID = pciBusID - {{endif}} - {{if 'cudaDeviceProp.pciDeviceID' in found_struct}} + + @property def pciDeviceID(self): return self._pvt_ptr[0].pciDeviceID @pciDeviceID.setter def pciDeviceID(self, int pciDeviceID): self._pvt_ptr[0].pciDeviceID = pciDeviceID - {{endif}} - {{if 'cudaDeviceProp.pciDomainID' in found_struct}} + + @property def pciDomainID(self): return self._pvt_ptr[0].pciDomainID @pciDomainID.setter def pciDomainID(self, int pciDomainID): self._pvt_ptr[0].pciDomainID = pciDomainID - {{endif}} - {{if 'cudaDeviceProp.tccDriver' in found_struct}} + + @property def tccDriver(self): return self._pvt_ptr[0].tccDriver @tccDriver.setter def tccDriver(self, int tccDriver): self._pvt_ptr[0].tccDriver = tccDriver - {{endif}} - {{if 'cudaDeviceProp.asyncEngineCount' in found_struct}} + + @property def asyncEngineCount(self): return self._pvt_ptr[0].asyncEngineCount @asyncEngineCount.setter def asyncEngineCount(self, int asyncEngineCount): self._pvt_ptr[0].asyncEngineCount = asyncEngineCount - {{endif}} - {{if 'cudaDeviceProp.unifiedAddressing' in found_struct}} + + @property def unifiedAddressing(self): return self._pvt_ptr[0].unifiedAddressing @unifiedAddressing.setter def unifiedAddressing(self, int unifiedAddressing): self._pvt_ptr[0].unifiedAddressing = unifiedAddressing - {{endif}} - {{if 'cudaDeviceProp.memoryBusWidth' in found_struct}} + + @property def memoryBusWidth(self): return self._pvt_ptr[0].memoryBusWidth @memoryBusWidth.setter def memoryBusWidth(self, int memoryBusWidth): self._pvt_ptr[0].memoryBusWidth = memoryBusWidth - {{endif}} - {{if 'cudaDeviceProp.l2CacheSize' in found_struct}} + + @property def l2CacheSize(self): return self._pvt_ptr[0].l2CacheSize @l2CacheSize.setter def l2CacheSize(self, int l2CacheSize): self._pvt_ptr[0].l2CacheSize = l2CacheSize - {{endif}} - {{if 'cudaDeviceProp.persistingL2CacheMaxSize' in found_struct}} + + @property def persistingL2CacheMaxSize(self): return self._pvt_ptr[0].persistingL2CacheMaxSize @persistingL2CacheMaxSize.setter def persistingL2CacheMaxSize(self, int persistingL2CacheMaxSize): self._pvt_ptr[0].persistingL2CacheMaxSize = persistingL2CacheMaxSize - {{endif}} - {{if 'cudaDeviceProp.maxThreadsPerMultiProcessor' in found_struct}} + + @property def maxThreadsPerMultiProcessor(self): return self._pvt_ptr[0].maxThreadsPerMultiProcessor @maxThreadsPerMultiProcessor.setter def maxThreadsPerMultiProcessor(self, int maxThreadsPerMultiProcessor): self._pvt_ptr[0].maxThreadsPerMultiProcessor = maxThreadsPerMultiProcessor - {{endif}} - {{if 'cudaDeviceProp.streamPrioritiesSupported' in found_struct}} + + @property def streamPrioritiesSupported(self): return self._pvt_ptr[0].streamPrioritiesSupported @streamPrioritiesSupported.setter def streamPrioritiesSupported(self, int streamPrioritiesSupported): self._pvt_ptr[0].streamPrioritiesSupported = streamPrioritiesSupported - {{endif}} - {{if 'cudaDeviceProp.globalL1CacheSupported' in found_struct}} + + @property def globalL1CacheSupported(self): return self._pvt_ptr[0].globalL1CacheSupported @globalL1CacheSupported.setter def globalL1CacheSupported(self, int globalL1CacheSupported): self._pvt_ptr[0].globalL1CacheSupported = globalL1CacheSupported - {{endif}} - {{if 'cudaDeviceProp.localL1CacheSupported' in found_struct}} + + @property def localL1CacheSupported(self): return self._pvt_ptr[0].localL1CacheSupported @localL1CacheSupported.setter def localL1CacheSupported(self, int localL1CacheSupported): self._pvt_ptr[0].localL1CacheSupported = localL1CacheSupported - {{endif}} - {{if 'cudaDeviceProp.sharedMemPerMultiprocessor' in found_struct}} + + @property def sharedMemPerMultiprocessor(self): return self._pvt_ptr[0].sharedMemPerMultiprocessor @sharedMemPerMultiprocessor.setter def sharedMemPerMultiprocessor(self, size_t sharedMemPerMultiprocessor): self._pvt_ptr[0].sharedMemPerMultiprocessor = sharedMemPerMultiprocessor - {{endif}} - {{if 'cudaDeviceProp.regsPerMultiprocessor' in found_struct}} + + @property def regsPerMultiprocessor(self): return self._pvt_ptr[0].regsPerMultiprocessor @regsPerMultiprocessor.setter def regsPerMultiprocessor(self, int regsPerMultiprocessor): self._pvt_ptr[0].regsPerMultiprocessor = regsPerMultiprocessor - {{endif}} - {{if 'cudaDeviceProp.managedMemory' in found_struct}} + + @property def managedMemory(self): return self._pvt_ptr[0].managedMemory @managedMemory.setter def managedMemory(self, int managedMemory): self._pvt_ptr[0].managedMemory = managedMemory - {{endif}} - {{if 'cudaDeviceProp.isMultiGpuBoard' in found_struct}} + + @property def isMultiGpuBoard(self): return self._pvt_ptr[0].isMultiGpuBoard @isMultiGpuBoard.setter def isMultiGpuBoard(self, int isMultiGpuBoard): self._pvt_ptr[0].isMultiGpuBoard = isMultiGpuBoard - {{endif}} - {{if 'cudaDeviceProp.multiGpuBoardGroupID' in found_struct}} + + @property def multiGpuBoardGroupID(self): return self._pvt_ptr[0].multiGpuBoardGroupID @multiGpuBoardGroupID.setter def multiGpuBoardGroupID(self, int multiGpuBoardGroupID): self._pvt_ptr[0].multiGpuBoardGroupID = multiGpuBoardGroupID - {{endif}} - {{if 'cudaDeviceProp.hostNativeAtomicSupported' in found_struct}} + + @property def hostNativeAtomicSupported(self): return self._pvt_ptr[0].hostNativeAtomicSupported @hostNativeAtomicSupported.setter def hostNativeAtomicSupported(self, int hostNativeAtomicSupported): self._pvt_ptr[0].hostNativeAtomicSupported = hostNativeAtomicSupported - {{endif}} - {{if 'cudaDeviceProp.pageableMemoryAccess' in found_struct}} + + @property def pageableMemoryAccess(self): return self._pvt_ptr[0].pageableMemoryAccess @pageableMemoryAccess.setter def pageableMemoryAccess(self, int pageableMemoryAccess): self._pvt_ptr[0].pageableMemoryAccess = pageableMemoryAccess - {{endif}} - {{if 'cudaDeviceProp.concurrentManagedAccess' in found_struct}} + + @property def concurrentManagedAccess(self): return self._pvt_ptr[0].concurrentManagedAccess @concurrentManagedAccess.setter def concurrentManagedAccess(self, int concurrentManagedAccess): self._pvt_ptr[0].concurrentManagedAccess = concurrentManagedAccess - {{endif}} - {{if 'cudaDeviceProp.computePreemptionSupported' in found_struct}} + + @property def computePreemptionSupported(self): return self._pvt_ptr[0].computePreemptionSupported @computePreemptionSupported.setter def computePreemptionSupported(self, int computePreemptionSupported): self._pvt_ptr[0].computePreemptionSupported = computePreemptionSupported - {{endif}} - {{if 'cudaDeviceProp.canUseHostPointerForRegisteredMem' in found_struct}} + + @property def canUseHostPointerForRegisteredMem(self): return self._pvt_ptr[0].canUseHostPointerForRegisteredMem @canUseHostPointerForRegisteredMem.setter def canUseHostPointerForRegisteredMem(self, int canUseHostPointerForRegisteredMem): self._pvt_ptr[0].canUseHostPointerForRegisteredMem = canUseHostPointerForRegisteredMem - {{endif}} - {{if 'cudaDeviceProp.cooperativeLaunch' in found_struct}} + + @property def cooperativeLaunch(self): return self._pvt_ptr[0].cooperativeLaunch @cooperativeLaunch.setter def cooperativeLaunch(self, int cooperativeLaunch): self._pvt_ptr[0].cooperativeLaunch = cooperativeLaunch - {{endif}} - {{if 'cudaDeviceProp.sharedMemPerBlockOptin' in found_struct}} + + @property def sharedMemPerBlockOptin(self): return self._pvt_ptr[0].sharedMemPerBlockOptin @sharedMemPerBlockOptin.setter def sharedMemPerBlockOptin(self, size_t sharedMemPerBlockOptin): self._pvt_ptr[0].sharedMemPerBlockOptin = sharedMemPerBlockOptin - {{endif}} - {{if 'cudaDeviceProp.pageableMemoryAccessUsesHostPageTables' in found_struct}} + + @property def pageableMemoryAccessUsesHostPageTables(self): return self._pvt_ptr[0].pageableMemoryAccessUsesHostPageTables @pageableMemoryAccessUsesHostPageTables.setter def pageableMemoryAccessUsesHostPageTables(self, int pageableMemoryAccessUsesHostPageTables): self._pvt_ptr[0].pageableMemoryAccessUsesHostPageTables = pageableMemoryAccessUsesHostPageTables - {{endif}} - {{if 'cudaDeviceProp.directManagedMemAccessFromHost' in found_struct}} + + @property def directManagedMemAccessFromHost(self): return self._pvt_ptr[0].directManagedMemAccessFromHost @directManagedMemAccessFromHost.setter def directManagedMemAccessFromHost(self, int directManagedMemAccessFromHost): self._pvt_ptr[0].directManagedMemAccessFromHost = directManagedMemAccessFromHost - {{endif}} - {{if 'cudaDeviceProp.maxBlocksPerMultiProcessor' in found_struct}} + + @property def maxBlocksPerMultiProcessor(self): return self._pvt_ptr[0].maxBlocksPerMultiProcessor @maxBlocksPerMultiProcessor.setter def maxBlocksPerMultiProcessor(self, int maxBlocksPerMultiProcessor): self._pvt_ptr[0].maxBlocksPerMultiProcessor = maxBlocksPerMultiProcessor - {{endif}} - {{if 'cudaDeviceProp.accessPolicyMaxWindowSize' in found_struct}} + + @property def accessPolicyMaxWindowSize(self): return self._pvt_ptr[0].accessPolicyMaxWindowSize @accessPolicyMaxWindowSize.setter def accessPolicyMaxWindowSize(self, int accessPolicyMaxWindowSize): self._pvt_ptr[0].accessPolicyMaxWindowSize = accessPolicyMaxWindowSize - {{endif}} - {{if 'cudaDeviceProp.reservedSharedMemPerBlock' in found_struct}} + + @property def reservedSharedMemPerBlock(self): return self._pvt_ptr[0].reservedSharedMemPerBlock @reservedSharedMemPerBlock.setter def reservedSharedMemPerBlock(self, size_t reservedSharedMemPerBlock): self._pvt_ptr[0].reservedSharedMemPerBlock = reservedSharedMemPerBlock - {{endif}} - {{if 'cudaDeviceProp.hostRegisterSupported' in found_struct}} + + @property def hostRegisterSupported(self): return self._pvt_ptr[0].hostRegisterSupported @hostRegisterSupported.setter def hostRegisterSupported(self, int hostRegisterSupported): self._pvt_ptr[0].hostRegisterSupported = hostRegisterSupported - {{endif}} - {{if 'cudaDeviceProp.sparseCudaArraySupported' in found_struct}} + + @property def sparseCudaArraySupported(self): return self._pvt_ptr[0].sparseCudaArraySupported @sparseCudaArraySupported.setter def sparseCudaArraySupported(self, int sparseCudaArraySupported): self._pvt_ptr[0].sparseCudaArraySupported = sparseCudaArraySupported - {{endif}} - {{if 'cudaDeviceProp.hostRegisterReadOnlySupported' in found_struct}} + + @property def hostRegisterReadOnlySupported(self): return self._pvt_ptr[0].hostRegisterReadOnlySupported @hostRegisterReadOnlySupported.setter def hostRegisterReadOnlySupported(self, int hostRegisterReadOnlySupported): self._pvt_ptr[0].hostRegisterReadOnlySupported = hostRegisterReadOnlySupported - {{endif}} - {{if 'cudaDeviceProp.timelineSemaphoreInteropSupported' in found_struct}} + + @property def timelineSemaphoreInteropSupported(self): return self._pvt_ptr[0].timelineSemaphoreInteropSupported @timelineSemaphoreInteropSupported.setter def timelineSemaphoreInteropSupported(self, int timelineSemaphoreInteropSupported): self._pvt_ptr[0].timelineSemaphoreInteropSupported = timelineSemaphoreInteropSupported - {{endif}} - {{if 'cudaDeviceProp.memoryPoolsSupported' in found_struct}} + + @property def memoryPoolsSupported(self): return self._pvt_ptr[0].memoryPoolsSupported @memoryPoolsSupported.setter def memoryPoolsSupported(self, int memoryPoolsSupported): self._pvt_ptr[0].memoryPoolsSupported = memoryPoolsSupported - {{endif}} - {{if 'cudaDeviceProp.gpuDirectRDMASupported' in found_struct}} + + @property def gpuDirectRDMASupported(self): return self._pvt_ptr[0].gpuDirectRDMASupported @gpuDirectRDMASupported.setter def gpuDirectRDMASupported(self, int gpuDirectRDMASupported): self._pvt_ptr[0].gpuDirectRDMASupported = gpuDirectRDMASupported - {{endif}} - {{if 'cudaDeviceProp.gpuDirectRDMAFlushWritesOptions' in found_struct}} + + @property def gpuDirectRDMAFlushWritesOptions(self): return self._pvt_ptr[0].gpuDirectRDMAFlushWritesOptions @gpuDirectRDMAFlushWritesOptions.setter def gpuDirectRDMAFlushWritesOptions(self, unsigned int gpuDirectRDMAFlushWritesOptions): self._pvt_ptr[0].gpuDirectRDMAFlushWritesOptions = gpuDirectRDMAFlushWritesOptions - {{endif}} - {{if 'cudaDeviceProp.gpuDirectRDMAWritesOrdering' in found_struct}} + + @property def gpuDirectRDMAWritesOrdering(self): return self._pvt_ptr[0].gpuDirectRDMAWritesOrdering @gpuDirectRDMAWritesOrdering.setter def gpuDirectRDMAWritesOrdering(self, int gpuDirectRDMAWritesOrdering): self._pvt_ptr[0].gpuDirectRDMAWritesOrdering = gpuDirectRDMAWritesOrdering - {{endif}} - {{if 'cudaDeviceProp.memoryPoolSupportedHandleTypes' in found_struct}} + + @property def memoryPoolSupportedHandleTypes(self): return self._pvt_ptr[0].memoryPoolSupportedHandleTypes @memoryPoolSupportedHandleTypes.setter def memoryPoolSupportedHandleTypes(self, unsigned int memoryPoolSupportedHandleTypes): self._pvt_ptr[0].memoryPoolSupportedHandleTypes = memoryPoolSupportedHandleTypes - {{endif}} - {{if 'cudaDeviceProp.deferredMappingCudaArraySupported' in found_struct}} + + @property def deferredMappingCudaArraySupported(self): return self._pvt_ptr[0].deferredMappingCudaArraySupported @deferredMappingCudaArraySupported.setter def deferredMappingCudaArraySupported(self, int deferredMappingCudaArraySupported): self._pvt_ptr[0].deferredMappingCudaArraySupported = deferredMappingCudaArraySupported - {{endif}} - {{if 'cudaDeviceProp.ipcEventSupported' in found_struct}} + + @property def ipcEventSupported(self): return self._pvt_ptr[0].ipcEventSupported @ipcEventSupported.setter def ipcEventSupported(self, int ipcEventSupported): self._pvt_ptr[0].ipcEventSupported = ipcEventSupported - {{endif}} - {{if 'cudaDeviceProp.clusterLaunch' in found_struct}} + + @property def clusterLaunch(self): return self._pvt_ptr[0].clusterLaunch @clusterLaunch.setter def clusterLaunch(self, int clusterLaunch): self._pvt_ptr[0].clusterLaunch = clusterLaunch - {{endif}} - {{if 'cudaDeviceProp.unifiedFunctionPointers' in found_struct}} + + @property def unifiedFunctionPointers(self): return self._pvt_ptr[0].unifiedFunctionPointers @unifiedFunctionPointers.setter def unifiedFunctionPointers(self, int unifiedFunctionPointers): self._pvt_ptr[0].unifiedFunctionPointers = unifiedFunctionPointers - {{endif}} - {{if 'cudaDeviceProp.deviceNumaConfig' in found_struct}} + + @property def deviceNumaConfig(self): return self._pvt_ptr[0].deviceNumaConfig @deviceNumaConfig.setter def deviceNumaConfig(self, int deviceNumaConfig): self._pvt_ptr[0].deviceNumaConfig = deviceNumaConfig - {{endif}} - {{if 'cudaDeviceProp.deviceNumaId' in found_struct}} + + @property def deviceNumaId(self): return self._pvt_ptr[0].deviceNumaId @deviceNumaId.setter def deviceNumaId(self, int deviceNumaId): self._pvt_ptr[0].deviceNumaId = deviceNumaId - {{endif}} - {{if 'cudaDeviceProp.mpsEnabled' in found_struct}} + + @property def mpsEnabled(self): return self._pvt_ptr[0].mpsEnabled @mpsEnabled.setter def mpsEnabled(self, int mpsEnabled): self._pvt_ptr[0].mpsEnabled = mpsEnabled - {{endif}} - {{if 'cudaDeviceProp.hostNumaId' in found_struct}} + + @property def hostNumaId(self): return self._pvt_ptr[0].hostNumaId @hostNumaId.setter def hostNumaId(self, int hostNumaId): self._pvt_ptr[0].hostNumaId = hostNumaId - {{endif}} - {{if 'cudaDeviceProp.gpuPciDeviceID' in found_struct}} + + @property def gpuPciDeviceID(self): return self._pvt_ptr[0].gpuPciDeviceID @gpuPciDeviceID.setter def gpuPciDeviceID(self, unsigned int gpuPciDeviceID): self._pvt_ptr[0].gpuPciDeviceID = gpuPciDeviceID - {{endif}} - {{if 'cudaDeviceProp.gpuPciSubsystemID' in found_struct}} + + @property def gpuPciSubsystemID(self): return self._pvt_ptr[0].gpuPciSubsystemID @gpuPciSubsystemID.setter def gpuPciSubsystemID(self, unsigned int gpuPciSubsystemID): self._pvt_ptr[0].gpuPciSubsystemID = gpuPciSubsystemID - {{endif}} - {{if 'cudaDeviceProp.hostNumaMultinodeIpcSupported' in found_struct}} + + @property def hostNumaMultinodeIpcSupported(self): return self._pvt_ptr[0].hostNumaMultinodeIpcSupported @hostNumaMultinodeIpcSupported.setter def hostNumaMultinodeIpcSupported(self, int hostNumaMultinodeIpcSupported): self._pvt_ptr[0].hostNumaMultinodeIpcSupported = hostNumaMultinodeIpcSupported - {{endif}} - {{if 'cudaDeviceProp.reserved' in found_struct}} + + @property def reserved(self): return self._pvt_ptr[0].reserved @reserved.setter def reserved(self, reserved): self._pvt_ptr[0].reserved = reserved - {{endif}} -{{endif}} -{{if 'cudaIpcEventHandle_st' in found_struct}} + cdef class cudaIpcEventHandle_st: """ @@ -14453,10 +14013,10 @@ cdef class cudaIpcEventHandle_st: Attributes ---------- - {{if 'cudaIpcEventHandle_st.reserved' in found_struct}} + reserved : bytes - {{endif}} + Methods ------- @@ -14477,16 +14037,16 @@ cdef class cudaIpcEventHandle_st: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaIpcEventHandle_st.reserved' in found_struct}} + try: str_list += ['reserved : ' + str(self.reserved)] except ValueError: str_list += ['reserved : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaIpcEventHandle_st.reserved' in found_struct}} + @property def reserved(self): return PyBytes_FromStringAndSize(self._pvt_ptr[0].reserved, 64) @@ -14504,9 +14064,7 @@ cdef class cudaIpcEventHandle_st: if b > 127 and b < 256: b = b - 256 self._pvt_ptr[0].reserved[i] = b - {{endif}} -{{endif}} -{{if 'cudaIpcMemHandle_st' in found_struct}} + cdef class cudaIpcMemHandle_st: """ @@ -14514,10 +14072,10 @@ cdef class cudaIpcMemHandle_st: Attributes ---------- - {{if 'cudaIpcMemHandle_st.reserved' in found_struct}} + reserved : bytes - {{endif}} + Methods ------- @@ -14538,16 +14096,16 @@ cdef class cudaIpcMemHandle_st: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaIpcMemHandle_st.reserved' in found_struct}} + try: str_list += ['reserved : ' + str(self.reserved)] except ValueError: str_list += ['reserved : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaIpcMemHandle_st.reserved' in found_struct}} + @property def reserved(self): return PyBytes_FromStringAndSize(self._pvt_ptr[0].reserved, 64) @@ -14565,18 +14123,16 @@ cdef class cudaIpcMemHandle_st: if b > 127 and b < 256: b = b - 256 self._pvt_ptr[0].reserved[i] = b - {{endif}} -{{endif}} -{{if 'cudaMemFabricHandle_st' in found_struct}} + cdef class cudaMemFabricHandle_st: """ Attributes ---------- - {{if 'cudaMemFabricHandle_st.reserved' in found_struct}} + reserved : bytes - {{endif}} + Methods ------- @@ -14597,16 +14153,16 @@ cdef class cudaMemFabricHandle_st: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaMemFabricHandle_st.reserved' in found_struct}} + try: str_list += ['reserved : ' + str(self.reserved)] except ValueError: str_list += ['reserved : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaMemFabricHandle_st.reserved' in found_struct}} + @property def reserved(self): return PyBytes_FromStringAndSize(self._pvt_ptr[0].reserved, 64) @@ -14624,22 +14180,20 @@ cdef class cudaMemFabricHandle_st: if b > 127 and b < 256: b = b - 256 self._pvt_ptr[0].reserved[i] = b - {{endif}} -{{endif}} -{{if 'cudaExternalMemoryHandleDesc.handle.win32' in found_struct}} + cdef class anon_struct8: """ Attributes ---------- - {{if 'cudaExternalMemoryHandleDesc.handle.win32.handle' in found_struct}} + handle : Any - {{endif}} - {{if 'cudaExternalMemoryHandleDesc.handle.win32.name' in found_struct}} + + name : Any - {{endif}} + Methods ------- @@ -14658,22 +14212,22 @@ cdef class anon_struct8: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaExternalMemoryHandleDesc.handle.win32.handle' in found_struct}} + try: str_list += ['handle : ' + hex(self.handle)] except ValueError: str_list += ['handle : '] - {{endif}} - {{if 'cudaExternalMemoryHandleDesc.handle.win32.name' in found_struct}} + + try: str_list += ['name : ' + hex(self.name)] except ValueError: str_list += ['name : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaExternalMemoryHandleDesc.handle.win32.handle' in found_struct}} + @property def handle(self): return self._pvt_ptr[0].handle.win32.handle @@ -14681,8 +14235,8 @@ cdef class anon_struct8: def handle(self, handle): self._cyhandle = _HelperInputVoidPtr(handle) self._pvt_ptr[0].handle.win32.handle = self._cyhandle.cptr - {{endif}} - {{if 'cudaExternalMemoryHandleDesc.handle.win32.name' in found_struct}} + + @property def name(self): return self._pvt_ptr[0].handle.win32.name @@ -14690,26 +14244,24 @@ cdef class anon_struct8: def name(self, name): self._cyname = _HelperInputVoidPtr(name) self._pvt_ptr[0].handle.win32.name = self._cyname.cptr - {{endif}} -{{endif}} -{{if 'cudaExternalMemoryHandleDesc.handle' in found_struct}} + cdef class anon_union3: """ Attributes ---------- - {{if 'cudaExternalMemoryHandleDesc.handle.fd' in found_struct}} + fd : int - {{endif}} - {{if 'cudaExternalMemoryHandleDesc.handle.win32' in found_struct}} + + win32 : anon_struct8 - {{endif}} - {{if 'cudaExternalMemoryHandleDesc.handle.nvSciBufObject' in found_struct}} + + nvSciBufObject : Any - {{endif}} + Methods ------- @@ -14721,9 +14273,9 @@ cdef class anon_union3: def __init__(self, void_ptr _ptr): pass - {{if 'cudaExternalMemoryHandleDesc.handle.win32' in found_struct}} + self._win32 = anon_struct8(_ptr=self._pvt_ptr) - {{endif}} + def __dealloc__(self): pass def getPtr(self): @@ -14731,44 +14283,44 @@ cdef class anon_union3: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaExternalMemoryHandleDesc.handle.fd' in found_struct}} + try: str_list += ['fd : ' + str(self.fd)] except ValueError: str_list += ['fd : '] - {{endif}} - {{if 'cudaExternalMemoryHandleDesc.handle.win32' in found_struct}} + + try: str_list += ['win32 :\n' + '\n'.join([' ' + line for line in str(self.win32).splitlines()])] except ValueError: str_list += ['win32 : '] - {{endif}} - {{if 'cudaExternalMemoryHandleDesc.handle.nvSciBufObject' in found_struct}} + + try: str_list += ['nvSciBufObject : ' + hex(self.nvSciBufObject)] except ValueError: str_list += ['nvSciBufObject : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaExternalMemoryHandleDesc.handle.fd' in found_struct}} + @property def fd(self): return self._pvt_ptr[0].handle.fd @fd.setter def fd(self, int fd): self._pvt_ptr[0].handle.fd = fd - {{endif}} - {{if 'cudaExternalMemoryHandleDesc.handle.win32' in found_struct}} + + @property def win32(self): return self._win32 @win32.setter def win32(self, win32 not None : anon_struct8): string.memcpy(&self._pvt_ptr[0].handle.win32, win32.getPtr(), sizeof(self._pvt_ptr[0].handle.win32)) - {{endif}} - {{if 'cudaExternalMemoryHandleDesc.handle.nvSciBufObject' in found_struct}} + + @property def nvSciBufObject(self): return self._pvt_ptr[0].handle.nvSciBufObject @@ -14776,9 +14328,7 @@ cdef class anon_union3: def nvSciBufObject(self, nvSciBufObject): self._cynvSciBufObject = _HelperInputVoidPtr(nvSciBufObject) self._pvt_ptr[0].handle.nvSciBufObject = self._cynvSciBufObject.cptr - {{endif}} -{{endif}} -{{if 'cudaExternalMemoryHandleDesc' in found_struct}} + cdef class cudaExternalMemoryHandleDesc: """ @@ -14786,26 +14336,26 @@ cdef class cudaExternalMemoryHandleDesc: Attributes ---------- - {{if 'cudaExternalMemoryHandleDesc.type' in found_struct}} + type : cudaExternalMemoryHandleType Type of the handle - {{endif}} - {{if 'cudaExternalMemoryHandleDesc.handle' in found_struct}} + + handle : anon_union3 - {{endif}} - {{if 'cudaExternalMemoryHandleDesc.size' in found_struct}} + + size : unsigned long long Size of the memory allocation - {{endif}} - {{if 'cudaExternalMemoryHandleDesc.flags' in found_struct}} + + flags : unsigned int Flags must either be zero or cudaExternalMemoryDedicated - {{endif}} - {{if 'cudaExternalMemoryHandleDesc.reserved' in found_struct}} + + reserved : list[unsigned int] Must be zero - {{endif}} + Methods ------- @@ -14820,9 +14370,9 @@ cdef class cudaExternalMemoryHandleDesc: self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass - {{if 'cudaExternalMemoryHandleDesc.handle' in found_struct}} + self._handle = anon_union3(_ptr=self._pvt_ptr) - {{endif}} + def __dealloc__(self): if self._val_ptr is not NULL: free(self._val_ptr) @@ -14831,81 +14381,79 @@ cdef class cudaExternalMemoryHandleDesc: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaExternalMemoryHandleDesc.type' in found_struct}} + try: str_list += ['type : ' + str(self.type)] except ValueError: str_list += ['type : '] - {{endif}} - {{if 'cudaExternalMemoryHandleDesc.handle' in found_struct}} + + try: str_list += ['handle :\n' + '\n'.join([' ' + line for line in str(self.handle).splitlines()])] except ValueError: str_list += ['handle : '] - {{endif}} - {{if 'cudaExternalMemoryHandleDesc.size' in found_struct}} + + try: str_list += ['size : ' + str(self.size)] except ValueError: str_list += ['size : '] - {{endif}} - {{if 'cudaExternalMemoryHandleDesc.flags' in found_struct}} + + try: str_list += ['flags : ' + str(self.flags)] except ValueError: str_list += ['flags : '] - {{endif}} - {{if 'cudaExternalMemoryHandleDesc.reserved' in found_struct}} + + try: str_list += ['reserved : ' + str(self.reserved)] except ValueError: str_list += ['reserved : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaExternalMemoryHandleDesc.type' in found_struct}} + @property def type(self): return cudaExternalMemoryHandleType(self._pvt_ptr[0].type) @type.setter def type(self, type not None : cudaExternalMemoryHandleType): - self._pvt_ptr[0].type = int(type) - {{endif}} - {{if 'cudaExternalMemoryHandleDesc.handle' in found_struct}} + self._pvt_ptr[0].type = int(type) + + @property def handle(self): return self._handle @handle.setter def handle(self, handle not None : anon_union3): string.memcpy(&self._pvt_ptr[0].handle, handle.getPtr(), sizeof(self._pvt_ptr[0].handle)) - {{endif}} - {{if 'cudaExternalMemoryHandleDesc.size' in found_struct}} + + @property def size(self): return self._pvt_ptr[0].size @size.setter def size(self, unsigned long long size): self._pvt_ptr[0].size = size - {{endif}} - {{if 'cudaExternalMemoryHandleDesc.flags' in found_struct}} + + @property def flags(self): return self._pvt_ptr[0].flags @flags.setter def flags(self, unsigned int flags): self._pvt_ptr[0].flags = flags - {{endif}} - {{if 'cudaExternalMemoryHandleDesc.reserved' in found_struct}} + + @property def reserved(self): return self._pvt_ptr[0].reserved @reserved.setter def reserved(self, reserved): self._pvt_ptr[0].reserved = reserved - {{endif}} -{{endif}} -{{if 'cudaExternalMemoryBufferDesc' in found_struct}} + cdef class cudaExternalMemoryBufferDesc: """ @@ -14913,22 +14461,22 @@ cdef class cudaExternalMemoryBufferDesc: Attributes ---------- - {{if 'cudaExternalMemoryBufferDesc.offset' in found_struct}} + offset : unsigned long long Offset into the memory object where the buffer's base is - {{endif}} - {{if 'cudaExternalMemoryBufferDesc.size' in found_struct}} + + size : unsigned long long Size of the buffer - {{endif}} - {{if 'cudaExternalMemoryBufferDesc.flags' in found_struct}} + + flags : unsigned int Flags reserved for future use. Must be zero. - {{endif}} - {{if 'cudaExternalMemoryBufferDesc.reserved' in found_struct}} + + reserved : list[unsigned int] Must be zero - {{endif}} + Methods ------- @@ -14949,67 +14497,65 @@ cdef class cudaExternalMemoryBufferDesc: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaExternalMemoryBufferDesc.offset' in found_struct}} + try: str_list += ['offset : ' + str(self.offset)] except ValueError: str_list += ['offset : '] - {{endif}} - {{if 'cudaExternalMemoryBufferDesc.size' in found_struct}} + + try: str_list += ['size : ' + str(self.size)] except ValueError: str_list += ['size : '] - {{endif}} - {{if 'cudaExternalMemoryBufferDesc.flags' in found_struct}} + + try: str_list += ['flags : ' + str(self.flags)] except ValueError: str_list += ['flags : '] - {{endif}} - {{if 'cudaExternalMemoryBufferDesc.reserved' in found_struct}} + + try: str_list += ['reserved : ' + str(self.reserved)] except ValueError: str_list += ['reserved : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaExternalMemoryBufferDesc.offset' in found_struct}} + @property def offset(self): return self._pvt_ptr[0].offset @offset.setter def offset(self, unsigned long long offset): self._pvt_ptr[0].offset = offset - {{endif}} - {{if 'cudaExternalMemoryBufferDesc.size' in found_struct}} + + @property def size(self): return self._pvt_ptr[0].size @size.setter def size(self, unsigned long long size): self._pvt_ptr[0].size = size - {{endif}} - {{if 'cudaExternalMemoryBufferDesc.flags' in found_struct}} + + @property def flags(self): return self._pvt_ptr[0].flags @flags.setter def flags(self, unsigned int flags): self._pvt_ptr[0].flags = flags - {{endif}} - {{if 'cudaExternalMemoryBufferDesc.reserved' in found_struct}} + + @property def reserved(self): return self._pvt_ptr[0].reserved @reserved.setter def reserved(self, reserved): self._pvt_ptr[0].reserved = reserved - {{endif}} -{{endif}} -{{if 'cudaExternalMemoryMipmappedArrayDesc' in found_struct}} + cdef class cudaExternalMemoryMipmappedArrayDesc: """ @@ -15017,32 +14563,32 @@ cdef class cudaExternalMemoryMipmappedArrayDesc: Attributes ---------- - {{if 'cudaExternalMemoryMipmappedArrayDesc.offset' in found_struct}} + offset : unsigned long long Offset into the memory object where the base level of the mipmap chain is. - {{endif}} - {{if 'cudaExternalMemoryMipmappedArrayDesc.formatDesc' in found_struct}} + + formatDesc : cudaChannelFormatDesc Format of base level of the mipmap chain - {{endif}} - {{if 'cudaExternalMemoryMipmappedArrayDesc.extent' in found_struct}} + + extent : cudaExtent Dimensions of base level of the mipmap chain - {{endif}} - {{if 'cudaExternalMemoryMipmappedArrayDesc.flags' in found_struct}} + + flags : unsigned int Flags associated with CUDA mipmapped arrays. See cudaMallocMipmappedArray - {{endif}} - {{if 'cudaExternalMemoryMipmappedArrayDesc.numLevels' in found_struct}} + + numLevels : unsigned int Total number of levels in the mipmap chain - {{endif}} - {{if 'cudaExternalMemoryMipmappedArrayDesc.reserved' in found_struct}} + + reserved : list[unsigned int] Must be zero - {{endif}} + Methods ------- @@ -15056,12 +14602,12 @@ cdef class cudaExternalMemoryMipmappedArrayDesc: self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass - {{if 'cudaExternalMemoryMipmappedArrayDesc.formatDesc' in found_struct}} + self._formatDesc = cudaChannelFormatDesc(_ptr=&self._pvt_ptr[0].formatDesc) - {{endif}} - {{if 'cudaExternalMemoryMipmappedArrayDesc.extent' in found_struct}} + + self._extent = cudaExtent(_ptr=&self._pvt_ptr[0].extent) - {{endif}} + def __dealloc__(self): pass def getPtr(self): @@ -15069,108 +14615,106 @@ cdef class cudaExternalMemoryMipmappedArrayDesc: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaExternalMemoryMipmappedArrayDesc.offset' in found_struct}} + try: str_list += ['offset : ' + str(self.offset)] except ValueError: str_list += ['offset : '] - {{endif}} - {{if 'cudaExternalMemoryMipmappedArrayDesc.formatDesc' in found_struct}} + + try: str_list += ['formatDesc :\n' + '\n'.join([' ' + line for line in str(self.formatDesc).splitlines()])] except ValueError: str_list += ['formatDesc : '] - {{endif}} - {{if 'cudaExternalMemoryMipmappedArrayDesc.extent' in found_struct}} + + try: str_list += ['extent :\n' + '\n'.join([' ' + line for line in str(self.extent).splitlines()])] except ValueError: str_list += ['extent : '] - {{endif}} - {{if 'cudaExternalMemoryMipmappedArrayDesc.flags' in found_struct}} + + try: str_list += ['flags : ' + str(self.flags)] except ValueError: str_list += ['flags : '] - {{endif}} - {{if 'cudaExternalMemoryMipmappedArrayDesc.numLevels' in found_struct}} + + try: str_list += ['numLevels : ' + str(self.numLevels)] except ValueError: str_list += ['numLevels : '] - {{endif}} - {{if 'cudaExternalMemoryMipmappedArrayDesc.reserved' in found_struct}} + + try: str_list += ['reserved : ' + str(self.reserved)] except ValueError: str_list += ['reserved : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaExternalMemoryMipmappedArrayDesc.offset' in found_struct}} + @property def offset(self): return self._pvt_ptr[0].offset @offset.setter def offset(self, unsigned long long offset): self._pvt_ptr[0].offset = offset - {{endif}} - {{if 'cudaExternalMemoryMipmappedArrayDesc.formatDesc' in found_struct}} + + @property def formatDesc(self): return self._formatDesc @formatDesc.setter def formatDesc(self, formatDesc not None : cudaChannelFormatDesc): string.memcpy(&self._pvt_ptr[0].formatDesc, formatDesc.getPtr(), sizeof(self._pvt_ptr[0].formatDesc)) - {{endif}} - {{if 'cudaExternalMemoryMipmappedArrayDesc.extent' in found_struct}} + + @property def extent(self): return self._extent @extent.setter def extent(self, extent not None : cudaExtent): string.memcpy(&self._pvt_ptr[0].extent, extent.getPtr(), sizeof(self._pvt_ptr[0].extent)) - {{endif}} - {{if 'cudaExternalMemoryMipmappedArrayDesc.flags' in found_struct}} + + @property def flags(self): return self._pvt_ptr[0].flags @flags.setter def flags(self, unsigned int flags): self._pvt_ptr[0].flags = flags - {{endif}} - {{if 'cudaExternalMemoryMipmappedArrayDesc.numLevels' in found_struct}} + + @property def numLevels(self): return self._pvt_ptr[0].numLevels @numLevels.setter def numLevels(self, unsigned int numLevels): self._pvt_ptr[0].numLevels = numLevels - {{endif}} - {{if 'cudaExternalMemoryMipmappedArrayDesc.reserved' in found_struct}} + + @property def reserved(self): return self._pvt_ptr[0].reserved @reserved.setter def reserved(self, reserved): self._pvt_ptr[0].reserved = reserved - {{endif}} -{{endif}} -{{if 'cudaExternalSemaphoreHandleDesc.handle.win32' in found_struct}} + cdef class anon_struct9: """ Attributes ---------- - {{if 'cudaExternalSemaphoreHandleDesc.handle.win32.handle' in found_struct}} + handle : Any - {{endif}} - {{if 'cudaExternalSemaphoreHandleDesc.handle.win32.name' in found_struct}} + + name : Any - {{endif}} + Methods ------- @@ -15189,22 +14733,22 @@ cdef class anon_struct9: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaExternalSemaphoreHandleDesc.handle.win32.handle' in found_struct}} + try: str_list += ['handle : ' + hex(self.handle)] except ValueError: str_list += ['handle : '] - {{endif}} - {{if 'cudaExternalSemaphoreHandleDesc.handle.win32.name' in found_struct}} + + try: str_list += ['name : ' + hex(self.name)] except ValueError: str_list += ['name : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaExternalSemaphoreHandleDesc.handle.win32.handle' in found_struct}} + @property def handle(self): return self._pvt_ptr[0].handle.win32.handle @@ -15212,8 +14756,8 @@ cdef class anon_struct9: def handle(self, handle): self._cyhandle = _HelperInputVoidPtr(handle) self._pvt_ptr[0].handle.win32.handle = self._cyhandle.cptr - {{endif}} - {{if 'cudaExternalSemaphoreHandleDesc.handle.win32.name' in found_struct}} + + @property def name(self): return self._pvt_ptr[0].handle.win32.name @@ -15221,26 +14765,24 @@ cdef class anon_struct9: def name(self, name): self._cyname = _HelperInputVoidPtr(name) self._pvt_ptr[0].handle.win32.name = self._cyname.cptr - {{endif}} -{{endif}} -{{if 'cudaExternalSemaphoreHandleDesc.handle' in found_struct}} + cdef class anon_union4: """ Attributes ---------- - {{if 'cudaExternalSemaphoreHandleDesc.handle.fd' in found_struct}} + fd : int - {{endif}} - {{if 'cudaExternalSemaphoreHandleDesc.handle.win32' in found_struct}} + + win32 : anon_struct9 - {{endif}} - {{if 'cudaExternalSemaphoreHandleDesc.handle.nvSciSyncObj' in found_struct}} + + nvSciSyncObj : Any - {{endif}} + Methods ------- @@ -15252,9 +14794,9 @@ cdef class anon_union4: def __init__(self, void_ptr _ptr): pass - {{if 'cudaExternalSemaphoreHandleDesc.handle.win32' in found_struct}} + self._win32 = anon_struct9(_ptr=self._pvt_ptr) - {{endif}} + def __dealloc__(self): pass def getPtr(self): @@ -15262,44 +14804,44 @@ cdef class anon_union4: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaExternalSemaphoreHandleDesc.handle.fd' in found_struct}} + try: str_list += ['fd : ' + str(self.fd)] except ValueError: str_list += ['fd : '] - {{endif}} - {{if 'cudaExternalSemaphoreHandleDesc.handle.win32' in found_struct}} + + try: str_list += ['win32 :\n' + '\n'.join([' ' + line for line in str(self.win32).splitlines()])] except ValueError: str_list += ['win32 : '] - {{endif}} - {{if 'cudaExternalSemaphoreHandleDesc.handle.nvSciSyncObj' in found_struct}} + + try: str_list += ['nvSciSyncObj : ' + hex(self.nvSciSyncObj)] except ValueError: str_list += ['nvSciSyncObj : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaExternalSemaphoreHandleDesc.handle.fd' in found_struct}} + @property def fd(self): return self._pvt_ptr[0].handle.fd @fd.setter def fd(self, int fd): self._pvt_ptr[0].handle.fd = fd - {{endif}} - {{if 'cudaExternalSemaphoreHandleDesc.handle.win32' in found_struct}} + + @property def win32(self): return self._win32 @win32.setter def win32(self, win32 not None : anon_struct9): string.memcpy(&self._pvt_ptr[0].handle.win32, win32.getPtr(), sizeof(self._pvt_ptr[0].handle.win32)) - {{endif}} - {{if 'cudaExternalSemaphoreHandleDesc.handle.nvSciSyncObj' in found_struct}} + + @property def nvSciSyncObj(self): return self._pvt_ptr[0].handle.nvSciSyncObj @@ -15307,9 +14849,7 @@ cdef class anon_union4: def nvSciSyncObj(self, nvSciSyncObj): self._cynvSciSyncObj = _HelperInputVoidPtr(nvSciSyncObj) self._pvt_ptr[0].handle.nvSciSyncObj = self._cynvSciSyncObj.cptr - {{endif}} -{{endif}} -{{if 'cudaExternalSemaphoreHandleDesc' in found_struct}} + cdef class cudaExternalSemaphoreHandleDesc: """ @@ -15317,22 +14857,22 @@ cdef class cudaExternalSemaphoreHandleDesc: Attributes ---------- - {{if 'cudaExternalSemaphoreHandleDesc.type' in found_struct}} + type : cudaExternalSemaphoreHandleType Type of the handle - {{endif}} - {{if 'cudaExternalSemaphoreHandleDesc.handle' in found_struct}} + + handle : anon_union4 - {{endif}} - {{if 'cudaExternalSemaphoreHandleDesc.flags' in found_struct}} + + flags : unsigned int Flags reserved for the future. Must be zero. - {{endif}} - {{if 'cudaExternalSemaphoreHandleDesc.reserved' in found_struct}} + + reserved : list[unsigned int] Must be zero - {{endif}} + Methods ------- @@ -15347,9 +14887,9 @@ cdef class cudaExternalSemaphoreHandleDesc: self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass - {{if 'cudaExternalSemaphoreHandleDesc.handle' in found_struct}} + self._handle = anon_union4(_ptr=self._pvt_ptr) - {{endif}} + def __dealloc__(self): if self._val_ptr is not NULL: free(self._val_ptr) @@ -15358,76 +14898,74 @@ cdef class cudaExternalSemaphoreHandleDesc: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaExternalSemaphoreHandleDesc.type' in found_struct}} + try: str_list += ['type : ' + str(self.type)] except ValueError: str_list += ['type : '] - {{endif}} - {{if 'cudaExternalSemaphoreHandleDesc.handle' in found_struct}} + + try: str_list += ['handle :\n' + '\n'.join([' ' + line for line in str(self.handle).splitlines()])] except ValueError: str_list += ['handle : '] - {{endif}} - {{if 'cudaExternalSemaphoreHandleDesc.flags' in found_struct}} + + try: str_list += ['flags : ' + str(self.flags)] except ValueError: str_list += ['flags : '] - {{endif}} - {{if 'cudaExternalSemaphoreHandleDesc.reserved' in found_struct}} + + try: str_list += ['reserved : ' + str(self.reserved)] except ValueError: str_list += ['reserved : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaExternalSemaphoreHandleDesc.type' in found_struct}} + @property def type(self): return cudaExternalSemaphoreHandleType(self._pvt_ptr[0].type) @type.setter def type(self, type not None : cudaExternalSemaphoreHandleType): - self._pvt_ptr[0].type = int(type) - {{endif}} - {{if 'cudaExternalSemaphoreHandleDesc.handle' in found_struct}} + self._pvt_ptr[0].type = int(type) + + @property def handle(self): return self._handle @handle.setter def handle(self, handle not None : anon_union4): string.memcpy(&self._pvt_ptr[0].handle, handle.getPtr(), sizeof(self._pvt_ptr[0].handle)) - {{endif}} - {{if 'cudaExternalSemaphoreHandleDesc.flags' in found_struct}} + + @property def flags(self): return self._pvt_ptr[0].flags @flags.setter def flags(self, unsigned int flags): self._pvt_ptr[0].flags = flags - {{endif}} - {{if 'cudaExternalSemaphoreHandleDesc.reserved' in found_struct}} + + @property def reserved(self): return self._pvt_ptr[0].reserved @reserved.setter def reserved(self, reserved): self._pvt_ptr[0].reserved = reserved - {{endif}} -{{endif}} -{{if 'cudaExternalSemaphoreSignalParams.params.fence' in found_struct}} + cdef class anon_struct10: """ Attributes ---------- - {{if 'cudaExternalSemaphoreSignalParams.params.fence.value' in found_struct}} + value : unsigned long long - {{endif}} + Methods ------- @@ -15446,38 +14984,36 @@ cdef class anon_struct10: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaExternalSemaphoreSignalParams.params.fence.value' in found_struct}} + try: str_list += ['value : ' + str(self.value)] except ValueError: str_list += ['value : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaExternalSemaphoreSignalParams.params.fence.value' in found_struct}} + @property def value(self): return self._pvt_ptr[0].params.fence.value @value.setter def value(self, unsigned long long value): self._pvt_ptr[0].params.fence.value = value - {{endif}} -{{endif}} -{{if 'cudaExternalSemaphoreSignalParams.params.nvSciSync' in found_struct}} + cdef class anon_union5: """ Attributes ---------- - {{if 'cudaExternalSemaphoreSignalParams.params.nvSciSync.fence' in found_struct}} + fence : Any - {{endif}} - {{if 'cudaExternalSemaphoreSignalParams.params.nvSciSync.reserved' in found_struct}} + + reserved : unsigned long long - {{endif}} + Methods ------- @@ -15496,22 +15032,22 @@ cdef class anon_union5: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaExternalSemaphoreSignalParams.params.nvSciSync.fence' in found_struct}} + try: str_list += ['fence : ' + hex(self.fence)] except ValueError: str_list += ['fence : '] - {{endif}} - {{if 'cudaExternalSemaphoreSignalParams.params.nvSciSync.reserved' in found_struct}} + + try: str_list += ['reserved : ' + str(self.reserved)] except ValueError: str_list += ['reserved : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaExternalSemaphoreSignalParams.params.nvSciSync.fence' in found_struct}} + @property def fence(self): return self._pvt_ptr[0].params.nvSciSync.fence @@ -15519,26 +15055,24 @@ cdef class anon_union5: def fence(self, fence): self._cyfence = _HelperInputVoidPtr(fence) self._pvt_ptr[0].params.nvSciSync.fence = self._cyfence.cptr - {{endif}} - {{if 'cudaExternalSemaphoreSignalParams.params.nvSciSync.reserved' in found_struct}} + + @property def reserved(self): return self._pvt_ptr[0].params.nvSciSync.reserved @reserved.setter def reserved(self, unsigned long long reserved): self._pvt_ptr[0].params.nvSciSync.reserved = reserved - {{endif}} -{{endif}} -{{if 'cudaExternalSemaphoreSignalParams.params.keyedMutex' in found_struct}} + cdef class anon_struct11: """ Attributes ---------- - {{if 'cudaExternalSemaphoreSignalParams.params.keyedMutex.key' in found_struct}} + key : unsigned long long - {{endif}} + Methods ------- @@ -15557,46 +15091,44 @@ cdef class anon_struct11: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaExternalSemaphoreSignalParams.params.keyedMutex.key' in found_struct}} + try: str_list += ['key : ' + str(self.key)] except ValueError: str_list += ['key : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaExternalSemaphoreSignalParams.params.keyedMutex.key' in found_struct}} + @property def key(self): return self._pvt_ptr[0].params.keyedMutex.key @key.setter def key(self, unsigned long long key): self._pvt_ptr[0].params.keyedMutex.key = key - {{endif}} -{{endif}} -{{if 'cudaExternalSemaphoreSignalParams.params' in found_struct}} + cdef class anon_struct12: """ Attributes ---------- - {{if 'cudaExternalSemaphoreSignalParams.params.fence' in found_struct}} + fence : anon_struct10 - {{endif}} - {{if 'cudaExternalSemaphoreSignalParams.params.nvSciSync' in found_struct}} + + nvSciSync : anon_union5 - {{endif}} - {{if 'cudaExternalSemaphoreSignalParams.params.keyedMutex' in found_struct}} + + keyedMutex : anon_struct11 - {{endif}} - {{if 'cudaExternalSemaphoreSignalParams.params.reserved' in found_struct}} + + reserved : list[unsigned int] - {{endif}} + Methods ------- @@ -15608,15 +15140,15 @@ cdef class anon_struct12: def __init__(self, void_ptr _ptr): pass - {{if 'cudaExternalSemaphoreSignalParams.params.fence' in found_struct}} + self._fence = anon_struct10(_ptr=self._pvt_ptr) - {{endif}} - {{if 'cudaExternalSemaphoreSignalParams.params.nvSciSync' in found_struct}} + + self._nvSciSync = anon_union5(_ptr=self._pvt_ptr) - {{endif}} - {{if 'cudaExternalSemaphoreSignalParams.params.keyedMutex' in found_struct}} + + self._keyedMutex = anon_struct11(_ptr=self._pvt_ptr) - {{endif}} + def __dealloc__(self): pass def getPtr(self): @@ -15624,67 +15156,65 @@ cdef class anon_struct12: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaExternalSemaphoreSignalParams.params.fence' in found_struct}} + try: str_list += ['fence :\n' + '\n'.join([' ' + line for line in str(self.fence).splitlines()])] except ValueError: str_list += ['fence : '] - {{endif}} - {{if 'cudaExternalSemaphoreSignalParams.params.nvSciSync' in found_struct}} + + try: str_list += ['nvSciSync :\n' + '\n'.join([' ' + line for line in str(self.nvSciSync).splitlines()])] except ValueError: str_list += ['nvSciSync : '] - {{endif}} - {{if 'cudaExternalSemaphoreSignalParams.params.keyedMutex' in found_struct}} + + try: str_list += ['keyedMutex :\n' + '\n'.join([' ' + line for line in str(self.keyedMutex).splitlines()])] except ValueError: str_list += ['keyedMutex : '] - {{endif}} - {{if 'cudaExternalSemaphoreSignalParams.params.reserved' in found_struct}} + + try: str_list += ['reserved : ' + str(self.reserved)] except ValueError: str_list += ['reserved : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaExternalSemaphoreSignalParams.params.fence' in found_struct}} + @property def fence(self): return self._fence @fence.setter def fence(self, fence not None : anon_struct10): string.memcpy(&self._pvt_ptr[0].params.fence, fence.getPtr(), sizeof(self._pvt_ptr[0].params.fence)) - {{endif}} - {{if 'cudaExternalSemaphoreSignalParams.params.nvSciSync' in found_struct}} + + @property def nvSciSync(self): return self._nvSciSync @nvSciSync.setter def nvSciSync(self, nvSciSync not None : anon_union5): string.memcpy(&self._pvt_ptr[0].params.nvSciSync, nvSciSync.getPtr(), sizeof(self._pvt_ptr[0].params.nvSciSync)) - {{endif}} - {{if 'cudaExternalSemaphoreSignalParams.params.keyedMutex' in found_struct}} + + @property def keyedMutex(self): return self._keyedMutex @keyedMutex.setter def keyedMutex(self, keyedMutex not None : anon_struct11): string.memcpy(&self._pvt_ptr[0].params.keyedMutex, keyedMutex.getPtr(), sizeof(self._pvt_ptr[0].params.keyedMutex)) - {{endif}} - {{if 'cudaExternalSemaphoreSignalParams.params.reserved' in found_struct}} + + @property def reserved(self): return self._pvt_ptr[0].params.reserved @reserved.setter def reserved(self, reserved): self._pvt_ptr[0].params.reserved = reserved - {{endif}} -{{endif}} -{{if 'cudaExternalSemaphoreSignalParams' in found_struct}} + cdef class cudaExternalSemaphoreSignalParams: """ @@ -15692,11 +15222,11 @@ cdef class cudaExternalSemaphoreSignalParams: Attributes ---------- - {{if 'cudaExternalSemaphoreSignalParams.params' in found_struct}} + params : anon_struct12 - {{endif}} - {{if 'cudaExternalSemaphoreSignalParams.flags' in found_struct}} + + flags : unsigned int Only when cudaExternalSemaphoreSignalParams is used to signal a cudaExternalSemaphore_t of type @@ -15706,11 +15236,11 @@ cdef class cudaExternalSemaphoreSignalParams: synchronization operations should be performed for any external memory object imported as cudaExternalMemoryHandleTypeNvSciBuf. For all other types of cudaExternalSemaphore_t, flags must be zero. - {{endif}} - {{if 'cudaExternalSemaphoreSignalParams.reserved' in found_struct}} + + reserved : list[unsigned int] - {{endif}} + Methods ------- @@ -15724,9 +15254,9 @@ cdef class cudaExternalSemaphoreSignalParams: self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass - {{if 'cudaExternalSemaphoreSignalParams.params' in found_struct}} + self._params = anon_struct12(_ptr=self._pvt_ptr) - {{endif}} + def __dealloc__(self): pass def getPtr(self): @@ -15734,62 +15264,60 @@ cdef class cudaExternalSemaphoreSignalParams: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaExternalSemaphoreSignalParams.params' in found_struct}} + try: str_list += ['params :\n' + '\n'.join([' ' + line for line in str(self.params).splitlines()])] except ValueError: str_list += ['params : '] - {{endif}} - {{if 'cudaExternalSemaphoreSignalParams.flags' in found_struct}} + + try: str_list += ['flags : ' + str(self.flags)] except ValueError: str_list += ['flags : '] - {{endif}} - {{if 'cudaExternalSemaphoreSignalParams.reserved' in found_struct}} + + try: str_list += ['reserved : ' + str(self.reserved)] except ValueError: str_list += ['reserved : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaExternalSemaphoreSignalParams.params' in found_struct}} + @property def params(self): return self._params @params.setter def params(self, params not None : anon_struct12): string.memcpy(&self._pvt_ptr[0].params, params.getPtr(), sizeof(self._pvt_ptr[0].params)) - {{endif}} - {{if 'cudaExternalSemaphoreSignalParams.flags' in found_struct}} + + @property def flags(self): return self._pvt_ptr[0].flags @flags.setter def flags(self, unsigned int flags): self._pvt_ptr[0].flags = flags - {{endif}} - {{if 'cudaExternalSemaphoreSignalParams.reserved' in found_struct}} + + @property def reserved(self): return self._pvt_ptr[0].reserved @reserved.setter def reserved(self, reserved): self._pvt_ptr[0].reserved = reserved - {{endif}} -{{endif}} -{{if 'cudaExternalSemaphoreWaitParams.params.fence' in found_struct}} + cdef class anon_struct13: """ Attributes ---------- - {{if 'cudaExternalSemaphoreWaitParams.params.fence.value' in found_struct}} + value : unsigned long long - {{endif}} + Methods ------- @@ -15808,38 +15336,36 @@ cdef class anon_struct13: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaExternalSemaphoreWaitParams.params.fence.value' in found_struct}} + try: str_list += ['value : ' + str(self.value)] except ValueError: str_list += ['value : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaExternalSemaphoreWaitParams.params.fence.value' in found_struct}} + @property def value(self): return self._pvt_ptr[0].params.fence.value @value.setter def value(self, unsigned long long value): self._pvt_ptr[0].params.fence.value = value - {{endif}} -{{endif}} -{{if 'cudaExternalSemaphoreWaitParams.params.nvSciSync' in found_struct}} + cdef class anon_union6: """ Attributes ---------- - {{if 'cudaExternalSemaphoreWaitParams.params.nvSciSync.fence' in found_struct}} + fence : Any - {{endif}} - {{if 'cudaExternalSemaphoreWaitParams.params.nvSciSync.reserved' in found_struct}} + + reserved : unsigned long long - {{endif}} + Methods ------- @@ -15858,22 +15384,22 @@ cdef class anon_union6: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaExternalSemaphoreWaitParams.params.nvSciSync.fence' in found_struct}} + try: str_list += ['fence : ' + hex(self.fence)] except ValueError: str_list += ['fence : '] - {{endif}} - {{if 'cudaExternalSemaphoreWaitParams.params.nvSciSync.reserved' in found_struct}} + + try: str_list += ['reserved : ' + str(self.reserved)] except ValueError: str_list += ['reserved : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaExternalSemaphoreWaitParams.params.nvSciSync.fence' in found_struct}} + @property def fence(self): return self._pvt_ptr[0].params.nvSciSync.fence @@ -15881,30 +15407,28 @@ cdef class anon_union6: def fence(self, fence): self._cyfence = _HelperInputVoidPtr(fence) self._pvt_ptr[0].params.nvSciSync.fence = self._cyfence.cptr - {{endif}} - {{if 'cudaExternalSemaphoreWaitParams.params.nvSciSync.reserved' in found_struct}} + + @property def reserved(self): return self._pvt_ptr[0].params.nvSciSync.reserved @reserved.setter def reserved(self, unsigned long long reserved): self._pvt_ptr[0].params.nvSciSync.reserved = reserved - {{endif}} -{{endif}} -{{if 'cudaExternalSemaphoreWaitParams.params.keyedMutex' in found_struct}} + cdef class anon_struct14: """ Attributes ---------- - {{if 'cudaExternalSemaphoreWaitParams.params.keyedMutex.key' in found_struct}} + key : unsigned long long - {{endif}} - {{if 'cudaExternalSemaphoreWaitParams.params.keyedMutex.timeoutMs' in found_struct}} + + timeoutMs : unsigned int - {{endif}} + Methods ------- @@ -15923,60 +15447,58 @@ cdef class anon_struct14: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaExternalSemaphoreWaitParams.params.keyedMutex.key' in found_struct}} + try: str_list += ['key : ' + str(self.key)] except ValueError: str_list += ['key : '] - {{endif}} - {{if 'cudaExternalSemaphoreWaitParams.params.keyedMutex.timeoutMs' in found_struct}} + + try: str_list += ['timeoutMs : ' + str(self.timeoutMs)] except ValueError: str_list += ['timeoutMs : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaExternalSemaphoreWaitParams.params.keyedMutex.key' in found_struct}} + @property def key(self): return self._pvt_ptr[0].params.keyedMutex.key @key.setter def key(self, unsigned long long key): self._pvt_ptr[0].params.keyedMutex.key = key - {{endif}} - {{if 'cudaExternalSemaphoreWaitParams.params.keyedMutex.timeoutMs' in found_struct}} + + @property def timeoutMs(self): return self._pvt_ptr[0].params.keyedMutex.timeoutMs @timeoutMs.setter def timeoutMs(self, unsigned int timeoutMs): self._pvt_ptr[0].params.keyedMutex.timeoutMs = timeoutMs - {{endif}} -{{endif}} -{{if 'cudaExternalSemaphoreWaitParams.params' in found_struct}} + cdef class anon_struct15: """ Attributes ---------- - {{if 'cudaExternalSemaphoreWaitParams.params.fence' in found_struct}} + fence : anon_struct13 - {{endif}} - {{if 'cudaExternalSemaphoreWaitParams.params.nvSciSync' in found_struct}} + + nvSciSync : anon_union6 - {{endif}} - {{if 'cudaExternalSemaphoreWaitParams.params.keyedMutex' in found_struct}} + + keyedMutex : anon_struct14 - {{endif}} - {{if 'cudaExternalSemaphoreWaitParams.params.reserved' in found_struct}} + + reserved : list[unsigned int] - {{endif}} + Methods ------- @@ -15988,15 +15510,15 @@ cdef class anon_struct15: def __init__(self, void_ptr _ptr): pass - {{if 'cudaExternalSemaphoreWaitParams.params.fence' in found_struct}} + self._fence = anon_struct13(_ptr=self._pvt_ptr) - {{endif}} - {{if 'cudaExternalSemaphoreWaitParams.params.nvSciSync' in found_struct}} + + self._nvSciSync = anon_union6(_ptr=self._pvt_ptr) - {{endif}} - {{if 'cudaExternalSemaphoreWaitParams.params.keyedMutex' in found_struct}} + + self._keyedMutex = anon_struct14(_ptr=self._pvt_ptr) - {{endif}} + def __dealloc__(self): pass def getPtr(self): @@ -16004,67 +15526,65 @@ cdef class anon_struct15: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaExternalSemaphoreWaitParams.params.fence' in found_struct}} + try: str_list += ['fence :\n' + '\n'.join([' ' + line for line in str(self.fence).splitlines()])] except ValueError: str_list += ['fence : '] - {{endif}} - {{if 'cudaExternalSemaphoreWaitParams.params.nvSciSync' in found_struct}} + + try: str_list += ['nvSciSync :\n' + '\n'.join([' ' + line for line in str(self.nvSciSync).splitlines()])] except ValueError: str_list += ['nvSciSync : '] - {{endif}} - {{if 'cudaExternalSemaphoreWaitParams.params.keyedMutex' in found_struct}} + + try: str_list += ['keyedMutex :\n' + '\n'.join([' ' + line for line in str(self.keyedMutex).splitlines()])] except ValueError: str_list += ['keyedMutex : '] - {{endif}} - {{if 'cudaExternalSemaphoreWaitParams.params.reserved' in found_struct}} + + try: str_list += ['reserved : ' + str(self.reserved)] except ValueError: str_list += ['reserved : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaExternalSemaphoreWaitParams.params.fence' in found_struct}} + @property def fence(self): return self._fence @fence.setter def fence(self, fence not None : anon_struct13): string.memcpy(&self._pvt_ptr[0].params.fence, fence.getPtr(), sizeof(self._pvt_ptr[0].params.fence)) - {{endif}} - {{if 'cudaExternalSemaphoreWaitParams.params.nvSciSync' in found_struct}} + + @property def nvSciSync(self): return self._nvSciSync @nvSciSync.setter def nvSciSync(self, nvSciSync not None : anon_union6): string.memcpy(&self._pvt_ptr[0].params.nvSciSync, nvSciSync.getPtr(), sizeof(self._pvt_ptr[0].params.nvSciSync)) - {{endif}} - {{if 'cudaExternalSemaphoreWaitParams.params.keyedMutex' in found_struct}} + + @property def keyedMutex(self): return self._keyedMutex @keyedMutex.setter def keyedMutex(self, keyedMutex not None : anon_struct14): string.memcpy(&self._pvt_ptr[0].params.keyedMutex, keyedMutex.getPtr(), sizeof(self._pvt_ptr[0].params.keyedMutex)) - {{endif}} - {{if 'cudaExternalSemaphoreWaitParams.params.reserved' in found_struct}} + + @property def reserved(self): return self._pvt_ptr[0].params.reserved @reserved.setter def reserved(self, reserved): self._pvt_ptr[0].params.reserved = reserved - {{endif}} -{{endif}} -{{if 'cudaExternalSemaphoreWaitParams' in found_struct}} + cdef class cudaExternalSemaphoreWaitParams: """ @@ -16072,11 +15592,11 @@ cdef class cudaExternalSemaphoreWaitParams: Attributes ---------- - {{if 'cudaExternalSemaphoreWaitParams.params' in found_struct}} + params : anon_struct15 - {{endif}} - {{if 'cudaExternalSemaphoreWaitParams.flags' in found_struct}} + + flags : unsigned int Only when cudaExternalSemaphoreSignalParams is used to signal a cudaExternalSemaphore_t of type @@ -16086,11 +15606,11 @@ cdef class cudaExternalSemaphoreWaitParams: synchronization operations should be performed for any external memory object imported as cudaExternalMemoryHandleTypeNvSciBuf. For all other types of cudaExternalSemaphore_t, flags must be zero. - {{endif}} - {{if 'cudaExternalSemaphoreWaitParams.reserved' in found_struct}} + + reserved : list[unsigned int] - {{endif}} + Methods ------- @@ -16104,9 +15624,9 @@ cdef class cudaExternalSemaphoreWaitParams: self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass - {{if 'cudaExternalSemaphoreWaitParams.params' in found_struct}} + self._params = anon_struct15(_ptr=self._pvt_ptr) - {{endif}} + def __dealloc__(self): pass def getPtr(self): @@ -16114,53 +15634,51 @@ cdef class cudaExternalSemaphoreWaitParams: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaExternalSemaphoreWaitParams.params' in found_struct}} + try: str_list += ['params :\n' + '\n'.join([' ' + line for line in str(self.params).splitlines()])] except ValueError: str_list += ['params : '] - {{endif}} - {{if 'cudaExternalSemaphoreWaitParams.flags' in found_struct}} + + try: str_list += ['flags : ' + str(self.flags)] except ValueError: str_list += ['flags : '] - {{endif}} - {{if 'cudaExternalSemaphoreWaitParams.reserved' in found_struct}} + + try: str_list += ['reserved : ' + str(self.reserved)] except ValueError: str_list += ['reserved : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaExternalSemaphoreWaitParams.params' in found_struct}} + @property def params(self): return self._params @params.setter def params(self, params not None : anon_struct15): string.memcpy(&self._pvt_ptr[0].params, params.getPtr(), sizeof(self._pvt_ptr[0].params)) - {{endif}} - {{if 'cudaExternalSemaphoreWaitParams.flags' in found_struct}} + + @property def flags(self): return self._pvt_ptr[0].flags @flags.setter def flags(self, unsigned int flags): self._pvt_ptr[0].flags = flags - {{endif}} - {{if 'cudaExternalSemaphoreWaitParams.reserved' in found_struct}} + + @property def reserved(self): return self._pvt_ptr[0].reserved @reserved.setter def reserved(self, reserved): self._pvt_ptr[0].reserved = reserved - {{endif}} -{{endif}} -{{if 'cudaDevSmResource' in found_struct}} + cdef class cudaDevSmResource: """ @@ -16169,27 +15687,27 @@ cdef class cudaDevSmResource: Attributes ---------- - {{if 'cudaDevSmResource.smCount' in found_struct}} + smCount : unsigned int The amount of streaming multiprocessors available in this resource. - {{endif}} - {{if 'cudaDevSmResource.minSmPartitionSize' in found_struct}} + + minSmPartitionSize : unsigned int The minimum number of streaming multiprocessors required to partition this resource. - {{endif}} - {{if 'cudaDevSmResource.smCoscheduledAlignment' in found_struct}} + + smCoscheduledAlignment : unsigned int The number of streaming multiprocessors in this resource that are guaranteed to be co-scheduled on the same GPU processing cluster. smCount will be a multiple of this value, unless the backfill flag is set. - {{endif}} - {{if 'cudaDevSmResource.flags' in found_struct}} + + flags : unsigned int The flags set on this SM resource. For available flags see cudaDevSmResourceGroup_flags. - {{endif}} + Methods ------- @@ -16210,67 +15728,65 @@ cdef class cudaDevSmResource: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaDevSmResource.smCount' in found_struct}} + try: str_list += ['smCount : ' + str(self.smCount)] except ValueError: str_list += ['smCount : '] - {{endif}} - {{if 'cudaDevSmResource.minSmPartitionSize' in found_struct}} + + try: str_list += ['minSmPartitionSize : ' + str(self.minSmPartitionSize)] except ValueError: str_list += ['minSmPartitionSize : '] - {{endif}} - {{if 'cudaDevSmResource.smCoscheduledAlignment' in found_struct}} + + try: str_list += ['smCoscheduledAlignment : ' + str(self.smCoscheduledAlignment)] except ValueError: str_list += ['smCoscheduledAlignment : '] - {{endif}} - {{if 'cudaDevSmResource.flags' in found_struct}} + + try: str_list += ['flags : ' + str(self.flags)] except ValueError: str_list += ['flags : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaDevSmResource.smCount' in found_struct}} + @property def smCount(self): return self._pvt_ptr[0].smCount @smCount.setter def smCount(self, unsigned int smCount): self._pvt_ptr[0].smCount = smCount - {{endif}} - {{if 'cudaDevSmResource.minSmPartitionSize' in found_struct}} + + @property def minSmPartitionSize(self): return self._pvt_ptr[0].minSmPartitionSize @minSmPartitionSize.setter def minSmPartitionSize(self, unsigned int minSmPartitionSize): self._pvt_ptr[0].minSmPartitionSize = minSmPartitionSize - {{endif}} - {{if 'cudaDevSmResource.smCoscheduledAlignment' in found_struct}} + + @property def smCoscheduledAlignment(self): return self._pvt_ptr[0].smCoscheduledAlignment @smCoscheduledAlignment.setter def smCoscheduledAlignment(self, unsigned int smCoscheduledAlignment): self._pvt_ptr[0].smCoscheduledAlignment = smCoscheduledAlignment - {{endif}} - {{if 'cudaDevSmResource.flags' in found_struct}} + + @property def flags(self): return self._pvt_ptr[0].flags @flags.setter def flags(self, unsigned int flags): self._pvt_ptr[0].flags = flags - {{endif}} -{{endif}} -{{if 'cudaDevWorkqueueConfigResource' in found_struct}} + cdef class cudaDevWorkqueueConfigResource: """ @@ -16278,18 +15794,18 @@ cdef class cudaDevWorkqueueConfigResource: Attributes ---------- - {{if 'cudaDevWorkqueueConfigResource.device' in found_struct}} + device : int The device on which the workqueue resources are available - {{endif}} - {{if 'cudaDevWorkqueueConfigResource.wqConcurrencyLimit' in found_struct}} + + wqConcurrencyLimit : unsigned int The expected maximum number of concurrent stream-ordered workloads - {{endif}} - {{if 'cudaDevWorkqueueConfigResource.sharingScope' in found_struct}} + + sharingScope : cudaDevWorkqueueConfigScope The sharing scope for the workqueue resources - {{endif}} + Methods ------- @@ -16310,53 +15826,51 @@ cdef class cudaDevWorkqueueConfigResource: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaDevWorkqueueConfigResource.device' in found_struct}} + try: str_list += ['device : ' + str(self.device)] except ValueError: str_list += ['device : '] - {{endif}} - {{if 'cudaDevWorkqueueConfigResource.wqConcurrencyLimit' in found_struct}} + + try: str_list += ['wqConcurrencyLimit : ' + str(self.wqConcurrencyLimit)] except ValueError: str_list += ['wqConcurrencyLimit : '] - {{endif}} - {{if 'cudaDevWorkqueueConfigResource.sharingScope' in found_struct}} + + try: str_list += ['sharingScope : ' + str(self.sharingScope)] except ValueError: str_list += ['sharingScope : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaDevWorkqueueConfigResource.device' in found_struct}} + @property def device(self): return self._pvt_ptr[0].device @device.setter def device(self, int device): self._pvt_ptr[0].device = device - {{endif}} - {{if 'cudaDevWorkqueueConfigResource.wqConcurrencyLimit' in found_struct}} + + @property def wqConcurrencyLimit(self): return self._pvt_ptr[0].wqConcurrencyLimit @wqConcurrencyLimit.setter def wqConcurrencyLimit(self, unsigned int wqConcurrencyLimit): self._pvt_ptr[0].wqConcurrencyLimit = wqConcurrencyLimit - {{endif}} - {{if 'cudaDevWorkqueueConfigResource.sharingScope' in found_struct}} + + @property def sharingScope(self): return cudaDevWorkqueueConfigScope(self._pvt_ptr[0].sharingScope) @sharingScope.setter def sharingScope(self, sharingScope not None : cudaDevWorkqueueConfigScope): - self._pvt_ptr[0].sharingScope = int(sharingScope) - {{endif}} -{{endif}} -{{if 'cudaDevWorkqueueResource' in found_struct}} + self._pvt_ptr[0].sharingScope = int(sharingScope) + cdef class cudaDevWorkqueueResource: """ @@ -16364,10 +15878,10 @@ cdef class cudaDevWorkqueueResource: Attributes ---------- - {{if 'cudaDevWorkqueueResource.reserved' in found_struct}} + reserved : bytes Reserved for future use - {{endif}} + Methods ------- @@ -16388,16 +15902,16 @@ cdef class cudaDevWorkqueueResource: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaDevWorkqueueResource.reserved' in found_struct}} + try: str_list += ['reserved : ' + str(self.reserved)] except ValueError: str_list += ['reserved : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaDevWorkqueueResource.reserved' in found_struct}} + @property def reserved(self): return PyBytes_FromStringAndSize(self._pvt_ptr[0].reserved, 40) @@ -16407,9 +15921,7 @@ cdef class cudaDevWorkqueueResource: raise ValueError("reserved length must be 40, is " + str(len(reserved))) for i, b in enumerate(reserved): self._pvt_ptr[0].reserved[i] = b - {{endif}} -{{endif}} -{{if 'cudaDevSmResourceGroupParams_st' in found_struct}} + cdef class cudaDevSmResourceGroupParams_st: """ @@ -16417,29 +15929,29 @@ cdef class cudaDevSmResourceGroupParams_st: Attributes ---------- - {{if 'cudaDevSmResourceGroupParams_st.smCount' in found_struct}} + smCount : unsigned int The amount of SMs available in this resource. - {{endif}} - {{if 'cudaDevSmResourceGroupParams_st.coscheduledSmCount' in found_struct}} + + coscheduledSmCount : unsigned int The amount of co-scheduled SMs grouped together for locality purposes. - {{endif}} - {{if 'cudaDevSmResourceGroupParams_st.preferredCoscheduledSmCount' in found_struct}} + + preferredCoscheduledSmCount : unsigned int When possible, combine co-scheduled groups together into larger groups of this size. - {{endif}} - {{if 'cudaDevSmResourceGroupParams_st.flags' in found_struct}} + + flags : unsigned int Combination of `cudaDevSmResourceGroup_flags` values to indicate this this group is created. - {{endif}} - {{if 'cudaDevSmResourceGroupParams_st.reserved' in found_struct}} + + reserved : list[unsigned int] Reserved for future use - ensure this is zero initialized. - {{endif}} + Methods ------- @@ -16460,81 +15972,79 @@ cdef class cudaDevSmResourceGroupParams_st: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaDevSmResourceGroupParams_st.smCount' in found_struct}} + try: str_list += ['smCount : ' + str(self.smCount)] except ValueError: str_list += ['smCount : '] - {{endif}} - {{if 'cudaDevSmResourceGroupParams_st.coscheduledSmCount' in found_struct}} + + try: str_list += ['coscheduledSmCount : ' + str(self.coscheduledSmCount)] except ValueError: str_list += ['coscheduledSmCount : '] - {{endif}} - {{if 'cudaDevSmResourceGroupParams_st.preferredCoscheduledSmCount' in found_struct}} + + try: str_list += ['preferredCoscheduledSmCount : ' + str(self.preferredCoscheduledSmCount)] except ValueError: str_list += ['preferredCoscheduledSmCount : '] - {{endif}} - {{if 'cudaDevSmResourceGroupParams_st.flags' in found_struct}} + + try: str_list += ['flags : ' + str(self.flags)] except ValueError: str_list += ['flags : '] - {{endif}} - {{if 'cudaDevSmResourceGroupParams_st.reserved' in found_struct}} + + try: str_list += ['reserved : ' + str(self.reserved)] except ValueError: str_list += ['reserved : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaDevSmResourceGroupParams_st.smCount' in found_struct}} + @property def smCount(self): return self._pvt_ptr[0].smCount @smCount.setter def smCount(self, unsigned int smCount): self._pvt_ptr[0].smCount = smCount - {{endif}} - {{if 'cudaDevSmResourceGroupParams_st.coscheduledSmCount' in found_struct}} + + @property def coscheduledSmCount(self): return self._pvt_ptr[0].coscheduledSmCount @coscheduledSmCount.setter def coscheduledSmCount(self, unsigned int coscheduledSmCount): self._pvt_ptr[0].coscheduledSmCount = coscheduledSmCount - {{endif}} - {{if 'cudaDevSmResourceGroupParams_st.preferredCoscheduledSmCount' in found_struct}} + + @property def preferredCoscheduledSmCount(self): return self._pvt_ptr[0].preferredCoscheduledSmCount @preferredCoscheduledSmCount.setter def preferredCoscheduledSmCount(self, unsigned int preferredCoscheduledSmCount): self._pvt_ptr[0].preferredCoscheduledSmCount = preferredCoscheduledSmCount - {{endif}} - {{if 'cudaDevSmResourceGroupParams_st.flags' in found_struct}} + + @property def flags(self): return self._pvt_ptr[0].flags @flags.setter def flags(self, unsigned int flags): self._pvt_ptr[0].flags = flags - {{endif}} - {{if 'cudaDevSmResourceGroupParams_st.reserved' in found_struct}} + + @property def reserved(self): return self._pvt_ptr[0].reserved @reserved.setter def reserved(self, reserved): self._pvt_ptr[0].reserved = reserved - {{endif}} -{{endif}} -{{if 'cudaDevResource_st' in found_struct}} + cdef class cudaDevResource_st: """ @@ -16556,35 +16066,35 @@ cdef class cudaDevResource_st: Attributes ---------- - {{if 'cudaDevResource_st.type' in found_struct}} + type : cudaDevResourceType Type of resource, dictates which union field was last set - {{endif}} - {{if 'cudaDevResource_st._internal_padding' in found_struct}} + + _internal_padding : bytes - {{endif}} - {{if 'cudaDevResource_st.sm' in found_struct}} + + sm : cudaDevSmResource Resource corresponding to cudaDevResourceTypeSm `typename`. - {{endif}} - {{if 'cudaDevResource_st.wqConfig' in found_struct}} + + wqConfig : cudaDevWorkqueueConfigResource Resource corresponding to cudaDevResourceTypeWorkqueueConfig `typename`. - {{endif}} - {{if 'cudaDevResource_st.wq' in found_struct}} + + wq : cudaDevWorkqueueResource Resource corresponding to cudaDevResourceTypeWorkqueue `typename`. - {{endif}} - {{if 'cudaDevResource_st._oversize' in found_struct}} + + _oversize : bytes - {{endif}} - {{if 'cudaDevResource_st.nextResource' in found_struct}} + + nextResource : cudaDevResource_st - {{endif}} + Methods ------- @@ -16599,82 +16109,82 @@ cdef class cudaDevResource_st: self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass - {{if 'cudaDevResource_st.sm' in found_struct}} + self._sm = cudaDevSmResource(_ptr=&self._pvt_ptr[0].sm) - {{endif}} - {{if 'cudaDevResource_st.wqConfig' in found_struct}} + + self._wqConfig = cudaDevWorkqueueConfigResource(_ptr=&self._pvt_ptr[0].wqConfig) - {{endif}} - {{if 'cudaDevResource_st.wq' in found_struct}} + + self._wq = cudaDevWorkqueueResource(_ptr=&self._pvt_ptr[0].wq) - {{endif}} + def __dealloc__(self): if self._val_ptr is not NULL: free(self._val_ptr) - {{if 'cudaDevResource_st.nextResource' in found_struct}} + if self._nextResource is not NULL: free(self._nextResource) self._pvt_ptr[0].nextResource = NULL - {{endif}} + def getPtr(self): return self._pvt_ptr def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaDevResource_st.type' in found_struct}} + try: str_list += ['type : ' + str(self.type)] except ValueError: str_list += ['type : '] - {{endif}} - {{if 'cudaDevResource_st._internal_padding' in found_struct}} + + try: str_list += ['_internal_padding : ' + str(self._internal_padding)] except ValueError: str_list += ['_internal_padding : '] - {{endif}} - {{if 'cudaDevResource_st.sm' in found_struct}} + + try: str_list += ['sm :\n' + '\n'.join([' ' + line for line in str(self.sm).splitlines()])] except ValueError: str_list += ['sm : '] - {{endif}} - {{if 'cudaDevResource_st.wqConfig' in found_struct}} + + try: str_list += ['wqConfig :\n' + '\n'.join([' ' + line for line in str(self.wqConfig).splitlines()])] except ValueError: str_list += ['wqConfig : '] - {{endif}} - {{if 'cudaDevResource_st.wq' in found_struct}} + + try: str_list += ['wq :\n' + '\n'.join([' ' + line for line in str(self.wq).splitlines()])] except ValueError: str_list += ['wq : '] - {{endif}} - {{if 'cudaDevResource_st._oversize' in found_struct}} + + try: str_list += ['_oversize : ' + str(self._oversize)] except ValueError: str_list += ['_oversize : '] - {{endif}} - {{if 'cudaDevResource_st.nextResource' in found_struct}} + + try: str_list += ['nextResource : ' + str(self.nextResource)] except ValueError: str_list += ['nextResource : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaDevResource_st.type' in found_struct}} + @property def type(self): return cudaDevResourceType(self._pvt_ptr[0].type) @type.setter def type(self, type not None : cudaDevResourceType): - self._pvt_ptr[0].type = int(type) - {{endif}} - {{if 'cudaDevResource_st._internal_padding' in found_struct}} + self._pvt_ptr[0].type = int(type) + + @property def _internal_padding(self): return PyBytes_FromStringAndSize(self._pvt_ptr[0]._internal_padding, 92) @@ -16684,32 +16194,32 @@ cdef class cudaDevResource_st: raise ValueError("_internal_padding length must be 92, is " + str(len(_internal_padding))) for i, b in enumerate(_internal_padding): self._pvt_ptr[0]._internal_padding[i] = b - {{endif}} - {{if 'cudaDevResource_st.sm' in found_struct}} + + @property def sm(self): return self._sm @sm.setter def sm(self, sm not None : cudaDevSmResource): string.memcpy(&self._pvt_ptr[0].sm, sm.getPtr(), sizeof(self._pvt_ptr[0].sm)) - {{endif}} - {{if 'cudaDevResource_st.wqConfig' in found_struct}} + + @property def wqConfig(self): return self._wqConfig @wqConfig.setter def wqConfig(self, wqConfig not None : cudaDevWorkqueueConfigResource): string.memcpy(&self._pvt_ptr[0].wqConfig, wqConfig.getPtr(), sizeof(self._pvt_ptr[0].wqConfig)) - {{endif}} - {{if 'cudaDevResource_st.wq' in found_struct}} + + @property def wq(self): return self._wq @wq.setter def wq(self, wq not None : cudaDevWorkqueueResource): string.memcpy(&self._pvt_ptr[0].wq, wq.getPtr(), sizeof(self._pvt_ptr[0].wq)) - {{endif}} - {{if 'cudaDevResource_st._oversize' in found_struct}} + + @property def _oversize(self): return PyBytes_FromStringAndSize(self._pvt_ptr[0]._oversize, 40) @@ -16719,8 +16229,8 @@ cdef class cudaDevResource_st: raise ValueError("_oversize length must be 40, is " + str(len(_oversize))) for i, b in enumerate(_oversize): self._pvt_ptr[0]._oversize[i] = b - {{endif}} - {{if 'cudaDevResource_st.nextResource' in found_struct}} + + @property def nextResource(self): arrs = [self._pvt_ptr[0].nextResource + x*sizeof(cyruntime.cudaDevResource_st) for x in range(self._nextResource_length)] @@ -16743,30 +16253,28 @@ cdef class cudaDevResource_st: for idx in range(len(val)): string.memcpy(&self._nextResource[idx], (val[idx])._pvt_ptr, sizeof(cyruntime.cudaDevResource_st)) - {{endif}} -{{endif}} -{{if 'cudalibraryHostUniversalFunctionAndDataTable' in found_struct}} + cdef class cudalibraryHostUniversalFunctionAndDataTable: """ Attributes ---------- - {{if 'cudalibraryHostUniversalFunctionAndDataTable.functionTable' in found_struct}} + functionTable : Any - {{endif}} - {{if 'cudalibraryHostUniversalFunctionAndDataTable.functionWindowSize' in found_struct}} + + functionWindowSize : size_t - {{endif}} - {{if 'cudalibraryHostUniversalFunctionAndDataTable.dataTable' in found_struct}} + + dataTable : Any - {{endif}} - {{if 'cudalibraryHostUniversalFunctionAndDataTable.dataWindowSize' in found_struct}} + + dataWindowSize : size_t - {{endif}} + Methods ------- @@ -16787,34 +16295,34 @@ cdef class cudalibraryHostUniversalFunctionAndDataTable: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudalibraryHostUniversalFunctionAndDataTable.functionTable' in found_struct}} + try: str_list += ['functionTable : ' + hex(self.functionTable)] except ValueError: str_list += ['functionTable : '] - {{endif}} - {{if 'cudalibraryHostUniversalFunctionAndDataTable.functionWindowSize' in found_struct}} + + try: str_list += ['functionWindowSize : ' + str(self.functionWindowSize)] except ValueError: str_list += ['functionWindowSize : '] - {{endif}} - {{if 'cudalibraryHostUniversalFunctionAndDataTable.dataTable' in found_struct}} + + try: str_list += ['dataTable : ' + hex(self.dataTable)] except ValueError: str_list += ['dataTable : '] - {{endif}} - {{if 'cudalibraryHostUniversalFunctionAndDataTable.dataWindowSize' in found_struct}} + + try: str_list += ['dataWindowSize : ' + str(self.dataWindowSize)] except ValueError: str_list += ['dataWindowSize : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudalibraryHostUniversalFunctionAndDataTable.functionTable' in found_struct}} + @property def functionTable(self): return self._pvt_ptr[0].functionTable @@ -16822,16 +16330,16 @@ cdef class cudalibraryHostUniversalFunctionAndDataTable: def functionTable(self, functionTable): self._cyfunctionTable = _HelperInputVoidPtr(functionTable) self._pvt_ptr[0].functionTable = self._cyfunctionTable.cptr - {{endif}} - {{if 'cudalibraryHostUniversalFunctionAndDataTable.functionWindowSize' in found_struct}} + + @property def functionWindowSize(self): return self._pvt_ptr[0].functionWindowSize @functionWindowSize.setter def functionWindowSize(self, size_t functionWindowSize): self._pvt_ptr[0].functionWindowSize = functionWindowSize - {{endif}} - {{if 'cudalibraryHostUniversalFunctionAndDataTable.dataTable' in found_struct}} + + @property def dataTable(self): return self._pvt_ptr[0].dataTable @@ -16839,17 +16347,15 @@ cdef class cudalibraryHostUniversalFunctionAndDataTable: def dataTable(self, dataTable): self._cydataTable = _HelperInputVoidPtr(dataTable) self._pvt_ptr[0].dataTable = self._cydataTable.cptr - {{endif}} - {{if 'cudalibraryHostUniversalFunctionAndDataTable.dataWindowSize' in found_struct}} + + @property def dataWindowSize(self): return self._pvt_ptr[0].dataWindowSize @dataWindowSize.setter def dataWindowSize(self, size_t dataWindowSize): self._pvt_ptr[0].dataWindowSize = dataWindowSize - {{endif}} -{{endif}} -{{if 'cudaKernelNodeParams' in found_struct}} + cdef class cudaKernelNodeParams: """ @@ -16857,30 +16363,30 @@ cdef class cudaKernelNodeParams: Attributes ---------- - {{if 'cudaKernelNodeParams.func' in found_struct}} + func : Any Kernel to launch - {{endif}} - {{if 'cudaKernelNodeParams.gridDim' in found_struct}} + + gridDim : dim3 Grid dimensions - {{endif}} - {{if 'cudaKernelNodeParams.blockDim' in found_struct}} + + blockDim : dim3 Block dimensions - {{endif}} - {{if 'cudaKernelNodeParams.sharedMemBytes' in found_struct}} + + sharedMemBytes : unsigned int Dynamic shared-memory size per thread block in bytes - {{endif}} - {{if 'cudaKernelNodeParams.kernelParams' in found_struct}} + + kernelParams : Any Array of pointers to individual kernel arguments - {{endif}} - {{if 'cudaKernelNodeParams.extra' in found_struct}} + + extra : Any Pointer to kernel arguments in the "extra" format - {{endif}} + Methods ------- @@ -16894,12 +16400,12 @@ cdef class cudaKernelNodeParams: self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass - {{if 'cudaKernelNodeParams.gridDim' in found_struct}} + self._gridDim = dim3(_ptr=&self._pvt_ptr[0].gridDim) - {{endif}} - {{if 'cudaKernelNodeParams.blockDim' in found_struct}} + + self._blockDim = dim3(_ptr=&self._pvt_ptr[0].blockDim) - {{endif}} + def __dealloc__(self): pass def getPtr(self): @@ -16907,46 +16413,46 @@ cdef class cudaKernelNodeParams: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaKernelNodeParams.func' in found_struct}} + try: str_list += ['func : ' + hex(self.func)] except ValueError: str_list += ['func : '] - {{endif}} - {{if 'cudaKernelNodeParams.gridDim' in found_struct}} + + try: str_list += ['gridDim :\n' + '\n'.join([' ' + line for line in str(self.gridDim).splitlines()])] except ValueError: str_list += ['gridDim : '] - {{endif}} - {{if 'cudaKernelNodeParams.blockDim' in found_struct}} + + try: str_list += ['blockDim :\n' + '\n'.join([' ' + line for line in str(self.blockDim).splitlines()])] except ValueError: str_list += ['blockDim : '] - {{endif}} - {{if 'cudaKernelNodeParams.sharedMemBytes' in found_struct}} + + try: str_list += ['sharedMemBytes : ' + str(self.sharedMemBytes)] except ValueError: str_list += ['sharedMemBytes : '] - {{endif}} - {{if 'cudaKernelNodeParams.kernelParams' in found_struct}} + + try: str_list += ['kernelParams : ' + str(self.kernelParams)] except ValueError: str_list += ['kernelParams : '] - {{endif}} - {{if 'cudaKernelNodeParams.extra' in found_struct}} + + try: str_list += ['extra : ' + str(self.extra)] except ValueError: str_list += ['extra : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaKernelNodeParams.func' in found_struct}} + @property def func(self): return self._pvt_ptr[0].func @@ -16954,32 +16460,32 @@ cdef class cudaKernelNodeParams: def func(self, func): self._cyfunc = _HelperInputVoidPtr(func) self._pvt_ptr[0].func = self._cyfunc.cptr - {{endif}} - {{if 'cudaKernelNodeParams.gridDim' in found_struct}} + + @property def gridDim(self): return self._gridDim @gridDim.setter def gridDim(self, gridDim not None : dim3): string.memcpy(&self._pvt_ptr[0].gridDim, gridDim.getPtr(), sizeof(self._pvt_ptr[0].gridDim)) - {{endif}} - {{if 'cudaKernelNodeParams.blockDim' in found_struct}} + + @property def blockDim(self): return self._blockDim @blockDim.setter def blockDim(self, blockDim not None : dim3): string.memcpy(&self._pvt_ptr[0].blockDim, blockDim.getPtr(), sizeof(self._pvt_ptr[0].blockDim)) - {{endif}} - {{if 'cudaKernelNodeParams.sharedMemBytes' in found_struct}} + + @property def sharedMemBytes(self): return self._pvt_ptr[0].sharedMemBytes @sharedMemBytes.setter def sharedMemBytes(self, unsigned int sharedMemBytes): self._pvt_ptr[0].sharedMemBytes = sharedMemBytes - {{endif}} - {{if 'cudaKernelNodeParams.kernelParams' in found_struct}} + + @property def kernelParams(self): return self._pvt_ptr[0].kernelParams @@ -16987,17 +16493,15 @@ cdef class cudaKernelNodeParams: def kernelParams(self, kernelParams): self._cykernelParams = _HelperKernelParams(kernelParams) self._pvt_ptr[0].kernelParams = self._cykernelParams.ckernelParams - {{endif}} - {{if 'cudaKernelNodeParams.extra' in found_struct}} + + @property def extra(self): return self._pvt_ptr[0].extra @extra.setter def extra(self, void_ptr extra): self._pvt_ptr[0].extra = extra - {{endif}} -{{endif}} -{{if 'cudaKernelNodeParamsV2' in found_struct}} + cdef class cudaKernelNodeParamsV2: """ @@ -17005,47 +16509,47 @@ cdef class cudaKernelNodeParamsV2: Attributes ---------- - {{if 'cudaKernelNodeParamsV2.func' in found_struct}} + func : Any functionType = cudaKernelFucntionTypeDevice - {{endif}} - {{if 'cudaKernelNodeParamsV2.kern' in found_struct}} + + kern : cudaKernel_t functionType = cudaKernelFucntionTypeKernel - {{endif}} - {{if 'cudaKernelNodeParamsV2.cuFunc' in found_struct}} + + cuFunc : cudaFunction_t functionType = cudaKernelFucntionTypeFunction - {{endif}} - {{if 'cudaKernelNodeParamsV2.gridDim' in found_struct}} + + gridDim : dim3 Grid dimensions - {{endif}} - {{if 'cudaKernelNodeParamsV2.blockDim' in found_struct}} + + blockDim : dim3 Block dimensions - {{endif}} - {{if 'cudaKernelNodeParamsV2.sharedMemBytes' in found_struct}} + + sharedMemBytes : unsigned int Dynamic shared-memory size per thread block in bytes - {{endif}} - {{if 'cudaKernelNodeParamsV2.kernelParams' in found_struct}} + + kernelParams : Any Array of pointers to individual kernel arguments - {{endif}} - {{if 'cudaKernelNodeParamsV2.extra' in found_struct}} + + extra : Any Pointer to kernel arguments in the "extra" format - {{endif}} - {{if 'cudaKernelNodeParamsV2.ctx' in found_struct}} + + ctx : cudaExecutionContext_t Context in which to run the kernel. If NULL will try to use the current context. - {{endif}} - {{if 'cudaKernelNodeParamsV2.functionType' in found_struct}} + + functionType : cudaKernelFunctionType Type of handle passed in the func/kern/cuFunc union above - {{endif}} + Methods ------- @@ -17060,21 +16564,21 @@ cdef class cudaKernelNodeParamsV2: self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass - {{if 'cudaKernelNodeParamsV2.kern' in found_struct}} + self._kern = cudaKernel_t(_ptr=&self._pvt_ptr[0].kern) - {{endif}} - {{if 'cudaKernelNodeParamsV2.cuFunc' in found_struct}} + + self._cuFunc = cudaFunction_t(_ptr=&self._pvt_ptr[0].cuFunc) - {{endif}} - {{if 'cudaKernelNodeParamsV2.gridDim' in found_struct}} + + self._gridDim = dim3(_ptr=&self._pvt_ptr[0].gridDim) - {{endif}} - {{if 'cudaKernelNodeParamsV2.blockDim' in found_struct}} + + self._blockDim = dim3(_ptr=&self._pvt_ptr[0].blockDim) - {{endif}} - {{if 'cudaKernelNodeParamsV2.ctx' in found_struct}} + + self._ctx = cudaExecutionContext_t(_ptr=&self._pvt_ptr[0].ctx) - {{endif}} + def __dealloc__(self): if self._val_ptr is not NULL: free(self._val_ptr) @@ -17083,70 +16587,70 @@ cdef class cudaKernelNodeParamsV2: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaKernelNodeParamsV2.func' in found_struct}} + try: str_list += ['func : ' + hex(self.func)] except ValueError: str_list += ['func : '] - {{endif}} - {{if 'cudaKernelNodeParamsV2.kern' in found_struct}} + + try: str_list += ['kern : ' + str(self.kern)] except ValueError: str_list += ['kern : '] - {{endif}} - {{if 'cudaKernelNodeParamsV2.cuFunc' in found_struct}} + + try: str_list += ['cuFunc : ' + str(self.cuFunc)] except ValueError: str_list += ['cuFunc : '] - {{endif}} - {{if 'cudaKernelNodeParamsV2.gridDim' in found_struct}} + + try: str_list += ['gridDim :\n' + '\n'.join([' ' + line for line in str(self.gridDim).splitlines()])] except ValueError: str_list += ['gridDim : '] - {{endif}} - {{if 'cudaKernelNodeParamsV2.blockDim' in found_struct}} + + try: str_list += ['blockDim :\n' + '\n'.join([' ' + line for line in str(self.blockDim).splitlines()])] except ValueError: str_list += ['blockDim : '] - {{endif}} - {{if 'cudaKernelNodeParamsV2.sharedMemBytes' in found_struct}} + + try: str_list += ['sharedMemBytes : ' + str(self.sharedMemBytes)] except ValueError: str_list += ['sharedMemBytes : '] - {{endif}} - {{if 'cudaKernelNodeParamsV2.kernelParams' in found_struct}} + + try: str_list += ['kernelParams : ' + str(self.kernelParams)] except ValueError: str_list += ['kernelParams : '] - {{endif}} - {{if 'cudaKernelNodeParamsV2.extra' in found_struct}} + + try: str_list += ['extra : ' + str(self.extra)] except ValueError: str_list += ['extra : '] - {{endif}} - {{if 'cudaKernelNodeParamsV2.ctx' in found_struct}} + + try: str_list += ['ctx : ' + str(self.ctx)] except ValueError: str_list += ['ctx : '] - {{endif}} - {{if 'cudaKernelNodeParamsV2.functionType' in found_struct}} + + try: str_list += ['functionType : ' + str(self.functionType)] except ValueError: str_list += ['functionType : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaKernelNodeParamsV2.func' in found_struct}} + @property def func(self): return self._pvt_ptr[0].func @@ -17154,8 +16658,8 @@ cdef class cudaKernelNodeParamsV2: def func(self, func): self._cyfunc = _HelperInputVoidPtr(func) self._pvt_ptr[0].func = self._cyfunc.cptr - {{endif}} - {{if 'cudaKernelNodeParamsV2.kern' in found_struct}} + + @property def kern(self): return self._kern @@ -17171,8 +16675,8 @@ cdef class cudaKernelNodeParamsV2: pkern = int(cudaKernel_t(kern)) cykern = pkern self._kern._pvt_ptr[0] = cykern - {{endif}} - {{if 'cudaKernelNodeParamsV2.cuFunc' in found_struct}} + + @property def cuFunc(self): return self._cuFunc @@ -17188,32 +16692,32 @@ cdef class cudaKernelNodeParamsV2: pcuFunc = int(cudaFunction_t(cuFunc)) cycuFunc = pcuFunc self._cuFunc._pvt_ptr[0] = cycuFunc - {{endif}} - {{if 'cudaKernelNodeParamsV2.gridDim' in found_struct}} + + @property def gridDim(self): return self._gridDim @gridDim.setter def gridDim(self, gridDim not None : dim3): string.memcpy(&self._pvt_ptr[0].gridDim, gridDim.getPtr(), sizeof(self._pvt_ptr[0].gridDim)) - {{endif}} - {{if 'cudaKernelNodeParamsV2.blockDim' in found_struct}} + + @property def blockDim(self): return self._blockDim @blockDim.setter def blockDim(self, blockDim not None : dim3): string.memcpy(&self._pvt_ptr[0].blockDim, blockDim.getPtr(), sizeof(self._pvt_ptr[0].blockDim)) - {{endif}} - {{if 'cudaKernelNodeParamsV2.sharedMemBytes' in found_struct}} + + @property def sharedMemBytes(self): return self._pvt_ptr[0].sharedMemBytes @sharedMemBytes.setter def sharedMemBytes(self, unsigned int sharedMemBytes): self._pvt_ptr[0].sharedMemBytes = sharedMemBytes - {{endif}} - {{if 'cudaKernelNodeParamsV2.kernelParams' in found_struct}} + + @property def kernelParams(self): return self._pvt_ptr[0].kernelParams @@ -17221,16 +16725,16 @@ cdef class cudaKernelNodeParamsV2: def kernelParams(self, kernelParams): self._cykernelParams = _HelperKernelParams(kernelParams) self._pvt_ptr[0].kernelParams = self._cykernelParams.ckernelParams - {{endif}} - {{if 'cudaKernelNodeParamsV2.extra' in found_struct}} + + @property def extra(self): return self._pvt_ptr[0].extra @extra.setter def extra(self, void_ptr extra): self._pvt_ptr[0].extra = extra - {{endif}} - {{if 'cudaKernelNodeParamsV2.ctx' in found_struct}} + + @property def ctx(self): return self._ctx @@ -17246,17 +16750,15 @@ cdef class cudaKernelNodeParamsV2: pctx = int(cudaExecutionContext_t(ctx)) cyctx = pctx self._ctx._pvt_ptr[0] = cyctx - {{endif}} - {{if 'cudaKernelNodeParamsV2.functionType' in found_struct}} + + @property def functionType(self): return cudaKernelFunctionType(self._pvt_ptr[0].functionType) @functionType.setter def functionType(self, functionType not None : cudaKernelFunctionType): - self._pvt_ptr[0].functionType = int(functionType) - {{endif}} -{{endif}} -{{if 'cudaExternalSemaphoreSignalNodeParams' in found_struct}} + self._pvt_ptr[0].functionType = int(functionType) + cdef class cudaExternalSemaphoreSignalNodeParams: """ @@ -17264,19 +16766,19 @@ cdef class cudaExternalSemaphoreSignalNodeParams: Attributes ---------- - {{if 'cudaExternalSemaphoreSignalNodeParams.extSemArray' in found_struct}} + extSemArray : cudaExternalSemaphore_t Array of external semaphore handles. - {{endif}} - {{if 'cudaExternalSemaphoreSignalNodeParams.paramsArray' in found_struct}} + + paramsArray : cudaExternalSemaphoreSignalParams Array of external semaphore signal parameters. - {{endif}} - {{if 'cudaExternalSemaphoreSignalNodeParams.numExtSems' in found_struct}} + + numExtSems : unsigned int Number of handles and parameters supplied in extSemArray and paramsArray. - {{endif}} + Methods ------- @@ -17292,43 +16794,43 @@ cdef class cudaExternalSemaphoreSignalNodeParams: pass def __dealloc__(self): pass - {{if 'cudaExternalSemaphoreSignalNodeParams.extSemArray' in found_struct}} + if self._extSemArray is not NULL: free(self._extSemArray) self._pvt_ptr[0].extSemArray = NULL - {{endif}} - {{if 'cudaExternalSemaphoreSignalNodeParams.paramsArray' in found_struct}} + + if self._paramsArray is not NULL: free(self._paramsArray) self._pvt_ptr[0].paramsArray = NULL - {{endif}} + def getPtr(self): return self._pvt_ptr def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaExternalSemaphoreSignalNodeParams.extSemArray' in found_struct}} + try: str_list += ['extSemArray : ' + str(self.extSemArray)] except ValueError: str_list += ['extSemArray : '] - {{endif}} - {{if 'cudaExternalSemaphoreSignalNodeParams.paramsArray' in found_struct}} + + try: str_list += ['paramsArray : ' + str(self.paramsArray)] except ValueError: str_list += ['paramsArray : '] - {{endif}} - {{if 'cudaExternalSemaphoreSignalNodeParams.numExtSems' in found_struct}} + + try: str_list += ['numExtSems : ' + str(self.numExtSems)] except ValueError: str_list += ['numExtSems : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaExternalSemaphoreSignalNodeParams.extSemArray' in found_struct}} + @property def extSemArray(self): arrs = [self._pvt_ptr[0].extSemArray + x*sizeof(cyruntime.cudaExternalSemaphore_t) for x in range(self._extSemArray_length)] @@ -17351,8 +16853,8 @@ cdef class cudaExternalSemaphoreSignalNodeParams: for idx in range(len(val)): self._extSemArray[idx] = (val[idx])._pvt_ptr[0] - {{endif}} - {{if 'cudaExternalSemaphoreSignalNodeParams.paramsArray' in found_struct}} + + @property def paramsArray(self): arrs = [self._pvt_ptr[0].paramsArray + x*sizeof(cyruntime.cudaExternalSemaphoreSignalParams) for x in range(self._paramsArray_length)] @@ -17375,17 +16877,15 @@ cdef class cudaExternalSemaphoreSignalNodeParams: for idx in range(len(val)): string.memcpy(&self._paramsArray[idx], (val[idx])._pvt_ptr, sizeof(cyruntime.cudaExternalSemaphoreSignalParams)) - {{endif}} - {{if 'cudaExternalSemaphoreSignalNodeParams.numExtSems' in found_struct}} + + @property def numExtSems(self): return self._pvt_ptr[0].numExtSems @numExtSems.setter def numExtSems(self, unsigned int numExtSems): self._pvt_ptr[0].numExtSems = numExtSems - {{endif}} -{{endif}} -{{if 'cudaExternalSemaphoreSignalNodeParamsV2' in found_struct}} + cdef class cudaExternalSemaphoreSignalNodeParamsV2: """ @@ -17393,19 +16893,19 @@ cdef class cudaExternalSemaphoreSignalNodeParamsV2: Attributes ---------- - {{if 'cudaExternalSemaphoreSignalNodeParamsV2.extSemArray' in found_struct}} + extSemArray : cudaExternalSemaphore_t Array of external semaphore handles. - {{endif}} - {{if 'cudaExternalSemaphoreSignalNodeParamsV2.paramsArray' in found_struct}} + + paramsArray : cudaExternalSemaphoreSignalParams Array of external semaphore signal parameters. - {{endif}} - {{if 'cudaExternalSemaphoreSignalNodeParamsV2.numExtSems' in found_struct}} + + numExtSems : unsigned int Number of handles and parameters supplied in extSemArray and paramsArray. - {{endif}} + Methods ------- @@ -17421,43 +16921,43 @@ cdef class cudaExternalSemaphoreSignalNodeParamsV2: pass def __dealloc__(self): pass - {{if 'cudaExternalSemaphoreSignalNodeParamsV2.extSemArray' in found_struct}} + if self._extSemArray is not NULL: free(self._extSemArray) self._pvt_ptr[0].extSemArray = NULL - {{endif}} - {{if 'cudaExternalSemaphoreSignalNodeParamsV2.paramsArray' in found_struct}} + + if self._paramsArray is not NULL: free(self._paramsArray) self._pvt_ptr[0].paramsArray = NULL - {{endif}} + def getPtr(self): return self._pvt_ptr def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaExternalSemaphoreSignalNodeParamsV2.extSemArray' in found_struct}} + try: str_list += ['extSemArray : ' + str(self.extSemArray)] except ValueError: str_list += ['extSemArray : '] - {{endif}} - {{if 'cudaExternalSemaphoreSignalNodeParamsV2.paramsArray' in found_struct}} + + try: str_list += ['paramsArray : ' + str(self.paramsArray)] except ValueError: str_list += ['paramsArray : '] - {{endif}} - {{if 'cudaExternalSemaphoreSignalNodeParamsV2.numExtSems' in found_struct}} + + try: str_list += ['numExtSems : ' + str(self.numExtSems)] except ValueError: str_list += ['numExtSems : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaExternalSemaphoreSignalNodeParamsV2.extSemArray' in found_struct}} + @property def extSemArray(self): arrs = [self._pvt_ptr[0].extSemArray + x*sizeof(cyruntime.cudaExternalSemaphore_t) for x in range(self._extSemArray_length)] @@ -17480,8 +16980,8 @@ cdef class cudaExternalSemaphoreSignalNodeParamsV2: for idx in range(len(val)): self._extSemArray[idx] = (val[idx])._pvt_ptr[0] - {{endif}} - {{if 'cudaExternalSemaphoreSignalNodeParamsV2.paramsArray' in found_struct}} + + @property def paramsArray(self): arrs = [self._pvt_ptr[0].paramsArray + x*sizeof(cyruntime.cudaExternalSemaphoreSignalParams) for x in range(self._paramsArray_length)] @@ -17504,17 +17004,15 @@ cdef class cudaExternalSemaphoreSignalNodeParamsV2: for idx in range(len(val)): string.memcpy(&self._paramsArray[idx], (val[idx])._pvt_ptr, sizeof(cyruntime.cudaExternalSemaphoreSignalParams)) - {{endif}} - {{if 'cudaExternalSemaphoreSignalNodeParamsV2.numExtSems' in found_struct}} + + @property def numExtSems(self): return self._pvt_ptr[0].numExtSems @numExtSems.setter def numExtSems(self, unsigned int numExtSems): self._pvt_ptr[0].numExtSems = numExtSems - {{endif}} -{{endif}} -{{if 'cudaExternalSemaphoreWaitNodeParams' in found_struct}} + cdef class cudaExternalSemaphoreWaitNodeParams: """ @@ -17522,19 +17020,19 @@ cdef class cudaExternalSemaphoreWaitNodeParams: Attributes ---------- - {{if 'cudaExternalSemaphoreWaitNodeParams.extSemArray' in found_struct}} + extSemArray : cudaExternalSemaphore_t Array of external semaphore handles. - {{endif}} - {{if 'cudaExternalSemaphoreWaitNodeParams.paramsArray' in found_struct}} + + paramsArray : cudaExternalSemaphoreWaitParams Array of external semaphore wait parameters. - {{endif}} - {{if 'cudaExternalSemaphoreWaitNodeParams.numExtSems' in found_struct}} + + numExtSems : unsigned int Number of handles and parameters supplied in extSemArray and paramsArray. - {{endif}} + Methods ------- @@ -17550,43 +17048,43 @@ cdef class cudaExternalSemaphoreWaitNodeParams: pass def __dealloc__(self): pass - {{if 'cudaExternalSemaphoreWaitNodeParams.extSemArray' in found_struct}} + if self._extSemArray is not NULL: free(self._extSemArray) self._pvt_ptr[0].extSemArray = NULL - {{endif}} - {{if 'cudaExternalSemaphoreWaitNodeParams.paramsArray' in found_struct}} + + if self._paramsArray is not NULL: free(self._paramsArray) self._pvt_ptr[0].paramsArray = NULL - {{endif}} + def getPtr(self): return self._pvt_ptr def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaExternalSemaphoreWaitNodeParams.extSemArray' in found_struct}} + try: str_list += ['extSemArray : ' + str(self.extSemArray)] except ValueError: str_list += ['extSemArray : '] - {{endif}} - {{if 'cudaExternalSemaphoreWaitNodeParams.paramsArray' in found_struct}} + + try: str_list += ['paramsArray : ' + str(self.paramsArray)] except ValueError: str_list += ['paramsArray : '] - {{endif}} - {{if 'cudaExternalSemaphoreWaitNodeParams.numExtSems' in found_struct}} + + try: str_list += ['numExtSems : ' + str(self.numExtSems)] except ValueError: str_list += ['numExtSems : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaExternalSemaphoreWaitNodeParams.extSemArray' in found_struct}} + @property def extSemArray(self): arrs = [self._pvt_ptr[0].extSemArray + x*sizeof(cyruntime.cudaExternalSemaphore_t) for x in range(self._extSemArray_length)] @@ -17609,8 +17107,8 @@ cdef class cudaExternalSemaphoreWaitNodeParams: for idx in range(len(val)): self._extSemArray[idx] = (val[idx])._pvt_ptr[0] - {{endif}} - {{if 'cudaExternalSemaphoreWaitNodeParams.paramsArray' in found_struct}} + + @property def paramsArray(self): arrs = [self._pvt_ptr[0].paramsArray + x*sizeof(cyruntime.cudaExternalSemaphoreWaitParams) for x in range(self._paramsArray_length)] @@ -17633,17 +17131,15 @@ cdef class cudaExternalSemaphoreWaitNodeParams: for idx in range(len(val)): string.memcpy(&self._paramsArray[idx], (val[idx])._pvt_ptr, sizeof(cyruntime.cudaExternalSemaphoreWaitParams)) - {{endif}} - {{if 'cudaExternalSemaphoreWaitNodeParams.numExtSems' in found_struct}} + + @property def numExtSems(self): return self._pvt_ptr[0].numExtSems @numExtSems.setter def numExtSems(self, unsigned int numExtSems): self._pvt_ptr[0].numExtSems = numExtSems - {{endif}} -{{endif}} -{{if 'cudaExternalSemaphoreWaitNodeParamsV2' in found_struct}} + cdef class cudaExternalSemaphoreWaitNodeParamsV2: """ @@ -17651,19 +17147,19 @@ cdef class cudaExternalSemaphoreWaitNodeParamsV2: Attributes ---------- - {{if 'cudaExternalSemaphoreWaitNodeParamsV2.extSemArray' in found_struct}} + extSemArray : cudaExternalSemaphore_t Array of external semaphore handles. - {{endif}} - {{if 'cudaExternalSemaphoreWaitNodeParamsV2.paramsArray' in found_struct}} + + paramsArray : cudaExternalSemaphoreWaitParams Array of external semaphore wait parameters. - {{endif}} - {{if 'cudaExternalSemaphoreWaitNodeParamsV2.numExtSems' in found_struct}} + + numExtSems : unsigned int Number of handles and parameters supplied in extSemArray and paramsArray. - {{endif}} + Methods ------- @@ -17679,43 +17175,43 @@ cdef class cudaExternalSemaphoreWaitNodeParamsV2: pass def __dealloc__(self): pass - {{if 'cudaExternalSemaphoreWaitNodeParamsV2.extSemArray' in found_struct}} + if self._extSemArray is not NULL: free(self._extSemArray) self._pvt_ptr[0].extSemArray = NULL - {{endif}} - {{if 'cudaExternalSemaphoreWaitNodeParamsV2.paramsArray' in found_struct}} + + if self._paramsArray is not NULL: free(self._paramsArray) self._pvt_ptr[0].paramsArray = NULL - {{endif}} + def getPtr(self): return self._pvt_ptr def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaExternalSemaphoreWaitNodeParamsV2.extSemArray' in found_struct}} + try: str_list += ['extSemArray : ' + str(self.extSemArray)] except ValueError: str_list += ['extSemArray : '] - {{endif}} - {{if 'cudaExternalSemaphoreWaitNodeParamsV2.paramsArray' in found_struct}} + + try: str_list += ['paramsArray : ' + str(self.paramsArray)] except ValueError: str_list += ['paramsArray : '] - {{endif}} - {{if 'cudaExternalSemaphoreWaitNodeParamsV2.numExtSems' in found_struct}} + + try: str_list += ['numExtSems : ' + str(self.numExtSems)] except ValueError: str_list += ['numExtSems : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaExternalSemaphoreWaitNodeParamsV2.extSemArray' in found_struct}} + @property def extSemArray(self): arrs = [self._pvt_ptr[0].extSemArray + x*sizeof(cyruntime.cudaExternalSemaphore_t) for x in range(self._extSemArray_length)] @@ -17738,8 +17234,8 @@ cdef class cudaExternalSemaphoreWaitNodeParamsV2: for idx in range(len(val)): self._extSemArray[idx] = (val[idx])._pvt_ptr[0] - {{endif}} - {{if 'cudaExternalSemaphoreWaitNodeParamsV2.paramsArray' in found_struct}} + + @property def paramsArray(self): arrs = [self._pvt_ptr[0].paramsArray + x*sizeof(cyruntime.cudaExternalSemaphoreWaitParams) for x in range(self._paramsArray_length)] @@ -17762,17 +17258,15 @@ cdef class cudaExternalSemaphoreWaitNodeParamsV2: for idx in range(len(val)): string.memcpy(&self._paramsArray[idx], (val[idx])._pvt_ptr, sizeof(cyruntime.cudaExternalSemaphoreWaitParams)) - {{endif}} - {{if 'cudaExternalSemaphoreWaitNodeParamsV2.numExtSems' in found_struct}} + + @property def numExtSems(self): return self._pvt_ptr[0].numExtSems @numExtSems.setter def numExtSems(self, unsigned int numExtSems): self._pvt_ptr[0].numExtSems = numExtSems - {{endif}} -{{endif}} -{{if 'cudaConditionalNodeParams' in found_struct}} + cdef class cudaConditionalNodeParams: """ @@ -17780,22 +17274,22 @@ cdef class cudaConditionalNodeParams: Attributes ---------- - {{if 'cudaConditionalNodeParams.handle' in found_struct}} + handle : cudaGraphConditionalHandle Conditional node handle. Handles must be created in advance of creating the node using cudaGraphConditionalHandleCreate. - {{endif}} - {{if 'cudaConditionalNodeParams.type' in found_struct}} + + type : cudaGraphConditionalNodeType Type of conditional node. - {{endif}} - {{if 'cudaConditionalNodeParams.size' in found_struct}} + + size : unsigned int Size of graph output array. Allowed values are 1 for cudaGraphCondTypeWhile, 1 or 2 for cudaGraphCondTypeIf, or any value greater than zero for cudaGraphCondTypeSwitch. - {{endif}} - {{if 'cudaConditionalNodeParams.phGraph_out' in found_struct}} + + phGraph_out : cudaGraph_t CUDA-owned array populated with conditional node child graphs during creation of the node. Valid for the lifetime of the @@ -17813,11 +17307,11 @@ cdef class cudaConditionalNodeParams: condition is non-zero. cudaGraphCondTypeSwitch: phGraph_out[n] is executed when the condition is equal to n. If the condition >= `size`, no body graph is executed. - {{endif}} - {{if 'cudaConditionalNodeParams.ctx' in found_struct}} + + ctx : cudaExecutionContext_t CUDA Execution Context - {{endif}} + Methods ------- @@ -17831,12 +17325,12 @@ cdef class cudaConditionalNodeParams: self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass - {{if 'cudaConditionalNodeParams.handle' in found_struct}} + self._handle = cudaGraphConditionalHandle(_ptr=&self._pvt_ptr[0].handle) - {{endif}} - {{if 'cudaConditionalNodeParams.ctx' in found_struct}} + + self._ctx = cudaExecutionContext_t(_ptr=&self._pvt_ptr[0].ctx) - {{endif}} + def __dealloc__(self): pass def getPtr(self): @@ -17844,40 +17338,40 @@ cdef class cudaConditionalNodeParams: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaConditionalNodeParams.handle' in found_struct}} + try: str_list += ['handle : ' + str(self.handle)] except ValueError: str_list += ['handle : '] - {{endif}} - {{if 'cudaConditionalNodeParams.type' in found_struct}} + + try: str_list += ['type : ' + str(self.type)] except ValueError: str_list += ['type : '] - {{endif}} - {{if 'cudaConditionalNodeParams.size' in found_struct}} + + try: str_list += ['size : ' + str(self.size)] except ValueError: str_list += ['size : '] - {{endif}} - {{if 'cudaConditionalNodeParams.phGraph_out' in found_struct}} + + try: str_list += ['phGraph_out : ' + str(self.phGraph_out)] except ValueError: str_list += ['phGraph_out : '] - {{endif}} - {{if 'cudaConditionalNodeParams.ctx' in found_struct}} + + try: str_list += ['ctx : ' + str(self.ctx)] except ValueError: str_list += ['ctx : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaConditionalNodeParams.handle' in found_struct}} + @property def handle(self): return self._handle @@ -17894,30 +17388,30 @@ cdef class cudaConditionalNodeParams: cyhandle = phandle self._handle._pvt_ptr[0] = cyhandle - {{endif}} - {{if 'cudaConditionalNodeParams.type' in found_struct}} + + @property def type(self): return cudaGraphConditionalNodeType(self._pvt_ptr[0].type) @type.setter def type(self, type not None : cudaGraphConditionalNodeType): - self._pvt_ptr[0].type = int(type) - {{endif}} - {{if 'cudaConditionalNodeParams.size' in found_struct}} + self._pvt_ptr[0].type = int(type) + + @property def size(self): return self._pvt_ptr[0].size @size.setter def size(self, unsigned int size): self._pvt_ptr[0].size = size - {{endif}} - {{if 'cudaConditionalNodeParams.phGraph_out' in found_struct}} + + @property def phGraph_out(self): arrs = [self._pvt_ptr[0].phGraph_out + x*sizeof(cyruntime.cudaGraph_t) for x in range(self.size)] return [cudaGraph_t(_ptr=arr) for arr in arrs] - {{endif}} - {{if 'cudaConditionalNodeParams.ctx' in found_struct}} + + @property def ctx(self): return self._ctx @@ -17933,9 +17427,7 @@ cdef class cudaConditionalNodeParams: pctx = int(cudaExecutionContext_t(ctx)) cyctx = pctx self._ctx._pvt_ptr[0] = cyctx - {{endif}} -{{endif}} -{{if 'cudaChildGraphNodeParams' in found_struct}} + cdef class cudaChildGraphNodeParams: """ @@ -17943,18 +17435,18 @@ cdef class cudaChildGraphNodeParams: Attributes ---------- - {{if 'cudaChildGraphNodeParams.graph' in found_struct}} + graph : cudaGraph_t The child graph to clone into the node for node creation, or a handle to the graph owned by the node for node query. The graph must not contain conditional nodes. Graphs containing memory allocation or memory free nodes must set the ownership to be moved to the parent. - {{endif}} - {{if 'cudaChildGraphNodeParams.ownership' in found_struct}} + + ownership : cudaGraphChildGraphNodeOwnership The ownership relationship of the child graph node. - {{endif}} + Methods ------- @@ -17968,9 +17460,9 @@ cdef class cudaChildGraphNodeParams: self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass - {{if 'cudaChildGraphNodeParams.graph' in found_struct}} + self._graph = cudaGraph_t(_ptr=&self._pvt_ptr[0].graph) - {{endif}} + def __dealloc__(self): pass def getPtr(self): @@ -17978,22 +17470,22 @@ cdef class cudaChildGraphNodeParams: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaChildGraphNodeParams.graph' in found_struct}} + try: str_list += ['graph : ' + str(self.graph)] except ValueError: str_list += ['graph : '] - {{endif}} - {{if 'cudaChildGraphNodeParams.ownership' in found_struct}} + + try: str_list += ['ownership : ' + str(self.ownership)] except ValueError: str_list += ['ownership : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaChildGraphNodeParams.graph' in found_struct}} + @property def graph(self): return self._graph @@ -18009,17 +17501,15 @@ cdef class cudaChildGraphNodeParams: pgraph = int(cudaGraph_t(graph)) cygraph = pgraph self._graph._pvt_ptr[0] = cygraph - {{endif}} - {{if 'cudaChildGraphNodeParams.ownership' in found_struct}} + + @property def ownership(self): return cudaGraphChildGraphNodeOwnership(self._pvt_ptr[0].ownership) @ownership.setter def ownership(self, ownership not None : cudaGraphChildGraphNodeOwnership): - self._pvt_ptr[0].ownership = int(ownership) - {{endif}} -{{endif}} -{{if 'cudaEventRecordNodeParams' in found_struct}} + self._pvt_ptr[0].ownership = int(ownership) + cdef class cudaEventRecordNodeParams: """ @@ -18027,10 +17517,10 @@ cdef class cudaEventRecordNodeParams: Attributes ---------- - {{if 'cudaEventRecordNodeParams.event' in found_struct}} + event : cudaEvent_t The event to record when the node executes - {{endif}} + Methods ------- @@ -18044,9 +17534,9 @@ cdef class cudaEventRecordNodeParams: self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass - {{if 'cudaEventRecordNodeParams.event' in found_struct}} + self._event = cudaEvent_t(_ptr=&self._pvt_ptr[0].event) - {{endif}} + def __dealloc__(self): pass def getPtr(self): @@ -18054,16 +17544,16 @@ cdef class cudaEventRecordNodeParams: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaEventRecordNodeParams.event' in found_struct}} + try: str_list += ['event : ' + str(self.event)] except ValueError: str_list += ['event : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaEventRecordNodeParams.event' in found_struct}} + @property def event(self): return self._event @@ -18079,9 +17569,7 @@ cdef class cudaEventRecordNodeParams: pevent = int(cudaEvent_t(event)) cyevent = pevent self._event._pvt_ptr[0] = cyevent - {{endif}} -{{endif}} -{{if 'cudaEventWaitNodeParams' in found_struct}} + cdef class cudaEventWaitNodeParams: """ @@ -18089,10 +17577,10 @@ cdef class cudaEventWaitNodeParams: Attributes ---------- - {{if 'cudaEventWaitNodeParams.event' in found_struct}} + event : cudaEvent_t The event to wait on from the node - {{endif}} + Methods ------- @@ -18106,9 +17594,9 @@ cdef class cudaEventWaitNodeParams: self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass - {{if 'cudaEventWaitNodeParams.event' in found_struct}} + self._event = cudaEvent_t(_ptr=&self._pvt_ptr[0].event) - {{endif}} + def __dealloc__(self): pass def getPtr(self): @@ -18116,16 +17604,16 @@ cdef class cudaEventWaitNodeParams: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaEventWaitNodeParams.event' in found_struct}} + try: str_list += ['event : ' + str(self.event)] except ValueError: str_list += ['event : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaEventWaitNodeParams.event' in found_struct}} + @property def event(self): return self._event @@ -18141,9 +17629,7 @@ cdef class cudaEventWaitNodeParams: pevent = int(cudaEvent_t(event)) cyevent = pevent self._event._pvt_ptr[0] = cyevent - {{endif}} -{{endif}} -{{if 'cudaGraphNodeParams' in found_struct}} + cdef class cudaGraphNodeParams: """ @@ -18151,70 +17637,70 @@ cdef class cudaGraphNodeParams: Attributes ---------- - {{if 'cudaGraphNodeParams.type' in found_struct}} + type : cudaGraphNodeType Type of the node - {{endif}} - {{if 'cudaGraphNodeParams.reserved0' in found_struct}} + + reserved0 : list[int] Reserved. Must be zero. - {{endif}} - {{if 'cudaGraphNodeParams.reserved1' in found_struct}} + + reserved1 : list[long long] Padding. Unused bytes must be zero. - {{endif}} - {{if 'cudaGraphNodeParams.kernel' in found_struct}} + + kernel : cudaKernelNodeParamsV2 Kernel node parameters. - {{endif}} - {{if 'cudaGraphNodeParams.memcpy' in found_struct}} + + memcpy : cudaMemcpyNodeParams Memcpy node parameters. - {{endif}} - {{if 'cudaGraphNodeParams.memset' in found_struct}} + + memset : cudaMemsetParamsV2 Memset node parameters. - {{endif}} - {{if 'cudaGraphNodeParams.host' in found_struct}} + + host : cudaHostNodeParamsV2 Host node parameters. - {{endif}} - {{if 'cudaGraphNodeParams.graph' in found_struct}} + + graph : cudaChildGraphNodeParams Child graph node parameters. - {{endif}} - {{if 'cudaGraphNodeParams.eventWait' in found_struct}} + + eventWait : cudaEventWaitNodeParams Event wait node parameters. - {{endif}} - {{if 'cudaGraphNodeParams.eventRecord' in found_struct}} + + eventRecord : cudaEventRecordNodeParams Event record node parameters. - {{endif}} - {{if 'cudaGraphNodeParams.extSemSignal' in found_struct}} + + extSemSignal : cudaExternalSemaphoreSignalNodeParamsV2 External semaphore signal node parameters. - {{endif}} - {{if 'cudaGraphNodeParams.extSemWait' in found_struct}} + + extSemWait : cudaExternalSemaphoreWaitNodeParamsV2 External semaphore wait node parameters. - {{endif}} - {{if 'cudaGraphNodeParams.alloc' in found_struct}} + + alloc : cudaMemAllocNodeParamsV2 Memory allocation node parameters. - {{endif}} - {{if 'cudaGraphNodeParams.free' in found_struct}} + + free : cudaMemFreeNodeParams Memory free node parameters. - {{endif}} - {{if 'cudaGraphNodeParams.conditional' in found_struct}} + + conditional : cudaConditionalNodeParams Conditional node parameters. - {{endif}} - {{if 'cudaGraphNodeParams.reserved2' in found_struct}} + + reserved2 : long long Reserved bytes. Must be zero. - {{endif}} + Methods ------- @@ -18229,42 +17715,42 @@ cdef class cudaGraphNodeParams: self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass - {{if 'cudaGraphNodeParams.kernel' in found_struct}} + self._kernel = cudaKernelNodeParamsV2(_ptr=&self._pvt_ptr[0].kernel) - {{endif}} - {{if 'cudaGraphNodeParams.memcpy' in found_struct}} + + self._memcpy = cudaMemcpyNodeParams(_ptr=&self._pvt_ptr[0].memcpy) - {{endif}} - {{if 'cudaGraphNodeParams.memset' in found_struct}} + + self._memset = cudaMemsetParamsV2(_ptr=&self._pvt_ptr[0].memset) - {{endif}} - {{if 'cudaGraphNodeParams.host' in found_struct}} + + self._host = cudaHostNodeParamsV2(_ptr=&self._pvt_ptr[0].host) - {{endif}} - {{if 'cudaGraphNodeParams.graph' in found_struct}} + + self._graph = cudaChildGraphNodeParams(_ptr=&self._pvt_ptr[0].graph) - {{endif}} - {{if 'cudaGraphNodeParams.eventWait' in found_struct}} + + self._eventWait = cudaEventWaitNodeParams(_ptr=&self._pvt_ptr[0].eventWait) - {{endif}} - {{if 'cudaGraphNodeParams.eventRecord' in found_struct}} + + self._eventRecord = cudaEventRecordNodeParams(_ptr=&self._pvt_ptr[0].eventRecord) - {{endif}} - {{if 'cudaGraphNodeParams.extSemSignal' in found_struct}} + + self._extSemSignal = cudaExternalSemaphoreSignalNodeParamsV2(_ptr=&self._pvt_ptr[0].extSemSignal) - {{endif}} - {{if 'cudaGraphNodeParams.extSemWait' in found_struct}} + + self._extSemWait = cudaExternalSemaphoreWaitNodeParamsV2(_ptr=&self._pvt_ptr[0].extSemWait) - {{endif}} - {{if 'cudaGraphNodeParams.alloc' in found_struct}} + + self._alloc = cudaMemAllocNodeParamsV2(_ptr=&self._pvt_ptr[0].alloc) - {{endif}} - {{if 'cudaGraphNodeParams.free' in found_struct}} + + self._free = cudaMemFreeNodeParams(_ptr=&self._pvt_ptr[0].free) - {{endif}} - {{if 'cudaGraphNodeParams.conditional' in found_struct}} + + self._conditional = cudaConditionalNodeParams(_ptr=&self._pvt_ptr[0].conditional) - {{endif}} + def __dealloc__(self): if self._val_ptr is not NULL: free(self._val_ptr) @@ -18273,235 +17759,233 @@ cdef class cudaGraphNodeParams: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaGraphNodeParams.type' in found_struct}} + try: str_list += ['type : ' + str(self.type)] except ValueError: str_list += ['type : '] - {{endif}} - {{if 'cudaGraphNodeParams.reserved0' in found_struct}} + + try: str_list += ['reserved0 : ' + str(self.reserved0)] except ValueError: str_list += ['reserved0 : '] - {{endif}} - {{if 'cudaGraphNodeParams.reserved1' in found_struct}} + + try: str_list += ['reserved1 : ' + str(self.reserved1)] except ValueError: str_list += ['reserved1 : '] - {{endif}} - {{if 'cudaGraphNodeParams.kernel' in found_struct}} + + try: str_list += ['kernel :\n' + '\n'.join([' ' + line for line in str(self.kernel).splitlines()])] except ValueError: str_list += ['kernel : '] - {{endif}} - {{if 'cudaGraphNodeParams.memcpy' in found_struct}} + + try: str_list += ['memcpy :\n' + '\n'.join([' ' + line for line in str(self.memcpy).splitlines()])] except ValueError: str_list += ['memcpy : '] - {{endif}} - {{if 'cudaGraphNodeParams.memset' in found_struct}} + + try: str_list += ['memset :\n' + '\n'.join([' ' + line for line in str(self.memset).splitlines()])] except ValueError: str_list += ['memset : '] - {{endif}} - {{if 'cudaGraphNodeParams.host' in found_struct}} + + try: str_list += ['host :\n' + '\n'.join([' ' + line for line in str(self.host).splitlines()])] except ValueError: str_list += ['host : '] - {{endif}} - {{if 'cudaGraphNodeParams.graph' in found_struct}} + + try: str_list += ['graph :\n' + '\n'.join([' ' + line for line in str(self.graph).splitlines()])] except ValueError: str_list += ['graph : '] - {{endif}} - {{if 'cudaGraphNodeParams.eventWait' in found_struct}} + + try: str_list += ['eventWait :\n' + '\n'.join([' ' + line for line in str(self.eventWait).splitlines()])] except ValueError: str_list += ['eventWait : '] - {{endif}} - {{if 'cudaGraphNodeParams.eventRecord' in found_struct}} + + try: str_list += ['eventRecord :\n' + '\n'.join([' ' + line for line in str(self.eventRecord).splitlines()])] except ValueError: str_list += ['eventRecord : '] - {{endif}} - {{if 'cudaGraphNodeParams.extSemSignal' in found_struct}} + + try: str_list += ['extSemSignal :\n' + '\n'.join([' ' + line for line in str(self.extSemSignal).splitlines()])] except ValueError: str_list += ['extSemSignal : '] - {{endif}} - {{if 'cudaGraphNodeParams.extSemWait' in found_struct}} + + try: str_list += ['extSemWait :\n' + '\n'.join([' ' + line for line in str(self.extSemWait).splitlines()])] except ValueError: str_list += ['extSemWait : '] - {{endif}} - {{if 'cudaGraphNodeParams.alloc' in found_struct}} + + try: str_list += ['alloc :\n' + '\n'.join([' ' + line for line in str(self.alloc).splitlines()])] except ValueError: str_list += ['alloc : '] - {{endif}} - {{if 'cudaGraphNodeParams.free' in found_struct}} + + try: str_list += ['free :\n' + '\n'.join([' ' + line for line in str(self.free).splitlines()])] except ValueError: str_list += ['free : '] - {{endif}} - {{if 'cudaGraphNodeParams.conditional' in found_struct}} + + try: str_list += ['conditional :\n' + '\n'.join([' ' + line for line in str(self.conditional).splitlines()])] except ValueError: str_list += ['conditional : '] - {{endif}} - {{if 'cudaGraphNodeParams.reserved2' in found_struct}} + + try: str_list += ['reserved2 : ' + str(self.reserved2)] except ValueError: str_list += ['reserved2 : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaGraphNodeParams.type' in found_struct}} + @property def type(self): return cudaGraphNodeType(self._pvt_ptr[0].type) @type.setter def type(self, type not None : cudaGraphNodeType): - self._pvt_ptr[0].type = int(type) - {{endif}} - {{if 'cudaGraphNodeParams.reserved0' in found_struct}} + self._pvt_ptr[0].type = int(type) + + @property def reserved0(self): return self._pvt_ptr[0].reserved0 @reserved0.setter def reserved0(self, reserved0): self._pvt_ptr[0].reserved0 = reserved0 - {{endif}} - {{if 'cudaGraphNodeParams.reserved1' in found_struct}} + + @property def reserved1(self): return self._pvt_ptr[0].reserved1 @reserved1.setter def reserved1(self, reserved1): self._pvt_ptr[0].reserved1 = reserved1 - {{endif}} - {{if 'cudaGraphNodeParams.kernel' in found_struct}} + + @property def kernel(self): return self._kernel @kernel.setter def kernel(self, kernel not None : cudaKernelNodeParamsV2): string.memcpy(&self._pvt_ptr[0].kernel, kernel.getPtr(), sizeof(self._pvt_ptr[0].kernel)) - {{endif}} - {{if 'cudaGraphNodeParams.memcpy' in found_struct}} + + @property def memcpy(self): return self._memcpy @memcpy.setter def memcpy(self, memcpy not None : cudaMemcpyNodeParams): string.memcpy(&self._pvt_ptr[0].memcpy, memcpy.getPtr(), sizeof(self._pvt_ptr[0].memcpy)) - {{endif}} - {{if 'cudaGraphNodeParams.memset' in found_struct}} + + @property def memset(self): return self._memset @memset.setter def memset(self, memset not None : cudaMemsetParamsV2): string.memcpy(&self._pvt_ptr[0].memset, memset.getPtr(), sizeof(self._pvt_ptr[0].memset)) - {{endif}} - {{if 'cudaGraphNodeParams.host' in found_struct}} + + @property def host(self): return self._host @host.setter def host(self, host not None : cudaHostNodeParamsV2): string.memcpy(&self._pvt_ptr[0].host, host.getPtr(), sizeof(self._pvt_ptr[0].host)) - {{endif}} - {{if 'cudaGraphNodeParams.graph' in found_struct}} + + @property def graph(self): return self._graph @graph.setter def graph(self, graph not None : cudaChildGraphNodeParams): string.memcpy(&self._pvt_ptr[0].graph, graph.getPtr(), sizeof(self._pvt_ptr[0].graph)) - {{endif}} - {{if 'cudaGraphNodeParams.eventWait' in found_struct}} + + @property def eventWait(self): return self._eventWait @eventWait.setter def eventWait(self, eventWait not None : cudaEventWaitNodeParams): string.memcpy(&self._pvt_ptr[0].eventWait, eventWait.getPtr(), sizeof(self._pvt_ptr[0].eventWait)) - {{endif}} - {{if 'cudaGraphNodeParams.eventRecord' in found_struct}} + + @property def eventRecord(self): return self._eventRecord @eventRecord.setter def eventRecord(self, eventRecord not None : cudaEventRecordNodeParams): string.memcpy(&self._pvt_ptr[0].eventRecord, eventRecord.getPtr(), sizeof(self._pvt_ptr[0].eventRecord)) - {{endif}} - {{if 'cudaGraphNodeParams.extSemSignal' in found_struct}} + + @property def extSemSignal(self): return self._extSemSignal @extSemSignal.setter def extSemSignal(self, extSemSignal not None : cudaExternalSemaphoreSignalNodeParamsV2): string.memcpy(&self._pvt_ptr[0].extSemSignal, extSemSignal.getPtr(), sizeof(self._pvt_ptr[0].extSemSignal)) - {{endif}} - {{if 'cudaGraphNodeParams.extSemWait' in found_struct}} + + @property def extSemWait(self): return self._extSemWait @extSemWait.setter def extSemWait(self, extSemWait not None : cudaExternalSemaphoreWaitNodeParamsV2): string.memcpy(&self._pvt_ptr[0].extSemWait, extSemWait.getPtr(), sizeof(self._pvt_ptr[0].extSemWait)) - {{endif}} - {{if 'cudaGraphNodeParams.alloc' in found_struct}} + + @property def alloc(self): return self._alloc @alloc.setter def alloc(self, alloc not None : cudaMemAllocNodeParamsV2): string.memcpy(&self._pvt_ptr[0].alloc, alloc.getPtr(), sizeof(self._pvt_ptr[0].alloc)) - {{endif}} - {{if 'cudaGraphNodeParams.free' in found_struct}} + + @property def free(self): return self._free @free.setter def free(self, free not None : cudaMemFreeNodeParams): string.memcpy(&self._pvt_ptr[0].free, free.getPtr(), sizeof(self._pvt_ptr[0].free)) - {{endif}} - {{if 'cudaGraphNodeParams.conditional' in found_struct}} + + @property def conditional(self): return self._conditional @conditional.setter def conditional(self, conditional not None : cudaConditionalNodeParams): string.memcpy(&self._pvt_ptr[0].conditional, conditional.getPtr(), sizeof(self._pvt_ptr[0].conditional)) - {{endif}} - {{if 'cudaGraphNodeParams.reserved2' in found_struct}} + + @property def reserved2(self): return self._pvt_ptr[0].reserved2 @reserved2.setter def reserved2(self, long long reserved2): self._pvt_ptr[0].reserved2 = reserved2 - {{endif}} -{{endif}} -{{if 'cudaGraphEdgeData_st' in found_struct}} + cdef class cudaGraphEdgeData_st: """ @@ -18512,7 +17996,7 @@ cdef class cudaGraphEdgeData_st: Attributes ---------- - {{if 'cudaGraphEdgeData_st.from_port' in found_struct}} + from_port : bytes This indicates when the dependency is triggered from the upstream node on the edge. The meaning is specfic to the node type. A value @@ -18523,8 +18007,8 @@ cdef class cudaGraphEdgeData_st: cudaGraphKernelNodePortDefault, cudaGraphKernelNodePortProgrammatic, or cudaGraphKernelNodePortLaunchCompletion. - {{endif}} - {{if 'cudaGraphEdgeData_st.to_port' in found_struct}} + + to_port : bytes This indicates what portion of the downstream node is dependent on the upstream node or portion thereof (indicated by `from_port`). @@ -18532,18 +18016,18 @@ cdef class cudaGraphEdgeData_st: means the entirety of the downstream node is dependent on the upstream work. Currently no node types define non-zero ports. Accordingly, this field must be set to zero. - {{endif}} - {{if 'cudaGraphEdgeData_st.type' in found_struct}} + + type : bytes This should be populated with a value from cudaGraphDependencyType. (It is typed as char due to compiler-specific layout of bitfields.) See cudaGraphDependencyType. - {{endif}} - {{if 'cudaGraphEdgeData_st.reserved' in found_struct}} + + reserved : bytes These bytes are unused and must be zeroed. This ensures compatibility if additional fields are added in the future. - {{endif}} + Methods ------- @@ -18564,58 +18048,58 @@ cdef class cudaGraphEdgeData_st: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaGraphEdgeData_st.from_port' in found_struct}} + try: str_list += ['from_port : ' + str(self.from_port)] except ValueError: str_list += ['from_port : '] - {{endif}} - {{if 'cudaGraphEdgeData_st.to_port' in found_struct}} + + try: str_list += ['to_port : ' + str(self.to_port)] except ValueError: str_list += ['to_port : '] - {{endif}} - {{if 'cudaGraphEdgeData_st.type' in found_struct}} + + try: str_list += ['type : ' + str(self.type)] except ValueError: str_list += ['type : '] - {{endif}} - {{if 'cudaGraphEdgeData_st.reserved' in found_struct}} + + try: str_list += ['reserved : ' + str(self.reserved)] except ValueError: str_list += ['reserved : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaGraphEdgeData_st.from_port' in found_struct}} + @property def from_port(self): return self._pvt_ptr[0].from_port @from_port.setter def from_port(self, unsigned char from_port): self._pvt_ptr[0].from_port = from_port - {{endif}} - {{if 'cudaGraphEdgeData_st.to_port' in found_struct}} + + @property def to_port(self): return self._pvt_ptr[0].to_port @to_port.setter def to_port(self, unsigned char to_port): self._pvt_ptr[0].to_port = to_port - {{endif}} - {{if 'cudaGraphEdgeData_st.type' in found_struct}} + + @property def type(self): return self._pvt_ptr[0].type @type.setter def type(self, unsigned char type): self._pvt_ptr[0].type = type - {{endif}} - {{if 'cudaGraphEdgeData_st.reserved' in found_struct}} + + @property def reserved(self): return PyBytes_FromStringAndSize(self._pvt_ptr[0].reserved, 5) @@ -18625,9 +18109,7 @@ cdef class cudaGraphEdgeData_st: raise ValueError("reserved length must be 5, is " + str(len(reserved))) for i, b in enumerate(reserved): self._pvt_ptr[0].reserved[i] = b - {{endif}} -{{endif}} -{{if 'cudaGraphInstantiateParams_st' in found_struct}} + cdef class cudaGraphInstantiateParams_st: """ @@ -18635,22 +18117,22 @@ cdef class cudaGraphInstantiateParams_st: Attributes ---------- - {{if 'cudaGraphInstantiateParams_st.flags' in found_struct}} + flags : unsigned long long Instantiation flags - {{endif}} - {{if 'cudaGraphInstantiateParams_st.uploadStream' in found_struct}} + + uploadStream : cudaStream_t Upload stream - {{endif}} - {{if 'cudaGraphInstantiateParams_st.errNode_out' in found_struct}} + + errNode_out : cudaGraphNode_t The node which caused instantiation to fail, if any - {{endif}} - {{if 'cudaGraphInstantiateParams_st.result_out' in found_struct}} + + result_out : cudaGraphInstantiateResult Whether instantiation was successful. If it failed, the reason why - {{endif}} + Methods ------- @@ -18664,12 +18146,12 @@ cdef class cudaGraphInstantiateParams_st: self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass - {{if 'cudaGraphInstantiateParams_st.uploadStream' in found_struct}} + self._uploadStream = cudaStream_t(_ptr=&self._pvt_ptr[0].uploadStream) - {{endif}} - {{if 'cudaGraphInstantiateParams_st.errNode_out' in found_struct}} + + self._errNode_out = cudaGraphNode_t(_ptr=&self._pvt_ptr[0].errNode_out) - {{endif}} + def __dealloc__(self): pass def getPtr(self): @@ -18677,42 +18159,42 @@ cdef class cudaGraphInstantiateParams_st: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaGraphInstantiateParams_st.flags' in found_struct}} + try: str_list += ['flags : ' + str(self.flags)] except ValueError: str_list += ['flags : '] - {{endif}} - {{if 'cudaGraphInstantiateParams_st.uploadStream' in found_struct}} + + try: str_list += ['uploadStream : ' + str(self.uploadStream)] except ValueError: str_list += ['uploadStream : '] - {{endif}} - {{if 'cudaGraphInstantiateParams_st.errNode_out' in found_struct}} + + try: str_list += ['errNode_out : ' + str(self.errNode_out)] except ValueError: str_list += ['errNode_out : '] - {{endif}} - {{if 'cudaGraphInstantiateParams_st.result_out' in found_struct}} + + try: str_list += ['result_out : ' + str(self.result_out)] except ValueError: str_list += ['result_out : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaGraphInstantiateParams_st.flags' in found_struct}} + @property def flags(self): return self._pvt_ptr[0].flags @flags.setter def flags(self, unsigned long long flags): self._pvt_ptr[0].flags = flags - {{endif}} - {{if 'cudaGraphInstantiateParams_st.uploadStream' in found_struct}} + + @property def uploadStream(self): return self._uploadStream @@ -18728,8 +18210,8 @@ cdef class cudaGraphInstantiateParams_st: puploadStream = int(cudaStream_t(uploadStream)) cyuploadStream = puploadStream self._uploadStream._pvt_ptr[0] = cyuploadStream - {{endif}} - {{if 'cudaGraphInstantiateParams_st.errNode_out' in found_struct}} + + @property def errNode_out(self): return self._errNode_out @@ -18745,17 +18227,15 @@ cdef class cudaGraphInstantiateParams_st: perrNode_out = int(cudaGraphNode_t(errNode_out)) cyerrNode_out = perrNode_out self._errNode_out._pvt_ptr[0] = cyerrNode_out - {{endif}} - {{if 'cudaGraphInstantiateParams_st.result_out' in found_struct}} + + @property def result_out(self): return cudaGraphInstantiateResult(self._pvt_ptr[0].result_out) @result_out.setter def result_out(self, result_out not None : cudaGraphInstantiateResult): - self._pvt_ptr[0].result_out = int(result_out) - {{endif}} -{{endif}} -{{if 'cudaGraphExecUpdateResultInfo_st' in found_struct}} + self._pvt_ptr[0].result_out = int(result_out) + cdef class cudaGraphExecUpdateResultInfo_st: """ @@ -18763,21 +18243,21 @@ cdef class cudaGraphExecUpdateResultInfo_st: Attributes ---------- - {{if 'cudaGraphExecUpdateResultInfo_st.result' in found_struct}} + result : cudaGraphExecUpdateResult Gives more specific detail when a cuda graph update fails. - {{endif}} - {{if 'cudaGraphExecUpdateResultInfo_st.errorNode' in found_struct}} + + errorNode : cudaGraphNode_t The "to node" of the error edge when the topologies do not match. The error node when the error is associated with a specific node. NULL when the error is generic. - {{endif}} - {{if 'cudaGraphExecUpdateResultInfo_st.errorFromNode' in found_struct}} + + errorFromNode : cudaGraphNode_t The from node of error edge when the topologies do not match. Otherwise NULL. - {{endif}} + Methods ------- @@ -18791,12 +18271,12 @@ cdef class cudaGraphExecUpdateResultInfo_st: self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass - {{if 'cudaGraphExecUpdateResultInfo_st.errorNode' in found_struct}} + self._errorNode = cudaGraphNode_t(_ptr=&self._pvt_ptr[0].errorNode) - {{endif}} - {{if 'cudaGraphExecUpdateResultInfo_st.errorFromNode' in found_struct}} + + self._errorFromNode = cudaGraphNode_t(_ptr=&self._pvt_ptr[0].errorFromNode) - {{endif}} + def __dealloc__(self): pass def getPtr(self): @@ -18804,36 +18284,36 @@ cdef class cudaGraphExecUpdateResultInfo_st: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaGraphExecUpdateResultInfo_st.result' in found_struct}} + try: str_list += ['result : ' + str(self.result)] except ValueError: str_list += ['result : '] - {{endif}} - {{if 'cudaGraphExecUpdateResultInfo_st.errorNode' in found_struct}} + + try: str_list += ['errorNode : ' + str(self.errorNode)] except ValueError: str_list += ['errorNode : '] - {{endif}} - {{if 'cudaGraphExecUpdateResultInfo_st.errorFromNode' in found_struct}} + + try: str_list += ['errorFromNode : ' + str(self.errorFromNode)] except ValueError: str_list += ['errorFromNode : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaGraphExecUpdateResultInfo_st.result' in found_struct}} + @property def result(self): return cudaGraphExecUpdateResult(self._pvt_ptr[0].result) @result.setter def result(self, result not None : cudaGraphExecUpdateResult): - self._pvt_ptr[0].result = int(result) - {{endif}} - {{if 'cudaGraphExecUpdateResultInfo_st.errorNode' in found_struct}} + self._pvt_ptr[0].result = int(result) + + @property def errorNode(self): return self._errorNode @@ -18849,8 +18329,8 @@ cdef class cudaGraphExecUpdateResultInfo_st: perrorNode = int(cudaGraphNode_t(errorNode)) cyerrorNode = perrorNode self._errorNode._pvt_ptr[0] = cyerrorNode - {{endif}} - {{if 'cudaGraphExecUpdateResultInfo_st.errorFromNode' in found_struct}} + + @property def errorFromNode(self): return self._errorFromNode @@ -18866,26 +18346,24 @@ cdef class cudaGraphExecUpdateResultInfo_st: perrorFromNode = int(cudaGraphNode_t(errorFromNode)) cyerrorFromNode = perrorFromNode self._errorFromNode._pvt_ptr[0] = cyerrorFromNode - {{endif}} -{{endif}} -{{if 'cudaGraphKernelNodeUpdate.updateData.param' in found_struct}} + cdef class anon_struct16: """ Attributes ---------- - {{if 'cudaGraphKernelNodeUpdate.updateData.param.pValue' in found_struct}} + pValue : Any - {{endif}} - {{if 'cudaGraphKernelNodeUpdate.updateData.param.offset' in found_struct}} + + offset : size_t - {{endif}} - {{if 'cudaGraphKernelNodeUpdate.updateData.param.size' in found_struct}} + + size : size_t - {{endif}} + Methods ------- @@ -18904,28 +18382,28 @@ cdef class anon_struct16: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaGraphKernelNodeUpdate.updateData.param.pValue' in found_struct}} + try: str_list += ['pValue : ' + hex(self.pValue)] except ValueError: str_list += ['pValue : '] - {{endif}} - {{if 'cudaGraphKernelNodeUpdate.updateData.param.offset' in found_struct}} + + try: str_list += ['offset : ' + str(self.offset)] except ValueError: str_list += ['offset : '] - {{endif}} - {{if 'cudaGraphKernelNodeUpdate.updateData.param.size' in found_struct}} + + try: str_list += ['size : ' + str(self.size)] except ValueError: str_list += ['size : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaGraphKernelNodeUpdate.updateData.param.pValue' in found_struct}} + @property def pValue(self): return self._pvt_ptr[0].updateData.param.pValue @@ -18933,42 +18411,40 @@ cdef class anon_struct16: def pValue(self, pValue): self._cypValue = _HelperInputVoidPtr(pValue) self._pvt_ptr[0].updateData.param.pValue = self._cypValue.cptr - {{endif}} - {{if 'cudaGraphKernelNodeUpdate.updateData.param.offset' in found_struct}} + + @property def offset(self): return self._pvt_ptr[0].updateData.param.offset @offset.setter def offset(self, size_t offset): self._pvt_ptr[0].updateData.param.offset = offset - {{endif}} - {{if 'cudaGraphKernelNodeUpdate.updateData.param.size' in found_struct}} + + @property def size(self): return self._pvt_ptr[0].updateData.param.size @size.setter def size(self, size_t size): self._pvt_ptr[0].updateData.param.size = size - {{endif}} -{{endif}} -{{if 'cudaGraphKernelNodeUpdate.updateData' in found_struct}} + cdef class anon_union10: """ Attributes ---------- - {{if 'cudaGraphKernelNodeUpdate.updateData.gridDim' in found_struct}} + gridDim : dim3 - {{endif}} - {{if 'cudaGraphKernelNodeUpdate.updateData.param' in found_struct}} - param : anon_struct16 - {{endif}} - {{if 'cudaGraphKernelNodeUpdate.updateData.isEnabled' in found_struct}} + + param : anon_struct16 + + + isEnabled : unsigned int - {{endif}} + Methods ------- @@ -18980,12 +18456,12 @@ cdef class anon_union10: def __init__(self, void_ptr _ptr): pass - {{if 'cudaGraphKernelNodeUpdate.updateData.gridDim' in found_struct}} + self._gridDim = dim3(_ptr=&self._pvt_ptr[0].updateData.gridDim) - {{endif}} - {{if 'cudaGraphKernelNodeUpdate.updateData.param' in found_struct}} + + self._param = anon_struct16(_ptr=self._pvt_ptr) - {{endif}} + def __dealloc__(self): pass def getPtr(self): @@ -18993,53 +18469,51 @@ cdef class anon_union10: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaGraphKernelNodeUpdate.updateData.gridDim' in found_struct}} + try: str_list += ['gridDim :\n' + '\n'.join([' ' + line for line in str(self.gridDim).splitlines()])] except ValueError: str_list += ['gridDim : '] - {{endif}} - {{if 'cudaGraphKernelNodeUpdate.updateData.param' in found_struct}} + + try: str_list += ['param :\n' + '\n'.join([' ' + line for line in str(self.param).splitlines()])] except ValueError: str_list += ['param : '] - {{endif}} - {{if 'cudaGraphKernelNodeUpdate.updateData.isEnabled' in found_struct}} + + try: str_list += ['isEnabled : ' + str(self.isEnabled)] except ValueError: str_list += ['isEnabled : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaGraphKernelNodeUpdate.updateData.gridDim' in found_struct}} + @property def gridDim(self): return self._gridDim @gridDim.setter def gridDim(self, gridDim not None : dim3): string.memcpy(&self._pvt_ptr[0].updateData.gridDim, gridDim.getPtr(), sizeof(self._pvt_ptr[0].updateData.gridDim)) - {{endif}} - {{if 'cudaGraphKernelNodeUpdate.updateData.param' in found_struct}} + + @property def param(self): return self._param @param.setter def param(self, param not None : anon_struct16): string.memcpy(&self._pvt_ptr[0].updateData.param, param.getPtr(), sizeof(self._pvt_ptr[0].updateData.param)) - {{endif}} - {{if 'cudaGraphKernelNodeUpdate.updateData.isEnabled' in found_struct}} + + @property def isEnabled(self): return self._pvt_ptr[0].updateData.isEnabled @isEnabled.setter def isEnabled(self, unsigned int isEnabled): self._pvt_ptr[0].updateData.isEnabled = isEnabled - {{endif}} -{{endif}} -{{if 'cudaGraphKernelNodeUpdate' in found_struct}} + cdef class cudaGraphKernelNodeUpdate: """ @@ -19048,19 +18522,19 @@ cdef class cudaGraphKernelNodeUpdate: Attributes ---------- - {{if 'cudaGraphKernelNodeUpdate.node' in found_struct}} + node : cudaGraphDeviceNode_t Node to update - {{endif}} - {{if 'cudaGraphKernelNodeUpdate.field' in found_struct}} + + field : cudaGraphKernelNodeField Which type of update to apply. Determines how updateData is interpreted - {{endif}} - {{if 'cudaGraphKernelNodeUpdate.updateData' in found_struct}} + + updateData : anon_union10 Update data to apply. Which field is used depends on field's value - {{endif}} + Methods ------- @@ -19075,12 +18549,12 @@ cdef class cudaGraphKernelNodeUpdate: self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass - {{if 'cudaGraphKernelNodeUpdate.node' in found_struct}} + self._node = cudaGraphDeviceNode_t(_ptr=&self._pvt_ptr[0].node) - {{endif}} - {{if 'cudaGraphKernelNodeUpdate.updateData' in found_struct}} + + self._updateData = anon_union10(_ptr=self._pvt_ptr) - {{endif}} + def __dealloc__(self): if self._val_ptr is not NULL: free(self._val_ptr) @@ -19089,28 +18563,28 @@ cdef class cudaGraphKernelNodeUpdate: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaGraphKernelNodeUpdate.node' in found_struct}} + try: str_list += ['node : ' + str(self.node)] except ValueError: str_list += ['node : '] - {{endif}} - {{if 'cudaGraphKernelNodeUpdate.field' in found_struct}} + + try: str_list += ['field : ' + str(self.field)] except ValueError: str_list += ['field : '] - {{endif}} - {{if 'cudaGraphKernelNodeUpdate.updateData' in found_struct}} + + try: str_list += ['updateData :\n' + '\n'.join([' ' + line for line in str(self.updateData).splitlines()])] except ValueError: str_list += ['updateData : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaGraphKernelNodeUpdate.node' in found_struct}} + @property def node(self): return self._node @@ -19126,25 +18600,23 @@ cdef class cudaGraphKernelNodeUpdate: pnode = int(cudaGraphDeviceNode_t(node)) cynode = pnode self._node._pvt_ptr[0] = cynode - {{endif}} - {{if 'cudaGraphKernelNodeUpdate.field' in found_struct}} + + @property def field(self): return cudaGraphKernelNodeField(self._pvt_ptr[0].field) @field.setter def field(self, field not None : cudaGraphKernelNodeField): - self._pvt_ptr[0].field = int(field) - {{endif}} - {{if 'cudaGraphKernelNodeUpdate.updateData' in found_struct}} + self._pvt_ptr[0].field = int(field) + + @property def updateData(self): return self._updateData @updateData.setter def updateData(self, updateData not None : anon_union10): string.memcpy(&self._pvt_ptr[0].updateData, updateData.getPtr(), sizeof(self._pvt_ptr[0].updateData)) - {{endif}} -{{endif}} -{{if 'cudaLaunchMemSyncDomainMap_st' in found_struct}} + cdef class cudaLaunchMemSyncDomainMap_st: """ @@ -19158,14 +18630,14 @@ cdef class cudaLaunchMemSyncDomainMap_st: Attributes ---------- - {{if 'cudaLaunchMemSyncDomainMap_st.default_' in found_struct}} + default_ : bytes The default domain ID to use for designated kernels - {{endif}} - {{if 'cudaLaunchMemSyncDomainMap_st.remote' in found_struct}} + + remote : bytes The remote domain ID to use for designated kernels - {{endif}} + Methods ------- @@ -19186,56 +18658,54 @@ cdef class cudaLaunchMemSyncDomainMap_st: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaLaunchMemSyncDomainMap_st.default_' in found_struct}} + try: str_list += ['default_ : ' + str(self.default_)] except ValueError: str_list += ['default_ : '] - {{endif}} - {{if 'cudaLaunchMemSyncDomainMap_st.remote' in found_struct}} + + try: str_list += ['remote : ' + str(self.remote)] except ValueError: str_list += ['remote : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaLaunchMemSyncDomainMap_st.default_' in found_struct}} + @property def default_(self): return self._pvt_ptr[0].default_ @default_.setter def default_(self, unsigned char default_): self._pvt_ptr[0].default_ = default_ - {{endif}} - {{if 'cudaLaunchMemSyncDomainMap_st.remote' in found_struct}} + + @property def remote(self): return self._pvt_ptr[0].remote @remote.setter def remote(self, unsigned char remote): self._pvt_ptr[0].remote = remote - {{endif}} -{{endif}} -{{if 'cudaLaunchAttributeValue.clusterDim' in found_struct}} + cdef class anon_struct17: """ Attributes ---------- - {{if 'cudaLaunchAttributeValue.clusterDim.x' in found_struct}} + x : unsigned int - {{endif}} - {{if 'cudaLaunchAttributeValue.clusterDim.y' in found_struct}} + + y : unsigned int - {{endif}} - {{if 'cudaLaunchAttributeValue.clusterDim.z' in found_struct}} + + z : unsigned int - {{endif}} + Methods ------- @@ -19254,70 +18724,68 @@ cdef class anon_struct17: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaLaunchAttributeValue.clusterDim.x' in found_struct}} + try: str_list += ['x : ' + str(self.x)] except ValueError: str_list += ['x : '] - {{endif}} - {{if 'cudaLaunchAttributeValue.clusterDim.y' in found_struct}} + + try: str_list += ['y : ' + str(self.y)] except ValueError: str_list += ['y : '] - {{endif}} - {{if 'cudaLaunchAttributeValue.clusterDim.z' in found_struct}} + + try: str_list += ['z : ' + str(self.z)] except ValueError: str_list += ['z : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaLaunchAttributeValue.clusterDim.x' in found_struct}} + @property def x(self): return self._pvt_ptr[0].clusterDim.x @x.setter def x(self, unsigned int x): self._pvt_ptr[0].clusterDim.x = x - {{endif}} - {{if 'cudaLaunchAttributeValue.clusterDim.y' in found_struct}} + + @property def y(self): return self._pvt_ptr[0].clusterDim.y @y.setter def y(self, unsigned int y): self._pvt_ptr[0].clusterDim.y = y - {{endif}} - {{if 'cudaLaunchAttributeValue.clusterDim.z' in found_struct}} + + @property def z(self): return self._pvt_ptr[0].clusterDim.z @z.setter def z(self, unsigned int z): self._pvt_ptr[0].clusterDim.z = z - {{endif}} -{{endif}} -{{if 'cudaLaunchAttributeValue.programmaticEvent' in found_struct}} + cdef class anon_struct18: """ Attributes ---------- - {{if 'cudaLaunchAttributeValue.programmaticEvent.event' in found_struct}} + event : cudaEvent_t - {{endif}} - {{if 'cudaLaunchAttributeValue.programmaticEvent.flags' in found_struct}} + + flags : int - {{endif}} - {{if 'cudaLaunchAttributeValue.programmaticEvent.triggerAtBlockStart' in found_struct}} + + triggerAtBlockStart : int - {{endif}} + Methods ------- @@ -19329,9 +18797,9 @@ cdef class anon_struct18: def __init__(self, void_ptr _ptr): pass - {{if 'cudaLaunchAttributeValue.programmaticEvent.event' in found_struct}} + self._event = cudaEvent_t(_ptr=&self._pvt_ptr[0].programmaticEvent.event) - {{endif}} + def __dealloc__(self): pass def getPtr(self): @@ -19339,28 +18807,28 @@ cdef class anon_struct18: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaLaunchAttributeValue.programmaticEvent.event' in found_struct}} + try: str_list += ['event : ' + str(self.event)] except ValueError: str_list += ['event : '] - {{endif}} - {{if 'cudaLaunchAttributeValue.programmaticEvent.flags' in found_struct}} + + try: str_list += ['flags : ' + str(self.flags)] except ValueError: str_list += ['flags : '] - {{endif}} - {{if 'cudaLaunchAttributeValue.programmaticEvent.triggerAtBlockStart' in found_struct}} + + try: str_list += ['triggerAtBlockStart : ' + str(self.triggerAtBlockStart)] except ValueError: str_list += ['triggerAtBlockStart : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaLaunchAttributeValue.programmaticEvent.event' in found_struct}} + @property def event(self): return self._event @@ -19376,42 +18844,40 @@ cdef class anon_struct18: pevent = int(cudaEvent_t(event)) cyevent = pevent self._event._pvt_ptr[0] = cyevent - {{endif}} - {{if 'cudaLaunchAttributeValue.programmaticEvent.flags' in found_struct}} + + @property def flags(self): return self._pvt_ptr[0].programmaticEvent.flags @flags.setter def flags(self, int flags): self._pvt_ptr[0].programmaticEvent.flags = flags - {{endif}} - {{if 'cudaLaunchAttributeValue.programmaticEvent.triggerAtBlockStart' in found_struct}} + + @property def triggerAtBlockStart(self): return self._pvt_ptr[0].programmaticEvent.triggerAtBlockStart @triggerAtBlockStart.setter def triggerAtBlockStart(self, int triggerAtBlockStart): self._pvt_ptr[0].programmaticEvent.triggerAtBlockStart = triggerAtBlockStart - {{endif}} -{{endif}} -{{if 'cudaLaunchAttributeValue.preferredClusterDim' in found_struct}} + cdef class anon_struct19: """ Attributes ---------- - {{if 'cudaLaunchAttributeValue.preferredClusterDim.x' in found_struct}} + x : unsigned int - {{endif}} - {{if 'cudaLaunchAttributeValue.preferredClusterDim.y' in found_struct}} + + y : unsigned int - {{endif}} - {{if 'cudaLaunchAttributeValue.preferredClusterDim.z' in found_struct}} + + z : unsigned int - {{endif}} + Methods ------- @@ -19430,66 +18896,64 @@ cdef class anon_struct19: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaLaunchAttributeValue.preferredClusterDim.x' in found_struct}} + try: str_list += ['x : ' + str(self.x)] except ValueError: str_list += ['x : '] - {{endif}} - {{if 'cudaLaunchAttributeValue.preferredClusterDim.y' in found_struct}} + + try: str_list += ['y : ' + str(self.y)] except ValueError: str_list += ['y : '] - {{endif}} - {{if 'cudaLaunchAttributeValue.preferredClusterDim.z' in found_struct}} + + try: str_list += ['z : ' + str(self.z)] except ValueError: str_list += ['z : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaLaunchAttributeValue.preferredClusterDim.x' in found_struct}} + @property def x(self): return self._pvt_ptr[0].preferredClusterDim.x @x.setter def x(self, unsigned int x): self._pvt_ptr[0].preferredClusterDim.x = x - {{endif}} - {{if 'cudaLaunchAttributeValue.preferredClusterDim.y' in found_struct}} + + @property def y(self): return self._pvt_ptr[0].preferredClusterDim.y @y.setter def y(self, unsigned int y): self._pvt_ptr[0].preferredClusterDim.y = y - {{endif}} - {{if 'cudaLaunchAttributeValue.preferredClusterDim.z' in found_struct}} + + @property def z(self): return self._pvt_ptr[0].preferredClusterDim.z @z.setter def z(self, unsigned int z): self._pvt_ptr[0].preferredClusterDim.z = z - {{endif}} -{{endif}} -{{if 'cudaLaunchAttributeValue.launchCompletionEvent' in found_struct}} + cdef class anon_struct20: """ Attributes ---------- - {{if 'cudaLaunchAttributeValue.launchCompletionEvent.event' in found_struct}} + event : cudaEvent_t - {{endif}} - {{if 'cudaLaunchAttributeValue.launchCompletionEvent.flags' in found_struct}} + + flags : int - {{endif}} + Methods ------- @@ -19501,9 +18965,9 @@ cdef class anon_struct20: def __init__(self, void_ptr _ptr): pass - {{if 'cudaLaunchAttributeValue.launchCompletionEvent.event' in found_struct}} + self._event = cudaEvent_t(_ptr=&self._pvt_ptr[0].launchCompletionEvent.event) - {{endif}} + def __dealloc__(self): pass def getPtr(self): @@ -19511,22 +18975,22 @@ cdef class anon_struct20: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaLaunchAttributeValue.launchCompletionEvent.event' in found_struct}} + try: str_list += ['event : ' + str(self.event)] except ValueError: str_list += ['event : '] - {{endif}} - {{if 'cudaLaunchAttributeValue.launchCompletionEvent.flags' in found_struct}} + + try: str_list += ['flags : ' + str(self.flags)] except ValueError: str_list += ['flags : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaLaunchAttributeValue.launchCompletionEvent.event' in found_struct}} + @property def event(self): return self._event @@ -19542,30 +19006,28 @@ cdef class anon_struct20: pevent = int(cudaEvent_t(event)) cyevent = pevent self._event._pvt_ptr[0] = cyevent - {{endif}} - {{if 'cudaLaunchAttributeValue.launchCompletionEvent.flags' in found_struct}} + + @property def flags(self): return self._pvt_ptr[0].launchCompletionEvent.flags @flags.setter def flags(self, int flags): self._pvt_ptr[0].launchCompletionEvent.flags = flags - {{endif}} -{{endif}} -{{if 'cudaLaunchAttributeValue.deviceUpdatableKernelNode' in found_struct}} + cdef class anon_struct21: """ Attributes ---------- - {{if 'cudaLaunchAttributeValue.deviceUpdatableKernelNode.deviceUpdatable' in found_struct}} + deviceUpdatable : int - {{endif}} - {{if 'cudaLaunchAttributeValue.deviceUpdatableKernelNode.devNode' in found_struct}} + + devNode : cudaGraphDeviceNode_t - {{endif}} + Methods ------- @@ -19577,9 +19039,9 @@ cdef class anon_struct21: def __init__(self, void_ptr _ptr): pass - {{if 'cudaLaunchAttributeValue.deviceUpdatableKernelNode.devNode' in found_struct}} + self._devNode = cudaGraphDeviceNode_t(_ptr=&self._pvt_ptr[0].deviceUpdatableKernelNode.devNode) - {{endif}} + def __dealloc__(self): pass def getPtr(self): @@ -19587,30 +19049,30 @@ cdef class anon_struct21: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaLaunchAttributeValue.deviceUpdatableKernelNode.deviceUpdatable' in found_struct}} + try: str_list += ['deviceUpdatable : ' + str(self.deviceUpdatable)] except ValueError: str_list += ['deviceUpdatable : '] - {{endif}} - {{if 'cudaLaunchAttributeValue.deviceUpdatableKernelNode.devNode' in found_struct}} + + try: str_list += ['devNode : ' + str(self.devNode)] except ValueError: str_list += ['devNode : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaLaunchAttributeValue.deviceUpdatableKernelNode.deviceUpdatable' in found_struct}} + @property def deviceUpdatable(self): return self._pvt_ptr[0].deviceUpdatableKernelNode.deviceUpdatable @deviceUpdatable.setter def deviceUpdatable(self, int deviceUpdatable): self._pvt_ptr[0].deviceUpdatableKernelNode.deviceUpdatable = deviceUpdatable - {{endif}} - {{if 'cudaLaunchAttributeValue.deviceUpdatableKernelNode.devNode' in found_struct}} + + @property def devNode(self): return self._devNode @@ -19626,9 +19088,7 @@ cdef class anon_struct21: pdevNode = int(cudaGraphDeviceNode_t(devNode)) cydevNode = pdevNode self._devNode._pvt_ptr[0] = cydevNode - {{endif}} -{{endif}} -{{if 'cudaLaunchAttributeValue' in found_struct}} + cdef class cudaLaunchAttributeValue: """ @@ -19636,25 +19096,25 @@ cdef class cudaLaunchAttributeValue: Attributes ---------- - {{if 'cudaLaunchAttributeValue.pad' in found_struct}} + pad : bytes - {{endif}} - {{if 'cudaLaunchAttributeValue.accessPolicyWindow' in found_struct}} + + accessPolicyWindow : cudaAccessPolicyWindow Value of launch attribute cudaLaunchAttributeAccessPolicyWindow. - {{endif}} - {{if 'cudaLaunchAttributeValue.cooperative' in found_struct}} + + cooperative : int Value of launch attribute cudaLaunchAttributeCooperative. Nonzero indicates a cooperative kernel (see cudaLaunchCooperativeKernel). - {{endif}} - {{if 'cudaLaunchAttributeValue.syncPolicy' in found_struct}} + + syncPolicy : cudaSynchronizationPolicy Value of launch attribute cudaLaunchAttributeSynchronizationPolicy. cudaSynchronizationPolicy for work queued up in this stream. - {{endif}} - {{if 'cudaLaunchAttributeValue.clusterDim' in found_struct}} + + clusterDim : anon_struct17 Value of launch attribute cudaLaunchAttributeClusterDimension that represents the desired cluster dimensions for the kernel. Opaque @@ -19663,19 +19123,19 @@ cdef class cudaLaunchAttributeValue: `y` - The Y dimension of the cluster, in blocks. Must be a divisor of the grid Y dimension. - `z` - The Z dimension of the cluster, in blocks. Must be a divisor of the grid Z dimension. - {{endif}} - {{if 'cudaLaunchAttributeValue.clusterSchedulingPolicyPreference' in found_struct}} + + clusterSchedulingPolicyPreference : cudaClusterSchedulingPolicy Value of launch attribute cudaLaunchAttributeClusterSchedulingPolicyPreference. Cluster scheduling policy preference for the kernel. - {{endif}} - {{if 'cudaLaunchAttributeValue.programmaticStreamSerializationAllowed' in found_struct}} + + programmaticStreamSerializationAllowed : int Value of launch attribute cudaLaunchAttributeProgrammaticStreamSerialization. - {{endif}} - {{if 'cudaLaunchAttributeValue.programmaticEvent' in found_struct}} + + programmaticEvent : anon_struct18 Value of launch attribute cudaLaunchAttributeProgrammaticEvent with the following fields: - `cudaEvent_t` event - Event to fire when @@ -19683,23 +19143,23 @@ cdef class cudaLaunchAttributeValue: cudaEventRecordWithFlags. Does not accept cudaEventRecordExternal. - `int` triggerAtBlockStart - If this is set to non-0, each block launch will automatically trigger the event. - {{endif}} - {{if 'cudaLaunchAttributeValue.priority' in found_struct}} + + priority : int Value of launch attribute cudaLaunchAttributePriority. Execution priority of the kernel. - {{endif}} - {{if 'cudaLaunchAttributeValue.memSyncDomainMap' in found_struct}} + + memSyncDomainMap : cudaLaunchMemSyncDomainMap Value of launch attribute cudaLaunchAttributeMemSyncDomainMap. See cudaLaunchMemSyncDomainMap. - {{endif}} - {{if 'cudaLaunchAttributeValue.memSyncDomain' in found_struct}} + + memSyncDomain : cudaLaunchMemSyncDomain Value of launch attribute cudaLaunchAttributeMemSyncDomain. See cudaLaunchMemSyncDomain. - {{endif}} - {{if 'cudaLaunchAttributeValue.preferredClusterDim' in found_struct}} + + preferredClusterDim : anon_struct19 Value of launch attribute cudaLaunchAttributePreferredClusterDimension that represents the @@ -19713,16 +19173,16 @@ cdef class cudaLaunchAttributeValue: ::cudaLaunchAttributeValue::clusterDim. - `z` - The Z dimension of the preferred cluster, in blocks. Must be equal to the `z` field of ::cudaLaunchAttributeValue::clusterDim. - {{endif}} - {{if 'cudaLaunchAttributeValue.launchCompletionEvent' in found_struct}} + + launchCompletionEvent : anon_struct20 Value of launch attribute cudaLaunchAttributeLaunchCompletionEvent with the following fields: - `cudaEvent_t` event - Event to fire when the last block launches. - `int` flags - Event record flags, see cudaEventRecordWithFlags. Does not accept cudaEventRecordExternal. - {{endif}} - {{if 'cudaLaunchAttributeValue.deviceUpdatableKernelNode' in found_struct}} + + deviceUpdatableKernelNode : anon_struct21 Value of launch attribute cudaLaunchAttributeDeviceUpdatableKernelNode with the following @@ -19730,27 +19190,27 @@ cdef class cudaLaunchAttributeValue: kernel node should be device-updatable. - `cudaGraphDeviceNode_t` devNode - Returns a handle to pass to the various device-side update functions. - {{endif}} - {{if 'cudaLaunchAttributeValue.sharedMemCarveout' in found_struct}} + + sharedMemCarveout : unsigned int Value of launch attribute cudaLaunchAttributePreferredSharedMemoryCarveout. - {{endif}} - {{if 'cudaLaunchAttributeValue.nvlinkUtilCentricScheduling' in found_struct}} + + nvlinkUtilCentricScheduling : unsigned int Value of launch attribute cudaLaunchAttributeNvlinkUtilCentricScheduling. - {{endif}} - {{if 'cudaLaunchAttributeValue.portableClusterSizeMode' in found_struct}} + + portableClusterSizeMode : cudaLaunchAttributePortableClusterMode Value of launch attribute cudaLaunchAttributePortableClusterSizeMode - {{endif}} - {{if 'cudaLaunchAttributeValue.sharedMemoryMode' in found_struct}} + + sharedMemoryMode : cudaSharedMemoryMode Value of launch attribute cudaLaunchAttributeSharedMemoryMode. See cudaSharedMemoryMode for acceptable values. - {{endif}} + Methods ------- @@ -19764,27 +19224,27 @@ cdef class cudaLaunchAttributeValue: self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass - {{if 'cudaLaunchAttributeValue.accessPolicyWindow' in found_struct}} + self._accessPolicyWindow = cudaAccessPolicyWindow(_ptr=&self._pvt_ptr[0].accessPolicyWindow) - {{endif}} - {{if 'cudaLaunchAttributeValue.clusterDim' in found_struct}} + + self._clusterDim = anon_struct17(_ptr=self._pvt_ptr) - {{endif}} - {{if 'cudaLaunchAttributeValue.programmaticEvent' in found_struct}} + + self._programmaticEvent = anon_struct18(_ptr=self._pvt_ptr) - {{endif}} - {{if 'cudaLaunchAttributeValue.memSyncDomainMap' in found_struct}} + + self._memSyncDomainMap = cudaLaunchMemSyncDomainMap(_ptr=&self._pvt_ptr[0].memSyncDomainMap) - {{endif}} - {{if 'cudaLaunchAttributeValue.preferredClusterDim' in found_struct}} + + self._preferredClusterDim = anon_struct19(_ptr=self._pvt_ptr) - {{endif}} - {{if 'cudaLaunchAttributeValue.launchCompletionEvent' in found_struct}} + + self._launchCompletionEvent = anon_struct20(_ptr=self._pvt_ptr) - {{endif}} - {{if 'cudaLaunchAttributeValue.deviceUpdatableKernelNode' in found_struct}} + + self._deviceUpdatableKernelNode = anon_struct21(_ptr=self._pvt_ptr) - {{endif}} + def __dealloc__(self): pass def getPtr(self): @@ -19792,118 +19252,118 @@ cdef class cudaLaunchAttributeValue: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaLaunchAttributeValue.pad' in found_struct}} + try: str_list += ['pad : ' + str(self.pad)] except ValueError: str_list += ['pad : '] - {{endif}} - {{if 'cudaLaunchAttributeValue.accessPolicyWindow' in found_struct}} + + try: str_list += ['accessPolicyWindow :\n' + '\n'.join([' ' + line for line in str(self.accessPolicyWindow).splitlines()])] except ValueError: str_list += ['accessPolicyWindow : '] - {{endif}} - {{if 'cudaLaunchAttributeValue.cooperative' in found_struct}} + + try: str_list += ['cooperative : ' + str(self.cooperative)] except ValueError: str_list += ['cooperative : '] - {{endif}} - {{if 'cudaLaunchAttributeValue.syncPolicy' in found_struct}} + + try: str_list += ['syncPolicy : ' + str(self.syncPolicy)] except ValueError: str_list += ['syncPolicy : '] - {{endif}} - {{if 'cudaLaunchAttributeValue.clusterDim' in found_struct}} + + try: str_list += ['clusterDim :\n' + '\n'.join([' ' + line for line in str(self.clusterDim).splitlines()])] except ValueError: str_list += ['clusterDim : '] - {{endif}} - {{if 'cudaLaunchAttributeValue.clusterSchedulingPolicyPreference' in found_struct}} + + try: str_list += ['clusterSchedulingPolicyPreference : ' + str(self.clusterSchedulingPolicyPreference)] except ValueError: str_list += ['clusterSchedulingPolicyPreference : '] - {{endif}} - {{if 'cudaLaunchAttributeValue.programmaticStreamSerializationAllowed' in found_struct}} + + try: str_list += ['programmaticStreamSerializationAllowed : ' + str(self.programmaticStreamSerializationAllowed)] except ValueError: str_list += ['programmaticStreamSerializationAllowed : '] - {{endif}} - {{if 'cudaLaunchAttributeValue.programmaticEvent' in found_struct}} + + try: str_list += ['programmaticEvent :\n' + '\n'.join([' ' + line for line in str(self.programmaticEvent).splitlines()])] except ValueError: str_list += ['programmaticEvent : '] - {{endif}} - {{if 'cudaLaunchAttributeValue.priority' in found_struct}} + + try: str_list += ['priority : ' + str(self.priority)] except ValueError: str_list += ['priority : '] - {{endif}} - {{if 'cudaLaunchAttributeValue.memSyncDomainMap' in found_struct}} + + try: str_list += ['memSyncDomainMap :\n' + '\n'.join([' ' + line for line in str(self.memSyncDomainMap).splitlines()])] except ValueError: str_list += ['memSyncDomainMap : '] - {{endif}} - {{if 'cudaLaunchAttributeValue.memSyncDomain' in found_struct}} + + try: str_list += ['memSyncDomain : ' + str(self.memSyncDomain)] except ValueError: str_list += ['memSyncDomain : '] - {{endif}} - {{if 'cudaLaunchAttributeValue.preferredClusterDim' in found_struct}} + + try: str_list += ['preferredClusterDim :\n' + '\n'.join([' ' + line for line in str(self.preferredClusterDim).splitlines()])] except ValueError: str_list += ['preferredClusterDim : '] - {{endif}} - {{if 'cudaLaunchAttributeValue.launchCompletionEvent' in found_struct}} + + try: str_list += ['launchCompletionEvent :\n' + '\n'.join([' ' + line for line in str(self.launchCompletionEvent).splitlines()])] except ValueError: str_list += ['launchCompletionEvent : '] - {{endif}} - {{if 'cudaLaunchAttributeValue.deviceUpdatableKernelNode' in found_struct}} + + try: str_list += ['deviceUpdatableKernelNode :\n' + '\n'.join([' ' + line for line in str(self.deviceUpdatableKernelNode).splitlines()])] except ValueError: str_list += ['deviceUpdatableKernelNode : '] - {{endif}} - {{if 'cudaLaunchAttributeValue.sharedMemCarveout' in found_struct}} + + try: str_list += ['sharedMemCarveout : ' + str(self.sharedMemCarveout)] except ValueError: str_list += ['sharedMemCarveout : '] - {{endif}} - {{if 'cudaLaunchAttributeValue.nvlinkUtilCentricScheduling' in found_struct}} + + try: str_list += ['nvlinkUtilCentricScheduling : ' + str(self.nvlinkUtilCentricScheduling)] except ValueError: str_list += ['nvlinkUtilCentricScheduling : '] - {{endif}} - {{if 'cudaLaunchAttributeValue.portableClusterSizeMode' in found_struct}} + + try: str_list += ['portableClusterSizeMode : ' + str(self.portableClusterSizeMode)] except ValueError: str_list += ['portableClusterSizeMode : '] - {{endif}} - {{if 'cudaLaunchAttributeValue.sharedMemoryMode' in found_struct}} + + try: str_list += ['sharedMemoryMode : ' + str(self.sharedMemoryMode)] except ValueError: str_list += ['sharedMemoryMode : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaLaunchAttributeValue.pad' in found_struct}} + @property def pad(self): return PyBytes_FromStringAndSize(self._pvt_ptr[0].pad, 64) @@ -19921,145 +19381,143 @@ cdef class cudaLaunchAttributeValue: if b > 127 and b < 256: b = b - 256 self._pvt_ptr[0].pad[i] = b - {{endif}} - {{if 'cudaLaunchAttributeValue.accessPolicyWindow' in found_struct}} + + @property def accessPolicyWindow(self): return self._accessPolicyWindow @accessPolicyWindow.setter def accessPolicyWindow(self, accessPolicyWindow not None : cudaAccessPolicyWindow): string.memcpy(&self._pvt_ptr[0].accessPolicyWindow, accessPolicyWindow.getPtr(), sizeof(self._pvt_ptr[0].accessPolicyWindow)) - {{endif}} - {{if 'cudaLaunchAttributeValue.cooperative' in found_struct}} + + @property def cooperative(self): return self._pvt_ptr[0].cooperative @cooperative.setter def cooperative(self, int cooperative): self._pvt_ptr[0].cooperative = cooperative - {{endif}} - {{if 'cudaLaunchAttributeValue.syncPolicy' in found_struct}} + + @property def syncPolicy(self): return cudaSynchronizationPolicy(self._pvt_ptr[0].syncPolicy) @syncPolicy.setter def syncPolicy(self, syncPolicy not None : cudaSynchronizationPolicy): - self._pvt_ptr[0].syncPolicy = int(syncPolicy) - {{endif}} - {{if 'cudaLaunchAttributeValue.clusterDim' in found_struct}} + self._pvt_ptr[0].syncPolicy = int(syncPolicy) + + @property def clusterDim(self): return self._clusterDim @clusterDim.setter def clusterDim(self, clusterDim not None : anon_struct17): string.memcpy(&self._pvt_ptr[0].clusterDim, clusterDim.getPtr(), sizeof(self._pvt_ptr[0].clusterDim)) - {{endif}} - {{if 'cudaLaunchAttributeValue.clusterSchedulingPolicyPreference' in found_struct}} + + @property def clusterSchedulingPolicyPreference(self): return cudaClusterSchedulingPolicy(self._pvt_ptr[0].clusterSchedulingPolicyPreference) @clusterSchedulingPolicyPreference.setter def clusterSchedulingPolicyPreference(self, clusterSchedulingPolicyPreference not None : cudaClusterSchedulingPolicy): - self._pvt_ptr[0].clusterSchedulingPolicyPreference = int(clusterSchedulingPolicyPreference) - {{endif}} - {{if 'cudaLaunchAttributeValue.programmaticStreamSerializationAllowed' in found_struct}} + self._pvt_ptr[0].clusterSchedulingPolicyPreference = int(clusterSchedulingPolicyPreference) + + @property def programmaticStreamSerializationAllowed(self): return self._pvt_ptr[0].programmaticStreamSerializationAllowed @programmaticStreamSerializationAllowed.setter def programmaticStreamSerializationAllowed(self, int programmaticStreamSerializationAllowed): self._pvt_ptr[0].programmaticStreamSerializationAllowed = programmaticStreamSerializationAllowed - {{endif}} - {{if 'cudaLaunchAttributeValue.programmaticEvent' in found_struct}} + + @property def programmaticEvent(self): return self._programmaticEvent @programmaticEvent.setter def programmaticEvent(self, programmaticEvent not None : anon_struct18): string.memcpy(&self._pvt_ptr[0].programmaticEvent, programmaticEvent.getPtr(), sizeof(self._pvt_ptr[0].programmaticEvent)) - {{endif}} - {{if 'cudaLaunchAttributeValue.priority' in found_struct}} + + @property def priority(self): return self._pvt_ptr[0].priority @priority.setter def priority(self, int priority): self._pvt_ptr[0].priority = priority - {{endif}} - {{if 'cudaLaunchAttributeValue.memSyncDomainMap' in found_struct}} + + @property def memSyncDomainMap(self): return self._memSyncDomainMap @memSyncDomainMap.setter def memSyncDomainMap(self, memSyncDomainMap not None : cudaLaunchMemSyncDomainMap): string.memcpy(&self._pvt_ptr[0].memSyncDomainMap, memSyncDomainMap.getPtr(), sizeof(self._pvt_ptr[0].memSyncDomainMap)) - {{endif}} - {{if 'cudaLaunchAttributeValue.memSyncDomain' in found_struct}} + + @property def memSyncDomain(self): return cudaLaunchMemSyncDomain(self._pvt_ptr[0].memSyncDomain) @memSyncDomain.setter def memSyncDomain(self, memSyncDomain not None : cudaLaunchMemSyncDomain): - self._pvt_ptr[0].memSyncDomain = int(memSyncDomain) - {{endif}} - {{if 'cudaLaunchAttributeValue.preferredClusterDim' in found_struct}} + self._pvt_ptr[0].memSyncDomain = int(memSyncDomain) + + @property def preferredClusterDim(self): return self._preferredClusterDim @preferredClusterDim.setter def preferredClusterDim(self, preferredClusterDim not None : anon_struct19): string.memcpy(&self._pvt_ptr[0].preferredClusterDim, preferredClusterDim.getPtr(), sizeof(self._pvt_ptr[0].preferredClusterDim)) - {{endif}} - {{if 'cudaLaunchAttributeValue.launchCompletionEvent' in found_struct}} + + @property def launchCompletionEvent(self): return self._launchCompletionEvent @launchCompletionEvent.setter def launchCompletionEvent(self, launchCompletionEvent not None : anon_struct20): string.memcpy(&self._pvt_ptr[0].launchCompletionEvent, launchCompletionEvent.getPtr(), sizeof(self._pvt_ptr[0].launchCompletionEvent)) - {{endif}} - {{if 'cudaLaunchAttributeValue.deviceUpdatableKernelNode' in found_struct}} + + @property def deviceUpdatableKernelNode(self): return self._deviceUpdatableKernelNode @deviceUpdatableKernelNode.setter def deviceUpdatableKernelNode(self, deviceUpdatableKernelNode not None : anon_struct21): string.memcpy(&self._pvt_ptr[0].deviceUpdatableKernelNode, deviceUpdatableKernelNode.getPtr(), sizeof(self._pvt_ptr[0].deviceUpdatableKernelNode)) - {{endif}} - {{if 'cudaLaunchAttributeValue.sharedMemCarveout' in found_struct}} + + @property def sharedMemCarveout(self): return self._pvt_ptr[0].sharedMemCarveout @sharedMemCarveout.setter def sharedMemCarveout(self, unsigned int sharedMemCarveout): self._pvt_ptr[0].sharedMemCarveout = sharedMemCarveout - {{endif}} - {{if 'cudaLaunchAttributeValue.nvlinkUtilCentricScheduling' in found_struct}} + + @property def nvlinkUtilCentricScheduling(self): return self._pvt_ptr[0].nvlinkUtilCentricScheduling @nvlinkUtilCentricScheduling.setter def nvlinkUtilCentricScheduling(self, unsigned int nvlinkUtilCentricScheduling): self._pvt_ptr[0].nvlinkUtilCentricScheduling = nvlinkUtilCentricScheduling - {{endif}} - {{if 'cudaLaunchAttributeValue.portableClusterSizeMode' in found_struct}} + + @property def portableClusterSizeMode(self): return cudaLaunchAttributePortableClusterMode(self._pvt_ptr[0].portableClusterSizeMode) @portableClusterSizeMode.setter def portableClusterSizeMode(self, portableClusterSizeMode not None : cudaLaunchAttributePortableClusterMode): - self._pvt_ptr[0].portableClusterSizeMode = int(portableClusterSizeMode) - {{endif}} - {{if 'cudaLaunchAttributeValue.sharedMemoryMode' in found_struct}} + self._pvt_ptr[0].portableClusterSizeMode = int(portableClusterSizeMode) + + @property def sharedMemoryMode(self): return cudaSharedMemoryMode(self._pvt_ptr[0].sharedMemoryMode) @sharedMemoryMode.setter def sharedMemoryMode(self, sharedMemoryMode not None : cudaSharedMemoryMode): - self._pvt_ptr[0].sharedMemoryMode = int(sharedMemoryMode) - {{endif}} -{{endif}} -{{if 'cudaLaunchAttribute_st' in found_struct}} + self._pvt_ptr[0].sharedMemoryMode = int(sharedMemoryMode) + cdef class cudaLaunchAttribute_st: """ @@ -20067,14 +19525,14 @@ cdef class cudaLaunchAttribute_st: Attributes ---------- - {{if 'cudaLaunchAttribute_st.id' in found_struct}} + id : cudaLaunchAttributeID Attribute to set - {{endif}} - {{if 'cudaLaunchAttribute_st.val' in found_struct}} + + val : cudaLaunchAttributeValue Value of the attribute - {{endif}} + Methods ------- @@ -20088,9 +19546,9 @@ cdef class cudaLaunchAttribute_st: self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass - {{if 'cudaLaunchAttribute_st.val' in found_struct}} + self._val = cudaLaunchAttributeValue(_ptr=&self._pvt_ptr[0].val) - {{endif}} + def __dealloc__(self): pass def getPtr(self): @@ -20098,48 +19556,46 @@ cdef class cudaLaunchAttribute_st: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaLaunchAttribute_st.id' in found_struct}} + try: str_list += ['id : ' + str(self.id)] except ValueError: str_list += ['id : '] - {{endif}} - {{if 'cudaLaunchAttribute_st.val' in found_struct}} + + try: str_list += ['val :\n' + '\n'.join([' ' + line for line in str(self.val).splitlines()])] except ValueError: str_list += ['val : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaLaunchAttribute_st.id' in found_struct}} + @property def id(self): return cudaLaunchAttributeID(self._pvt_ptr[0].id) @id.setter def id(self, id not None : cudaLaunchAttributeID): - self._pvt_ptr[0].id = int(id) - {{endif}} - {{if 'cudaLaunchAttribute_st.val' in found_struct}} + self._pvt_ptr[0].id = int(id) + + @property def val(self): return self._val @val.setter def val(self, val not None : cudaLaunchAttributeValue): string.memcpy(&self._pvt_ptr[0].val, val.getPtr(), sizeof(self._pvt_ptr[0].val)) - {{endif}} -{{endif}} -{{if 'cudaAsyncNotificationInfo.info.overBudget' in found_struct}} + cdef class anon_struct22: """ Attributes ---------- - {{if 'cudaAsyncNotificationInfo.info.overBudget.bytesOverBudget' in found_struct}} + bytesOverBudget : unsigned long long - {{endif}} + Methods ------- @@ -20158,34 +19614,32 @@ cdef class anon_struct22: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaAsyncNotificationInfo.info.overBudget.bytesOverBudget' in found_struct}} + try: str_list += ['bytesOverBudget : ' + str(self.bytesOverBudget)] except ValueError: str_list += ['bytesOverBudget : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaAsyncNotificationInfo.info.overBudget.bytesOverBudget' in found_struct}} + @property def bytesOverBudget(self): return self._pvt_ptr[0].info.overBudget.bytesOverBudget @bytesOverBudget.setter def bytesOverBudget(self, unsigned long long bytesOverBudget): self._pvt_ptr[0].info.overBudget.bytesOverBudget = bytesOverBudget - {{endif}} -{{endif}} -{{if 'cudaAsyncNotificationInfo.info' in found_struct}} + cdef class anon_union11: """ Attributes ---------- - {{if 'cudaAsyncNotificationInfo.info.overBudget' in found_struct}} + overBudget : anon_struct22 - {{endif}} + Methods ------- @@ -20197,9 +19651,9 @@ cdef class anon_union11: def __init__(self, void_ptr _ptr): pass - {{if 'cudaAsyncNotificationInfo.info.overBudget' in found_struct}} + self._overBudget = anon_struct22(_ptr=self._pvt_ptr) - {{endif}} + def __dealloc__(self): pass def getPtr(self): @@ -20207,25 +19661,23 @@ cdef class anon_union11: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaAsyncNotificationInfo.info.overBudget' in found_struct}} + try: str_list += ['overBudget :\n' + '\n'.join([' ' + line for line in str(self.overBudget).splitlines()])] except ValueError: str_list += ['overBudget : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaAsyncNotificationInfo.info.overBudget' in found_struct}} + @property def overBudget(self): return self._overBudget @overBudget.setter def overBudget(self, overBudget not None : anon_struct22): string.memcpy(&self._pvt_ptr[0].info.overBudget, overBudget.getPtr(), sizeof(self._pvt_ptr[0].info.overBudget)) - {{endif}} -{{endif}} -{{if 'cudaAsyncNotificationInfo' in found_struct}} + cdef class cudaAsyncNotificationInfo: """ @@ -20233,15 +19685,15 @@ cdef class cudaAsyncNotificationInfo: Attributes ---------- - {{if 'cudaAsyncNotificationInfo.type' in found_struct}} + type : cudaAsyncNotificationType The type of notification being sent - {{endif}} - {{if 'cudaAsyncNotificationInfo.info' in found_struct}} + + info : anon_union11 Information about the notification. `typename` must be checked in order to interpret this field. - {{endif}} + Methods ------- @@ -20256,9 +19708,9 @@ cdef class cudaAsyncNotificationInfo: self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass - {{if 'cudaAsyncNotificationInfo.info' in found_struct}} + self._info = anon_union11(_ptr=self._pvt_ptr) - {{endif}} + def __dealloc__(self): if self._val_ptr is not NULL: free(self._val_ptr) @@ -20267,39 +19719,37 @@ cdef class cudaAsyncNotificationInfo: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaAsyncNotificationInfo.type' in found_struct}} + try: str_list += ['type : ' + str(self.type)] except ValueError: str_list += ['type : '] - {{endif}} - {{if 'cudaAsyncNotificationInfo.info' in found_struct}} + + try: str_list += ['info :\n' + '\n'.join([' ' + line for line in str(self.info).splitlines()])] except ValueError: str_list += ['info : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaAsyncNotificationInfo.type' in found_struct}} + @property def type(self): return cudaAsyncNotificationType(self._pvt_ptr[0].type) @type.setter def type(self, type not None : cudaAsyncNotificationType): - self._pvt_ptr[0].type = int(type) - {{endif}} - {{if 'cudaAsyncNotificationInfo.info' in found_struct}} + self._pvt_ptr[0].type = int(type) + + @property def info(self): return self._info @info.setter def info(self, info not None : anon_union11): string.memcpy(&self._pvt_ptr[0].info, info.getPtr(), sizeof(self._pvt_ptr[0].info)) - {{endif}} -{{endif}} -{{if 'cudaTextureDesc' in found_struct}} + cdef class cudaTextureDesc: """ @@ -20307,58 +19757,58 @@ cdef class cudaTextureDesc: Attributes ---------- - {{if 'cudaTextureDesc.addressMode' in found_struct}} + addressMode : list[cudaTextureAddressMode] Texture address mode for up to 3 dimensions - {{endif}} - {{if 'cudaTextureDesc.filterMode' in found_struct}} + + filterMode : cudaTextureFilterMode Texture filter mode - {{endif}} - {{if 'cudaTextureDesc.readMode' in found_struct}} + + readMode : cudaTextureReadMode Texture read mode - {{endif}} - {{if 'cudaTextureDesc.sRGB' in found_struct}} + + sRGB : int Perform sRGB->linear conversion during texture read - {{endif}} - {{if 'cudaTextureDesc.borderColor' in found_struct}} + + borderColor : list[float] Texture Border Color - {{endif}} - {{if 'cudaTextureDesc.normalizedCoords' in found_struct}} + + normalizedCoords : int Indicates whether texture reads are normalized or not - {{endif}} - {{if 'cudaTextureDesc.maxAnisotropy' in found_struct}} + + maxAnisotropy : unsigned int Limit to the anisotropy ratio - {{endif}} - {{if 'cudaTextureDesc.mipmapFilterMode' in found_struct}} + + mipmapFilterMode : cudaTextureFilterMode Mipmap filter mode - {{endif}} - {{if 'cudaTextureDesc.mipmapLevelBias' in found_struct}} + + mipmapLevelBias : float Offset applied to the supplied mipmap level - {{endif}} - {{if 'cudaTextureDesc.minMipmapLevelClamp' in found_struct}} + + minMipmapLevelClamp : float Lower end of the mipmap level range to clamp access to - {{endif}} - {{if 'cudaTextureDesc.maxMipmapLevelClamp' in found_struct}} + + maxMipmapLevelClamp : float Upper end of the mipmap level range to clamp access to - {{endif}} - {{if 'cudaTextureDesc.disableTrilinearOptimization' in found_struct}} + + disableTrilinearOptimization : int Disable any trilinear filtering optimizations. - {{endif}} - {{if 'cudaTextureDesc.seamlessCubemap' in found_struct}} + + seamlessCubemap : int Enable seamless cube map filtering. - {{endif}} + Methods ------- @@ -20379,193 +19829,191 @@ cdef class cudaTextureDesc: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaTextureDesc.addressMode' in found_struct}} + try: str_list += ['addressMode : ' + str(self.addressMode)] except ValueError: str_list += ['addressMode : '] - {{endif}} - {{if 'cudaTextureDesc.filterMode' in found_struct}} + + try: str_list += ['filterMode : ' + str(self.filterMode)] except ValueError: str_list += ['filterMode : '] - {{endif}} - {{if 'cudaTextureDesc.readMode' in found_struct}} + + try: str_list += ['readMode : ' + str(self.readMode)] except ValueError: str_list += ['readMode : '] - {{endif}} - {{if 'cudaTextureDesc.sRGB' in found_struct}} + + try: str_list += ['sRGB : ' + str(self.sRGB)] except ValueError: str_list += ['sRGB : '] - {{endif}} - {{if 'cudaTextureDesc.borderColor' in found_struct}} + + try: str_list += ['borderColor : ' + str(self.borderColor)] except ValueError: str_list += ['borderColor : '] - {{endif}} - {{if 'cudaTextureDesc.normalizedCoords' in found_struct}} + + try: str_list += ['normalizedCoords : ' + str(self.normalizedCoords)] except ValueError: str_list += ['normalizedCoords : '] - {{endif}} - {{if 'cudaTextureDesc.maxAnisotropy' in found_struct}} + + try: str_list += ['maxAnisotropy : ' + str(self.maxAnisotropy)] except ValueError: str_list += ['maxAnisotropy : '] - {{endif}} - {{if 'cudaTextureDesc.mipmapFilterMode' in found_struct}} + + try: str_list += ['mipmapFilterMode : ' + str(self.mipmapFilterMode)] except ValueError: str_list += ['mipmapFilterMode : '] - {{endif}} - {{if 'cudaTextureDesc.mipmapLevelBias' in found_struct}} + + try: str_list += ['mipmapLevelBias : ' + str(self.mipmapLevelBias)] except ValueError: str_list += ['mipmapLevelBias : '] - {{endif}} - {{if 'cudaTextureDesc.minMipmapLevelClamp' in found_struct}} + + try: str_list += ['minMipmapLevelClamp : ' + str(self.minMipmapLevelClamp)] except ValueError: str_list += ['minMipmapLevelClamp : '] - {{endif}} - {{if 'cudaTextureDesc.maxMipmapLevelClamp' in found_struct}} + + try: str_list += ['maxMipmapLevelClamp : ' + str(self.maxMipmapLevelClamp)] except ValueError: str_list += ['maxMipmapLevelClamp : '] - {{endif}} - {{if 'cudaTextureDesc.disableTrilinearOptimization' in found_struct}} + + try: str_list += ['disableTrilinearOptimization : ' + str(self.disableTrilinearOptimization)] except ValueError: str_list += ['disableTrilinearOptimization : '] - {{endif}} - {{if 'cudaTextureDesc.seamlessCubemap' in found_struct}} + + try: str_list += ['seamlessCubemap : ' + str(self.seamlessCubemap)] except ValueError: str_list += ['seamlessCubemap : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaTextureDesc.addressMode' in found_struct}} + @property def addressMode(self): return [cudaTextureAddressMode(_x) for _x in list(self._pvt_ptr[0].addressMode)] @addressMode.setter def addressMode(self, addressMode): self._pvt_ptr[0].addressMode = [int(_x) for _x in addressMode] - {{endif}} - {{if 'cudaTextureDesc.filterMode' in found_struct}} + + @property def filterMode(self): return cudaTextureFilterMode(self._pvt_ptr[0].filterMode) @filterMode.setter def filterMode(self, filterMode not None : cudaTextureFilterMode): - self._pvt_ptr[0].filterMode = int(filterMode) - {{endif}} - {{if 'cudaTextureDesc.readMode' in found_struct}} + self._pvt_ptr[0].filterMode = int(filterMode) + + @property def readMode(self): return cudaTextureReadMode(self._pvt_ptr[0].readMode) @readMode.setter def readMode(self, readMode not None : cudaTextureReadMode): - self._pvt_ptr[0].readMode = int(readMode) - {{endif}} - {{if 'cudaTextureDesc.sRGB' in found_struct}} + self._pvt_ptr[0].readMode = int(readMode) + + @property def sRGB(self): return self._pvt_ptr[0].sRGB @sRGB.setter def sRGB(self, int sRGB): self._pvt_ptr[0].sRGB = sRGB - {{endif}} - {{if 'cudaTextureDesc.borderColor' in found_struct}} + + @property def borderColor(self): return self._pvt_ptr[0].borderColor @borderColor.setter def borderColor(self, borderColor): self._pvt_ptr[0].borderColor = borderColor - {{endif}} - {{if 'cudaTextureDesc.normalizedCoords' in found_struct}} + + @property def normalizedCoords(self): return self._pvt_ptr[0].normalizedCoords @normalizedCoords.setter def normalizedCoords(self, int normalizedCoords): self._pvt_ptr[0].normalizedCoords = normalizedCoords - {{endif}} - {{if 'cudaTextureDesc.maxAnisotropy' in found_struct}} + + @property def maxAnisotropy(self): return self._pvt_ptr[0].maxAnisotropy @maxAnisotropy.setter def maxAnisotropy(self, unsigned int maxAnisotropy): self._pvt_ptr[0].maxAnisotropy = maxAnisotropy - {{endif}} - {{if 'cudaTextureDesc.mipmapFilterMode' in found_struct}} + + @property def mipmapFilterMode(self): return cudaTextureFilterMode(self._pvt_ptr[0].mipmapFilterMode) @mipmapFilterMode.setter def mipmapFilterMode(self, mipmapFilterMode not None : cudaTextureFilterMode): - self._pvt_ptr[0].mipmapFilterMode = int(mipmapFilterMode) - {{endif}} - {{if 'cudaTextureDesc.mipmapLevelBias' in found_struct}} + self._pvt_ptr[0].mipmapFilterMode = int(mipmapFilterMode) + + @property def mipmapLevelBias(self): return self._pvt_ptr[0].mipmapLevelBias @mipmapLevelBias.setter def mipmapLevelBias(self, float mipmapLevelBias): self._pvt_ptr[0].mipmapLevelBias = mipmapLevelBias - {{endif}} - {{if 'cudaTextureDesc.minMipmapLevelClamp' in found_struct}} + + @property def minMipmapLevelClamp(self): return self._pvt_ptr[0].minMipmapLevelClamp @minMipmapLevelClamp.setter def minMipmapLevelClamp(self, float minMipmapLevelClamp): self._pvt_ptr[0].minMipmapLevelClamp = minMipmapLevelClamp - {{endif}} - {{if 'cudaTextureDesc.maxMipmapLevelClamp' in found_struct}} + + @property def maxMipmapLevelClamp(self): return self._pvt_ptr[0].maxMipmapLevelClamp @maxMipmapLevelClamp.setter def maxMipmapLevelClamp(self, float maxMipmapLevelClamp): self._pvt_ptr[0].maxMipmapLevelClamp = maxMipmapLevelClamp - {{endif}} - {{if 'cudaTextureDesc.disableTrilinearOptimization' in found_struct}} + + @property def disableTrilinearOptimization(self): return self._pvt_ptr[0].disableTrilinearOptimization @disableTrilinearOptimization.setter def disableTrilinearOptimization(self, int disableTrilinearOptimization): self._pvt_ptr[0].disableTrilinearOptimization = disableTrilinearOptimization - {{endif}} - {{if 'cudaTextureDesc.seamlessCubemap' in found_struct}} + + @property def seamlessCubemap(self): return self._pvt_ptr[0].seamlessCubemap @seamlessCubemap.setter def seamlessCubemap(self, int seamlessCubemap): self._pvt_ptr[0].seamlessCubemap = seamlessCubemap - {{endif}} -{{endif}} -{{if 'cudaGraphRecaptureCallbackData' in found_struct}} + cdef class cudaGraphRecaptureCallbackData: """ @@ -20574,14 +20022,14 @@ cdef class cudaGraphRecaptureCallbackData: Attributes ---------- - {{if 'cudaGraphRecaptureCallbackData.callbackFunc' in found_struct}} + callbackFunc : cudaGraphRecaptureCallback_t Callback function that will be invoked - {{endif}} - {{if 'cudaGraphRecaptureCallbackData.userData' in found_struct}} + + userData : Any Generic pointer that is passed to the callback function - {{endif}} + Methods ------- @@ -20595,9 +20043,9 @@ cdef class cudaGraphRecaptureCallbackData: self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass - {{if 'cudaGraphRecaptureCallbackData.callbackFunc' in found_struct}} + self._callbackFunc = cudaGraphRecaptureCallback_t(_ptr=&self._pvt_ptr[0].callbackFunc) - {{endif}} + def __dealloc__(self): pass def getPtr(self): @@ -20605,22 +20053,22 @@ cdef class cudaGraphRecaptureCallbackData: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'cudaGraphRecaptureCallbackData.callbackFunc' in found_struct}} + try: str_list += ['callbackFunc : ' + str(self.callbackFunc)] except ValueError: str_list += ['callbackFunc : '] - {{endif}} - {{if 'cudaGraphRecaptureCallbackData.userData' in found_struct}} + + try: str_list += ['userData : ' + hex(self.userData)] except ValueError: str_list += ['userData : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if 'cudaGraphRecaptureCallbackData.callbackFunc' in found_struct}} + @property def callbackFunc(self): return self._callbackFunc @@ -20636,8 +20084,8 @@ cdef class cudaGraphRecaptureCallbackData: pcallbackFunc = int(cudaGraphRecaptureCallback_t(callbackFunc)) cycallbackFunc = pcallbackFunc self._callbackFunc._pvt_ptr[0] = cycallbackFunc - {{endif}} - {{if 'cudaGraphRecaptureCallbackData.userData' in found_struct}} + + @property def userData(self): return self._pvt_ptr[0].userData @@ -20645,9 +20093,7 @@ cdef class cudaGraphRecaptureCallbackData: def userData(self, userData): self._cyuserData = _HelperInputVoidPtr(userData) self._pvt_ptr[0].userData = self._cyuserData.cptr - {{endif}} -{{endif}} -{{if True}} + cdef class cudaEglPlaneDesc_st: """ @@ -20656,34 +20102,34 @@ cdef class cudaEglPlaneDesc_st: Attributes ---------- - {{if True}} + width : unsigned int Width of plane - {{endif}} - {{if True}} + + height : unsigned int Height of plane - {{endif}} - {{if True}} + + depth : unsigned int Depth of plane - {{endif}} - {{if True}} + + pitch : unsigned int Pitch of plane - {{endif}} - {{if True}} + + numChannels : unsigned int Number of channels for the plane - {{endif}} - {{if True}} + + channelDesc : cudaChannelFormatDesc Channel Format Descriptor - {{endif}} - {{if True}} + + reserved : list[unsigned int] Reserved for future use - {{endif}} + Methods ------- @@ -20697,9 +20143,9 @@ cdef class cudaEglPlaneDesc_st: self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass - {{if True}} + self._channelDesc = cudaChannelFormatDesc(_ptr=&self._pvt_ptr[0].channelDesc) - {{endif}} + def __dealloc__(self): pass def getPtr(self): @@ -20707,122 +20153,120 @@ cdef class cudaEglPlaneDesc_st: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if True}} + try: str_list += ['width : ' + str(self.width)] except ValueError: str_list += ['width : '] - {{endif}} - {{if True}} + + try: str_list += ['height : ' + str(self.height)] except ValueError: str_list += ['height : '] - {{endif}} - {{if True}} + + try: str_list += ['depth : ' + str(self.depth)] except ValueError: str_list += ['depth : '] - {{endif}} - {{if True}} + + try: str_list += ['pitch : ' + str(self.pitch)] except ValueError: str_list += ['pitch : '] - {{endif}} - {{if True}} + + try: str_list += ['numChannels : ' + str(self.numChannels)] except ValueError: str_list += ['numChannels : '] - {{endif}} - {{if True}} + + try: str_list += ['channelDesc :\n' + '\n'.join([' ' + line for line in str(self.channelDesc).splitlines()])] except ValueError: str_list += ['channelDesc : '] - {{endif}} - {{if True}} + + try: str_list += ['reserved : ' + str(self.reserved)] except ValueError: str_list += ['reserved : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if True}} + @property def width(self): return self._pvt_ptr[0].width @width.setter def width(self, unsigned int width): self._pvt_ptr[0].width = width - {{endif}} - {{if True}} + + @property def height(self): return self._pvt_ptr[0].height @height.setter def height(self, unsigned int height): self._pvt_ptr[0].height = height - {{endif}} - {{if True}} + + @property def depth(self): return self._pvt_ptr[0].depth @depth.setter def depth(self, unsigned int depth): self._pvt_ptr[0].depth = depth - {{endif}} - {{if True}} + + @property def pitch(self): return self._pvt_ptr[0].pitch @pitch.setter def pitch(self, unsigned int pitch): self._pvt_ptr[0].pitch = pitch - {{endif}} - {{if True}} + + @property def numChannels(self): return self._pvt_ptr[0].numChannels @numChannels.setter def numChannels(self, unsigned int numChannels): self._pvt_ptr[0].numChannels = numChannels - {{endif}} - {{if True}} + + @property def channelDesc(self): return self._channelDesc @channelDesc.setter def channelDesc(self, channelDesc not None : cudaChannelFormatDesc): string.memcpy(&self._pvt_ptr[0].channelDesc, channelDesc.getPtr(), sizeof(self._pvt_ptr[0].channelDesc)) - {{endif}} - {{if True}} + + @property def reserved(self): return self._pvt_ptr[0].reserved @reserved.setter def reserved(self, reserved): self._pvt_ptr[0].reserved = reserved - {{endif}} -{{endif}} -{{if True}} + cdef class anon_union12: """ Attributes ---------- - {{if True}} + pArray : list[cudaArray_t] - {{endif}} - {{if True}} + + pPitch : list[cudaPitchedPtr] - {{endif}} + Methods ------- @@ -20841,22 +20285,22 @@ cdef class anon_union12: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if True}} + try: str_list += ['pArray : ' + str(self.pArray)] except ValueError: str_list += ['pArray : '] - {{endif}} - {{if True}} + + try: str_list += ['pPitch :\n' + '\n'.join([' ' + line for line in str(self.pPitch).splitlines()])] except ValueError: str_list += ['pPitch : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if True}} + @property def pArray(self): return [cudaArray_t(init_value=_pArray) for _pArray in self._pvt_ptr[0].frame.pArray] @@ -20868,8 +20312,8 @@ cdef class anon_union12: for _idx, _pArray in enumerate(pArray): self._pvt_ptr[0].frame.pArray[_idx] = _pArray - {{endif}} - {{if True}} + + @property def pPitch(self): out_pPitch = [cudaPitchedPtr() for _pPitch in self._pvt_ptr[0].frame.pPitch] @@ -20883,9 +20327,7 @@ cdef class anon_union12: for _idx in range(len(pPitch)): string.memcpy(&self._pvt_ptr[0].frame.pPitch[_idx], pPitch[_idx].getPtr(), sizeof(cyruntime.cudaPitchedPtr)) - {{endif}} -{{endif}} -{{if True}} + cdef class cudaEglFrame_st: """ @@ -20900,26 +20342,26 @@ cdef class cudaEglFrame_st: Attributes ---------- - {{if True}} + frame : anon_union12 - {{endif}} - {{if True}} + + planeDesc : list[cudaEglPlaneDesc] CUDA EGL Plane Descriptor cudaEglPlaneDesc - {{endif}} - {{if True}} + + planeCount : unsigned int Number of planes - {{endif}} - {{if True}} + + frameType : cudaEglFrameType Array or Pitch - {{endif}} - {{if True}} + + eglColorFormat : cudaEglColorFormat CUDA EGL Color Format - {{endif}} + Methods ------- @@ -20934,9 +20376,9 @@ cdef class cudaEglFrame_st: self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass - {{if True}} + self._frame = anon_union12(_ptr=self._pvt_ptr) - {{endif}} + def __dealloc__(self): if self._val_ptr is not NULL: free(self._val_ptr) @@ -20945,48 +20387,48 @@ cdef class cudaEglFrame_st: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if True}} + try: str_list += ['frame :\n' + '\n'.join([' ' + line for line in str(self.frame).splitlines()])] except ValueError: str_list += ['frame : '] - {{endif}} - {{if True}} + + try: str_list += ['planeDesc :\n' + '\n'.join([' ' + line for line in str(self.planeDesc).splitlines()])] except ValueError: str_list += ['planeDesc : '] - {{endif}} - {{if True}} + + try: str_list += ['planeCount : ' + str(self.planeCount)] except ValueError: str_list += ['planeCount : '] - {{endif}} - {{if True}} + + try: str_list += ['frameType : ' + str(self.frameType)] except ValueError: str_list += ['frameType : '] - {{endif}} - {{if True}} + + try: str_list += ['eglColorFormat : ' + str(self.eglColorFormat)] except ValueError: str_list += ['eglColorFormat : '] - {{endif}} + return '\n'.join(str_list) else: return '' - {{if True}} + @property def frame(self): return self._frame @frame.setter def frame(self, frame not None : anon_union12): string.memcpy(&self._pvt_ptr[0].frame, frame.getPtr(), sizeof(self._pvt_ptr[0].frame)) - {{endif}} - {{if True}} + + @property def planeDesc(self): out_planeDesc = [cudaEglPlaneDesc() for _planeDesc in self._pvt_ptr[0].planeDesc] @@ -21000,33 +20442,31 @@ cdef class cudaEglFrame_st: for _idx in range(len(planeDesc)): string.memcpy(&self._pvt_ptr[0].planeDesc[_idx], planeDesc[_idx].getPtr(), sizeof(cyruntime.cudaEglPlaneDesc)) - {{endif}} - {{if True}} + + @property def planeCount(self): return self._pvt_ptr[0].planeCount @planeCount.setter def planeCount(self, unsigned int planeCount): self._pvt_ptr[0].planeCount = planeCount - {{endif}} - {{if True}} + + @property def frameType(self): return cudaEglFrameType(self._pvt_ptr[0].frameType) @frameType.setter def frameType(self, frameType not None : cudaEglFrameType): - self._pvt_ptr[0].frameType = int(frameType) - {{endif}} - {{if True}} + self._pvt_ptr[0].frameType = int(frameType) + + @property def eglColorFormat(self): return cudaEglColorFormat(self._pvt_ptr[0].eglColorFormat) @eglColorFormat.setter def eglColorFormat(self, eglColorFormat not None : cudaEglColorFormat): - self._pvt_ptr[0].eglColorFormat = int(eglColorFormat) - {{endif}} -{{endif}} -{{if 'cudaGraphConditionalHandle' in found_types}} + self._pvt_ptr[0].eglColorFormat = int(eglColorFormat) + cdef class cudaGraphConditionalHandle: """ @@ -21054,9 +20494,6 @@ cdef class cudaGraphConditionalHandle: return self._pvt_ptr[0] def getPtr(self): return self._pvt_ptr -{{endif}} - -{{if 'cudaLogIterator' in found_types}} cdef class cudaLogIterator: """ @@ -21082,9 +20519,6 @@ cdef class cudaLogIterator: return self._pvt_ptr[0] def getPtr(self): return self._pvt_ptr -{{endif}} - -{{if 'cudaSurfaceObject_t' in found_types}} cdef class cudaSurfaceObject_t: """ @@ -21112,9 +20546,6 @@ cdef class cudaSurfaceObject_t: return self._pvt_ptr[0] def getPtr(self): return self._pvt_ptr -{{endif}} - -{{if 'cudaTextureObject_t' in found_types}} cdef class cudaTextureObject_t: """ @@ -21142,9 +20573,6 @@ cdef class cudaTextureObject_t: return self._pvt_ptr[0] def getPtr(self): return self._pvt_ptr -{{endif}} - -{{if True}} cdef class GLenum: """ @@ -21170,9 +20598,6 @@ cdef class GLenum: return self._pvt_ptr[0] def getPtr(self): return self._pvt_ptr -{{endif}} - -{{if True}} cdef class GLuint: """ @@ -21198,9 +20623,6 @@ cdef class GLuint: return self._pvt_ptr[0] def getPtr(self): return self._pvt_ptr -{{endif}} - -{{if True}} cdef class EGLint: """ @@ -21226,9 +20648,6 @@ cdef class EGLint: return self._pvt_ptr[0] def getPtr(self): return self._pvt_ptr -{{endif}} - -{{if True}} cdef class VdpDevice: """ @@ -21254,9 +20673,6 @@ cdef class VdpDevice: return self._pvt_ptr[0] def getPtr(self): return self._pvt_ptr -{{endif}} - -{{if True}} cdef class VdpGetProcAddress: """ @@ -21282,9 +20698,6 @@ cdef class VdpGetProcAddress: return self._pvt_ptr[0] def getPtr(self): return self._pvt_ptr -{{endif}} - -{{if True}} cdef class VdpVideoSurface: """ @@ -21310,9 +20723,6 @@ cdef class VdpVideoSurface: return self._pvt_ptr[0] def getPtr(self): return self._pvt_ptr -{{endif}} - -{{if True}} cdef class VdpOutputSurface: """ @@ -21338,9 +20748,6 @@ cdef class VdpOutputSurface: return self._pvt_ptr[0] def getPtr(self): return self._pvt_ptr -{{endif}} - -{{if 'cudaDeviceReset' in found_functions}} @cython.embedsignature(True) def cudaDeviceReset(): @@ -21385,9 +20792,6 @@ def cudaDeviceReset(): with nogil: err = cyruntime.cudaDeviceReset() return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaDeviceSynchronize' in found_functions}} @cython.embedsignature(True) def cudaDeviceSynchronize(): @@ -21412,9 +20816,6 @@ def cudaDeviceSynchronize(): with nogil: err = cyruntime.cudaDeviceSynchronize() return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaDeviceSetLimit' in found_functions}} @cython.embedsignature(True) def cudaDeviceSetLimit(limit not None : cudaLimit, size_t value): @@ -21515,9 +20916,6 @@ def cudaDeviceSetLimit(limit not None : cudaLimit, size_t value): with nogil: err = cyruntime.cudaDeviceSetLimit(cylimit, value) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaDeviceGetLimit' in found_functions}} @cython.embedsignature(True) def cudaDeviceGetLimit(limit not None : cudaLimit): @@ -21575,9 +20973,6 @@ def cudaDeviceGetLimit(limit not None : cudaLimit): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pValue) -{{endif}} - -{{if 'cudaDeviceGetTexture1DLinearMaxWidth' in found_functions}} @cython.embedsignature(True) def cudaDeviceGetTexture1DLinearMaxWidth(fmtDesc : Optional[cudaChannelFormatDesc], int device): @@ -21613,9 +21008,6 @@ def cudaDeviceGetTexture1DLinearMaxWidth(fmtDesc : Optional[cudaChannelFormatDes if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, maxWidthInElements) -{{endif}} - -{{if 'cudaDeviceGetCacheConfig' in found_functions}} @cython.embedsignature(True) def cudaDeviceGetCacheConfig(): @@ -21663,9 +21055,6 @@ def cudaDeviceGetCacheConfig(): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, cudaFuncCache(pCacheConfig)) -{{endif}} - -{{if 'cudaDeviceGetStreamPriorityRange' in found_functions}} @cython.embedsignature(True) def cudaDeviceGetStreamPriorityRange(): @@ -21710,9 +21099,6 @@ def cudaDeviceGetStreamPriorityRange(): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None, None) return (_cudaError_t_SUCCESS, leastPriority, greatestPriority) -{{endif}} - -{{if 'cudaDeviceSetCacheConfig' in found_functions}} @cython.embedsignature(True) def cudaDeviceSetCacheConfig(cacheConfig not None : cudaFuncCache): @@ -21768,9 +21154,6 @@ def cudaDeviceSetCacheConfig(cacheConfig not None : cudaFuncCache): with nogil: err = cyruntime.cudaDeviceSetCacheConfig(cycacheConfig) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaDeviceGetByPCIBusId' in found_functions}} @cython.embedsignature(True) def cudaDeviceGetByPCIBusId(char* pciBusId): @@ -21803,9 +21186,6 @@ def cudaDeviceGetByPCIBusId(char* pciBusId): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, device) -{{endif}} - -{{if 'cudaDeviceGetPCIBusId' in found_functions}} @cython.embedsignature(True) def cudaDeviceGetPCIBusId(int length, int device): @@ -21844,9 +21224,6 @@ def cudaDeviceGetPCIBusId(int length, int device): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pypciBusId) -{{endif}} - -{{if 'cudaIpcGetEventHandle' in found_functions}} @cython.embedsignature(True) def cudaIpcGetEventHandle(event): @@ -21905,9 +21282,6 @@ def cudaIpcGetEventHandle(event): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, handle) -{{endif}} - -{{if 'cudaIpcOpenEventHandle' in found_functions}} @cython.embedsignature(True) def cudaIpcOpenEventHandle(handle not None : cudaIpcEventHandle_t): @@ -21952,9 +21326,6 @@ def cudaIpcOpenEventHandle(handle not None : cudaIpcEventHandle_t): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, event) -{{endif}} - -{{if 'cudaIpcGetMemHandle' in found_functions}} @cython.embedsignature(True) def cudaIpcGetMemHandle(devPtr): @@ -22003,9 +21374,6 @@ def cudaIpcGetMemHandle(devPtr): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, handle) -{{endif}} - -{{if 'cudaIpcOpenMemHandle' in found_functions}} @cython.embedsignature(True) def cudaIpcOpenMemHandle(handle not None : cudaIpcMemHandle_t, unsigned int flags): @@ -22067,7 +21435,7 @@ def cudaIpcOpenMemHandle(handle not None : cudaIpcMemHandle_t, unsigned int flag Notes ----- - No guarantees are made about the address returned in `*devPtr`. + No guarantees are made about the address returned in `*devPtr`. In particular, multiple processes may not receive the same address for the same `handle`. """ cdef void_ptr devPtr = 0 @@ -22076,9 +21444,6 @@ def cudaIpcOpenMemHandle(handle not None : cudaIpcMemHandle_t, unsigned int flag if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, devPtr) -{{endif}} - -{{if 'cudaIpcCloseMemHandle' in found_functions}} @cython.embedsignature(True) def cudaIpcCloseMemHandle(devPtr): @@ -22120,9 +21485,6 @@ def cudaIpcCloseMemHandle(devPtr): err = cyruntime.cudaIpcCloseMemHandle(cydevPtr) _helper_input_void_ptr_free(&cydevPtrHelper) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaDeviceFlushGPUDirectRDMAWrites' in found_functions}} @cython.embedsignature(True) def cudaDeviceFlushGPUDirectRDMAWrites(target not None : cudaFlushGPUDirectRDMAWritesTarget, scope not None : cudaFlushGPUDirectRDMAWritesScope): @@ -22165,9 +21527,6 @@ def cudaDeviceFlushGPUDirectRDMAWrites(target not None : cudaFlushGPUDirectRDMAW with nogil: err = cyruntime.cudaDeviceFlushGPUDirectRDMAWrites(cytarget, cyscope) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaDeviceRegisterAsyncNotification' in found_functions}} ctypedef struct cudaAsyncCallbackData_st: cyruntime.cudaAsyncCallback callback @@ -22254,9 +21613,6 @@ def cudaDeviceRegisterAsyncNotification(int device, callbackFunc, userData): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, callback) -{{endif}} - -{{if 'cudaDeviceUnregisterAsyncNotification' in found_functions}} @cython.embedsignature(True) def cudaDeviceUnregisterAsyncNotification(int device, callback): @@ -22296,9 +21652,6 @@ def cudaDeviceUnregisterAsyncNotification(int device, callback): free(m_global._allocated[pcallback]) m_global._allocated.erase(pcallback) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaDeviceGetSharedMemConfig' in found_functions}} @cython.embedsignature(True) def cudaDeviceGetSharedMemConfig(): @@ -22340,9 +21693,6 @@ def cudaDeviceGetSharedMemConfig(): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, cudaSharedMemConfig(pConfig)) -{{endif}} - -{{if 'cudaDeviceSetSharedMemConfig' in found_functions}} @cython.embedsignature(True) def cudaDeviceSetSharedMemConfig(config not None : cudaSharedMemConfig): @@ -22397,9 +21747,6 @@ def cudaDeviceSetSharedMemConfig(config not None : cudaSharedMemConfig): with nogil: err = cyruntime.cudaDeviceSetSharedMemConfig(cyconfig) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaGetLastError' in found_functions}} @cython.embedsignature(True) def cudaGetLastError(): @@ -22425,9 +21772,6 @@ def cudaGetLastError(): with nogil: err = cyruntime.cudaGetLastError() return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaPeekAtLastError' in found_functions}} @cython.embedsignature(True) def cudaPeekAtLastError(): @@ -22454,9 +21798,6 @@ def cudaPeekAtLastError(): with nogil: err = cyruntime.cudaPeekAtLastError() return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaGetErrorName' in found_functions}} @cython.embedsignature(True) def cudaGetErrorName(error not None : cudaError_t): @@ -22486,9 +21827,6 @@ def cudaGetErrorName(error not None : cudaError_t): with nogil: err = cyruntime.cudaGetErrorName(cyerror) return (cudaError_t.cudaSuccess, err) -{{endif}} - -{{if 'cudaGetErrorString' in found_functions}} @cython.embedsignature(True) def cudaGetErrorString(error not None : cudaError_t): @@ -22517,9 +21855,6 @@ def cudaGetErrorString(error not None : cudaError_t): with nogil: err = cyruntime.cudaGetErrorString(cyerror) return (cudaError_t.cudaSuccess, err) -{{endif}} - -{{if 'cudaGetDeviceCount' in found_functions}} @cython.embedsignature(True) def cudaGetDeviceCount(): @@ -22546,9 +21881,6 @@ def cudaGetDeviceCount(): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, count) -{{endif}} - -{{if 'cudaGetDeviceProperties' in found_functions}} @cython.embedsignature(True) def cudaGetDeviceProperties(int device): @@ -22578,9 +21910,6 @@ def cudaGetDeviceProperties(int device): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, prop) -{{endif}} - -{{if 'cudaDeviceGetAttribute' in found_functions}} @cython.embedsignature(True) def cudaDeviceGetAttribute(attr not None : cudaDeviceAttr, int device): @@ -22614,9 +21943,6 @@ def cudaDeviceGetAttribute(attr not None : cudaDeviceAttr, int device): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, value) -{{endif}} - -{{if 'cudaDeviceGetHostAtomicCapabilities' in found_functions}} @cython.embedsignature(True) def cudaDeviceGetHostAtomicCapabilities(operations : Optional[tuple[cudaAtomicOperation] | list[cudaAtomicOperation]], unsigned int count, int device): @@ -22677,9 +22003,6 @@ def cudaDeviceGetHostAtomicCapabilities(operations : Optional[tuple[cudaAtomicOp if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pycapabilities) -{{endif}} - -{{if 'cudaDeviceGetDefaultMemPool' in found_functions}} @cython.embedsignature(True) def cudaDeviceGetDefaultMemPool(int device): @@ -22710,9 +22033,6 @@ def cudaDeviceGetDefaultMemPool(int device): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, memPool) -{{endif}} - -{{if 'cudaDeviceSetMemPool' in found_functions}} @cython.embedsignature(True) def cudaDeviceSetMemPool(int device, memPool): @@ -22755,9 +22075,6 @@ def cudaDeviceSetMemPool(int device, memPool): with nogil: err = cyruntime.cudaDeviceSetMemPool(device, cymemPool) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaDeviceGetMemPool' in found_functions}} @cython.embedsignature(True) def cudaDeviceGetMemPool(int device): @@ -22792,9 +22109,6 @@ def cudaDeviceGetMemPool(int device): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, memPool) -{{endif}} - -{{if 'cudaDeviceGetNvSciSyncAttributes' in found_functions}} @cython.embedsignature(True) def cudaDeviceGetNvSciSyncAttributes(nvSciSyncAttrList, int device, int flags): @@ -22868,7 +22182,6 @@ def cudaDeviceGetNvSciSyncAttributes(nvSciSyncAttrList, int device, int flags): ------- cudaError_t - See Also -------- :py:obj:`~.cudaImportExternalSemaphore`, :py:obj:`~.cudaDestroyExternalSemaphore`, :py:obj:`~.cudaSignalExternalSemaphoresAsync`, :py:obj:`~.cudaWaitExternalSemaphoresAsync` @@ -22879,9 +22192,6 @@ def cudaDeviceGetNvSciSyncAttributes(nvSciSyncAttrList, int device, int flags): err = cyruntime.cudaDeviceGetNvSciSyncAttributes(cynvSciSyncAttrList, device, flags) _helper_input_void_ptr_free(&cynvSciSyncAttrListHelper) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaDeviceGetP2PAttribute' in found_functions}} @cython.embedsignature(True) def cudaDeviceGetP2PAttribute(attr not None : cudaDeviceP2PAttr, int srcDevice, int dstDevice): @@ -22944,9 +22254,6 @@ def cudaDeviceGetP2PAttribute(attr not None : cudaDeviceP2PAttr, int srcDevice, if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, value) -{{endif}} - -{{if 'cudaDeviceGetP2PAtomicCapabilities' in found_functions}} @cython.embedsignature(True) def cudaDeviceGetP2PAtomicCapabilities(operations : Optional[tuple[cudaAtomicOperation] | list[cudaAtomicOperation]], unsigned int count, int srcDevice, int dstDevice): @@ -23011,9 +22318,6 @@ def cudaDeviceGetP2PAtomicCapabilities(operations : Optional[tuple[cudaAtomicOpe if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pycapabilities) -{{endif}} - -{{if 'cudaChooseDevice' in found_functions}} @cython.embedsignature(True) def cudaChooseDevice(prop : Optional[cudaDeviceProp]): @@ -23045,9 +22349,6 @@ def cudaChooseDevice(prop : Optional[cudaDeviceProp]): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, device) -{{endif}} - -{{if 'cudaInitDevice' in found_functions}} @cython.embedsignature(True) def cudaInitDevice(int device, unsigned int deviceFlags, unsigned int flags): @@ -23088,9 +22389,6 @@ def cudaInitDevice(int device, unsigned int deviceFlags, unsigned int flags): with nogil: err = cyruntime.cudaInitDevice(device, deviceFlags, flags) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaSetDevice' in found_functions}} @cython.embedsignature(True) def cudaSetDevice(int device): @@ -23144,9 +22442,6 @@ def cudaSetDevice(int device): with nogil: err = cyruntime.cudaSetDevice(device) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaGetDevice' in found_functions}} @cython.embedsignature(True) def cudaGetDevice(): @@ -23172,9 +22467,6 @@ def cudaGetDevice(): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, device) -{{endif}} - -{{if 'cudaSetDeviceFlags' in found_functions}} @cython.embedsignature(True) def cudaSetDeviceFlags(unsigned int flags): @@ -23259,9 +22551,6 @@ def cudaSetDeviceFlags(unsigned int flags): with nogil: err = cyruntime.cudaSetDeviceFlags(flags) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaGetDeviceFlags' in found_functions}} @cython.embedsignature(True) def cudaGetDeviceFlags(): @@ -23309,9 +22598,6 @@ def cudaGetDeviceFlags(): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, flags) -{{endif}} - -{{if 'cudaStreamCreate' in found_functions}} @cython.embedsignature(True) def cudaStreamCreate(): @@ -23339,9 +22625,6 @@ def cudaStreamCreate(): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pStream) -{{endif}} - -{{if 'cudaStreamCreateWithFlags' in found_functions}} @cython.embedsignature(True) def cudaStreamCreateWithFlags(unsigned int flags): @@ -23383,9 +22666,6 @@ def cudaStreamCreateWithFlags(unsigned int flags): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pStream) -{{endif}} - -{{if 'cudaStreamCreateWithPriority' in found_functions}} @cython.embedsignature(True) def cudaStreamCreateWithPriority(unsigned int flags, int priority): @@ -23444,9 +22724,6 @@ def cudaStreamCreateWithPriority(unsigned int flags, int priority): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pStream) -{{endif}} - -{{if 'cudaStreamGetPriority' in found_functions}} @cython.embedsignature(True) def cudaStreamGetPriority(hStream): @@ -23490,9 +22767,6 @@ def cudaStreamGetPriority(hStream): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, priority) -{{endif}} - -{{if 'cudaStreamGetFlags' in found_functions}} @cython.embedsignature(True) def cudaStreamGetFlags(hStream): @@ -23532,9 +22806,6 @@ def cudaStreamGetFlags(hStream): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, flags) -{{endif}} - -{{if 'cudaStreamGetId' in found_functions}} @cython.embedsignature(True) def cudaStreamGetId(hStream): @@ -23588,9 +22859,6 @@ def cudaStreamGetId(hStream): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, streamId) -{{endif}} - -{{if 'cudaStreamGetDevice' in found_functions}} @cython.embedsignature(True) def cudaStreamGetDevice(hStream): @@ -23628,9 +22896,6 @@ def cudaStreamGetDevice(hStream): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, device) -{{endif}} - -{{if 'cudaCtxResetPersistingL2Cache' in found_functions}} @cython.embedsignature(True) def cudaCtxResetPersistingL2Cache(): @@ -23651,9 +22916,6 @@ def cudaCtxResetPersistingL2Cache(): with nogil: err = cyruntime.cudaCtxResetPersistingL2Cache() return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaStreamCopyAttributes' in found_functions}} @cython.embedsignature(True) def cudaStreamCopyAttributes(dst, src): @@ -23697,9 +22959,6 @@ def cudaStreamCopyAttributes(dst, src): with nogil: err = cyruntime.cudaStreamCopyAttributes(cydst, cysrc) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaStreamGetAttribute' in found_functions}} @cython.embedsignature(True) def cudaStreamGetAttribute(hStream, attr not None : cudaStreamAttrID): @@ -23714,14 +22973,12 @@ def cudaStreamGetAttribute(hStream, attr not None : cudaStreamAttrID): attr : :py:obj:`~.cudaStreamAttrID` - Returns ------- cudaError_t :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorInvalidResourceHandle` value_out : :py:obj:`~.cudaStreamAttrValue` - See Also -------- :py:obj:`~.cudaAccessPolicyWindow` @@ -23741,9 +22998,6 @@ def cudaStreamGetAttribute(hStream, attr not None : cudaStreamAttrID): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, value_out) -{{endif}} - -{{if 'cudaStreamSetAttribute' in found_functions}} @cython.embedsignature(True) def cudaStreamSetAttribute(hStream, attr not None : cudaStreamAttrID, value : Optional[cudaStreamAttrValue]): @@ -23761,7 +23015,6 @@ def cudaStreamSetAttribute(hStream, attr not None : cudaStreamAttrID, value : Op value : :py:obj:`~.cudaStreamAttrValue` - Returns ------- cudaError_t @@ -23784,9 +23037,6 @@ def cudaStreamSetAttribute(hStream, attr not None : cudaStreamAttrID, value : Op with nogil: err = cyruntime.cudaStreamSetAttribute(cyhStream, cyattr, cyvalue_ptr) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaStreamDestroy' in found_functions}} @cython.embedsignature(True) def cudaStreamDestroy(stream): @@ -23824,9 +23074,6 @@ def cudaStreamDestroy(stream): with nogil: err = cyruntime.cudaStreamDestroy(cystream) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaStreamWaitEvent' in found_functions}} @cython.embedsignature(True) def cudaStreamWaitEvent(stream, event, unsigned int flags): @@ -23882,9 +23129,6 @@ def cudaStreamWaitEvent(stream, event, unsigned int flags): with nogil: err = cyruntime.cudaStreamWaitEvent(cystream, cyevent, flags) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaStreamAddCallback' in found_functions}} ctypedef struct cudaStreamCallbackData_st: cyruntime.cudaStreamCallback_t callback @@ -24001,9 +23245,6 @@ def cudaStreamAddCallback(stream, callback, userData, unsigned int flags): _helper_input_void_ptr_free(&cyuserDataHelper) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaStreamSynchronize' in found_functions}} @cython.embedsignature(True) def cudaStreamSynchronize(stream): @@ -24039,9 +23280,6 @@ def cudaStreamSynchronize(stream): with nogil: err = cyruntime.cudaStreamSynchronize(cystream) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaStreamQuery' in found_functions}} @cython.embedsignature(True) def cudaStreamQuery(stream): @@ -24079,9 +23317,6 @@ def cudaStreamQuery(stream): with nogil: err = cyruntime.cudaStreamQuery(cystream) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaStreamAttachMemAsync' in found_functions}} @cython.embedsignature(True) def cudaStreamAttachMemAsync(stream, devPtr, size_t length, unsigned int flags): @@ -24191,9 +23426,6 @@ def cudaStreamAttachMemAsync(stream, devPtr, size_t length, unsigned int flags): err = cyruntime.cudaStreamAttachMemAsync(cystream, cydevPtr, length, flags) _helper_input_void_ptr_free(&cydevPtrHelper) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaStreamBeginCapture' in found_functions}} @cython.embedsignature(True) def cudaStreamBeginCapture(stream, mode not None : cudaStreamCaptureMode): @@ -24248,9 +23480,6 @@ def cudaStreamBeginCapture(stream, mode not None : cudaStreamCaptureMode): with nogil: err = cyruntime.cudaStreamBeginCapture(cystream, cymode) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaStreamBeginRecaptureToGraph' in found_functions}} @cython.embedsignature(True) def cudaStreamBeginRecaptureToGraph(stream, mode not None : cudaStreamCaptureMode, graph, callbackData : Optional[cudaGraphRecaptureCallbackData]): @@ -24324,9 +23553,6 @@ def cudaStreamBeginRecaptureToGraph(stream, mode not None : cudaStreamCaptureMod with nogil: err = cyruntime.cudaStreamBeginRecaptureToGraph(cystream, cymode, cygraph, cycallbackData_ptr) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaStreamBeginCaptureToGraph' in found_functions}} @cython.embedsignature(True) def cudaStreamBeginCaptureToGraph(stream, graph, dependencies : Optional[tuple[cudaGraphNode_t] | list[cudaGraphNode_t]], dependencyData : Optional[tuple[cudaGraphEdgeData] | list[cudaGraphEdgeData]], size_t numDependencies, mode not None : cudaStreamCaptureMode): @@ -24429,9 +23655,6 @@ def cudaStreamBeginCaptureToGraph(stream, graph, dependencies : Optional[tuple[c if len(dependencyData) > 1 and cydependencyData is not NULL: free(cydependencyData) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaThreadExchangeStreamCaptureMode' in found_functions}} @cython.embedsignature(True) def cudaThreadExchangeStreamCaptureMode(mode not None : cudaStreamCaptureMode): @@ -24503,9 +23726,6 @@ def cudaThreadExchangeStreamCaptureMode(mode not None : cudaStreamCaptureMode): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, cudaStreamCaptureMode(cymode)) -{{endif}} - -{{if 'cudaStreamEndCapture' in found_functions}} @cython.embedsignature(True) def cudaStreamEndCapture(stream): @@ -24551,9 +23771,6 @@ def cudaStreamEndCapture(stream): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pGraph) -{{endif}} - -{{if 'cudaStreamIsCapturing' in found_functions}} @cython.embedsignature(True) def cudaStreamIsCapturing(stream): @@ -24613,9 +23830,6 @@ def cudaStreamIsCapturing(stream): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, cudaStreamCaptureStatus(pCaptureStatus)) -{{endif}} - -{{if 'cudaStreamGetCaptureInfo' in found_functions}} @cython.embedsignature(True) def cudaStreamGetCaptureInfo(stream): @@ -24717,9 +23931,6 @@ def cudaStreamGetCaptureInfo(stream): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None, None, None, None, None, None) return (_cudaError_t_SUCCESS, cudaStreamCaptureStatus(captureStatus_out), id_out, graph_out, pydependencies_out, pyedgeData_out, numDependencies_out) -{{endif}} - -{{if 'cudaStreamUpdateCaptureDependencies' in found_functions}} @cython.embedsignature(True) def cudaStreamUpdateCaptureDependencies(stream, dependencies : Optional[tuple[cudaGraphNode_t] | list[cudaGraphNode_t]], dependencyData : Optional[tuple[cudaGraphEdgeData] | list[cudaGraphEdgeData]], size_t numDependencies, unsigned int flags): @@ -24804,9 +24015,6 @@ def cudaStreamUpdateCaptureDependencies(stream, dependencies : Optional[tuple[cu if len(dependencyData) > 1 and cydependencyData is not NULL: free(cydependencyData) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaEventCreate' in found_functions}} @cython.embedsignature(True) def cudaEventCreate(): @@ -24832,9 +24040,6 @@ def cudaEventCreate(): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, event) -{{endif}} - -{{if 'cudaEventCreateWithFlags' in found_functions}} @cython.embedsignature(True) def cudaEventCreateWithFlags(unsigned int flags): @@ -24884,9 +24089,6 @@ def cudaEventCreateWithFlags(unsigned int flags): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, event) -{{endif}} - -{{if 'cudaEventRecord' in found_functions}} @cython.embedsignature(True) def cudaEventRecord(event, stream): @@ -24943,9 +24145,6 @@ def cudaEventRecord(event, stream): with nogil: err = cyruntime.cudaEventRecord(cyevent, cystream) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaEventRecordWithFlags' in found_functions}} @cython.embedsignature(True) def cudaEventRecordWithFlags(event, stream, unsigned int flags): @@ -25011,9 +24210,6 @@ def cudaEventRecordWithFlags(event, stream, unsigned int flags): with nogil: err = cyruntime.cudaEventRecordWithFlags(cyevent, cystream, flags) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaEventQuery' in found_functions}} @cython.embedsignature(True) def cudaEventQuery(event): @@ -25056,9 +24252,6 @@ def cudaEventQuery(event): with nogil: err = cyruntime.cudaEventQuery(cyevent) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaEventSynchronize' in found_functions}} @cython.embedsignature(True) def cudaEventSynchronize(event): @@ -25100,9 +24293,6 @@ def cudaEventSynchronize(event): with nogil: err = cyruntime.cudaEventSynchronize(cyevent) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaEventDestroy' in found_functions}} @cython.embedsignature(True) def cudaEventDestroy(event): @@ -25141,9 +24331,6 @@ def cudaEventDestroy(event): with nogil: err = cyruntime.cudaEventDestroy(cyevent) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaEventElapsedTime' in found_functions}} @cython.embedsignature(True) def cudaEventElapsedTime(start, end): @@ -25214,9 +24401,6 @@ def cudaEventElapsedTime(start, end): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, ms) -{{endif}} - -{{if 'cudaImportExternalMemory' in found_functions}} @cython.embedsignature(True) def cudaImportExternalMemory(memHandleDesc : Optional[cudaExternalMemoryHandleDesc]): @@ -25363,9 +24547,6 @@ def cudaImportExternalMemory(memHandleDesc : Optional[cudaExternalMemoryHandleDe if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, extMem_out) -{{endif}} - -{{if 'cudaExternalMemoryGetMappedBuffer' in found_functions}} @cython.embedsignature(True) def cudaExternalMemoryGetMappedBuffer(extMem, bufferDesc : Optional[cudaExternalMemoryBufferDesc]): @@ -25431,9 +24612,6 @@ def cudaExternalMemoryGetMappedBuffer(extMem, bufferDesc : Optional[cudaExternal if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, devPtr) -{{endif}} - -{{if 'cudaExternalMemoryGetMappedMipmappedArray' in found_functions}} @cython.embedsignature(True) def cudaExternalMemoryGetMappedMipmappedArray(extMem, mipmapDesc : Optional[cudaExternalMemoryMipmappedArrayDesc]): @@ -25503,9 +24681,6 @@ def cudaExternalMemoryGetMappedMipmappedArray(extMem, mipmapDesc : Optional[cuda if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, mipmap) -{{endif}} - -{{if 'cudaDestroyExternalMemory' in found_functions}} @cython.embedsignature(True) def cudaDestroyExternalMemory(extMem): @@ -25541,9 +24716,6 @@ def cudaDestroyExternalMemory(extMem): with nogil: err = cyruntime.cudaDestroyExternalMemory(cyextMem) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaImportExternalSemaphore' in found_functions}} @cython.embedsignature(True) def cudaImportExternalSemaphore(semHandleDesc : Optional[cudaExternalSemaphoreHandleDesc]): @@ -25688,9 +24860,6 @@ def cudaImportExternalSemaphore(semHandleDesc : Optional[cudaExternalSemaphoreHa if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, extSem_out) -{{endif}} - -{{if 'cudaSignalExternalSemaphoresAsync' in found_functions}} @cython.embedsignature(True) def cudaSignalExternalSemaphoresAsync(extSemArray : Optional[tuple[cudaExternalSemaphore_t] | list[cudaExternalSemaphore_t]], paramsArray : Optional[tuple[cudaExternalSemaphoreSignalParams] | list[cudaExternalSemaphoreSignalParams]], unsigned int numExtSems, stream): @@ -25844,9 +25013,6 @@ def cudaSignalExternalSemaphoresAsync(extSemArray : Optional[tuple[cudaExternalS if len(paramsArray) > 1 and cyparamsArray is not NULL: free(cyparamsArray) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaWaitExternalSemaphoresAsync' in found_functions}} @cython.embedsignature(True) def cudaWaitExternalSemaphoresAsync(extSemArray : Optional[tuple[cudaExternalSemaphore_t] | list[cudaExternalSemaphore_t]], paramsArray : Optional[tuple[cudaExternalSemaphoreWaitParams] | list[cudaExternalSemaphoreWaitParams]], unsigned int numExtSems, stream): @@ -25972,9 +25138,6 @@ def cudaWaitExternalSemaphoresAsync(extSemArray : Optional[tuple[cudaExternalSem if len(paramsArray) > 1 and cyparamsArray is not NULL: free(cyparamsArray) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaDestroyExternalSemaphore' in found_functions}} @cython.embedsignature(True) def cudaDestroyExternalSemaphore(extSem): @@ -26009,9 +25172,6 @@ def cudaDestroyExternalSemaphore(extSem): with nogil: err = cyruntime.cudaDestroyExternalSemaphore(cyextSem) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaFuncSetCacheConfig' in found_functions}} @cython.embedsignature(True) def cudaFuncSetCacheConfig(func, cacheConfig not None : cudaFuncCache): @@ -26077,9 +25237,6 @@ def cudaFuncSetCacheConfig(func, cacheConfig not None : cudaFuncCache): err = cyruntime.cudaFuncSetCacheConfig(cyfunc, cycacheConfig) _helper_input_void_ptr_free(&cyfuncHelper) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaFuncGetAttributes' in found_functions}} @cython.embedsignature(True) def cudaFuncGetAttributes(func): @@ -26122,9 +25279,6 @@ def cudaFuncGetAttributes(func): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, attr) -{{endif}} - -{{if 'cudaFuncSetAttribute' in found_functions}} @cython.embedsignature(True) def cudaFuncSetAttribute(func, attr not None : cudaFuncAttribute, int value): @@ -26209,9 +25363,6 @@ def cudaFuncSetAttribute(func, attr not None : cudaFuncAttribute, int value): err = cyruntime.cudaFuncSetAttribute(cyfunc, cyattr, value) _helper_input_void_ptr_free(&cyfuncHelper) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaFuncGetParamCount' in found_functions}} @cython.embedsignature(True) def cudaFuncGetParamCount(func): @@ -26241,9 +25392,6 @@ def cudaFuncGetParamCount(func): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, paramCount) -{{endif}} - -{{if 'cudaLaunchHostFunc' in found_functions}} ctypedef struct cudaStreamHostCallbackData_st: cyruntime.cudaHostFn_t callback @@ -26353,9 +25501,6 @@ def cudaLaunchHostFunc(stream, fn, userData): _helper_input_void_ptr_free(&cyuserDataHelper) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaLaunchHostFunc_v2' in found_functions}} @cython.embedsignature(True) def cudaLaunchHostFunc_v2(stream, fn, userData, unsigned int syncMode): @@ -26443,9 +25588,6 @@ def cudaLaunchHostFunc_v2(stream, fn, userData, unsigned int syncMode): err = cyruntime.cudaLaunchHostFunc_v2(cystream, cyfn, cyuserData, syncMode) _helper_input_void_ptr_free(&cyuserDataHelper) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaFuncSetSharedMemConfig' in found_functions}} @cython.embedsignature(True) def cudaFuncSetSharedMemConfig(func, config not None : cudaSharedMemConfig): @@ -26512,9 +25654,6 @@ def cudaFuncSetSharedMemConfig(func, config not None : cudaSharedMemConfig): err = cyruntime.cudaFuncSetSharedMemConfig(cyfunc, cyconfig) _helper_input_void_ptr_free(&cyfuncHelper) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaOccupancyMaxActiveBlocksPerMultiprocessor' in found_functions}} @cython.embedsignature(True) def cudaOccupancyMaxActiveBlocksPerMultiprocessor(func, int blockSize, size_t dynamicSMemSize): @@ -26552,9 +25691,6 @@ def cudaOccupancyMaxActiveBlocksPerMultiprocessor(func, int blockSize, size_t dy if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, numBlocks) -{{endif}} - -{{if 'cudaOccupancyAvailableDynamicSMemPerBlock' in found_functions}} @cython.embedsignature(True) def cudaOccupancyAvailableDynamicSMemPerBlock(func, int numBlocks, int blockSize): @@ -26592,9 +25728,6 @@ def cudaOccupancyAvailableDynamicSMemPerBlock(func, int numBlocks, int blockSize if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, dynamicSmemSize) -{{endif}} - -{{if 'cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags' in found_functions}} @cython.embedsignature(True) def cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(func, int blockSize, size_t dynamicSMemSize, unsigned int flags): @@ -26649,9 +25782,6 @@ def cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(func, int blockSize, if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, numBlocks) -{{endif}} - -{{if 'cudaMallocManaged' in found_functions}} @cython.embedsignature(True) def cudaMallocManaged(size_t size, unsigned int flags): @@ -26783,9 +25913,6 @@ def cudaMallocManaged(size_t size, unsigned int flags): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, devPtr) -{{endif}} - -{{if 'cudaMalloc' in found_functions}} @cython.embedsignature(True) def cudaMalloc(size_t size): @@ -26822,9 +25949,6 @@ def cudaMalloc(size_t size): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, devPtr) -{{endif}} - -{{if 'cudaMallocHost' in found_functions}} @cython.embedsignature(True) def cudaMallocHost(size_t size): @@ -26870,9 +25994,6 @@ def cudaMallocHost(size_t size): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, ptr) -{{endif}} - -{{if 'cudaMallocPitch' in found_functions}} @cython.embedsignature(True) def cudaMallocPitch(size_t width, size_t height): @@ -26926,9 +26047,6 @@ def cudaMallocPitch(size_t width, size_t height): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None, None) return (_cudaError_t_SUCCESS, devPtr, pitch) -{{endif}} - -{{if 'cudaMallocArray' in found_functions}} @cython.embedsignature(True) def cudaMallocArray(desc : Optional[cudaChannelFormatDesc], size_t width, size_t height, unsigned int flags): @@ -27003,9 +26121,6 @@ def cudaMallocArray(desc : Optional[cudaChannelFormatDesc], size_t width, size_t if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, array) -{{endif}} - -{{if 'cudaFree' in found_functions}} @cython.embedsignature(True) def cudaFree(devPtr): @@ -27054,9 +26169,6 @@ def cudaFree(devPtr): err = cyruntime.cudaFree(cydevPtr) _helper_input_void_ptr_free(&cydevPtrHelper) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaFreeHost' in found_functions}} @cython.embedsignature(True) def cudaFreeHost(ptr): @@ -27086,9 +26198,6 @@ def cudaFreeHost(ptr): err = cyruntime.cudaFreeHost(cyptr) _helper_input_void_ptr_free(&cyptrHelper) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaFreeArray' in found_functions}} @cython.embedsignature(True) def cudaFreeArray(array): @@ -27123,9 +26232,6 @@ def cudaFreeArray(array): with nogil: err = cyruntime.cudaFreeArray(cyarray) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaFreeMipmappedArray' in found_functions}} @cython.embedsignature(True) def cudaFreeMipmappedArray(mipmappedArray): @@ -27160,9 +26266,6 @@ def cudaFreeMipmappedArray(mipmappedArray): with nogil: err = cyruntime.cudaFreeMipmappedArray(cymipmappedArray) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaHostAlloc' in found_functions}} @cython.embedsignature(True) def cudaHostAlloc(size_t size, unsigned int flags): @@ -27245,9 +26348,6 @@ def cudaHostAlloc(size_t size, unsigned int flags): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pHost) -{{endif}} - -{{if 'cudaHostRegister' in found_functions}} @cython.embedsignature(True) def cudaHostRegister(ptr, size_t size, unsigned int flags): @@ -27363,9 +26463,6 @@ def cudaHostRegister(ptr, size_t size, unsigned int flags): err = cyruntime.cudaHostRegister(cyptr, size, flags) _helper_input_void_ptr_free(&cyptrHelper) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaHostUnregister' in found_functions}} @cython.embedsignature(True) def cudaHostUnregister(ptr): @@ -27397,9 +26494,6 @@ def cudaHostUnregister(ptr): err = cyruntime.cudaHostUnregister(cyptr) _helper_input_void_ptr_free(&cyptrHelper) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaHostGetDevicePointer' in found_functions}} @cython.embedsignature(True) def cudaHostGetDevicePointer(pHost, unsigned int flags): @@ -27460,9 +26554,6 @@ def cudaHostGetDevicePointer(pHost, unsigned int flags): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pDevice) -{{endif}} - -{{if 'cudaHostGetFlags' in found_functions}} @cython.embedsignature(True) def cudaHostGetFlags(pHost): @@ -27496,9 +26587,6 @@ def cudaHostGetFlags(pHost): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pFlags) -{{endif}} - -{{if 'cudaMalloc3D' in found_functions}} @cython.embedsignature(True) def cudaMalloc3D(extent not None : cudaExtent): @@ -27545,9 +26633,6 @@ def cudaMalloc3D(extent not None : cudaExtent): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pitchedDevPtr) -{{endif}} - -{{if 'cudaMalloc3DArray' in found_functions}} @cython.embedsignature(True) def cudaMalloc3DArray(desc : Optional[cudaChannelFormatDesc], extent not None : cudaExtent, unsigned int flags): @@ -27668,9 +26753,6 @@ def cudaMalloc3DArray(desc : Optional[cudaChannelFormatDesc], extent not None : if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, array) -{{endif}} - -{{if 'cudaMallocMipmappedArray' in found_functions}} @cython.embedsignature(True) def cudaMallocMipmappedArray(desc : Optional[cudaChannelFormatDesc], extent not None : cudaExtent, unsigned int numLevels, unsigned int flags): @@ -27794,9 +26876,6 @@ def cudaMallocMipmappedArray(desc : Optional[cudaChannelFormatDesc], extent not if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, mipmappedArray) -{{endif}} - -{{if 'cudaGetMipmappedArrayLevel' in found_functions}} @cython.embedsignature(True) def cudaGetMipmappedArrayLevel(mipmappedArray, unsigned int level): @@ -27843,9 +26922,6 @@ def cudaGetMipmappedArrayLevel(mipmappedArray, unsigned int level): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, levelArray) -{{endif}} - -{{if 'cudaMemcpy3D' in found_functions}} @cython.embedsignature(True) def cudaMemcpy3D(p : Optional[cudaMemcpy3DParms]): @@ -27927,9 +27003,6 @@ def cudaMemcpy3D(p : Optional[cudaMemcpy3DParms]): with nogil: err = cyruntime.cudaMemcpy3D(cyp_ptr) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaMemcpy3DPeer' in found_functions}} @cython.embedsignature(True) def cudaMemcpy3DPeer(p : Optional[cudaMemcpy3DPeerParms]): @@ -27964,9 +27037,6 @@ def cudaMemcpy3DPeer(p : Optional[cudaMemcpy3DPeerParms]): with nogil: err = cyruntime.cudaMemcpy3DPeer(cyp_ptr) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaMemcpy3DAsync' in found_functions}} @cython.embedsignature(True) def cudaMemcpy3DAsync(p : Optional[cudaMemcpy3DParms], stream): @@ -28069,9 +27139,6 @@ def cudaMemcpy3DAsync(p : Optional[cudaMemcpy3DParms], stream): with nogil: err = cyruntime.cudaMemcpy3DAsync(cyp_ptr, cystream) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaMemcpy3DPeerAsync' in found_functions}} @cython.embedsignature(True) def cudaMemcpy3DPeerAsync(p : Optional[cudaMemcpy3DPeerParms], stream): @@ -28109,9 +27176,6 @@ def cudaMemcpy3DPeerAsync(p : Optional[cudaMemcpy3DPeerParms], stream): with nogil: err = cyruntime.cudaMemcpy3DPeerAsync(cyp_ptr, cystream) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaMemGetInfo' in found_functions}} @cython.embedsignature(True) def cudaMemGetInfo(): @@ -28154,9 +27218,6 @@ def cudaMemGetInfo(): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None, None) return (_cudaError_t_SUCCESS, free, total) -{{endif}} - -{{if 'cudaArrayGetInfo' in found_functions}} @cython.embedsignature(True) def cudaArrayGetInfo(array): @@ -28203,9 +27264,6 @@ def cudaArrayGetInfo(array): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None, None, None) return (_cudaError_t_SUCCESS, desc, extent, flags) -{{endif}} - -{{if 'cudaArrayGetPlane' in found_functions}} @cython.embedsignature(True) def cudaArrayGetPlane(hArray, unsigned int planeIdx): @@ -28259,9 +27317,6 @@ def cudaArrayGetPlane(hArray, unsigned int planeIdx): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pPlaneArray) -{{endif}} - -{{if 'cudaArrayGetMemoryRequirements' in found_functions}} @cython.embedsignature(True) def cudaArrayGetMemoryRequirements(array, int device): @@ -28309,9 +27364,6 @@ def cudaArrayGetMemoryRequirements(array, int device): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, memoryRequirements) -{{endif}} - -{{if 'cudaMipmappedArrayGetMemoryRequirements' in found_functions}} @cython.embedsignature(True) def cudaMipmappedArrayGetMemoryRequirements(mipmap, int device): @@ -28359,9 +27411,6 @@ def cudaMipmappedArrayGetMemoryRequirements(mipmap, int device): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, memoryRequirements) -{{endif}} - -{{if 'cudaArrayGetSparseProperties' in found_functions}} @cython.embedsignature(True) def cudaArrayGetSparseProperties(array): @@ -28415,9 +27464,6 @@ def cudaArrayGetSparseProperties(array): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, sparseProperties) -{{endif}} - -{{if 'cudaMipmappedArrayGetSparseProperties' in found_functions}} @cython.embedsignature(True) def cudaMipmappedArrayGetSparseProperties(mipmap): @@ -28471,9 +27517,6 @@ def cudaMipmappedArrayGetSparseProperties(mipmap): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, sparseProperties) -{{endif}} - -{{if 'cudaMemcpy' in found_functions}} @cython.embedsignature(True) def cudaMemcpy(dst, src, size_t count, kind not None : cudaMemcpyKind): @@ -28523,9 +27566,6 @@ def cudaMemcpy(dst, src, size_t count, kind not None : cudaMemcpyKind): _helper_input_void_ptr_free(&cydstHelper) _helper_input_void_ptr_free(&cysrcHelper) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaMemcpyPeer' in found_functions}} @cython.embedsignature(True) def cudaMemcpyPeer(dst, int dstDevice, src, int srcDevice, size_t count): @@ -28573,9 +27613,6 @@ def cudaMemcpyPeer(dst, int dstDevice, src, int srcDevice, size_t count): _helper_input_void_ptr_free(&cydstHelper) _helper_input_void_ptr_free(&cysrcHelper) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaMemcpy2D' in found_functions}} @cython.embedsignature(True) def cudaMemcpy2D(dst, size_t dpitch, src, size_t spitch, size_t width, size_t height, kind not None : cudaMemcpyKind): @@ -28635,9 +27672,6 @@ def cudaMemcpy2D(dst, size_t dpitch, src, size_t spitch, size_t width, size_t he _helper_input_void_ptr_free(&cydstHelper) _helper_input_void_ptr_free(&cysrcHelper) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaMemcpy2DToArray' in found_functions}} @cython.embedsignature(True) def cudaMemcpy2DToArray(dst, size_t wOffset, size_t hOffset, src, size_t spitch, size_t width, size_t height, kind not None : cudaMemcpyKind): @@ -28703,9 +27737,6 @@ def cudaMemcpy2DToArray(dst, size_t wOffset, size_t hOffset, src, size_t spitch, err = cyruntime.cudaMemcpy2DToArray(cydst, wOffset, hOffset, cysrc, spitch, width, height, cykind) _helper_input_void_ptr_free(&cysrcHelper) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaMemcpy2DFromArray' in found_functions}} @cython.embedsignature(True) def cudaMemcpy2DFromArray(dst, size_t dpitch, src, size_t wOffset, size_t hOffset, size_t width, size_t height, kind not None : cudaMemcpyKind): @@ -28771,9 +27802,6 @@ def cudaMemcpy2DFromArray(dst, size_t dpitch, src, size_t wOffset, size_t hOffse err = cyruntime.cudaMemcpy2DFromArray(cydst, dpitch, cysrc, wOffset, hOffset, width, height, cykind) _helper_input_void_ptr_free(&cydstHelper) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaMemcpy2DArrayToArray' in found_functions}} @cython.embedsignature(True) def cudaMemcpy2DArrayToArray(dst, size_t wOffsetDst, size_t hOffsetDst, src, size_t wOffsetSrc, size_t hOffsetSrc, size_t width, size_t height, kind not None : cudaMemcpyKind): @@ -28844,9 +27872,6 @@ def cudaMemcpy2DArrayToArray(dst, size_t wOffsetDst, size_t hOffsetDst, src, siz with nogil: err = cyruntime.cudaMemcpy2DArrayToArray(cydst, wOffsetDst, hOffsetDst, cysrc, wOffsetSrc, hOffsetSrc, width, height, cykind) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaMemcpyAsync' in found_functions}} @cython.embedsignature(True) def cudaMemcpyAsync(dst, src, size_t count, kind not None : cudaMemcpyKind, stream): @@ -28916,9 +27941,6 @@ def cudaMemcpyAsync(dst, src, size_t count, kind not None : cudaMemcpyKind, stre _helper_input_void_ptr_free(&cydstHelper) _helper_input_void_ptr_free(&cysrcHelper) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaMemcpyPeerAsync' in found_functions}} @cython.embedsignature(True) def cudaMemcpyPeerAsync(dst, int dstDevice, src, int srcDevice, size_t count, stream): @@ -28974,9 +27996,6 @@ def cudaMemcpyPeerAsync(dst, int dstDevice, src, int srcDevice, size_t count, st _helper_input_void_ptr_free(&cydstHelper) _helper_input_void_ptr_free(&cysrcHelper) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaMemcpyBatchAsync' in found_functions}} @cython.embedsignature(True) def cudaMemcpyBatchAsync(dsts : Optional[tuple[Any] | list[Any]], srcs : Optional[tuple[Any] | list[Any]], sizes : tuple[int] | list[int], size_t count, attrs : Optional[tuple[cudaMemcpyAttributes] | list[cudaMemcpyAttributes]], attrsIdxs : tuple[int] | list[int], size_t numAttrs, stream): @@ -29124,9 +28143,6 @@ def cudaMemcpyBatchAsync(dsts : Optional[tuple[Any] | list[Any]], srcs : Optiona if len(attrs) > 1 and cyattrs is not NULL: free(cyattrs) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaMemcpy3DBatchAsync' in found_functions}} @cython.embedsignature(True) def cudaMemcpy3DBatchAsync(size_t numOps, opList : Optional[tuple[cudaMemcpy3DBatchOp] | list[cudaMemcpy3DBatchOp]], unsigned long long flags, stream): @@ -29254,13 +28270,10 @@ def cudaMemcpy3DBatchAsync(size_t numOps, opList : Optional[tuple[cudaMemcpy3DBa if len(opList) > 1 and cyopList is not NULL: free(cyopList) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaMemcpyWithAttributesAsync' in found_functions}} @cython.embedsignature(True) def cudaMemcpyWithAttributesAsync(dst, src, size_t size, attr : Optional[cudaMemcpyAttributes], stream): - """ + """ Performs asynchronous memory copy operation with the specified attributes. @@ -29314,13 +28327,10 @@ def cudaMemcpyWithAttributesAsync(dst, src, size_t size, attr : Optional[cudaMem _helper_input_void_ptr_free(&cydstHelper) _helper_input_void_ptr_free(&cysrcHelper) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaMemcpy3DWithAttributesAsync' in found_functions}} @cython.embedsignature(True) def cudaMemcpy3DWithAttributesAsync(op : Optional[cudaMemcpy3DBatchOp], unsigned long long flags, stream): - """ + """ Performs 3D asynchronous memory copy with the specified attributes. @@ -29362,9 +28372,6 @@ def cudaMemcpy3DWithAttributesAsync(op : Optional[cudaMemcpy3DBatchOp], unsigned with nogil: err = cyruntime.cudaMemcpy3DWithAttributesAsync(cyop_ptr, flags, cystream) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaMemcpy2DAsync' in found_functions}} @cython.embedsignature(True) def cudaMemcpy2DAsync(dst, size_t dpitch, src, size_t spitch, size_t width, size_t height, kind not None : cudaMemcpyKind, stream): @@ -29445,9 +28452,6 @@ def cudaMemcpy2DAsync(dst, size_t dpitch, src, size_t spitch, size_t width, size _helper_input_void_ptr_free(&cydstHelper) _helper_input_void_ptr_free(&cysrcHelper) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaMemcpy2DToArrayAsync' in found_functions}} @cython.embedsignature(True) def cudaMemcpy2DToArrayAsync(dst, size_t wOffset, size_t hOffset, src, size_t spitch, size_t width, size_t height, kind not None : cudaMemcpyKind, stream): @@ -29534,9 +28538,6 @@ def cudaMemcpy2DToArrayAsync(dst, size_t wOffset, size_t hOffset, src, size_t sp err = cyruntime.cudaMemcpy2DToArrayAsync(cydst, wOffset, hOffset, cysrc, spitch, width, height, cykind, cystream) _helper_input_void_ptr_free(&cysrcHelper) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaMemcpy2DFromArrayAsync' in found_functions}} @cython.embedsignature(True) def cudaMemcpy2DFromArrayAsync(dst, size_t dpitch, src, size_t wOffset, size_t hOffset, size_t width, size_t height, kind not None : cudaMemcpyKind, stream): @@ -29622,9 +28623,6 @@ def cudaMemcpy2DFromArrayAsync(dst, size_t dpitch, src, size_t wOffset, size_t h err = cyruntime.cudaMemcpy2DFromArrayAsync(cydst, dpitch, cysrc, wOffset, hOffset, width, height, cykind, cystream) _helper_input_void_ptr_free(&cydstHelper) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaMemset' in found_functions}} @cython.embedsignature(True) def cudaMemset(devPtr, int value, size_t count): @@ -29660,9 +28658,6 @@ def cudaMemset(devPtr, int value, size_t count): err = cyruntime.cudaMemset(cydevPtr, value, count) _helper_input_void_ptr_free(&cydevPtrHelper) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaMemset2D' in found_functions}} @cython.embedsignature(True) def cudaMemset2D(devPtr, size_t pitch, int value, size_t width, size_t height): @@ -29705,9 +28700,6 @@ def cudaMemset2D(devPtr, size_t pitch, int value, size_t width, size_t height): err = cyruntime.cudaMemset2D(cydevPtr, pitch, value, width, height) _helper_input_void_ptr_free(&cydevPtrHelper) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaMemset3D' in found_functions}} @cython.embedsignature(True) def cudaMemset3D(pitchedDevPtr not None : cudaPitchedPtr, int value, extent not None : cudaExtent): @@ -29759,9 +28751,6 @@ def cudaMemset3D(pitchedDevPtr not None : cudaPitchedPtr, int value, extent not with nogil: err = cyruntime.cudaMemset3D(pitchedDevPtr._pvt_ptr[0], value, extent._pvt_ptr[0]) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaMemsetAsync' in found_functions}} @cython.embedsignature(True) def cudaMemsetAsync(devPtr, int value, size_t count, stream): @@ -29813,9 +28802,6 @@ def cudaMemsetAsync(devPtr, int value, size_t count, stream): err = cyruntime.cudaMemsetAsync(cydevPtr, value, count, cystream) _helper_input_void_ptr_free(&cydevPtrHelper) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaMemset2DAsync' in found_functions}} @cython.embedsignature(True) def cudaMemset2DAsync(devPtr, size_t pitch, int value, size_t width, size_t height, stream): @@ -29874,9 +28860,6 @@ def cudaMemset2DAsync(devPtr, size_t pitch, int value, size_t width, size_t heig err = cyruntime.cudaMemset2DAsync(cydevPtr, pitch, value, width, height, cystream) _helper_input_void_ptr_free(&cydevPtrHelper) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaMemset3DAsync' in found_functions}} @cython.embedsignature(True) def cudaMemset3DAsync(pitchedDevPtr not None : cudaPitchedPtr, int value, extent not None : cudaExtent, stream): @@ -29944,9 +28927,6 @@ def cudaMemset3DAsync(pitchedDevPtr not None : cudaPitchedPtr, int value, extent with nogil: err = cyruntime.cudaMemset3DAsync(pitchedDevPtr._pvt_ptr[0], value, extent._pvt_ptr[0], cystream) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaMemPrefetchAsync' in found_functions}} @cython.embedsignature(True) def cudaMemPrefetchAsync(devPtr, size_t count, location not None : cudaMemLocation, unsigned int flags, stream): @@ -30063,9 +29043,6 @@ def cudaMemPrefetchAsync(devPtr, size_t count, location not None : cudaMemLocati err = cyruntime.cudaMemPrefetchAsync(cydevPtr, count, location._pvt_ptr[0], flags, cystream) _helper_input_void_ptr_free(&cydevPtrHelper) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaMemPrefetchBatchAsync' in found_functions}} @cython.embedsignature(True) def cudaMemPrefetchBatchAsync(dptrs : Optional[tuple[Any] | list[Any]], sizes : tuple[int] | list[int], size_t count, prefetchLocs : Optional[tuple[cudaMemLocation] | list[cudaMemLocation]], prefetchLocIdxs : tuple[int] | list[int], size_t numPrefetchLocs, unsigned long long flags, stream): @@ -30172,9 +29149,6 @@ def cudaMemPrefetchBatchAsync(dptrs : Optional[tuple[Any] | list[Any]], sizes : if len(prefetchLocs) > 1 and cyprefetchLocs is not NULL: free(cyprefetchLocs) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaMemDiscardBatchAsync' in found_functions}} @cython.embedsignature(True) def cudaMemDiscardBatchAsync(dptrs : Optional[tuple[Any] | list[Any]], sizes : tuple[int] | list[int], size_t count, unsigned long long flags, stream): @@ -30246,9 +29220,6 @@ def cudaMemDiscardBatchAsync(dptrs : Optional[tuple[Any] | list[Any]], sizes : t with nogil: err = cyruntime.cudaMemDiscardBatchAsync(cydptrs_ptr, cysizes.data(), count, flags, cystream) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaMemDiscardAndPrefetchBatchAsync' in found_functions}} @cython.embedsignature(True) def cudaMemDiscardAndPrefetchBatchAsync(dptrs : Optional[tuple[Any] | list[Any]], sizes : tuple[int] | list[int], size_t count, prefetchLocs : Optional[tuple[cudaMemLocation] | list[cudaMemLocation]], prefetchLocIdxs : tuple[int] | list[int], size_t numPrefetchLocs, unsigned long long flags, stream): @@ -30363,9 +29334,6 @@ def cudaMemDiscardAndPrefetchBatchAsync(dptrs : Optional[tuple[Any] | list[Any]] if len(prefetchLocs) > 1 and cyprefetchLocs is not NULL: free(cyprefetchLocs) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaMemAdvise' in found_functions}} @cython.embedsignature(True) def cudaMemAdvise(devPtr, size_t count, advice not None : cudaMemoryAdvise, location not None : cudaMemLocation): @@ -30561,9 +29529,6 @@ def cudaMemAdvise(devPtr, size_t count, advice not None : cudaMemoryAdvise, loca err = cyruntime.cudaMemAdvise(cydevPtr, count, cyadvice, location._pvt_ptr[0]) _helper_input_void_ptr_free(&cydevPtrHelper) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaMemRangeGetAttribute' in found_functions}} @cython.embedsignature(True) def cudaMemRangeGetAttribute(size_t dataSize, attribute not None : cudaMemRangeAttribute, devPtr, size_t count): @@ -30712,9 +29677,6 @@ def cudaMemRangeGetAttribute(size_t dataSize, attribute not None : cudaMemRangeA if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, cydata.pyObj()) -{{endif}} - -{{if 'cudaMemRangeGetAttributes' in found_functions}} @cython.embedsignature(True) def cudaMemRangeGetAttributes(dataSizes : tuple[int] | list[int], attributes : Optional[tuple[cudaMemRangeAttribute] | list[cudaMemRangeAttribute]], size_t numAttributes, devPtr, size_t count): @@ -30794,9 +29756,6 @@ def cudaMemRangeGetAttributes(dataSizes : tuple[int] | list[int], attributes : O if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, [obj.pyObj() for obj in pylist]) -{{endif}} - -{{if 'cudaMemcpyToArray' in found_functions}} @cython.embedsignature(True) def cudaMemcpyToArray(dst, size_t wOffset, size_t hOffset, src, size_t count, kind not None : cudaMemcpyKind): @@ -30854,9 +29813,6 @@ def cudaMemcpyToArray(dst, size_t wOffset, size_t hOffset, src, size_t count, ki err = cyruntime.cudaMemcpyToArray(cydst, wOffset, hOffset, cysrc, count, cykind) _helper_input_void_ptr_free(&cysrcHelper) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaMemcpyFromArray' in found_functions}} @cython.embedsignature(True) def cudaMemcpyFromArray(dst, src, size_t wOffset, size_t hOffset, size_t count, kind not None : cudaMemcpyKind): @@ -30914,9 +29870,6 @@ def cudaMemcpyFromArray(dst, src, size_t wOffset, size_t hOffset, size_t count, err = cyruntime.cudaMemcpyFromArray(cydst, cysrc, wOffset, hOffset, count, cykind) _helper_input_void_ptr_free(&cydstHelper) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaMemcpyArrayToArray' in found_functions}} @cython.embedsignature(True) def cudaMemcpyArrayToArray(dst, size_t wOffsetDst, size_t hOffsetDst, src, size_t wOffsetSrc, size_t hOffsetSrc, size_t count, kind not None : cudaMemcpyKind): @@ -30984,9 +29937,6 @@ def cudaMemcpyArrayToArray(dst, size_t wOffsetDst, size_t hOffsetDst, src, size_ with nogil: err = cyruntime.cudaMemcpyArrayToArray(cydst, wOffsetDst, hOffsetDst, cysrc, wOffsetSrc, hOffsetSrc, count, cykind) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaMemcpyToArrayAsync' in found_functions}} @cython.embedsignature(True) def cudaMemcpyToArrayAsync(dst, size_t wOffset, size_t hOffset, src, size_t count, kind not None : cudaMemcpyKind, stream): @@ -31061,9 +30011,6 @@ def cudaMemcpyToArrayAsync(dst, size_t wOffset, size_t hOffset, src, size_t coun err = cyruntime.cudaMemcpyToArrayAsync(cydst, wOffset, hOffset, cysrc, count, cykind, cystream) _helper_input_void_ptr_free(&cysrcHelper) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaMemcpyFromArrayAsync' in found_functions}} @cython.embedsignature(True) def cudaMemcpyFromArrayAsync(dst, src, size_t wOffset, size_t hOffset, size_t count, kind not None : cudaMemcpyKind, stream): @@ -31138,9 +30085,6 @@ def cudaMemcpyFromArrayAsync(dst, src, size_t wOffset, size_t hOffset, size_t co err = cyruntime.cudaMemcpyFromArrayAsync(cydst, cysrc, wOffset, hOffset, count, cykind, cystream) _helper_input_void_ptr_free(&cydstHelper) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaMallocAsync' in found_functions}} @cython.embedsignature(True) def cudaMallocAsync(size_t size, hStream): @@ -31193,9 +30137,6 @@ def cudaMallocAsync(size_t size, hStream): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, devPtr) -{{endif}} - -{{if 'cudaFreeAsync' in found_functions}} @cython.embedsignature(True) def cudaFreeAsync(devPtr, hStream): @@ -31240,9 +30181,6 @@ def cudaFreeAsync(devPtr, hStream): err = cyruntime.cudaFreeAsync(cydevPtr, cyhStream) _helper_input_void_ptr_free(&cydevPtrHelper) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaMemPoolTrimTo' in found_functions}} @cython.embedsignature(True) def cudaMemPoolTrimTo(memPool, size_t minBytesToKeep): @@ -31290,9 +30228,6 @@ def cudaMemPoolTrimTo(memPool, size_t minBytesToKeep): with nogil: err = cyruntime.cudaMemPoolTrimTo(cymemPool, minBytesToKeep) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaMemPoolSetAttribute' in found_functions}} @cython.embedsignature(True) def cudaMemPoolSetAttribute(memPool, attr not None : cudaMemPoolAttr, value): @@ -31366,9 +30301,6 @@ def cudaMemPoolSetAttribute(memPool, attr not None : cudaMemPoolAttr, value): with nogil: err = cyruntime.cudaMemPoolSetAttribute(cymemPool, cyattr, cyvalue_ptr) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaMemPoolGetAttribute' in found_functions}} @cython.embedsignature(True) def cudaMemPoolGetAttribute(memPool, attr not None : cudaMemPoolAttr): @@ -31481,9 +30413,6 @@ def cudaMemPoolGetAttribute(memPool, attr not None : cudaMemPoolAttr): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, cyvalue.pyObj()) -{{endif}} - -{{if 'cudaMemPoolSetAccess' in found_functions}} @cython.embedsignature(True) def cudaMemPoolSetAccess(memPool, descList : Optional[tuple[cudaMemAccessDesc] | list[cudaMemAccessDesc]], size_t count): @@ -31534,9 +30463,6 @@ def cudaMemPoolSetAccess(memPool, descList : Optional[tuple[cudaMemAccessDesc] | if len(descList) > 1 and cydescList is not NULL: free(cydescList) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaMemPoolGetAccess' in found_functions}} @cython.embedsignature(True) def cudaMemPoolGetAccess(memPool, location : Optional[cudaMemLocation]): @@ -31578,9 +30504,6 @@ def cudaMemPoolGetAccess(memPool, location : Optional[cudaMemLocation]): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, cudaMemAccessFlags(flags)) -{{endif}} - -{{if 'cudaMemPoolCreate' in found_functions}} @cython.embedsignature(True) def cudaMemPoolCreate(poolProps : Optional[cudaMemPoolProps]): @@ -31678,9 +30601,6 @@ def cudaMemPoolCreate(poolProps : Optional[cudaMemPoolProps]): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, memPool) -{{endif}} - -{{if 'cudaMemPoolDestroy' in found_functions}} @cython.embedsignature(True) def cudaMemPoolDestroy(memPool): @@ -31724,9 +30644,6 @@ def cudaMemPoolDestroy(memPool): with nogil: err = cyruntime.cudaMemPoolDestroy(cymemPool) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaMemGetDefaultMemPool' in found_functions}} @cython.embedsignature(True) def cudaMemGetDefaultMemPool(location : Optional[cudaMemLocation], typename not None : cudaMemAllocationType): @@ -31769,9 +30686,6 @@ def cudaMemGetDefaultMemPool(location : Optional[cudaMemLocation], typename not if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, memPool) -{{endif}} - -{{if 'cudaMemGetMemPool' in found_functions}} @cython.embedsignature(True) def cudaMemGetMemPool(location : Optional[cudaMemLocation], typename not None : cudaMemAllocationType): @@ -31823,9 +30737,6 @@ def cudaMemGetMemPool(location : Optional[cudaMemLocation], typename not None : if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, memPool) -{{endif}} - -{{if 'cudaMemSetMemPool' in found_functions}} @cython.embedsignature(True) def cudaMemSetMemPool(location : Optional[cudaMemLocation], typename not None : cudaMemAllocationType, memPool): @@ -31890,9 +30801,6 @@ def cudaMemSetMemPool(location : Optional[cudaMemLocation], typename not None : with nogil: err = cyruntime.cudaMemSetMemPool(cylocation_ptr, cytypename, cymemPool) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaMallocFromPoolAsync' in found_functions}} @cython.embedsignature(True) def cudaMallocFromPoolAsync(size_t size, memPool, stream): @@ -31949,9 +30857,6 @@ def cudaMallocFromPoolAsync(size_t size, memPool, stream): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, ptr) -{{endif}} - -{{if 'cudaMemPoolExportToShareableHandle' in found_functions}} @cython.embedsignature(True) def cudaMemPoolExportToShareableHandle(memPool, handleType not None : cudaMemAllocationHandleType, unsigned int flags): @@ -32006,9 +30911,6 @@ def cudaMemPoolExportToShareableHandle(memPool, handleType not None : cudaMemAll if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, cyshareableHandle.pyObj()) -{{endif}} - -{{if 'cudaMemPoolImportFromShareableHandle' in found_functions}} @cython.embedsignature(True) def cudaMemPoolImportFromShareableHandle(shareableHandle, handleType not None : cudaMemAllocationHandleType, unsigned int flags): @@ -32051,9 +30953,6 @@ def cudaMemPoolImportFromShareableHandle(shareableHandle, handleType not None : if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, memPool) -{{endif}} - -{{if 'cudaMemPoolExportPointer' in found_functions}} @cython.embedsignature(True) def cudaMemPoolExportPointer(ptr): @@ -32089,9 +30988,6 @@ def cudaMemPoolExportPointer(ptr): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, exportData) -{{endif}} - -{{if 'cudaMemPoolImportPointer' in found_functions}} @cython.embedsignature(True) def cudaMemPoolImportPointer(memPool, exportData : Optional[cudaMemPoolPtrExportData]): @@ -32142,9 +31038,6 @@ def cudaMemPoolImportPointer(memPool, exportData : Optional[cudaMemPoolPtrExport if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, ptr) -{{endif}} - -{{if 'cudaPointerGetAttributes' in found_functions}} @cython.embedsignature(True) def cudaPointerGetAttributes(ptr): @@ -32215,9 +31108,6 @@ def cudaPointerGetAttributes(ptr): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, attributes) -{{endif}} - -{{if 'cudaDeviceCanAccessPeer' in found_functions}} @cython.embedsignature(True) def cudaDeviceCanAccessPeer(int device, int peerDevice): @@ -32254,9 +31144,6 @@ def cudaDeviceCanAccessPeer(int device, int peerDevice): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, canAccessPeer) -{{endif}} - -{{if 'cudaDeviceEnablePeerAccess' in found_functions}} @cython.embedsignature(True) def cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags): @@ -32305,9 +31192,6 @@ def cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags): with nogil: err = cyruntime.cudaDeviceEnablePeerAccess(peerDevice, flags) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaDeviceDisablePeerAccess' in found_functions}} @cython.embedsignature(True) def cudaDeviceDisablePeerAccess(int peerDevice): @@ -32334,9 +31218,6 @@ def cudaDeviceDisablePeerAccess(int peerDevice): with nogil: err = cyruntime.cudaDeviceDisablePeerAccess(peerDevice) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaGraphicsUnregisterResource' in found_functions}} @cython.embedsignature(True) def cudaGraphicsUnregisterResource(resource): @@ -32373,9 +31254,6 @@ def cudaGraphicsUnregisterResource(resource): with nogil: err = cyruntime.cudaGraphicsUnregisterResource(cyresource) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaGraphicsResourceSetMapFlags' in found_functions}} @cython.embedsignature(True) def cudaGraphicsResourceSetMapFlags(resource, unsigned int flags): @@ -32429,9 +31307,6 @@ def cudaGraphicsResourceSetMapFlags(resource, unsigned int flags): with nogil: err = cyruntime.cudaGraphicsResourceSetMapFlags(cyresource, flags) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaGraphicsMapResources' in found_functions}} @cython.embedsignature(True) def cudaGraphicsMapResources(int count, resources, stream): @@ -32492,9 +31367,6 @@ def cudaGraphicsMapResources(int count, resources, stream): with nogil: err = cyruntime.cudaGraphicsMapResources(count, cyresources, cystream) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaGraphicsUnmapResources' in found_functions}} @cython.embedsignature(True) def cudaGraphicsUnmapResources(int count, resources, stream): @@ -32553,9 +31425,6 @@ def cudaGraphicsUnmapResources(int count, resources, stream): with nogil: err = cyruntime.cudaGraphicsUnmapResources(count, cyresources, cystream) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaGraphicsResourceGetMappedPointer' in found_functions}} @cython.embedsignature(True) def cudaGraphicsResourceGetMappedPointer(resource): @@ -32599,9 +31468,6 @@ def cudaGraphicsResourceGetMappedPointer(resource): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None, None) return (_cudaError_t_SUCCESS, devPtr, size) -{{endif}} - -{{if 'cudaGraphicsSubResourceGetMappedArray' in found_functions}} @cython.embedsignature(True) def cudaGraphicsSubResourceGetMappedArray(resource, unsigned int arrayIndex, unsigned int mipLevel): @@ -32656,9 +31522,6 @@ def cudaGraphicsSubResourceGetMappedArray(resource, unsigned int arrayIndex, uns if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, array) -{{endif}} - -{{if 'cudaGraphicsResourceGetMappedMipmappedArray' in found_functions}} @cython.embedsignature(True) def cudaGraphicsResourceGetMappedMipmappedArray(resource): @@ -32702,9 +31565,6 @@ def cudaGraphicsResourceGetMappedMipmappedArray(resource): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, mipmappedArray) -{{endif}} - -{{if 'cudaGetChannelDesc' in found_functions}} @cython.embedsignature(True) def cudaGetChannelDesc(array): @@ -32742,9 +31602,6 @@ def cudaGetChannelDesc(array): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, desc) -{{endif}} - -{{if 'cudaCreateChannelDesc' in found_functions}} @cython.embedsignature(True) def cudaCreateChannelDesc(int x, int y, int z, int w, f not None : cudaChannelFormatKind): @@ -32791,9 +31648,6 @@ def cudaCreateChannelDesc(int x, int y, int z, int w, f not None : cudaChannelFo cdef cudaChannelFormatDesc wrapper = cudaChannelFormatDesc() wrapper._pvt_ptr[0] = err return (cudaError_t.cudaSuccess, wrapper) -{{endif}} - -{{if 'cudaCreateTextureObject' in found_functions}} @cython.embedsignature(True) def cudaCreateTextureObject(pResDesc : Optional[cudaResourceDesc], pTexDesc : Optional[cudaTextureDesc], pResViewDesc : Optional[cudaResourceViewDesc]): @@ -33036,9 +31890,6 @@ def cudaCreateTextureObject(pResDesc : Optional[cudaResourceDesc], pTexDesc : Op if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pTexObject) -{{endif}} - -{{if 'cudaDestroyTextureObject' in found_functions}} @cython.embedsignature(True) def cudaDestroyTextureObject(texObject): @@ -33071,9 +31922,6 @@ def cudaDestroyTextureObject(texObject): with nogil: err = cyruntime.cudaDestroyTextureObject(cytexObject) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaGetTextureObjectResourceDesc' in found_functions}} @cython.embedsignature(True) def cudaGetTextureObjectResourceDesc(texObject): @@ -33112,9 +31960,6 @@ def cudaGetTextureObjectResourceDesc(texObject): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pResDesc) -{{endif}} - -{{if 'cudaGetTextureObjectTextureDesc' in found_functions}} @cython.embedsignature(True) def cudaGetTextureObjectTextureDesc(texObject): @@ -33153,9 +31998,6 @@ def cudaGetTextureObjectTextureDesc(texObject): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pTexDesc) -{{endif}} - -{{if 'cudaGetTextureObjectResourceViewDesc' in found_functions}} @cython.embedsignature(True) def cudaGetTextureObjectResourceViewDesc(texObject): @@ -33195,9 +32037,6 @@ def cudaGetTextureObjectResourceViewDesc(texObject): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pResViewDesc) -{{endif}} - -{{if 'cudaCreateSurfaceObject' in found_functions}} @cython.embedsignature(True) def cudaCreateSurfaceObject(pResDesc : Optional[cudaResourceDesc]): @@ -33237,9 +32076,6 @@ def cudaCreateSurfaceObject(pResDesc : Optional[cudaResourceDesc]): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pSurfObject) -{{endif}} - -{{if 'cudaDestroySurfaceObject' in found_functions}} @cython.embedsignature(True) def cudaDestroySurfaceObject(surfObject): @@ -33272,9 +32108,6 @@ def cudaDestroySurfaceObject(surfObject): with nogil: err = cyruntime.cudaDestroySurfaceObject(cysurfObject) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaGetSurfaceObjectResourceDesc' in found_functions}} @cython.embedsignature(True) def cudaGetSurfaceObjectResourceDesc(surfObject): @@ -33310,9 +32143,6 @@ def cudaGetSurfaceObjectResourceDesc(surfObject): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pResDesc) -{{endif}} - -{{if 'cudaDriverGetVersion' in found_functions}} @cython.embedsignature(True) def cudaDriverGetVersion(): @@ -33343,9 +32173,6 @@ def cudaDriverGetVersion(): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, driverVersion) -{{endif}} - -{{if 'cudaRuntimeGetVersion' in found_functions}} @cython.embedsignature(True) def cudaRuntimeGetVersion(): @@ -33379,9 +32206,6 @@ def cudaRuntimeGetVersion(): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, runtimeVersion) -{{endif}} - -{{if 'cudaLogsRegisterCallback' in found_functions}} @cython.embedsignature(True) def cudaLogsRegisterCallback(callbackFunc, userData): @@ -33420,9 +32244,6 @@ def cudaLogsRegisterCallback(callbackFunc, userData): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, callback_out) -{{endif}} - -{{if 'cudaLogsUnregisterCallback' in found_functions}} @cython.embedsignature(True) def cudaLogsUnregisterCallback(callback): @@ -33449,9 +32270,6 @@ def cudaLogsUnregisterCallback(callback): with nogil: err = cyruntime.cudaLogsUnregisterCallback(cycallback) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaLogsCurrent' in found_functions}} @cython.embedsignature(True) def cudaLogsCurrent(unsigned int flags): @@ -33475,9 +32293,6 @@ def cudaLogsCurrent(unsigned int flags): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, iterator_out) -{{endif}} - -{{if 'cudaLogsDumpToFile' in found_functions}} @cython.embedsignature(True) def cudaLogsDumpToFile(iterator : Optional[cudaLogIterator], char* pathToFile, unsigned int flags): @@ -33519,9 +32334,6 @@ def cudaLogsDumpToFile(iterator : Optional[cudaLogIterator], char* pathToFile, u if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, iterator) -{{endif}} - -{{if 'cudaLogsDumpToMemory' in found_functions}} @cython.embedsignature(True) def cudaLogsDumpToMemory(iterator : Optional[cudaLogIterator], char* buffer, size_t size, unsigned int flags): @@ -33577,9 +32389,6 @@ def cudaLogsDumpToMemory(iterator : Optional[cudaLogIterator], char* buffer, siz if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None, None) return (_cudaError_t_SUCCESS, iterator, size) -{{endif}} - -{{if 'cudaGraphCreate' in found_functions}} @cython.embedsignature(True) def cudaGraphCreate(unsigned int flags): @@ -33609,9 +32418,6 @@ def cudaGraphCreate(unsigned int flags): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pGraph) -{{endif}} - -{{if 'cudaGraphAddKernelNode' in found_functions}} @cython.embedsignature(True) def cudaGraphAddKernelNode(graph, pDependencies : Optional[tuple[cudaGraphNode_t] | list[cudaGraphNode_t]], size_t numDependencies, pNodeParams : Optional[cudaKernelNodeParams]): @@ -33731,9 +32537,6 @@ def cudaGraphAddKernelNode(graph, pDependencies : Optional[tuple[cudaGraphNode_t if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pGraphNode) -{{endif}} - -{{if 'cudaGraphKernelNodeGetParams' in found_functions}} @cython.embedsignature(True) def cudaGraphKernelNodeGetParams(node): @@ -33780,9 +32583,6 @@ def cudaGraphKernelNodeGetParams(node): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pNodeParams) -{{endif}} - -{{if 'cudaGraphKernelNodeSetParams' in found_functions}} @cython.embedsignature(True) def cudaGraphKernelNodeSetParams(node, pNodeParams : Optional[cudaKernelNodeParams]): @@ -33818,9 +32618,6 @@ def cudaGraphKernelNodeSetParams(node, pNodeParams : Optional[cudaKernelNodePara with nogil: err = cyruntime.cudaGraphKernelNodeSetParams(cynode, cypNodeParams_ptr) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaGraphKernelNodeCopyAttributes' in found_functions}} @cython.embedsignature(True) def cudaGraphKernelNodeCopyAttributes(hDst, hSrc): @@ -33865,9 +32662,6 @@ def cudaGraphKernelNodeCopyAttributes(hDst, hSrc): with nogil: err = cyruntime.cudaGraphKernelNodeCopyAttributes(cyhDst, cyhSrc) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaGraphKernelNodeGetAttribute' in found_functions}} @cython.embedsignature(True) def cudaGraphKernelNodeGetAttribute(hNode, attr not None : cudaKernelNodeAttrID): @@ -33882,14 +32676,12 @@ def cudaGraphKernelNodeGetAttribute(hNode, attr not None : cudaKernelNodeAttrID) attr : :py:obj:`~.cudaKernelNodeAttrID` - Returns ------- cudaError_t :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorInvalidResourceHandle` value_out : :py:obj:`~.cudaKernelNodeAttrValue` - See Also -------- :py:obj:`~.cudaAccessPolicyWindow` @@ -33909,9 +32701,6 @@ def cudaGraphKernelNodeGetAttribute(hNode, attr not None : cudaKernelNodeAttrID) if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, value_out) -{{endif}} - -{{if 'cudaGraphKernelNodeSetAttribute' in found_functions}} @cython.embedsignature(True) def cudaGraphKernelNodeSetAttribute(hNode, attr not None : cudaKernelNodeAttrID, value : Optional[cudaKernelNodeAttrValue]): @@ -33928,7 +32717,6 @@ def cudaGraphKernelNodeSetAttribute(hNode, attr not None : cudaKernelNodeAttrID, value : :py:obj:`~.cudaKernelNodeAttrValue` - Returns ------- cudaError_t @@ -33951,9 +32739,6 @@ def cudaGraphKernelNodeSetAttribute(hNode, attr not None : cudaKernelNodeAttrID, with nogil: err = cyruntime.cudaGraphKernelNodeSetAttribute(cyhNode, cyattr, cyvalue_ptr) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaGraphAddMemcpyNode' in found_functions}} @cython.embedsignature(True) def cudaGraphAddMemcpyNode(graph, pDependencies : Optional[tuple[cudaGraphNode_t] | list[cudaGraphNode_t]], size_t numDependencies, pCopyParams : Optional[cudaMemcpy3DParms]): @@ -34027,9 +32812,6 @@ def cudaGraphAddMemcpyNode(graph, pDependencies : Optional[tuple[cudaGraphNode_t if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pGraphNode) -{{endif}} - -{{if 'cudaGraphAddMemcpyNode1D' in found_functions}} @cython.embedsignature(True) def cudaGraphAddMemcpyNode1D(graph, pDependencies : Optional[tuple[cudaGraphNode_t] | list[cudaGraphNode_t]], size_t numDependencies, dst, src, size_t count, kind not None : cudaMemcpyKind): @@ -34124,9 +32906,6 @@ def cudaGraphAddMemcpyNode1D(graph, pDependencies : Optional[tuple[cudaGraphNode if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pGraphNode) -{{endif}} - -{{if 'cudaGraphMemcpyNodeGetParams' in found_functions}} @cython.embedsignature(True) def cudaGraphMemcpyNodeGetParams(node): @@ -34164,9 +32943,6 @@ def cudaGraphMemcpyNodeGetParams(node): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pNodeParams) -{{endif}} - -{{if 'cudaGraphMemcpyNodeSetParams' in found_functions}} @cython.embedsignature(True) def cudaGraphMemcpyNodeSetParams(node, pNodeParams : Optional[cudaMemcpy3DParms]): @@ -34202,9 +32978,6 @@ def cudaGraphMemcpyNodeSetParams(node, pNodeParams : Optional[cudaMemcpy3DParms] with nogil: err = cyruntime.cudaGraphMemcpyNodeSetParams(cynode, cypNodeParams_ptr) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaGraphMemcpyNodeSetParams1D' in found_functions}} @cython.embedsignature(True) def cudaGraphMemcpyNodeSetParams1D(node, dst, src, size_t count, kind not None : cudaMemcpyKind): @@ -34266,9 +33039,6 @@ def cudaGraphMemcpyNodeSetParams1D(node, dst, src, size_t count, kind not None : _helper_input_void_ptr_free(&cydstHelper) _helper_input_void_ptr_free(&cysrcHelper) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaGraphAddMemsetNode' in found_functions}} @cython.embedsignature(True) def cudaGraphAddMemsetNode(graph, pDependencies : Optional[tuple[cudaGraphNode_t] | list[cudaGraphNode_t]], size_t numDependencies, pMemsetParams : Optional[cudaMemsetParams]): @@ -34336,9 +33106,6 @@ def cudaGraphAddMemsetNode(graph, pDependencies : Optional[tuple[cudaGraphNode_t if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pGraphNode) -{{endif}} - -{{if 'cudaGraphMemsetNodeGetParams' in found_functions}} @cython.embedsignature(True) def cudaGraphMemsetNodeGetParams(node): @@ -34376,9 +33143,6 @@ def cudaGraphMemsetNodeGetParams(node): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pNodeParams) -{{endif}} - -{{if 'cudaGraphMemsetNodeSetParams' in found_functions}} @cython.embedsignature(True) def cudaGraphMemsetNodeSetParams(node, pNodeParams : Optional[cudaMemsetParams]): @@ -34414,9 +33178,6 @@ def cudaGraphMemsetNodeSetParams(node, pNodeParams : Optional[cudaMemsetParams]) with nogil: err = cyruntime.cudaGraphMemsetNodeSetParams(cynode, cypNodeParams_ptr) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaGraphAddHostNode' in found_functions}} @cython.embedsignature(True) def cudaGraphAddHostNode(graph, pDependencies : Optional[tuple[cudaGraphNode_t] | list[cudaGraphNode_t]], size_t numDependencies, pNodeParams : Optional[cudaHostNodeParams]): @@ -34485,9 +33246,6 @@ def cudaGraphAddHostNode(graph, pDependencies : Optional[tuple[cudaGraphNode_t] if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pGraphNode) -{{endif}} - -{{if 'cudaGraphHostNodeGetParams' in found_functions}} @cython.embedsignature(True) def cudaGraphHostNodeGetParams(node): @@ -34525,9 +33283,6 @@ def cudaGraphHostNodeGetParams(node): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pNodeParams) -{{endif}} - -{{if 'cudaGraphHostNodeSetParams' in found_functions}} @cython.embedsignature(True) def cudaGraphHostNodeSetParams(node, pNodeParams : Optional[cudaHostNodeParams]): @@ -34563,9 +33318,6 @@ def cudaGraphHostNodeSetParams(node, pNodeParams : Optional[cudaHostNodeParams]) with nogil: err = cyruntime.cudaGraphHostNodeSetParams(cynode, cypNodeParams_ptr) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaGraphAddChildGraphNode' in found_functions}} @cython.embedsignature(True) def cudaGraphAddChildGraphNode(graph, pDependencies : Optional[tuple[cudaGraphNode_t] | list[cudaGraphNode_t]], size_t numDependencies, childGraph): @@ -34644,9 +33396,6 @@ def cudaGraphAddChildGraphNode(graph, pDependencies : Optional[tuple[cudaGraphNo if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pGraphNode) -{{endif}} - -{{if 'cudaGraphChildGraphNodeGetGraph' in found_functions}} @cython.embedsignature(True) def cudaGraphChildGraphNodeGetGraph(node): @@ -34689,9 +33438,6 @@ def cudaGraphChildGraphNodeGetGraph(node): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pGraph) -{{endif}} - -{{if 'cudaGraphAddEmptyNode' in found_functions}} @cython.embedsignature(True) def cudaGraphAddEmptyNode(graph, pDependencies : Optional[tuple[cudaGraphNode_t] | list[cudaGraphNode_t]], size_t numDependencies): @@ -34760,9 +33506,6 @@ def cudaGraphAddEmptyNode(graph, pDependencies : Optional[tuple[cudaGraphNode_t] if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pGraphNode) -{{endif}} - -{{if 'cudaGraphAddEventRecordNode' in found_functions}} @cython.embedsignature(True) def cudaGraphAddEventRecordNode(graph, pDependencies : Optional[tuple[cudaGraphNode_t] | list[cudaGraphNode_t]], size_t numDependencies, event): @@ -34840,9 +33583,6 @@ def cudaGraphAddEventRecordNode(graph, pDependencies : Optional[tuple[cudaGraphN if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pGraphNode) -{{endif}} - -{{if 'cudaGraphEventRecordNodeGetEvent' in found_functions}} @cython.embedsignature(True) def cudaGraphEventRecordNodeGetEvent(node): @@ -34880,9 +33620,6 @@ def cudaGraphEventRecordNodeGetEvent(node): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, event_out) -{{endif}} - -{{if 'cudaGraphEventRecordNodeSetEvent' in found_functions}} @cython.embedsignature(True) def cudaGraphEventRecordNodeSetEvent(node, event): @@ -34925,9 +33662,6 @@ def cudaGraphEventRecordNodeSetEvent(node, event): with nogil: err = cyruntime.cudaGraphEventRecordNodeSetEvent(cynode, cyevent) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaGraphAddEventWaitNode' in found_functions}} @cython.embedsignature(True) def cudaGraphAddEventWaitNode(graph, pDependencies : Optional[tuple[cudaGraphNode_t] | list[cudaGraphNode_t]], size_t numDependencies, event): @@ -35008,9 +33742,6 @@ def cudaGraphAddEventWaitNode(graph, pDependencies : Optional[tuple[cudaGraphNod if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pGraphNode) -{{endif}} - -{{if 'cudaGraphEventWaitNodeGetEvent' in found_functions}} @cython.embedsignature(True) def cudaGraphEventWaitNodeGetEvent(node): @@ -35048,9 +33779,6 @@ def cudaGraphEventWaitNodeGetEvent(node): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, event_out) -{{endif}} - -{{if 'cudaGraphEventWaitNodeSetEvent' in found_functions}} @cython.embedsignature(True) def cudaGraphEventWaitNodeSetEvent(node, event): @@ -35093,9 +33821,6 @@ def cudaGraphEventWaitNodeSetEvent(node, event): with nogil: err = cyruntime.cudaGraphEventWaitNodeSetEvent(cynode, cyevent) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaGraphAddExternalSemaphoresSignalNode' in found_functions}} @cython.embedsignature(True) def cudaGraphAddExternalSemaphoresSignalNode(graph, pDependencies : Optional[tuple[cudaGraphNode_t] | list[cudaGraphNode_t]], size_t numDependencies, nodeParams : Optional[cudaExternalSemaphoreSignalNodeParams]): @@ -35165,9 +33890,6 @@ def cudaGraphAddExternalSemaphoresSignalNode(graph, pDependencies : Optional[tup if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pGraphNode) -{{endif}} - -{{if 'cudaGraphExternalSemaphoresSignalNodeGetParams' in found_functions}} @cython.embedsignature(True) def cudaGraphExternalSemaphoresSignalNodeGetParams(hNode): @@ -35211,9 +33933,6 @@ def cudaGraphExternalSemaphoresSignalNodeGetParams(hNode): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, params_out) -{{endif}} - -{{if 'cudaGraphExternalSemaphoresSignalNodeSetParams' in found_functions}} @cython.embedsignature(True) def cudaGraphExternalSemaphoresSignalNodeSetParams(hNode, nodeParams : Optional[cudaExternalSemaphoreSignalNodeParams]): @@ -35250,9 +33969,6 @@ def cudaGraphExternalSemaphoresSignalNodeSetParams(hNode, nodeParams : Optional[ with nogil: err = cyruntime.cudaGraphExternalSemaphoresSignalNodeSetParams(cyhNode, cynodeParams_ptr) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaGraphAddExternalSemaphoresWaitNode' in found_functions}} @cython.embedsignature(True) def cudaGraphAddExternalSemaphoresWaitNode(graph, pDependencies : Optional[tuple[cudaGraphNode_t] | list[cudaGraphNode_t]], size_t numDependencies, nodeParams : Optional[cudaExternalSemaphoreWaitNodeParams]): @@ -35322,9 +34038,6 @@ def cudaGraphAddExternalSemaphoresWaitNode(graph, pDependencies : Optional[tuple if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pGraphNode) -{{endif}} - -{{if 'cudaGraphExternalSemaphoresWaitNodeGetParams' in found_functions}} @cython.embedsignature(True) def cudaGraphExternalSemaphoresWaitNodeGetParams(hNode): @@ -35368,9 +34081,6 @@ def cudaGraphExternalSemaphoresWaitNodeGetParams(hNode): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, params_out) -{{endif}} - -{{if 'cudaGraphExternalSemaphoresWaitNodeSetParams' in found_functions}} @cython.embedsignature(True) def cudaGraphExternalSemaphoresWaitNodeSetParams(hNode, nodeParams : Optional[cudaExternalSemaphoreWaitNodeParams]): @@ -35407,9 +34117,6 @@ def cudaGraphExternalSemaphoresWaitNodeSetParams(hNode, nodeParams : Optional[cu with nogil: err = cyruntime.cudaGraphExternalSemaphoresWaitNodeSetParams(cyhNode, cynodeParams_ptr) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaGraphAddMemAllocNode' in found_functions}} @cython.embedsignature(True) def cudaGraphAddMemAllocNode(graph, pDependencies : Optional[tuple[cudaGraphNode_t] | list[cudaGraphNode_t]], size_t numDependencies, nodeParams : Optional[cudaMemAllocNodeParams]): @@ -35518,9 +34225,6 @@ def cudaGraphAddMemAllocNode(graph, pDependencies : Optional[tuple[cudaGraphNode if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pGraphNode) -{{endif}} - -{{if 'cudaGraphMemAllocNodeGetParams' in found_functions}} @cython.embedsignature(True) def cudaGraphMemAllocNodeGetParams(node): @@ -35561,9 +34265,6 @@ def cudaGraphMemAllocNodeGetParams(node): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, params_out) -{{endif}} - -{{if 'cudaGraphAddMemFreeNode' in found_functions}} @cython.embedsignature(True) def cudaGraphAddMemFreeNode(graph, pDependencies : Optional[tuple[cudaGraphNode_t] | list[cudaGraphNode_t]], size_t numDependencies, dptr): @@ -35652,9 +34353,6 @@ def cudaGraphAddMemFreeNode(graph, pDependencies : Optional[tuple[cudaGraphNode_ if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pGraphNode) -{{endif}} - -{{if 'cudaGraphMemFreeNodeGetParams' in found_functions}} @cython.embedsignature(True) def cudaGraphMemFreeNodeGetParams(node): @@ -35693,9 +34391,6 @@ def cudaGraphMemFreeNodeGetParams(node): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, dptr_out) -{{endif}} - -{{if 'cudaDeviceGraphMemTrim' in found_functions}} @cython.embedsignature(True) def cudaDeviceGraphMemTrim(int device): @@ -35722,9 +34417,6 @@ def cudaDeviceGraphMemTrim(int device): with nogil: err = cyruntime.cudaDeviceGraphMemTrim(device) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaDeviceGetGraphMemAttribute' in found_functions}} @cython.embedsignature(True) def cudaDeviceGetGraphMemAttribute(int device, attr not None : cudaGraphMemAttributeType): @@ -35773,9 +34465,6 @@ def cudaDeviceGetGraphMemAttribute(int device, attr not None : cudaGraphMemAttri if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, cyvalue.pyObj()) -{{endif}} - -{{if 'cudaDeviceSetGraphMemAttribute' in found_functions}} @cython.embedsignature(True) def cudaDeviceSetGraphMemAttribute(int device, attr not None : cudaGraphMemAttributeType, value): @@ -35815,9 +34504,6 @@ def cudaDeviceSetGraphMemAttribute(int device, attr not None : cudaGraphMemAttri with nogil: err = cyruntime.cudaDeviceSetGraphMemAttribute(device, cyattr, cyvalue_ptr) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaGraphClone' in found_functions}} @cython.embedsignature(True) def cudaGraphClone(originalGraph): @@ -35865,9 +34551,6 @@ def cudaGraphClone(originalGraph): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pGraphClone) -{{endif}} - -{{if 'cudaGraphNodeFindInClone' in found_functions}} @cython.embedsignature(True) def cudaGraphNodeFindInClone(originalNode, clonedGraph): @@ -35922,9 +34605,6 @@ def cudaGraphNodeFindInClone(originalNode, clonedGraph): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pNode) -{{endif}} - -{{if 'cudaGraphNodeGetType' in found_functions}} @cython.embedsignature(True) def cudaGraphNodeGetType(node): @@ -35962,9 +34642,6 @@ def cudaGraphNodeGetType(node): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, cudaGraphNodeType(pType)) -{{endif}} - -{{if 'cudaGraphNodeGetContainingGraph' in found_functions}} @cython.embedsignature(True) def cudaGraphNodeGetContainingGraph(hNode): @@ -36003,9 +34680,6 @@ def cudaGraphNodeGetContainingGraph(hNode): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, phGraph) -{{endif}} - -{{if 'cudaGraphNodeGetLocalId' in found_functions}} @cython.embedsignature(True) def cudaGraphNodeGetLocalId(hNode): @@ -36045,9 +34719,6 @@ def cudaGraphNodeGetLocalId(hNode): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, nodeId) -{{endif}} - -{{if 'cudaGraphNodeGetToolsId' in found_functions}} @cython.embedsignature(True) def cudaGraphNodeGetToolsId(hNode): @@ -36083,9 +34754,6 @@ def cudaGraphNodeGetToolsId(hNode): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, toolsNodeId) -{{endif}} - -{{if 'cudaGraphGetId' in found_functions}} @cython.embedsignature(True) def cudaGraphGetId(hGraph): @@ -36124,9 +34792,6 @@ def cudaGraphGetId(hGraph): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, graphID) -{{endif}} - -{{if 'cudaGraphExecGetId' in found_functions}} @cython.embedsignature(True) def cudaGraphExecGetId(hGraphExec): @@ -36165,9 +34830,6 @@ def cudaGraphExecGetId(hGraphExec): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, graphID) -{{endif}} - -{{if 'cudaGraphGetNodes' in found_functions}} @cython.embedsignature(True) def cudaGraphGetNodes(graph, size_t numNodes = 0): @@ -36226,9 +34888,6 @@ def cudaGraphGetNodes(graph, size_t numNodes = 0): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None, None) return (_cudaError_t_SUCCESS, pynodes, numNodes) -{{endif}} - -{{if 'cudaGraphGetRootNodes' in found_functions}} @cython.embedsignature(True) def cudaGraphGetRootNodes(graph, size_t pNumRootNodes = 0): @@ -36287,9 +34946,6 @@ def cudaGraphGetRootNodes(graph, size_t pNumRootNodes = 0): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None, None) return (_cudaError_t_SUCCESS, pypRootNodes, pNumRootNodes) -{{endif}} - -{{if 'cudaGraphGetEdges' in found_functions}} @cython.embedsignature(True) def cudaGraphGetEdges(graph, size_t numEdges = 0): @@ -36383,9 +35039,6 @@ def cudaGraphGetEdges(graph, size_t numEdges = 0): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None, None, None, None) return (_cudaError_t_SUCCESS, pyfrom_, pyto, pyedgeData, numEdges) -{{endif}} - -{{if 'cudaGraphNodeGetDependencies' in found_functions}} @cython.embedsignature(True) def cudaGraphNodeGetDependencies(node, size_t pNumDependencies = 0): @@ -36464,9 +35117,6 @@ def cudaGraphNodeGetDependencies(node, size_t pNumDependencies = 0): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None, None, None) return (_cudaError_t_SUCCESS, pypDependencies, pyedgeData, pNumDependencies) -{{endif}} - -{{if 'cudaGraphNodeGetDependentNodes' in found_functions}} @cython.embedsignature(True) def cudaGraphNodeGetDependentNodes(node, size_t pNumDependentNodes = 0): @@ -36545,9 +35195,6 @@ def cudaGraphNodeGetDependentNodes(node, size_t pNumDependentNodes = 0): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None, None, None) return (_cudaError_t_SUCCESS, pypDependentNodes, pyedgeData, pNumDependentNodes) -{{endif}} - -{{if 'cudaGraphAddDependencies' in found_functions}} @cython.embedsignature(True) def cudaGraphAddDependencies(graph, from_ : Optional[tuple[cudaGraphNode_t] | list[cudaGraphNode_t]], to : Optional[tuple[cudaGraphNode_t] | list[cudaGraphNode_t]], edgeData : Optional[tuple[cudaGraphEdgeData] | list[cudaGraphEdgeData]], size_t numDependencies): @@ -36638,9 +35285,6 @@ def cudaGraphAddDependencies(graph, from_ : Optional[tuple[cudaGraphNode_t] | li if len(edgeData) > 1 and cyedgeData is not NULL: free(cyedgeData) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaGraphRemoveDependencies' in found_functions}} @cython.embedsignature(True) def cudaGraphRemoveDependencies(graph, from_ : Optional[tuple[cudaGraphNode_t] | list[cudaGraphNode_t]], to : Optional[tuple[cudaGraphNode_t] | list[cudaGraphNode_t]], edgeData : Optional[tuple[cudaGraphEdgeData] | list[cudaGraphEdgeData]], size_t numDependencies): @@ -36734,9 +35378,6 @@ def cudaGraphRemoveDependencies(graph, from_ : Optional[tuple[cudaGraphNode_t] | if len(edgeData) > 1 and cyedgeData is not NULL: free(cyedgeData) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaGraphDestroyNode' in found_functions}} @cython.embedsignature(True) def cudaGraphDestroyNode(node): @@ -36773,9 +35414,6 @@ def cudaGraphDestroyNode(node): with nogil: err = cyruntime.cudaGraphDestroyNode(cynode) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaGraphInstantiate' in found_functions}} @cython.embedsignature(True) def cudaGraphInstantiate(graph, unsigned long long flags): @@ -36877,9 +35515,6 @@ def cudaGraphInstantiate(graph, unsigned long long flags): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pGraphExec) -{{endif}} - -{{if 'cudaGraphInstantiateWithFlags' in found_functions}} @cython.embedsignature(True) def cudaGraphInstantiateWithFlags(graph, unsigned long long flags): @@ -36983,9 +35618,6 @@ def cudaGraphInstantiateWithFlags(graph, unsigned long long flags): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pGraphExec) -{{endif}} - -{{if 'cudaGraphInstantiateWithParams' in found_functions}} @cython.embedsignature(True) def cudaGraphInstantiateWithParams(graph, instantiateParams : Optional[cudaGraphInstantiateParams]): @@ -37130,9 +35762,6 @@ def cudaGraphInstantiateWithParams(graph, instantiateParams : Optional[cudaGraph if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pGraphExec) -{{endif}} - -{{if 'cudaGraphExecGetFlags' in found_functions}} @cython.embedsignature(True) def cudaGraphExecGetFlags(graphExec): @@ -37173,9 +35802,6 @@ def cudaGraphExecGetFlags(graphExec): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, flags) -{{endif}} - -{{if 'cudaGraphExecKernelNodeSetParams' in found_functions}} @cython.embedsignature(True) def cudaGraphExecKernelNodeSetParams(hGraphExec, node, pNodeParams : Optional[cudaKernelNodeParams]): @@ -37255,9 +35881,6 @@ def cudaGraphExecKernelNodeSetParams(hGraphExec, node, pNodeParams : Optional[cu with nogil: err = cyruntime.cudaGraphExecKernelNodeSetParams(cyhGraphExec, cynode, cypNodeParams_ptr) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaGraphExecMemcpyNodeSetParams' in found_functions}} @cython.embedsignature(True) def cudaGraphExecMemcpyNodeSetParams(hGraphExec, node, pNodeParams : Optional[cudaMemcpy3DParms]): @@ -37320,9 +35943,6 @@ def cudaGraphExecMemcpyNodeSetParams(hGraphExec, node, pNodeParams : Optional[cu with nogil: err = cyruntime.cudaGraphExecMemcpyNodeSetParams(cyhGraphExec, cynode, cypNodeParams_ptr) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaGraphExecMemcpyNodeSetParams1D' in found_functions}} @cython.embedsignature(True) def cudaGraphExecMemcpyNodeSetParams1D(hGraphExec, node, dst, src, size_t count, kind not None : cudaMemcpyKind): @@ -37395,9 +36015,6 @@ def cudaGraphExecMemcpyNodeSetParams1D(hGraphExec, node, dst, src, size_t count, _helper_input_void_ptr_free(&cydstHelper) _helper_input_void_ptr_free(&cysrcHelper) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaGraphExecMemsetNodeSetParams' in found_functions}} @cython.embedsignature(True) def cudaGraphExecMemsetNodeSetParams(hGraphExec, node, pNodeParams : Optional[cudaMemsetParams]): @@ -37465,9 +36082,6 @@ def cudaGraphExecMemsetNodeSetParams(hGraphExec, node, pNodeParams : Optional[cu with nogil: err = cyruntime.cudaGraphExecMemsetNodeSetParams(cyhGraphExec, cynode, cypNodeParams_ptr) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaGraphExecHostNodeSetParams' in found_functions}} @cython.embedsignature(True) def cudaGraphExecHostNodeSetParams(hGraphExec, node, pNodeParams : Optional[cudaHostNodeParams]): @@ -37520,9 +36134,6 @@ def cudaGraphExecHostNodeSetParams(hGraphExec, node, pNodeParams : Optional[cuda with nogil: err = cyruntime.cudaGraphExecHostNodeSetParams(cyhGraphExec, cynode, cypNodeParams_ptr) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaGraphExecChildGraphNodeSetParams' in found_functions}} @cython.embedsignature(True) def cudaGraphExecChildGraphNodeSetParams(hGraphExec, node, childGraph): @@ -37590,9 +36201,6 @@ def cudaGraphExecChildGraphNodeSetParams(hGraphExec, node, childGraph): with nogil: err = cyruntime.cudaGraphExecChildGraphNodeSetParams(cyhGraphExec, cynode, cychildGraph) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaGraphExecEventRecordNodeSetEvent' in found_functions}} @cython.embedsignature(True) def cudaGraphExecEventRecordNodeSetEvent(hGraphExec, hNode, event): @@ -37653,9 +36261,6 @@ def cudaGraphExecEventRecordNodeSetEvent(hGraphExec, hNode, event): with nogil: err = cyruntime.cudaGraphExecEventRecordNodeSetEvent(cyhGraphExec, cyhNode, cyevent) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaGraphExecEventWaitNodeSetEvent' in found_functions}} @cython.embedsignature(True) def cudaGraphExecEventWaitNodeSetEvent(hGraphExec, hNode, event): @@ -37716,9 +36321,6 @@ def cudaGraphExecEventWaitNodeSetEvent(hGraphExec, hNode, event): with nogil: err = cyruntime.cudaGraphExecEventWaitNodeSetEvent(cyhGraphExec, cyhNode, cyevent) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaGraphExecExternalSemaphoresSignalNodeSetParams' in found_functions}} @cython.embedsignature(True) def cudaGraphExecExternalSemaphoresSignalNodeSetParams(hGraphExec, hNode, nodeParams : Optional[cudaExternalSemaphoreSignalNodeParams]): @@ -37776,9 +36378,6 @@ def cudaGraphExecExternalSemaphoresSignalNodeSetParams(hGraphExec, hNode, nodePa with nogil: err = cyruntime.cudaGraphExecExternalSemaphoresSignalNodeSetParams(cyhGraphExec, cyhNode, cynodeParams_ptr) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaGraphExecExternalSemaphoresWaitNodeSetParams' in found_functions}} @cython.embedsignature(True) def cudaGraphExecExternalSemaphoresWaitNodeSetParams(hGraphExec, hNode, nodeParams : Optional[cudaExternalSemaphoreWaitNodeParams]): @@ -37836,9 +36435,6 @@ def cudaGraphExecExternalSemaphoresWaitNodeSetParams(hGraphExec, hNode, nodePara with nogil: err = cyruntime.cudaGraphExecExternalSemaphoresWaitNodeSetParams(cyhGraphExec, cyhNode, cynodeParams_ptr) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaGraphNodeSetEnabled' in found_functions}} @cython.embedsignature(True) def cudaGraphNodeSetEnabled(hGraphExec, hNode, unsigned int isEnabled): @@ -37899,9 +36495,6 @@ def cudaGraphNodeSetEnabled(hGraphExec, hNode, unsigned int isEnabled): with nogil: err = cyruntime.cudaGraphNodeSetEnabled(cyhGraphExec, cyhNode, isEnabled) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaGraphNodeGetEnabled' in found_functions}} @cython.embedsignature(True) def cudaGraphNodeGetEnabled(hGraphExec, hNode): @@ -37958,9 +36551,6 @@ def cudaGraphNodeGetEnabled(hGraphExec, hNode): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, isEnabled) -{{endif}} - -{{if 'cudaGraphExecUpdate' in found_functions}} @cython.embedsignature(True) def cudaGraphExecUpdate(hGraphExec, hGraph): @@ -38134,9 +36724,6 @@ def cudaGraphExecUpdate(hGraphExec, hGraph): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, resultInfo) -{{endif}} - -{{if 'cudaGraphUpload' in found_functions}} @cython.embedsignature(True) def cudaGraphUpload(graphExec, stream): @@ -38183,9 +36770,6 @@ def cudaGraphUpload(graphExec, stream): with nogil: err = cyruntime.cudaGraphUpload(cygraphExec, cystream) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaGraphLaunch' in found_functions}} @cython.embedsignature(True) def cudaGraphLaunch(graphExec, stream): @@ -38237,9 +36821,6 @@ def cudaGraphLaunch(graphExec, stream): with nogil: err = cyruntime.cudaGraphLaunch(cygraphExec, cystream) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaGraphExecDestroy' in found_functions}} @cython.embedsignature(True) def cudaGraphExecDestroy(graphExec): @@ -38272,9 +36853,6 @@ def cudaGraphExecDestroy(graphExec): with nogil: err = cyruntime.cudaGraphExecDestroy(cygraphExec) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaGraphDestroy' in found_functions}} @cython.embedsignature(True) def cudaGraphDestroy(graph): @@ -38307,9 +36885,6 @@ def cudaGraphDestroy(graph): with nogil: err = cyruntime.cudaGraphDestroy(cygraph) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaGraphDebugDotPrint' in found_functions}} @cython.embedsignature(True) def cudaGraphDebugDotPrint(graph, char* path, unsigned int flags): @@ -38347,9 +36922,6 @@ def cudaGraphDebugDotPrint(graph, char* path, unsigned int flags): with nogil: err = cyruntime.cudaGraphDebugDotPrint(cygraph, path, flags) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaUserObjectCreate' in found_functions}} @cython.embedsignature(True) def cudaUserObjectCreate(ptr, destroy, unsigned int initialRefcount, unsigned int flags): @@ -38410,9 +36982,6 @@ def cudaUserObjectCreate(ptr, destroy, unsigned int initialRefcount, unsigned in if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, object_out) -{{endif}} - -{{if 'cudaUserObjectRetain' in found_functions}} @cython.embedsignature(True) def cudaUserObjectRetain(object, unsigned int count): @@ -38452,9 +37021,6 @@ def cudaUserObjectRetain(object, unsigned int count): with nogil: err = cyruntime.cudaUserObjectRetain(cyobject, count) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaUserObjectRelease' in found_functions}} @cython.embedsignature(True) def cudaUserObjectRelease(object, unsigned int count): @@ -38497,9 +37063,6 @@ def cudaUserObjectRelease(object, unsigned int count): with nogil: err = cyruntime.cudaUserObjectRelease(cyobject, count) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaGraphRetainUserObject' in found_functions}} @cython.embedsignature(True) def cudaGraphRetainUserObject(graph, object, unsigned int count, unsigned int flags): @@ -38553,9 +37116,6 @@ def cudaGraphRetainUserObject(graph, object, unsigned int count, unsigned int fl with nogil: err = cyruntime.cudaGraphRetainUserObject(cygraph, cyobject, count, flags) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaGraphReleaseUserObject' in found_functions}} @cython.embedsignature(True) def cudaGraphReleaseUserObject(graph, object, unsigned int count): @@ -38604,9 +37164,6 @@ def cudaGraphReleaseUserObject(graph, object, unsigned int count): with nogil: err = cyruntime.cudaGraphReleaseUserObject(cygraph, cyobject, count) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaGraphAddNode' in found_functions}} @cython.embedsignature(True) def cudaGraphAddNode(graph, pDependencies : Optional[tuple[cudaGraphNode_t] | list[cudaGraphNode_t]], dependencyData : Optional[tuple[cudaGraphEdgeData] | list[cudaGraphEdgeData]], size_t numDependencies, nodeParams : Optional[cudaGraphNodeParams]): @@ -38700,9 +37257,6 @@ def cudaGraphAddNode(graph, pDependencies : Optional[tuple[cudaGraphNode_t] | li if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pGraphNode) -{{endif}} - -{{if 'cudaGraphNodeSetParams' in found_functions}} @cython.embedsignature(True) def cudaGraphNodeSetParams(node, nodeParams : Optional[cudaGraphNodeParams]): @@ -38744,9 +37298,6 @@ def cudaGraphNodeSetParams(node, nodeParams : Optional[cudaGraphNodeParams]): with nogil: err = cyruntime.cudaGraphNodeSetParams(cynode, cynodeParams_ptr) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaGraphNodeGetParams' in found_functions}} @cython.embedsignature(True) def cudaGraphNodeGetParams(node): @@ -38797,9 +37348,6 @@ def cudaGraphNodeGetParams(node): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, nodeParams) -{{endif}} - -{{if 'cudaGraphExecNodeSetParams' in found_functions}} @cython.embedsignature(True) def cudaGraphExecNodeSetParams(graphExec, node, nodeParams : Optional[cudaGraphNodeParams]): @@ -38857,9 +37405,6 @@ def cudaGraphExecNodeSetParams(graphExec, node, nodeParams : Optional[cudaGraphN with nogil: err = cyruntime.cudaGraphExecNodeSetParams(cygraphExec, cynode, cynodeParams_ptr) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaGraphConditionalHandleCreate' in found_functions}} @cython.embedsignature(True) def cudaGraphConditionalHandleCreate(graph, unsigned int defaultLaunchValue, unsigned int flags): @@ -38909,9 +37454,6 @@ def cudaGraphConditionalHandleCreate(graph, unsigned int defaultLaunchValue, uns if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pHandle_out) -{{endif}} - -{{if 'cudaGraphConditionalHandleCreate_v2' in found_functions}} @cython.embedsignature(True) def cudaGraphConditionalHandleCreate_v2(graph, ctx, unsigned int defaultLaunchValue, unsigned int flags): @@ -38972,9 +37514,6 @@ def cudaGraphConditionalHandleCreate_v2(graph, ctx, unsigned int defaultLaunchVa if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pHandle_out) -{{endif}} - -{{if 'cudaGetDriverEntryPoint' in found_functions}} @cython.embedsignature(True) def cudaGetDriverEntryPoint(char* symbol, unsigned long long flags): @@ -39076,9 +37615,6 @@ def cudaGetDriverEntryPoint(char* symbol, unsigned long long flags): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None, None) return (_cudaError_t_SUCCESS, funcPtr, cudaDriverEntryPointQueryResult(driverStatus)) -{{endif}} - -{{if 'cudaGetDriverEntryPointByVersion' in found_functions}} @cython.embedsignature(True) def cudaGetDriverEntryPointByVersion(char* symbol, unsigned int cudaVersion, unsigned long long flags): @@ -39184,9 +37720,6 @@ def cudaGetDriverEntryPointByVersion(char* symbol, unsigned int cudaVersion, uns if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None, None) return (_cudaError_t_SUCCESS, funcPtr, cudaDriverEntryPointQueryResult(driverStatus)) -{{endif}} - -{{if 'cudaLibraryLoadData' in found_functions}} @cython.embedsignature(True) def cudaLibraryLoadData(code, jitOptions : Optional[tuple[cudaJitOption] | list[cudaJitOption]], jitOptionsValues : Optional[tuple[Any] | list[Any]], unsigned int numJitOptions, libraryOptions : Optional[tuple[cudaLibraryOption] | list[cudaLibraryOption]], libraryOptionValues : Optional[tuple[Any] | list[Any]], unsigned int numLibraryOptions): @@ -39284,9 +37817,6 @@ def cudaLibraryLoadData(code, jitOptions : Optional[tuple[cudaJitOption] | list[ if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, library) -{{endif}} - -{{if 'cudaLibraryLoadFromFile' in found_functions}} @cython.embedsignature(True) def cudaLibraryLoadFromFile(char* fileName, jitOptions : Optional[tuple[cudaJitOption] | list[cudaJitOption]], jitOptionsValues : Optional[tuple[Any] | list[Any]], unsigned int numJitOptions, libraryOptions : Optional[tuple[cudaLibraryOption] | list[cudaLibraryOption]], libraryOptionValues : Optional[tuple[Any] | list[Any]], unsigned int numLibraryOptions): @@ -39382,9 +37912,6 @@ def cudaLibraryLoadFromFile(char* fileName, jitOptions : Optional[tuple[cudaJitO if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, library) -{{endif}} - -{{if 'cudaLibraryUnload' in found_functions}} @cython.embedsignature(True) def cudaLibraryUnload(library): @@ -39417,9 +37944,6 @@ def cudaLibraryUnload(library): with nogil: err = cyruntime.cudaLibraryUnload(cylibrary) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaLibraryGetKernel' in found_functions}} @cython.embedsignature(True) def cudaLibraryGetKernel(library, char* name): @@ -39461,9 +37985,6 @@ def cudaLibraryGetKernel(library, char* name): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pKernel) -{{endif}} - -{{if 'cudaLibraryGetGlobal' in found_functions}} @cython.embedsignature(True) def cudaLibraryGetGlobal(library, char* name): @@ -39513,9 +38034,6 @@ def cudaLibraryGetGlobal(library, char* name): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None, None) return (_cudaError_t_SUCCESS, dptr, numbytes) -{{endif}} - -{{if 'cudaLibraryGetManaged' in found_functions}} @cython.embedsignature(True) def cudaLibraryGetManaged(library, char* name): @@ -39567,9 +38085,6 @@ def cudaLibraryGetManaged(library, char* name): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None, None) return (_cudaError_t_SUCCESS, dptr, numbytes) -{{endif}} - -{{if 'cudaLibraryGetUnifiedFunction' in found_functions}} @cython.embedsignature(True) def cudaLibraryGetUnifiedFunction(library, char* symbol): @@ -39613,9 +38128,6 @@ def cudaLibraryGetUnifiedFunction(library, char* symbol): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, fptr) -{{endif}} - -{{if 'cudaLibraryGetKernelCount' in found_functions}} @cython.embedsignature(True) def cudaLibraryGetKernelCount(lib): @@ -39653,9 +38165,6 @@ def cudaLibraryGetKernelCount(lib): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, count) -{{endif}} - -{{if 'cudaLibraryEnumerateKernels' in found_functions}} @cython.embedsignature(True) def cudaLibraryEnumerateKernels(unsigned int numKernels, lib): @@ -39706,9 +38215,6 @@ def cudaLibraryEnumerateKernels(unsigned int numKernels, lib): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pykernels) -{{endif}} - -{{if 'cudaKernelSetAttributeForDevice' in found_functions}} @cython.embedsignature(True) def cudaKernelSetAttributeForDevice(kernel, attr not None : cudaFuncAttribute, int value, int device): @@ -39812,9 +38318,6 @@ def cudaKernelSetAttributeForDevice(kernel, attr not None : cudaFuncAttribute, i with nogil: err = cyruntime.cudaKernelSetAttributeForDevice(cykernel, cyattr, value, device) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaDeviceGetDevResource' in found_functions}} @cython.embedsignature(True) def cudaDeviceGetDevResource(int device, typename not None : cudaDevResourceType): @@ -39851,9 +38354,6 @@ def cudaDeviceGetDevResource(int device, typename not None : cudaDevResourceType if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, resource) -{{endif}} - -{{if 'cudaDevSmResourceSplitByCount' in found_functions}} @cython.embedsignature(True) def cudaDevSmResourceSplitByCount(unsigned int nbGroups, input_ : Optional[cudaDevResource], unsigned int flags, unsigned int minCount): @@ -39972,9 +38472,6 @@ def cudaDevSmResourceSplitByCount(unsigned int nbGroups, input_ : Optional[cudaD if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None, None, None) return (_cudaError_t_SUCCESS, pyresult, cynbGroups, remaining) -{{endif}} - -{{if 'cudaDevSmResourceSplit' in found_functions}} @cython.embedsignature(True) def cudaDevSmResourceSplit(unsigned int nbGroups, input_ : Optional[cudaDevResource], unsigned int flags, groupParams : Optional[tuple[cudaDevSmResourceGroupParams] | list[cudaDevSmResourceGroupParams]]): @@ -40145,9 +38642,6 @@ def cudaDevSmResourceSplit(unsigned int nbGroups, input_ : Optional[cudaDevResou if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None, None) return (_cudaError_t_SUCCESS, pyresult, remainder) -{{endif}} - -{{if 'cudaDevResourceGenerateDesc' in found_functions}} @cython.embedsignature(True) def cudaDevResourceGenerateDesc(resources : Optional[tuple[cudaDevResource] | list[cudaDevResource]], unsigned int nbResources): @@ -40212,9 +38706,6 @@ def cudaDevResourceGenerateDesc(resources : Optional[tuple[cudaDevResource] | li if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, phDesc) -{{endif}} - -{{if 'cudaGreenCtxCreate' in found_functions}} @cython.embedsignature(True) def cudaGreenCtxCreate(desc, int device, unsigned int flags): @@ -40275,9 +38766,6 @@ def cudaGreenCtxCreate(desc, int device, unsigned int flags): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, phCtx) -{{endif}} - -{{if 'cudaExecutionCtxDestroy' in found_functions}} @cython.embedsignature(True) def cudaExecutionCtxDestroy(ctx): @@ -40334,9 +38822,6 @@ def cudaExecutionCtxDestroy(ctx): with nogil: err = cyruntime.cudaExecutionCtxDestroy(cyctx) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaExecutionCtxGetDevResource' in found_functions}} @cython.embedsignature(True) def cudaExecutionCtxGetDevResource(ctx, typename not None : cudaDevResourceType): @@ -40380,9 +38865,6 @@ def cudaExecutionCtxGetDevResource(ctx, typename not None : cudaDevResourceType) if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, resource) -{{endif}} - -{{if 'cudaExecutionCtxGetDevice' in found_functions}} @cython.embedsignature(True) def cudaExecutionCtxGetDevice(ctx): @@ -40422,9 +38904,6 @@ def cudaExecutionCtxGetDevice(ctx): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, device) -{{endif}} - -{{if 'cudaExecutionCtxGetId' in found_functions}} @cython.embedsignature(True) def cudaExecutionCtxGetId(ctx): @@ -40465,9 +38944,6 @@ def cudaExecutionCtxGetId(ctx): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, ctxId) -{{endif}} - -{{if 'cudaExecutionCtxStreamCreate' in found_functions}} @cython.embedsignature(True) def cudaExecutionCtxStreamCreate(ctx, unsigned int flags, int priority): @@ -40540,9 +39016,6 @@ def cudaExecutionCtxStreamCreate(ctx, unsigned int flags, int priority): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, phStream) -{{endif}} - -{{if 'cudaExecutionCtxSynchronize' in found_functions}} @cython.embedsignature(True) def cudaExecutionCtxSynchronize(ctx): @@ -40582,9 +39055,6 @@ def cudaExecutionCtxSynchronize(ctx): with nogil: err = cyruntime.cudaExecutionCtxSynchronize(cyctx) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaStreamGetDevResource' in found_functions}} @cython.embedsignature(True) def cudaStreamGetDevResource(hStream, typename not None : cudaDevResourceType): @@ -40630,9 +39100,6 @@ def cudaStreamGetDevResource(hStream, typename not None : cudaDevResourceType): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, resource) -{{endif}} - -{{if 'cudaExecutionCtxRecordEvent' in found_functions}} @cython.embedsignature(True) def cudaExecutionCtxRecordEvent(ctx, event): @@ -40689,9 +39156,6 @@ def cudaExecutionCtxRecordEvent(ctx, event): with nogil: err = cyruntime.cudaExecutionCtxRecordEvent(cyctx, cyevent) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaExecutionCtxWaitEvent' in found_functions}} @cython.embedsignature(True) def cudaExecutionCtxWaitEvent(ctx, event): @@ -40747,9 +39211,6 @@ def cudaExecutionCtxWaitEvent(ctx, event): with nogil: err = cyruntime.cudaExecutionCtxWaitEvent(cyctx, cyevent) return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaDeviceGetExecutionCtx' in found_functions}} @cython.embedsignature(True) def cudaDeviceGetExecutionCtx(int device): @@ -40787,9 +39248,6 @@ def cudaDeviceGetExecutionCtx(int device): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, ctx) -{{endif}} - -{{if 'cudaGetExportTable' in found_functions}} @cython.embedsignature(True) def cudaGetExportTable(pExportTableId : Optional[cudaUUID_t]): @@ -40801,9 +39259,6 @@ def cudaGetExportTable(pExportTableId : Optional[cudaUUID_t]): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, ppExportTable) -{{endif}} - -{{if 'cudaGetKernel' in found_functions}} @cython.embedsignature(True) def cudaGetKernel(entryFuncAddr): @@ -40846,9 +39301,6 @@ def cudaGetKernel(entryFuncAddr): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, kernelPtr) -{{endif}} - -{{if 'make_cudaPitchedPtr' in found_functions}} @cython.embedsignature(True) def make_cudaPitchedPtr(d, size_t p, size_t xsz, size_t ysz): @@ -40887,9 +39339,6 @@ def make_cudaPitchedPtr(d, size_t p, size_t xsz, size_t ysz): cdef cudaPitchedPtr wrapper = cudaPitchedPtr() wrapper._pvt_ptr[0] = err return wrapper -{{endif}} - -{{if 'make_cudaPos' in found_functions}} @cython.embedsignature(True) def make_cudaPos(size_t x, size_t y, size_t z): @@ -40923,9 +39372,6 @@ def make_cudaPos(size_t x, size_t y, size_t z): cdef cudaPos wrapper = cudaPos() wrapper._pvt_ptr[0] = err return wrapper -{{endif}} - -{{if 'make_cudaExtent' in found_functions}} @cython.embedsignature(True) def make_cudaExtent(size_t w, size_t h, size_t d): @@ -40960,19 +39406,17 @@ def make_cudaExtent(size_t w, size_t h, size_t d): cdef cudaExtent wrapper = cudaExtent() wrapper._pvt_ptr[0] = err return wrapper -{{endif}} - -{{if True}} @cython.embedsignature(True) def cudaGraphicsEGLRegisterImage(image, unsigned int flags): """ Registers an EGL image. - Registers the EGLImageKHR specified by `image` for access by CUDA. A - handle to the registered object is returned as `pCudaResource`. - Additional Mapping/Unmapping is not required for the registered - resource and :py:obj:`~.cudaGraphicsResourceGetMappedEglFrame` can be - directly called on the `pCudaResource`. + Registers the :py:obj:`~.EGLImageKHR` specified by `image` for access + by CUDA. A handle to the registered object is returned as + `pCudaResource`. Additional Mapping/Unmapping is not required for the + registered resource and + :py:obj:`~.cudaGraphicsResourceGetMappedEglFrame` can be directly + called on the `pCudaResource`. The application will be responsible for synchronizing access to shared objects. The application must ensure that any pending operation which @@ -41000,14 +39444,15 @@ def cudaGraphicsEGLRegisterImage(image, unsigned int flags): contents of the resource, so none of the data previously stored in the resource will be preserved. - The EGLImageKHR is an object which can be used to create EGLImage - target resource. It is defined as a void pointer. typedef void* - EGLImageKHR + The :py:obj:`~.EGLImageKHR` is an object which can be used to create + EGLImage target resource. It is defined as a void pointer. typedef + void* :py:obj:`~.EGLImageKHR` Parameters ---------- image : :py:obj:`~.EGLImageKHR` - An EGLImageKHR image which can be used to create target resource. + An :py:obj:`~.EGLImageKHR` image which can be used to create target + resource. flags : unsigned int Map flags @@ -41036,23 +39481,21 @@ def cudaGraphicsEGLRegisterImage(image, unsigned int flags): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, pCudaResource) -{{endif}} - -{{if True}} @cython.embedsignature(True) def cudaEGLStreamConsumerConnect(eglStream): """ Connect CUDA to EGLStream as a consumer. - Connect CUDA as a consumer to EGLStreamKHR specified by `eglStream`. + Connect CUDA as a consumer to :py:obj:`~.EGLStreamKHR` specified by + `eglStream`. - The EGLStreamKHR is an EGL object that transfers a sequence of image - frames from one API to another. + The :py:obj:`~.EGLStreamKHR` is an EGL object that transfers a sequence + of image frames from one API to another. Parameters ---------- eglStream : :py:obj:`~.EGLStreamKHR` - EGLStreamKHR handle + :py:obj:`~.EGLStreamKHR` handle Returns ------- @@ -41079,16 +39522,14 @@ def cudaEGLStreamConsumerConnect(eglStream): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, conn) -{{endif}} - -{{if True}} @cython.embedsignature(True) def cudaEGLStreamConsumerConnectWithFlags(eglStream, unsigned int flags): """ Connect CUDA to EGLStream as a consumer with given flags. - Connect CUDA as a consumer to EGLStreamKHR specified by `stream` with - specified `flags` defined by :py:obj:`~.cudaEglResourceLocationFlags`. + Connect CUDA as a consumer to :py:obj:`~.EGLStreamKHR` specified by + `stream` with specified `flags` defined by + :py:obj:`~.cudaEglResourceLocationFlags`. The flags specify whether the consumer wants to access frames from system memory or video memory. Default is @@ -41097,7 +39538,7 @@ def cudaEGLStreamConsumerConnectWithFlags(eglStream, unsigned int flags): Parameters ---------- eglStream : :py:obj:`~.EGLStreamKHR` - EGLStreamKHR handle + :py:obj:`~.EGLStreamKHR` handle flags : unsigned int Flags denote intended location - system or video. @@ -41126,15 +39567,12 @@ def cudaEGLStreamConsumerConnectWithFlags(eglStream, unsigned int flags): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, conn) -{{endif}} - -{{if True}} @cython.embedsignature(True) def cudaEGLStreamConsumerDisconnect(conn): """ Disconnect CUDA as a consumer to EGLStream . - Disconnect CUDA as a consumer to EGLStreamKHR. + Disconnect CUDA as a consumer to :py:obj:`~.EGLStreamKHR`. Parameters ---------- @@ -41163,15 +39601,12 @@ def cudaEGLStreamConsumerDisconnect(conn): with nogil: err = cyruntime.cudaEGLStreamConsumerDisconnect(cyconn) return (_cudaError_t(err),) -{{endif}} - -{{if True}} @cython.embedsignature(True) def cudaEGLStreamConsumerAcquireFrame(conn, pCudaResource, pStream, unsigned int timeout): """ Acquire an image frame from the EGLStream with CUDA as a consumer. - Acquire an image frame from EGLStreamKHR. + Acquire an image frame from :py:obj:`~.EGLStreamKHR`. :py:obj:`~.cudaGraphicsResourceGetMappedEglFrame` can be called on `pCudaResource` to get :py:obj:`~.cudaEglFrame`. @@ -41229,16 +39664,13 @@ def cudaEGLStreamConsumerAcquireFrame(conn, pCudaResource, pStream, unsigned int with nogil: err = cyruntime.cudaEGLStreamConsumerAcquireFrame(cyconn, cypCudaResource, cypStream, timeout) return (_cudaError_t(err),) -{{endif}} - -{{if True}} @cython.embedsignature(True) def cudaEGLStreamConsumerReleaseFrame(conn, pCudaResource, pStream): """ Releases the last frame acquired from the EGLStream. Release the acquired image frame specified by `pCudaResource` to - EGLStreamKHR. + :py:obj:`~.EGLStreamKHR`. Parameters ---------- @@ -41289,23 +39721,21 @@ def cudaEGLStreamConsumerReleaseFrame(conn, pCudaResource, pStream): with nogil: err = cyruntime.cudaEGLStreamConsumerReleaseFrame(cyconn, cypCudaResource, cypStream) return (_cudaError_t(err),) -{{endif}} - -{{if True}} @cython.embedsignature(True) def cudaEGLStreamProducerConnect(eglStream, width, height): """ Connect CUDA to EGLStream as a producer. - Connect CUDA as a producer to EGLStreamKHR specified by `stream`. + Connect CUDA as a producer to :py:obj:`~.EGLStreamKHR` specified by + `stream`. - The EGLStreamKHR is an EGL object that transfers a sequence of image - frames from one API to another. + The :py:obj:`~.EGLStreamKHR` is an EGL object that transfers a sequence + of image frames from one API to another. Parameters ---------- eglStream : :py:obj:`~.EGLStreamKHR` - EGLStreamKHR handle + :py:obj:`~.EGLStreamKHR` handle width : :py:obj:`~.EGLint` width of the image to be submitted to the stream height : :py:obj:`~.EGLint` @@ -41352,15 +39782,12 @@ def cudaEGLStreamProducerConnect(eglStream, width, height): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, conn) -{{endif}} - -{{if True}} @cython.embedsignature(True) def cudaEGLStreamProducerDisconnect(conn): """ Disconnect CUDA as a producer to EGLStream . - Disconnect CUDA as a producer to EGLStreamKHR. + Disconnect CUDA as a producer to :py:obj:`~.EGLStreamKHR`. Parameters ---------- @@ -41389,9 +39816,6 @@ def cudaEGLStreamProducerDisconnect(conn): with nogil: err = cyruntime.cudaEGLStreamProducerDisconnect(cyconn) return (_cudaError_t(err),) -{{endif}} - -{{if True}} @cython.embedsignature(True) def cudaEGLStreamProducerPresentFrame(conn, eglframe not None : cudaEglFrame, pStream): @@ -41449,9 +39873,6 @@ def cudaEGLStreamProducerPresentFrame(conn, eglframe not None : cudaEglFrame, pS with nogil: err = cyruntime.cudaEGLStreamProducerPresentFrame(cyconn, eglframe._pvt_ptr[0], cypStream) return (_cudaError_t(err),) -{{endif}} - -{{if True}} @cython.embedsignature(True) def cudaEGLStreamProducerReturnFrame(conn, eglframe : Optional[cudaEglFrame], pStream): @@ -41504,9 +39925,6 @@ def cudaEGLStreamProducerReturnFrame(conn, eglframe : Optional[cudaEglFrame], pS with nogil: err = cyruntime.cudaEGLStreamProducerReturnFrame(cyconn, cyeglframe_ptr, cypStream) return (_cudaError_t(err),) -{{endif}} - -{{if True}} @cython.embedsignature(True) def cudaGraphicsResourceGetMappedEglFrame(resource, unsigned int index, unsigned int mipLevel): @@ -41558,16 +39976,13 @@ def cudaGraphicsResourceGetMappedEglFrame(resource, unsigned int index, unsigned if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, eglFrame) -{{endif}} - -{{if True}} @cython.embedsignature(True) def cudaEventCreateFromEGLSync(eglSync, unsigned int flags): """ Creates an event from EGLSync object. - Creates an event *phEvent from an EGLSyncKHR eglSync with the flages - specified via `flags`. Valid flags include: + Creates an event *phEvent from an :py:obj:`~.EGLSyncKHR` eglSync with + the flages specified via `flags`. Valid flags include: - :py:obj:`~.cudaEventDefault`: Default event creation flag. @@ -41579,8 +39994,8 @@ def cudaEventCreateFromEGLSync(eglSync, unsigned int flags): :py:obj:`~.cudaEventRecord` and TimingData are not supported for events created from EGLSync. - The EGLSyncKHR is an opaque handle to an EGL sync object. typedef void* - EGLSyncKHR + The :py:obj:`~.EGLSyncKHR` is an opaque handle to an EGL sync object. + typedef void* :py:obj:`~.EGLSyncKHR` Parameters ---------- @@ -41614,9 +40029,6 @@ def cudaEventCreateFromEGLSync(eglSync, unsigned int flags): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, phEvent) -{{endif}} - -{{if 'cudaProfilerStart' in found_functions}} @cython.embedsignature(True) def cudaProfilerStart(): @@ -41642,9 +40054,6 @@ def cudaProfilerStart(): with nogil: err = cyruntime.cudaProfilerStart() return (_cudaError_t(err),) -{{endif}} - -{{if 'cudaProfilerStop' in found_functions}} @cython.embedsignature(True) def cudaProfilerStop(): @@ -41670,9 +40079,6 @@ def cudaProfilerStop(): with nogil: err = cyruntime.cudaProfilerStop() return (_cudaError_t(err),) -{{endif}} - -{{if True}} @cython.embedsignature(True) def cudaGLGetDevices(unsigned int cudaDeviceCount, deviceList not None : cudaGLDeviceList): @@ -41738,9 +40144,6 @@ def cudaGLGetDevices(unsigned int cudaDeviceCount, deviceList not None : cudaGLD if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None, None) return (_cudaError_t_SUCCESS, pCudaDeviceCount, pypCudaDevices) -{{endif}} - -{{if True}} @cython.embedsignature(True) def cudaGraphicsGLRegisterImage(image, target, unsigned int flags): @@ -41838,9 +40241,6 @@ def cudaGraphicsGLRegisterImage(image, target, unsigned int flags): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, resource) -{{endif}} - -{{if True}} @cython.embedsignature(True) def cudaGraphicsGLRegisterBuffer(buffer, unsigned int flags): @@ -41895,22 +40295,20 @@ def cudaGraphicsGLRegisterBuffer(buffer, unsigned int flags): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, resource) -{{endif}} - -{{if True}} @cython.embedsignature(True) def cudaVDPAUGetDevice(vdpDevice, vdpGetProcAddress): - """ Gets the CUDA device associated with a VdpDevice. + """ Gets the CUDA device associated with a :py:obj:`~.VdpDevice`. - Returns the CUDA device associated with a VdpDevice, if applicable. + Returns the CUDA device associated with a :py:obj:`~.VdpDevice`, if + applicable. Parameters ---------- vdpDevice : :py:obj:`~.VdpDevice` - A VdpDevice handle + A :py:obj:`~.VdpDevice` handle vdpGetProcAddress : :py:obj:`~.VdpGetProcAddress` - VDPAU's VdpGetProcAddress function pointer + VDPAU's :py:obj:`~.VdpGetProcAddress` function pointer Returns ------- @@ -41948,17 +40346,14 @@ def cudaVDPAUGetDevice(vdpDevice, vdpGetProcAddress): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, device) -{{endif}} - -{{if True}} @cython.embedsignature(True) def cudaVDPAUSetVDPAUDevice(int device, vdpDevice, vdpGetProcAddress): """ Sets a CUDA device to use VDPAU interoperability. - Records `vdpDevice` as the VdpDevice for VDPAU interoperability with - the CUDA device `device` and sets `device` as the current device for - the calling host thread. + Records `vdpDevice` as the :py:obj:`~.VdpDevice` for VDPAU + interoperability with the CUDA device `device` and sets `device` as the + current device for the calling host thread. This function will immediately initialize the primary context on `device` if needed. @@ -41973,9 +40368,9 @@ def cudaVDPAUSetVDPAUDevice(int device, vdpDevice, vdpGetProcAddress): device : int Device to use for VDPAU interoperability vdpDevice : :py:obj:`~.VdpDevice` - The VdpDevice to interoperate with + The :py:obj:`~.VdpDevice` to interoperate with vdpGetProcAddress : :py:obj:`~.VdpGetProcAddress` - VDPAU's VdpGetProcAddress function pointer + VDPAU's :py:obj:`~.VdpGetProcAddress` function pointer Returns ------- @@ -42007,17 +40402,15 @@ def cudaVDPAUSetVDPAUDevice(int device, vdpDevice, vdpGetProcAddress): with nogil: err = cyruntime.cudaVDPAUSetVDPAUDevice(device, cyvdpDevice, cyvdpGetProcAddress) return (_cudaError_t(err),) -{{endif}} - -{{if True}} @cython.embedsignature(True) def cudaGraphicsVDPAURegisterVideoSurface(vdpSurface, unsigned int flags): - """ Register a VdpVideoSurface object. + """ Register a :py:obj:`~.VdpVideoSurface` object. - Registers the VdpVideoSurface specified by `vdpSurface` for access by - CUDA. A handle to the registered object is returned as `resource`. The - surface's intended usage is specified using `flags`, as follows: + Registers the :py:obj:`~.VdpVideoSurface` specified by `vdpSurface` for + access by CUDA. A handle to the registered object is returned as + `resource`. The surface's intended usage is specified using `flags`, as + follows: - :py:obj:`~.cudaGraphicsMapFlagsNone`: Specifies no hints about how this resource will be used. It is therefore assumed that this @@ -42064,17 +40457,15 @@ def cudaGraphicsVDPAURegisterVideoSurface(vdpSurface, unsigned int flags): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, resource) -{{endif}} - -{{if True}} @cython.embedsignature(True) def cudaGraphicsVDPAURegisterOutputSurface(vdpSurface, unsigned int flags): - """ Register a VdpOutputSurface object. + """ Register a :py:obj:`~.VdpOutputSurface` object. - Registers the VdpOutputSurface specified by `vdpSurface` for access by - CUDA. A handle to the registered object is returned as `resource`. The - surface's intended usage is specified using `flags`, as follows: + Registers the :py:obj:`~.VdpOutputSurface` specified by `vdpSurface` + for access by CUDA. A handle to the registered object is returned as + `resource`. The surface's intended usage is specified using `flags`, as + follows: - :py:obj:`~.cudaGraphicsMapFlagsNone`: Specifies no hints about how this resource will be used. It is therefore assumed that this @@ -42121,8 +40512,6 @@ def cudaGraphicsVDPAURegisterOutputSurface(vdpSurface, unsigned int flags): if err != cyruntime.cudaSuccess: return (_cudaError_t(err), None) return (_cudaError_t_SUCCESS, resource) -{{endif}} - @cython.embedsignature(True) def getLocalRuntimeVersion(): @@ -42154,7 +40543,6 @@ def getLocalRuntimeVersion(): err = cyruntime.getLocalRuntimeVersion(&runtimeVersion) return (cudaError_t(err), runtimeVersion) - cdef class cudaBindingsRuntimeGlobal: cdef map[void_ptr, void*] _allocated @@ -42165,7 +40553,6 @@ cdef class cudaBindingsRuntimeGlobal: cdef cudaBindingsRuntimeGlobal m_global = cudaBindingsRuntimeGlobal() - @cython.embedsignature(True) def sizeof(objType): """ Returns the size of provided CUDA Python structure in bytes @@ -42180,501 +40567,500 @@ def sizeof(objType): lowered_name : int The size of `objType` in bytes """ - {{if 'dim3' in found_struct}} + if objType == dim3: - return sizeof(cyruntime.dim3){{endif}} - {{if 'cudaDevResourceDesc_t' in found_types}} + return sizeof(cyruntime.dim3) + if objType == cudaDevResourceDesc_t: - return sizeof(cyruntime.cudaDevResourceDesc_t){{endif}} - {{if 'cudaExecutionContext_t' in found_types}} + return sizeof(cyruntime.cudaDevResourceDesc_t) + if objType == cudaExecutionContext_t: - return sizeof(cyruntime.cudaExecutionContext_t){{endif}} - {{if 'cudaChannelFormatDesc' in found_struct}} + return sizeof(cyruntime.cudaExecutionContext_t) + if objType == cudaChannelFormatDesc: - return sizeof(cyruntime.cudaChannelFormatDesc){{endif}} - {{if 'cudaArray_t' in found_types}} + return sizeof(cyruntime.cudaChannelFormatDesc) + if objType == cudaArray_t: - return sizeof(cyruntime.cudaArray_t){{endif}} - {{if 'cudaArray_const_t' in found_types}} + return sizeof(cyruntime.cudaArray_t) + if objType == cudaArray_const_t: - return sizeof(cyruntime.cudaArray_const_t){{endif}} - {{if 'cudaMipmappedArray_t' in found_types}} + return sizeof(cyruntime.cudaArray_const_t) + if objType == cudaMipmappedArray_t: - return sizeof(cyruntime.cudaMipmappedArray_t){{endif}} - {{if 'cudaMipmappedArray_const_t' in found_types}} + return sizeof(cyruntime.cudaMipmappedArray_t) + if objType == cudaMipmappedArray_const_t: - return sizeof(cyruntime.cudaMipmappedArray_const_t){{endif}} - {{if 'cudaArraySparseProperties' in found_struct}} + return sizeof(cyruntime.cudaMipmappedArray_const_t) + if objType == cudaArraySparseProperties: - return sizeof(cyruntime.cudaArraySparseProperties){{endif}} - {{if 'cudaArrayMemoryRequirements' in found_struct}} + return sizeof(cyruntime.cudaArraySparseProperties) + if objType == cudaArrayMemoryRequirements: - return sizeof(cyruntime.cudaArrayMemoryRequirements){{endif}} - {{if 'cudaPitchedPtr' in found_struct}} + return sizeof(cyruntime.cudaArrayMemoryRequirements) + if objType == cudaPitchedPtr: - return sizeof(cyruntime.cudaPitchedPtr){{endif}} - {{if 'cudaExtent' in found_struct}} + return sizeof(cyruntime.cudaPitchedPtr) + if objType == cudaExtent: - return sizeof(cyruntime.cudaExtent){{endif}} - {{if 'cudaPos' in found_struct}} + return sizeof(cyruntime.cudaExtent) + if objType == cudaPos: - return sizeof(cyruntime.cudaPos){{endif}} - {{if 'cudaMemcpy3DParms' in found_struct}} + return sizeof(cyruntime.cudaPos) + if objType == cudaMemcpy3DParms: - return sizeof(cyruntime.cudaMemcpy3DParms){{endif}} - {{if 'cudaMemcpyNodeParams' in found_struct}} + return sizeof(cyruntime.cudaMemcpy3DParms) + if objType == cudaMemcpyNodeParams: - return sizeof(cyruntime.cudaMemcpyNodeParams){{endif}} - {{if 'cudaMemcpy3DPeerParms' in found_struct}} + return sizeof(cyruntime.cudaMemcpyNodeParams) + if objType == cudaMemcpy3DPeerParms: - return sizeof(cyruntime.cudaMemcpy3DPeerParms){{endif}} - {{if 'cudaMemsetParams' in found_struct}} + return sizeof(cyruntime.cudaMemcpy3DPeerParms) + if objType == cudaMemsetParams: - return sizeof(cyruntime.cudaMemsetParams){{endif}} - {{if 'cudaMemsetParamsV2' in found_struct}} + return sizeof(cyruntime.cudaMemsetParams) + if objType == cudaMemsetParamsV2: - return sizeof(cyruntime.cudaMemsetParamsV2){{endif}} - {{if 'cudaAccessPolicyWindow' in found_struct}} + return sizeof(cyruntime.cudaMemsetParamsV2) + if objType == cudaAccessPolicyWindow: - return sizeof(cyruntime.cudaAccessPolicyWindow){{endif}} - {{if 'cudaHostFn_t' in found_types}} + return sizeof(cyruntime.cudaAccessPolicyWindow) + if objType == cudaHostFn_t: - return sizeof(cyruntime.cudaHostFn_t){{endif}} - {{if 'cudaHostNodeParams' in found_struct}} + return sizeof(cyruntime.cudaHostFn_t) + if objType == cudaHostNodeParams: - return sizeof(cyruntime.cudaHostNodeParams){{endif}} - {{if 'cudaHostNodeParamsV2' in found_struct}} + return sizeof(cyruntime.cudaHostNodeParams) + if objType == cudaHostNodeParamsV2: - return sizeof(cyruntime.cudaHostNodeParamsV2){{endif}} - {{if 'cudaResourceDesc' in found_struct}} + return sizeof(cyruntime.cudaHostNodeParamsV2) + if objType == cudaResourceDesc: - return sizeof(cyruntime.cudaResourceDesc){{endif}} - {{if 'cudaResourceViewDesc' in found_struct}} + return sizeof(cyruntime.cudaResourceDesc) + if objType == cudaResourceViewDesc: - return sizeof(cyruntime.cudaResourceViewDesc){{endif}} - {{if 'cudaPointerAttributes' in found_struct}} + return sizeof(cyruntime.cudaResourceViewDesc) + if objType == cudaPointerAttributes: - return sizeof(cyruntime.cudaPointerAttributes){{endif}} - {{if 'cudaFuncAttributes' in found_struct}} + return sizeof(cyruntime.cudaPointerAttributes) + if objType == cudaFuncAttributes: - return sizeof(cyruntime.cudaFuncAttributes){{endif}} - {{if 'cudaMemLocation' in found_struct}} + return sizeof(cyruntime.cudaFuncAttributes) + if objType == cudaMemLocation: - return sizeof(cyruntime.cudaMemLocation){{endif}} - {{if 'cudaMemAccessDesc' in found_struct}} + return sizeof(cyruntime.cudaMemLocation) + if objType == cudaMemAccessDesc: - return sizeof(cyruntime.cudaMemAccessDesc){{endif}} - {{if 'cudaMemPoolProps' in found_struct}} + return sizeof(cyruntime.cudaMemAccessDesc) + if objType == cudaMemPoolProps: - return sizeof(cyruntime.cudaMemPoolProps){{endif}} - {{if 'cudaMemPoolPtrExportData' in found_struct}} + return sizeof(cyruntime.cudaMemPoolProps) + if objType == cudaMemPoolPtrExportData: - return sizeof(cyruntime.cudaMemPoolPtrExportData){{endif}} - {{if 'cudaMemAllocNodeParams' in found_struct}} + return sizeof(cyruntime.cudaMemPoolPtrExportData) + if objType == cudaMemAllocNodeParams: - return sizeof(cyruntime.cudaMemAllocNodeParams){{endif}} - {{if 'cudaMemAllocNodeParamsV2' in found_struct}} + return sizeof(cyruntime.cudaMemAllocNodeParams) + if objType == cudaMemAllocNodeParamsV2: - return sizeof(cyruntime.cudaMemAllocNodeParamsV2){{endif}} - {{if 'cudaMemFreeNodeParams' in found_struct}} + return sizeof(cyruntime.cudaMemAllocNodeParamsV2) + if objType == cudaMemFreeNodeParams: - return sizeof(cyruntime.cudaMemFreeNodeParams){{endif}} - {{if 'cudaMemcpyAttributes' in found_struct}} + return sizeof(cyruntime.cudaMemFreeNodeParams) + if objType == cudaMemcpyAttributes: - return sizeof(cyruntime.cudaMemcpyAttributes){{endif}} - {{if 'cudaOffset3D' in found_struct}} + return sizeof(cyruntime.cudaMemcpyAttributes) + if objType == cudaOffset3D: - return sizeof(cyruntime.cudaOffset3D){{endif}} - {{if 'cudaMemcpy3DOperand' in found_struct}} + return sizeof(cyruntime.cudaOffset3D) + if objType == cudaMemcpy3DOperand: - return sizeof(cyruntime.cudaMemcpy3DOperand){{endif}} - {{if 'cudaMemcpy3DBatchOp' in found_struct}} + return sizeof(cyruntime.cudaMemcpy3DOperand) + if objType == cudaMemcpy3DBatchOp: - return sizeof(cyruntime.cudaMemcpy3DBatchOp){{endif}} - {{if 'CUuuid_st' in found_struct}} + return sizeof(cyruntime.cudaMemcpy3DBatchOp) + if objType == CUuuid_st: - return sizeof(cyruntime.CUuuid_st){{endif}} - {{if 'CUuuid' in found_types}} + return sizeof(cyruntime.CUuuid_st) + if objType == CUuuid: - return sizeof(cyruntime.CUuuid){{endif}} - {{if 'cudaUUID_t' in found_types}} + return sizeof(cyruntime.CUuuid) + if objType == cudaUUID_t: - return sizeof(cyruntime.cudaUUID_t){{endif}} - {{if 'cudaDeviceProp' in found_struct}} + return sizeof(cyruntime.cudaUUID_t) + if objType == cudaDeviceProp: - return sizeof(cyruntime.cudaDeviceProp){{endif}} - {{if 'cudaIpcEventHandle_st' in found_struct}} + return sizeof(cyruntime.cudaDeviceProp) + if objType == cudaIpcEventHandle_st: - return sizeof(cyruntime.cudaIpcEventHandle_st){{endif}} - {{if 'cudaIpcEventHandle_t' in found_types}} + return sizeof(cyruntime.cudaIpcEventHandle_st) + if objType == cudaIpcEventHandle_t: - return sizeof(cyruntime.cudaIpcEventHandle_t){{endif}} - {{if 'cudaIpcMemHandle_st' in found_struct}} + return sizeof(cyruntime.cudaIpcEventHandle_t) + if objType == cudaIpcMemHandle_st: - return sizeof(cyruntime.cudaIpcMemHandle_st){{endif}} - {{if 'cudaIpcMemHandle_t' in found_types}} + return sizeof(cyruntime.cudaIpcMemHandle_st) + if objType == cudaIpcMemHandle_t: - return sizeof(cyruntime.cudaIpcMemHandle_t){{endif}} - {{if 'cudaMemFabricHandle_st' in found_struct}} + return sizeof(cyruntime.cudaIpcMemHandle_t) + if objType == cudaMemFabricHandle_st: - return sizeof(cyruntime.cudaMemFabricHandle_st){{endif}} - {{if 'cudaMemFabricHandle_t' in found_types}} + return sizeof(cyruntime.cudaMemFabricHandle_st) + if objType == cudaMemFabricHandle_t: - return sizeof(cyruntime.cudaMemFabricHandle_t){{endif}} - {{if 'cudaExternalMemoryHandleDesc' in found_struct}} + return sizeof(cyruntime.cudaMemFabricHandle_t) + if objType == cudaExternalMemoryHandleDesc: - return sizeof(cyruntime.cudaExternalMemoryHandleDesc){{endif}} - {{if 'cudaExternalMemoryBufferDesc' in found_struct}} + return sizeof(cyruntime.cudaExternalMemoryHandleDesc) + if objType == cudaExternalMemoryBufferDesc: - return sizeof(cyruntime.cudaExternalMemoryBufferDesc){{endif}} - {{if 'cudaExternalMemoryMipmappedArrayDesc' in found_struct}} + return sizeof(cyruntime.cudaExternalMemoryBufferDesc) + if objType == cudaExternalMemoryMipmappedArrayDesc: - return sizeof(cyruntime.cudaExternalMemoryMipmappedArrayDesc){{endif}} - {{if 'cudaExternalSemaphoreHandleDesc' in found_struct}} + return sizeof(cyruntime.cudaExternalMemoryMipmappedArrayDesc) + if objType == cudaExternalSemaphoreHandleDesc: - return sizeof(cyruntime.cudaExternalSemaphoreHandleDesc){{endif}} - {{if 'cudaExternalSemaphoreSignalParams' in found_struct}} + return sizeof(cyruntime.cudaExternalSemaphoreHandleDesc) + if objType == cudaExternalSemaphoreSignalParams: - return sizeof(cyruntime.cudaExternalSemaphoreSignalParams){{endif}} - {{if 'cudaExternalSemaphoreWaitParams' in found_struct}} + return sizeof(cyruntime.cudaExternalSemaphoreSignalParams) + if objType == cudaExternalSemaphoreWaitParams: - return sizeof(cyruntime.cudaExternalSemaphoreWaitParams){{endif}} - {{if 'cudaDevSmResource' in found_struct}} + return sizeof(cyruntime.cudaExternalSemaphoreWaitParams) + if objType == cudaDevSmResource: - return sizeof(cyruntime.cudaDevSmResource){{endif}} - {{if 'cudaDevWorkqueueConfigResource' in found_struct}} + return sizeof(cyruntime.cudaDevSmResource) + if objType == cudaDevWorkqueueConfigResource: - return sizeof(cyruntime.cudaDevWorkqueueConfigResource){{endif}} - {{if 'cudaDevWorkqueueResource' in found_struct}} + return sizeof(cyruntime.cudaDevWorkqueueConfigResource) + if objType == cudaDevWorkqueueResource: - return sizeof(cyruntime.cudaDevWorkqueueResource){{endif}} - {{if 'cudaDevSmResourceGroupParams_st' in found_struct}} + return sizeof(cyruntime.cudaDevWorkqueueResource) + if objType == cudaDevSmResourceGroupParams_st: - return sizeof(cyruntime.cudaDevSmResourceGroupParams_st){{endif}} - {{if 'cudaDevSmResourceGroupParams' in found_types}} + return sizeof(cyruntime.cudaDevSmResourceGroupParams_st) + if objType == cudaDevSmResourceGroupParams: - return sizeof(cyruntime.cudaDevSmResourceGroupParams){{endif}} - {{if 'cudaDevResource_st' in found_struct}} + return sizeof(cyruntime.cudaDevSmResourceGroupParams) + if objType == cudaDevResource_st: - return sizeof(cyruntime.cudaDevResource_st){{endif}} - {{if 'cudaDevResource' in found_types}} + return sizeof(cyruntime.cudaDevResource_st) + if objType == cudaDevResource: - return sizeof(cyruntime.cudaDevResource){{endif}} - {{if 'cudaStream_t' in found_types}} + return sizeof(cyruntime.cudaDevResource) + if objType == cudaStream_t: - return sizeof(cyruntime.cudaStream_t){{endif}} - {{if 'cudaEvent_t' in found_types}} + return sizeof(cyruntime.cudaStream_t) + if objType == cudaEvent_t: - return sizeof(cyruntime.cudaEvent_t){{endif}} - {{if 'cudaGraphicsResource_t' in found_types}} + return sizeof(cyruntime.cudaEvent_t) + if objType == cudaGraphicsResource_t: - return sizeof(cyruntime.cudaGraphicsResource_t){{endif}} - {{if 'cudaExternalMemory_t' in found_types}} + return sizeof(cyruntime.cudaGraphicsResource_t) + if objType == cudaExternalMemory_t: - return sizeof(cyruntime.cudaExternalMemory_t){{endif}} - {{if 'cudaExternalSemaphore_t' in found_types}} + return sizeof(cyruntime.cudaExternalMemory_t) + if objType == cudaExternalSemaphore_t: - return sizeof(cyruntime.cudaExternalSemaphore_t){{endif}} - {{if 'cudaGraph_t' in found_types}} + return sizeof(cyruntime.cudaExternalSemaphore_t) + if objType == cudaGraph_t: - return sizeof(cyruntime.cudaGraph_t){{endif}} - {{if 'cudaGraphNode_t' in found_types}} + return sizeof(cyruntime.cudaGraph_t) + if objType == cudaGraphNode_t: - return sizeof(cyruntime.cudaGraphNode_t){{endif}} - {{if 'cudaUserObject_t' in found_types}} + return sizeof(cyruntime.cudaGraphNode_t) + if objType == cudaUserObject_t: - return sizeof(cyruntime.cudaUserObject_t){{endif}} - {{if 'cudaGraphConditionalHandle' in found_types}} + return sizeof(cyruntime.cudaUserObject_t) + if objType == cudaGraphConditionalHandle: - return sizeof(cyruntime.cudaGraphConditionalHandle){{endif}} - {{if 'cudaFunction_t' in found_types}} + return sizeof(cyruntime.cudaGraphConditionalHandle) + if objType == cudaFunction_t: - return sizeof(cyruntime.cudaFunction_t){{endif}} - {{if 'cudaKernel_t' in found_types}} + return sizeof(cyruntime.cudaFunction_t) + if objType == cudaKernel_t: - return sizeof(cyruntime.cudaKernel_t){{endif}} - {{if 'cudalibraryHostUniversalFunctionAndDataTable' in found_struct}} + return sizeof(cyruntime.cudaKernel_t) + if objType == cudalibraryHostUniversalFunctionAndDataTable: - return sizeof(cyruntime.cudalibraryHostUniversalFunctionAndDataTable){{endif}} - {{if 'cudaLibrary_t' in found_types}} + return sizeof(cyruntime.cudalibraryHostUniversalFunctionAndDataTable) + if objType == cudaLibrary_t: - return sizeof(cyruntime.cudaLibrary_t){{endif}} - {{if 'cudaMemPool_t' in found_types}} + return sizeof(cyruntime.cudaLibrary_t) + if objType == cudaMemPool_t: - return sizeof(cyruntime.cudaMemPool_t){{endif}} - {{if 'cudaKernelNodeParams' in found_struct}} + return sizeof(cyruntime.cudaMemPool_t) + if objType == cudaKernelNodeParams: - return sizeof(cyruntime.cudaKernelNodeParams){{endif}} - {{if 'cudaKernelNodeParamsV2' in found_struct}} + return sizeof(cyruntime.cudaKernelNodeParams) + if objType == cudaKernelNodeParamsV2: - return sizeof(cyruntime.cudaKernelNodeParamsV2){{endif}} - {{if 'cudaExternalSemaphoreSignalNodeParams' in found_struct}} + return sizeof(cyruntime.cudaKernelNodeParamsV2) + if objType == cudaExternalSemaphoreSignalNodeParams: - return sizeof(cyruntime.cudaExternalSemaphoreSignalNodeParams){{endif}} - {{if 'cudaExternalSemaphoreSignalNodeParamsV2' in found_struct}} + return sizeof(cyruntime.cudaExternalSemaphoreSignalNodeParams) + if objType == cudaExternalSemaphoreSignalNodeParamsV2: - return sizeof(cyruntime.cudaExternalSemaphoreSignalNodeParamsV2){{endif}} - {{if 'cudaExternalSemaphoreWaitNodeParams' in found_struct}} + return sizeof(cyruntime.cudaExternalSemaphoreSignalNodeParamsV2) + if objType == cudaExternalSemaphoreWaitNodeParams: - return sizeof(cyruntime.cudaExternalSemaphoreWaitNodeParams){{endif}} - {{if 'cudaExternalSemaphoreWaitNodeParamsV2' in found_struct}} + return sizeof(cyruntime.cudaExternalSemaphoreWaitNodeParams) + if objType == cudaExternalSemaphoreWaitNodeParamsV2: - return sizeof(cyruntime.cudaExternalSemaphoreWaitNodeParamsV2){{endif}} - {{if 'cudaConditionalNodeParams' in found_struct}} + return sizeof(cyruntime.cudaExternalSemaphoreWaitNodeParamsV2) + if objType == cudaConditionalNodeParams: - return sizeof(cyruntime.cudaConditionalNodeParams){{endif}} - {{if 'cudaChildGraphNodeParams' in found_struct}} + return sizeof(cyruntime.cudaConditionalNodeParams) + if objType == cudaChildGraphNodeParams: - return sizeof(cyruntime.cudaChildGraphNodeParams){{endif}} - {{if 'cudaEventRecordNodeParams' in found_struct}} + return sizeof(cyruntime.cudaChildGraphNodeParams) + if objType == cudaEventRecordNodeParams: - return sizeof(cyruntime.cudaEventRecordNodeParams){{endif}} - {{if 'cudaEventWaitNodeParams' in found_struct}} + return sizeof(cyruntime.cudaEventRecordNodeParams) + if objType == cudaEventWaitNodeParams: - return sizeof(cyruntime.cudaEventWaitNodeParams){{endif}} - {{if 'cudaGraphNodeParams' in found_struct}} + return sizeof(cyruntime.cudaEventWaitNodeParams) + if objType == cudaGraphNodeParams: - return sizeof(cyruntime.cudaGraphNodeParams){{endif}} - {{if 'cudaGraphEdgeData_st' in found_struct}} + return sizeof(cyruntime.cudaGraphNodeParams) + if objType == cudaGraphEdgeData_st: - return sizeof(cyruntime.cudaGraphEdgeData_st){{endif}} - {{if 'cudaGraphEdgeData' in found_types}} + return sizeof(cyruntime.cudaGraphEdgeData_st) + if objType == cudaGraphEdgeData: - return sizeof(cyruntime.cudaGraphEdgeData){{endif}} - {{if 'cudaGraphExec_t' in found_types}} + return sizeof(cyruntime.cudaGraphEdgeData) + if objType == cudaGraphExec_t: - return sizeof(cyruntime.cudaGraphExec_t){{endif}} - {{if 'cudaGraphInstantiateParams_st' in found_struct}} + return sizeof(cyruntime.cudaGraphExec_t) + if objType == cudaGraphInstantiateParams_st: - return sizeof(cyruntime.cudaGraphInstantiateParams_st){{endif}} - {{if 'cudaGraphInstantiateParams' in found_types}} + return sizeof(cyruntime.cudaGraphInstantiateParams_st) + if objType == cudaGraphInstantiateParams: - return sizeof(cyruntime.cudaGraphInstantiateParams){{endif}} - {{if 'cudaGraphExecUpdateResultInfo_st' in found_struct}} + return sizeof(cyruntime.cudaGraphInstantiateParams) + if objType == cudaGraphExecUpdateResultInfo_st: - return sizeof(cyruntime.cudaGraphExecUpdateResultInfo_st){{endif}} - {{if 'cudaGraphExecUpdateResultInfo' in found_types}} + return sizeof(cyruntime.cudaGraphExecUpdateResultInfo_st) + if objType == cudaGraphExecUpdateResultInfo: - return sizeof(cyruntime.cudaGraphExecUpdateResultInfo){{endif}} - {{if 'cudaGraphDeviceNode_t' in found_types}} + return sizeof(cyruntime.cudaGraphExecUpdateResultInfo) + if objType == cudaGraphDeviceNode_t: - return sizeof(cyruntime.cudaGraphDeviceNode_t){{endif}} - {{if 'cudaGraphKernelNodeUpdate' in found_struct}} + return sizeof(cyruntime.cudaGraphDeviceNode_t) + if objType == cudaGraphKernelNodeUpdate: - return sizeof(cyruntime.cudaGraphKernelNodeUpdate){{endif}} - {{if 'cudaLaunchMemSyncDomainMap_st' in found_struct}} + return sizeof(cyruntime.cudaGraphKernelNodeUpdate) + if objType == cudaLaunchMemSyncDomainMap_st: - return sizeof(cyruntime.cudaLaunchMemSyncDomainMap_st){{endif}} - {{if 'cudaLaunchMemSyncDomainMap' in found_types}} + return sizeof(cyruntime.cudaLaunchMemSyncDomainMap_st) + if objType == cudaLaunchMemSyncDomainMap: - return sizeof(cyruntime.cudaLaunchMemSyncDomainMap){{endif}} - {{if 'cudaLaunchAttributeValue' in found_struct}} + return sizeof(cyruntime.cudaLaunchMemSyncDomainMap) + if objType == cudaLaunchAttributeValue: - return sizeof(cyruntime.cudaLaunchAttributeValue){{endif}} - {{if 'cudaLaunchAttribute_st' in found_struct}} + return sizeof(cyruntime.cudaLaunchAttributeValue) + if objType == cudaLaunchAttribute_st: - return sizeof(cyruntime.cudaLaunchAttribute_st){{endif}} - {{if 'cudaLaunchAttribute' in found_types}} + return sizeof(cyruntime.cudaLaunchAttribute_st) + if objType == cudaLaunchAttribute: - return sizeof(cyruntime.cudaLaunchAttribute){{endif}} - {{if 'cudaAsyncCallbackHandle_t' in found_types}} + return sizeof(cyruntime.cudaLaunchAttribute) + if objType == cudaAsyncCallbackHandle_t: - return sizeof(cyruntime.cudaAsyncCallbackHandle_t){{endif}} - {{if 'cudaAsyncNotificationInfo' in found_struct}} + return sizeof(cyruntime.cudaAsyncCallbackHandle_t) + if objType == cudaAsyncNotificationInfo: - return sizeof(cyruntime.cudaAsyncNotificationInfo){{endif}} - {{if 'cudaAsyncNotificationInfo_t' in found_types}} + return sizeof(cyruntime.cudaAsyncNotificationInfo) + if objType == cudaAsyncNotificationInfo_t: - return sizeof(cyruntime.cudaAsyncNotificationInfo_t){{endif}} - {{if 'cudaAsyncCallback' in found_types}} + return sizeof(cyruntime.cudaAsyncNotificationInfo_t) + if objType == cudaAsyncCallback: - return sizeof(cyruntime.cudaAsyncCallback){{endif}} - {{if 'cudaLogsCallbackHandle' in found_types}} + return sizeof(cyruntime.cudaAsyncCallback) + if objType == cudaLogsCallbackHandle: - return sizeof(cyruntime.cudaLogsCallbackHandle){{endif}} - {{if 'cudaLogIterator' in found_types}} + return sizeof(cyruntime.cudaLogsCallbackHandle) + if objType == cudaLogIterator: - return sizeof(cyruntime.cudaLogIterator){{endif}} - {{if 'cudaSurfaceObject_t' in found_types}} + return sizeof(cyruntime.cudaLogIterator) + if objType == cudaSurfaceObject_t: - return sizeof(cyruntime.cudaSurfaceObject_t){{endif}} - {{if 'cudaTextureDesc' in found_struct}} + return sizeof(cyruntime.cudaSurfaceObject_t) + if objType == cudaTextureDesc: - return sizeof(cyruntime.cudaTextureDesc){{endif}} - {{if 'cudaTextureObject_t' in found_types}} + return sizeof(cyruntime.cudaTextureDesc) + if objType == cudaTextureObject_t: - return sizeof(cyruntime.cudaTextureObject_t){{endif}} - {{if 'cudaStreamCallback_t' in found_types}} + return sizeof(cyruntime.cudaTextureObject_t) + if objType == cudaStreamCallback_t: - return sizeof(cyruntime.cudaStreamCallback_t){{endif}} - {{if 'cudaGraphRecaptureCallback_t' in found_types}} + return sizeof(cyruntime.cudaStreamCallback_t) + if objType == cudaGraphRecaptureCallback_t: - return sizeof(cyruntime.cudaGraphRecaptureCallback_t){{endif}} - {{if 'cudaGraphRecaptureCallbackData' in found_struct}} + return sizeof(cyruntime.cudaGraphRecaptureCallback_t) + if objType == cudaGraphRecaptureCallbackData: - return sizeof(cyruntime.cudaGraphRecaptureCallbackData){{endif}} - {{if 'cudaLogsCallback_t' in found_types}} + return sizeof(cyruntime.cudaGraphRecaptureCallbackData) + if objType == cudaLogsCallback_t: - return sizeof(cyruntime.cudaLogsCallback_t){{endif}} - {{if True}} + return sizeof(cyruntime.cudaLogsCallback_t) + if objType == GLenum: - return sizeof(cyruntime.GLenum){{endif}} - {{if True}} + return sizeof(cyruntime.GLenum) + if objType == GLuint: - return sizeof(cyruntime.GLuint){{endif}} - {{if True}} + return sizeof(cyruntime.GLuint) + if objType == EGLImageKHR: - return sizeof(cyruntime.EGLImageKHR){{endif}} - {{if True}} + return sizeof(cyruntime.EGLImageKHR) + if objType == EGLStreamKHR: - return sizeof(cyruntime.EGLStreamKHR){{endif}} - {{if True}} + return sizeof(cyruntime.EGLStreamKHR) + if objType == EGLint: - return sizeof(cyruntime.EGLint){{endif}} - {{if True}} + return sizeof(cyruntime.EGLint) + if objType == EGLSyncKHR: - return sizeof(cyruntime.EGLSyncKHR){{endif}} - {{if True}} + return sizeof(cyruntime.EGLSyncKHR) + if objType == VdpDevice: - return sizeof(cyruntime.VdpDevice){{endif}} - {{if True}} + return sizeof(cyruntime.VdpDevice) + if objType == VdpGetProcAddress: - return sizeof(cyruntime.VdpGetProcAddress){{endif}} - {{if True}} + return sizeof(cyruntime.VdpGetProcAddress) + if objType == VdpVideoSurface: - return sizeof(cyruntime.VdpVideoSurface){{endif}} - {{if True}} + return sizeof(cyruntime.VdpVideoSurface) + if objType == VdpOutputSurface: - return sizeof(cyruntime.VdpOutputSurface){{endif}} - {{if True}} + return sizeof(cyruntime.VdpOutputSurface) + if objType == cudaStreamAttrValue: - return sizeof(cyruntime.cudaStreamAttrValue){{endif}} - {{if True}} + return sizeof(cyruntime.cudaStreamAttrValue) + if objType == cudaKernelNodeAttrValue: - return sizeof(cyruntime.cudaKernelNodeAttrValue){{endif}} - {{if True}} + return sizeof(cyruntime.cudaKernelNodeAttrValue) + if objType == cudaEglPlaneDesc_st: - return sizeof(cyruntime.cudaEglPlaneDesc_st){{endif}} - {{if True}} + return sizeof(cyruntime.cudaEglPlaneDesc_st) + if objType == cudaEglPlaneDesc: - return sizeof(cyruntime.cudaEglPlaneDesc){{endif}} - {{if True}} + return sizeof(cyruntime.cudaEglPlaneDesc) + if objType == cudaEglFrame_st: - return sizeof(cyruntime.cudaEglFrame_st){{endif}} - {{if True}} + return sizeof(cyruntime.cudaEglFrame_st) + if objType == cudaEglFrame: - return sizeof(cyruntime.cudaEglFrame){{endif}} - {{if True}} + return sizeof(cyruntime.cudaEglFrame) + if objType == cudaEglStreamConnection: - return sizeof(cyruntime.cudaEglStreamConnection){{endif}} + return sizeof(cyruntime.cudaEglStreamConnection) raise TypeError("Unknown type: " + str(objType)) cdef int _add_native_handle_getters() except?-1: from cuda.bindings.utils import _add_cuda_native_handle_getter - {{if 'cudaDevResourceDesc_t' in found_types}} + def cudaDevResourceDesc_t_getter(cudaDevResourceDesc_t x): return (x._pvt_ptr[0]) _add_cuda_native_handle_getter(cudaDevResourceDesc_t, cudaDevResourceDesc_t_getter) - {{endif}} - {{if 'cudaExecutionContext_t' in found_types}} + + def cudaExecutionContext_t_getter(cudaExecutionContext_t x): return (x._pvt_ptr[0]) _add_cuda_native_handle_getter(cudaExecutionContext_t, cudaExecutionContext_t_getter) - {{endif}} - {{if 'cudaArray_t' in found_types}} + + def cudaArray_t_getter(cudaArray_t x): return (x._pvt_ptr[0]) _add_cuda_native_handle_getter(cudaArray_t, cudaArray_t_getter) - {{endif}} - {{if 'cudaArray_const_t' in found_types}} + + def cudaArray_const_t_getter(cudaArray_const_t x): return (x._pvt_ptr[0]) _add_cuda_native_handle_getter(cudaArray_const_t, cudaArray_const_t_getter) - {{endif}} - {{if 'cudaMipmappedArray_t' in found_types}} + + def cudaMipmappedArray_t_getter(cudaMipmappedArray_t x): return (x._pvt_ptr[0]) _add_cuda_native_handle_getter(cudaMipmappedArray_t, cudaMipmappedArray_t_getter) - {{endif}} - {{if 'cudaMipmappedArray_const_t' in found_types}} + + def cudaMipmappedArray_const_t_getter(cudaMipmappedArray_const_t x): return (x._pvt_ptr[0]) _add_cuda_native_handle_getter(cudaMipmappedArray_const_t, cudaMipmappedArray_const_t_getter) - {{endif}} - {{if 'cudaStream_t' in found_types}} + + def cudaStream_t_getter(cudaStream_t x): return (x._pvt_ptr[0]) _add_cuda_native_handle_getter(cudaStream_t, cudaStream_t_getter) - {{endif}} - {{if 'cudaEvent_t' in found_types}} + + def cudaEvent_t_getter(cudaEvent_t x): return (x._pvt_ptr[0]) _add_cuda_native_handle_getter(cudaEvent_t, cudaEvent_t_getter) - {{endif}} - {{if 'cudaGraphicsResource_t' in found_types}} + + def cudaGraphicsResource_t_getter(cudaGraphicsResource_t x): return (x._pvt_ptr[0]) _add_cuda_native_handle_getter(cudaGraphicsResource_t, cudaGraphicsResource_t_getter) - {{endif}} - {{if 'cudaExternalMemory_t' in found_types}} + + def cudaExternalMemory_t_getter(cudaExternalMemory_t x): return (x._pvt_ptr[0]) _add_cuda_native_handle_getter(cudaExternalMemory_t, cudaExternalMemory_t_getter) - {{endif}} - {{if 'cudaExternalSemaphore_t' in found_types}} + + def cudaExternalSemaphore_t_getter(cudaExternalSemaphore_t x): return (x._pvt_ptr[0]) _add_cuda_native_handle_getter(cudaExternalSemaphore_t, cudaExternalSemaphore_t_getter) - {{endif}} - {{if 'cudaGraph_t' in found_types}} + + def cudaGraph_t_getter(cudaGraph_t x): return (x._pvt_ptr[0]) _add_cuda_native_handle_getter(cudaGraph_t, cudaGraph_t_getter) - {{endif}} - {{if 'cudaGraphNode_t' in found_types}} + + def cudaGraphNode_t_getter(cudaGraphNode_t x): return (x._pvt_ptr[0]) _add_cuda_native_handle_getter(cudaGraphNode_t, cudaGraphNode_t_getter) - {{endif}} - {{if 'cudaUserObject_t' in found_types}} + + def cudaUserObject_t_getter(cudaUserObject_t x): return (x._pvt_ptr[0]) _add_cuda_native_handle_getter(cudaUserObject_t, cudaUserObject_t_getter) - {{endif}} - {{if 'cudaFunction_t' in found_types}} + + def cudaFunction_t_getter(cudaFunction_t x): return (x._pvt_ptr[0]) _add_cuda_native_handle_getter(cudaFunction_t, cudaFunction_t_getter) - {{endif}} - {{if 'cudaKernel_t' in found_types}} + + def cudaKernel_t_getter(cudaKernel_t x): return (x._pvt_ptr[0]) _add_cuda_native_handle_getter(cudaKernel_t, cudaKernel_t_getter) - {{endif}} - {{if 'cudaLibrary_t' in found_types}} + + def cudaLibrary_t_getter(cudaLibrary_t x): return (x._pvt_ptr[0]) _add_cuda_native_handle_getter(cudaLibrary_t, cudaLibrary_t_getter) - {{endif}} - {{if 'cudaMemPool_t' in found_types}} + + def cudaMemPool_t_getter(cudaMemPool_t x): return (x._pvt_ptr[0]) _add_cuda_native_handle_getter(cudaMemPool_t, cudaMemPool_t_getter) - {{endif}} - {{if 'cudaGraphExec_t' in found_types}} + + def cudaGraphExec_t_getter(cudaGraphExec_t x): return (x._pvt_ptr[0]) _add_cuda_native_handle_getter(cudaGraphExec_t, cudaGraphExec_t_getter) - {{endif}} - {{if 'cudaGraphDeviceNode_t' in found_types}} + + def cudaGraphDeviceNode_t_getter(cudaGraphDeviceNode_t x): return (x._pvt_ptr[0]) _add_cuda_native_handle_getter(cudaGraphDeviceNode_t, cudaGraphDeviceNode_t_getter) - {{endif}} - {{if 'cudaAsyncCallbackHandle_t' in found_types}} + + def cudaAsyncCallbackHandle_t_getter(cudaAsyncCallbackHandle_t x): return (x._pvt_ptr[0]) _add_cuda_native_handle_getter(cudaAsyncCallbackHandle_t, cudaAsyncCallbackHandle_t_getter) - {{endif}} - {{if 'cudaLogsCallbackHandle' in found_types}} + + def cudaLogsCallbackHandle_getter(cudaLogsCallbackHandle x): return (x._pvt_ptr[0]) _add_cuda_native_handle_getter(cudaLogsCallbackHandle, cudaLogsCallbackHandle_getter) - {{endif}} - {{if True}} + + def EGLImageKHR_getter(EGLImageKHR x): return (x._pvt_ptr[0]) _add_cuda_native_handle_getter(EGLImageKHR, EGLImageKHR_getter) - {{endif}} - {{if True}} + + def EGLStreamKHR_getter(EGLStreamKHR x): return (x._pvt_ptr[0]) _add_cuda_native_handle_getter(EGLStreamKHR, EGLStreamKHR_getter) - {{endif}} - {{if True}} + + def EGLSyncKHR_getter(EGLSyncKHR x): return (x._pvt_ptr[0]) _add_cuda_native_handle_getter(EGLSyncKHR, EGLSyncKHR_getter) - {{endif}} - {{if True}} + + def cudaEglStreamConnection_getter(cudaEglStreamConnection x): return (x._pvt_ptr[0]) _add_cuda_native_handle_getter(cudaEglStreamConnection, cudaEglStreamConnection_getter) - {{endif}} + return 0 _add_native_handle_getters() - diff --git a/cuda_bindings/docs/source/environment_variables.rst b/cuda_bindings/docs/source/environment_variables.rst index 4eba9e93047..7f716b1234a 100644 --- a/cuda_bindings/docs/source/environment_variables.rst +++ b/cuda_bindings/docs/source/environment_variables.rst @@ -24,6 +24,4 @@ Build-Time Environment Variables `cuda-pathfinder 1.5.0 release notes `_ for details and migration guidance. -- ``CUDA_PYTHON_PARSER_CACHING`` : bool, toggles the caching of parsed header files during the cuda-bindings build process. If caching is enabled (``CUDA_PYTHON_PARSER_CACHING`` is True), the cache path is set to ./cache_, where is derived from the cuda toolkit libraries used to build cuda-bindings. - - ``CUDA_PYTHON_PARALLEL_LEVEL`` (previously ``PARALLEL_LEVEL``) : int, sets the number of threads used in the compilation of extension modules. Not setting it or setting it to 0 would disable parallel builds. diff --git a/cuda_bindings/pixi.toml b/cuda_bindings/pixi.toml index 58722da7d2f..943d57e11bb 100644 --- a/cuda_bindings/pixi.toml +++ b/cuda_bindings/pixi.toml @@ -33,7 +33,6 @@ myst-parser = "*" numpy = "*" numpydoc = "*" pip = "*" -pyclibrary = "*" pydata-sphinx-theme = "*" pytest = "*" scipy = "*" @@ -96,9 +95,6 @@ backend = { name = "pixi-build-python", version = "*" } [package.build.config] compilers = ["c", "cxx"] -[package.build.config.env] -CUDA_PYTHON_PARSER_CACHING = "1" - [package.build.target.linux-64.config.env] CUDA_HOME = "$PREFIX/targets/x86_64-linux" CUDA_PYTHON_PARALLEL_LEVEL = "$(nproc)" @@ -120,7 +116,6 @@ cuda-version = "*" setuptools = ">=80" setuptools-scm = ">=8" cython = ">=3.2,<3.3" -pyclibrary = ">=0.1.7" cuda-pathfinder = { path = "../cuda_pathfinder" } cuda-cudart-static = "*" cuda-nvrtc-dev = "*" diff --git a/cuda_bindings/pyproject.toml b/cuda_bindings/pyproject.toml index 22de742f724..9744a0a009b 100644 --- a/cuda_bindings/pyproject.toml +++ b/cuda_bindings/pyproject.toml @@ -5,7 +5,6 @@ requires = [ "setuptools>=80.0.0", "setuptools_scm[simple]>=8,!=10.1", "cython>=3.2,<3.3", - "pyclibrary>=0.1.7", "cuda-pathfinder>=1.5", ] build-backend = "build_hooks" From 888bce04fb82e0ab893700ad5d29a777533981f9 Mon Sep 17 00:00:00 2001 From: Andy Jost Date: Tue, 14 Jul 2026 12:33:06 -0700 Subject: [PATCH 25/25] docs: clarify cuda.core concurrency and thread-safety policy (#2318) Document the concurrency contract that was previously agreed only in review threads: concurrent reads of a cuda.core object are supported, but concurrent mutation of the same object requires application-provided synchronization. Distinct objects can still collide through shared CUDA driver/context state (e.g. peer device access), which is also the caller's responsibility. - docs/source/concurrency.rst: new user-facing "Concurrency and Thread Safety" page, linked into the docs toctree. - cuda_core/AGENTS.md: contributor-facing invariants (reads-safe/mutation boundary, prefer immutable designs, shared-driver-state collisions, guarding internal cached state only for legitimately-shared objects, GIL-held entry points, and releasing the GIL before entering the driver from callback/__del__ paths). --- cuda_core/AGENTS.md | 38 +++++++++++++++++++++++++++ cuda_core/docs/source/concurrency.rst | 28 ++++++++++++++++++++ cuda_core/docs/source/index.rst | 3 ++- 3 files changed, 68 insertions(+), 1 deletion(-) create mode 100644 cuda_core/docs/source/concurrency.rst diff --git a/cuda_core/AGENTS.md b/cuda_core/AGENTS.md index 45fc2481042..83c96800e9d 100644 --- a/cuda_core/AGENTS.md +++ b/cuda_core/AGENTS.md @@ -63,6 +63,44 @@ This file describes `cuda_core`, the high-level Pythonic CUDA subpackage in the - Prefer explicit error propagation over silent fallback paths. - If you change public behavior, update tests and docs under `docs/source/`. +## Concurrency and free-threading + +`cuda.core` ships free-threaded (no-GIL) wheels and builds with +`freethreading_compatible=True`. The user-facing policy lives in +`docs/source/concurrency.rst`; the invariants below are for contributors. Reviewers +and agents should flag violations. + +- **Reads are safe; mutation is the boundary**: concurrent reads of an object are + supported, but concurrent mutation of the same public object (e.g., building one + graph from two threads, or `close()` racing another call) is the caller's + responsibility -- do not add locks to make it safe. Prefer immutable designs to + keep the mutable, thread-unsafe surface small. Protecting library-internal state + *is* in scope. +- **Distinct objects can still collide via shared driver state**: operating on + separate objects is not automatically safe when they share driver or context + state (e.g., changing peer device access while another thread touches affected + memory). Synchronizing these cases is the caller's responsibility; do not try to + lock around them internally. +- **Protect internal cached/module-level state**: guard lazily-populated + `cdef object` caches and module-level state so concurrent access cannot corrupt + interpreter state (CPython reference counts -- a strictly free-threading hazard). + Established patterns are `@cython.critical_section` on accessors (#2215), an + atomic initialization flag (#2216), and `dict.setdefault` for identity caches + (#2217). Guard state only on objects that are legitimately shared between threads; + objects that are not meant to be shared (e.g., the thread-local `Device`) do not + need such guards (see #2321). Reference-count integrity is guaranteed; cache + value-identity/idempotency is not. +- **Entry points assume the GIL is held**: the helpers in `_cpp/resource_handles.*` + are called from Cython with the GIL held and do not re-acquire it. Driver and + destructor callbacks run at arbitrary times, so they take the GIL (`with gil`) + and probe for interpreter shutdown before touching Python objects. +- **Lock ordering -- release the GIL before entering the driver**: any CUDA work + reachable from a host callback or a retained object's `__del__` must release the + GIL before calling the driver, to avoid GIL/driver-lock deadlocks (see the + `_py_host_trampoline` path and numba-cuda#321). Objects retained into a graph + (kernel arguments, memcpy/memset operands, `dst_owner`/`src_owner`, and + host-callback closures) inherit this contract. + ## API design guidelines These are some API design guidelines we try to follow when adding new APIs to diff --git a/cuda_core/docs/source/concurrency.rst b/cuda_core/docs/source/concurrency.rst new file mode 100644 index 00000000000..51a1baa1be9 --- /dev/null +++ b/cuda_core/docs/source/concurrency.rst @@ -0,0 +1,28 @@ +.. SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +.. SPDX-License-Identifier: Apache-2.0 + +.. currentmodule:: cuda.core + +Concurrency and Thread Safety +============================= + +``cuda.core`` allows concurrent reads of its objects from multiple host +threads, but concurrent *mutation* of the same object is **not supported** -- +for example, adding nodes to the same graph, or closing a resource while +another thread is using it. Whenever an object is shared across threads and at +least one of them may mutate it, the application is responsible for providing +external synchronization. + +The library does protect the integrity of its own internal state (such as +cached attributes and reference counting), so that concurrent reads of the same +object, or any kind of concurrent use of *distinct* objects, cannot corrupt the +interpreter. This is an integrity guarantee only: the ordering and outcome of +concurrent operations on a shared object are otherwise undefined. + +Additional limitations apply because ``cuda.core`` inherits the concurrency +constraints of the underlying CUDA driver. Distinct ``cuda.core`` objects can +share driver or context state, so operating on separate objects is not always +safe. For example, modifying peer device access from one thread while another +thread accesses device memory affected by that change is unsafe, even though the +two threads use different objects. The application is responsible for +synchronizing operations that concurrently read and modify shared driver state. diff --git a/cuda_core/docs/source/index.rst b/cuda_core/docs/source/index.rst index bf9128b1389..34c0933ffb8 100644 --- a/cuda_core/docs/source/index.rst +++ b/cuda_core/docs/source/index.rst @@ -1,4 +1,4 @@ -.. SPDX-FileCopyrightText: Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +.. SPDX-FileCopyrightText: Copyright (c) 2024-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. .. SPDX-License-Identifier: Apache-2.0 ``cuda.core``: Pythonic access to CUDA core functionality @@ -15,6 +15,7 @@ Welcome to the documentation for ``cuda.core``. 10_minutes_to_cuda_core examples interoperability + concurrency api api_nvml environment_variables