diff --git a/.agents/skills/create-cuda-python-pull-request/SKILL.md b/.agents/skills/create-cuda-python-pull-request/SKILL.md new file mode 100644 index 00000000000..4e3a07b83c1 --- /dev/null +++ b/.agents/skills/create-cuda-python-pull-request/SKILL.md @@ -0,0 +1,127 @@ +--- +name: create-cuda-python-pull-request +description: Create a CUDA Python pull request from an approved personal or organization-owned fork, including the GitHub CLI GraphQL fallback for renamed organization-owned forks. Use when the user directly requests creating or opening a CUDA Python pull request. Do not use for local implementation, commits, pushes, branch preparation, PR advice, or general GitHub work without that direct request. +--- + +# Create CUDA Python Pull Request + +This skill supplies technical procedure after the user directly asks to create +a pull request. It does not define when a pull request should be created or +authorize one without that direct request. Do not infer the request from +completed work, a local commit, a push request, or the existence of a suitable +fork. + +## Inspect the topology and proposed change + +1. Run `git status --short --branch`, inspect the branch diff, and confirm the + intended base branch. +2. Run `git remote -v` and resolve the complete `OWNER/REPOSITORY` names of the + base repository and intended fork. Do not rely on remote names alone. +3. Confirm through GitHub that the push target is a fork of the base repository + and is not the base repository itself. +4. Confirm that the intended push target complies with the repository's + remote-write policy and the user's request. +5. Inspect the repository's pull-request template, available labels, and open + milestones. Do not guess required metadata; ask the user when it is unclear. + +## Validate and push + +Run the checks appropriate to the change and review the final diff. Push the +current branch to the approved fork using the explicit remote and branch: + +```bash +git push +``` + +## Create the pull request + +Prepare a complete body from the repository's pull-request template. Every +pull request must have at least one assignee, one label, and a milestone; CI +enforces this through `pr-metadata-check`. + +Use `gh pr create` when it can identify the fork unambiguously. Select the base +repository and branch explicitly and supply the required metadata: + +```bash +gh pr create \ + --repo / \ + --base \ + --head : \ + --title "" \ + --body-file <path-to-pr-body> \ + --assignee <assignee> \ + --label <label> \ + --milestone <milestone> +``` + +Add `--draft` when the user requests a draft pull request. + +## Handle renamed organization-owned forks + +[GitHub CLI issue cli/cli#10093](https://github.com/cli/cli/issues/10093) +tracks `gh pr create` support for cross-repository pull requests within one +organization. Check whether the issue has been resolved before using the +workaround. + +If `gh pr create` cannot identify an organization-owned fork whose repository +name differs from the base repository, create the pull request with GitHub's +GraphQL API and pass `headRepositoryId` explicitly. + +Resolve the repository node IDs: + +```bash +BASE_REPO="<base-owner>/<base-repository>" +HEAD_REPO="<fork-owner>/<fork-repository>" +BASE_REPO_ID="$(gh api "repos/${BASE_REPO}" --jq '.node_id')" +HEAD_REPO_ID="$(gh api "repos/${HEAD_REPO}" --jq '.node_id')" +``` + +Create the pull request. Set `draft` to match the user's request. + +```bash +gh api graphql \ + -f repositoryId="${BASE_REPO_ID}" \ + -f headRepositoryId="${HEAD_REPO_ID}" \ + -f baseRefName="<base-branch>" \ + -f headRefName="<head-branch>" \ + -f title="<title>" \ + -F body="@<path-to-pr-body>" \ + -F draft=false \ + -f query=' + mutation CreatePullRequest( + $repositoryId: ID! + $headRepositoryId: ID! + $baseRefName: String! + $headRefName: String! + $title: String! + $body: String! + $draft: Boolean! + ) { + createPullRequest(input: { + repositoryId: $repositoryId + headRepositoryId: $headRepositoryId + baseRefName: $baseRefName + headRefName: $headRefName + title: $title + body: $body + draft: $draft + }) { + pullRequest { number url } + } + }' \ + --jq '.data.createPullRequest.pullRequest' +``` + +The GraphQL API does not populate the pull-request template automatically. +After creation, add the required metadata to the returned pull-request number: + +```bash +gh pr edit <pr-number> \ + --repo "${BASE_REPO}" \ + --add-assignee "<assignee>" \ + --add-label "<label>" \ + --milestone "<milestone>" +``` + +Verify the resulting URL, base branch, head repository and branch, draft state, +body, assignee, label, and milestone before reporting completion. diff --git a/.agents/skills/create-cuda-python-pull-request/agents/openai.yaml b/.agents/skills/create-cuda-python-pull-request/agents/openai.yaml new file mode 100644 index 00000000000..1d2725a7696 --- /dev/null +++ b/.agents/skills/create-cuda-python-pull-request/agents/openai.yaml @@ -0,0 +1,10 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# SPDX-License-Identifier: Apache-2.0 + +interface: + display_name: "Create CUDA Python PR" + short_description: "Open an explicitly requested CUDA Python pull request" + default_prompt: "Use $create-cuda-python-pull-request to create the CUDA Python pull request I explicitly requested." +policy: + allow_implicit_invocation: true diff --git a/.github/workflows/build-wheel.yml b/.github/workflows/build-wheel.yml index d1e5512a8bf..d09146cb82d 100644 --- a/.github/workflows/build-wheel.yml +++ b/.github/workflows/build-wheel.yml @@ -27,12 +27,45 @@ on: required: false type: boolean default: false + build-pathfinder: + required: false + type: boolean + default: true + build-bindings: + required: false + type: boolean + default: true + build-core: + required: false + type: boolean + default: true + build-python: + required: false + type: boolean + default: true + test-bindings: + required: false + type: boolean + default: true + test-core: + required: false + type: boolean + default: true + baseline-run-id: + required: false + type: string + default: "" + baseline-sha: + required: false + type: string + default: "" defaults: run: shell: bash --noprofile --norc -xeuo pipefail {0} permissions: + actions: read contents: read # This is required for actions/checkout jobs: @@ -56,7 +89,7 @@ jobs: filter: blob:none - name: Install latest rapidsai/sccache - if: ${{ startsWith(inputs.host-platform, 'linux') }} + if: ${{ startsWith(inputs.host-platform, 'linux') && (inputs.build-bindings || inputs.build-core) }} run: | curl -fsSL "https://github.com/rapidsai/sccache/releases/latest/download/sccache-$(uname -m)-unknown-linux-musl.tar.gz" \ | sudo tar -C /usr/local/bin -xvzf - --wildcards --strip-components=1 -x '*/sccache' @@ -64,6 +97,7 @@ jobs: # xref: https://github.com/orgs/community/discussions/42856#discussioncomment-7678867 - name: Adding addtional GHA cache-related env vars + if: ${{ inputs.build-bindings || inputs.build-core }} uses: actions/github-script@v9 with: script: | @@ -91,7 +125,7 @@ jobs: architecture: ${{ ((inputs.host-platform == 'linux-aarch64' || inputs.host-platform == 'win-arm64') && 'arm64') || 'x64' }} - name: Set up MSVC - if: ${{ startsWith(inputs.host-platform, 'win') }} + if: ${{ startsWith(inputs.host-platform, 'win') && (inputs.build-bindings || inputs.build-core || inputs.test-bindings || inputs.test-core) }} uses: step-security/msvc-dev-cmd@22c98154b708dbd743e6f27a933cf6ceba3305c4 # v1.13.1 with: arch: ${{ (inputs.host-platform == 'win-arm64' && 'arm64') || 'x64' }} @@ -104,7 +138,7 @@ jobs: - name: Set up yq # GitHub made an unprofessional decision to not provide it in their Windows VMs, # see https://github.com/actions/runner-images/issues/7443. - if: ${{ startsWith(inputs.host-platform, 'win') && !inputs.single-cuda-major }} + if: ${{ startsWith(inputs.host-platform, 'win') && inputs.build-core && !inputs.single-cuda-major }} env: YQ_VERSION: v4.52.5 YQ_ARCH: ${{ (inputs.host-platform == 'win-arm64' && 'arm64') || 'amd64' }} @@ -143,11 +177,21 @@ jobs: # To keep the build workflow simple, all matrix jobs will build a wheel for later use within this workflow. - name: Build and check cuda.pathfinder wheel + if: ${{ inputs.build-pathfinder }} run: | pushd cuda_pathfinder pip wheel -v --no-deps . popd + - name: Download reusable cuda.pathfinder wheel + if: ${{ !inputs.build-pathfinder }} + uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 + with: + name: cuda-pathfinder-wheel + path: cuda_pathfinder + github-token: ${{ github.token }} + run-id: ${{ inputs.baseline-run-id }} + - name: List the cuda.pathfinder artifacts directory run: | if [[ "${{ inputs.host-platform }}" == win* ]]; then @@ -161,11 +205,12 @@ jobs: # We only need/want a single pure python wheel, pick linux-64 index 0. # This is what we will use for testing & releasing. - name: Check cuda.pathfinder wheel - if: ${{ strategy.job-index == 0 && inputs.host-platform == 'linux-64' }} + if: ${{ inputs.build-pathfinder && strategy.job-index == 0 && inputs.host-platform == 'linux-64' }} run: | twine check --strict cuda_pathfinder/*.whl - name: Constrain builds to the local cuda.pathfinder wheel + if: ${{ inputs.build-bindings }} run: | pathfinder_wheels=(cuda_pathfinder/cuda_pathfinder-*.whl) test "${#pathfinder_wheels[@]}" -eq 1 @@ -187,6 +232,7 @@ jobs: if-no-files-found: error - name: Set up mini CTK + if: ${{ inputs.build-bindings || inputs.build-core || inputs.test-bindings || inputs.test-core }} uses: ./.github/actions/fetch_ctk continue-on-error: false with: @@ -195,6 +241,7 @@ jobs: cuda-channel: ${{ inputs.cuda-channel }} - name: Build cuda.bindings wheel + if: ${{ inputs.build-bindings }} uses: pypa/cibuildwheel@4726cd35bb13f7bde50cf2761f2499ac7b3aa32c # v4.1.1 with: package-dir: ./cuda_bindings/ @@ -241,13 +288,22 @@ jobs: echo "ok!" - name: Report sccache stats (cuda.bindings) - if: ${{ !startsWith(inputs.host-platform, 'win') }} + if: ${{ inputs.build-bindings && !startsWith(inputs.host-platform, 'win') }} uses: ./.github/actions/sccache-summary with: json-file: sccache_bindings.json label: "cuda.bindings" build-step: "Build cuda.bindings wheel" + - name: Download reusable cuda.bindings wheel + if: ${{ !inputs.build-bindings }} + uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 + with: + name: ${{ env.CUDA_BINDINGS_ARTIFACT_BASENAME }}-${{ inputs.baseline-sha }} + path: ${{ env.CUDA_BINDINGS_ARTIFACTS_DIR }} + github-token: ${{ github.token }} + run-id: ${{ inputs.baseline-run-id }} + - name: List the cuda.bindings artifacts directory run: | if [[ "${{ inputs.host-platform }}" == win* ]]; then @@ -259,10 +315,12 @@ jobs: ls -lahR ${{ env.CUDA_BINDINGS_ARTIFACTS_DIR }} - name: Check cuda.bindings wheel + if: ${{ inputs.build-bindings }} run: | twine check --strict ${{ env.CUDA_BINDINGS_ARTIFACTS_DIR }}/*.whl - name: Constrain cuda.core to the local cuda.bindings wheel + if: ${{ inputs.build-core }} run: | pathfinder_wheels=(cuda_pathfinder/cuda_pathfinder-*.whl) bindings_wheels=("${CUDA_BINDINGS_ARTIFACTS_DIR}"/cuda_bindings-"${BUILD_CUDA_MAJOR}".*.whl) @@ -291,6 +349,7 @@ jobs: if-no-files-found: error - name: Build cuda.core wheel + if: ${{ inputs.build-core }} uses: pypa/cibuildwheel@4726cd35bb13f7bde50cf2761f2499ac7b3aa32c # v4.1.1 with: package-dir: ./cuda_core/ @@ -339,7 +398,7 @@ jobs: echo "ok!" - name: Report sccache stats (cuda.core) - if: ${{ !startsWith(inputs.host-platform, 'win') }} + if: ${{ inputs.build-core && !startsWith(inputs.host-platform, 'win') }} uses: ./.github/actions/sccache-summary with: json-file: sccache_core.json @@ -347,6 +406,7 @@ jobs: build-step: "Build cuda.core wheel" - name: List the cuda.core artifacts directory and rename + if: ${{ inputs.build-core }} run: | if [[ "${{ inputs.host-platform }}" == win* ]]; then export CHOWN=chown @@ -369,7 +429,7 @@ jobs: ls -lahR ${{ env.CUDA_CORE_ARTIFACTS_DIR }} - name: Finalize single-major cuda.core wheel - if: ${{ inputs.single-cuda-major }} + if: ${{ inputs.single-cuda-major && inputs.build-core }} run: | for wheel in "${{ env.CUDA_CORE_ARTIFACTS_DIR }}"/cu"${BUILD_CUDA_MAJOR}"/*.cu"${BUILD_CUDA_MAJOR}".whl; do base_name=$(basename "${wheel}" ".cu${BUILD_CUDA_MAJOR}.whl") @@ -377,15 +437,33 @@ jobs: done ls -lahR "${{ env.CUDA_CORE_ARTIFACTS_DIR }}" + - name: Download reusable cuda.core wheel + if: ${{ !inputs.build-core }} + uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 + with: + name: ${{ env.CUDA_CORE_ARTIFACT_BASENAME }}-${{ inputs.baseline-sha }} + path: ${{ env.CUDA_CORE_ARTIFACTS_DIR }} + github-token: ${{ github.token }} + run-id: ${{ inputs.baseline-run-id }} + # We only need/want a single pure python wheel, pick linux-64 index 0. - name: Build and check cuda-python wheel - if: ${{ strategy.job-index == 0 && inputs.host-platform == 'linux-64' }} + if: ${{ inputs.build-python && strategy.job-index == 0 && inputs.host-platform == 'linux-64' }} run: | pushd cuda_python pip wheel -v --no-deps . twine check --strict *.whl popd + - name: Download reusable cuda-python wheel + if: ${{ !inputs.build-python && strategy.job-index == 0 && inputs.host-platform == 'linux-64' }} + uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 + with: + name: cuda-python-wheel + path: cuda_python + github-token: ${{ github.token }} + run-id: ${{ inputs.baseline-run-id }} + - name: List the cuda-python artifacts directory if: ${{ strategy.job-index == 0 && inputs.host-platform == 'linux-64' }} run: | @@ -406,8 +484,8 @@ jobs: if-no-files-found: error - name: Set up Python - if: ${{ !inputs.single-cuda-major }} id: setup-python2 + if: ${{ !inputs.single-cuda-major && (inputs.test-bindings || inputs.test-core) }} uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0 with: python-version: ${{ matrix.python-version }} @@ -416,17 +494,17 @@ jobs: allow-prereleases: ${{ startsWith(matrix.python-version, '3.15') }} - name: Enable Scientific Python Nightly Wheels for Python 3.15 - if: ${{ !inputs.single-cuda-major && startsWith(matrix.python-version, '3.15') }} + if: ${{ !inputs.single-cuda-major && (inputs.test-bindings || inputs.test-core) && startsWith(matrix.python-version, '3.15') }} run: | echo "PIP_EXTRA_INDEX_URL=https://pypi.anaconda.org/scientific-python-nightly-wheels/simple" >> "$GITHUB_ENV" echo "PIP_ONLY_BINARY=numpy" >> "$GITHUB_ENV" - name: verify free-threaded build - if: ${{ !inputs.single-cuda-major && endsWith(matrix.python-version, 't') }} + if: ${{ !inputs.single-cuda-major && (inputs.test-bindings || inputs.test-core) && endsWith(matrix.python-version, 't') }} run: python -c 'import sys; assert not sys._is_gil_enabled()' - name: Set up Python include paths - if: ${{ !inputs.single-cuda-major }} + if: ${{ !inputs.single-cuda-major && (inputs.test-bindings || inputs.test-core) }} run: | if [[ "${{ inputs.host-platform }}" == linux* ]]; then echo "CPLUS_INCLUDE_PATH=${Python3_ROOT_DIR}/include/python${{ matrix.python-version }}" >> $GITHUB_ENV @@ -437,19 +515,19 @@ jobs: echo "PY_EXT_SUFFIX=$(python -c "import sysconfig; print(sysconfig.get_config_var('EXT_SUFFIX'))")" >> $GITHUB_ENV - name: Install cuda.pathfinder (required for next step) - if: ${{ !inputs.single-cuda-major }} + if: ${{ !inputs.single-cuda-major && (inputs.test-bindings || inputs.test-core) }} run: | pip install cuda_pathfinder/*.whl - name: Hide GNU link.exe so Meson finds MSVC link.exe - if: ${{ !inputs.single-cuda-major && startsWith(inputs.host-platform, 'win') }} + if: ${{ !inputs.single-cuda-major && startsWith(inputs.host-platform, 'win') && (inputs.test-bindings || inputs.test-core) }} run: | if [ -f "/c/Program Files/Git/usr/bin/link.exe" ]; then mv "/c/Program Files/Git/usr/bin/link.exe" "/c/Program Files/Git/usr/bin/link.exe.bak" fi - name: Build cuda.bindings Cython tests - if: ${{ !inputs.single-cuda-major }} + if: ${{ !inputs.single-cuda-major && inputs.test-bindings }} run: | pip install ${{ env.CUDA_BINDINGS_ARTIFACTS_DIR }}/*.whl --group ./cuda_bindings/pyproject.toml:test pushd ${{ env.CUDA_BINDINGS_CYTHON_TESTS_DIR }} @@ -457,7 +535,7 @@ jobs: popd - name: Upload cuda.bindings Cython tests - if: ${{ !inputs.single-cuda-major }} + if: ${{ !inputs.single-cuda-major && inputs.test-bindings }} uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 with: name: ${{ env.CUDA_BINDINGS_ARTIFACT_NAME }}-tests @@ -465,15 +543,25 @@ jobs: if-no-files-found: error - name: Build cuda.core Cython tests - if: ${{ !inputs.single-cuda-major }} + if: ${{ !inputs.single-cuda-major && inputs.test-core }} run: | - pip install ${{ env.CUDA_CORE_ARTIFACTS_DIR }}/"cu${BUILD_CUDA_MAJOR}"/*.whl --group ./cuda_core/pyproject.toml:test + pip install ${{ env.CUDA_BINDINGS_ARTIFACTS_DIR }}/*.whl + if ${{ inputs.build-core }}; then + core_wheel=$(find "${{ env.CUDA_CORE_ARTIFACTS_DIR }}/cu${BUILD_CUDA_MAJOR}" -maxdepth 1 -type f -name '*.whl' -print -quit) + else + core_wheel=$(find "${{ env.CUDA_CORE_ARTIFACTS_DIR }}" -maxdepth 1 -type f -name '*.whl' -print -quit) + fi + if [[ -z "${core_wheel}" ]]; then + echo "No cuda.core wheel found" >&2 + exit 1 + fi + pip install "${core_wheel}" --group ./cuda_core/pyproject.toml:test pushd ${{ env.CUDA_CORE_CYTHON_TESTS_DIR }} bash build_tests.sh popd - name: Upload cuda.core Cython tests - if: ${{ !inputs.single-cuda-major }} + if: ${{ !inputs.single-cuda-major && inputs.test-core }} uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 with: name: ${{ env.CUDA_CORE_ARTIFACT_NAME }}-tests @@ -482,7 +570,7 @@ jobs: # Note: This overwrites CUDA_PATH etc - name: Set up mini CTK - if: ${{ !inputs.single-cuda-major }} + if: ${{ !inputs.single-cuda-major && (inputs.build-core || inputs.test-core) }} uses: ./.github/actions/fetch_ctk continue-on-error: false with: @@ -491,13 +579,13 @@ jobs: cuda-path: "./cuda_toolkit_prev" - name: Build cuda.core test binaries - if: ${{ !inputs.single-cuda-major }} + if: ${{ !inputs.single-cuda-major && inputs.test-core }} run: | nvcc --version python "${{ env.CUDA_CORE_TEST_BINARIES_DIR }}/build_test_binaries.py" - name: Upload cuda.core test binaries - if: ${{ !inputs.single-cuda-major }} + if: ${{ !inputs.single-cuda-major && inputs.test-core }} uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 with: name: ${{ env.CUDA_CORE_ARTIFACT_NAME }}-test-binaries @@ -508,7 +596,7 @@ jobs: if-no-files-found: error - name: Download cuda.bindings build artifacts from the prior branch - if: ${{ !inputs.single-cuda-major }} + if: ${{ !inputs.single-cuda-major && inputs.build-core }} env: GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} run: | @@ -526,10 +614,14 @@ jobs: OLD_BRANCH=$(yq '.backport_branch' ci/versions.yml) OLD_BASENAME="cuda-bindings-python${PYTHON_VERSION_FORMATTED}-cuda*-${{ inputs.host-platform }}*" - LATEST_PRIOR_RUN_ID=$(./ci/tools/lookup-run-id --branch "${OLD_BRANCH}" NVIDIA/cuda-python "CI") + OLD_WHEEL_ARTIFACT_PATTERN="${OLD_BASENAME}[0-9a-f]" + LATEST_PRIOR_RUN_ID=$(./ci/tools/lookup-run-id \ + --branch "${OLD_BRANCH}" \ + --artifact "${OLD_WHEEL_ARTIFACT_PATTERN}" \ + NVIDIA/cuda-python "CI") PREV_BINDINGS_DIR="cuda_bindings/dist-prev" - gh run download $LATEST_PRIOR_RUN_ID -p ${OLD_BASENAME} -R NVIDIA/cuda-python + gh run download "${LATEST_PRIOR_RUN_ID}" -p "${OLD_BASENAME}" -R NVIDIA/cuda-python rm -rf ${OLD_BASENAME}-tests # exclude cython test artifacts ls -al $OLD_BASENAME mkdir -p "${PREV_BINDINGS_DIR}" @@ -537,6 +629,7 @@ jobs: rmdir $OLD_BASENAME - name: Constrain previous cuda.core to the downloaded cuda.bindings wheel + if: ${{ !inputs.single-cuda-major && inputs.build-core }} run: | pathfinder_wheels=(cuda_pathfinder/cuda_pathfinder-*.whl) bindings_wheels=(cuda_bindings/dist-prev/cuda_bindings-"${BUILD_PREV_CUDA_MAJOR}".*.whl) @@ -558,7 +651,7 @@ jobs: } | tee wheel-constraints/cuda-core-prev.txt - name: Build cuda.core wheel - if: ${{ !inputs.single-cuda-major }} + if: ${{ !inputs.single-cuda-major && inputs.build-core }} uses: pypa/cibuildwheel@4726cd35bb13f7bde50cf2761f2499ac7b3aa32c # v4.1.1 with: package-dir: ./cuda_core/ @@ -607,7 +700,7 @@ jobs: echo "ok!" - name: Report sccache stats (cuda.core prev) - if: ${{ !inputs.single-cuda-major && !startsWith(inputs.host-platform, 'win') }} + if: ${{ !inputs.single-cuda-major && inputs.build-core && !startsWith(inputs.host-platform, 'win') }} uses: ./.github/actions/sccache-summary with: json-file: sccache_core_prev.json @@ -615,7 +708,7 @@ jobs: build-step: "Build cuda.core wheel" - name: List the cuda.core artifacts directory and rename - if: ${{ !inputs.single-cuda-major }} + if: ${{ !inputs.single-cuda-major && inputs.build-core }} run: | if [[ "${{ inputs.host-platform }}" == win* ]]; then export CHOWN=chown @@ -639,7 +732,7 @@ jobs: ls -lahR ${{ env.CUDA_CORE_ARTIFACTS_DIR }} - name: Merge cuda.core wheels - if: ${{ !inputs.single-cuda-major }} + if: ${{ !inputs.single-cuda-major && inputs.build-core }} run: | pip install wheel python ci/tools/merge_cuda_core_wheels.py \ @@ -648,6 +741,7 @@ jobs: --output-dir "${{ env.CUDA_CORE_ARTIFACTS_DIR }}" - name: Check cuda.core wheel + if: ${{ inputs.build-core }} run: | twine check --strict ${{ env.CUDA_CORE_ARTIFACTS_DIR }}/*.whl diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index ca3c31ea7dc..a3583a57098 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -486,7 +486,7 @@ jobs: host-platform: ${{ matrix.host-platform }} build-ctk-ver: ${{ needs.ci-vars.outputs.CUDA_BUILD_VER }} nruns: ${{ (github.event_name == 'schedule' && 5) || 1}} - skip-bindings-test: ${{ !fromJSON(needs.detect-changes.outputs.test_bindings) }} + test-bindings: ${{ fromJSON(needs.detect-changes.outputs.test_bindings) }} # See test-linux-64 for why test jobs are split by platform. test-linux-aarch64: @@ -511,7 +511,7 @@ jobs: host-platform: ${{ matrix.host-platform }} build-ctk-ver: ${{ needs.ci-vars.outputs.CUDA_BUILD_VER }} nruns: ${{ (github.event_name == 'schedule' && 5) || 1}} - skip-bindings-test: ${{ !fromJSON(needs.detect-changes.outputs.test_bindings) }} + test-bindings: ${{ fromJSON(needs.detect-changes.outputs.test_bindings) }} # See test-linux-64 for why test jobs are split by platform. test-windows: @@ -536,7 +536,7 @@ jobs: host-platform: ${{ matrix.host-platform }} build-ctk-ver: ${{ needs.ci-vars.outputs.CUDA_BUILD_VER }} nruns: ${{ (github.event_name == 'schedule' && 5) || 1}} - skip-bindings-test: ${{ !fromJSON(needs.detect-changes.outputs.test_bindings) }} + test-bindings: ${{ fromJSON(needs.detect-changes.outputs.test_bindings) }} doc: name: Docs @@ -584,7 +584,7 @@ jobs: shell: bash run: | set -euxo pipefail - SKIP=lychee pre-commit run --all-files + SKIP=lychee,check-pixi-cuda-version pre-commit run --all-files checks: name: Check job status diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml deleted file mode 100644 index 87bcd8e58d5..00000000000 --- a/.github/workflows/codeql.yml +++ /dev/null @@ -1,46 +0,0 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# -# SPDX-License-Identifier: Apache-2.0 - -name: "Static Analysis: CodeQL Scan" - -on: - push: - branches: - - "pull-request/[0-9]+" - - "ctk-next" - - "main" -concurrency: - group: ${{ github.workflow }}-${{ github.ref }}-${{ github.event_name }} - cancel-in-progress: true - -jobs: - analyze: - name: Analyze (${{ matrix.language }}) - runs-on: ubuntu-latest - permissions: - actions: read - contents: read - security-events: write - - strategy: - fail-fast: false - matrix: - include: - - language: python - build-mode: none - steps: - - name: Checkout repository - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0 - - - name: Initialize CodeQL - uses: github/codeql-action/init@8aad20d150bbac5944a9f9d289da16a4b0d87c1e # v4.36.2 - with: - languages: ${{ matrix.language }} - build-mode: ${{ matrix.build-mode }} - queries: security-extended - - - name: Perform CodeQL Analysis - uses: github/codeql-action/analyze@8aad20d150bbac5944a9f9d289da16a4b0d87c1e # v4.36.2 - with: - category: "/language:${{matrix.language}}" diff --git a/.github/workflows/security-suite.yml b/.github/workflows/security-suite.yml new file mode 100644 index 00000000000..0902db6119a --- /dev/null +++ b/.github/workflows/security-suite.yml @@ -0,0 +1,47 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# SPDX-License-Identifier: Apache-2.0 +# +# CI security scanning via the NVIDIA/security-workflows suite: Pulse secret scan + CodeQL SAST. +# Pulse runs on Linux nv-gha-runners (Docker image + OIDC/Vault) — Linux-only by design. +# The local secret-scan-trufflehog pre-commit hook is cross-platform (Linux/macOS/Windows). +# Pinned to a reviewed commit SHA. + +name: Security Suite (Pulse + CodeQL) + +on: + push: + branches: + - main + - ctk-next + - "pull-request/[0-9]+" + workflow_dispatch: + +concurrency: + group: ${{ github.workflow }}-on-${{ github.event_name }}-from-${{ github.ref_name }} + cancel-in-progress: true + +# Caller must grant every permission the reusable workflow declares, including scans it disables. +permissions: + contents: read + id-token: write # OIDC -> Vault -> nvcr.io image pull + security-events: write # publish redacted SARIF to code scanning + actions: read + +jobs: + security-suite: + name: Security Suite + # Pulse needs nv-gha-runners + Vault/nvcr vars; skip on forks. + if: github.repository == 'NVIDIA/cuda-python' + uses: NVIDIA/security-workflows/.github/workflows/security-suite.yml@711025b090f2aa728da576700750b195d1e816dc # v0.3.0 + with: + enable-secret-scan: true + enable-sast-scan: true + secret-runs-on: linux-amd64-cpu4 + # Set failure_policy explicitly so enforcement can't drift with upstream defaults. + # unverified — fail on verified/live secrets (183); warn on unverified (185) [default] + # strict — fail on any finding (verified or unverified) + # all — warn only; never fail the job on findings + secret-failure-policy: unverified + # Same analysis the retired codeql.yml performed: python, build-mode none, security-extended. + sast-languages: '["python"]' diff --git a/.github/workflows/test-sdist-linux.yml b/.github/workflows/test-sdist-linux.yml index e88f358bf3f..8d7f250a233 100644 --- a/.github/workflows/test-sdist-linux.yml +++ b/.github/workflows/test-sdist-linux.yml @@ -15,17 +15,35 @@ on: required: false type: string default: stable + build-pathfinder: + required: false + default: true + type: boolean + build-bindings: + required: false + default: true + type: boolean + build-core: + required: false + default: true + type: boolean + build-python: + required: false + default: true + type: boolean defaults: run: shell: bash --noprofile --norc -xeuo pipefail {0} permissions: + actions: read # This is required for actions/download-artifact contents: read # This is required for actions/checkout jobs: test-sdist: name: Test sdist builds + if: ${{ inputs.build-pathfinder || inputs.build-bindings || inputs.build-core || inputs.build-python }} timeout-minutes: 60 runs-on: linux-amd64-cpu8 steps: @@ -47,16 +65,26 @@ jobs: # Pure Python packages -- no CTK needed. - name: Build cuda.pathfinder sdist and wheel-from-sdist + if: ${{ inputs.build-pathfinder }} run: | python -m build --sdist cuda_pathfinder/ pip wheel --no-deps --wheel-dir cuda_pathfinder/dist cuda_pathfinder/dist/*.tar.gz - name: Build cuda-python sdist and wheel-from-sdist + if: ${{ inputs.build-python }} run: | python -m build --sdist cuda_python/ pip wheel --no-deps --wheel-dir cuda_python/dist cuda_python/dist/*.tar.gz + - name: Download cuda.pathfinder wheel + if: ${{ !inputs.build-pathfinder && (inputs.build-bindings || inputs.build-core) }} + uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 + with: + name: cuda-pathfinder-wheel + path: cuda_pathfinder/dist + - name: Constrain builds to the local cuda.pathfinder wheel + if: ${{ inputs.build-bindings }} run: | pathfinder_wheels=(cuda_pathfinder/dist/cuda_pathfinder-*.whl) test "${#pathfinder_wheels[@]}" -eq 1 @@ -69,12 +97,14 @@ jobs: # The env vars ACTIONS_CACHE_SERVICE_V2, ACTIONS_RESULTS_URL, and ACTIONS_RUNTIME_TOKEN # are exposed by this action. - name: Enable sccache + if: ${{ inputs.build-bindings || inputs.build-core }} uses: mozilla-actions/sccache-action@9e7fa8a12102821edf02ca5dbea1acd0f89a2696 # 0.0.10 with: disable_annotations: 'true' # xref: https://github.com/orgs/community/discussions/42856#discussioncomment-7678867 - name: Adding additional GHA cache-related env vars + if: ${{ inputs.build-bindings || inputs.build-core }} uses: actions/github-script@v9 with: script: | @@ -82,12 +112,14 @@ jobs: core.exportVariable('ACTIONS_RUNTIME_URL', process.env['ACTIONS_RUNTIME_URL']) - name: Setup proxy cache + if: ${{ inputs.build-bindings || inputs.build-core }} uses: nv-gha-runners/setup-proxy-cache@main continue-on-error: true with: enable-apt: true - name: Set up mini CTK + if: ${{ inputs.build-bindings || inputs.build-core }} uses: ./.github/actions/fetch_ctk continue-on-error: false with: @@ -98,6 +130,7 @@ jobs: # cuda_bindings/setup.py parses CUDA headers at import time, so CUDA_PATH # (set by fetch_ctk) must be available for both sdist and wheel builds. - name: Build cuda.bindings sdist and wheel-from-sdist + if: ${{ inputs.build-bindings }} run: | export CUDA_PYTHON_PARALLEL_LEVEL=$(nproc) export CC="sccache cc" @@ -107,7 +140,15 @@ jobs: python -m build --sdist cuda_bindings/ pip wheel --no-deps --wheel-dir cuda_bindings/dist cuda_bindings/dist/*.tar.gz + - name: Download cuda.bindings wheel + if: ${{ !inputs.build-bindings && inputs.build-core }} + uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 + with: + name: cuda-bindings-python312-cuda${{ inputs.cuda-version }}-${{ inputs.host-platform }}-${{ github.sha }} + path: cuda_bindings/dist + - name: Constrain cuda.core to the local cuda.bindings wheel + if: ${{ inputs.build-core }} run: | CUDA_MAJOR="$(echo '${{ inputs.cuda-version }}' | cut -d. -f1)" pathfinder_wheels=(cuda_pathfinder/dist/cuda_pathfinder-*.whl) @@ -128,6 +169,7 @@ jobs: # wheel-from-sdist needs CTK and cuda-bindings (dynamic build dep via # get_requires_for_build_wheel in build_hooks.py). - name: Build cuda.core sdist and wheel-from-sdist + if: ${{ inputs.build-core }} run: | export CUDA_PYTHON_PARALLEL_LEVEL=$(nproc) export CUDA_CORE_BUILD_MAJOR="$(echo '${{ inputs.cuda-version }}' | cut -d. -f1)" @@ -139,5 +181,5 @@ jobs: pip wheel --no-deps --wheel-dir cuda_core/dist cuda_core/dist/*.tar.gz - name: Show sccache stats - if: always() + if: ${{ always() && (inputs.build-bindings || inputs.build-core) }} run: sccache --show-stats diff --git a/.github/workflows/test-sdist-windows.yml b/.github/workflows/test-sdist-windows.yml index 8ebd9738f0f..40d65e75c4c 100644 --- a/.github/workflows/test-sdist-windows.yml +++ b/.github/workflows/test-sdist-windows.yml @@ -21,17 +21,35 @@ on: required: false type: string default: stable + build-pathfinder: + required: false + default: true + type: boolean + build-bindings: + required: false + default: true + type: boolean + build-core: + required: false + default: true + type: boolean + build-python: + required: false + default: true + type: boolean defaults: run: shell: bash --noprofile --norc -xeuo pipefail {0} permissions: + actions: read # This is required for actions/download-artifact contents: read # This is required for actions/checkout jobs: test-sdist: name: Test sdist builds + if: ${{ inputs.build-pathfinder || inputs.build-bindings || inputs.build-core || inputs.build-python }} timeout-minutes: 60 runs-on: windows-2022 steps: @@ -49,6 +67,7 @@ jobs: python-version: "3.12" - name: Set up MSVC + if: ${{ inputs.build-bindings || inputs.build-core }} uses: step-security/msvc-dev-cmd@22c98154b708dbd743e6f27a933cf6ceba3305c4 # v1.13.1 - name: Install build tools @@ -56,16 +75,26 @@ jobs: # Pure Python packages -- no CTK needed. - name: Build cuda.pathfinder sdist and wheel-from-sdist + if: ${{ inputs.build-pathfinder }} run: | python -m build --sdist cuda_pathfinder/ pip wheel --no-deps --wheel-dir cuda_pathfinder/dist cuda_pathfinder/dist/*.tar.gz - name: Build cuda-python sdist and wheel-from-sdist + if: ${{ inputs.build-python }} run: | python -m build --sdist cuda_python/ pip wheel --no-deps --wheel-dir cuda_python/dist cuda_python/dist/*.tar.gz + - name: Download cuda.pathfinder wheel + if: ${{ !inputs.build-pathfinder && (inputs.build-bindings || inputs.build-core) }} + uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 + with: + name: cuda-pathfinder-wheel + path: cuda_pathfinder/dist + - name: Constrain builds to the local cuda.pathfinder wheel + if: ${{ inputs.build-bindings }} run: | pathfinder_wheels=(cuda_pathfinder/dist/cuda_pathfinder-*.whl) test "${#pathfinder_wheels[@]}" -eq 1 @@ -78,6 +107,7 @@ jobs: # smoke test, not a production build; see build-wheel.yml which also # limits sccache to Linux). - name: Set up mini CTK + if: ${{ inputs.build-bindings || inputs.build-core }} uses: ./.github/actions/fetch_ctk continue-on-error: false with: @@ -90,6 +120,7 @@ jobs: # Constraint paths are passed as native Windows paths because the pip # subprocesses run outside Git Bash. - name: Build cuda.bindings sdist and wheel-from-sdist + if: ${{ inputs.build-bindings }} run: | export CUDA_PYTHON_PARALLEL_LEVEL=$(nproc) export PIP_BUILD_CONSTRAINT="$(cygpath -w "$(pwd)/wheel-constraints/cuda-bindings.txt")" @@ -97,7 +128,15 @@ jobs: python -m build --sdist cuda_bindings/ pip wheel --no-deps --wheel-dir cuda_bindings/dist cuda_bindings/dist/*.tar.gz + - name: Download cuda.bindings wheel + if: ${{ !inputs.build-bindings && inputs.build-core }} + uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 + with: + name: cuda-bindings-python312-cuda${{ inputs.cuda-version }}-${{ inputs.host-platform }}-${{ github.sha }} + path: cuda_bindings/dist + - name: Constrain cuda.core to the local cuda.bindings wheel + if: ${{ inputs.build-core }} run: | CUDA_MAJOR="$(echo '${{ inputs.cuda-version }}' | cut -d. -f1)" pathfinder_wheels=(cuda_pathfinder/dist/cuda_pathfinder-*.whl) @@ -118,6 +157,7 @@ jobs: # wheel-from-sdist needs CTK and cuda-bindings (dynamic build dep via # get_requires_for_build_wheel in build_hooks.py). - name: Build cuda.core sdist and wheel-from-sdist + if: ${{ inputs.build-core }} run: | export CUDA_PYTHON_PARALLEL_LEVEL=$(nproc) export CUDA_CORE_BUILD_MAJOR="$(echo '${{ inputs.cuda-version }}' | cut -d. -f1)" diff --git a/.github/workflows/test-wheel-linux.yml b/.github/workflows/test-wheel-linux.yml index 4235e01d321..2fd918e2859 100644 --- a/.github/workflows/test-wheel-linux.yml +++ b/.github/workflows/test-wheel-linux.yml @@ -22,13 +22,18 @@ on: nruns: type: number default: 1 - # When true, cuda.bindings tests (and the Cython tests that depend on - # them) are skipped even when CTK majors match. Callers set this based - # on the output of the detect-changes job in ci.yml so PRs that only - # touch unrelated modules avoid the expensive bindings test suite. - skip-bindings-test: + test-pathfinder: type: boolean - default: false + default: true + test-bindings: + type: boolean + default: true + test-core: + type: boolean + default: true + test-python: + type: boolean + default: true run-id: description: > Workflow run ID to download artifacts from. @@ -159,7 +164,7 @@ jobs: LOCAL_CTK: ${{ matrix.LOCAL_CTK }} PY_VER: ${{ matrix.PY_VER }} SHA: ${{ inputs.sha || github.sha }} - SKIP_BINDINGS_TEST_OVERRIDE: ${{ inputs.skip-bindings-test && '1' || '0' }} + SKIP_BINDINGS_TEST_OVERRIDE: ${{ !inputs.test-bindings && '1' || '0' }} run: ./ci/tools/env-vars test - name: Apply extra matrix environment variables @@ -169,6 +174,7 @@ jobs: run: echo "$MATRIX_ENV" | jq -r 'to_entries[] | "\(.key)=\(.value)"' >> "$GITHUB_ENV" - name: Download cuda-pathfinder build artifacts + if: ${{ inputs.test-pathfinder || inputs.test-bindings || inputs.test-core || inputs.test-python }} uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 with: name: cuda-pathfinder-wheel @@ -177,7 +183,7 @@ jobs: github-token: ${{ secrets.GITHUB_TOKEN }} - name: Download cuda-python build artifacts - if: ${{ env.BINDINGS_SOURCE == 'main' }} + if: ${{ inputs.test-python && env.BINDINGS_SOURCE == 'main' }} uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 with: name: cuda-python-wheel @@ -186,7 +192,8 @@ jobs: github-token: ${{ secrets.GITHUB_TOKEN }} - name: Download cuda.bindings build artifacts - if: ${{ env.BINDINGS_SOURCE == 'main' }} + if: ${{ (inputs.test-bindings || inputs.test-core || inputs.test-python) && + env.BINDINGS_SOURCE == 'main' }} uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 with: name: ${{ env.CUDA_BINDINGS_ARTIFACT_NAME }} @@ -195,7 +202,8 @@ jobs: github-token: ${{ secrets.GITHUB_TOKEN }} - name: Download cuda-python & cuda.bindings build artifacts from the prior branch - if: ${{ env.BINDINGS_SOURCE == 'backport' }} + if: ${{ (inputs.test-bindings || inputs.test-core || inputs.test-python) && + env.BINDINGS_SOURCE == 'backport' }} env: GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} run: | @@ -211,34 +219,46 @@ jobs: OLD_BRANCH=${{ needs.compute-matrix.outputs.OLD_BRANCH }} OLD_BASENAME="cuda-bindings-python${PYTHON_VERSION_FORMATTED}-cuda*-${{ inputs.host-platform }}*" - LATEST_PRIOR_RUN_ID=$(./ci/tools/lookup-run-id --branch "${OLD_BRANCH}" NVIDIA/cuda-python "CI") + OLD_WHEEL_ARTIFACT_PATTERN="${OLD_BASENAME}[0-9a-f]" + LOOKUP_ARGS=( + --branch "${OLD_BRANCH}" + --artifact "${OLD_WHEEL_ARTIFACT_PATTERN}" + ) + if ${{ inputs.test-python }}; then + LOOKUP_ARGS+=(--artifact cuda-python-wheel) + fi + LATEST_PRIOR_RUN_ID=$(./ci/tools/lookup-run-id \ + "${LOOKUP_ARGS[@]}" NVIDIA/cuda-python "CI") - gh run download $LATEST_PRIOR_RUN_ID -p ${OLD_BASENAME} -R NVIDIA/cuda-python + gh run download "${LATEST_PRIOR_RUN_ID}" -p "${OLD_BASENAME}" -R NVIDIA/cuda-python rm -rf ${OLD_BASENAME}-tests # exclude cython test artifacts ls -al $OLD_BASENAME mkdir -p "${{ env.CUDA_BINDINGS_ARTIFACTS_DIR }}" mv $OLD_BASENAME/*.whl "${{ env.CUDA_BINDINGS_ARTIFACTS_DIR }}"/ rmdir $OLD_BASENAME - gh run download $LATEST_PRIOR_RUN_ID -p cuda-python-wheel -R NVIDIA/cuda-python - ls -al cuda-python-wheel - mv cuda-python-wheel/*.whl . - rmdir cuda-python-wheel + if ${{ inputs.test-python }}; then + gh run download "${LATEST_PRIOR_RUN_ID}" -p cuda-python-wheel -R NVIDIA/cuda-python + ls -al cuda-python-wheel + mv cuda-python-wheel/*.whl . + rmdir cuda-python-wheel + fi - name: Display structure of downloaded cuda-python artifacts - if: ${{ env.BINDINGS_SOURCE != 'published' }} + if: ${{ inputs.test-python && env.BINDINGS_SOURCE != 'published' }} run: | pwd ls -lah cuda_python*.whl cuda_pathfinder/ - name: Display structure of downloaded cuda.bindings artifacts - if: ${{ env.BINDINGS_SOURCE != 'published' }} + if: ${{ (inputs.test-bindings || inputs.test-core || inputs.test-python) && + env.BINDINGS_SOURCE != 'published' }} run: | pwd ls -lahR $CUDA_BINDINGS_ARTIFACTS_DIR - name: Download cuda.bindings Cython tests - if: ${{ env.SKIP_CYTHON_TEST == '0' }} + if: ${{ inputs.test-bindings && env.SKIP_CYTHON_TEST == '0' }} uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 with: name: ${{ env.CUDA_BINDINGS_ARTIFACT_NAME }}-tests @@ -247,12 +267,13 @@ jobs: github-token: ${{ secrets.GITHUB_TOKEN }} - name: Display structure of downloaded cuda.bindings Cython tests - if: ${{ env.SKIP_CYTHON_TEST == '0' }} + if: ${{ inputs.test-bindings && env.SKIP_CYTHON_TEST == '0' }} run: | pwd ls -lahR $CUDA_BINDINGS_CYTHON_TESTS_DIR - name: Download cuda.core build artifacts + if: ${{ inputs.test-core }} uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 with: name: ${{ env.CUDA_CORE_ARTIFACT_NAME }} @@ -261,12 +282,13 @@ jobs: github-token: ${{ secrets.GITHUB_TOKEN }} - name: Display structure of downloaded cuda.core build artifacts + if: ${{ inputs.test-core }} run: | pwd ls -lahR $CUDA_CORE_ARTIFACTS_DIR - name: Download cuda.core Cython tests - if: ${{ env.SKIP_CYTHON_TEST == '0' }} + if: ${{ inputs.test-core && env.SKIP_CYTHON_TEST == '0' }} uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 with: name: ${{ env.CUDA_CORE_ARTIFACT_NAME }}-tests @@ -275,12 +297,13 @@ jobs: github-token: ${{ secrets.GITHUB_TOKEN }} - name: Display structure of downloaded cuda.core Cython tests - if: ${{ env.SKIP_CYTHON_TEST == '0' }} + if: ${{ inputs.test-core && env.SKIP_CYTHON_TEST == '0' }} run: | pwd ls -lahR $CUDA_CORE_CYTHON_TESTS_DIR - name: Download cuda.core test binaries + if: ${{ inputs.test-core }} uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 with: name: ${{ env.CUDA_CORE_ARTIFACT_NAME }}-test-binaries @@ -289,6 +312,7 @@ jobs: github-token: ${{ secrets.GITHUB_TOKEN }} - name: Display structure of downloaded cuda.core test binaries + if: ${{ inputs.test-core }} run: | pwd ls -lahR $CUDA_CORE_TEST_BINARIES_DIR @@ -304,7 +328,8 @@ jobs: AGENT_TOOLSDIRECTORY: "/opt/hostedtoolcache" - name: Enable Scientific Python Nightly Wheels for Python 3.15 - if: ${{ startsWith(matrix.PY_VER, '3.15') }} + if: ${{ (inputs.test-bindings || inputs.test-core || inputs.test-python) && + startsWith(matrix.PY_VER, '3.15') }} run: | echo "PIP_EXTRA_INDEX_URL=https://pypi.anaconda.org/scientific-python-nightly-wheels/simple" >> "$GITHUB_ENV" echo "PIP_ONLY_BINARY=numpy" >> "$GITHUB_ENV" @@ -318,7 +343,7 @@ jobs: cuda-version: ${{ matrix.CUDA_VER }} - name: Set up latest cuda_sanitizer_api - if: ${{ env.SETUP_SANITIZER == '1' }} + if: ${{ (inputs.test-bindings || inputs.test-core) && env.SETUP_SANITIZER == '1' }} uses: ./.github/actions/fetch_ctk continue-on-error: false with: @@ -327,6 +352,7 @@ jobs: cuda-components: "cuda_sanitizer_api" - name: Set up compute-sanitizer + if: ${{ inputs.test-bindings || inputs.test-core }} run: setup-sanitizer - name: Set up test repetition on nightly runs @@ -334,7 +360,7 @@ jobs: # ── Standard test steps (skipped for nightly modes) ── - name: Run cuda.pathfinder tests with see_what_works - if: ${{ inputs.test-mode == 'standard' }} + if: ${{ inputs.test-mode == 'standard' && inputs.test-pathfinder }} env: CUDA_PATHFINDER_TEST_LOAD_NVIDIA_DYNAMIC_LIB_STRICTNESS: see_what_works CUDA_PATHFINDER_TEST_FIND_NVIDIA_HEADERS_STRICTNESS: see_what_works @@ -342,14 +368,14 @@ jobs: run: run-tests pathfinder - name: Run cuda.bindings tests - if: ${{ inputs.test-mode == 'standard' && env.SKIP_CUDA_BINDINGS_TEST == '0' }} + if: ${{ inputs.test-mode == 'standard' && inputs.test-bindings && env.SKIP_CUDA_BINDINGS_TEST == '0' }} env: CUDA_VER: ${{ matrix.CUDA_VER }} LOCAL_CTK: ${{ matrix.LOCAL_CTK }} run: run-tests bindings - name: Run cuda.bindings benchmarks (smoke test) - if: ${{ inputs.test-mode == 'standard' && env.SKIP_CUDA_BINDINGS_TEST == '0' }} + if: ${{ inputs.test-mode == 'standard' && inputs.test-bindings && env.SKIP_CUDA_BINDINGS_TEST == '0' }} run: | pip install pyperf pushd benchmarks/cuda_bindings @@ -357,25 +383,35 @@ jobs: popd - name: Run cuda.core tests - if: ${{ inputs.test-mode == 'standard' }} + if: ${{ inputs.test-mode == 'standard' && inputs.test-core }} env: CUDA_VER: ${{ matrix.CUDA_VER }} LOCAL_CTK: ${{ matrix.LOCAL_CTK }} run: run-tests core - name: Ensure cuda-python installable - if: ${{ inputs.test-mode == 'standard' && env.BINDINGS_SOURCE == 'main' }} + if: ${{ inputs.test-mode == 'standard' && inputs.test-python && 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: --no-deps cuda_python*.whl + # Package suites install their own dependencies. A metapackage-only + # run has no preceding suite, so install the exact local internal + # wheels in one transaction while resolving released dependencies + # such as cuda-core from the package index. + if ${{ inputs.test-bindings || inputs.test-core }}; then + dependency_args=(--no-deps) else - pip install --only-binary=:all: --no-deps $(ls cuda_python*.whl)[all] + dependency_args=( + ./cuda_pathfinder/cuda_pathfinder-*.whl + "${CUDA_BINDINGS_ARTIFACTS_DIR}"/cuda_bindings-*.whl + ) + fi + python_requirements=(cuda_python*.whl) + if [[ "${{ matrix.LOCAL_CTK }}" != 1 ]]; then + python_requirements=("${python_requirements[@]/%/[all]}") fi + pip install --only-binary=:all: "${dependency_args[@]}" "${python_requirements[@]}" - name: Install cuda.pathfinder extra wheels for testing - if: ${{ inputs.test-mode == 'standard' }} + if: ${{ inputs.test-mode == 'standard' && inputs.test-pathfinder }} run: | set -euo pipefail pushd cuda_pathfinder @@ -384,7 +420,7 @@ jobs: popd - name: Run cuda.pathfinder tests with all_must_work - if: ${{ inputs.test-mode == 'standard' }} + if: ${{ inputs.test-mode == 'standard' && inputs.test-pathfinder }} env: CUDA_PATHFINDER_TEST_LOAD_NVIDIA_DYNAMIC_LIB_STRICTNESS: all_must_work CUDA_PATHFINDER_TEST_FIND_NVIDIA_HEADERS_STRICTNESS: all_must_work diff --git a/.github/workflows/test-wheel-windows.yml b/.github/workflows/test-wheel-windows.yml index 91da06d9eac..1af7c4b625b 100644 --- a/.github/workflows/test-wheel-windows.yml +++ b/.github/workflows/test-wheel-windows.yml @@ -22,13 +22,18 @@ on: nruns: type: number default: 1 - # When true, cuda.bindings tests (and the Cython tests that depend on - # them) are skipped even when CTK majors match. Callers set this based - # on the output of the detect-changes job in ci.yml so PRs that only - # touch unrelated modules avoid the expensive bindings test suite. - skip-bindings-test: + test-pathfinder: type: boolean - default: false + default: true + test-bindings: + type: boolean + default: true + test-core: + type: boolean + default: true + test-python: + type: boolean + default: true run-id: description: > Workflow run ID to download artifacts from. @@ -146,7 +151,7 @@ jobs: LOCAL_CTK: ${{ matrix.LOCAL_CTK }} PY_VER: ${{ matrix.PY_VER }} SHA: ${{ inputs.sha || github.sha }} - SKIP_BINDINGS_TEST_OVERRIDE: ${{ inputs.skip-bindings-test && '1' || '0' }} + SKIP_BINDINGS_TEST_OVERRIDE: ${{ !inputs.test-bindings && '1' || '0' }} shell: bash --noprofile --norc -xeuo pipefail {0} run: ./ci/tools/env-vars test @@ -158,6 +163,7 @@ jobs: run: echo "$MATRIX_ENV" | jq -r 'to_entries[] | "\(.key)=\(.value)"' >> "$GITHUB_ENV" - name: Download cuda-pathfinder build artifacts + if: ${{ inputs.test-pathfinder || inputs.test-bindings || inputs.test-core || inputs.test-python }} uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 with: name: cuda-pathfinder-wheel @@ -166,7 +172,7 @@ jobs: github-token: ${{ secrets.GITHUB_TOKEN }} - name: Download cuda-python build artifacts - if: ${{ env.BINDINGS_SOURCE == 'main' }} + if: ${{ inputs.test-python && env.BINDINGS_SOURCE == 'main' }} uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 with: name: cuda-python-wheel @@ -175,7 +181,8 @@ jobs: github-token: ${{ secrets.GITHUB_TOKEN }} - name: Download cuda.bindings build artifacts - if: ${{ env.BINDINGS_SOURCE == 'main' }} + if: ${{ (inputs.test-bindings || inputs.test-core || inputs.test-python) && + env.BINDINGS_SOURCE == 'main' }} uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 with: name: ${{ env.CUDA_BINDINGS_ARTIFACT_NAME }} @@ -184,41 +191,54 @@ jobs: github-token: ${{ secrets.GITHUB_TOKEN }} - name: Download cuda-python & cuda.bindings build artifacts from the prior branch - if: ${{ env.BINDINGS_SOURCE == 'backport' }} + if: ${{ (inputs.test-bindings || inputs.test-core || inputs.test-python) && + env.BINDINGS_SOURCE == 'backport' }} env: GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} shell: bash --noprofile --norc -xeuo pipefail {0} run: | OLD_BRANCH=$(yq '.backport_branch' ci/versions.yml) OLD_BASENAME="cuda-bindings-python${PYTHON_VERSION_FORMATTED}-cuda*-${{ inputs.host-platform }}*" - LATEST_PRIOR_RUN_ID=$(./ci/tools/lookup-run-id --branch "${OLD_BRANCH}" NVIDIA/cuda-python "CI") + OLD_WHEEL_ARTIFACT_PATTERN="${OLD_BASENAME}[0-9a-f]" + LOOKUP_ARGS=( + --branch "${OLD_BRANCH}" + --artifact "${OLD_WHEEL_ARTIFACT_PATTERN}" + ) + if ${{ inputs.test-python }}; then + LOOKUP_ARGS+=(--artifact cuda-python-wheel) + fi + LATEST_PRIOR_RUN_ID=$(./ci/tools/lookup-run-id \ + "${LOOKUP_ARGS[@]}" NVIDIA/cuda-python "CI") - gh run download $LATEST_PRIOR_RUN_ID -p ${OLD_BASENAME} -R NVIDIA/cuda-python + gh run download "${LATEST_PRIOR_RUN_ID}" -p "${OLD_BASENAME}" -R NVIDIA/cuda-python rm -rf ${OLD_BASENAME}-tests # exclude cython test artifacts ls -al $OLD_BASENAME mkdir -p "${{ env.CUDA_BINDINGS_ARTIFACTS_DIR }}" mv $OLD_BASENAME/*.whl "${{ env.CUDA_BINDINGS_ARTIFACTS_DIR }}"/ rmdir $OLD_BASENAME - gh run download $LATEST_PRIOR_RUN_ID -p cuda-python-wheel -R NVIDIA/cuda-python - ls -al cuda-python-wheel - mv cuda-python-wheel/*.whl . - rmdir cuda-python-wheel + if ${{ inputs.test-python }}; then + gh run download "${LATEST_PRIOR_RUN_ID}" -p cuda-python-wheel -R NVIDIA/cuda-python + ls -al cuda-python-wheel + mv cuda-python-wheel/*.whl . + rmdir cuda-python-wheel + fi - name: Display structure of downloaded cuda-python artifacts - if: ${{ env.BINDINGS_SOURCE != 'published' }} + if: ${{ inputs.test-python && env.BINDINGS_SOURCE != 'published' }} run: | Get-Location Get-ChildItem cuda_python*.whl | Select-Object Mode, LastWriteTime, Length, FullName - name: Display structure of downloaded cuda.bindings artifacts - if: ${{ env.BINDINGS_SOURCE != 'published' }} + if: ${{ (inputs.test-bindings || inputs.test-core || inputs.test-python) && + env.BINDINGS_SOURCE != 'published' }} run: | Get-Location Get-ChildItem -Recurse -Force $env:CUDA_BINDINGS_ARTIFACTS_DIR | Select-Object Mode, LastWriteTime, Length, FullName - name: Download cuda.bindings Cython tests - if: ${{ env.SKIP_CYTHON_TEST == '0' }} + if: ${{ inputs.test-bindings && env.SKIP_CYTHON_TEST == '0' }} uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 with: name: ${{ env.CUDA_BINDINGS_ARTIFACT_NAME }}-tests @@ -227,12 +247,13 @@ jobs: github-token: ${{ secrets.GITHUB_TOKEN }} - name: Display structure of downloaded cuda.bindings Cython tests - if: ${{ env.SKIP_CYTHON_TEST == '0' }} + if: ${{ inputs.test-bindings && env.SKIP_CYTHON_TEST == '0' }} run: | Get-Location Get-ChildItem -Recurse -Force $env:CUDA_BINDINGS_CYTHON_TESTS_DIR | Select-Object Mode, LastWriteTime, Length, FullName - name: Download cuda.core build artifacts + if: ${{ inputs.test-core }} uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 with: name: ${{ env.CUDA_CORE_ARTIFACT_NAME }} @@ -241,12 +262,13 @@ jobs: github-token: ${{ secrets.GITHUB_TOKEN }} - name: Display structure of downloaded cuda.core build artifacts + if: ${{ inputs.test-core }} run: | Get-Location Get-ChildItem -Recurse -Force $env:CUDA_CORE_ARTIFACTS_DIR | Select-Object Mode, LastWriteTime, Length, FullName - name: Download cuda.core Cython tests - if: ${{ env.SKIP_CYTHON_TEST == '0' }} + if: ${{ inputs.test-core && env.SKIP_CYTHON_TEST == '0' }} uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 with: name: ${{ env.CUDA_CORE_ARTIFACT_NAME }}-tests @@ -255,12 +277,13 @@ jobs: github-token: ${{ secrets.GITHUB_TOKEN }} - name: Display structure of downloaded cuda.core Cython tests - if: ${{ env.SKIP_CYTHON_TEST == '0' }} + if: ${{ inputs.test-core && env.SKIP_CYTHON_TEST == '0' }} run: | Get-Location Get-ChildItem -Recurse -Force $env:CUDA_CORE_CYTHON_TESTS_DIR | Select-Object Mode, LastWriteTime, Length, FullName - name: Download cuda.core test binaries + if: ${{ inputs.test-core }} uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 with: name: ${{ env.CUDA_CORE_ARTIFACT_NAME }}-test-binaries @@ -269,6 +292,7 @@ jobs: github-token: ${{ secrets.GITHUB_TOKEN }} - name: Display structure of downloaded cuda.core test binaries + if: ${{ inputs.test-core }} run: | Get-Location Get-ChildItem -Recurse -Force $env:CUDA_CORE_TEST_BINARIES_DIR | Select-Object Mode, LastWriteTime, Length, FullName @@ -281,7 +305,8 @@ jobs: allow-prereleases: ${{ startsWith(matrix.PY_VER, '3.15') }} - name: Enable Scientific Python Nightly Wheels for Python 3.15 - if: ${{ startsWith(matrix.PY_VER, '3.15') }} + if: ${{ (inputs.test-bindings || inputs.test-core || inputs.test-python) && + startsWith(matrix.PY_VER, '3.15') }} shell: bash --noprofile --norc -xeuo pipefail {0} run: | echo "PIP_EXTRA_INDEX_URL=https://pypi.anaconda.org/scientific-python-nightly-wheels/simple" >> "$GITHUB_ENV" @@ -310,7 +335,7 @@ jobs: # ── Standard test steps (skipped for nightly modes) ── - name: Run cuda.pathfinder tests with see_what_works - if: ${{ inputs.test-mode == 'standard' }} + if: ${{ inputs.test-mode == 'standard' && inputs.test-pathfinder }} env: CUDA_PATHFINDER_TEST_LOAD_NVIDIA_DYNAMIC_LIB_STRICTNESS: see_what_works CUDA_PATHFINDER_TEST_FIND_NVIDIA_HEADERS_STRICTNESS: see_what_works @@ -319,7 +344,7 @@ jobs: run: run-tests pathfinder - name: Run cuda.bindings tests - if: ${{ inputs.test-mode == 'standard' && env.SKIP_CUDA_BINDINGS_TEST == '0' }} + if: ${{ inputs.test-mode == 'standard' && inputs.test-bindings && env.SKIP_CUDA_BINDINGS_TEST == '0' }} env: CUDA_VER: ${{ matrix.CUDA_VER }} LOCAL_CTK: ${{ matrix.LOCAL_CTK }} @@ -327,7 +352,7 @@ jobs: run: run-tests bindings - name: Run cuda.core tests - if: ${{ inputs.test-mode == 'standard' }} + if: ${{ inputs.test-mode == 'standard' && inputs.test-core }} env: CUDA_VER: ${{ matrix.CUDA_VER }} LOCAL_CTK: ${{ matrix.LOCAL_CTK }} @@ -335,18 +360,28 @@ jobs: run: run-tests core - name: Ensure cuda-python installable - if: ${{ inputs.test-mode == 'standard' && env.BINDINGS_SOURCE == 'main' }} + if: ${{ inputs.test-mode == 'standard' && inputs.test-python && 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: --no-deps (Get-ChildItem -Filter cuda_python*.whl).FullName + # Package suites install their own dependencies. A metapackage-only + # run has no preceding suite, so install the exact local internal + # wheels in one transaction while resolving released dependencies + # such as cuda-core from the package index. + if ('${{ inputs.test-bindings || inputs.test-core }}' -eq 'true') { + $dependencyArgs = @('--no-deps') } else { - pip install --only-binary=:all: --no-deps "$((Get-ChildItem -Filter cuda_python*.whl).FullName)[all]" + $dependencyArgs = @( + (Get-Item ./cuda_pathfinder/cuda_pathfinder-*.whl).FullName + (Get-Item "$env:CUDA_BINDINGS_ARTIFACTS_DIR/cuda_bindings-*.whl").FullName + ) + } + $pythonRequirements = @((Get-Item ./cuda_python*.whl).FullName) + if ('${{ matrix.LOCAL_CTK }}' -ne '1') { + $pythonRequirements = @($pythonRequirements | ForEach-Object { "$($_)[all]" }) } + pip install --only-binary=:all: @dependencyArgs @pythonRequirements - name: Install cuda.pathfinder extra wheels for testing - if: ${{ inputs.test-mode == 'standard' }} + if: ${{ inputs.test-mode == 'standard' && inputs.test-pathfinder }} shell: bash --noprofile --norc -xeuo pipefail {0} run: | pushd cuda_pathfinder @@ -355,7 +390,7 @@ jobs: popd - name: Run cuda.pathfinder tests with all_must_work - if: ${{ inputs.test-mode == 'standard' }} + if: ${{ inputs.test-mode == 'standard' && inputs.test-pathfinder }} env: CUDA_PATHFINDER_TEST_LOAD_NVIDIA_DYNAMIC_LIB_STRICTNESS: all_must_work CUDA_PATHFINDER_TEST_FIND_NVIDIA_HEADERS_STRICTNESS: all_must_work diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 451e665cbf6..06591bf4c9f 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -9,12 +9,20 @@ ci: autoupdate_branch: '' autoupdate_commit_msg: '[pre-commit.ci] pre-commit autoupdate' autoupdate_schedule: quarterly - skip: [lychee, check-precommit-installed] + skip: [lychee, check-precommit-installed, secret-scan-trufflehog, check-pixi-cuda-version] submodules: false # Please update the rev: SHAs below with this command: # pre-commit autoupdate --freeze repos: + # Runs first so a leaked credential blocks the commit before any formatter runs. + # Self-installing: the hook downloads a pinned, checksum-verified trufflehog on + # first use (no manual install). Skipped on pre-commit.ci; Pulse CI enforces server-side. + - repo: https://github.com/NVIDIA/security-workflows + rev: 711025b090f2aa728da576700750b195d1e816dc # frozen: v0.3.0 + hooks: + - id: secret-scan-trufflehog + - repo: https://github.com/astral-sh/ruff-pre-commit rev: c60c980e561ed3e73101667fe8365c609d19a438 # frozen: v0.15.9 hooks: diff --git a/AGENTS.md b/AGENTS.md index e66437159b0..d026df1b5c8 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -14,26 +14,16 @@ guide for package-specific conventions and workflows. # Pull requests -**Never push branches or commits to the upstream repo (github.com/NVIDIA/cuda-python). -Treat it as read-only.** All branch creation and pushes must go to the contributor's -personal fork. Before pushing, confirm which remote points to the contributor's -personal fork (not `upstream`) by running `git remote -v`, then push there -(`git push <personal-fork-remote> <branch>`). Open the PR from that fork with -`gh pr create`. Do not use `git push upstream` or any command that writes to -the `upstream` remote. - -When creating pull requests with `gh pr create`, always assign at least one -label and a milestone. CI enforces this via the `pr-metadata-check` workflow -and will block PRs that are missing labels or a milestone. Use `--label` and -`--milestone` flags, for example: - -``` -gh pr create --title "..." --body "..." --label "bug" --milestone "v1.0" -``` - -If you are unsure which label or milestone to use, check the existing labels -and milestones on the repository with `gh label list` and `gh api -repos/{owner}/{repo}/milestones --jq '.[].title'`, and pick the best match. +**Never push branches or commits to the canonical upstream repository. Treat +it as read-only.** Branch creation and pushes for pull-request work must go to +an approved fork associated with the contributor. The fork may be owned by the +contributor's personal account or by an organization. + +Before pushing, run `git remote -v` and confirm that the intended push remote +points to a fork of the pull-request base, not to the base repository itself. +Compare complete `OWNER/REPOSITORY` names; do not rely on remote names such as +`origin` or `upstream`, or on the owner alone. Do not use `git push upstream` +or any command that writes to the upstream remote. # General diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 2a477edddeb..7474ac4d840 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -179,6 +179,11 @@ commit` workflow. To resolve this, you can either: 2. Skip it by setting the environment variable `SKIP` to `lychee`. This would be `$env:SKIP = "lychee"` in PowerShell or `set SKIP=lychee` in cmd. +## Secret Scanning + +The `secret-scan-trufflehog` pre-commit hook scans staged files and installs TruffleHog into its own environment on first run, on Linux, macOS, and Windows. If it flags a secret, remove it before committing, or contact a maintainer if it's a false positive. Secrets are also scanned server-side in CI. + + ## Signing Your Work Contributions to files licensed under Apache 2.0 must be certified under the diff --git a/LICENSE b/LICENSE index d6f74778be8..f3fe76ecadf 100644 --- a/LICENSE +++ b/LICENSE @@ -176,3 +176,28 @@ Copyright (c) 2024-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/README.md b/README.md index 10d0bc6a0cf..9c2955f6b7e 100644 --- a/README.md +++ b/README.md @@ -52,3 +52,14 @@ The list of available interfaces is: CUDA Python is licensed under the [Apache License 2.0](./LICENSE). Third-party attributions for `cuda.core` are listed in [`cuda_core/NOTICE`](./cuda_core/NOTICE). + +Each subproject is distributed as its own package and ships a copy of the same +license alongside its sources, so that the license accompanies the built wheel. +The root `LICENSE` governs the repository as a whole: + +| Subproject | License | License file | +| ---------------- | ---------- | -------------------------------------------------------- | +| `cuda.bindings` | Apache-2.0 | [`cuda_bindings/LICENSE`](./cuda_bindings/LICENSE) | +| `cuda.core` | Apache-2.0 | [`cuda_core/LICENSE`](./cuda_core/LICENSE) | +| `cuda.pathfinder`| Apache-2.0 | [`cuda_pathfinder/LICENSE`](./cuda_pathfinder/LICENSE) | +| `cuda-python` | Apache-2.0 | [`cuda_python/LICENSE`](./cuda_python/LICENSE) | diff --git a/benchmarks/cuda_bindings/runner/main.py b/benchmarks/cuda_bindings/runner/main.py index 9c984c340d6..eb2bcdacaf0 100644 --- a/benchmarks/cuda_bindings/runner/main.py +++ b/benchmarks/cuda_bindings/runner/main.py @@ -232,11 +232,18 @@ def parse_args(argv: list[str], default_output: Path = DEFAULT_OUTPUT) -> tuple[ def main( *, - bench_dir: Path = BENCH_DIR, - default_output: Path = DEFAULT_OUTPUT, + bench_dir: Path | None = None, + default_output: Path | None = None, module_name_prefix: str = DEFAULT_MODULE_NAME_PREFIX, bench_filter_env_var: str = DEFAULT_BENCH_FILTER_ENV_VAR, ) -> None: + # Resolve the defaults inside the call, for the same reason + # discover_benchmarks() does: a literal default would be bound at def-time + # and would ignore a later monkeypatch of the module-level constant. + if bench_dir is None: + bench_dir = BENCH_DIR + if default_output is None: + default_output = DEFAULT_OUTPUT parsed, remaining_argv = parse_args(sys.argv[1:], default_output=default_output) registry = discover_benchmarks(bench_dir=bench_dir, module_name_prefix=module_name_prefix) diff --git a/benchmarks/cuda_bindings/tests/test_runner.py b/benchmarks/cuda_bindings/tests/test_runner.py index 56d88444c9e..836653522a1 100644 --- a/benchmarks/cuda_bindings/tests/test_runner.py +++ b/benchmarks/cuda_bindings/tests/test_runner.py @@ -164,3 +164,24 @@ def test_bench_launch_initializes_on_first_use(monkeypatch): assert len(compile_calls) == 1 assert len(launch_calls) == 2 + + +def test_main_honors_a_monkeypatched_bench_dir(monkeypatch, tmp_path, capsys): + """main() must resolve BENCH_DIR at call time, like discover_benchmarks() does. + + A literal default would be bound at def-time and would silently ignore a + later patch of the module-level constant. + """ + runner_main = load_runner_main(monkeypatch) + + (tmp_path / "bench_patched.py").write_text( + "def bench_only_here(loops: int) -> float:\n return loops + 0.5\n", + encoding="utf-8", + ) + monkeypatch.setattr(runner_main, "BENCH_DIR", tmp_path) + runner_main._MODULE_CACHE.clear() + monkeypatch.setattr(sys, "argv", ["run_pyperf.py", "--list"]) + + runner_main.main() + + assert capsys.readouterr().out.split() == ["patched.only_here"] diff --git a/ci/tools/check_release_notes.py b/ci/tools/check_release_notes.py index 75d2c9871f0..1c99ddb019a 100644 --- a/ci/tools/check_release_notes.py +++ b/ci/tools/check_release_notes.py @@ -18,6 +18,7 @@ import os import re import sys +from pathlib import Path COMPONENT_TO_PACKAGE: dict[str, str] = { "cuda-core": "cuda_core", @@ -62,8 +63,8 @@ def is_post_release(version: str) -> bool: return ".post" in version -def load_backport_branch(repo_root: str = ".") -> str | None: - path = os.path.join(repo_root, "ci", "versions.yml") +def load_backport_branch(repo_root: Path = Path(".")) -> str | None: + path = repo_root / "ci" / "versions.yml" try: with open(path, encoding="utf-8") as f: for line in f: @@ -84,13 +85,16 @@ def is_backport_version(version: str, backport_branch: str) -> bool: return version == backport_branch -def notes_path(package: str, version: str) -> str: - return os.path.join(package, "docs", "source", "release", f"{version}-notes.rst") +def notes_path(package: str, version: str) -> Path: + return Path(package, "docs", "source", "release", f"{version}-notes.rst") -def check_release_notes(git_tag: str, component: str, repo_root: str = ".") -> list[tuple[str, str]]: +def check_release_notes(git_tag: str, component: str, repo_root: Path = Path(".")) -> list[tuple[str | Path, str]]: """Return a list of (path, reason) for missing or empty release notes. + ``path`` is the repo-relative notes path, or a ``<placeholder>`` naming the + offending argument when the tag or component itself is the problem. + Returns an empty list when notes are present and non-empty, or when the tag is a .post release (no new notes required). """ @@ -105,10 +109,10 @@ def check_release_notes(git_tag: str, component: str, repo_root: str = ".") -> l return [] path = notes_path(COMPONENT_TO_PACKAGE[component], version) - full = os.path.join(repo_root, path) - if not os.path.isfile(full): + full = repo_root / path + if not full.is_file(): return [(path, "missing")] - if os.path.getsize(full) == 0: + if full.stat().st_size == 0: return [(path, "empty")] return [] @@ -123,7 +127,7 @@ def write_step_summary(message: str) -> None: f.write("\n") -def warn_missing_backport_notes(git_tag: str, component: str, problems: list[tuple[str, str]]) -> None: +def warn_missing_backport_notes(git_tag: str, component: str, problems: list[tuple[str | Path, str]]) -> None: print(f"WARNING: missing or empty release notes for backport tag {git_tag}:") summary_lines = [ "## Release Notes Reminder", @@ -147,8 +151,8 @@ def validate_backport_decision( version: str, backport_git_tag: str, backport_branch: str | None, - repo_root: str, -) -> tuple[int | None, list[tuple[str, str]]]: + repo_root: Path, +) -> tuple[int | None, list[tuple[str | Path, str]]]: if component not in BACKPORT_PLANNING_COMPONENTS or is_post_release(version): return None, [] @@ -205,7 +209,7 @@ def main(argv: list[str] | None = None) -> int: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--git-tag", required=True) parser.add_argument("--component", required=True, choices=list(COMPONENT_TO_PACKAGE)) - parser.add_argument("--repo-root", default=".") + parser.add_argument("--repo-root", default=Path("."), type=Path) parser.add_argument("--backport-git-tag", default="") parser.add_argument("--backport-branch", default="") args = parser.parse_args(argv) diff --git a/ci/tools/lookup-run-id b/ci/tools/lookup-run-id index bd8ba413974..cc106c4e4f3 100755 --- a/ci/tools/lookup-run-id +++ b/ci/tools/lookup-run-id @@ -8,7 +8,7 @@ # # Two modes: # --tag <tag> Find the successful CI run triggered by a tag push. -# --branch <branch> Find the latest successful CI run on a branch. +# --branch <branch> Find the latest qualifying successful CI run on a branch. # # Outputs the run ID on stdout. All diagnostic messages go to stderr. # When --head-sha is passed, a second line with the run's head SHA is printed. @@ -24,11 +24,14 @@ Usage: Options: --tag <tag> Find run by git tag (requires local git repo with the tag) --branch <branch> Find latest successful run on the given branch + --artifact <glob> Require an unexpired artifact matching this shell glob + (repeatable; branch mode only) --head-sha Also print the run's head commit SHA (second line) Examples: $0 --tag v13.0.1 NVIDIA/cuda-python $0 --branch main NVIDIA/cuda-python + $0 --branch 12.9.x --artifact 'cuda-bindings-python313-*' NVIDIA/cuda-python $0 --branch main --head-sha NVIDIA/cuda-python "CI" EOF exit 1 @@ -38,15 +41,21 @@ EOF MODE="" REF="" HEAD_SHA_FLAG=0 +ARTIFACT_PATTERNS=() while [[ $# -gt 0 ]]; do case "${1}" in --tag) + [[ $# -ge 2 ]] || usage [[ -n "${MODE}" && "${MODE}" != "tag" ]] && { echo "Error: --tag and --branch are mutually exclusive" >&2; exit 1; } MODE="tag"; REF="${2}"; shift 2 ;; --branch) + [[ $# -ge 2 ]] || usage [[ -n "${MODE}" && "${MODE}" != "branch" ]] && { echo "Error: --tag and --branch are mutually exclusive" >&2; exit 1; } MODE="branch"; REF="${2}"; shift 2 ;; + --artifact) + [[ $# -ge 2 ]] || usage + ARTIFACT_PATTERNS+=("${2}"); shift 2 ;; --head-sha) HEAD_SHA_FLAG=1; shift ;; -h|--help) @@ -69,6 +78,11 @@ WORKFLOW_NAME="${1:-CI}" if [[ -z "${REPOSITORY}" ]]; then usage; fi +if [[ "${MODE}" != "branch" && ${#ARTIFACT_PATTERNS[@]} -gt 0 ]]; then + echo "Error: --artifact is only supported with --branch" >&2 + exit 1 +fi + # ── Prerequisite checks ── if [[ -z "${GH_TOKEN:-}" ]]; then echo "Error: GH_TOKEN environment variable is required" >&2 @@ -86,17 +100,79 @@ done if [[ "${MODE}" == "branch" ]]; then echo "Looking up latest successful '${WORKFLOW_NAME}' run on branch: ${REF}" >&2 - RUN_ID=$(gh run list \ - -b "${REF}" \ - -L 1 \ - -w "${WORKFLOW_NAME}" \ - -s success \ - -R "${REPOSITORY}" \ - --json databaseId \ - | jq -r '.[0].databaseId // empty') + RUN_DATA=$(gh run list \ + --repo "${REPOSITORY}" \ + --branch "${REF}" \ + --workflow "${WORKFLOW_NAME}" \ + --status completed \ + --json databaseId,workflowName,status,conclusion,headSha,headBranch,createdAt,url \ + --limit 100) + + CANDIDATE_RUNS=$(echo "${RUN_DATA}" | jq -r \ + --arg branch "${REF}" ' + map(select( + .headBranch == $branch + and .conclusion == "success" + )) + | sort_by(.createdAt, .databaseId) + | reverse + | .[] + | [.databaseId, .headSha, .createdAt] + | @tsv + ') + + if [[ -z "${CANDIDATE_RUNS}" ]]; then + echo "Error: No successful '${WORKFLOW_NAME}' run found on branch '${REF}'" >&2 + exit 1 + fi + + if [[ ${#ARTIFACT_PATTERNS[@]} -gt 0 ]]; then + echo "Requiring unexpired artifacts matching:" >&2 + printf ' - %s\n' "${ARTIFACT_PATTERNS[@]}" >&2 + fi + + RUN_ID="" + HEAD_SHA="" + while IFS= read -r candidate; do + IFS=$'\t' read -r candidate_id candidate_sha candidate_created_at <<< "${candidate}" + + missing_patterns=() + if [[ ${#ARTIFACT_PATTERNS[@]} -gt 0 ]]; then + if ! ARTIFACT_NAMES=$(gh api --paginate \ + "repos/${REPOSITORY}/actions/runs/${candidate_id}/artifacts?per_page=100" \ + --jq '.artifacts[] | select(.expired == false) | .name'); then + echo "Error: Failed to list artifacts for run ${candidate_id}" >&2 + exit 1 + fi + + for pattern in "${ARTIFACT_PATTERNS[@]}"; do + pattern_matched=0 + while IFS= read -r artifact_name; do + # The caller supplies a shell glob, so the RHS must remain unquoted. + # shellcheck disable=SC2053 + if [[ -n "${artifact_name}" && "${artifact_name}" == ${pattern} ]]; then + pattern_matched=1 + break + fi + done <<< "${ARTIFACT_NAMES}" + if [[ ${pattern_matched} == 0 ]]; then + missing_patterns+=("${pattern}") + fi + done + fi + + if [[ ${#missing_patterns[@]} -gt 0 ]]; then + echo "Skipping run ${candidate_id} (${candidate_created_at}); missing unexpired artifact(s): ${missing_patterns[*]}" >&2 + continue + fi + + RUN_ID="${candidate_id}" + HEAD_SHA="${candidate_sha}" + break + done <<< "${CANDIDATE_RUNS}" if [[ -z "${RUN_ID}" ]]; then - echo "Error: No successful '${WORKFLOW_NAME}' run found on branch '${REF}'" >&2 + echo "Error: No successful '${WORKFLOW_NAME}' run on branch '${REF}' has all required artifacts" >&2 exit 1 fi @@ -104,10 +180,10 @@ if [[ "${MODE}" == "branch" ]]; then echo "${RUN_ID}" if [[ "${HEAD_SHA_FLAG}" == 1 ]]; then - HEAD_SHA=$(gh run view "${RUN_ID}" \ - -R "${REPOSITORY}" \ - --json headSha \ - | jq -r '.headSha') + if [[ -z "${HEAD_SHA}" ]]; then + echo "Error: Run ${RUN_ID} has no head SHA" >&2 + exit 1 + fi echo "Head SHA: ${HEAD_SHA}" >&2 echo "${HEAD_SHA}" fi diff --git a/ci/tools/tests/test_check_release_notes.py b/ci/tools/tests/test_check_release_notes.py index 4f65404eed5..e08eac6610d 100644 --- a/ci/tools/tests/test_check_release_notes.py +++ b/ci/tools/tests/test_check_release_notes.py @@ -3,10 +3,10 @@ from __future__ import annotations -import os import sys +from pathlib import Path -sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..")) +sys.path.insert(0, str(Path(__file__).parent.parent)) from check_release_notes import ( check_release_notes, is_post_release, @@ -87,43 +87,43 @@ def _make_notes(self, tmp_path, pkg, version, content="Release notes."): def test_present_and_nonempty(self, tmp_path): self._make_notes(tmp_path, "cuda_core", "0.7.0") - problems = check_release_notes("cuda-core-v0.7.0", "cuda-core", str(tmp_path)) + problems = check_release_notes("cuda-core-v0.7.0", "cuda-core", tmp_path) assert problems == [] def test_missing(self, tmp_path): - problems = check_release_notes("cuda-core-v0.7.0", "cuda-core", str(tmp_path)) + problems = check_release_notes("cuda-core-v0.7.0", "cuda-core", tmp_path) assert len(problems) == 1 assert problems[0][1] == "missing" def test_empty(self, tmp_path): self._make_notes(tmp_path, "cuda_core", "0.7.0", content="") - problems = check_release_notes("cuda-core-v0.7.0", "cuda-core", str(tmp_path)) + problems = check_release_notes("cuda-core-v0.7.0", "cuda-core", tmp_path) assert len(problems) == 1 assert problems[0][1] == "empty" def test_post_release_skipped(self, tmp_path): - problems = check_release_notes("v12.6.2.post1", "cuda-bindings", str(tmp_path)) + problems = check_release_notes("v12.6.2.post1", "cuda-bindings", tmp_path) assert problems == [] def test_invalid_tag(self, tmp_path): - problems = check_release_notes("not-a-tag", "cuda-core", str(tmp_path)) + problems = check_release_notes("not-a-tag", "cuda-core", tmp_path) assert len(problems) == 1 assert "cannot parse" in problems[0][1] def test_component_prefix_mismatch(self, tmp_path): # Pass a cuda-core tag with component=cuda-pathfinder; must be rejected. - problems = check_release_notes("cuda-core-v0.7.0", "cuda-pathfinder", str(tmp_path)) + problems = check_release_notes("cuda-core-v0.7.0", "cuda-pathfinder", tmp_path) assert len(problems) == 1 assert "cannot parse" in problems[0][1] def test_unknown_component(self, tmp_path): - problems = check_release_notes("v13.1.0", "bogus", str(tmp_path)) + problems = check_release_notes("v13.1.0", "bogus", tmp_path) assert len(problems) == 1 assert "unknown component" in problems[0][1] def test_plain_v_tag(self, tmp_path): self._make_notes(tmp_path, "cuda_python", "13.1.0") - problems = check_release_notes("v13.1.0", "cuda-python", str(tmp_path)) + problems = check_release_notes("v13.1.0", "cuda-python", tmp_path) assert problems == [] @@ -133,17 +133,17 @@ def test_from_versions_yml(self, tmp_path): d.mkdir(parents=True) (d / "versions.yml").write_text('backport_branch: "12.9.x"\n') - assert load_backport_branch(str(tmp_path)) == "12.9.x" + assert load_backport_branch(tmp_path) == "12.9.x" def test_from_github_ref_name_for_legacy_backport_branch(self, tmp_path, monkeypatch): monkeypatch.setenv("GITHUB_REF_NAME", "12.9.x") - assert load_backport_branch(str(tmp_path)) == "12.9.x" + assert load_backport_branch(tmp_path) == "12.9.x" def test_ignores_non_backport_github_ref_name(self, tmp_path, monkeypatch): monkeypatch.setenv("GITHUB_REF_NAME", "main") - assert load_backport_branch(str(tmp_path)) is None + assert load_backport_branch(tmp_path) is None class TestMain: diff --git a/ci/tools/tests/test_lookup_run_id.py b/ci/tools/tests/test_lookup_run_id.py new file mode 100644 index 00000000000..a61b2019a5c --- /dev/null +++ b/ci/tools/tests/test_lookup_run_id.py @@ -0,0 +1,203 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 + +from __future__ import annotations + +import json +import os +import subprocess +from pathlib import Path + +import pytest + +LOOKUP_RUN_ID = Path(__file__).parent.parent / "lookup-run-id" + +FAKE_GH = r"""#!/usr/bin/env python3 +import json +import os +import re +import sys + +args = sys.argv[1:] +if args[:2] == ["run", "list"]: + print(os.environ["FAKE_RUNS"]) + raise SystemExit(0) + +if args[:1] == ["api"]: + if "--paginate" not in args or "--jq" not in args: + print("artifact lookup must be paginated and filtered", file=sys.stderr) + raise SystemExit(2) + match = re.search(r"/runs/(\d+)/artifacts", " ".join(args)) + if match is None: + print("could not determine run ID", file=sys.stderr) + raise SystemExit(2) + artifacts_by_run = json.loads(os.environ["FAKE_ARTIFACTS"]) + artifacts = artifacts_by_run.get(match.group(1)) + if artifacts is None: + print("simulated artifact API failure", file=sys.stderr) + raise SystemExit(3) + for artifact in artifacts: + if not artifact.get("expired", False): + print(artifact["name"]) + raise SystemExit(0) + +print(f"unexpected gh arguments: {args!r}", file=sys.stderr) +raise SystemExit(2) +""" + + +def _run(run_id, created_at, *, branch="12.9.x", workflow="CI", conclusion="success"): + return { + "databaseId": run_id, + "workflowName": workflow, + "status": "completed", + "conclusion": conclusion, + "headSha": f"sha-{run_id}", + "headBranch": branch, + "createdAt": created_at, + "url": f"https://example.invalid/runs/{run_id}", + } + + +@pytest.fixture +def fake_gh(tmp_path): + fake_bin = tmp_path / "bin" + fake_bin.mkdir() + gh = fake_bin / "gh" + gh.write_text(FAKE_GH, encoding="utf-8") + gh.chmod(0o755) + return fake_bin + + +def _lookup(fake_gh, runs, artifacts, *args, workflow="CI"): + env = os.environ.copy() + env.update( + { + "FAKE_ARTIFACTS": json.dumps(artifacts), + "FAKE_RUNS": json.dumps(runs), + "GH_TOKEN": "test-token", + "PATH": f"{fake_gh}{os.pathsep}{env['PATH']}", + } + ) + return subprocess.run( # noqa: S603 - invokes the repository script under test + [str(LOOKUP_RUN_ID), *args, "NVIDIA/cuda-python", workflow], + check=False, + capture_output=True, + env=env, + text=True, + ) + + +@pytest.mark.agent_authored(model="gpt-5.6") +class TestBranchLookup: + def test_selects_newest_run_with_filename_workflow_selector(self, fake_gh): + runs = [ + _run(100, "2026-08-10T12:00:00Z"), + _run(400, "2026-08-13T12:00:00Z", conclusion="failure"), + _run(300, "2026-08-12T12:00:00Z", branch="other"), + _run(200, "2026-08-11T12:00:00Z"), + ] + + result = _lookup( + fake_gh, + runs, + {}, + "--branch", + "12.9.x", + "--head-sha", + workflow="ci.yml", + ) + + assert result.returncode == 0, result.stderr + assert result.stdout.splitlines() == ["200", "sha-200"] + + def test_falls_back_until_all_required_artifacts_are_unexpired(self, fake_gh): + bindings_pattern = "cuda-bindings-python315-cuda*-linux-64*[0-9a-f]" + runs = [ + _run(300, "2026-08-13T12:00:00Z"), + _run(200, "2026-08-12T12:00:00Z"), + _run(100, "2026-08-11T12:00:00Z"), + ] + artifacts = { + "300": [ + { + "name": "cuda-bindings-python315-cuda12.9.1-linux-64-abc123", + "expired": True, + }, + { + "name": "cuda-bindings-python315-cuda12.9.1-linux-64-abc123-tests", + "expired": False, + }, + {"name": "cuda-python-wheel", "expired": False}, + ], + "200": [ + { + "name": "cuda-bindings-python315-cuda12.9.1-linux-64-def456", + "expired": False, + } + ], + "100": [ + { + "name": "cuda-bindings-python315-cuda12.9.1-linux-64-fedcba", + "expired": False, + }, + {"name": "cuda-python-wheel", "expired": False}, + ], + } + + result = _lookup( + fake_gh, + runs, + artifacts, + "--branch", + "12.9.x", + "--artifact", + bindings_pattern, + "--artifact", + "cuda-python-wheel", + ) + + assert result.returncode == 0, result.stderr + assert result.stdout.strip() == "100" + assert "Skipping run 300" in result.stderr + assert "Skipping run 200" in result.stderr + + def test_reports_when_no_successful_run_has_required_artifacts(self, fake_gh): + runs = [_run(100, "2026-08-11T12:00:00Z")] + artifacts = { + "100": [ + { + "name": "cuda-bindings-python315-cuda12.9.1-linux-64-fedcba", + "expired": True, + } + ] + } + + result = _lookup( + fake_gh, + runs, + artifacts, + "--branch", + "12.9.x", + "--artifact", + "cuda-bindings-python315-cuda*-linux-64*[0-9a-f]", + ) + + assert result.returncode == 1 + assert "has all required artifacts" in result.stderr + + def test_propagates_artifact_api_failures(self, fake_gh): + runs = [_run(100, "2026-08-11T12:00:00Z")] + + result = _lookup( + fake_gh, + runs, + {}, + "--branch", + "12.9.x", + "--artifact", + "cuda-bindings-*", + ) + + assert result.returncode == 1 + assert "Failed to list artifacts for run 100" in result.stderr diff --git a/cuda_bindings/LICENSE b/cuda_bindings/LICENSE index d6f74778be8..f3fe76ecadf 100644 --- a/cuda_bindings/LICENSE +++ b/cuda_bindings/LICENSE @@ -176,3 +176,28 @@ Copyright (c) 2024-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/cuda_bindings/build_hooks.py b/cuda_bindings/build_hooks.py index 99ad5c66268..63a371d125d 100644 --- a/cuda_bindings/build_hooks.py +++ b/cuda_bindings/build_hooks.py @@ -137,6 +137,7 @@ def _build_cuda_bindings(debug=False): that metadata queries do not require a CUDA toolkit installation. """ from Cython.Build import cythonize + from Cython.Compiler import Options as _CythonOptions global _extensions @@ -230,6 +231,7 @@ def get_static_libraries(f): ) # Cythonize + _CythonOptions.warning_errors = True cython_directives = {"language_level": 3, "embedsignature": True, "binding": True, "freethreading_compatible": True} if compile_for_coverage: cython_directives["linetrace"] = True diff --git a/cuda_bindings/cuda/bindings/_internal/cudla.pxd b/cuda_bindings/cuda/bindings/_internal/cudla.pxd index 2594bb88da9..0cea9cf7f01 100644 --- a/cuda_bindings/cuda/bindings/_internal/cudla.pxd +++ b/cuda_bindings/cuda/bindings/_internal/cudla.pxd @@ -2,9 +2,21 @@ # SPDX-License-Identifier: Apache-2.0 # This code was automatically generated across versions from 1.5.0 to 13.4.0. Do not modify it directly. - # !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=496ca23b9a84c00538bab7ea91ea3789a1caece491349843387a706509454f43 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=39c36382a0106c38b48e265dfbcf434182c3d1452c0f0153e4b6caebe46cd8ec + + +# <<<< PREAMBLE CONTENT >>>> + +from libc.stdint cimport ( + uint32_t, + uint64_t, + uint8_t, +) + + +# <<<< END OF PREAMBLE CONTENT >>>> + from ..cycudla cimport * diff --git a/cuda_bindings/cuda/bindings/_internal/cudla_linux.pyx b/cuda_bindings/cuda/bindings/_internal/cudla_linux.pyx index 284c90b15e1..f7b4a759897 100644 --- a/cuda_bindings/cuda/bindings/_internal/cudla_linux.pyx +++ b/cuda_bindings/cuda/bindings/_internal/cudla_linux.pyx @@ -3,7 +3,7 @@ # This code was automatically generated across versions from 1.5.0 to 13.4.0. Do not modify it directly. # !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=b11294791915840a6cb53811f7ce9d81a295c011e6d3c7585aa0c4d45be6bf43 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=1255a970577407cbee9302ec94e091c26bfb2b73276a84cfc20055c419c89801 # <<<< PREAMBLE CONTENT >>>> @@ -44,7 +44,12 @@ cdef extern from "<dlfcn.h>": void* _cyb_dlsym "dlsym"(void*, const char*) nogil const void * _cyb_RTLD_DEFAULT "RTLD_DEFAULT" -from libc.stdint cimport intptr_t as _cyb_intptr_t +from libc.stdint cimport ( + intptr_t, + uint32_t, + uint64_t, + uint8_t, +) import threading as _cyb_threading @@ -193,43 +198,43 @@ cpdef dict _inspect_function_pointers(): _check_or_init_cudla() cdef dict data = {} global __cudlaGetVersion - data["__cudlaGetVersion"] = <_cyb_intptr_t>__cudlaGetVersion + data["__cudlaGetVersion"] = <intptr_t>__cudlaGetVersion global __cudlaDeviceGetCount - data["__cudlaDeviceGetCount"] = <_cyb_intptr_t>__cudlaDeviceGetCount + data["__cudlaDeviceGetCount"] = <intptr_t>__cudlaDeviceGetCount global __cudlaCreateDevice - data["__cudlaCreateDevice"] = <_cyb_intptr_t>__cudlaCreateDevice + data["__cudlaCreateDevice"] = <intptr_t>__cudlaCreateDevice global __cudlaMemRegister - data["__cudlaMemRegister"] = <_cyb_intptr_t>__cudlaMemRegister + data["__cudlaMemRegister"] = <intptr_t>__cudlaMemRegister global __cudlaModuleLoadFromMemory - data["__cudlaModuleLoadFromMemory"] = <_cyb_intptr_t>__cudlaModuleLoadFromMemory + data["__cudlaModuleLoadFromMemory"] = <intptr_t>__cudlaModuleLoadFromMemory global __cudlaModuleGetAttributes - data["__cudlaModuleGetAttributes"] = <_cyb_intptr_t>__cudlaModuleGetAttributes + data["__cudlaModuleGetAttributes"] = <intptr_t>__cudlaModuleGetAttributes global __cudlaModuleUnload - data["__cudlaModuleUnload"] = <_cyb_intptr_t>__cudlaModuleUnload + data["__cudlaModuleUnload"] = <intptr_t>__cudlaModuleUnload global __cudlaSubmitTask - data["__cudlaSubmitTask"] = <_cyb_intptr_t>__cudlaSubmitTask + data["__cudlaSubmitTask"] = <intptr_t>__cudlaSubmitTask global __cudlaDeviceGetAttribute - data["__cudlaDeviceGetAttribute"] = <_cyb_intptr_t>__cudlaDeviceGetAttribute + data["__cudlaDeviceGetAttribute"] = <intptr_t>__cudlaDeviceGetAttribute global __cudlaMemUnregister - data["__cudlaMemUnregister"] = <_cyb_intptr_t>__cudlaMemUnregister + data["__cudlaMemUnregister"] = <intptr_t>__cudlaMemUnregister global __cudlaGetLastError - data["__cudlaGetLastError"] = <_cyb_intptr_t>__cudlaGetLastError + data["__cudlaGetLastError"] = <intptr_t>__cudlaGetLastError global __cudlaDestroyDevice - data["__cudlaDestroyDevice"] = <_cyb_intptr_t>__cudlaDestroyDevice + data["__cudlaDestroyDevice"] = <intptr_t>__cudlaDestroyDevice global __cudlaSetTaskTimeoutInMs - data["__cudlaSetTaskTimeoutInMs"] = <_cyb_intptr_t>__cudlaSetTaskTimeoutInMs + data["__cudlaSetTaskTimeoutInMs"] = <intptr_t>__cudlaSetTaskTimeoutInMs _cyb_func_ptrs = data return data diff --git a/cuda_bindings/cuda/bindings/_internal/cudla_windows.pyx b/cuda_bindings/cuda/bindings/_internal/cudla_windows.pyx index 09c20781d71..0f9c17b6164 100644 --- a/cuda_bindings/cuda/bindings/_internal/cudla_windows.pyx +++ b/cuda_bindings/cuda/bindings/_internal/cudla_windows.pyx @@ -3,7 +3,7 @@ # This code was automatically generated across versions from 1.5.0 to 13.4.0. Do not modify it directly. # !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=e076e29e87500d2bdc0a65891978259cc1be746831c7b7177427daf7a970708e +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=a4196ca097125be37ac917ca487c74884fb6fec2c011c21e2a7af60f4d1b35bf # <<<< PREAMBLE CONTENT >>>> @@ -44,7 +44,13 @@ cdef extern from "<windows.h>": ctypedef void* HMODULE void* _cyb_GetProcAddress "GetProcAddress"(HMODULE, const char*) nogil -from libc.stdint cimport intptr_t as _cyb_intptr_t +from libc.stdint cimport ( + intptr_t, + uint32_t, + uint64_t, + uint8_t, + uintptr_t, +) import threading as _cyb_threading @@ -146,43 +152,43 @@ cpdef dict _inspect_function_pointers(): _check_or_init_cudla() cdef dict data = {} global __cudlaGetVersion - data["__cudlaGetVersion"] = <_cyb_intptr_t>__cudlaGetVersion + data["__cudlaGetVersion"] = <intptr_t>__cudlaGetVersion global __cudlaDeviceGetCount - data["__cudlaDeviceGetCount"] = <_cyb_intptr_t>__cudlaDeviceGetCount + data["__cudlaDeviceGetCount"] = <intptr_t>__cudlaDeviceGetCount global __cudlaCreateDevice - data["__cudlaCreateDevice"] = <_cyb_intptr_t>__cudlaCreateDevice + data["__cudlaCreateDevice"] = <intptr_t>__cudlaCreateDevice global __cudlaMemRegister - data["__cudlaMemRegister"] = <_cyb_intptr_t>__cudlaMemRegister + data["__cudlaMemRegister"] = <intptr_t>__cudlaMemRegister global __cudlaModuleLoadFromMemory - data["__cudlaModuleLoadFromMemory"] = <_cyb_intptr_t>__cudlaModuleLoadFromMemory + data["__cudlaModuleLoadFromMemory"] = <intptr_t>__cudlaModuleLoadFromMemory global __cudlaModuleGetAttributes - data["__cudlaModuleGetAttributes"] = <_cyb_intptr_t>__cudlaModuleGetAttributes + data["__cudlaModuleGetAttributes"] = <intptr_t>__cudlaModuleGetAttributes global __cudlaModuleUnload - data["__cudlaModuleUnload"] = <_cyb_intptr_t>__cudlaModuleUnload + data["__cudlaModuleUnload"] = <intptr_t>__cudlaModuleUnload global __cudlaSubmitTask - data["__cudlaSubmitTask"] = <_cyb_intptr_t>__cudlaSubmitTask + data["__cudlaSubmitTask"] = <intptr_t>__cudlaSubmitTask global __cudlaDeviceGetAttribute - data["__cudlaDeviceGetAttribute"] = <_cyb_intptr_t>__cudlaDeviceGetAttribute + data["__cudlaDeviceGetAttribute"] = <intptr_t>__cudlaDeviceGetAttribute global __cudlaMemUnregister - data["__cudlaMemUnregister"] = <_cyb_intptr_t>__cudlaMemUnregister + data["__cudlaMemUnregister"] = <intptr_t>__cudlaMemUnregister global __cudlaGetLastError - data["__cudlaGetLastError"] = <_cyb_intptr_t>__cudlaGetLastError + data["__cudlaGetLastError"] = <intptr_t>__cudlaGetLastError global __cudlaDestroyDevice - data["__cudlaDestroyDevice"] = <_cyb_intptr_t>__cudlaDestroyDevice + data["__cudlaDestroyDevice"] = <intptr_t>__cudlaDestroyDevice global __cudlaSetTaskTimeoutInMs - data["__cudlaSetTaskTimeoutInMs"] = <_cyb_intptr_t>__cudlaSetTaskTimeoutInMs + data["__cudlaSetTaskTimeoutInMs"] = <intptr_t>__cudlaSetTaskTimeoutInMs _cyb_func_ptrs = data return data diff --git a/cuda_bindings/cuda/bindings/_internal/cufile.pxd b/cuda_bindings/cuda/bindings/_internal/cufile.pxd index b8c508e21de..207a9fc1bb9 100644 --- a/cuda_bindings/cuda/bindings/_internal/cufile.pxd +++ b/cuda_bindings/cuda/bindings/_internal/cufile.pxd @@ -3,9 +3,17 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.9.1 to 13.4.0. Do not modify it directly. - # !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=aa4406f8a34fc4f1cf43294df5b80bcd84c0beb3b43dbcb66ecdbca3e17d439e +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=e3b62cfc529f936bb9d3bb29f36bda105c0b7b233457d6a03f8afde19a3a31eb + + +# <<<< PREAMBLE CONTENT >>>> + +from libcpp cimport bool as _cyb_bool + + +# <<<< END OF PREAMBLE CONTENT >>>> + from ..cycufile cimport * @@ -24,7 +32,7 @@ cdef CUfileError_t _cuFileDriverClose() except?<CUfileError_t>CUFILE_LOADING_ERR cdef CUfileError_t _cuFileDriverClose_v2() except?<CUfileError_t>CUFILE_LOADING_ERROR nogil cdef long _cuFileUseCount() except* nogil cdef CUfileError_t _cuFileDriverGetProperties(CUfileDrvProps_t* props) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil -cdef CUfileError_t _cuFileDriverSetPollMode(cpp_bool poll, size_t poll_threshold_size) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil +cdef CUfileError_t _cuFileDriverSetPollMode(_cyb_bool poll, size_t poll_threshold_size) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil cdef CUfileError_t _cuFileDriverSetMaxDirectIOSize(size_t max_direct_io_size) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil cdef CUfileError_t _cuFileDriverSetMaxCacheSize(size_t max_cache_size) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil cdef CUfileError_t _cuFileDriverSetMaxPinnedMemSize(size_t max_pinned_size) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil @@ -39,10 +47,10 @@ cdef CUfileError_t _cuFileStreamRegister(CUstream stream, unsigned flags) except cdef CUfileError_t _cuFileStreamDeregister(CUstream stream) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil cdef CUfileError_t _cuFileGetVersion(int* version) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil cdef CUfileError_t _cuFileGetParameterSizeT(CUFileSizeTConfigParameter_t param, size_t* value) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil -cdef CUfileError_t _cuFileGetParameterBool(CUFileBoolConfigParameter_t param, cpp_bool* value) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil +cdef CUfileError_t _cuFileGetParameterBool(CUFileBoolConfigParameter_t param, _cyb_bool* value) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil cdef CUfileError_t _cuFileGetParameterString(CUFileStringConfigParameter_t param, char* desc_str, int len) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil cdef CUfileError_t _cuFileSetParameterSizeT(CUFileSizeTConfigParameter_t param, size_t value) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil -cdef CUfileError_t _cuFileSetParameterBool(CUFileBoolConfigParameter_t param, cpp_bool value) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil +cdef CUfileError_t _cuFileSetParameterBool(CUFileBoolConfigParameter_t param, _cyb_bool value) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil cdef CUfileError_t _cuFileSetParameterString(CUFileStringConfigParameter_t param, const char* desc_str) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil cdef CUfileError_t _cuFileGetParameterMinMaxValue(CUFileSizeTConfigParameter_t param, size_t* min_value, size_t* max_value) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil cdef CUfileError_t _cuFileSetStatsLevel(int level) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil diff --git a/cuda_bindings/cuda/bindings/_internal/cufile_linux.pyx b/cuda_bindings/cuda/bindings/_internal/cufile_linux.pyx index baa2bd94858..835391cfba7 100644 --- a/cuda_bindings/cuda/bindings/_internal/cufile_linux.pyx +++ b/cuda_bindings/cuda/bindings/_internal/cufile_linux.pyx @@ -4,7 +4,7 @@ # # This code was automatically generated across versions from 12.9.1 to 13.4.0. Do not modify it directly. # !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=84741b6deffabec746bbb6a7efa6a638e72579f8eae7731380ae3c1718f1854b +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=64e2ed5888cc6da3670011d33eddb92e86df90e083f8590e1d272b007ae57b02 # <<<< PREAMBLE CONTENT >>>> @@ -46,7 +46,8 @@ cdef extern from "<dlfcn.h>": const void * _cyb_RTLD_DEFAULT "RTLD_DEFAULT" cimport cython as _cyb_cython -from libc.stdint cimport intptr_t as _cyb_intptr_t +from libc.stdint cimport intptr_t +from libcpp cimport bool as _cyb_bool import threading as _cyb_threading @@ -452,139 +453,139 @@ cpdef dict _inspect_function_pointers(): _check_or_init_cufile() cdef dict data = {} global __cuFileHandleRegister - data["__cuFileHandleRegister"] = <_cyb_intptr_t>__cuFileHandleRegister + data["__cuFileHandleRegister"] = <intptr_t>__cuFileHandleRegister global __cuFileHandleDeregister - data["__cuFileHandleDeregister"] = <_cyb_intptr_t>__cuFileHandleDeregister + data["__cuFileHandleDeregister"] = <intptr_t>__cuFileHandleDeregister global __cuFileBufRegister - data["__cuFileBufRegister"] = <_cyb_intptr_t>__cuFileBufRegister + data["__cuFileBufRegister"] = <intptr_t>__cuFileBufRegister global __cuFileBufDeregister - data["__cuFileBufDeregister"] = <_cyb_intptr_t>__cuFileBufDeregister + data["__cuFileBufDeregister"] = <intptr_t>__cuFileBufDeregister global __cuFileRead - data["__cuFileRead"] = <_cyb_intptr_t>__cuFileRead + data["__cuFileRead"] = <intptr_t>__cuFileRead global __cuFileWrite - data["__cuFileWrite"] = <_cyb_intptr_t>__cuFileWrite + data["__cuFileWrite"] = <intptr_t>__cuFileWrite global __cuFileDriverOpen - data["__cuFileDriverOpen"] = <_cyb_intptr_t>__cuFileDriverOpen + data["__cuFileDriverOpen"] = <intptr_t>__cuFileDriverOpen global __cuFileDriverClose - data["__cuFileDriverClose"] = <_cyb_intptr_t>__cuFileDriverClose + data["__cuFileDriverClose"] = <intptr_t>__cuFileDriverClose global __cuFileDriverClose_v2 - data["__cuFileDriverClose_v2"] = <_cyb_intptr_t>__cuFileDriverClose_v2 + data["__cuFileDriverClose_v2"] = <intptr_t>__cuFileDriverClose_v2 global __cuFileUseCount - data["__cuFileUseCount"] = <_cyb_intptr_t>__cuFileUseCount + data["__cuFileUseCount"] = <intptr_t>__cuFileUseCount global __cuFileDriverGetProperties - data["__cuFileDriverGetProperties"] = <_cyb_intptr_t>__cuFileDriverGetProperties + data["__cuFileDriverGetProperties"] = <intptr_t>__cuFileDriverGetProperties global __cuFileDriverSetPollMode - data["__cuFileDriverSetPollMode"] = <_cyb_intptr_t>__cuFileDriverSetPollMode + data["__cuFileDriverSetPollMode"] = <intptr_t>__cuFileDriverSetPollMode global __cuFileDriverSetMaxDirectIOSize - data["__cuFileDriverSetMaxDirectIOSize"] = <_cyb_intptr_t>__cuFileDriverSetMaxDirectIOSize + data["__cuFileDriverSetMaxDirectIOSize"] = <intptr_t>__cuFileDriverSetMaxDirectIOSize global __cuFileDriverSetMaxCacheSize - data["__cuFileDriverSetMaxCacheSize"] = <_cyb_intptr_t>__cuFileDriverSetMaxCacheSize + data["__cuFileDriverSetMaxCacheSize"] = <intptr_t>__cuFileDriverSetMaxCacheSize global __cuFileDriverSetMaxPinnedMemSize - data["__cuFileDriverSetMaxPinnedMemSize"] = <_cyb_intptr_t>__cuFileDriverSetMaxPinnedMemSize + data["__cuFileDriverSetMaxPinnedMemSize"] = <intptr_t>__cuFileDriverSetMaxPinnedMemSize global __cuFileBatchIOSetUp - data["__cuFileBatchIOSetUp"] = <_cyb_intptr_t>__cuFileBatchIOSetUp + data["__cuFileBatchIOSetUp"] = <intptr_t>__cuFileBatchIOSetUp global __cuFileBatchIOSubmit - data["__cuFileBatchIOSubmit"] = <_cyb_intptr_t>__cuFileBatchIOSubmit + data["__cuFileBatchIOSubmit"] = <intptr_t>__cuFileBatchIOSubmit global __cuFileBatchIOGetStatus - data["__cuFileBatchIOGetStatus"] = <_cyb_intptr_t>__cuFileBatchIOGetStatus + data["__cuFileBatchIOGetStatus"] = <intptr_t>__cuFileBatchIOGetStatus global __cuFileBatchIOCancel - data["__cuFileBatchIOCancel"] = <_cyb_intptr_t>__cuFileBatchIOCancel + data["__cuFileBatchIOCancel"] = <intptr_t>__cuFileBatchIOCancel global __cuFileBatchIODestroy - data["__cuFileBatchIODestroy"] = <_cyb_intptr_t>__cuFileBatchIODestroy + data["__cuFileBatchIODestroy"] = <intptr_t>__cuFileBatchIODestroy global __cuFileReadAsync - data["__cuFileReadAsync"] = <_cyb_intptr_t>__cuFileReadAsync + data["__cuFileReadAsync"] = <intptr_t>__cuFileReadAsync global __cuFileWriteAsync - data["__cuFileWriteAsync"] = <_cyb_intptr_t>__cuFileWriteAsync + data["__cuFileWriteAsync"] = <intptr_t>__cuFileWriteAsync global __cuFileStreamRegister - data["__cuFileStreamRegister"] = <_cyb_intptr_t>__cuFileStreamRegister + data["__cuFileStreamRegister"] = <intptr_t>__cuFileStreamRegister global __cuFileStreamDeregister - data["__cuFileStreamDeregister"] = <_cyb_intptr_t>__cuFileStreamDeregister + data["__cuFileStreamDeregister"] = <intptr_t>__cuFileStreamDeregister global __cuFileGetVersion - data["__cuFileGetVersion"] = <_cyb_intptr_t>__cuFileGetVersion + data["__cuFileGetVersion"] = <intptr_t>__cuFileGetVersion global __cuFileGetParameterSizeT - data["__cuFileGetParameterSizeT"] = <_cyb_intptr_t>__cuFileGetParameterSizeT + data["__cuFileGetParameterSizeT"] = <intptr_t>__cuFileGetParameterSizeT global __cuFileGetParameterBool - data["__cuFileGetParameterBool"] = <_cyb_intptr_t>__cuFileGetParameterBool + data["__cuFileGetParameterBool"] = <intptr_t>__cuFileGetParameterBool global __cuFileGetParameterString - data["__cuFileGetParameterString"] = <_cyb_intptr_t>__cuFileGetParameterString + data["__cuFileGetParameterString"] = <intptr_t>__cuFileGetParameterString global __cuFileSetParameterSizeT - data["__cuFileSetParameterSizeT"] = <_cyb_intptr_t>__cuFileSetParameterSizeT + data["__cuFileSetParameterSizeT"] = <intptr_t>__cuFileSetParameterSizeT global __cuFileSetParameterBool - data["__cuFileSetParameterBool"] = <_cyb_intptr_t>__cuFileSetParameterBool + data["__cuFileSetParameterBool"] = <intptr_t>__cuFileSetParameterBool global __cuFileSetParameterString - data["__cuFileSetParameterString"] = <_cyb_intptr_t>__cuFileSetParameterString + data["__cuFileSetParameterString"] = <intptr_t>__cuFileSetParameterString global __cuFileGetParameterMinMaxValue - data["__cuFileGetParameterMinMaxValue"] = <_cyb_intptr_t>__cuFileGetParameterMinMaxValue + data["__cuFileGetParameterMinMaxValue"] = <intptr_t>__cuFileGetParameterMinMaxValue global __cuFileSetStatsLevel - data["__cuFileSetStatsLevel"] = <_cyb_intptr_t>__cuFileSetStatsLevel + data["__cuFileSetStatsLevel"] = <intptr_t>__cuFileSetStatsLevel global __cuFileGetStatsLevel - data["__cuFileGetStatsLevel"] = <_cyb_intptr_t>__cuFileGetStatsLevel + data["__cuFileGetStatsLevel"] = <intptr_t>__cuFileGetStatsLevel global __cuFileStatsStart - data["__cuFileStatsStart"] = <_cyb_intptr_t>__cuFileStatsStart + data["__cuFileStatsStart"] = <intptr_t>__cuFileStatsStart global __cuFileStatsStop - data["__cuFileStatsStop"] = <_cyb_intptr_t>__cuFileStatsStop + data["__cuFileStatsStop"] = <intptr_t>__cuFileStatsStop global __cuFileStatsReset - data["__cuFileStatsReset"] = <_cyb_intptr_t>__cuFileStatsReset + data["__cuFileStatsReset"] = <intptr_t>__cuFileStatsReset global __cuFileGetStatsL1 - data["__cuFileGetStatsL1"] = <_cyb_intptr_t>__cuFileGetStatsL1 + data["__cuFileGetStatsL1"] = <intptr_t>__cuFileGetStatsL1 global __cuFileGetStatsL2 - data["__cuFileGetStatsL2"] = <_cyb_intptr_t>__cuFileGetStatsL2 + data["__cuFileGetStatsL2"] = <intptr_t>__cuFileGetStatsL2 global __cuFileGetStatsL3 - data["__cuFileGetStatsL3"] = <_cyb_intptr_t>__cuFileGetStatsL3 + data["__cuFileGetStatsL3"] = <intptr_t>__cuFileGetStatsL3 global __cuFileGetBARSizeInKB - data["__cuFileGetBARSizeInKB"] = <_cyb_intptr_t>__cuFileGetBARSizeInKB + data["__cuFileGetBARSizeInKB"] = <intptr_t>__cuFileGetBARSizeInKB global __cuFileSetParameterPosixPoolSlabArray - data["__cuFileSetParameterPosixPoolSlabArray"] = <_cyb_intptr_t>__cuFileSetParameterPosixPoolSlabArray + data["__cuFileSetParameterPosixPoolSlabArray"] = <intptr_t>__cuFileSetParameterPosixPoolSlabArray global __cuFileGetParameterPosixPoolSlabArray - data["__cuFileGetParameterPosixPoolSlabArray"] = <_cyb_intptr_t>__cuFileGetParameterPosixPoolSlabArray + data["__cuFileGetParameterPosixPoolSlabArray"] = <intptr_t>__cuFileGetParameterPosixPoolSlabArray global __cuFileReadv - data["__cuFileReadv"] = <_cyb_intptr_t>__cuFileReadv + data["__cuFileReadv"] = <intptr_t>__cuFileReadv global __cuFileWritev - data["__cuFileWritev"] = <_cyb_intptr_t>__cuFileWritev + data["__cuFileWritev"] = <intptr_t>__cuFileWritev _cyb_func_ptrs = data return data @@ -717,13 +718,13 @@ cdef CUfileError_t _cuFileDriverGetProperties(CUfileDrvProps_t* props) except?<C props) -cdef CUfileError_t _cuFileDriverSetPollMode(cpp_bool poll, size_t poll_threshold_size) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: +cdef CUfileError_t _cuFileDriverSetPollMode(_cyb_bool poll, size_t poll_threshold_size) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: global __cuFileDriverSetPollMode _check_or_init_cufile() if __cuFileDriverSetPollMode == NULL: with gil: raise FunctionNotFoundError("function cuFileDriverSetPollMode is not found") - return (<CUfileError_t (*)(cpp_bool, size_t) noexcept nogil>__cuFileDriverSetPollMode)( + return (<CUfileError_t (*)(_cyb_bool, size_t) noexcept nogil>__cuFileDriverSetPollMode)( poll, poll_threshold_size) @@ -868,13 +869,13 @@ cdef CUfileError_t _cuFileGetParameterSizeT(CUFileSizeTConfigParameter_t param, param, value) -cdef CUfileError_t _cuFileGetParameterBool(CUFileBoolConfigParameter_t param, cpp_bool* value) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: +cdef CUfileError_t _cuFileGetParameterBool(CUFileBoolConfigParameter_t param, _cyb_bool* value) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: global __cuFileGetParameterBool _check_or_init_cufile() if __cuFileGetParameterBool == NULL: with gil: raise FunctionNotFoundError("function cuFileGetParameterBool is not found") - return (<CUfileError_t (*)(CUFileBoolConfigParameter_t, cpp_bool*) noexcept nogil>__cuFileGetParameterBool)( + return (<CUfileError_t (*)(CUFileBoolConfigParameter_t, _cyb_bool*) noexcept nogil>__cuFileGetParameterBool)( param, value) @@ -898,13 +899,13 @@ cdef CUfileError_t _cuFileSetParameterSizeT(CUFileSizeTConfigParameter_t param, param, value) -cdef CUfileError_t _cuFileSetParameterBool(CUFileBoolConfigParameter_t param, cpp_bool value) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: +cdef CUfileError_t _cuFileSetParameterBool(CUFileBoolConfigParameter_t param, _cyb_bool value) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: global __cuFileSetParameterBool _check_or_init_cufile() if __cuFileSetParameterBool == NULL: with gil: raise FunctionNotFoundError("function cuFileSetParameterBool is not found") - return (<CUfileError_t (*)(CUFileBoolConfigParameter_t, cpp_bool) noexcept nogil>__cuFileSetParameterBool)( + return (<CUfileError_t (*)(CUFileBoolConfigParameter_t, _cyb_bool) noexcept nogil>__cuFileSetParameterBool)( param, value) diff --git a/cuda_bindings/cuda/bindings/_internal/driver_linux.pyx b/cuda_bindings/cuda/bindings/_internal/driver_linux.pyx index 9473f1d6afb..f0922d2f4bd 100644 --- a/cuda_bindings/cuda/bindings/_internal/driver_linux.pyx +++ b/cuda_bindings/cuda/bindings/_internal/driver_linux.pyx @@ -4,7 +4,7 @@ # # This code was automatically generated across versions from 12.9.0 to 13.4.0. Do not modify it directly. # !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=1e5b152412ef388b8a785b8362155fef84faecf8a3575f95461cedb918b08fb0 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=0fc726f8d963197a11bba5027050e90528a31b29ece3de3bec606b2c4d66aa7a # <<<< PREAMBLE CONTENT >>>> @@ -44,7 +44,7 @@ cdef extern from * nogil: cdef extern from "<dlfcn.h>": void* _cyb_dlsym "dlsym"(void*, const char*) nogil -from libc.stdint cimport intptr_t as _cyb_intptr_t +from libc.stdint cimport intptr_t from os import getenv as _cyb_getenv import threading as _cyb_threading @@ -2202,1576 +2202,1576 @@ cpdef dict _inspect_function_pointers(): _check_or_init_driver() cdef dict data = {} global __cuGetErrorString - data["__cuGetErrorString"] = <_cyb_intptr_t>__cuGetErrorString + data["__cuGetErrorString"] = <intptr_t>__cuGetErrorString global __cuGetErrorName - data["__cuGetErrorName"] = <_cyb_intptr_t>__cuGetErrorName + data["__cuGetErrorName"] = <intptr_t>__cuGetErrorName global __cuInit - data["__cuInit"] = <_cyb_intptr_t>__cuInit + data["__cuInit"] = <intptr_t>__cuInit global __cuDriverGetVersion - data["__cuDriverGetVersion"] = <_cyb_intptr_t>__cuDriverGetVersion + data["__cuDriverGetVersion"] = <intptr_t>__cuDriverGetVersion global __cuDeviceGet - data["__cuDeviceGet"] = <_cyb_intptr_t>__cuDeviceGet + data["__cuDeviceGet"] = <intptr_t>__cuDeviceGet global __cuDeviceGetCount - data["__cuDeviceGetCount"] = <_cyb_intptr_t>__cuDeviceGetCount + data["__cuDeviceGetCount"] = <intptr_t>__cuDeviceGetCount global __cuDeviceGetName - data["__cuDeviceGetName"] = <_cyb_intptr_t>__cuDeviceGetName + data["__cuDeviceGetName"] = <intptr_t>__cuDeviceGetName global __cuDeviceGetUuid_v2 - data["__cuDeviceGetUuid_v2"] = <_cyb_intptr_t>__cuDeviceGetUuid_v2 + data["__cuDeviceGetUuid_v2"] = <intptr_t>__cuDeviceGetUuid_v2 global __cuDeviceGetLuid - data["__cuDeviceGetLuid"] = <_cyb_intptr_t>__cuDeviceGetLuid + data["__cuDeviceGetLuid"] = <intptr_t>__cuDeviceGetLuid global __cuDeviceTotalMem_v2 - data["__cuDeviceTotalMem_v2"] = <_cyb_intptr_t>__cuDeviceTotalMem_v2 + data["__cuDeviceTotalMem_v2"] = <intptr_t>__cuDeviceTotalMem_v2 global __cuDeviceGetTexture1DLinearMaxWidth - data["__cuDeviceGetTexture1DLinearMaxWidth"] = <_cyb_intptr_t>__cuDeviceGetTexture1DLinearMaxWidth + data["__cuDeviceGetTexture1DLinearMaxWidth"] = <intptr_t>__cuDeviceGetTexture1DLinearMaxWidth global __cuDeviceGetAttribute - data["__cuDeviceGetAttribute"] = <_cyb_intptr_t>__cuDeviceGetAttribute + data["__cuDeviceGetAttribute"] = <intptr_t>__cuDeviceGetAttribute global __cuDeviceGetNvSciSyncAttributes - data["__cuDeviceGetNvSciSyncAttributes"] = <_cyb_intptr_t>__cuDeviceGetNvSciSyncAttributes + data["__cuDeviceGetNvSciSyncAttributes"] = <intptr_t>__cuDeviceGetNvSciSyncAttributes global __cuDeviceSetMemPool - data["__cuDeviceSetMemPool"] = <_cyb_intptr_t>__cuDeviceSetMemPool + data["__cuDeviceSetMemPool"] = <intptr_t>__cuDeviceSetMemPool global __cuDeviceGetMemPool - data["__cuDeviceGetMemPool"] = <_cyb_intptr_t>__cuDeviceGetMemPool + data["__cuDeviceGetMemPool"] = <intptr_t>__cuDeviceGetMemPool global __cuDeviceGetDefaultMemPool - data["__cuDeviceGetDefaultMemPool"] = <_cyb_intptr_t>__cuDeviceGetDefaultMemPool + data["__cuDeviceGetDefaultMemPool"] = <intptr_t>__cuDeviceGetDefaultMemPool global __cuDeviceGetExecAffinitySupport - data["__cuDeviceGetExecAffinitySupport"] = <_cyb_intptr_t>__cuDeviceGetExecAffinitySupport + data["__cuDeviceGetExecAffinitySupport"] = <intptr_t>__cuDeviceGetExecAffinitySupport global __cuFlushGPUDirectRDMAWrites - data["__cuFlushGPUDirectRDMAWrites"] = <_cyb_intptr_t>__cuFlushGPUDirectRDMAWrites + data["__cuFlushGPUDirectRDMAWrites"] = <intptr_t>__cuFlushGPUDirectRDMAWrites global __cuDeviceGetProperties - data["__cuDeviceGetProperties"] = <_cyb_intptr_t>__cuDeviceGetProperties + data["__cuDeviceGetProperties"] = <intptr_t>__cuDeviceGetProperties global __cuDeviceComputeCapability - data["__cuDeviceComputeCapability"] = <_cyb_intptr_t>__cuDeviceComputeCapability + data["__cuDeviceComputeCapability"] = <intptr_t>__cuDeviceComputeCapability global __cuDevicePrimaryCtxRetain - data["__cuDevicePrimaryCtxRetain"] = <_cyb_intptr_t>__cuDevicePrimaryCtxRetain + data["__cuDevicePrimaryCtxRetain"] = <intptr_t>__cuDevicePrimaryCtxRetain global __cuDevicePrimaryCtxRelease_v2 - data["__cuDevicePrimaryCtxRelease_v2"] = <_cyb_intptr_t>__cuDevicePrimaryCtxRelease_v2 + data["__cuDevicePrimaryCtxRelease_v2"] = <intptr_t>__cuDevicePrimaryCtxRelease_v2 global __cuDevicePrimaryCtxSetFlags_v2 - data["__cuDevicePrimaryCtxSetFlags_v2"] = <_cyb_intptr_t>__cuDevicePrimaryCtxSetFlags_v2 + data["__cuDevicePrimaryCtxSetFlags_v2"] = <intptr_t>__cuDevicePrimaryCtxSetFlags_v2 global __cuDevicePrimaryCtxGetState - data["__cuDevicePrimaryCtxGetState"] = <_cyb_intptr_t>__cuDevicePrimaryCtxGetState + data["__cuDevicePrimaryCtxGetState"] = <intptr_t>__cuDevicePrimaryCtxGetState global __cuDevicePrimaryCtxReset_v2 - data["__cuDevicePrimaryCtxReset_v2"] = <_cyb_intptr_t>__cuDevicePrimaryCtxReset_v2 + data["__cuDevicePrimaryCtxReset_v2"] = <intptr_t>__cuDevicePrimaryCtxReset_v2 global __cuCtxCreate_v2 - data["__cuCtxCreate_v2"] = <_cyb_intptr_t>__cuCtxCreate_v2 + data["__cuCtxCreate_v2"] = <intptr_t>__cuCtxCreate_v2 global __cuCtxCreate_v3 - data["__cuCtxCreate_v3"] = <_cyb_intptr_t>__cuCtxCreate_v3 + data["__cuCtxCreate_v3"] = <intptr_t>__cuCtxCreate_v3 global __cuCtxCreate_v4 - data["__cuCtxCreate_v4"] = <_cyb_intptr_t>__cuCtxCreate_v4 + data["__cuCtxCreate_v4"] = <intptr_t>__cuCtxCreate_v4 global __cuCtxDestroy_v2 - data["__cuCtxDestroy_v2"] = <_cyb_intptr_t>__cuCtxDestroy_v2 + data["__cuCtxDestroy_v2"] = <intptr_t>__cuCtxDestroy_v2 global __cuCtxPushCurrent_v2 - data["__cuCtxPushCurrent_v2"] = <_cyb_intptr_t>__cuCtxPushCurrent_v2 + data["__cuCtxPushCurrent_v2"] = <intptr_t>__cuCtxPushCurrent_v2 global __cuCtxPopCurrent_v2 - data["__cuCtxPopCurrent_v2"] = <_cyb_intptr_t>__cuCtxPopCurrent_v2 + data["__cuCtxPopCurrent_v2"] = <intptr_t>__cuCtxPopCurrent_v2 global __cuCtxSetCurrent - data["__cuCtxSetCurrent"] = <_cyb_intptr_t>__cuCtxSetCurrent + data["__cuCtxSetCurrent"] = <intptr_t>__cuCtxSetCurrent global __cuCtxGetCurrent - data["__cuCtxGetCurrent"] = <_cyb_intptr_t>__cuCtxGetCurrent + data["__cuCtxGetCurrent"] = <intptr_t>__cuCtxGetCurrent global __cuCtxGetDevice - data["__cuCtxGetDevice"] = <_cyb_intptr_t>__cuCtxGetDevice + data["__cuCtxGetDevice"] = <intptr_t>__cuCtxGetDevice global __cuCtxGetFlags - data["__cuCtxGetFlags"] = <_cyb_intptr_t>__cuCtxGetFlags + data["__cuCtxGetFlags"] = <intptr_t>__cuCtxGetFlags global __cuCtxSetFlags - data["__cuCtxSetFlags"] = <_cyb_intptr_t>__cuCtxSetFlags + data["__cuCtxSetFlags"] = <intptr_t>__cuCtxSetFlags global __cuCtxGetId - data["__cuCtxGetId"] = <_cyb_intptr_t>__cuCtxGetId + data["__cuCtxGetId"] = <intptr_t>__cuCtxGetId global __cuCtxSynchronize - data["__cuCtxSynchronize"] = <_cyb_intptr_t>__cuCtxSynchronize + data["__cuCtxSynchronize"] = <intptr_t>__cuCtxSynchronize global __cuCtxSetLimit - data["__cuCtxSetLimit"] = <_cyb_intptr_t>__cuCtxSetLimit + data["__cuCtxSetLimit"] = <intptr_t>__cuCtxSetLimit global __cuCtxGetLimit - data["__cuCtxGetLimit"] = <_cyb_intptr_t>__cuCtxGetLimit + data["__cuCtxGetLimit"] = <intptr_t>__cuCtxGetLimit global __cuCtxGetCacheConfig - data["__cuCtxGetCacheConfig"] = <_cyb_intptr_t>__cuCtxGetCacheConfig + data["__cuCtxGetCacheConfig"] = <intptr_t>__cuCtxGetCacheConfig global __cuCtxSetCacheConfig - data["__cuCtxSetCacheConfig"] = <_cyb_intptr_t>__cuCtxSetCacheConfig + data["__cuCtxSetCacheConfig"] = <intptr_t>__cuCtxSetCacheConfig global __cuCtxGetApiVersion - data["__cuCtxGetApiVersion"] = <_cyb_intptr_t>__cuCtxGetApiVersion + data["__cuCtxGetApiVersion"] = <intptr_t>__cuCtxGetApiVersion global __cuCtxGetStreamPriorityRange - data["__cuCtxGetStreamPriorityRange"] = <_cyb_intptr_t>__cuCtxGetStreamPriorityRange + data["__cuCtxGetStreamPriorityRange"] = <intptr_t>__cuCtxGetStreamPriorityRange global __cuCtxResetPersistingL2Cache - data["__cuCtxResetPersistingL2Cache"] = <_cyb_intptr_t>__cuCtxResetPersistingL2Cache + data["__cuCtxResetPersistingL2Cache"] = <intptr_t>__cuCtxResetPersistingL2Cache global __cuCtxGetExecAffinity - data["__cuCtxGetExecAffinity"] = <_cyb_intptr_t>__cuCtxGetExecAffinity + data["__cuCtxGetExecAffinity"] = <intptr_t>__cuCtxGetExecAffinity global __cuCtxRecordEvent - data["__cuCtxRecordEvent"] = <_cyb_intptr_t>__cuCtxRecordEvent + data["__cuCtxRecordEvent"] = <intptr_t>__cuCtxRecordEvent global __cuCtxWaitEvent - data["__cuCtxWaitEvent"] = <_cyb_intptr_t>__cuCtxWaitEvent + data["__cuCtxWaitEvent"] = <intptr_t>__cuCtxWaitEvent global __cuCtxAttach - data["__cuCtxAttach"] = <_cyb_intptr_t>__cuCtxAttach + data["__cuCtxAttach"] = <intptr_t>__cuCtxAttach global __cuCtxDetach - data["__cuCtxDetach"] = <_cyb_intptr_t>__cuCtxDetach + data["__cuCtxDetach"] = <intptr_t>__cuCtxDetach global __cuCtxGetSharedMemConfig - data["__cuCtxGetSharedMemConfig"] = <_cyb_intptr_t>__cuCtxGetSharedMemConfig + data["__cuCtxGetSharedMemConfig"] = <intptr_t>__cuCtxGetSharedMemConfig global __cuCtxSetSharedMemConfig - data["__cuCtxSetSharedMemConfig"] = <_cyb_intptr_t>__cuCtxSetSharedMemConfig + data["__cuCtxSetSharedMemConfig"] = <intptr_t>__cuCtxSetSharedMemConfig global __cuModuleLoad - data["__cuModuleLoad"] = <_cyb_intptr_t>__cuModuleLoad + data["__cuModuleLoad"] = <intptr_t>__cuModuleLoad global __cuModuleLoadData - data["__cuModuleLoadData"] = <_cyb_intptr_t>__cuModuleLoadData + data["__cuModuleLoadData"] = <intptr_t>__cuModuleLoadData global __cuModuleLoadDataEx - data["__cuModuleLoadDataEx"] = <_cyb_intptr_t>__cuModuleLoadDataEx + data["__cuModuleLoadDataEx"] = <intptr_t>__cuModuleLoadDataEx global __cuModuleLoadFatBinary - data["__cuModuleLoadFatBinary"] = <_cyb_intptr_t>__cuModuleLoadFatBinary + data["__cuModuleLoadFatBinary"] = <intptr_t>__cuModuleLoadFatBinary global __cuModuleUnload - data["__cuModuleUnload"] = <_cyb_intptr_t>__cuModuleUnload + data["__cuModuleUnload"] = <intptr_t>__cuModuleUnload global __cuModuleGetLoadingMode - data["__cuModuleGetLoadingMode"] = <_cyb_intptr_t>__cuModuleGetLoadingMode + data["__cuModuleGetLoadingMode"] = <intptr_t>__cuModuleGetLoadingMode global __cuModuleGetFunction - data["__cuModuleGetFunction"] = <_cyb_intptr_t>__cuModuleGetFunction + data["__cuModuleGetFunction"] = <intptr_t>__cuModuleGetFunction global __cuModuleGetFunctionCount - data["__cuModuleGetFunctionCount"] = <_cyb_intptr_t>__cuModuleGetFunctionCount + data["__cuModuleGetFunctionCount"] = <intptr_t>__cuModuleGetFunctionCount global __cuModuleEnumerateFunctions - data["__cuModuleEnumerateFunctions"] = <_cyb_intptr_t>__cuModuleEnumerateFunctions + data["__cuModuleEnumerateFunctions"] = <intptr_t>__cuModuleEnumerateFunctions global __cuModuleGetGlobal_v2 - data["__cuModuleGetGlobal_v2"] = <_cyb_intptr_t>__cuModuleGetGlobal_v2 + data["__cuModuleGetGlobal_v2"] = <intptr_t>__cuModuleGetGlobal_v2 global __cuLinkCreate_v2 - data["__cuLinkCreate_v2"] = <_cyb_intptr_t>__cuLinkCreate_v2 + data["__cuLinkCreate_v2"] = <intptr_t>__cuLinkCreate_v2 global __cuLinkAddData_v2 - data["__cuLinkAddData_v2"] = <_cyb_intptr_t>__cuLinkAddData_v2 + data["__cuLinkAddData_v2"] = <intptr_t>__cuLinkAddData_v2 global __cuLinkAddFile_v2 - data["__cuLinkAddFile_v2"] = <_cyb_intptr_t>__cuLinkAddFile_v2 + data["__cuLinkAddFile_v2"] = <intptr_t>__cuLinkAddFile_v2 global __cuLinkComplete - data["__cuLinkComplete"] = <_cyb_intptr_t>__cuLinkComplete + data["__cuLinkComplete"] = <intptr_t>__cuLinkComplete global __cuLinkDestroy - data["__cuLinkDestroy"] = <_cyb_intptr_t>__cuLinkDestroy + data["__cuLinkDestroy"] = <intptr_t>__cuLinkDestroy global __cuModuleGetTexRef - data["__cuModuleGetTexRef"] = <_cyb_intptr_t>__cuModuleGetTexRef + data["__cuModuleGetTexRef"] = <intptr_t>__cuModuleGetTexRef global __cuModuleGetSurfRef - data["__cuModuleGetSurfRef"] = <_cyb_intptr_t>__cuModuleGetSurfRef + data["__cuModuleGetSurfRef"] = <intptr_t>__cuModuleGetSurfRef global __cuLibraryLoadData - data["__cuLibraryLoadData"] = <_cyb_intptr_t>__cuLibraryLoadData + data["__cuLibraryLoadData"] = <intptr_t>__cuLibraryLoadData global __cuLibraryLoadFromFile - data["__cuLibraryLoadFromFile"] = <_cyb_intptr_t>__cuLibraryLoadFromFile + data["__cuLibraryLoadFromFile"] = <intptr_t>__cuLibraryLoadFromFile global __cuLibraryUnload - data["__cuLibraryUnload"] = <_cyb_intptr_t>__cuLibraryUnload + data["__cuLibraryUnload"] = <intptr_t>__cuLibraryUnload global __cuLibraryGetKernel - data["__cuLibraryGetKernel"] = <_cyb_intptr_t>__cuLibraryGetKernel + data["__cuLibraryGetKernel"] = <intptr_t>__cuLibraryGetKernel global __cuLibraryGetKernelCount - data["__cuLibraryGetKernelCount"] = <_cyb_intptr_t>__cuLibraryGetKernelCount + data["__cuLibraryGetKernelCount"] = <intptr_t>__cuLibraryGetKernelCount global __cuLibraryEnumerateKernels - data["__cuLibraryEnumerateKernels"] = <_cyb_intptr_t>__cuLibraryEnumerateKernels + data["__cuLibraryEnumerateKernels"] = <intptr_t>__cuLibraryEnumerateKernels global __cuLibraryGetModule - data["__cuLibraryGetModule"] = <_cyb_intptr_t>__cuLibraryGetModule + data["__cuLibraryGetModule"] = <intptr_t>__cuLibraryGetModule global __cuKernelGetFunction - data["__cuKernelGetFunction"] = <_cyb_intptr_t>__cuKernelGetFunction + data["__cuKernelGetFunction"] = <intptr_t>__cuKernelGetFunction global __cuKernelGetLibrary - data["__cuKernelGetLibrary"] = <_cyb_intptr_t>__cuKernelGetLibrary + data["__cuKernelGetLibrary"] = <intptr_t>__cuKernelGetLibrary global __cuLibraryGetGlobal - data["__cuLibraryGetGlobal"] = <_cyb_intptr_t>__cuLibraryGetGlobal + data["__cuLibraryGetGlobal"] = <intptr_t>__cuLibraryGetGlobal global __cuLibraryGetManaged - data["__cuLibraryGetManaged"] = <_cyb_intptr_t>__cuLibraryGetManaged + data["__cuLibraryGetManaged"] = <intptr_t>__cuLibraryGetManaged global __cuLibraryGetUnifiedFunction - data["__cuLibraryGetUnifiedFunction"] = <_cyb_intptr_t>__cuLibraryGetUnifiedFunction + data["__cuLibraryGetUnifiedFunction"] = <intptr_t>__cuLibraryGetUnifiedFunction global __cuKernelGetAttribute - data["__cuKernelGetAttribute"] = <_cyb_intptr_t>__cuKernelGetAttribute + data["__cuKernelGetAttribute"] = <intptr_t>__cuKernelGetAttribute global __cuKernelSetAttribute - data["__cuKernelSetAttribute"] = <_cyb_intptr_t>__cuKernelSetAttribute + data["__cuKernelSetAttribute"] = <intptr_t>__cuKernelSetAttribute global __cuKernelSetCacheConfig - data["__cuKernelSetCacheConfig"] = <_cyb_intptr_t>__cuKernelSetCacheConfig + data["__cuKernelSetCacheConfig"] = <intptr_t>__cuKernelSetCacheConfig global __cuKernelGetName - data["__cuKernelGetName"] = <_cyb_intptr_t>__cuKernelGetName + data["__cuKernelGetName"] = <intptr_t>__cuKernelGetName global __cuKernelGetParamInfo - data["__cuKernelGetParamInfo"] = <_cyb_intptr_t>__cuKernelGetParamInfo + data["__cuKernelGetParamInfo"] = <intptr_t>__cuKernelGetParamInfo global __cuMemGetInfo_v2 - data["__cuMemGetInfo_v2"] = <_cyb_intptr_t>__cuMemGetInfo_v2 + data["__cuMemGetInfo_v2"] = <intptr_t>__cuMemGetInfo_v2 global __cuMemAlloc_v2 - data["__cuMemAlloc_v2"] = <_cyb_intptr_t>__cuMemAlloc_v2 + data["__cuMemAlloc_v2"] = <intptr_t>__cuMemAlloc_v2 global __cuMemAllocPitch_v2 - data["__cuMemAllocPitch_v2"] = <_cyb_intptr_t>__cuMemAllocPitch_v2 + data["__cuMemAllocPitch_v2"] = <intptr_t>__cuMemAllocPitch_v2 global __cuMemFree_v2 - data["__cuMemFree_v2"] = <_cyb_intptr_t>__cuMemFree_v2 + data["__cuMemFree_v2"] = <intptr_t>__cuMemFree_v2 global __cuMemGetAddressRange_v2 - data["__cuMemGetAddressRange_v2"] = <_cyb_intptr_t>__cuMemGetAddressRange_v2 + data["__cuMemGetAddressRange_v2"] = <intptr_t>__cuMemGetAddressRange_v2 global __cuMemAllocHost_v2 - data["__cuMemAllocHost_v2"] = <_cyb_intptr_t>__cuMemAllocHost_v2 + data["__cuMemAllocHost_v2"] = <intptr_t>__cuMemAllocHost_v2 global __cuMemFreeHost - data["__cuMemFreeHost"] = <_cyb_intptr_t>__cuMemFreeHost + data["__cuMemFreeHost"] = <intptr_t>__cuMemFreeHost global __cuMemHostAlloc - data["__cuMemHostAlloc"] = <_cyb_intptr_t>__cuMemHostAlloc + data["__cuMemHostAlloc"] = <intptr_t>__cuMemHostAlloc global __cuMemHostGetDevicePointer_v2 - data["__cuMemHostGetDevicePointer_v2"] = <_cyb_intptr_t>__cuMemHostGetDevicePointer_v2 + data["__cuMemHostGetDevicePointer_v2"] = <intptr_t>__cuMemHostGetDevicePointer_v2 global __cuMemHostGetFlags - data["__cuMemHostGetFlags"] = <_cyb_intptr_t>__cuMemHostGetFlags + data["__cuMemHostGetFlags"] = <intptr_t>__cuMemHostGetFlags global __cuMemAllocManaged - data["__cuMemAllocManaged"] = <_cyb_intptr_t>__cuMemAllocManaged + data["__cuMemAllocManaged"] = <intptr_t>__cuMemAllocManaged global __cuDeviceRegisterAsyncNotification - data["__cuDeviceRegisterAsyncNotification"] = <_cyb_intptr_t>__cuDeviceRegisterAsyncNotification + data["__cuDeviceRegisterAsyncNotification"] = <intptr_t>__cuDeviceRegisterAsyncNotification global __cuDeviceUnregisterAsyncNotification - data["__cuDeviceUnregisterAsyncNotification"] = <_cyb_intptr_t>__cuDeviceUnregisterAsyncNotification + data["__cuDeviceUnregisterAsyncNotification"] = <intptr_t>__cuDeviceUnregisterAsyncNotification global __cuDeviceGetByPCIBusId - data["__cuDeviceGetByPCIBusId"] = <_cyb_intptr_t>__cuDeviceGetByPCIBusId + data["__cuDeviceGetByPCIBusId"] = <intptr_t>__cuDeviceGetByPCIBusId global __cuDeviceGetPCIBusId - data["__cuDeviceGetPCIBusId"] = <_cyb_intptr_t>__cuDeviceGetPCIBusId + data["__cuDeviceGetPCIBusId"] = <intptr_t>__cuDeviceGetPCIBusId global __cuIpcGetEventHandle - data["__cuIpcGetEventHandle"] = <_cyb_intptr_t>__cuIpcGetEventHandle + data["__cuIpcGetEventHandle"] = <intptr_t>__cuIpcGetEventHandle global __cuIpcOpenEventHandle - data["__cuIpcOpenEventHandle"] = <_cyb_intptr_t>__cuIpcOpenEventHandle + data["__cuIpcOpenEventHandle"] = <intptr_t>__cuIpcOpenEventHandle global __cuIpcGetMemHandle - data["__cuIpcGetMemHandle"] = <_cyb_intptr_t>__cuIpcGetMemHandle + data["__cuIpcGetMemHandle"] = <intptr_t>__cuIpcGetMemHandle global __cuIpcOpenMemHandle_v2 - data["__cuIpcOpenMemHandle_v2"] = <_cyb_intptr_t>__cuIpcOpenMemHandle_v2 + data["__cuIpcOpenMemHandle_v2"] = <intptr_t>__cuIpcOpenMemHandle_v2 global __cuIpcCloseMemHandle - data["__cuIpcCloseMemHandle"] = <_cyb_intptr_t>__cuIpcCloseMemHandle + data["__cuIpcCloseMemHandle"] = <intptr_t>__cuIpcCloseMemHandle global __cuMemHostRegister_v2 - data["__cuMemHostRegister_v2"] = <_cyb_intptr_t>__cuMemHostRegister_v2 + data["__cuMemHostRegister_v2"] = <intptr_t>__cuMemHostRegister_v2 global __cuMemHostUnregister - data["__cuMemHostUnregister"] = <_cyb_intptr_t>__cuMemHostUnregister + data["__cuMemHostUnregister"] = <intptr_t>__cuMemHostUnregister global __cuMemcpy - data["__cuMemcpy"] = <_cyb_intptr_t>__cuMemcpy + data["__cuMemcpy"] = <intptr_t>__cuMemcpy global __cuMemcpyPeer - data["__cuMemcpyPeer"] = <_cyb_intptr_t>__cuMemcpyPeer + data["__cuMemcpyPeer"] = <intptr_t>__cuMemcpyPeer global __cuMemcpyHtoD_v2 - data["__cuMemcpyHtoD_v2"] = <_cyb_intptr_t>__cuMemcpyHtoD_v2 + data["__cuMemcpyHtoD_v2"] = <intptr_t>__cuMemcpyHtoD_v2 global __cuMemcpyDtoH_v2 - data["__cuMemcpyDtoH_v2"] = <_cyb_intptr_t>__cuMemcpyDtoH_v2 + data["__cuMemcpyDtoH_v2"] = <intptr_t>__cuMemcpyDtoH_v2 global __cuMemcpyDtoD_v2 - data["__cuMemcpyDtoD_v2"] = <_cyb_intptr_t>__cuMemcpyDtoD_v2 + data["__cuMemcpyDtoD_v2"] = <intptr_t>__cuMemcpyDtoD_v2 global __cuMemcpyDtoA_v2 - data["__cuMemcpyDtoA_v2"] = <_cyb_intptr_t>__cuMemcpyDtoA_v2 + data["__cuMemcpyDtoA_v2"] = <intptr_t>__cuMemcpyDtoA_v2 global __cuMemcpyAtoD_v2 - data["__cuMemcpyAtoD_v2"] = <_cyb_intptr_t>__cuMemcpyAtoD_v2 + data["__cuMemcpyAtoD_v2"] = <intptr_t>__cuMemcpyAtoD_v2 global __cuMemcpyHtoA_v2 - data["__cuMemcpyHtoA_v2"] = <_cyb_intptr_t>__cuMemcpyHtoA_v2 + data["__cuMemcpyHtoA_v2"] = <intptr_t>__cuMemcpyHtoA_v2 global __cuMemcpyAtoH_v2 - data["__cuMemcpyAtoH_v2"] = <_cyb_intptr_t>__cuMemcpyAtoH_v2 + data["__cuMemcpyAtoH_v2"] = <intptr_t>__cuMemcpyAtoH_v2 global __cuMemcpyAtoA_v2 - data["__cuMemcpyAtoA_v2"] = <_cyb_intptr_t>__cuMemcpyAtoA_v2 + data["__cuMemcpyAtoA_v2"] = <intptr_t>__cuMemcpyAtoA_v2 global __cuMemcpy2D_v2 - data["__cuMemcpy2D_v2"] = <_cyb_intptr_t>__cuMemcpy2D_v2 + data["__cuMemcpy2D_v2"] = <intptr_t>__cuMemcpy2D_v2 global __cuMemcpy2DUnaligned_v2 - data["__cuMemcpy2DUnaligned_v2"] = <_cyb_intptr_t>__cuMemcpy2DUnaligned_v2 + data["__cuMemcpy2DUnaligned_v2"] = <intptr_t>__cuMemcpy2DUnaligned_v2 global __cuMemcpy3D_v2 - data["__cuMemcpy3D_v2"] = <_cyb_intptr_t>__cuMemcpy3D_v2 + data["__cuMemcpy3D_v2"] = <intptr_t>__cuMemcpy3D_v2 global __cuMemcpy3DPeer - data["__cuMemcpy3DPeer"] = <_cyb_intptr_t>__cuMemcpy3DPeer + data["__cuMemcpy3DPeer"] = <intptr_t>__cuMemcpy3DPeer global __cuMemcpyAsync - data["__cuMemcpyAsync"] = <_cyb_intptr_t>__cuMemcpyAsync + data["__cuMemcpyAsync"] = <intptr_t>__cuMemcpyAsync global __cuMemcpyPeerAsync - data["__cuMemcpyPeerAsync"] = <_cyb_intptr_t>__cuMemcpyPeerAsync + data["__cuMemcpyPeerAsync"] = <intptr_t>__cuMemcpyPeerAsync global __cuMemcpyHtoDAsync_v2 - data["__cuMemcpyHtoDAsync_v2"] = <_cyb_intptr_t>__cuMemcpyHtoDAsync_v2 + data["__cuMemcpyHtoDAsync_v2"] = <intptr_t>__cuMemcpyHtoDAsync_v2 global __cuMemcpyDtoHAsync_v2 - data["__cuMemcpyDtoHAsync_v2"] = <_cyb_intptr_t>__cuMemcpyDtoHAsync_v2 + data["__cuMemcpyDtoHAsync_v2"] = <intptr_t>__cuMemcpyDtoHAsync_v2 global __cuMemcpyDtoDAsync_v2 - data["__cuMemcpyDtoDAsync_v2"] = <_cyb_intptr_t>__cuMemcpyDtoDAsync_v2 + data["__cuMemcpyDtoDAsync_v2"] = <intptr_t>__cuMemcpyDtoDAsync_v2 global __cuMemcpyHtoAAsync_v2 - data["__cuMemcpyHtoAAsync_v2"] = <_cyb_intptr_t>__cuMemcpyHtoAAsync_v2 + data["__cuMemcpyHtoAAsync_v2"] = <intptr_t>__cuMemcpyHtoAAsync_v2 global __cuMemcpyAtoHAsync_v2 - data["__cuMemcpyAtoHAsync_v2"] = <_cyb_intptr_t>__cuMemcpyAtoHAsync_v2 + data["__cuMemcpyAtoHAsync_v2"] = <intptr_t>__cuMemcpyAtoHAsync_v2 global __cuMemcpy2DAsync_v2 - data["__cuMemcpy2DAsync_v2"] = <_cyb_intptr_t>__cuMemcpy2DAsync_v2 + data["__cuMemcpy2DAsync_v2"] = <intptr_t>__cuMemcpy2DAsync_v2 global __cuMemcpy3DAsync_v2 - data["__cuMemcpy3DAsync_v2"] = <_cyb_intptr_t>__cuMemcpy3DAsync_v2 + data["__cuMemcpy3DAsync_v2"] = <intptr_t>__cuMemcpy3DAsync_v2 global __cuMemcpy3DPeerAsync - data["__cuMemcpy3DPeerAsync"] = <_cyb_intptr_t>__cuMemcpy3DPeerAsync + data["__cuMemcpy3DPeerAsync"] = <intptr_t>__cuMemcpy3DPeerAsync global __cuMemsetD8_v2 - data["__cuMemsetD8_v2"] = <_cyb_intptr_t>__cuMemsetD8_v2 + data["__cuMemsetD8_v2"] = <intptr_t>__cuMemsetD8_v2 global __cuMemsetD16_v2 - data["__cuMemsetD16_v2"] = <_cyb_intptr_t>__cuMemsetD16_v2 + data["__cuMemsetD16_v2"] = <intptr_t>__cuMemsetD16_v2 global __cuMemsetD32_v2 - data["__cuMemsetD32_v2"] = <_cyb_intptr_t>__cuMemsetD32_v2 + data["__cuMemsetD32_v2"] = <intptr_t>__cuMemsetD32_v2 global __cuMemsetD2D8_v2 - data["__cuMemsetD2D8_v2"] = <_cyb_intptr_t>__cuMemsetD2D8_v2 + data["__cuMemsetD2D8_v2"] = <intptr_t>__cuMemsetD2D8_v2 global __cuMemsetD2D16_v2 - data["__cuMemsetD2D16_v2"] = <_cyb_intptr_t>__cuMemsetD2D16_v2 + data["__cuMemsetD2D16_v2"] = <intptr_t>__cuMemsetD2D16_v2 global __cuMemsetD2D32_v2 - data["__cuMemsetD2D32_v2"] = <_cyb_intptr_t>__cuMemsetD2D32_v2 + data["__cuMemsetD2D32_v2"] = <intptr_t>__cuMemsetD2D32_v2 global __cuMemsetD8Async - data["__cuMemsetD8Async"] = <_cyb_intptr_t>__cuMemsetD8Async + data["__cuMemsetD8Async"] = <intptr_t>__cuMemsetD8Async global __cuMemsetD16Async - data["__cuMemsetD16Async"] = <_cyb_intptr_t>__cuMemsetD16Async + data["__cuMemsetD16Async"] = <intptr_t>__cuMemsetD16Async global __cuMemsetD32Async - data["__cuMemsetD32Async"] = <_cyb_intptr_t>__cuMemsetD32Async + data["__cuMemsetD32Async"] = <intptr_t>__cuMemsetD32Async global __cuMemsetD2D8Async - data["__cuMemsetD2D8Async"] = <_cyb_intptr_t>__cuMemsetD2D8Async + data["__cuMemsetD2D8Async"] = <intptr_t>__cuMemsetD2D8Async global __cuMemsetD2D16Async - data["__cuMemsetD2D16Async"] = <_cyb_intptr_t>__cuMemsetD2D16Async + data["__cuMemsetD2D16Async"] = <intptr_t>__cuMemsetD2D16Async global __cuMemsetD2D32Async - data["__cuMemsetD2D32Async"] = <_cyb_intptr_t>__cuMemsetD2D32Async + data["__cuMemsetD2D32Async"] = <intptr_t>__cuMemsetD2D32Async global __cuArrayCreate_v2 - data["__cuArrayCreate_v2"] = <_cyb_intptr_t>__cuArrayCreate_v2 + data["__cuArrayCreate_v2"] = <intptr_t>__cuArrayCreate_v2 global __cuArrayGetDescriptor_v2 - data["__cuArrayGetDescriptor_v2"] = <_cyb_intptr_t>__cuArrayGetDescriptor_v2 + data["__cuArrayGetDescriptor_v2"] = <intptr_t>__cuArrayGetDescriptor_v2 global __cuArrayGetSparseProperties - data["__cuArrayGetSparseProperties"] = <_cyb_intptr_t>__cuArrayGetSparseProperties + data["__cuArrayGetSparseProperties"] = <intptr_t>__cuArrayGetSparseProperties global __cuMipmappedArrayGetSparseProperties - data["__cuMipmappedArrayGetSparseProperties"] = <_cyb_intptr_t>__cuMipmappedArrayGetSparseProperties + data["__cuMipmappedArrayGetSparseProperties"] = <intptr_t>__cuMipmappedArrayGetSparseProperties global __cuArrayGetMemoryRequirements - data["__cuArrayGetMemoryRequirements"] = <_cyb_intptr_t>__cuArrayGetMemoryRequirements + data["__cuArrayGetMemoryRequirements"] = <intptr_t>__cuArrayGetMemoryRequirements global __cuMipmappedArrayGetMemoryRequirements - data["__cuMipmappedArrayGetMemoryRequirements"] = <_cyb_intptr_t>__cuMipmappedArrayGetMemoryRequirements + data["__cuMipmappedArrayGetMemoryRequirements"] = <intptr_t>__cuMipmappedArrayGetMemoryRequirements global __cuArrayGetPlane - data["__cuArrayGetPlane"] = <_cyb_intptr_t>__cuArrayGetPlane + data["__cuArrayGetPlane"] = <intptr_t>__cuArrayGetPlane global __cuArrayDestroy - data["__cuArrayDestroy"] = <_cyb_intptr_t>__cuArrayDestroy + data["__cuArrayDestroy"] = <intptr_t>__cuArrayDestroy global __cuArray3DCreate_v2 - data["__cuArray3DCreate_v2"] = <_cyb_intptr_t>__cuArray3DCreate_v2 + data["__cuArray3DCreate_v2"] = <intptr_t>__cuArray3DCreate_v2 global __cuArray3DGetDescriptor_v2 - data["__cuArray3DGetDescriptor_v2"] = <_cyb_intptr_t>__cuArray3DGetDescriptor_v2 + data["__cuArray3DGetDescriptor_v2"] = <intptr_t>__cuArray3DGetDescriptor_v2 global __cuMipmappedArrayCreate - data["__cuMipmappedArrayCreate"] = <_cyb_intptr_t>__cuMipmappedArrayCreate + data["__cuMipmappedArrayCreate"] = <intptr_t>__cuMipmappedArrayCreate global __cuMipmappedArrayGetLevel - data["__cuMipmappedArrayGetLevel"] = <_cyb_intptr_t>__cuMipmappedArrayGetLevel + data["__cuMipmappedArrayGetLevel"] = <intptr_t>__cuMipmappedArrayGetLevel global __cuMipmappedArrayDestroy - data["__cuMipmappedArrayDestroy"] = <_cyb_intptr_t>__cuMipmappedArrayDestroy + data["__cuMipmappedArrayDestroy"] = <intptr_t>__cuMipmappedArrayDestroy global __cuMemGetHandleForAddressRange - data["__cuMemGetHandleForAddressRange"] = <_cyb_intptr_t>__cuMemGetHandleForAddressRange + data["__cuMemGetHandleForAddressRange"] = <intptr_t>__cuMemGetHandleForAddressRange global __cuMemBatchDecompressAsync - data["__cuMemBatchDecompressAsync"] = <_cyb_intptr_t>__cuMemBatchDecompressAsync + data["__cuMemBatchDecompressAsync"] = <intptr_t>__cuMemBatchDecompressAsync global __cuMemAddressReserve - data["__cuMemAddressReserve"] = <_cyb_intptr_t>__cuMemAddressReserve + data["__cuMemAddressReserve"] = <intptr_t>__cuMemAddressReserve global __cuMemAddressFree - data["__cuMemAddressFree"] = <_cyb_intptr_t>__cuMemAddressFree + data["__cuMemAddressFree"] = <intptr_t>__cuMemAddressFree global __cuMemCreate - data["__cuMemCreate"] = <_cyb_intptr_t>__cuMemCreate + data["__cuMemCreate"] = <intptr_t>__cuMemCreate global __cuMemRelease - data["__cuMemRelease"] = <_cyb_intptr_t>__cuMemRelease + data["__cuMemRelease"] = <intptr_t>__cuMemRelease global __cuMemMap - data["__cuMemMap"] = <_cyb_intptr_t>__cuMemMap + data["__cuMemMap"] = <intptr_t>__cuMemMap global __cuMemMapArrayAsync - data["__cuMemMapArrayAsync"] = <_cyb_intptr_t>__cuMemMapArrayAsync + data["__cuMemMapArrayAsync"] = <intptr_t>__cuMemMapArrayAsync global __cuMemUnmap - data["__cuMemUnmap"] = <_cyb_intptr_t>__cuMemUnmap + data["__cuMemUnmap"] = <intptr_t>__cuMemUnmap global __cuMemSetAccess - data["__cuMemSetAccess"] = <_cyb_intptr_t>__cuMemSetAccess + data["__cuMemSetAccess"] = <intptr_t>__cuMemSetAccess global __cuMemGetAccess - data["__cuMemGetAccess"] = <_cyb_intptr_t>__cuMemGetAccess + data["__cuMemGetAccess"] = <intptr_t>__cuMemGetAccess global __cuMemExportToShareableHandle - data["__cuMemExportToShareableHandle"] = <_cyb_intptr_t>__cuMemExportToShareableHandle + data["__cuMemExportToShareableHandle"] = <intptr_t>__cuMemExportToShareableHandle global __cuMemImportFromShareableHandle - data["__cuMemImportFromShareableHandle"] = <_cyb_intptr_t>__cuMemImportFromShareableHandle + data["__cuMemImportFromShareableHandle"] = <intptr_t>__cuMemImportFromShareableHandle global __cuMemGetAllocationGranularity - data["__cuMemGetAllocationGranularity"] = <_cyb_intptr_t>__cuMemGetAllocationGranularity + data["__cuMemGetAllocationGranularity"] = <intptr_t>__cuMemGetAllocationGranularity global __cuMemGetAllocationPropertiesFromHandle - data["__cuMemGetAllocationPropertiesFromHandle"] = <_cyb_intptr_t>__cuMemGetAllocationPropertiesFromHandle + data["__cuMemGetAllocationPropertiesFromHandle"] = <intptr_t>__cuMemGetAllocationPropertiesFromHandle global __cuMemRetainAllocationHandle - data["__cuMemRetainAllocationHandle"] = <_cyb_intptr_t>__cuMemRetainAllocationHandle + data["__cuMemRetainAllocationHandle"] = <intptr_t>__cuMemRetainAllocationHandle global __cuMemFreeAsync - data["__cuMemFreeAsync"] = <_cyb_intptr_t>__cuMemFreeAsync + data["__cuMemFreeAsync"] = <intptr_t>__cuMemFreeAsync global __cuMemAllocAsync - data["__cuMemAllocAsync"] = <_cyb_intptr_t>__cuMemAllocAsync + data["__cuMemAllocAsync"] = <intptr_t>__cuMemAllocAsync global __cuMemPoolTrimTo - data["__cuMemPoolTrimTo"] = <_cyb_intptr_t>__cuMemPoolTrimTo + data["__cuMemPoolTrimTo"] = <intptr_t>__cuMemPoolTrimTo global __cuMemPoolSetAttribute - data["__cuMemPoolSetAttribute"] = <_cyb_intptr_t>__cuMemPoolSetAttribute + data["__cuMemPoolSetAttribute"] = <intptr_t>__cuMemPoolSetAttribute global __cuMemPoolGetAttribute - data["__cuMemPoolGetAttribute"] = <_cyb_intptr_t>__cuMemPoolGetAttribute + data["__cuMemPoolGetAttribute"] = <intptr_t>__cuMemPoolGetAttribute global __cuMemPoolSetAccess - data["__cuMemPoolSetAccess"] = <_cyb_intptr_t>__cuMemPoolSetAccess + data["__cuMemPoolSetAccess"] = <intptr_t>__cuMemPoolSetAccess global __cuMemPoolGetAccess - data["__cuMemPoolGetAccess"] = <_cyb_intptr_t>__cuMemPoolGetAccess + data["__cuMemPoolGetAccess"] = <intptr_t>__cuMemPoolGetAccess global __cuMemPoolCreate - data["__cuMemPoolCreate"] = <_cyb_intptr_t>__cuMemPoolCreate + data["__cuMemPoolCreate"] = <intptr_t>__cuMemPoolCreate global __cuMemPoolDestroy - data["__cuMemPoolDestroy"] = <_cyb_intptr_t>__cuMemPoolDestroy + data["__cuMemPoolDestroy"] = <intptr_t>__cuMemPoolDestroy global __cuMemAllocFromPoolAsync - data["__cuMemAllocFromPoolAsync"] = <_cyb_intptr_t>__cuMemAllocFromPoolAsync + data["__cuMemAllocFromPoolAsync"] = <intptr_t>__cuMemAllocFromPoolAsync global __cuMemPoolExportToShareableHandle - data["__cuMemPoolExportToShareableHandle"] = <_cyb_intptr_t>__cuMemPoolExportToShareableHandle + data["__cuMemPoolExportToShareableHandle"] = <intptr_t>__cuMemPoolExportToShareableHandle global __cuMemPoolImportFromShareableHandle - data["__cuMemPoolImportFromShareableHandle"] = <_cyb_intptr_t>__cuMemPoolImportFromShareableHandle + data["__cuMemPoolImportFromShareableHandle"] = <intptr_t>__cuMemPoolImportFromShareableHandle global __cuMemPoolExportPointer - data["__cuMemPoolExportPointer"] = <_cyb_intptr_t>__cuMemPoolExportPointer + data["__cuMemPoolExportPointer"] = <intptr_t>__cuMemPoolExportPointer global __cuMemPoolImportPointer - data["__cuMemPoolImportPointer"] = <_cyb_intptr_t>__cuMemPoolImportPointer + data["__cuMemPoolImportPointer"] = <intptr_t>__cuMemPoolImportPointer global __cuMulticastCreate - data["__cuMulticastCreate"] = <_cyb_intptr_t>__cuMulticastCreate + data["__cuMulticastCreate"] = <intptr_t>__cuMulticastCreate global __cuMulticastAddDevice - data["__cuMulticastAddDevice"] = <_cyb_intptr_t>__cuMulticastAddDevice + data["__cuMulticastAddDevice"] = <intptr_t>__cuMulticastAddDevice global __cuMulticastBindMem - data["__cuMulticastBindMem"] = <_cyb_intptr_t>__cuMulticastBindMem + data["__cuMulticastBindMem"] = <intptr_t>__cuMulticastBindMem global __cuMulticastBindAddr - data["__cuMulticastBindAddr"] = <_cyb_intptr_t>__cuMulticastBindAddr + data["__cuMulticastBindAddr"] = <intptr_t>__cuMulticastBindAddr global __cuMulticastUnbind - data["__cuMulticastUnbind"] = <_cyb_intptr_t>__cuMulticastUnbind + data["__cuMulticastUnbind"] = <intptr_t>__cuMulticastUnbind global __cuMulticastGetGranularity - data["__cuMulticastGetGranularity"] = <_cyb_intptr_t>__cuMulticastGetGranularity + data["__cuMulticastGetGranularity"] = <intptr_t>__cuMulticastGetGranularity global __cuPointerGetAttribute - data["__cuPointerGetAttribute"] = <_cyb_intptr_t>__cuPointerGetAttribute + data["__cuPointerGetAttribute"] = <intptr_t>__cuPointerGetAttribute global __cuMemPrefetchAsync_v2 - data["__cuMemPrefetchAsync_v2"] = <_cyb_intptr_t>__cuMemPrefetchAsync_v2 + data["__cuMemPrefetchAsync_v2"] = <intptr_t>__cuMemPrefetchAsync_v2 global __cuMemAdvise_v2 - data["__cuMemAdvise_v2"] = <_cyb_intptr_t>__cuMemAdvise_v2 + data["__cuMemAdvise_v2"] = <intptr_t>__cuMemAdvise_v2 global __cuMemRangeGetAttribute - data["__cuMemRangeGetAttribute"] = <_cyb_intptr_t>__cuMemRangeGetAttribute + data["__cuMemRangeGetAttribute"] = <intptr_t>__cuMemRangeGetAttribute global __cuMemRangeGetAttributes - data["__cuMemRangeGetAttributes"] = <_cyb_intptr_t>__cuMemRangeGetAttributes + data["__cuMemRangeGetAttributes"] = <intptr_t>__cuMemRangeGetAttributes global __cuPointerSetAttribute - data["__cuPointerSetAttribute"] = <_cyb_intptr_t>__cuPointerSetAttribute + data["__cuPointerSetAttribute"] = <intptr_t>__cuPointerSetAttribute global __cuPointerGetAttributes - data["__cuPointerGetAttributes"] = <_cyb_intptr_t>__cuPointerGetAttributes + data["__cuPointerGetAttributes"] = <intptr_t>__cuPointerGetAttributes global __cuStreamCreate - data["__cuStreamCreate"] = <_cyb_intptr_t>__cuStreamCreate + data["__cuStreamCreate"] = <intptr_t>__cuStreamCreate global __cuStreamCreateWithPriority - data["__cuStreamCreateWithPriority"] = <_cyb_intptr_t>__cuStreamCreateWithPriority + data["__cuStreamCreateWithPriority"] = <intptr_t>__cuStreamCreateWithPriority global __cuStreamGetPriority - data["__cuStreamGetPriority"] = <_cyb_intptr_t>__cuStreamGetPriority + data["__cuStreamGetPriority"] = <intptr_t>__cuStreamGetPriority global __cuStreamGetDevice - data["__cuStreamGetDevice"] = <_cyb_intptr_t>__cuStreamGetDevice + data["__cuStreamGetDevice"] = <intptr_t>__cuStreamGetDevice global __cuStreamGetFlags - data["__cuStreamGetFlags"] = <_cyb_intptr_t>__cuStreamGetFlags + data["__cuStreamGetFlags"] = <intptr_t>__cuStreamGetFlags global __cuStreamGetId - data["__cuStreamGetId"] = <_cyb_intptr_t>__cuStreamGetId + data["__cuStreamGetId"] = <intptr_t>__cuStreamGetId global __cuStreamGetCtx - data["__cuStreamGetCtx"] = <_cyb_intptr_t>__cuStreamGetCtx + data["__cuStreamGetCtx"] = <intptr_t>__cuStreamGetCtx global __cuStreamGetCtx_v2 - data["__cuStreamGetCtx_v2"] = <_cyb_intptr_t>__cuStreamGetCtx_v2 + data["__cuStreamGetCtx_v2"] = <intptr_t>__cuStreamGetCtx_v2 global __cuStreamWaitEvent - data["__cuStreamWaitEvent"] = <_cyb_intptr_t>__cuStreamWaitEvent + data["__cuStreamWaitEvent"] = <intptr_t>__cuStreamWaitEvent global __cuStreamAddCallback - data["__cuStreamAddCallback"] = <_cyb_intptr_t>__cuStreamAddCallback + data["__cuStreamAddCallback"] = <intptr_t>__cuStreamAddCallback global __cuStreamBeginCapture_v2 - data["__cuStreamBeginCapture_v2"] = <_cyb_intptr_t>__cuStreamBeginCapture_v2 + data["__cuStreamBeginCapture_v2"] = <intptr_t>__cuStreamBeginCapture_v2 global __cuStreamBeginCaptureToGraph - data["__cuStreamBeginCaptureToGraph"] = <_cyb_intptr_t>__cuStreamBeginCaptureToGraph + data["__cuStreamBeginCaptureToGraph"] = <intptr_t>__cuStreamBeginCaptureToGraph global __cuThreadExchangeStreamCaptureMode - data["__cuThreadExchangeStreamCaptureMode"] = <_cyb_intptr_t>__cuThreadExchangeStreamCaptureMode + data["__cuThreadExchangeStreamCaptureMode"] = <intptr_t>__cuThreadExchangeStreamCaptureMode global __cuStreamEndCapture - data["__cuStreamEndCapture"] = <_cyb_intptr_t>__cuStreamEndCapture + data["__cuStreamEndCapture"] = <intptr_t>__cuStreamEndCapture global __cuStreamIsCapturing - data["__cuStreamIsCapturing"] = <_cyb_intptr_t>__cuStreamIsCapturing + data["__cuStreamIsCapturing"] = <intptr_t>__cuStreamIsCapturing global __cuStreamGetCaptureInfo_v2 - data["__cuStreamGetCaptureInfo_v2"] = <_cyb_intptr_t>__cuStreamGetCaptureInfo_v2 + data["__cuStreamGetCaptureInfo_v2"] = <intptr_t>__cuStreamGetCaptureInfo_v2 global __cuStreamGetCaptureInfo_v3 - data["__cuStreamGetCaptureInfo_v3"] = <_cyb_intptr_t>__cuStreamGetCaptureInfo_v3 + data["__cuStreamGetCaptureInfo_v3"] = <intptr_t>__cuStreamGetCaptureInfo_v3 global __cuStreamUpdateCaptureDependencies_v2 - data["__cuStreamUpdateCaptureDependencies_v2"] = <_cyb_intptr_t>__cuStreamUpdateCaptureDependencies_v2 + data["__cuStreamUpdateCaptureDependencies_v2"] = <intptr_t>__cuStreamUpdateCaptureDependencies_v2 global __cuStreamAttachMemAsync - data["__cuStreamAttachMemAsync"] = <_cyb_intptr_t>__cuStreamAttachMemAsync + data["__cuStreamAttachMemAsync"] = <intptr_t>__cuStreamAttachMemAsync global __cuStreamQuery - data["__cuStreamQuery"] = <_cyb_intptr_t>__cuStreamQuery + data["__cuStreamQuery"] = <intptr_t>__cuStreamQuery global __cuStreamSynchronize - data["__cuStreamSynchronize"] = <_cyb_intptr_t>__cuStreamSynchronize + data["__cuStreamSynchronize"] = <intptr_t>__cuStreamSynchronize global __cuStreamDestroy_v2 - data["__cuStreamDestroy_v2"] = <_cyb_intptr_t>__cuStreamDestroy_v2 + data["__cuStreamDestroy_v2"] = <intptr_t>__cuStreamDestroy_v2 global __cuStreamCopyAttributes - data["__cuStreamCopyAttributes"] = <_cyb_intptr_t>__cuStreamCopyAttributes + data["__cuStreamCopyAttributes"] = <intptr_t>__cuStreamCopyAttributes global __cuStreamGetAttribute - data["__cuStreamGetAttribute"] = <_cyb_intptr_t>__cuStreamGetAttribute + data["__cuStreamGetAttribute"] = <intptr_t>__cuStreamGetAttribute global __cuStreamSetAttribute - data["__cuStreamSetAttribute"] = <_cyb_intptr_t>__cuStreamSetAttribute + data["__cuStreamSetAttribute"] = <intptr_t>__cuStreamSetAttribute global __cuEventCreate - data["__cuEventCreate"] = <_cyb_intptr_t>__cuEventCreate + data["__cuEventCreate"] = <intptr_t>__cuEventCreate global __cuEventRecord - data["__cuEventRecord"] = <_cyb_intptr_t>__cuEventRecord + data["__cuEventRecord"] = <intptr_t>__cuEventRecord global __cuEventRecordWithFlags - data["__cuEventRecordWithFlags"] = <_cyb_intptr_t>__cuEventRecordWithFlags + data["__cuEventRecordWithFlags"] = <intptr_t>__cuEventRecordWithFlags global __cuEventQuery - data["__cuEventQuery"] = <_cyb_intptr_t>__cuEventQuery + data["__cuEventQuery"] = <intptr_t>__cuEventQuery global __cuEventSynchronize - data["__cuEventSynchronize"] = <_cyb_intptr_t>__cuEventSynchronize + data["__cuEventSynchronize"] = <intptr_t>__cuEventSynchronize global __cuEventDestroy_v2 - data["__cuEventDestroy_v2"] = <_cyb_intptr_t>__cuEventDestroy_v2 + data["__cuEventDestroy_v2"] = <intptr_t>__cuEventDestroy_v2 global __cuEventElapsedTime_v2 - data["__cuEventElapsedTime_v2"] = <_cyb_intptr_t>__cuEventElapsedTime_v2 + data["__cuEventElapsedTime_v2"] = <intptr_t>__cuEventElapsedTime_v2 global __cuImportExternalMemory - data["__cuImportExternalMemory"] = <_cyb_intptr_t>__cuImportExternalMemory + data["__cuImportExternalMemory"] = <intptr_t>__cuImportExternalMemory global __cuExternalMemoryGetMappedBuffer - data["__cuExternalMemoryGetMappedBuffer"] = <_cyb_intptr_t>__cuExternalMemoryGetMappedBuffer + data["__cuExternalMemoryGetMappedBuffer"] = <intptr_t>__cuExternalMemoryGetMappedBuffer global __cuExternalMemoryGetMappedMipmappedArray - data["__cuExternalMemoryGetMappedMipmappedArray"] = <_cyb_intptr_t>__cuExternalMemoryGetMappedMipmappedArray + data["__cuExternalMemoryGetMappedMipmappedArray"] = <intptr_t>__cuExternalMemoryGetMappedMipmappedArray global __cuDestroyExternalMemory - data["__cuDestroyExternalMemory"] = <_cyb_intptr_t>__cuDestroyExternalMemory + data["__cuDestroyExternalMemory"] = <intptr_t>__cuDestroyExternalMemory global __cuImportExternalSemaphore - data["__cuImportExternalSemaphore"] = <_cyb_intptr_t>__cuImportExternalSemaphore + data["__cuImportExternalSemaphore"] = <intptr_t>__cuImportExternalSemaphore global __cuSignalExternalSemaphoresAsync - data["__cuSignalExternalSemaphoresAsync"] = <_cyb_intptr_t>__cuSignalExternalSemaphoresAsync + data["__cuSignalExternalSemaphoresAsync"] = <intptr_t>__cuSignalExternalSemaphoresAsync global __cuWaitExternalSemaphoresAsync - data["__cuWaitExternalSemaphoresAsync"] = <_cyb_intptr_t>__cuWaitExternalSemaphoresAsync + data["__cuWaitExternalSemaphoresAsync"] = <intptr_t>__cuWaitExternalSemaphoresAsync global __cuDestroyExternalSemaphore - data["__cuDestroyExternalSemaphore"] = <_cyb_intptr_t>__cuDestroyExternalSemaphore + data["__cuDestroyExternalSemaphore"] = <intptr_t>__cuDestroyExternalSemaphore global __cuStreamWaitValue32_v2 - data["__cuStreamWaitValue32_v2"] = <_cyb_intptr_t>__cuStreamWaitValue32_v2 + data["__cuStreamWaitValue32_v2"] = <intptr_t>__cuStreamWaitValue32_v2 global __cuStreamWaitValue64_v2 - data["__cuStreamWaitValue64_v2"] = <_cyb_intptr_t>__cuStreamWaitValue64_v2 + data["__cuStreamWaitValue64_v2"] = <intptr_t>__cuStreamWaitValue64_v2 global __cuStreamWriteValue32_v2 - data["__cuStreamWriteValue32_v2"] = <_cyb_intptr_t>__cuStreamWriteValue32_v2 + data["__cuStreamWriteValue32_v2"] = <intptr_t>__cuStreamWriteValue32_v2 global __cuStreamWriteValue64_v2 - data["__cuStreamWriteValue64_v2"] = <_cyb_intptr_t>__cuStreamWriteValue64_v2 + data["__cuStreamWriteValue64_v2"] = <intptr_t>__cuStreamWriteValue64_v2 global __cuStreamBatchMemOp_v2 - data["__cuStreamBatchMemOp_v2"] = <_cyb_intptr_t>__cuStreamBatchMemOp_v2 + data["__cuStreamBatchMemOp_v2"] = <intptr_t>__cuStreamBatchMemOp_v2 global __cuFuncGetAttribute - data["__cuFuncGetAttribute"] = <_cyb_intptr_t>__cuFuncGetAttribute + data["__cuFuncGetAttribute"] = <intptr_t>__cuFuncGetAttribute global __cuFuncSetAttribute - data["__cuFuncSetAttribute"] = <_cyb_intptr_t>__cuFuncSetAttribute + data["__cuFuncSetAttribute"] = <intptr_t>__cuFuncSetAttribute global __cuFuncSetCacheConfig - data["__cuFuncSetCacheConfig"] = <_cyb_intptr_t>__cuFuncSetCacheConfig + data["__cuFuncSetCacheConfig"] = <intptr_t>__cuFuncSetCacheConfig global __cuFuncGetModule - data["__cuFuncGetModule"] = <_cyb_intptr_t>__cuFuncGetModule + data["__cuFuncGetModule"] = <intptr_t>__cuFuncGetModule global __cuFuncGetName - data["__cuFuncGetName"] = <_cyb_intptr_t>__cuFuncGetName + data["__cuFuncGetName"] = <intptr_t>__cuFuncGetName global __cuFuncGetParamInfo - data["__cuFuncGetParamInfo"] = <_cyb_intptr_t>__cuFuncGetParamInfo + data["__cuFuncGetParamInfo"] = <intptr_t>__cuFuncGetParamInfo global __cuFuncIsLoaded - data["__cuFuncIsLoaded"] = <_cyb_intptr_t>__cuFuncIsLoaded + data["__cuFuncIsLoaded"] = <intptr_t>__cuFuncIsLoaded global __cuFuncLoad - data["__cuFuncLoad"] = <_cyb_intptr_t>__cuFuncLoad + data["__cuFuncLoad"] = <intptr_t>__cuFuncLoad global __cuLaunchKernel - data["__cuLaunchKernel"] = <_cyb_intptr_t>__cuLaunchKernel + data["__cuLaunchKernel"] = <intptr_t>__cuLaunchKernel global __cuLaunchKernelEx - data["__cuLaunchKernelEx"] = <_cyb_intptr_t>__cuLaunchKernelEx + data["__cuLaunchKernelEx"] = <intptr_t>__cuLaunchKernelEx global __cuLaunchCooperativeKernel - data["__cuLaunchCooperativeKernel"] = <_cyb_intptr_t>__cuLaunchCooperativeKernel + data["__cuLaunchCooperativeKernel"] = <intptr_t>__cuLaunchCooperativeKernel global __cuLaunchCooperativeKernelMultiDevice - data["__cuLaunchCooperativeKernelMultiDevice"] = <_cyb_intptr_t>__cuLaunchCooperativeKernelMultiDevice + data["__cuLaunchCooperativeKernelMultiDevice"] = <intptr_t>__cuLaunchCooperativeKernelMultiDevice global __cuLaunchHostFunc - data["__cuLaunchHostFunc"] = <_cyb_intptr_t>__cuLaunchHostFunc + data["__cuLaunchHostFunc"] = <intptr_t>__cuLaunchHostFunc global __cuFuncSetBlockShape - data["__cuFuncSetBlockShape"] = <_cyb_intptr_t>__cuFuncSetBlockShape + data["__cuFuncSetBlockShape"] = <intptr_t>__cuFuncSetBlockShape global __cuFuncSetSharedSize - data["__cuFuncSetSharedSize"] = <_cyb_intptr_t>__cuFuncSetSharedSize + data["__cuFuncSetSharedSize"] = <intptr_t>__cuFuncSetSharedSize global __cuParamSetSize - data["__cuParamSetSize"] = <_cyb_intptr_t>__cuParamSetSize + data["__cuParamSetSize"] = <intptr_t>__cuParamSetSize global __cuParamSeti - data["__cuParamSeti"] = <_cyb_intptr_t>__cuParamSeti + data["__cuParamSeti"] = <intptr_t>__cuParamSeti global __cuParamSetf - data["__cuParamSetf"] = <_cyb_intptr_t>__cuParamSetf + data["__cuParamSetf"] = <intptr_t>__cuParamSetf global __cuParamSetv - data["__cuParamSetv"] = <_cyb_intptr_t>__cuParamSetv + data["__cuParamSetv"] = <intptr_t>__cuParamSetv global __cuLaunch - data["__cuLaunch"] = <_cyb_intptr_t>__cuLaunch + data["__cuLaunch"] = <intptr_t>__cuLaunch global __cuLaunchGrid - data["__cuLaunchGrid"] = <_cyb_intptr_t>__cuLaunchGrid + data["__cuLaunchGrid"] = <intptr_t>__cuLaunchGrid global __cuLaunchGridAsync - data["__cuLaunchGridAsync"] = <_cyb_intptr_t>__cuLaunchGridAsync + data["__cuLaunchGridAsync"] = <intptr_t>__cuLaunchGridAsync global __cuParamSetTexRef - data["__cuParamSetTexRef"] = <_cyb_intptr_t>__cuParamSetTexRef + data["__cuParamSetTexRef"] = <intptr_t>__cuParamSetTexRef global __cuFuncSetSharedMemConfig - data["__cuFuncSetSharedMemConfig"] = <_cyb_intptr_t>__cuFuncSetSharedMemConfig + data["__cuFuncSetSharedMemConfig"] = <intptr_t>__cuFuncSetSharedMemConfig global __cuGraphCreate - data["__cuGraphCreate"] = <_cyb_intptr_t>__cuGraphCreate + data["__cuGraphCreate"] = <intptr_t>__cuGraphCreate global __cuGraphAddKernelNode_v2 - data["__cuGraphAddKernelNode_v2"] = <_cyb_intptr_t>__cuGraphAddKernelNode_v2 + data["__cuGraphAddKernelNode_v2"] = <intptr_t>__cuGraphAddKernelNode_v2 global __cuGraphKernelNodeGetParams_v2 - data["__cuGraphKernelNodeGetParams_v2"] = <_cyb_intptr_t>__cuGraphKernelNodeGetParams_v2 + data["__cuGraphKernelNodeGetParams_v2"] = <intptr_t>__cuGraphKernelNodeGetParams_v2 global __cuGraphKernelNodeSetParams_v2 - data["__cuGraphKernelNodeSetParams_v2"] = <_cyb_intptr_t>__cuGraphKernelNodeSetParams_v2 + data["__cuGraphKernelNodeSetParams_v2"] = <intptr_t>__cuGraphKernelNodeSetParams_v2 global __cuGraphAddMemcpyNode - data["__cuGraphAddMemcpyNode"] = <_cyb_intptr_t>__cuGraphAddMemcpyNode + data["__cuGraphAddMemcpyNode"] = <intptr_t>__cuGraphAddMemcpyNode global __cuGraphMemcpyNodeGetParams - data["__cuGraphMemcpyNodeGetParams"] = <_cyb_intptr_t>__cuGraphMemcpyNodeGetParams + data["__cuGraphMemcpyNodeGetParams"] = <intptr_t>__cuGraphMemcpyNodeGetParams global __cuGraphMemcpyNodeSetParams - data["__cuGraphMemcpyNodeSetParams"] = <_cyb_intptr_t>__cuGraphMemcpyNodeSetParams + data["__cuGraphMemcpyNodeSetParams"] = <intptr_t>__cuGraphMemcpyNodeSetParams global __cuGraphAddMemsetNode - data["__cuGraphAddMemsetNode"] = <_cyb_intptr_t>__cuGraphAddMemsetNode + data["__cuGraphAddMemsetNode"] = <intptr_t>__cuGraphAddMemsetNode global __cuGraphMemsetNodeGetParams - data["__cuGraphMemsetNodeGetParams"] = <_cyb_intptr_t>__cuGraphMemsetNodeGetParams + data["__cuGraphMemsetNodeGetParams"] = <intptr_t>__cuGraphMemsetNodeGetParams global __cuGraphMemsetNodeSetParams - data["__cuGraphMemsetNodeSetParams"] = <_cyb_intptr_t>__cuGraphMemsetNodeSetParams + data["__cuGraphMemsetNodeSetParams"] = <intptr_t>__cuGraphMemsetNodeSetParams global __cuGraphAddHostNode - data["__cuGraphAddHostNode"] = <_cyb_intptr_t>__cuGraphAddHostNode + data["__cuGraphAddHostNode"] = <intptr_t>__cuGraphAddHostNode global __cuGraphHostNodeGetParams - data["__cuGraphHostNodeGetParams"] = <_cyb_intptr_t>__cuGraphHostNodeGetParams + data["__cuGraphHostNodeGetParams"] = <intptr_t>__cuGraphHostNodeGetParams global __cuGraphHostNodeSetParams - data["__cuGraphHostNodeSetParams"] = <_cyb_intptr_t>__cuGraphHostNodeSetParams + data["__cuGraphHostNodeSetParams"] = <intptr_t>__cuGraphHostNodeSetParams global __cuGraphAddChildGraphNode - data["__cuGraphAddChildGraphNode"] = <_cyb_intptr_t>__cuGraphAddChildGraphNode + data["__cuGraphAddChildGraphNode"] = <intptr_t>__cuGraphAddChildGraphNode global __cuGraphChildGraphNodeGetGraph - data["__cuGraphChildGraphNodeGetGraph"] = <_cyb_intptr_t>__cuGraphChildGraphNodeGetGraph + data["__cuGraphChildGraphNodeGetGraph"] = <intptr_t>__cuGraphChildGraphNodeGetGraph global __cuGraphAddEmptyNode - data["__cuGraphAddEmptyNode"] = <_cyb_intptr_t>__cuGraphAddEmptyNode + data["__cuGraphAddEmptyNode"] = <intptr_t>__cuGraphAddEmptyNode global __cuGraphAddEventRecordNode - data["__cuGraphAddEventRecordNode"] = <_cyb_intptr_t>__cuGraphAddEventRecordNode + data["__cuGraphAddEventRecordNode"] = <intptr_t>__cuGraphAddEventRecordNode global __cuGraphEventRecordNodeGetEvent - data["__cuGraphEventRecordNodeGetEvent"] = <_cyb_intptr_t>__cuGraphEventRecordNodeGetEvent + data["__cuGraphEventRecordNodeGetEvent"] = <intptr_t>__cuGraphEventRecordNodeGetEvent global __cuGraphEventRecordNodeSetEvent - data["__cuGraphEventRecordNodeSetEvent"] = <_cyb_intptr_t>__cuGraphEventRecordNodeSetEvent + data["__cuGraphEventRecordNodeSetEvent"] = <intptr_t>__cuGraphEventRecordNodeSetEvent global __cuGraphAddEventWaitNode - data["__cuGraphAddEventWaitNode"] = <_cyb_intptr_t>__cuGraphAddEventWaitNode + data["__cuGraphAddEventWaitNode"] = <intptr_t>__cuGraphAddEventWaitNode global __cuGraphEventWaitNodeGetEvent - data["__cuGraphEventWaitNodeGetEvent"] = <_cyb_intptr_t>__cuGraphEventWaitNodeGetEvent + data["__cuGraphEventWaitNodeGetEvent"] = <intptr_t>__cuGraphEventWaitNodeGetEvent global __cuGraphEventWaitNodeSetEvent - data["__cuGraphEventWaitNodeSetEvent"] = <_cyb_intptr_t>__cuGraphEventWaitNodeSetEvent + data["__cuGraphEventWaitNodeSetEvent"] = <intptr_t>__cuGraphEventWaitNodeSetEvent global __cuGraphAddExternalSemaphoresSignalNode - data["__cuGraphAddExternalSemaphoresSignalNode"] = <_cyb_intptr_t>__cuGraphAddExternalSemaphoresSignalNode + data["__cuGraphAddExternalSemaphoresSignalNode"] = <intptr_t>__cuGraphAddExternalSemaphoresSignalNode global __cuGraphExternalSemaphoresSignalNodeGetParams - data["__cuGraphExternalSemaphoresSignalNodeGetParams"] = <_cyb_intptr_t>__cuGraphExternalSemaphoresSignalNodeGetParams + data["__cuGraphExternalSemaphoresSignalNodeGetParams"] = <intptr_t>__cuGraphExternalSemaphoresSignalNodeGetParams global __cuGraphExternalSemaphoresSignalNodeSetParams - data["__cuGraphExternalSemaphoresSignalNodeSetParams"] = <_cyb_intptr_t>__cuGraphExternalSemaphoresSignalNodeSetParams + data["__cuGraphExternalSemaphoresSignalNodeSetParams"] = <intptr_t>__cuGraphExternalSemaphoresSignalNodeSetParams global __cuGraphAddExternalSemaphoresWaitNode - data["__cuGraphAddExternalSemaphoresWaitNode"] = <_cyb_intptr_t>__cuGraphAddExternalSemaphoresWaitNode + data["__cuGraphAddExternalSemaphoresWaitNode"] = <intptr_t>__cuGraphAddExternalSemaphoresWaitNode global __cuGraphExternalSemaphoresWaitNodeGetParams - data["__cuGraphExternalSemaphoresWaitNodeGetParams"] = <_cyb_intptr_t>__cuGraphExternalSemaphoresWaitNodeGetParams + data["__cuGraphExternalSemaphoresWaitNodeGetParams"] = <intptr_t>__cuGraphExternalSemaphoresWaitNodeGetParams global __cuGraphExternalSemaphoresWaitNodeSetParams - data["__cuGraphExternalSemaphoresWaitNodeSetParams"] = <_cyb_intptr_t>__cuGraphExternalSemaphoresWaitNodeSetParams + data["__cuGraphExternalSemaphoresWaitNodeSetParams"] = <intptr_t>__cuGraphExternalSemaphoresWaitNodeSetParams global __cuGraphAddBatchMemOpNode - data["__cuGraphAddBatchMemOpNode"] = <_cyb_intptr_t>__cuGraphAddBatchMemOpNode + data["__cuGraphAddBatchMemOpNode"] = <intptr_t>__cuGraphAddBatchMemOpNode global __cuGraphBatchMemOpNodeGetParams - data["__cuGraphBatchMemOpNodeGetParams"] = <_cyb_intptr_t>__cuGraphBatchMemOpNodeGetParams + data["__cuGraphBatchMemOpNodeGetParams"] = <intptr_t>__cuGraphBatchMemOpNodeGetParams global __cuGraphBatchMemOpNodeSetParams - data["__cuGraphBatchMemOpNodeSetParams"] = <_cyb_intptr_t>__cuGraphBatchMemOpNodeSetParams + data["__cuGraphBatchMemOpNodeSetParams"] = <intptr_t>__cuGraphBatchMemOpNodeSetParams global __cuGraphExecBatchMemOpNodeSetParams - data["__cuGraphExecBatchMemOpNodeSetParams"] = <_cyb_intptr_t>__cuGraphExecBatchMemOpNodeSetParams + data["__cuGraphExecBatchMemOpNodeSetParams"] = <intptr_t>__cuGraphExecBatchMemOpNodeSetParams global __cuGraphAddMemAllocNode - data["__cuGraphAddMemAllocNode"] = <_cyb_intptr_t>__cuGraphAddMemAllocNode + data["__cuGraphAddMemAllocNode"] = <intptr_t>__cuGraphAddMemAllocNode global __cuGraphMemAllocNodeGetParams - data["__cuGraphMemAllocNodeGetParams"] = <_cyb_intptr_t>__cuGraphMemAllocNodeGetParams + data["__cuGraphMemAllocNodeGetParams"] = <intptr_t>__cuGraphMemAllocNodeGetParams global __cuGraphAddMemFreeNode - data["__cuGraphAddMemFreeNode"] = <_cyb_intptr_t>__cuGraphAddMemFreeNode + data["__cuGraphAddMemFreeNode"] = <intptr_t>__cuGraphAddMemFreeNode global __cuGraphMemFreeNodeGetParams - data["__cuGraphMemFreeNodeGetParams"] = <_cyb_intptr_t>__cuGraphMemFreeNodeGetParams + data["__cuGraphMemFreeNodeGetParams"] = <intptr_t>__cuGraphMemFreeNodeGetParams global __cuDeviceGraphMemTrim - data["__cuDeviceGraphMemTrim"] = <_cyb_intptr_t>__cuDeviceGraphMemTrim + data["__cuDeviceGraphMemTrim"] = <intptr_t>__cuDeviceGraphMemTrim global __cuDeviceGetGraphMemAttribute - data["__cuDeviceGetGraphMemAttribute"] = <_cyb_intptr_t>__cuDeviceGetGraphMemAttribute + data["__cuDeviceGetGraphMemAttribute"] = <intptr_t>__cuDeviceGetGraphMemAttribute global __cuDeviceSetGraphMemAttribute - data["__cuDeviceSetGraphMemAttribute"] = <_cyb_intptr_t>__cuDeviceSetGraphMemAttribute + data["__cuDeviceSetGraphMemAttribute"] = <intptr_t>__cuDeviceSetGraphMemAttribute global __cuGraphClone - data["__cuGraphClone"] = <_cyb_intptr_t>__cuGraphClone + data["__cuGraphClone"] = <intptr_t>__cuGraphClone global __cuGraphNodeFindInClone - data["__cuGraphNodeFindInClone"] = <_cyb_intptr_t>__cuGraphNodeFindInClone + data["__cuGraphNodeFindInClone"] = <intptr_t>__cuGraphNodeFindInClone global __cuGraphNodeGetType - data["__cuGraphNodeGetType"] = <_cyb_intptr_t>__cuGraphNodeGetType + data["__cuGraphNodeGetType"] = <intptr_t>__cuGraphNodeGetType global __cuGraphGetNodes - data["__cuGraphGetNodes"] = <_cyb_intptr_t>__cuGraphGetNodes + data["__cuGraphGetNodes"] = <intptr_t>__cuGraphGetNodes global __cuGraphGetRootNodes - data["__cuGraphGetRootNodes"] = <_cyb_intptr_t>__cuGraphGetRootNodes + data["__cuGraphGetRootNodes"] = <intptr_t>__cuGraphGetRootNodes global __cuGraphGetEdges_v2 - data["__cuGraphGetEdges_v2"] = <_cyb_intptr_t>__cuGraphGetEdges_v2 + data["__cuGraphGetEdges_v2"] = <intptr_t>__cuGraphGetEdges_v2 global __cuGraphNodeGetDependencies_v2 - data["__cuGraphNodeGetDependencies_v2"] = <_cyb_intptr_t>__cuGraphNodeGetDependencies_v2 + data["__cuGraphNodeGetDependencies_v2"] = <intptr_t>__cuGraphNodeGetDependencies_v2 global __cuGraphNodeGetDependentNodes_v2 - data["__cuGraphNodeGetDependentNodes_v2"] = <_cyb_intptr_t>__cuGraphNodeGetDependentNodes_v2 + data["__cuGraphNodeGetDependentNodes_v2"] = <intptr_t>__cuGraphNodeGetDependentNodes_v2 global __cuGraphAddDependencies_v2 - data["__cuGraphAddDependencies_v2"] = <_cyb_intptr_t>__cuGraphAddDependencies_v2 + data["__cuGraphAddDependencies_v2"] = <intptr_t>__cuGraphAddDependencies_v2 global __cuGraphRemoveDependencies_v2 - data["__cuGraphRemoveDependencies_v2"] = <_cyb_intptr_t>__cuGraphRemoveDependencies_v2 + data["__cuGraphRemoveDependencies_v2"] = <intptr_t>__cuGraphRemoveDependencies_v2 global __cuGraphDestroyNode - data["__cuGraphDestroyNode"] = <_cyb_intptr_t>__cuGraphDestroyNode + data["__cuGraphDestroyNode"] = <intptr_t>__cuGraphDestroyNode global __cuGraphInstantiateWithFlags - data["__cuGraphInstantiateWithFlags"] = <_cyb_intptr_t>__cuGraphInstantiateWithFlags + data["__cuGraphInstantiateWithFlags"] = <intptr_t>__cuGraphInstantiateWithFlags global __cuGraphInstantiateWithParams - data["__cuGraphInstantiateWithParams"] = <_cyb_intptr_t>__cuGraphInstantiateWithParams + data["__cuGraphInstantiateWithParams"] = <intptr_t>__cuGraphInstantiateWithParams global __cuGraphExecGetFlags - data["__cuGraphExecGetFlags"] = <_cyb_intptr_t>__cuGraphExecGetFlags + data["__cuGraphExecGetFlags"] = <intptr_t>__cuGraphExecGetFlags global __cuGraphExecKernelNodeSetParams_v2 - data["__cuGraphExecKernelNodeSetParams_v2"] = <_cyb_intptr_t>__cuGraphExecKernelNodeSetParams_v2 + data["__cuGraphExecKernelNodeSetParams_v2"] = <intptr_t>__cuGraphExecKernelNodeSetParams_v2 global __cuGraphExecMemcpyNodeSetParams - data["__cuGraphExecMemcpyNodeSetParams"] = <_cyb_intptr_t>__cuGraphExecMemcpyNodeSetParams + data["__cuGraphExecMemcpyNodeSetParams"] = <intptr_t>__cuGraphExecMemcpyNodeSetParams global __cuGraphExecMemsetNodeSetParams - data["__cuGraphExecMemsetNodeSetParams"] = <_cyb_intptr_t>__cuGraphExecMemsetNodeSetParams + data["__cuGraphExecMemsetNodeSetParams"] = <intptr_t>__cuGraphExecMemsetNodeSetParams global __cuGraphExecHostNodeSetParams - data["__cuGraphExecHostNodeSetParams"] = <_cyb_intptr_t>__cuGraphExecHostNodeSetParams + data["__cuGraphExecHostNodeSetParams"] = <intptr_t>__cuGraphExecHostNodeSetParams global __cuGraphExecChildGraphNodeSetParams - data["__cuGraphExecChildGraphNodeSetParams"] = <_cyb_intptr_t>__cuGraphExecChildGraphNodeSetParams + data["__cuGraphExecChildGraphNodeSetParams"] = <intptr_t>__cuGraphExecChildGraphNodeSetParams global __cuGraphExecEventRecordNodeSetEvent - data["__cuGraphExecEventRecordNodeSetEvent"] = <_cyb_intptr_t>__cuGraphExecEventRecordNodeSetEvent + data["__cuGraphExecEventRecordNodeSetEvent"] = <intptr_t>__cuGraphExecEventRecordNodeSetEvent global __cuGraphExecEventWaitNodeSetEvent - data["__cuGraphExecEventWaitNodeSetEvent"] = <_cyb_intptr_t>__cuGraphExecEventWaitNodeSetEvent + data["__cuGraphExecEventWaitNodeSetEvent"] = <intptr_t>__cuGraphExecEventWaitNodeSetEvent global __cuGraphExecExternalSemaphoresSignalNodeSetParams - data["__cuGraphExecExternalSemaphoresSignalNodeSetParams"] = <_cyb_intptr_t>__cuGraphExecExternalSemaphoresSignalNodeSetParams + data["__cuGraphExecExternalSemaphoresSignalNodeSetParams"] = <intptr_t>__cuGraphExecExternalSemaphoresSignalNodeSetParams global __cuGraphExecExternalSemaphoresWaitNodeSetParams - data["__cuGraphExecExternalSemaphoresWaitNodeSetParams"] = <_cyb_intptr_t>__cuGraphExecExternalSemaphoresWaitNodeSetParams + data["__cuGraphExecExternalSemaphoresWaitNodeSetParams"] = <intptr_t>__cuGraphExecExternalSemaphoresWaitNodeSetParams global __cuGraphNodeSetEnabled - data["__cuGraphNodeSetEnabled"] = <_cyb_intptr_t>__cuGraphNodeSetEnabled + data["__cuGraphNodeSetEnabled"] = <intptr_t>__cuGraphNodeSetEnabled global __cuGraphNodeGetEnabled - data["__cuGraphNodeGetEnabled"] = <_cyb_intptr_t>__cuGraphNodeGetEnabled + data["__cuGraphNodeGetEnabled"] = <intptr_t>__cuGraphNodeGetEnabled global __cuGraphUpload - data["__cuGraphUpload"] = <_cyb_intptr_t>__cuGraphUpload + data["__cuGraphUpload"] = <intptr_t>__cuGraphUpload global __cuGraphLaunch - data["__cuGraphLaunch"] = <_cyb_intptr_t>__cuGraphLaunch + data["__cuGraphLaunch"] = <intptr_t>__cuGraphLaunch global __cuGraphExecDestroy - data["__cuGraphExecDestroy"] = <_cyb_intptr_t>__cuGraphExecDestroy + data["__cuGraphExecDestroy"] = <intptr_t>__cuGraphExecDestroy global __cuGraphDestroy - data["__cuGraphDestroy"] = <_cyb_intptr_t>__cuGraphDestroy + data["__cuGraphDestroy"] = <intptr_t>__cuGraphDestroy global __cuGraphExecUpdate_v2 - data["__cuGraphExecUpdate_v2"] = <_cyb_intptr_t>__cuGraphExecUpdate_v2 + data["__cuGraphExecUpdate_v2"] = <intptr_t>__cuGraphExecUpdate_v2 global __cuGraphKernelNodeCopyAttributes - data["__cuGraphKernelNodeCopyAttributes"] = <_cyb_intptr_t>__cuGraphKernelNodeCopyAttributes + data["__cuGraphKernelNodeCopyAttributes"] = <intptr_t>__cuGraphKernelNodeCopyAttributes global __cuGraphKernelNodeGetAttribute - data["__cuGraphKernelNodeGetAttribute"] = <_cyb_intptr_t>__cuGraphKernelNodeGetAttribute + data["__cuGraphKernelNodeGetAttribute"] = <intptr_t>__cuGraphKernelNodeGetAttribute global __cuGraphKernelNodeSetAttribute - data["__cuGraphKernelNodeSetAttribute"] = <_cyb_intptr_t>__cuGraphKernelNodeSetAttribute + data["__cuGraphKernelNodeSetAttribute"] = <intptr_t>__cuGraphKernelNodeSetAttribute global __cuGraphDebugDotPrint - data["__cuGraphDebugDotPrint"] = <_cyb_intptr_t>__cuGraphDebugDotPrint + data["__cuGraphDebugDotPrint"] = <intptr_t>__cuGraphDebugDotPrint global __cuUserObjectCreate - data["__cuUserObjectCreate"] = <_cyb_intptr_t>__cuUserObjectCreate + data["__cuUserObjectCreate"] = <intptr_t>__cuUserObjectCreate global __cuUserObjectRetain - data["__cuUserObjectRetain"] = <_cyb_intptr_t>__cuUserObjectRetain + data["__cuUserObjectRetain"] = <intptr_t>__cuUserObjectRetain global __cuUserObjectRelease - data["__cuUserObjectRelease"] = <_cyb_intptr_t>__cuUserObjectRelease + data["__cuUserObjectRelease"] = <intptr_t>__cuUserObjectRelease global __cuGraphRetainUserObject - data["__cuGraphRetainUserObject"] = <_cyb_intptr_t>__cuGraphRetainUserObject + data["__cuGraphRetainUserObject"] = <intptr_t>__cuGraphRetainUserObject global __cuGraphReleaseUserObject - data["__cuGraphReleaseUserObject"] = <_cyb_intptr_t>__cuGraphReleaseUserObject + data["__cuGraphReleaseUserObject"] = <intptr_t>__cuGraphReleaseUserObject global __cuGraphAddNode_v2 - data["__cuGraphAddNode_v2"] = <_cyb_intptr_t>__cuGraphAddNode_v2 + data["__cuGraphAddNode_v2"] = <intptr_t>__cuGraphAddNode_v2 global __cuGraphNodeSetParams - data["__cuGraphNodeSetParams"] = <_cyb_intptr_t>__cuGraphNodeSetParams + data["__cuGraphNodeSetParams"] = <intptr_t>__cuGraphNodeSetParams global __cuGraphExecNodeSetParams - data["__cuGraphExecNodeSetParams"] = <_cyb_intptr_t>__cuGraphExecNodeSetParams + data["__cuGraphExecNodeSetParams"] = <intptr_t>__cuGraphExecNodeSetParams global __cuGraphConditionalHandleCreate - data["__cuGraphConditionalHandleCreate"] = <_cyb_intptr_t>__cuGraphConditionalHandleCreate + data["__cuGraphConditionalHandleCreate"] = <intptr_t>__cuGraphConditionalHandleCreate global __cuOccupancyMaxActiveBlocksPerMultiprocessor - data["__cuOccupancyMaxActiveBlocksPerMultiprocessor"] = <_cyb_intptr_t>__cuOccupancyMaxActiveBlocksPerMultiprocessor + data["__cuOccupancyMaxActiveBlocksPerMultiprocessor"] = <intptr_t>__cuOccupancyMaxActiveBlocksPerMultiprocessor global __cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags - data["__cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags"] = <_cyb_intptr_t>__cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags + data["__cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags"] = <intptr_t>__cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags global __cuOccupancyMaxPotentialBlockSize - data["__cuOccupancyMaxPotentialBlockSize"] = <_cyb_intptr_t>__cuOccupancyMaxPotentialBlockSize + data["__cuOccupancyMaxPotentialBlockSize"] = <intptr_t>__cuOccupancyMaxPotentialBlockSize global __cuOccupancyMaxPotentialBlockSizeWithFlags - data["__cuOccupancyMaxPotentialBlockSizeWithFlags"] = <_cyb_intptr_t>__cuOccupancyMaxPotentialBlockSizeWithFlags + data["__cuOccupancyMaxPotentialBlockSizeWithFlags"] = <intptr_t>__cuOccupancyMaxPotentialBlockSizeWithFlags global __cuOccupancyAvailableDynamicSMemPerBlock - data["__cuOccupancyAvailableDynamicSMemPerBlock"] = <_cyb_intptr_t>__cuOccupancyAvailableDynamicSMemPerBlock + data["__cuOccupancyAvailableDynamicSMemPerBlock"] = <intptr_t>__cuOccupancyAvailableDynamicSMemPerBlock global __cuOccupancyMaxPotentialClusterSize - data["__cuOccupancyMaxPotentialClusterSize"] = <_cyb_intptr_t>__cuOccupancyMaxPotentialClusterSize + data["__cuOccupancyMaxPotentialClusterSize"] = <intptr_t>__cuOccupancyMaxPotentialClusterSize global __cuOccupancyMaxActiveClusters - data["__cuOccupancyMaxActiveClusters"] = <_cyb_intptr_t>__cuOccupancyMaxActiveClusters + data["__cuOccupancyMaxActiveClusters"] = <intptr_t>__cuOccupancyMaxActiveClusters global __cuTexRefSetArray - data["__cuTexRefSetArray"] = <_cyb_intptr_t>__cuTexRefSetArray + data["__cuTexRefSetArray"] = <intptr_t>__cuTexRefSetArray global __cuTexRefSetMipmappedArray - data["__cuTexRefSetMipmappedArray"] = <_cyb_intptr_t>__cuTexRefSetMipmappedArray + data["__cuTexRefSetMipmappedArray"] = <intptr_t>__cuTexRefSetMipmappedArray global __cuTexRefSetAddress_v2 - data["__cuTexRefSetAddress_v2"] = <_cyb_intptr_t>__cuTexRefSetAddress_v2 + data["__cuTexRefSetAddress_v2"] = <intptr_t>__cuTexRefSetAddress_v2 global __cuTexRefSetAddress2D_v3 - data["__cuTexRefSetAddress2D_v3"] = <_cyb_intptr_t>__cuTexRefSetAddress2D_v3 + data["__cuTexRefSetAddress2D_v3"] = <intptr_t>__cuTexRefSetAddress2D_v3 global __cuTexRefSetFormat - data["__cuTexRefSetFormat"] = <_cyb_intptr_t>__cuTexRefSetFormat + data["__cuTexRefSetFormat"] = <intptr_t>__cuTexRefSetFormat global __cuTexRefSetAddressMode - data["__cuTexRefSetAddressMode"] = <_cyb_intptr_t>__cuTexRefSetAddressMode + data["__cuTexRefSetAddressMode"] = <intptr_t>__cuTexRefSetAddressMode global __cuTexRefSetFilterMode - data["__cuTexRefSetFilterMode"] = <_cyb_intptr_t>__cuTexRefSetFilterMode + data["__cuTexRefSetFilterMode"] = <intptr_t>__cuTexRefSetFilterMode global __cuTexRefSetMipmapFilterMode - data["__cuTexRefSetMipmapFilterMode"] = <_cyb_intptr_t>__cuTexRefSetMipmapFilterMode + data["__cuTexRefSetMipmapFilterMode"] = <intptr_t>__cuTexRefSetMipmapFilterMode global __cuTexRefSetMipmapLevelBias - data["__cuTexRefSetMipmapLevelBias"] = <_cyb_intptr_t>__cuTexRefSetMipmapLevelBias + data["__cuTexRefSetMipmapLevelBias"] = <intptr_t>__cuTexRefSetMipmapLevelBias global __cuTexRefSetMipmapLevelClamp - data["__cuTexRefSetMipmapLevelClamp"] = <_cyb_intptr_t>__cuTexRefSetMipmapLevelClamp + data["__cuTexRefSetMipmapLevelClamp"] = <intptr_t>__cuTexRefSetMipmapLevelClamp global __cuTexRefSetMaxAnisotropy - data["__cuTexRefSetMaxAnisotropy"] = <_cyb_intptr_t>__cuTexRefSetMaxAnisotropy + data["__cuTexRefSetMaxAnisotropy"] = <intptr_t>__cuTexRefSetMaxAnisotropy global __cuTexRefSetBorderColor - data["__cuTexRefSetBorderColor"] = <_cyb_intptr_t>__cuTexRefSetBorderColor + data["__cuTexRefSetBorderColor"] = <intptr_t>__cuTexRefSetBorderColor global __cuTexRefSetFlags - data["__cuTexRefSetFlags"] = <_cyb_intptr_t>__cuTexRefSetFlags + data["__cuTexRefSetFlags"] = <intptr_t>__cuTexRefSetFlags global __cuTexRefGetAddress_v2 - data["__cuTexRefGetAddress_v2"] = <_cyb_intptr_t>__cuTexRefGetAddress_v2 + data["__cuTexRefGetAddress_v2"] = <intptr_t>__cuTexRefGetAddress_v2 global __cuTexRefGetArray - data["__cuTexRefGetArray"] = <_cyb_intptr_t>__cuTexRefGetArray + data["__cuTexRefGetArray"] = <intptr_t>__cuTexRefGetArray global __cuTexRefGetMipmappedArray - data["__cuTexRefGetMipmappedArray"] = <_cyb_intptr_t>__cuTexRefGetMipmappedArray + data["__cuTexRefGetMipmappedArray"] = <intptr_t>__cuTexRefGetMipmappedArray global __cuTexRefGetAddressMode - data["__cuTexRefGetAddressMode"] = <_cyb_intptr_t>__cuTexRefGetAddressMode + data["__cuTexRefGetAddressMode"] = <intptr_t>__cuTexRefGetAddressMode global __cuTexRefGetFilterMode - data["__cuTexRefGetFilterMode"] = <_cyb_intptr_t>__cuTexRefGetFilterMode + data["__cuTexRefGetFilterMode"] = <intptr_t>__cuTexRefGetFilterMode global __cuTexRefGetFormat - data["__cuTexRefGetFormat"] = <_cyb_intptr_t>__cuTexRefGetFormat + data["__cuTexRefGetFormat"] = <intptr_t>__cuTexRefGetFormat global __cuTexRefGetMipmapFilterMode - data["__cuTexRefGetMipmapFilterMode"] = <_cyb_intptr_t>__cuTexRefGetMipmapFilterMode + data["__cuTexRefGetMipmapFilterMode"] = <intptr_t>__cuTexRefGetMipmapFilterMode global __cuTexRefGetMipmapLevelBias - data["__cuTexRefGetMipmapLevelBias"] = <_cyb_intptr_t>__cuTexRefGetMipmapLevelBias + data["__cuTexRefGetMipmapLevelBias"] = <intptr_t>__cuTexRefGetMipmapLevelBias global __cuTexRefGetMipmapLevelClamp - data["__cuTexRefGetMipmapLevelClamp"] = <_cyb_intptr_t>__cuTexRefGetMipmapLevelClamp + data["__cuTexRefGetMipmapLevelClamp"] = <intptr_t>__cuTexRefGetMipmapLevelClamp global __cuTexRefGetMaxAnisotropy - data["__cuTexRefGetMaxAnisotropy"] = <_cyb_intptr_t>__cuTexRefGetMaxAnisotropy + data["__cuTexRefGetMaxAnisotropy"] = <intptr_t>__cuTexRefGetMaxAnisotropy global __cuTexRefGetBorderColor - data["__cuTexRefGetBorderColor"] = <_cyb_intptr_t>__cuTexRefGetBorderColor + data["__cuTexRefGetBorderColor"] = <intptr_t>__cuTexRefGetBorderColor global __cuTexRefGetFlags - data["__cuTexRefGetFlags"] = <_cyb_intptr_t>__cuTexRefGetFlags + data["__cuTexRefGetFlags"] = <intptr_t>__cuTexRefGetFlags global __cuTexRefCreate - data["__cuTexRefCreate"] = <_cyb_intptr_t>__cuTexRefCreate + data["__cuTexRefCreate"] = <intptr_t>__cuTexRefCreate global __cuTexRefDestroy - data["__cuTexRefDestroy"] = <_cyb_intptr_t>__cuTexRefDestroy + data["__cuTexRefDestroy"] = <intptr_t>__cuTexRefDestroy global __cuSurfRefSetArray - data["__cuSurfRefSetArray"] = <_cyb_intptr_t>__cuSurfRefSetArray + data["__cuSurfRefSetArray"] = <intptr_t>__cuSurfRefSetArray global __cuSurfRefGetArray - data["__cuSurfRefGetArray"] = <_cyb_intptr_t>__cuSurfRefGetArray + data["__cuSurfRefGetArray"] = <intptr_t>__cuSurfRefGetArray global __cuTexObjectCreate - data["__cuTexObjectCreate"] = <_cyb_intptr_t>__cuTexObjectCreate + data["__cuTexObjectCreate"] = <intptr_t>__cuTexObjectCreate global __cuTexObjectDestroy - data["__cuTexObjectDestroy"] = <_cyb_intptr_t>__cuTexObjectDestroy + data["__cuTexObjectDestroy"] = <intptr_t>__cuTexObjectDestroy global __cuTexObjectGetResourceDesc - data["__cuTexObjectGetResourceDesc"] = <_cyb_intptr_t>__cuTexObjectGetResourceDesc + data["__cuTexObjectGetResourceDesc"] = <intptr_t>__cuTexObjectGetResourceDesc global __cuTexObjectGetTextureDesc - data["__cuTexObjectGetTextureDesc"] = <_cyb_intptr_t>__cuTexObjectGetTextureDesc + data["__cuTexObjectGetTextureDesc"] = <intptr_t>__cuTexObjectGetTextureDesc global __cuTexObjectGetResourceViewDesc - data["__cuTexObjectGetResourceViewDesc"] = <_cyb_intptr_t>__cuTexObjectGetResourceViewDesc + data["__cuTexObjectGetResourceViewDesc"] = <intptr_t>__cuTexObjectGetResourceViewDesc global __cuSurfObjectCreate - data["__cuSurfObjectCreate"] = <_cyb_intptr_t>__cuSurfObjectCreate + data["__cuSurfObjectCreate"] = <intptr_t>__cuSurfObjectCreate global __cuSurfObjectDestroy - data["__cuSurfObjectDestroy"] = <_cyb_intptr_t>__cuSurfObjectDestroy + data["__cuSurfObjectDestroy"] = <intptr_t>__cuSurfObjectDestroy global __cuSurfObjectGetResourceDesc - data["__cuSurfObjectGetResourceDesc"] = <_cyb_intptr_t>__cuSurfObjectGetResourceDesc + data["__cuSurfObjectGetResourceDesc"] = <intptr_t>__cuSurfObjectGetResourceDesc global __cuTensorMapEncodeTiled - data["__cuTensorMapEncodeTiled"] = <_cyb_intptr_t>__cuTensorMapEncodeTiled + data["__cuTensorMapEncodeTiled"] = <intptr_t>__cuTensorMapEncodeTiled global __cuTensorMapEncodeIm2col - data["__cuTensorMapEncodeIm2col"] = <_cyb_intptr_t>__cuTensorMapEncodeIm2col + data["__cuTensorMapEncodeIm2col"] = <intptr_t>__cuTensorMapEncodeIm2col global __cuTensorMapEncodeIm2colWide - data["__cuTensorMapEncodeIm2colWide"] = <_cyb_intptr_t>__cuTensorMapEncodeIm2colWide + data["__cuTensorMapEncodeIm2colWide"] = <intptr_t>__cuTensorMapEncodeIm2colWide global __cuTensorMapReplaceAddress - data["__cuTensorMapReplaceAddress"] = <_cyb_intptr_t>__cuTensorMapReplaceAddress + data["__cuTensorMapReplaceAddress"] = <intptr_t>__cuTensorMapReplaceAddress global __cuDeviceCanAccessPeer - data["__cuDeviceCanAccessPeer"] = <_cyb_intptr_t>__cuDeviceCanAccessPeer + data["__cuDeviceCanAccessPeer"] = <intptr_t>__cuDeviceCanAccessPeer global __cuCtxEnablePeerAccess - data["__cuCtxEnablePeerAccess"] = <_cyb_intptr_t>__cuCtxEnablePeerAccess + data["__cuCtxEnablePeerAccess"] = <intptr_t>__cuCtxEnablePeerAccess global __cuCtxDisablePeerAccess - data["__cuCtxDisablePeerAccess"] = <_cyb_intptr_t>__cuCtxDisablePeerAccess + data["__cuCtxDisablePeerAccess"] = <intptr_t>__cuCtxDisablePeerAccess global __cuDeviceGetP2PAttribute - data["__cuDeviceGetP2PAttribute"] = <_cyb_intptr_t>__cuDeviceGetP2PAttribute + data["__cuDeviceGetP2PAttribute"] = <intptr_t>__cuDeviceGetP2PAttribute global __cuGraphicsUnregisterResource - data["__cuGraphicsUnregisterResource"] = <_cyb_intptr_t>__cuGraphicsUnregisterResource + data["__cuGraphicsUnregisterResource"] = <intptr_t>__cuGraphicsUnregisterResource global __cuGraphicsSubResourceGetMappedArray - data["__cuGraphicsSubResourceGetMappedArray"] = <_cyb_intptr_t>__cuGraphicsSubResourceGetMappedArray + data["__cuGraphicsSubResourceGetMappedArray"] = <intptr_t>__cuGraphicsSubResourceGetMappedArray global __cuGraphicsResourceGetMappedMipmappedArray - data["__cuGraphicsResourceGetMappedMipmappedArray"] = <_cyb_intptr_t>__cuGraphicsResourceGetMappedMipmappedArray + data["__cuGraphicsResourceGetMappedMipmappedArray"] = <intptr_t>__cuGraphicsResourceGetMappedMipmappedArray global __cuGraphicsResourceGetMappedPointer_v2 - data["__cuGraphicsResourceGetMappedPointer_v2"] = <_cyb_intptr_t>__cuGraphicsResourceGetMappedPointer_v2 + data["__cuGraphicsResourceGetMappedPointer_v2"] = <intptr_t>__cuGraphicsResourceGetMappedPointer_v2 global __cuGraphicsResourceSetMapFlags_v2 - data["__cuGraphicsResourceSetMapFlags_v2"] = <_cyb_intptr_t>__cuGraphicsResourceSetMapFlags_v2 + data["__cuGraphicsResourceSetMapFlags_v2"] = <intptr_t>__cuGraphicsResourceSetMapFlags_v2 global __cuGraphicsMapResources - data["__cuGraphicsMapResources"] = <_cyb_intptr_t>__cuGraphicsMapResources + data["__cuGraphicsMapResources"] = <intptr_t>__cuGraphicsMapResources global __cuGraphicsUnmapResources - data["__cuGraphicsUnmapResources"] = <_cyb_intptr_t>__cuGraphicsUnmapResources + data["__cuGraphicsUnmapResources"] = <intptr_t>__cuGraphicsUnmapResources global __cuGetProcAddress_v2 - data["__cuGetProcAddress_v2"] = <_cyb_intptr_t>__cuGetProcAddress_v2 + data["__cuGetProcAddress_v2"] = <intptr_t>__cuGetProcAddress_v2 global __cuCoredumpGetAttribute - data["__cuCoredumpGetAttribute"] = <_cyb_intptr_t>__cuCoredumpGetAttribute + data["__cuCoredumpGetAttribute"] = <intptr_t>__cuCoredumpGetAttribute global __cuCoredumpGetAttributeGlobal - data["__cuCoredumpGetAttributeGlobal"] = <_cyb_intptr_t>__cuCoredumpGetAttributeGlobal + data["__cuCoredumpGetAttributeGlobal"] = <intptr_t>__cuCoredumpGetAttributeGlobal global __cuCoredumpSetAttribute - data["__cuCoredumpSetAttribute"] = <_cyb_intptr_t>__cuCoredumpSetAttribute + data["__cuCoredumpSetAttribute"] = <intptr_t>__cuCoredumpSetAttribute global __cuCoredumpSetAttributeGlobal - data["__cuCoredumpSetAttributeGlobal"] = <_cyb_intptr_t>__cuCoredumpSetAttributeGlobal + data["__cuCoredumpSetAttributeGlobal"] = <intptr_t>__cuCoredumpSetAttributeGlobal global __cuGetExportTable - data["__cuGetExportTable"] = <_cyb_intptr_t>__cuGetExportTable + data["__cuGetExportTable"] = <intptr_t>__cuGetExportTable global __cuGreenCtxCreate - data["__cuGreenCtxCreate"] = <_cyb_intptr_t>__cuGreenCtxCreate + data["__cuGreenCtxCreate"] = <intptr_t>__cuGreenCtxCreate global __cuGreenCtxDestroy - data["__cuGreenCtxDestroy"] = <_cyb_intptr_t>__cuGreenCtxDestroy + data["__cuGreenCtxDestroy"] = <intptr_t>__cuGreenCtxDestroy global __cuCtxFromGreenCtx - data["__cuCtxFromGreenCtx"] = <_cyb_intptr_t>__cuCtxFromGreenCtx + data["__cuCtxFromGreenCtx"] = <intptr_t>__cuCtxFromGreenCtx global __cuDeviceGetDevResource - data["__cuDeviceGetDevResource"] = <_cyb_intptr_t>__cuDeviceGetDevResource + data["__cuDeviceGetDevResource"] = <intptr_t>__cuDeviceGetDevResource global __cuCtxGetDevResource - data["__cuCtxGetDevResource"] = <_cyb_intptr_t>__cuCtxGetDevResource + data["__cuCtxGetDevResource"] = <intptr_t>__cuCtxGetDevResource global __cuGreenCtxGetDevResource - data["__cuGreenCtxGetDevResource"] = <_cyb_intptr_t>__cuGreenCtxGetDevResource + data["__cuGreenCtxGetDevResource"] = <intptr_t>__cuGreenCtxGetDevResource global __cuDevSmResourceSplitByCount - data["__cuDevSmResourceSplitByCount"] = <_cyb_intptr_t>__cuDevSmResourceSplitByCount + data["__cuDevSmResourceSplitByCount"] = <intptr_t>__cuDevSmResourceSplitByCount global __cuDevResourceGenerateDesc - data["__cuDevResourceGenerateDesc"] = <_cyb_intptr_t>__cuDevResourceGenerateDesc + data["__cuDevResourceGenerateDesc"] = <intptr_t>__cuDevResourceGenerateDesc global __cuGreenCtxRecordEvent - data["__cuGreenCtxRecordEvent"] = <_cyb_intptr_t>__cuGreenCtxRecordEvent + data["__cuGreenCtxRecordEvent"] = <intptr_t>__cuGreenCtxRecordEvent global __cuGreenCtxWaitEvent - data["__cuGreenCtxWaitEvent"] = <_cyb_intptr_t>__cuGreenCtxWaitEvent + data["__cuGreenCtxWaitEvent"] = <intptr_t>__cuGreenCtxWaitEvent global __cuStreamGetGreenCtx - data["__cuStreamGetGreenCtx"] = <_cyb_intptr_t>__cuStreamGetGreenCtx + data["__cuStreamGetGreenCtx"] = <intptr_t>__cuStreamGetGreenCtx global __cuGreenCtxStreamCreate - data["__cuGreenCtxStreamCreate"] = <_cyb_intptr_t>__cuGreenCtxStreamCreate + data["__cuGreenCtxStreamCreate"] = <intptr_t>__cuGreenCtxStreamCreate global __cuLogsRegisterCallback - data["__cuLogsRegisterCallback"] = <_cyb_intptr_t>__cuLogsRegisterCallback + data["__cuLogsRegisterCallback"] = <intptr_t>__cuLogsRegisterCallback global __cuLogsUnregisterCallback - data["__cuLogsUnregisterCallback"] = <_cyb_intptr_t>__cuLogsUnregisterCallback + data["__cuLogsUnregisterCallback"] = <intptr_t>__cuLogsUnregisterCallback global __cuLogsCurrent - data["__cuLogsCurrent"] = <_cyb_intptr_t>__cuLogsCurrent + data["__cuLogsCurrent"] = <intptr_t>__cuLogsCurrent global __cuLogsDumpToFile - data["__cuLogsDumpToFile"] = <_cyb_intptr_t>__cuLogsDumpToFile + data["__cuLogsDumpToFile"] = <intptr_t>__cuLogsDumpToFile global __cuLogsDumpToMemory - data["__cuLogsDumpToMemory"] = <_cyb_intptr_t>__cuLogsDumpToMemory + data["__cuLogsDumpToMemory"] = <intptr_t>__cuLogsDumpToMemory global __cuCheckpointProcessGetRestoreThreadId - data["__cuCheckpointProcessGetRestoreThreadId"] = <_cyb_intptr_t>__cuCheckpointProcessGetRestoreThreadId + data["__cuCheckpointProcessGetRestoreThreadId"] = <intptr_t>__cuCheckpointProcessGetRestoreThreadId global __cuCheckpointProcessGetState - data["__cuCheckpointProcessGetState"] = <_cyb_intptr_t>__cuCheckpointProcessGetState + data["__cuCheckpointProcessGetState"] = <intptr_t>__cuCheckpointProcessGetState global __cuCheckpointProcessLock - data["__cuCheckpointProcessLock"] = <_cyb_intptr_t>__cuCheckpointProcessLock + data["__cuCheckpointProcessLock"] = <intptr_t>__cuCheckpointProcessLock global __cuCheckpointProcessCheckpoint - data["__cuCheckpointProcessCheckpoint"] = <_cyb_intptr_t>__cuCheckpointProcessCheckpoint + data["__cuCheckpointProcessCheckpoint"] = <intptr_t>__cuCheckpointProcessCheckpoint global __cuCheckpointProcessRestore - data["__cuCheckpointProcessRestore"] = <_cyb_intptr_t>__cuCheckpointProcessRestore + data["__cuCheckpointProcessRestore"] = <intptr_t>__cuCheckpointProcessRestore global __cuCheckpointProcessUnlock - data["__cuCheckpointProcessUnlock"] = <_cyb_intptr_t>__cuCheckpointProcessUnlock + data["__cuCheckpointProcessUnlock"] = <intptr_t>__cuCheckpointProcessUnlock global __cuGraphicsEGLRegisterImage - data["__cuGraphicsEGLRegisterImage"] = <_cyb_intptr_t>__cuGraphicsEGLRegisterImage + data["__cuGraphicsEGLRegisterImage"] = <intptr_t>__cuGraphicsEGLRegisterImage global __cuEGLStreamConsumerConnect - data["__cuEGLStreamConsumerConnect"] = <_cyb_intptr_t>__cuEGLStreamConsumerConnect + data["__cuEGLStreamConsumerConnect"] = <intptr_t>__cuEGLStreamConsumerConnect global __cuEGLStreamConsumerConnectWithFlags - data["__cuEGLStreamConsumerConnectWithFlags"] = <_cyb_intptr_t>__cuEGLStreamConsumerConnectWithFlags + data["__cuEGLStreamConsumerConnectWithFlags"] = <intptr_t>__cuEGLStreamConsumerConnectWithFlags global __cuEGLStreamConsumerDisconnect - data["__cuEGLStreamConsumerDisconnect"] = <_cyb_intptr_t>__cuEGLStreamConsumerDisconnect + data["__cuEGLStreamConsumerDisconnect"] = <intptr_t>__cuEGLStreamConsumerDisconnect global __cuEGLStreamConsumerAcquireFrame - data["__cuEGLStreamConsumerAcquireFrame"] = <_cyb_intptr_t>__cuEGLStreamConsumerAcquireFrame + data["__cuEGLStreamConsumerAcquireFrame"] = <intptr_t>__cuEGLStreamConsumerAcquireFrame global __cuEGLStreamConsumerReleaseFrame - data["__cuEGLStreamConsumerReleaseFrame"] = <_cyb_intptr_t>__cuEGLStreamConsumerReleaseFrame + data["__cuEGLStreamConsumerReleaseFrame"] = <intptr_t>__cuEGLStreamConsumerReleaseFrame global __cuEGLStreamProducerConnect - data["__cuEGLStreamProducerConnect"] = <_cyb_intptr_t>__cuEGLStreamProducerConnect + data["__cuEGLStreamProducerConnect"] = <intptr_t>__cuEGLStreamProducerConnect global __cuEGLStreamProducerDisconnect - data["__cuEGLStreamProducerDisconnect"] = <_cyb_intptr_t>__cuEGLStreamProducerDisconnect + data["__cuEGLStreamProducerDisconnect"] = <intptr_t>__cuEGLStreamProducerDisconnect global __cuEGLStreamProducerPresentFrame - data["__cuEGLStreamProducerPresentFrame"] = <_cyb_intptr_t>__cuEGLStreamProducerPresentFrame + data["__cuEGLStreamProducerPresentFrame"] = <intptr_t>__cuEGLStreamProducerPresentFrame global __cuEGLStreamProducerReturnFrame - data["__cuEGLStreamProducerReturnFrame"] = <_cyb_intptr_t>__cuEGLStreamProducerReturnFrame + data["__cuEGLStreamProducerReturnFrame"] = <intptr_t>__cuEGLStreamProducerReturnFrame global __cuGraphicsResourceGetMappedEglFrame - data["__cuGraphicsResourceGetMappedEglFrame"] = <_cyb_intptr_t>__cuGraphicsResourceGetMappedEglFrame + data["__cuGraphicsResourceGetMappedEglFrame"] = <intptr_t>__cuGraphicsResourceGetMappedEglFrame global __cuEventCreateFromEGLSync - data["__cuEventCreateFromEGLSync"] = <_cyb_intptr_t>__cuEventCreateFromEGLSync + data["__cuEventCreateFromEGLSync"] = <intptr_t>__cuEventCreateFromEGLSync global __cuGraphicsGLRegisterBuffer - data["__cuGraphicsGLRegisterBuffer"] = <_cyb_intptr_t>__cuGraphicsGLRegisterBuffer + data["__cuGraphicsGLRegisterBuffer"] = <intptr_t>__cuGraphicsGLRegisterBuffer global __cuGraphicsGLRegisterImage - data["__cuGraphicsGLRegisterImage"] = <_cyb_intptr_t>__cuGraphicsGLRegisterImage + data["__cuGraphicsGLRegisterImage"] = <intptr_t>__cuGraphicsGLRegisterImage global __cuGLGetDevices_v2 - data["__cuGLGetDevices_v2"] = <_cyb_intptr_t>__cuGLGetDevices_v2 + data["__cuGLGetDevices_v2"] = <intptr_t>__cuGLGetDevices_v2 global __cuGLCtxCreate_v2 - data["__cuGLCtxCreate_v2"] = <_cyb_intptr_t>__cuGLCtxCreate_v2 + data["__cuGLCtxCreate_v2"] = <intptr_t>__cuGLCtxCreate_v2 global __cuGLInit - data["__cuGLInit"] = <_cyb_intptr_t>__cuGLInit + data["__cuGLInit"] = <intptr_t>__cuGLInit global __cuGLRegisterBufferObject - data["__cuGLRegisterBufferObject"] = <_cyb_intptr_t>__cuGLRegisterBufferObject + data["__cuGLRegisterBufferObject"] = <intptr_t>__cuGLRegisterBufferObject global __cuGLMapBufferObject_v2 - data["__cuGLMapBufferObject_v2"] = <_cyb_intptr_t>__cuGLMapBufferObject_v2 + data["__cuGLMapBufferObject_v2"] = <intptr_t>__cuGLMapBufferObject_v2 global __cuGLUnmapBufferObject - data["__cuGLUnmapBufferObject"] = <_cyb_intptr_t>__cuGLUnmapBufferObject + data["__cuGLUnmapBufferObject"] = <intptr_t>__cuGLUnmapBufferObject global __cuGLUnregisterBufferObject - data["__cuGLUnregisterBufferObject"] = <_cyb_intptr_t>__cuGLUnregisterBufferObject + data["__cuGLUnregisterBufferObject"] = <intptr_t>__cuGLUnregisterBufferObject global __cuGLSetBufferObjectMapFlags - data["__cuGLSetBufferObjectMapFlags"] = <_cyb_intptr_t>__cuGLSetBufferObjectMapFlags + data["__cuGLSetBufferObjectMapFlags"] = <intptr_t>__cuGLSetBufferObjectMapFlags global __cuGLMapBufferObjectAsync_v2 - data["__cuGLMapBufferObjectAsync_v2"] = <_cyb_intptr_t>__cuGLMapBufferObjectAsync_v2 + data["__cuGLMapBufferObjectAsync_v2"] = <intptr_t>__cuGLMapBufferObjectAsync_v2 global __cuGLUnmapBufferObjectAsync - data["__cuGLUnmapBufferObjectAsync"] = <_cyb_intptr_t>__cuGLUnmapBufferObjectAsync + data["__cuGLUnmapBufferObjectAsync"] = <intptr_t>__cuGLUnmapBufferObjectAsync global __cuProfilerInitialize - data["__cuProfilerInitialize"] = <_cyb_intptr_t>__cuProfilerInitialize + data["__cuProfilerInitialize"] = <intptr_t>__cuProfilerInitialize global __cuProfilerStart - data["__cuProfilerStart"] = <_cyb_intptr_t>__cuProfilerStart + data["__cuProfilerStart"] = <intptr_t>__cuProfilerStart global __cuProfilerStop - data["__cuProfilerStop"] = <_cyb_intptr_t>__cuProfilerStop + data["__cuProfilerStop"] = <intptr_t>__cuProfilerStop global __cuVDPAUGetDevice - data["__cuVDPAUGetDevice"] = <_cyb_intptr_t>__cuVDPAUGetDevice + data["__cuVDPAUGetDevice"] = <intptr_t>__cuVDPAUGetDevice global __cuVDPAUCtxCreate_v2 - data["__cuVDPAUCtxCreate_v2"] = <_cyb_intptr_t>__cuVDPAUCtxCreate_v2 + data["__cuVDPAUCtxCreate_v2"] = <intptr_t>__cuVDPAUCtxCreate_v2 global __cuGraphicsVDPAURegisterVideoSurface - data["__cuGraphicsVDPAURegisterVideoSurface"] = <_cyb_intptr_t>__cuGraphicsVDPAURegisterVideoSurface + data["__cuGraphicsVDPAURegisterVideoSurface"] = <intptr_t>__cuGraphicsVDPAURegisterVideoSurface global __cuGraphicsVDPAURegisterOutputSurface - data["__cuGraphicsVDPAURegisterOutputSurface"] = <_cyb_intptr_t>__cuGraphicsVDPAURegisterOutputSurface + data["__cuGraphicsVDPAURegisterOutputSurface"] = <intptr_t>__cuGraphicsVDPAURegisterOutputSurface global __cuDeviceGetHostAtomicCapabilities - data["__cuDeviceGetHostAtomicCapabilities"] = <_cyb_intptr_t>__cuDeviceGetHostAtomicCapabilities + data["__cuDeviceGetHostAtomicCapabilities"] = <intptr_t>__cuDeviceGetHostAtomicCapabilities global __cuCtxGetDevice_v2 - data["__cuCtxGetDevice_v2"] = <_cyb_intptr_t>__cuCtxGetDevice_v2 + data["__cuCtxGetDevice_v2"] = <intptr_t>__cuCtxGetDevice_v2 global __cuCtxSynchronize_v2 - data["__cuCtxSynchronize_v2"] = <_cyb_intptr_t>__cuCtxSynchronize_v2 + data["__cuCtxSynchronize_v2"] = <intptr_t>__cuCtxSynchronize_v2 global __cuMemcpyBatchAsync_v2 - data["__cuMemcpyBatchAsync_v2"] = <_cyb_intptr_t>__cuMemcpyBatchAsync_v2 + data["__cuMemcpyBatchAsync_v2"] = <intptr_t>__cuMemcpyBatchAsync_v2 global __cuMemcpy3DBatchAsync_v2 - data["__cuMemcpy3DBatchAsync_v2"] = <_cyb_intptr_t>__cuMemcpy3DBatchAsync_v2 + data["__cuMemcpy3DBatchAsync_v2"] = <intptr_t>__cuMemcpy3DBatchAsync_v2 global __cuMemGetDefaultMemPool - data["__cuMemGetDefaultMemPool"] = <_cyb_intptr_t>__cuMemGetDefaultMemPool + data["__cuMemGetDefaultMemPool"] = <intptr_t>__cuMemGetDefaultMemPool global __cuMemGetMemPool - data["__cuMemGetMemPool"] = <_cyb_intptr_t>__cuMemGetMemPool + data["__cuMemGetMemPool"] = <intptr_t>__cuMemGetMemPool global __cuMemSetMemPool - data["__cuMemSetMemPool"] = <_cyb_intptr_t>__cuMemSetMemPool + data["__cuMemSetMemPool"] = <intptr_t>__cuMemSetMemPool global __cuMemPrefetchBatchAsync - data["__cuMemPrefetchBatchAsync"] = <_cyb_intptr_t>__cuMemPrefetchBatchAsync + data["__cuMemPrefetchBatchAsync"] = <intptr_t>__cuMemPrefetchBatchAsync global __cuMemDiscardBatchAsync - data["__cuMemDiscardBatchAsync"] = <_cyb_intptr_t>__cuMemDiscardBatchAsync + data["__cuMemDiscardBatchAsync"] = <intptr_t>__cuMemDiscardBatchAsync global __cuMemDiscardAndPrefetchBatchAsync - data["__cuMemDiscardAndPrefetchBatchAsync"] = <_cyb_intptr_t>__cuMemDiscardAndPrefetchBatchAsync + data["__cuMemDiscardAndPrefetchBatchAsync"] = <intptr_t>__cuMemDiscardAndPrefetchBatchAsync global __cuDeviceGetP2PAtomicCapabilities - data["__cuDeviceGetP2PAtomicCapabilities"] = <_cyb_intptr_t>__cuDeviceGetP2PAtomicCapabilities + data["__cuDeviceGetP2PAtomicCapabilities"] = <intptr_t>__cuDeviceGetP2PAtomicCapabilities global __cuGreenCtxGetId - data["__cuGreenCtxGetId"] = <_cyb_intptr_t>__cuGreenCtxGetId + data["__cuGreenCtxGetId"] = <intptr_t>__cuGreenCtxGetId global __cuMulticastBindMem_v2 - data["__cuMulticastBindMem_v2"] = <_cyb_intptr_t>__cuMulticastBindMem_v2 + data["__cuMulticastBindMem_v2"] = <intptr_t>__cuMulticastBindMem_v2 global __cuMulticastBindAddr_v2 - data["__cuMulticastBindAddr_v2"] = <_cyb_intptr_t>__cuMulticastBindAddr_v2 + data["__cuMulticastBindAddr_v2"] = <intptr_t>__cuMulticastBindAddr_v2 global __cuGraphNodeGetContainingGraph - data["__cuGraphNodeGetContainingGraph"] = <_cyb_intptr_t>__cuGraphNodeGetContainingGraph + data["__cuGraphNodeGetContainingGraph"] = <intptr_t>__cuGraphNodeGetContainingGraph global __cuGraphNodeGetLocalId - data["__cuGraphNodeGetLocalId"] = <_cyb_intptr_t>__cuGraphNodeGetLocalId + data["__cuGraphNodeGetLocalId"] = <intptr_t>__cuGraphNodeGetLocalId global __cuGraphNodeGetToolsId - data["__cuGraphNodeGetToolsId"] = <_cyb_intptr_t>__cuGraphNodeGetToolsId + data["__cuGraphNodeGetToolsId"] = <intptr_t>__cuGraphNodeGetToolsId global __cuGraphGetId - data["__cuGraphGetId"] = <_cyb_intptr_t>__cuGraphGetId + data["__cuGraphGetId"] = <intptr_t>__cuGraphGetId global __cuGraphExecGetId - data["__cuGraphExecGetId"] = <_cyb_intptr_t>__cuGraphExecGetId + data["__cuGraphExecGetId"] = <intptr_t>__cuGraphExecGetId global __cuDevSmResourceSplit - data["__cuDevSmResourceSplit"] = <_cyb_intptr_t>__cuDevSmResourceSplit + data["__cuDevSmResourceSplit"] = <intptr_t>__cuDevSmResourceSplit global __cuStreamGetDevResource - data["__cuStreamGetDevResource"] = <_cyb_intptr_t>__cuStreamGetDevResource + data["__cuStreamGetDevResource"] = <intptr_t>__cuStreamGetDevResource global __cuKernelGetParamCount - data["__cuKernelGetParamCount"] = <_cyb_intptr_t>__cuKernelGetParamCount + data["__cuKernelGetParamCount"] = <intptr_t>__cuKernelGetParamCount global __cuMemcpyWithAttributesAsync - data["__cuMemcpyWithAttributesAsync"] = <_cyb_intptr_t>__cuMemcpyWithAttributesAsync + data["__cuMemcpyWithAttributesAsync"] = <intptr_t>__cuMemcpyWithAttributesAsync global __cuMemcpy3DWithAttributesAsync - data["__cuMemcpy3DWithAttributesAsync"] = <_cyb_intptr_t>__cuMemcpy3DWithAttributesAsync + data["__cuMemcpy3DWithAttributesAsync"] = <intptr_t>__cuMemcpy3DWithAttributesAsync global __cuStreamBeginCaptureToCig - data["__cuStreamBeginCaptureToCig"] = <_cyb_intptr_t>__cuStreamBeginCaptureToCig + data["__cuStreamBeginCaptureToCig"] = <intptr_t>__cuStreamBeginCaptureToCig global __cuStreamEndCaptureToCig - data["__cuStreamEndCaptureToCig"] = <_cyb_intptr_t>__cuStreamEndCaptureToCig + data["__cuStreamEndCaptureToCig"] = <intptr_t>__cuStreamEndCaptureToCig global __cuFuncGetParamCount - data["__cuFuncGetParamCount"] = <_cyb_intptr_t>__cuFuncGetParamCount + data["__cuFuncGetParamCount"] = <intptr_t>__cuFuncGetParamCount global __cuLaunchHostFunc_v2 - data["__cuLaunchHostFunc_v2"] = <_cyb_intptr_t>__cuLaunchHostFunc_v2 + data["__cuLaunchHostFunc_v2"] = <intptr_t>__cuLaunchHostFunc_v2 global __cuGraphNodeGetParams - data["__cuGraphNodeGetParams"] = <_cyb_intptr_t>__cuGraphNodeGetParams + data["__cuGraphNodeGetParams"] = <intptr_t>__cuGraphNodeGetParams global __cuCoredumpRegisterStartCallback - data["__cuCoredumpRegisterStartCallback"] = <_cyb_intptr_t>__cuCoredumpRegisterStartCallback + data["__cuCoredumpRegisterStartCallback"] = <intptr_t>__cuCoredumpRegisterStartCallback global __cuCoredumpRegisterCompleteCallback - data["__cuCoredumpRegisterCompleteCallback"] = <_cyb_intptr_t>__cuCoredumpRegisterCompleteCallback + data["__cuCoredumpRegisterCompleteCallback"] = <intptr_t>__cuCoredumpRegisterCompleteCallback global __cuCoredumpDeregisterStartCallback - data["__cuCoredumpDeregisterStartCallback"] = <_cyb_intptr_t>__cuCoredumpDeregisterStartCallback + data["__cuCoredumpDeregisterStartCallback"] = <intptr_t>__cuCoredumpDeregisterStartCallback global __cuCoredumpDeregisterCompleteCallback - data["__cuCoredumpDeregisterCompleteCallback"] = <_cyb_intptr_t>__cuCoredumpDeregisterCompleteCallback + data["__cuCoredumpDeregisterCompleteCallback"] = <intptr_t>__cuCoredumpDeregisterCompleteCallback global __cuLogicalEndpointIdReserve - data["__cuLogicalEndpointIdReserve"] = <_cyb_intptr_t>__cuLogicalEndpointIdReserve + data["__cuLogicalEndpointIdReserve"] = <intptr_t>__cuLogicalEndpointIdReserve global __cuLogicalEndpointIdRelease - data["__cuLogicalEndpointIdRelease"] = <_cyb_intptr_t>__cuLogicalEndpointIdRelease + data["__cuLogicalEndpointIdRelease"] = <intptr_t>__cuLogicalEndpointIdRelease global __cuLogicalEndpointCreate - data["__cuLogicalEndpointCreate"] = <_cyb_intptr_t>__cuLogicalEndpointCreate + data["__cuLogicalEndpointCreate"] = <intptr_t>__cuLogicalEndpointCreate global __cuLogicalEndpointAddDevice - data["__cuLogicalEndpointAddDevice"] = <_cyb_intptr_t>__cuLogicalEndpointAddDevice + data["__cuLogicalEndpointAddDevice"] = <intptr_t>__cuLogicalEndpointAddDevice global __cuLogicalEndpointDestroy - data["__cuLogicalEndpointDestroy"] = <_cyb_intptr_t>__cuLogicalEndpointDestroy + data["__cuLogicalEndpointDestroy"] = <intptr_t>__cuLogicalEndpointDestroy global __cuLogicalEndpointBindAddr - data["__cuLogicalEndpointBindAddr"] = <_cyb_intptr_t>__cuLogicalEndpointBindAddr + data["__cuLogicalEndpointBindAddr"] = <intptr_t>__cuLogicalEndpointBindAddr global __cuLogicalEndpointBindMem - data["__cuLogicalEndpointBindMem"] = <_cyb_intptr_t>__cuLogicalEndpointBindMem + data["__cuLogicalEndpointBindMem"] = <intptr_t>__cuLogicalEndpointBindMem global __cuLogicalEndpointUnbind - data["__cuLogicalEndpointUnbind"] = <_cyb_intptr_t>__cuLogicalEndpointUnbind + data["__cuLogicalEndpointUnbind"] = <intptr_t>__cuLogicalEndpointUnbind global __cuLogicalEndpointExport - data["__cuLogicalEndpointExport"] = <_cyb_intptr_t>__cuLogicalEndpointExport + data["__cuLogicalEndpointExport"] = <intptr_t>__cuLogicalEndpointExport global __cuLogicalEndpointImport - data["__cuLogicalEndpointImport"] = <_cyb_intptr_t>__cuLogicalEndpointImport + data["__cuLogicalEndpointImport"] = <intptr_t>__cuLogicalEndpointImport global __cuLogicalEndpointGetLimits - data["__cuLogicalEndpointGetLimits"] = <_cyb_intptr_t>__cuLogicalEndpointGetLimits + data["__cuLogicalEndpointGetLimits"] = <intptr_t>__cuLogicalEndpointGetLimits global __cuLogicalEndpointQuery - data["__cuLogicalEndpointQuery"] = <_cyb_intptr_t>__cuLogicalEndpointQuery + data["__cuLogicalEndpointQuery"] = <intptr_t>__cuLogicalEndpointQuery global __cuStreamBeginRecaptureToGraph - data["__cuStreamBeginRecaptureToGraph"] = <_cyb_intptr_t>__cuStreamBeginRecaptureToGraph + data["__cuStreamBeginRecaptureToGraph"] = <intptr_t>__cuStreamBeginRecaptureToGraph global __cuDeviceGetFabricClusterUuid - data["__cuDeviceGetFabricClusterUuid"] = <_cyb_intptr_t>__cuDeviceGetFabricClusterUuid + data["__cuDeviceGetFabricClusterUuid"] = <intptr_t>__cuDeviceGetFabricClusterUuid global __cuDeviceGetCliqueCount - data["__cuDeviceGetCliqueCount"] = <_cyb_intptr_t>__cuDeviceGetCliqueCount + data["__cuDeviceGetCliqueCount"] = <intptr_t>__cuDeviceGetCliqueCount global __cuDeviceGetCliqueInfo - data["__cuDeviceGetCliqueInfo"] = <_cyb_intptr_t>__cuDeviceGetCliqueInfo + data["__cuDeviceGetCliqueInfo"] = <intptr_t>__cuDeviceGetCliqueInfo global __cuMemGetLocationInfo - data["__cuMemGetLocationInfo"] = <_cyb_intptr_t>__cuMemGetLocationInfo + data["__cuMemGetLocationInfo"] = <intptr_t>__cuMemGetLocationInfo global __cuGraphAddNode_v3 - data["__cuGraphAddNode_v3"] = <_cyb_intptr_t>__cuGraphAddNode_v3 + data["__cuGraphAddNode_v3"] = <intptr_t>__cuGraphAddNode_v3 global __cuGraphNodeSetParams_v2 - data["__cuGraphNodeSetParams_v2"] = <_cyb_intptr_t>__cuGraphNodeSetParams_v2 + data["__cuGraphNodeSetParams_v2"] = <intptr_t>__cuGraphNodeSetParams_v2 global __cuCheckpointOperationComplete - data["__cuCheckpointOperationComplete"] = <_cyb_intptr_t>__cuCheckpointOperationComplete + data["__cuCheckpointOperationComplete"] = <intptr_t>__cuCheckpointOperationComplete _cyb_func_ptrs = data return data diff --git a/cuda_bindings/cuda/bindings/_internal/driver_windows.pyx b/cuda_bindings/cuda/bindings/_internal/driver_windows.pyx index 5bdc8edc360..c5a1db07768 100644 --- a/cuda_bindings/cuda/bindings/_internal/driver_windows.pyx +++ b/cuda_bindings/cuda/bindings/_internal/driver_windows.pyx @@ -4,7 +4,7 @@ # # This code was automatically generated across versions from 12.9.0 to 13.4.0. Do not modify it directly. # !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=56597b55df27ab42b4557879c383d53e0cff68853d1802c993db0e9eb8a449c7 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=f81fb19e0ada225c1596acd9484f5166c26f935f522d96dcf5618b5f8297911e # <<<< PREAMBLE CONTENT >>>> @@ -45,7 +45,7 @@ cdef extern from "<windows.h>": ctypedef void* HMODULE void* _cyb_GetProcAddress "GetProcAddress"(HMODULE, const char*) nogil -from libc.stdint cimport intptr_t as _cyb_intptr_t +from libc.stdint cimport intptr_t from os import getenv as _cyb_getenv import threading as _cyb_threading @@ -2205,1576 +2205,1576 @@ cpdef dict _inspect_function_pointers(): _check_or_init_driver() cdef dict data = {} global __cuGetErrorString - data["__cuGetErrorString"] = <_cyb_intptr_t>__cuGetErrorString + data["__cuGetErrorString"] = <intptr_t>__cuGetErrorString global __cuGetErrorName - data["__cuGetErrorName"] = <_cyb_intptr_t>__cuGetErrorName + data["__cuGetErrorName"] = <intptr_t>__cuGetErrorName global __cuInit - data["__cuInit"] = <_cyb_intptr_t>__cuInit + data["__cuInit"] = <intptr_t>__cuInit global __cuDriverGetVersion - data["__cuDriverGetVersion"] = <_cyb_intptr_t>__cuDriverGetVersion + data["__cuDriverGetVersion"] = <intptr_t>__cuDriverGetVersion global __cuDeviceGet - data["__cuDeviceGet"] = <_cyb_intptr_t>__cuDeviceGet + data["__cuDeviceGet"] = <intptr_t>__cuDeviceGet global __cuDeviceGetCount - data["__cuDeviceGetCount"] = <_cyb_intptr_t>__cuDeviceGetCount + data["__cuDeviceGetCount"] = <intptr_t>__cuDeviceGetCount global __cuDeviceGetName - data["__cuDeviceGetName"] = <_cyb_intptr_t>__cuDeviceGetName + data["__cuDeviceGetName"] = <intptr_t>__cuDeviceGetName global __cuDeviceGetUuid_v2 - data["__cuDeviceGetUuid_v2"] = <_cyb_intptr_t>__cuDeviceGetUuid_v2 + data["__cuDeviceGetUuid_v2"] = <intptr_t>__cuDeviceGetUuid_v2 global __cuDeviceGetLuid - data["__cuDeviceGetLuid"] = <_cyb_intptr_t>__cuDeviceGetLuid + data["__cuDeviceGetLuid"] = <intptr_t>__cuDeviceGetLuid global __cuDeviceTotalMem_v2 - data["__cuDeviceTotalMem_v2"] = <_cyb_intptr_t>__cuDeviceTotalMem_v2 + data["__cuDeviceTotalMem_v2"] = <intptr_t>__cuDeviceTotalMem_v2 global __cuDeviceGetTexture1DLinearMaxWidth - data["__cuDeviceGetTexture1DLinearMaxWidth"] = <_cyb_intptr_t>__cuDeviceGetTexture1DLinearMaxWidth + data["__cuDeviceGetTexture1DLinearMaxWidth"] = <intptr_t>__cuDeviceGetTexture1DLinearMaxWidth global __cuDeviceGetAttribute - data["__cuDeviceGetAttribute"] = <_cyb_intptr_t>__cuDeviceGetAttribute + data["__cuDeviceGetAttribute"] = <intptr_t>__cuDeviceGetAttribute global __cuDeviceGetNvSciSyncAttributes - data["__cuDeviceGetNvSciSyncAttributes"] = <_cyb_intptr_t>__cuDeviceGetNvSciSyncAttributes + data["__cuDeviceGetNvSciSyncAttributes"] = <intptr_t>__cuDeviceGetNvSciSyncAttributes global __cuDeviceSetMemPool - data["__cuDeviceSetMemPool"] = <_cyb_intptr_t>__cuDeviceSetMemPool + data["__cuDeviceSetMemPool"] = <intptr_t>__cuDeviceSetMemPool global __cuDeviceGetMemPool - data["__cuDeviceGetMemPool"] = <_cyb_intptr_t>__cuDeviceGetMemPool + data["__cuDeviceGetMemPool"] = <intptr_t>__cuDeviceGetMemPool global __cuDeviceGetDefaultMemPool - data["__cuDeviceGetDefaultMemPool"] = <_cyb_intptr_t>__cuDeviceGetDefaultMemPool + data["__cuDeviceGetDefaultMemPool"] = <intptr_t>__cuDeviceGetDefaultMemPool global __cuDeviceGetExecAffinitySupport - data["__cuDeviceGetExecAffinitySupport"] = <_cyb_intptr_t>__cuDeviceGetExecAffinitySupport + data["__cuDeviceGetExecAffinitySupport"] = <intptr_t>__cuDeviceGetExecAffinitySupport global __cuFlushGPUDirectRDMAWrites - data["__cuFlushGPUDirectRDMAWrites"] = <_cyb_intptr_t>__cuFlushGPUDirectRDMAWrites + data["__cuFlushGPUDirectRDMAWrites"] = <intptr_t>__cuFlushGPUDirectRDMAWrites global __cuDeviceGetProperties - data["__cuDeviceGetProperties"] = <_cyb_intptr_t>__cuDeviceGetProperties + data["__cuDeviceGetProperties"] = <intptr_t>__cuDeviceGetProperties global __cuDeviceComputeCapability - data["__cuDeviceComputeCapability"] = <_cyb_intptr_t>__cuDeviceComputeCapability + data["__cuDeviceComputeCapability"] = <intptr_t>__cuDeviceComputeCapability global __cuDevicePrimaryCtxRetain - data["__cuDevicePrimaryCtxRetain"] = <_cyb_intptr_t>__cuDevicePrimaryCtxRetain + data["__cuDevicePrimaryCtxRetain"] = <intptr_t>__cuDevicePrimaryCtxRetain global __cuDevicePrimaryCtxRelease_v2 - data["__cuDevicePrimaryCtxRelease_v2"] = <_cyb_intptr_t>__cuDevicePrimaryCtxRelease_v2 + data["__cuDevicePrimaryCtxRelease_v2"] = <intptr_t>__cuDevicePrimaryCtxRelease_v2 global __cuDevicePrimaryCtxSetFlags_v2 - data["__cuDevicePrimaryCtxSetFlags_v2"] = <_cyb_intptr_t>__cuDevicePrimaryCtxSetFlags_v2 + data["__cuDevicePrimaryCtxSetFlags_v2"] = <intptr_t>__cuDevicePrimaryCtxSetFlags_v2 global __cuDevicePrimaryCtxGetState - data["__cuDevicePrimaryCtxGetState"] = <_cyb_intptr_t>__cuDevicePrimaryCtxGetState + data["__cuDevicePrimaryCtxGetState"] = <intptr_t>__cuDevicePrimaryCtxGetState global __cuDevicePrimaryCtxReset_v2 - data["__cuDevicePrimaryCtxReset_v2"] = <_cyb_intptr_t>__cuDevicePrimaryCtxReset_v2 + data["__cuDevicePrimaryCtxReset_v2"] = <intptr_t>__cuDevicePrimaryCtxReset_v2 global __cuCtxCreate_v2 - data["__cuCtxCreate_v2"] = <_cyb_intptr_t>__cuCtxCreate_v2 + data["__cuCtxCreate_v2"] = <intptr_t>__cuCtxCreate_v2 global __cuCtxCreate_v3 - data["__cuCtxCreate_v3"] = <_cyb_intptr_t>__cuCtxCreate_v3 + data["__cuCtxCreate_v3"] = <intptr_t>__cuCtxCreate_v3 global __cuCtxCreate_v4 - data["__cuCtxCreate_v4"] = <_cyb_intptr_t>__cuCtxCreate_v4 + data["__cuCtxCreate_v4"] = <intptr_t>__cuCtxCreate_v4 global __cuCtxDestroy_v2 - data["__cuCtxDestroy_v2"] = <_cyb_intptr_t>__cuCtxDestroy_v2 + data["__cuCtxDestroy_v2"] = <intptr_t>__cuCtxDestroy_v2 global __cuCtxPushCurrent_v2 - data["__cuCtxPushCurrent_v2"] = <_cyb_intptr_t>__cuCtxPushCurrent_v2 + data["__cuCtxPushCurrent_v2"] = <intptr_t>__cuCtxPushCurrent_v2 global __cuCtxPopCurrent_v2 - data["__cuCtxPopCurrent_v2"] = <_cyb_intptr_t>__cuCtxPopCurrent_v2 + data["__cuCtxPopCurrent_v2"] = <intptr_t>__cuCtxPopCurrent_v2 global __cuCtxSetCurrent - data["__cuCtxSetCurrent"] = <_cyb_intptr_t>__cuCtxSetCurrent + data["__cuCtxSetCurrent"] = <intptr_t>__cuCtxSetCurrent global __cuCtxGetCurrent - data["__cuCtxGetCurrent"] = <_cyb_intptr_t>__cuCtxGetCurrent + data["__cuCtxGetCurrent"] = <intptr_t>__cuCtxGetCurrent global __cuCtxGetDevice - data["__cuCtxGetDevice"] = <_cyb_intptr_t>__cuCtxGetDevice + data["__cuCtxGetDevice"] = <intptr_t>__cuCtxGetDevice global __cuCtxGetFlags - data["__cuCtxGetFlags"] = <_cyb_intptr_t>__cuCtxGetFlags + data["__cuCtxGetFlags"] = <intptr_t>__cuCtxGetFlags global __cuCtxSetFlags - data["__cuCtxSetFlags"] = <_cyb_intptr_t>__cuCtxSetFlags + data["__cuCtxSetFlags"] = <intptr_t>__cuCtxSetFlags global __cuCtxGetId - data["__cuCtxGetId"] = <_cyb_intptr_t>__cuCtxGetId + data["__cuCtxGetId"] = <intptr_t>__cuCtxGetId global __cuCtxSynchronize - data["__cuCtxSynchronize"] = <_cyb_intptr_t>__cuCtxSynchronize + data["__cuCtxSynchronize"] = <intptr_t>__cuCtxSynchronize global __cuCtxSetLimit - data["__cuCtxSetLimit"] = <_cyb_intptr_t>__cuCtxSetLimit + data["__cuCtxSetLimit"] = <intptr_t>__cuCtxSetLimit global __cuCtxGetLimit - data["__cuCtxGetLimit"] = <_cyb_intptr_t>__cuCtxGetLimit + data["__cuCtxGetLimit"] = <intptr_t>__cuCtxGetLimit global __cuCtxGetCacheConfig - data["__cuCtxGetCacheConfig"] = <_cyb_intptr_t>__cuCtxGetCacheConfig + data["__cuCtxGetCacheConfig"] = <intptr_t>__cuCtxGetCacheConfig global __cuCtxSetCacheConfig - data["__cuCtxSetCacheConfig"] = <_cyb_intptr_t>__cuCtxSetCacheConfig + data["__cuCtxSetCacheConfig"] = <intptr_t>__cuCtxSetCacheConfig global __cuCtxGetApiVersion - data["__cuCtxGetApiVersion"] = <_cyb_intptr_t>__cuCtxGetApiVersion + data["__cuCtxGetApiVersion"] = <intptr_t>__cuCtxGetApiVersion global __cuCtxGetStreamPriorityRange - data["__cuCtxGetStreamPriorityRange"] = <_cyb_intptr_t>__cuCtxGetStreamPriorityRange + data["__cuCtxGetStreamPriorityRange"] = <intptr_t>__cuCtxGetStreamPriorityRange global __cuCtxResetPersistingL2Cache - data["__cuCtxResetPersistingL2Cache"] = <_cyb_intptr_t>__cuCtxResetPersistingL2Cache + data["__cuCtxResetPersistingL2Cache"] = <intptr_t>__cuCtxResetPersistingL2Cache global __cuCtxGetExecAffinity - data["__cuCtxGetExecAffinity"] = <_cyb_intptr_t>__cuCtxGetExecAffinity + data["__cuCtxGetExecAffinity"] = <intptr_t>__cuCtxGetExecAffinity global __cuCtxRecordEvent - data["__cuCtxRecordEvent"] = <_cyb_intptr_t>__cuCtxRecordEvent + data["__cuCtxRecordEvent"] = <intptr_t>__cuCtxRecordEvent global __cuCtxWaitEvent - data["__cuCtxWaitEvent"] = <_cyb_intptr_t>__cuCtxWaitEvent + data["__cuCtxWaitEvent"] = <intptr_t>__cuCtxWaitEvent global __cuCtxAttach - data["__cuCtxAttach"] = <_cyb_intptr_t>__cuCtxAttach + data["__cuCtxAttach"] = <intptr_t>__cuCtxAttach global __cuCtxDetach - data["__cuCtxDetach"] = <_cyb_intptr_t>__cuCtxDetach + data["__cuCtxDetach"] = <intptr_t>__cuCtxDetach global __cuCtxGetSharedMemConfig - data["__cuCtxGetSharedMemConfig"] = <_cyb_intptr_t>__cuCtxGetSharedMemConfig + data["__cuCtxGetSharedMemConfig"] = <intptr_t>__cuCtxGetSharedMemConfig global __cuCtxSetSharedMemConfig - data["__cuCtxSetSharedMemConfig"] = <_cyb_intptr_t>__cuCtxSetSharedMemConfig + data["__cuCtxSetSharedMemConfig"] = <intptr_t>__cuCtxSetSharedMemConfig global __cuModuleLoad - data["__cuModuleLoad"] = <_cyb_intptr_t>__cuModuleLoad + data["__cuModuleLoad"] = <intptr_t>__cuModuleLoad global __cuModuleLoadData - data["__cuModuleLoadData"] = <_cyb_intptr_t>__cuModuleLoadData + data["__cuModuleLoadData"] = <intptr_t>__cuModuleLoadData global __cuModuleLoadDataEx - data["__cuModuleLoadDataEx"] = <_cyb_intptr_t>__cuModuleLoadDataEx + data["__cuModuleLoadDataEx"] = <intptr_t>__cuModuleLoadDataEx global __cuModuleLoadFatBinary - data["__cuModuleLoadFatBinary"] = <_cyb_intptr_t>__cuModuleLoadFatBinary + data["__cuModuleLoadFatBinary"] = <intptr_t>__cuModuleLoadFatBinary global __cuModuleUnload - data["__cuModuleUnload"] = <_cyb_intptr_t>__cuModuleUnload + data["__cuModuleUnload"] = <intptr_t>__cuModuleUnload global __cuModuleGetLoadingMode - data["__cuModuleGetLoadingMode"] = <_cyb_intptr_t>__cuModuleGetLoadingMode + data["__cuModuleGetLoadingMode"] = <intptr_t>__cuModuleGetLoadingMode global __cuModuleGetFunction - data["__cuModuleGetFunction"] = <_cyb_intptr_t>__cuModuleGetFunction + data["__cuModuleGetFunction"] = <intptr_t>__cuModuleGetFunction global __cuModuleGetFunctionCount - data["__cuModuleGetFunctionCount"] = <_cyb_intptr_t>__cuModuleGetFunctionCount + data["__cuModuleGetFunctionCount"] = <intptr_t>__cuModuleGetFunctionCount global __cuModuleEnumerateFunctions - data["__cuModuleEnumerateFunctions"] = <_cyb_intptr_t>__cuModuleEnumerateFunctions + data["__cuModuleEnumerateFunctions"] = <intptr_t>__cuModuleEnumerateFunctions global __cuModuleGetGlobal_v2 - data["__cuModuleGetGlobal_v2"] = <_cyb_intptr_t>__cuModuleGetGlobal_v2 + data["__cuModuleGetGlobal_v2"] = <intptr_t>__cuModuleGetGlobal_v2 global __cuLinkCreate_v2 - data["__cuLinkCreate_v2"] = <_cyb_intptr_t>__cuLinkCreate_v2 + data["__cuLinkCreate_v2"] = <intptr_t>__cuLinkCreate_v2 global __cuLinkAddData_v2 - data["__cuLinkAddData_v2"] = <_cyb_intptr_t>__cuLinkAddData_v2 + data["__cuLinkAddData_v2"] = <intptr_t>__cuLinkAddData_v2 global __cuLinkAddFile_v2 - data["__cuLinkAddFile_v2"] = <_cyb_intptr_t>__cuLinkAddFile_v2 + data["__cuLinkAddFile_v2"] = <intptr_t>__cuLinkAddFile_v2 global __cuLinkComplete - data["__cuLinkComplete"] = <_cyb_intptr_t>__cuLinkComplete + data["__cuLinkComplete"] = <intptr_t>__cuLinkComplete global __cuLinkDestroy - data["__cuLinkDestroy"] = <_cyb_intptr_t>__cuLinkDestroy + data["__cuLinkDestroy"] = <intptr_t>__cuLinkDestroy global __cuModuleGetTexRef - data["__cuModuleGetTexRef"] = <_cyb_intptr_t>__cuModuleGetTexRef + data["__cuModuleGetTexRef"] = <intptr_t>__cuModuleGetTexRef global __cuModuleGetSurfRef - data["__cuModuleGetSurfRef"] = <_cyb_intptr_t>__cuModuleGetSurfRef + data["__cuModuleGetSurfRef"] = <intptr_t>__cuModuleGetSurfRef global __cuLibraryLoadData - data["__cuLibraryLoadData"] = <_cyb_intptr_t>__cuLibraryLoadData + data["__cuLibraryLoadData"] = <intptr_t>__cuLibraryLoadData global __cuLibraryLoadFromFile - data["__cuLibraryLoadFromFile"] = <_cyb_intptr_t>__cuLibraryLoadFromFile + data["__cuLibraryLoadFromFile"] = <intptr_t>__cuLibraryLoadFromFile global __cuLibraryUnload - data["__cuLibraryUnload"] = <_cyb_intptr_t>__cuLibraryUnload + data["__cuLibraryUnload"] = <intptr_t>__cuLibraryUnload global __cuLibraryGetKernel - data["__cuLibraryGetKernel"] = <_cyb_intptr_t>__cuLibraryGetKernel + data["__cuLibraryGetKernel"] = <intptr_t>__cuLibraryGetKernel global __cuLibraryGetKernelCount - data["__cuLibraryGetKernelCount"] = <_cyb_intptr_t>__cuLibraryGetKernelCount + data["__cuLibraryGetKernelCount"] = <intptr_t>__cuLibraryGetKernelCount global __cuLibraryEnumerateKernels - data["__cuLibraryEnumerateKernels"] = <_cyb_intptr_t>__cuLibraryEnumerateKernels + data["__cuLibraryEnumerateKernels"] = <intptr_t>__cuLibraryEnumerateKernels global __cuLibraryGetModule - data["__cuLibraryGetModule"] = <_cyb_intptr_t>__cuLibraryGetModule + data["__cuLibraryGetModule"] = <intptr_t>__cuLibraryGetModule global __cuKernelGetFunction - data["__cuKernelGetFunction"] = <_cyb_intptr_t>__cuKernelGetFunction + data["__cuKernelGetFunction"] = <intptr_t>__cuKernelGetFunction global __cuKernelGetLibrary - data["__cuKernelGetLibrary"] = <_cyb_intptr_t>__cuKernelGetLibrary + data["__cuKernelGetLibrary"] = <intptr_t>__cuKernelGetLibrary global __cuLibraryGetGlobal - data["__cuLibraryGetGlobal"] = <_cyb_intptr_t>__cuLibraryGetGlobal + data["__cuLibraryGetGlobal"] = <intptr_t>__cuLibraryGetGlobal global __cuLibraryGetManaged - data["__cuLibraryGetManaged"] = <_cyb_intptr_t>__cuLibraryGetManaged + data["__cuLibraryGetManaged"] = <intptr_t>__cuLibraryGetManaged global __cuLibraryGetUnifiedFunction - data["__cuLibraryGetUnifiedFunction"] = <_cyb_intptr_t>__cuLibraryGetUnifiedFunction + data["__cuLibraryGetUnifiedFunction"] = <intptr_t>__cuLibraryGetUnifiedFunction global __cuKernelGetAttribute - data["__cuKernelGetAttribute"] = <_cyb_intptr_t>__cuKernelGetAttribute + data["__cuKernelGetAttribute"] = <intptr_t>__cuKernelGetAttribute global __cuKernelSetAttribute - data["__cuKernelSetAttribute"] = <_cyb_intptr_t>__cuKernelSetAttribute + data["__cuKernelSetAttribute"] = <intptr_t>__cuKernelSetAttribute global __cuKernelSetCacheConfig - data["__cuKernelSetCacheConfig"] = <_cyb_intptr_t>__cuKernelSetCacheConfig + data["__cuKernelSetCacheConfig"] = <intptr_t>__cuKernelSetCacheConfig global __cuKernelGetName - data["__cuKernelGetName"] = <_cyb_intptr_t>__cuKernelGetName + data["__cuKernelGetName"] = <intptr_t>__cuKernelGetName global __cuKernelGetParamInfo - data["__cuKernelGetParamInfo"] = <_cyb_intptr_t>__cuKernelGetParamInfo + data["__cuKernelGetParamInfo"] = <intptr_t>__cuKernelGetParamInfo global __cuMemGetInfo_v2 - data["__cuMemGetInfo_v2"] = <_cyb_intptr_t>__cuMemGetInfo_v2 + data["__cuMemGetInfo_v2"] = <intptr_t>__cuMemGetInfo_v2 global __cuMemAlloc_v2 - data["__cuMemAlloc_v2"] = <_cyb_intptr_t>__cuMemAlloc_v2 + data["__cuMemAlloc_v2"] = <intptr_t>__cuMemAlloc_v2 global __cuMemAllocPitch_v2 - data["__cuMemAllocPitch_v2"] = <_cyb_intptr_t>__cuMemAllocPitch_v2 + data["__cuMemAllocPitch_v2"] = <intptr_t>__cuMemAllocPitch_v2 global __cuMemFree_v2 - data["__cuMemFree_v2"] = <_cyb_intptr_t>__cuMemFree_v2 + data["__cuMemFree_v2"] = <intptr_t>__cuMemFree_v2 global __cuMemGetAddressRange_v2 - data["__cuMemGetAddressRange_v2"] = <_cyb_intptr_t>__cuMemGetAddressRange_v2 + data["__cuMemGetAddressRange_v2"] = <intptr_t>__cuMemGetAddressRange_v2 global __cuMemAllocHost_v2 - data["__cuMemAllocHost_v2"] = <_cyb_intptr_t>__cuMemAllocHost_v2 + data["__cuMemAllocHost_v2"] = <intptr_t>__cuMemAllocHost_v2 global __cuMemFreeHost - data["__cuMemFreeHost"] = <_cyb_intptr_t>__cuMemFreeHost + data["__cuMemFreeHost"] = <intptr_t>__cuMemFreeHost global __cuMemHostAlloc - data["__cuMemHostAlloc"] = <_cyb_intptr_t>__cuMemHostAlloc + data["__cuMemHostAlloc"] = <intptr_t>__cuMemHostAlloc global __cuMemHostGetDevicePointer_v2 - data["__cuMemHostGetDevicePointer_v2"] = <_cyb_intptr_t>__cuMemHostGetDevicePointer_v2 + data["__cuMemHostGetDevicePointer_v2"] = <intptr_t>__cuMemHostGetDevicePointer_v2 global __cuMemHostGetFlags - data["__cuMemHostGetFlags"] = <_cyb_intptr_t>__cuMemHostGetFlags + data["__cuMemHostGetFlags"] = <intptr_t>__cuMemHostGetFlags global __cuMemAllocManaged - data["__cuMemAllocManaged"] = <_cyb_intptr_t>__cuMemAllocManaged + data["__cuMemAllocManaged"] = <intptr_t>__cuMemAllocManaged global __cuDeviceRegisterAsyncNotification - data["__cuDeviceRegisterAsyncNotification"] = <_cyb_intptr_t>__cuDeviceRegisterAsyncNotification + data["__cuDeviceRegisterAsyncNotification"] = <intptr_t>__cuDeviceRegisterAsyncNotification global __cuDeviceUnregisterAsyncNotification - data["__cuDeviceUnregisterAsyncNotification"] = <_cyb_intptr_t>__cuDeviceUnregisterAsyncNotification + data["__cuDeviceUnregisterAsyncNotification"] = <intptr_t>__cuDeviceUnregisterAsyncNotification global __cuDeviceGetByPCIBusId - data["__cuDeviceGetByPCIBusId"] = <_cyb_intptr_t>__cuDeviceGetByPCIBusId + data["__cuDeviceGetByPCIBusId"] = <intptr_t>__cuDeviceGetByPCIBusId global __cuDeviceGetPCIBusId - data["__cuDeviceGetPCIBusId"] = <_cyb_intptr_t>__cuDeviceGetPCIBusId + data["__cuDeviceGetPCIBusId"] = <intptr_t>__cuDeviceGetPCIBusId global __cuIpcGetEventHandle - data["__cuIpcGetEventHandle"] = <_cyb_intptr_t>__cuIpcGetEventHandle + data["__cuIpcGetEventHandle"] = <intptr_t>__cuIpcGetEventHandle global __cuIpcOpenEventHandle - data["__cuIpcOpenEventHandle"] = <_cyb_intptr_t>__cuIpcOpenEventHandle + data["__cuIpcOpenEventHandle"] = <intptr_t>__cuIpcOpenEventHandle global __cuIpcGetMemHandle - data["__cuIpcGetMemHandle"] = <_cyb_intptr_t>__cuIpcGetMemHandle + data["__cuIpcGetMemHandle"] = <intptr_t>__cuIpcGetMemHandle global __cuIpcOpenMemHandle_v2 - data["__cuIpcOpenMemHandle_v2"] = <_cyb_intptr_t>__cuIpcOpenMemHandle_v2 + data["__cuIpcOpenMemHandle_v2"] = <intptr_t>__cuIpcOpenMemHandle_v2 global __cuIpcCloseMemHandle - data["__cuIpcCloseMemHandle"] = <_cyb_intptr_t>__cuIpcCloseMemHandle + data["__cuIpcCloseMemHandle"] = <intptr_t>__cuIpcCloseMemHandle global __cuMemHostRegister_v2 - data["__cuMemHostRegister_v2"] = <_cyb_intptr_t>__cuMemHostRegister_v2 + data["__cuMemHostRegister_v2"] = <intptr_t>__cuMemHostRegister_v2 global __cuMemHostUnregister - data["__cuMemHostUnregister"] = <_cyb_intptr_t>__cuMemHostUnregister + data["__cuMemHostUnregister"] = <intptr_t>__cuMemHostUnregister global __cuMemcpy - data["__cuMemcpy"] = <_cyb_intptr_t>__cuMemcpy + data["__cuMemcpy"] = <intptr_t>__cuMemcpy global __cuMemcpyPeer - data["__cuMemcpyPeer"] = <_cyb_intptr_t>__cuMemcpyPeer + data["__cuMemcpyPeer"] = <intptr_t>__cuMemcpyPeer global __cuMemcpyHtoD_v2 - data["__cuMemcpyHtoD_v2"] = <_cyb_intptr_t>__cuMemcpyHtoD_v2 + data["__cuMemcpyHtoD_v2"] = <intptr_t>__cuMemcpyHtoD_v2 global __cuMemcpyDtoH_v2 - data["__cuMemcpyDtoH_v2"] = <_cyb_intptr_t>__cuMemcpyDtoH_v2 + data["__cuMemcpyDtoH_v2"] = <intptr_t>__cuMemcpyDtoH_v2 global __cuMemcpyDtoD_v2 - data["__cuMemcpyDtoD_v2"] = <_cyb_intptr_t>__cuMemcpyDtoD_v2 + data["__cuMemcpyDtoD_v2"] = <intptr_t>__cuMemcpyDtoD_v2 global __cuMemcpyDtoA_v2 - data["__cuMemcpyDtoA_v2"] = <_cyb_intptr_t>__cuMemcpyDtoA_v2 + data["__cuMemcpyDtoA_v2"] = <intptr_t>__cuMemcpyDtoA_v2 global __cuMemcpyAtoD_v2 - data["__cuMemcpyAtoD_v2"] = <_cyb_intptr_t>__cuMemcpyAtoD_v2 + data["__cuMemcpyAtoD_v2"] = <intptr_t>__cuMemcpyAtoD_v2 global __cuMemcpyHtoA_v2 - data["__cuMemcpyHtoA_v2"] = <_cyb_intptr_t>__cuMemcpyHtoA_v2 + data["__cuMemcpyHtoA_v2"] = <intptr_t>__cuMemcpyHtoA_v2 global __cuMemcpyAtoH_v2 - data["__cuMemcpyAtoH_v2"] = <_cyb_intptr_t>__cuMemcpyAtoH_v2 + data["__cuMemcpyAtoH_v2"] = <intptr_t>__cuMemcpyAtoH_v2 global __cuMemcpyAtoA_v2 - data["__cuMemcpyAtoA_v2"] = <_cyb_intptr_t>__cuMemcpyAtoA_v2 + data["__cuMemcpyAtoA_v2"] = <intptr_t>__cuMemcpyAtoA_v2 global __cuMemcpy2D_v2 - data["__cuMemcpy2D_v2"] = <_cyb_intptr_t>__cuMemcpy2D_v2 + data["__cuMemcpy2D_v2"] = <intptr_t>__cuMemcpy2D_v2 global __cuMemcpy2DUnaligned_v2 - data["__cuMemcpy2DUnaligned_v2"] = <_cyb_intptr_t>__cuMemcpy2DUnaligned_v2 + data["__cuMemcpy2DUnaligned_v2"] = <intptr_t>__cuMemcpy2DUnaligned_v2 global __cuMemcpy3D_v2 - data["__cuMemcpy3D_v2"] = <_cyb_intptr_t>__cuMemcpy3D_v2 + data["__cuMemcpy3D_v2"] = <intptr_t>__cuMemcpy3D_v2 global __cuMemcpy3DPeer - data["__cuMemcpy3DPeer"] = <_cyb_intptr_t>__cuMemcpy3DPeer + data["__cuMemcpy3DPeer"] = <intptr_t>__cuMemcpy3DPeer global __cuMemcpyAsync - data["__cuMemcpyAsync"] = <_cyb_intptr_t>__cuMemcpyAsync + data["__cuMemcpyAsync"] = <intptr_t>__cuMemcpyAsync global __cuMemcpyPeerAsync - data["__cuMemcpyPeerAsync"] = <_cyb_intptr_t>__cuMemcpyPeerAsync + data["__cuMemcpyPeerAsync"] = <intptr_t>__cuMemcpyPeerAsync global __cuMemcpyHtoDAsync_v2 - data["__cuMemcpyHtoDAsync_v2"] = <_cyb_intptr_t>__cuMemcpyHtoDAsync_v2 + data["__cuMemcpyHtoDAsync_v2"] = <intptr_t>__cuMemcpyHtoDAsync_v2 global __cuMemcpyDtoHAsync_v2 - data["__cuMemcpyDtoHAsync_v2"] = <_cyb_intptr_t>__cuMemcpyDtoHAsync_v2 + data["__cuMemcpyDtoHAsync_v2"] = <intptr_t>__cuMemcpyDtoHAsync_v2 global __cuMemcpyDtoDAsync_v2 - data["__cuMemcpyDtoDAsync_v2"] = <_cyb_intptr_t>__cuMemcpyDtoDAsync_v2 + data["__cuMemcpyDtoDAsync_v2"] = <intptr_t>__cuMemcpyDtoDAsync_v2 global __cuMemcpyHtoAAsync_v2 - data["__cuMemcpyHtoAAsync_v2"] = <_cyb_intptr_t>__cuMemcpyHtoAAsync_v2 + data["__cuMemcpyHtoAAsync_v2"] = <intptr_t>__cuMemcpyHtoAAsync_v2 global __cuMemcpyAtoHAsync_v2 - data["__cuMemcpyAtoHAsync_v2"] = <_cyb_intptr_t>__cuMemcpyAtoHAsync_v2 + data["__cuMemcpyAtoHAsync_v2"] = <intptr_t>__cuMemcpyAtoHAsync_v2 global __cuMemcpy2DAsync_v2 - data["__cuMemcpy2DAsync_v2"] = <_cyb_intptr_t>__cuMemcpy2DAsync_v2 + data["__cuMemcpy2DAsync_v2"] = <intptr_t>__cuMemcpy2DAsync_v2 global __cuMemcpy3DAsync_v2 - data["__cuMemcpy3DAsync_v2"] = <_cyb_intptr_t>__cuMemcpy3DAsync_v2 + data["__cuMemcpy3DAsync_v2"] = <intptr_t>__cuMemcpy3DAsync_v2 global __cuMemcpy3DPeerAsync - data["__cuMemcpy3DPeerAsync"] = <_cyb_intptr_t>__cuMemcpy3DPeerAsync + data["__cuMemcpy3DPeerAsync"] = <intptr_t>__cuMemcpy3DPeerAsync global __cuMemsetD8_v2 - data["__cuMemsetD8_v2"] = <_cyb_intptr_t>__cuMemsetD8_v2 + data["__cuMemsetD8_v2"] = <intptr_t>__cuMemsetD8_v2 global __cuMemsetD16_v2 - data["__cuMemsetD16_v2"] = <_cyb_intptr_t>__cuMemsetD16_v2 + data["__cuMemsetD16_v2"] = <intptr_t>__cuMemsetD16_v2 global __cuMemsetD32_v2 - data["__cuMemsetD32_v2"] = <_cyb_intptr_t>__cuMemsetD32_v2 + data["__cuMemsetD32_v2"] = <intptr_t>__cuMemsetD32_v2 global __cuMemsetD2D8_v2 - data["__cuMemsetD2D8_v2"] = <_cyb_intptr_t>__cuMemsetD2D8_v2 + data["__cuMemsetD2D8_v2"] = <intptr_t>__cuMemsetD2D8_v2 global __cuMemsetD2D16_v2 - data["__cuMemsetD2D16_v2"] = <_cyb_intptr_t>__cuMemsetD2D16_v2 + data["__cuMemsetD2D16_v2"] = <intptr_t>__cuMemsetD2D16_v2 global __cuMemsetD2D32_v2 - data["__cuMemsetD2D32_v2"] = <_cyb_intptr_t>__cuMemsetD2D32_v2 + data["__cuMemsetD2D32_v2"] = <intptr_t>__cuMemsetD2D32_v2 global __cuMemsetD8Async - data["__cuMemsetD8Async"] = <_cyb_intptr_t>__cuMemsetD8Async + data["__cuMemsetD8Async"] = <intptr_t>__cuMemsetD8Async global __cuMemsetD16Async - data["__cuMemsetD16Async"] = <_cyb_intptr_t>__cuMemsetD16Async + data["__cuMemsetD16Async"] = <intptr_t>__cuMemsetD16Async global __cuMemsetD32Async - data["__cuMemsetD32Async"] = <_cyb_intptr_t>__cuMemsetD32Async + data["__cuMemsetD32Async"] = <intptr_t>__cuMemsetD32Async global __cuMemsetD2D8Async - data["__cuMemsetD2D8Async"] = <_cyb_intptr_t>__cuMemsetD2D8Async + data["__cuMemsetD2D8Async"] = <intptr_t>__cuMemsetD2D8Async global __cuMemsetD2D16Async - data["__cuMemsetD2D16Async"] = <_cyb_intptr_t>__cuMemsetD2D16Async + data["__cuMemsetD2D16Async"] = <intptr_t>__cuMemsetD2D16Async global __cuMemsetD2D32Async - data["__cuMemsetD2D32Async"] = <_cyb_intptr_t>__cuMemsetD2D32Async + data["__cuMemsetD2D32Async"] = <intptr_t>__cuMemsetD2D32Async global __cuArrayCreate_v2 - data["__cuArrayCreate_v2"] = <_cyb_intptr_t>__cuArrayCreate_v2 + data["__cuArrayCreate_v2"] = <intptr_t>__cuArrayCreate_v2 global __cuArrayGetDescriptor_v2 - data["__cuArrayGetDescriptor_v2"] = <_cyb_intptr_t>__cuArrayGetDescriptor_v2 + data["__cuArrayGetDescriptor_v2"] = <intptr_t>__cuArrayGetDescriptor_v2 global __cuArrayGetSparseProperties - data["__cuArrayGetSparseProperties"] = <_cyb_intptr_t>__cuArrayGetSparseProperties + data["__cuArrayGetSparseProperties"] = <intptr_t>__cuArrayGetSparseProperties global __cuMipmappedArrayGetSparseProperties - data["__cuMipmappedArrayGetSparseProperties"] = <_cyb_intptr_t>__cuMipmappedArrayGetSparseProperties + data["__cuMipmappedArrayGetSparseProperties"] = <intptr_t>__cuMipmappedArrayGetSparseProperties global __cuArrayGetMemoryRequirements - data["__cuArrayGetMemoryRequirements"] = <_cyb_intptr_t>__cuArrayGetMemoryRequirements + data["__cuArrayGetMemoryRequirements"] = <intptr_t>__cuArrayGetMemoryRequirements global __cuMipmappedArrayGetMemoryRequirements - data["__cuMipmappedArrayGetMemoryRequirements"] = <_cyb_intptr_t>__cuMipmappedArrayGetMemoryRequirements + data["__cuMipmappedArrayGetMemoryRequirements"] = <intptr_t>__cuMipmappedArrayGetMemoryRequirements global __cuArrayGetPlane - data["__cuArrayGetPlane"] = <_cyb_intptr_t>__cuArrayGetPlane + data["__cuArrayGetPlane"] = <intptr_t>__cuArrayGetPlane global __cuArrayDestroy - data["__cuArrayDestroy"] = <_cyb_intptr_t>__cuArrayDestroy + data["__cuArrayDestroy"] = <intptr_t>__cuArrayDestroy global __cuArray3DCreate_v2 - data["__cuArray3DCreate_v2"] = <_cyb_intptr_t>__cuArray3DCreate_v2 + data["__cuArray3DCreate_v2"] = <intptr_t>__cuArray3DCreate_v2 global __cuArray3DGetDescriptor_v2 - data["__cuArray3DGetDescriptor_v2"] = <_cyb_intptr_t>__cuArray3DGetDescriptor_v2 + data["__cuArray3DGetDescriptor_v2"] = <intptr_t>__cuArray3DGetDescriptor_v2 global __cuMipmappedArrayCreate - data["__cuMipmappedArrayCreate"] = <_cyb_intptr_t>__cuMipmappedArrayCreate + data["__cuMipmappedArrayCreate"] = <intptr_t>__cuMipmappedArrayCreate global __cuMipmappedArrayGetLevel - data["__cuMipmappedArrayGetLevel"] = <_cyb_intptr_t>__cuMipmappedArrayGetLevel + data["__cuMipmappedArrayGetLevel"] = <intptr_t>__cuMipmappedArrayGetLevel global __cuMipmappedArrayDestroy - data["__cuMipmappedArrayDestroy"] = <_cyb_intptr_t>__cuMipmappedArrayDestroy + data["__cuMipmappedArrayDestroy"] = <intptr_t>__cuMipmappedArrayDestroy global __cuMemGetHandleForAddressRange - data["__cuMemGetHandleForAddressRange"] = <_cyb_intptr_t>__cuMemGetHandleForAddressRange + data["__cuMemGetHandleForAddressRange"] = <intptr_t>__cuMemGetHandleForAddressRange global __cuMemBatchDecompressAsync - data["__cuMemBatchDecompressAsync"] = <_cyb_intptr_t>__cuMemBatchDecompressAsync + data["__cuMemBatchDecompressAsync"] = <intptr_t>__cuMemBatchDecompressAsync global __cuMemAddressReserve - data["__cuMemAddressReserve"] = <_cyb_intptr_t>__cuMemAddressReserve + data["__cuMemAddressReserve"] = <intptr_t>__cuMemAddressReserve global __cuMemAddressFree - data["__cuMemAddressFree"] = <_cyb_intptr_t>__cuMemAddressFree + data["__cuMemAddressFree"] = <intptr_t>__cuMemAddressFree global __cuMemCreate - data["__cuMemCreate"] = <_cyb_intptr_t>__cuMemCreate + data["__cuMemCreate"] = <intptr_t>__cuMemCreate global __cuMemRelease - data["__cuMemRelease"] = <_cyb_intptr_t>__cuMemRelease + data["__cuMemRelease"] = <intptr_t>__cuMemRelease global __cuMemMap - data["__cuMemMap"] = <_cyb_intptr_t>__cuMemMap + data["__cuMemMap"] = <intptr_t>__cuMemMap global __cuMemMapArrayAsync - data["__cuMemMapArrayAsync"] = <_cyb_intptr_t>__cuMemMapArrayAsync + data["__cuMemMapArrayAsync"] = <intptr_t>__cuMemMapArrayAsync global __cuMemUnmap - data["__cuMemUnmap"] = <_cyb_intptr_t>__cuMemUnmap + data["__cuMemUnmap"] = <intptr_t>__cuMemUnmap global __cuMemSetAccess - data["__cuMemSetAccess"] = <_cyb_intptr_t>__cuMemSetAccess + data["__cuMemSetAccess"] = <intptr_t>__cuMemSetAccess global __cuMemGetAccess - data["__cuMemGetAccess"] = <_cyb_intptr_t>__cuMemGetAccess + data["__cuMemGetAccess"] = <intptr_t>__cuMemGetAccess global __cuMemExportToShareableHandle - data["__cuMemExportToShareableHandle"] = <_cyb_intptr_t>__cuMemExportToShareableHandle + data["__cuMemExportToShareableHandle"] = <intptr_t>__cuMemExportToShareableHandle global __cuMemImportFromShareableHandle - data["__cuMemImportFromShareableHandle"] = <_cyb_intptr_t>__cuMemImportFromShareableHandle + data["__cuMemImportFromShareableHandle"] = <intptr_t>__cuMemImportFromShareableHandle global __cuMemGetAllocationGranularity - data["__cuMemGetAllocationGranularity"] = <_cyb_intptr_t>__cuMemGetAllocationGranularity + data["__cuMemGetAllocationGranularity"] = <intptr_t>__cuMemGetAllocationGranularity global __cuMemGetAllocationPropertiesFromHandle - data["__cuMemGetAllocationPropertiesFromHandle"] = <_cyb_intptr_t>__cuMemGetAllocationPropertiesFromHandle + data["__cuMemGetAllocationPropertiesFromHandle"] = <intptr_t>__cuMemGetAllocationPropertiesFromHandle global __cuMemRetainAllocationHandle - data["__cuMemRetainAllocationHandle"] = <_cyb_intptr_t>__cuMemRetainAllocationHandle + data["__cuMemRetainAllocationHandle"] = <intptr_t>__cuMemRetainAllocationHandle global __cuMemFreeAsync - data["__cuMemFreeAsync"] = <_cyb_intptr_t>__cuMemFreeAsync + data["__cuMemFreeAsync"] = <intptr_t>__cuMemFreeAsync global __cuMemAllocAsync - data["__cuMemAllocAsync"] = <_cyb_intptr_t>__cuMemAllocAsync + data["__cuMemAllocAsync"] = <intptr_t>__cuMemAllocAsync global __cuMemPoolTrimTo - data["__cuMemPoolTrimTo"] = <_cyb_intptr_t>__cuMemPoolTrimTo + data["__cuMemPoolTrimTo"] = <intptr_t>__cuMemPoolTrimTo global __cuMemPoolSetAttribute - data["__cuMemPoolSetAttribute"] = <_cyb_intptr_t>__cuMemPoolSetAttribute + data["__cuMemPoolSetAttribute"] = <intptr_t>__cuMemPoolSetAttribute global __cuMemPoolGetAttribute - data["__cuMemPoolGetAttribute"] = <_cyb_intptr_t>__cuMemPoolGetAttribute + data["__cuMemPoolGetAttribute"] = <intptr_t>__cuMemPoolGetAttribute global __cuMemPoolSetAccess - data["__cuMemPoolSetAccess"] = <_cyb_intptr_t>__cuMemPoolSetAccess + data["__cuMemPoolSetAccess"] = <intptr_t>__cuMemPoolSetAccess global __cuMemPoolGetAccess - data["__cuMemPoolGetAccess"] = <_cyb_intptr_t>__cuMemPoolGetAccess + data["__cuMemPoolGetAccess"] = <intptr_t>__cuMemPoolGetAccess global __cuMemPoolCreate - data["__cuMemPoolCreate"] = <_cyb_intptr_t>__cuMemPoolCreate + data["__cuMemPoolCreate"] = <intptr_t>__cuMemPoolCreate global __cuMemPoolDestroy - data["__cuMemPoolDestroy"] = <_cyb_intptr_t>__cuMemPoolDestroy + data["__cuMemPoolDestroy"] = <intptr_t>__cuMemPoolDestroy global __cuMemAllocFromPoolAsync - data["__cuMemAllocFromPoolAsync"] = <_cyb_intptr_t>__cuMemAllocFromPoolAsync + data["__cuMemAllocFromPoolAsync"] = <intptr_t>__cuMemAllocFromPoolAsync global __cuMemPoolExportToShareableHandle - data["__cuMemPoolExportToShareableHandle"] = <_cyb_intptr_t>__cuMemPoolExportToShareableHandle + data["__cuMemPoolExportToShareableHandle"] = <intptr_t>__cuMemPoolExportToShareableHandle global __cuMemPoolImportFromShareableHandle - data["__cuMemPoolImportFromShareableHandle"] = <_cyb_intptr_t>__cuMemPoolImportFromShareableHandle + data["__cuMemPoolImportFromShareableHandle"] = <intptr_t>__cuMemPoolImportFromShareableHandle global __cuMemPoolExportPointer - data["__cuMemPoolExportPointer"] = <_cyb_intptr_t>__cuMemPoolExportPointer + data["__cuMemPoolExportPointer"] = <intptr_t>__cuMemPoolExportPointer global __cuMemPoolImportPointer - data["__cuMemPoolImportPointer"] = <_cyb_intptr_t>__cuMemPoolImportPointer + data["__cuMemPoolImportPointer"] = <intptr_t>__cuMemPoolImportPointer global __cuMulticastCreate - data["__cuMulticastCreate"] = <_cyb_intptr_t>__cuMulticastCreate + data["__cuMulticastCreate"] = <intptr_t>__cuMulticastCreate global __cuMulticastAddDevice - data["__cuMulticastAddDevice"] = <_cyb_intptr_t>__cuMulticastAddDevice + data["__cuMulticastAddDevice"] = <intptr_t>__cuMulticastAddDevice global __cuMulticastBindMem - data["__cuMulticastBindMem"] = <_cyb_intptr_t>__cuMulticastBindMem + data["__cuMulticastBindMem"] = <intptr_t>__cuMulticastBindMem global __cuMulticastBindAddr - data["__cuMulticastBindAddr"] = <_cyb_intptr_t>__cuMulticastBindAddr + data["__cuMulticastBindAddr"] = <intptr_t>__cuMulticastBindAddr global __cuMulticastUnbind - data["__cuMulticastUnbind"] = <_cyb_intptr_t>__cuMulticastUnbind + data["__cuMulticastUnbind"] = <intptr_t>__cuMulticastUnbind global __cuMulticastGetGranularity - data["__cuMulticastGetGranularity"] = <_cyb_intptr_t>__cuMulticastGetGranularity + data["__cuMulticastGetGranularity"] = <intptr_t>__cuMulticastGetGranularity global __cuPointerGetAttribute - data["__cuPointerGetAttribute"] = <_cyb_intptr_t>__cuPointerGetAttribute + data["__cuPointerGetAttribute"] = <intptr_t>__cuPointerGetAttribute global __cuMemPrefetchAsync_v2 - data["__cuMemPrefetchAsync_v2"] = <_cyb_intptr_t>__cuMemPrefetchAsync_v2 + data["__cuMemPrefetchAsync_v2"] = <intptr_t>__cuMemPrefetchAsync_v2 global __cuMemAdvise_v2 - data["__cuMemAdvise_v2"] = <_cyb_intptr_t>__cuMemAdvise_v2 + data["__cuMemAdvise_v2"] = <intptr_t>__cuMemAdvise_v2 global __cuMemRangeGetAttribute - data["__cuMemRangeGetAttribute"] = <_cyb_intptr_t>__cuMemRangeGetAttribute + data["__cuMemRangeGetAttribute"] = <intptr_t>__cuMemRangeGetAttribute global __cuMemRangeGetAttributes - data["__cuMemRangeGetAttributes"] = <_cyb_intptr_t>__cuMemRangeGetAttributes + data["__cuMemRangeGetAttributes"] = <intptr_t>__cuMemRangeGetAttributes global __cuPointerSetAttribute - data["__cuPointerSetAttribute"] = <_cyb_intptr_t>__cuPointerSetAttribute + data["__cuPointerSetAttribute"] = <intptr_t>__cuPointerSetAttribute global __cuPointerGetAttributes - data["__cuPointerGetAttributes"] = <_cyb_intptr_t>__cuPointerGetAttributes + data["__cuPointerGetAttributes"] = <intptr_t>__cuPointerGetAttributes global __cuStreamCreate - data["__cuStreamCreate"] = <_cyb_intptr_t>__cuStreamCreate + data["__cuStreamCreate"] = <intptr_t>__cuStreamCreate global __cuStreamCreateWithPriority - data["__cuStreamCreateWithPriority"] = <_cyb_intptr_t>__cuStreamCreateWithPriority + data["__cuStreamCreateWithPriority"] = <intptr_t>__cuStreamCreateWithPriority global __cuStreamGetPriority - data["__cuStreamGetPriority"] = <_cyb_intptr_t>__cuStreamGetPriority + data["__cuStreamGetPriority"] = <intptr_t>__cuStreamGetPriority global __cuStreamGetDevice - data["__cuStreamGetDevice"] = <_cyb_intptr_t>__cuStreamGetDevice + data["__cuStreamGetDevice"] = <intptr_t>__cuStreamGetDevice global __cuStreamGetFlags - data["__cuStreamGetFlags"] = <_cyb_intptr_t>__cuStreamGetFlags + data["__cuStreamGetFlags"] = <intptr_t>__cuStreamGetFlags global __cuStreamGetId - data["__cuStreamGetId"] = <_cyb_intptr_t>__cuStreamGetId + data["__cuStreamGetId"] = <intptr_t>__cuStreamGetId global __cuStreamGetCtx - data["__cuStreamGetCtx"] = <_cyb_intptr_t>__cuStreamGetCtx + data["__cuStreamGetCtx"] = <intptr_t>__cuStreamGetCtx global __cuStreamGetCtx_v2 - data["__cuStreamGetCtx_v2"] = <_cyb_intptr_t>__cuStreamGetCtx_v2 + data["__cuStreamGetCtx_v2"] = <intptr_t>__cuStreamGetCtx_v2 global __cuStreamWaitEvent - data["__cuStreamWaitEvent"] = <_cyb_intptr_t>__cuStreamWaitEvent + data["__cuStreamWaitEvent"] = <intptr_t>__cuStreamWaitEvent global __cuStreamAddCallback - data["__cuStreamAddCallback"] = <_cyb_intptr_t>__cuStreamAddCallback + data["__cuStreamAddCallback"] = <intptr_t>__cuStreamAddCallback global __cuStreamBeginCapture_v2 - data["__cuStreamBeginCapture_v2"] = <_cyb_intptr_t>__cuStreamBeginCapture_v2 + data["__cuStreamBeginCapture_v2"] = <intptr_t>__cuStreamBeginCapture_v2 global __cuStreamBeginCaptureToGraph - data["__cuStreamBeginCaptureToGraph"] = <_cyb_intptr_t>__cuStreamBeginCaptureToGraph + data["__cuStreamBeginCaptureToGraph"] = <intptr_t>__cuStreamBeginCaptureToGraph global __cuThreadExchangeStreamCaptureMode - data["__cuThreadExchangeStreamCaptureMode"] = <_cyb_intptr_t>__cuThreadExchangeStreamCaptureMode + data["__cuThreadExchangeStreamCaptureMode"] = <intptr_t>__cuThreadExchangeStreamCaptureMode global __cuStreamEndCapture - data["__cuStreamEndCapture"] = <_cyb_intptr_t>__cuStreamEndCapture + data["__cuStreamEndCapture"] = <intptr_t>__cuStreamEndCapture global __cuStreamIsCapturing - data["__cuStreamIsCapturing"] = <_cyb_intptr_t>__cuStreamIsCapturing + data["__cuStreamIsCapturing"] = <intptr_t>__cuStreamIsCapturing global __cuStreamGetCaptureInfo_v2 - data["__cuStreamGetCaptureInfo_v2"] = <_cyb_intptr_t>__cuStreamGetCaptureInfo_v2 + data["__cuStreamGetCaptureInfo_v2"] = <intptr_t>__cuStreamGetCaptureInfo_v2 global __cuStreamGetCaptureInfo_v3 - data["__cuStreamGetCaptureInfo_v3"] = <_cyb_intptr_t>__cuStreamGetCaptureInfo_v3 + data["__cuStreamGetCaptureInfo_v3"] = <intptr_t>__cuStreamGetCaptureInfo_v3 global __cuStreamUpdateCaptureDependencies_v2 - data["__cuStreamUpdateCaptureDependencies_v2"] = <_cyb_intptr_t>__cuStreamUpdateCaptureDependencies_v2 + data["__cuStreamUpdateCaptureDependencies_v2"] = <intptr_t>__cuStreamUpdateCaptureDependencies_v2 global __cuStreamAttachMemAsync - data["__cuStreamAttachMemAsync"] = <_cyb_intptr_t>__cuStreamAttachMemAsync + data["__cuStreamAttachMemAsync"] = <intptr_t>__cuStreamAttachMemAsync global __cuStreamQuery - data["__cuStreamQuery"] = <_cyb_intptr_t>__cuStreamQuery + data["__cuStreamQuery"] = <intptr_t>__cuStreamQuery global __cuStreamSynchronize - data["__cuStreamSynchronize"] = <_cyb_intptr_t>__cuStreamSynchronize + data["__cuStreamSynchronize"] = <intptr_t>__cuStreamSynchronize global __cuStreamDestroy_v2 - data["__cuStreamDestroy_v2"] = <_cyb_intptr_t>__cuStreamDestroy_v2 + data["__cuStreamDestroy_v2"] = <intptr_t>__cuStreamDestroy_v2 global __cuStreamCopyAttributes - data["__cuStreamCopyAttributes"] = <_cyb_intptr_t>__cuStreamCopyAttributes + data["__cuStreamCopyAttributes"] = <intptr_t>__cuStreamCopyAttributes global __cuStreamGetAttribute - data["__cuStreamGetAttribute"] = <_cyb_intptr_t>__cuStreamGetAttribute + data["__cuStreamGetAttribute"] = <intptr_t>__cuStreamGetAttribute global __cuStreamSetAttribute - data["__cuStreamSetAttribute"] = <_cyb_intptr_t>__cuStreamSetAttribute + data["__cuStreamSetAttribute"] = <intptr_t>__cuStreamSetAttribute global __cuEventCreate - data["__cuEventCreate"] = <_cyb_intptr_t>__cuEventCreate + data["__cuEventCreate"] = <intptr_t>__cuEventCreate global __cuEventRecord - data["__cuEventRecord"] = <_cyb_intptr_t>__cuEventRecord + data["__cuEventRecord"] = <intptr_t>__cuEventRecord global __cuEventRecordWithFlags - data["__cuEventRecordWithFlags"] = <_cyb_intptr_t>__cuEventRecordWithFlags + data["__cuEventRecordWithFlags"] = <intptr_t>__cuEventRecordWithFlags global __cuEventQuery - data["__cuEventQuery"] = <_cyb_intptr_t>__cuEventQuery + data["__cuEventQuery"] = <intptr_t>__cuEventQuery global __cuEventSynchronize - data["__cuEventSynchronize"] = <_cyb_intptr_t>__cuEventSynchronize + data["__cuEventSynchronize"] = <intptr_t>__cuEventSynchronize global __cuEventDestroy_v2 - data["__cuEventDestroy_v2"] = <_cyb_intptr_t>__cuEventDestroy_v2 + data["__cuEventDestroy_v2"] = <intptr_t>__cuEventDestroy_v2 global __cuEventElapsedTime_v2 - data["__cuEventElapsedTime_v2"] = <_cyb_intptr_t>__cuEventElapsedTime_v2 + data["__cuEventElapsedTime_v2"] = <intptr_t>__cuEventElapsedTime_v2 global __cuImportExternalMemory - data["__cuImportExternalMemory"] = <_cyb_intptr_t>__cuImportExternalMemory + data["__cuImportExternalMemory"] = <intptr_t>__cuImportExternalMemory global __cuExternalMemoryGetMappedBuffer - data["__cuExternalMemoryGetMappedBuffer"] = <_cyb_intptr_t>__cuExternalMemoryGetMappedBuffer + data["__cuExternalMemoryGetMappedBuffer"] = <intptr_t>__cuExternalMemoryGetMappedBuffer global __cuExternalMemoryGetMappedMipmappedArray - data["__cuExternalMemoryGetMappedMipmappedArray"] = <_cyb_intptr_t>__cuExternalMemoryGetMappedMipmappedArray + data["__cuExternalMemoryGetMappedMipmappedArray"] = <intptr_t>__cuExternalMemoryGetMappedMipmappedArray global __cuDestroyExternalMemory - data["__cuDestroyExternalMemory"] = <_cyb_intptr_t>__cuDestroyExternalMemory + data["__cuDestroyExternalMemory"] = <intptr_t>__cuDestroyExternalMemory global __cuImportExternalSemaphore - data["__cuImportExternalSemaphore"] = <_cyb_intptr_t>__cuImportExternalSemaphore + data["__cuImportExternalSemaphore"] = <intptr_t>__cuImportExternalSemaphore global __cuSignalExternalSemaphoresAsync - data["__cuSignalExternalSemaphoresAsync"] = <_cyb_intptr_t>__cuSignalExternalSemaphoresAsync + data["__cuSignalExternalSemaphoresAsync"] = <intptr_t>__cuSignalExternalSemaphoresAsync global __cuWaitExternalSemaphoresAsync - data["__cuWaitExternalSemaphoresAsync"] = <_cyb_intptr_t>__cuWaitExternalSemaphoresAsync + data["__cuWaitExternalSemaphoresAsync"] = <intptr_t>__cuWaitExternalSemaphoresAsync global __cuDestroyExternalSemaphore - data["__cuDestroyExternalSemaphore"] = <_cyb_intptr_t>__cuDestroyExternalSemaphore + data["__cuDestroyExternalSemaphore"] = <intptr_t>__cuDestroyExternalSemaphore global __cuStreamWaitValue32_v2 - data["__cuStreamWaitValue32_v2"] = <_cyb_intptr_t>__cuStreamWaitValue32_v2 + data["__cuStreamWaitValue32_v2"] = <intptr_t>__cuStreamWaitValue32_v2 global __cuStreamWaitValue64_v2 - data["__cuStreamWaitValue64_v2"] = <_cyb_intptr_t>__cuStreamWaitValue64_v2 + data["__cuStreamWaitValue64_v2"] = <intptr_t>__cuStreamWaitValue64_v2 global __cuStreamWriteValue32_v2 - data["__cuStreamWriteValue32_v2"] = <_cyb_intptr_t>__cuStreamWriteValue32_v2 + data["__cuStreamWriteValue32_v2"] = <intptr_t>__cuStreamWriteValue32_v2 global __cuStreamWriteValue64_v2 - data["__cuStreamWriteValue64_v2"] = <_cyb_intptr_t>__cuStreamWriteValue64_v2 + data["__cuStreamWriteValue64_v2"] = <intptr_t>__cuStreamWriteValue64_v2 global __cuStreamBatchMemOp_v2 - data["__cuStreamBatchMemOp_v2"] = <_cyb_intptr_t>__cuStreamBatchMemOp_v2 + data["__cuStreamBatchMemOp_v2"] = <intptr_t>__cuStreamBatchMemOp_v2 global __cuFuncGetAttribute - data["__cuFuncGetAttribute"] = <_cyb_intptr_t>__cuFuncGetAttribute + data["__cuFuncGetAttribute"] = <intptr_t>__cuFuncGetAttribute global __cuFuncSetAttribute - data["__cuFuncSetAttribute"] = <_cyb_intptr_t>__cuFuncSetAttribute + data["__cuFuncSetAttribute"] = <intptr_t>__cuFuncSetAttribute global __cuFuncSetCacheConfig - data["__cuFuncSetCacheConfig"] = <_cyb_intptr_t>__cuFuncSetCacheConfig + data["__cuFuncSetCacheConfig"] = <intptr_t>__cuFuncSetCacheConfig global __cuFuncGetModule - data["__cuFuncGetModule"] = <_cyb_intptr_t>__cuFuncGetModule + data["__cuFuncGetModule"] = <intptr_t>__cuFuncGetModule global __cuFuncGetName - data["__cuFuncGetName"] = <_cyb_intptr_t>__cuFuncGetName + data["__cuFuncGetName"] = <intptr_t>__cuFuncGetName global __cuFuncGetParamInfo - data["__cuFuncGetParamInfo"] = <_cyb_intptr_t>__cuFuncGetParamInfo + data["__cuFuncGetParamInfo"] = <intptr_t>__cuFuncGetParamInfo global __cuFuncIsLoaded - data["__cuFuncIsLoaded"] = <_cyb_intptr_t>__cuFuncIsLoaded + data["__cuFuncIsLoaded"] = <intptr_t>__cuFuncIsLoaded global __cuFuncLoad - data["__cuFuncLoad"] = <_cyb_intptr_t>__cuFuncLoad + data["__cuFuncLoad"] = <intptr_t>__cuFuncLoad global __cuLaunchKernel - data["__cuLaunchKernel"] = <_cyb_intptr_t>__cuLaunchKernel + data["__cuLaunchKernel"] = <intptr_t>__cuLaunchKernel global __cuLaunchKernelEx - data["__cuLaunchKernelEx"] = <_cyb_intptr_t>__cuLaunchKernelEx + data["__cuLaunchKernelEx"] = <intptr_t>__cuLaunchKernelEx global __cuLaunchCooperativeKernel - data["__cuLaunchCooperativeKernel"] = <_cyb_intptr_t>__cuLaunchCooperativeKernel + data["__cuLaunchCooperativeKernel"] = <intptr_t>__cuLaunchCooperativeKernel global __cuLaunchCooperativeKernelMultiDevice - data["__cuLaunchCooperativeKernelMultiDevice"] = <_cyb_intptr_t>__cuLaunchCooperativeKernelMultiDevice + data["__cuLaunchCooperativeKernelMultiDevice"] = <intptr_t>__cuLaunchCooperativeKernelMultiDevice global __cuLaunchHostFunc - data["__cuLaunchHostFunc"] = <_cyb_intptr_t>__cuLaunchHostFunc + data["__cuLaunchHostFunc"] = <intptr_t>__cuLaunchHostFunc global __cuFuncSetBlockShape - data["__cuFuncSetBlockShape"] = <_cyb_intptr_t>__cuFuncSetBlockShape + data["__cuFuncSetBlockShape"] = <intptr_t>__cuFuncSetBlockShape global __cuFuncSetSharedSize - data["__cuFuncSetSharedSize"] = <_cyb_intptr_t>__cuFuncSetSharedSize + data["__cuFuncSetSharedSize"] = <intptr_t>__cuFuncSetSharedSize global __cuParamSetSize - data["__cuParamSetSize"] = <_cyb_intptr_t>__cuParamSetSize + data["__cuParamSetSize"] = <intptr_t>__cuParamSetSize global __cuParamSeti - data["__cuParamSeti"] = <_cyb_intptr_t>__cuParamSeti + data["__cuParamSeti"] = <intptr_t>__cuParamSeti global __cuParamSetf - data["__cuParamSetf"] = <_cyb_intptr_t>__cuParamSetf + data["__cuParamSetf"] = <intptr_t>__cuParamSetf global __cuParamSetv - data["__cuParamSetv"] = <_cyb_intptr_t>__cuParamSetv + data["__cuParamSetv"] = <intptr_t>__cuParamSetv global __cuLaunch - data["__cuLaunch"] = <_cyb_intptr_t>__cuLaunch + data["__cuLaunch"] = <intptr_t>__cuLaunch global __cuLaunchGrid - data["__cuLaunchGrid"] = <_cyb_intptr_t>__cuLaunchGrid + data["__cuLaunchGrid"] = <intptr_t>__cuLaunchGrid global __cuLaunchGridAsync - data["__cuLaunchGridAsync"] = <_cyb_intptr_t>__cuLaunchGridAsync + data["__cuLaunchGridAsync"] = <intptr_t>__cuLaunchGridAsync global __cuParamSetTexRef - data["__cuParamSetTexRef"] = <_cyb_intptr_t>__cuParamSetTexRef + data["__cuParamSetTexRef"] = <intptr_t>__cuParamSetTexRef global __cuFuncSetSharedMemConfig - data["__cuFuncSetSharedMemConfig"] = <_cyb_intptr_t>__cuFuncSetSharedMemConfig + data["__cuFuncSetSharedMemConfig"] = <intptr_t>__cuFuncSetSharedMemConfig global __cuGraphCreate - data["__cuGraphCreate"] = <_cyb_intptr_t>__cuGraphCreate + data["__cuGraphCreate"] = <intptr_t>__cuGraphCreate global __cuGraphAddKernelNode_v2 - data["__cuGraphAddKernelNode_v2"] = <_cyb_intptr_t>__cuGraphAddKernelNode_v2 + data["__cuGraphAddKernelNode_v2"] = <intptr_t>__cuGraphAddKernelNode_v2 global __cuGraphKernelNodeGetParams_v2 - data["__cuGraphKernelNodeGetParams_v2"] = <_cyb_intptr_t>__cuGraphKernelNodeGetParams_v2 + data["__cuGraphKernelNodeGetParams_v2"] = <intptr_t>__cuGraphKernelNodeGetParams_v2 global __cuGraphKernelNodeSetParams_v2 - data["__cuGraphKernelNodeSetParams_v2"] = <_cyb_intptr_t>__cuGraphKernelNodeSetParams_v2 + data["__cuGraphKernelNodeSetParams_v2"] = <intptr_t>__cuGraphKernelNodeSetParams_v2 global __cuGraphAddMemcpyNode - data["__cuGraphAddMemcpyNode"] = <_cyb_intptr_t>__cuGraphAddMemcpyNode + data["__cuGraphAddMemcpyNode"] = <intptr_t>__cuGraphAddMemcpyNode global __cuGraphMemcpyNodeGetParams - data["__cuGraphMemcpyNodeGetParams"] = <_cyb_intptr_t>__cuGraphMemcpyNodeGetParams + data["__cuGraphMemcpyNodeGetParams"] = <intptr_t>__cuGraphMemcpyNodeGetParams global __cuGraphMemcpyNodeSetParams - data["__cuGraphMemcpyNodeSetParams"] = <_cyb_intptr_t>__cuGraphMemcpyNodeSetParams + data["__cuGraphMemcpyNodeSetParams"] = <intptr_t>__cuGraphMemcpyNodeSetParams global __cuGraphAddMemsetNode - data["__cuGraphAddMemsetNode"] = <_cyb_intptr_t>__cuGraphAddMemsetNode + data["__cuGraphAddMemsetNode"] = <intptr_t>__cuGraphAddMemsetNode global __cuGraphMemsetNodeGetParams - data["__cuGraphMemsetNodeGetParams"] = <_cyb_intptr_t>__cuGraphMemsetNodeGetParams + data["__cuGraphMemsetNodeGetParams"] = <intptr_t>__cuGraphMemsetNodeGetParams global __cuGraphMemsetNodeSetParams - data["__cuGraphMemsetNodeSetParams"] = <_cyb_intptr_t>__cuGraphMemsetNodeSetParams + data["__cuGraphMemsetNodeSetParams"] = <intptr_t>__cuGraphMemsetNodeSetParams global __cuGraphAddHostNode - data["__cuGraphAddHostNode"] = <_cyb_intptr_t>__cuGraphAddHostNode + data["__cuGraphAddHostNode"] = <intptr_t>__cuGraphAddHostNode global __cuGraphHostNodeGetParams - data["__cuGraphHostNodeGetParams"] = <_cyb_intptr_t>__cuGraphHostNodeGetParams + data["__cuGraphHostNodeGetParams"] = <intptr_t>__cuGraphHostNodeGetParams global __cuGraphHostNodeSetParams - data["__cuGraphHostNodeSetParams"] = <_cyb_intptr_t>__cuGraphHostNodeSetParams + data["__cuGraphHostNodeSetParams"] = <intptr_t>__cuGraphHostNodeSetParams global __cuGraphAddChildGraphNode - data["__cuGraphAddChildGraphNode"] = <_cyb_intptr_t>__cuGraphAddChildGraphNode + data["__cuGraphAddChildGraphNode"] = <intptr_t>__cuGraphAddChildGraphNode global __cuGraphChildGraphNodeGetGraph - data["__cuGraphChildGraphNodeGetGraph"] = <_cyb_intptr_t>__cuGraphChildGraphNodeGetGraph + data["__cuGraphChildGraphNodeGetGraph"] = <intptr_t>__cuGraphChildGraphNodeGetGraph global __cuGraphAddEmptyNode - data["__cuGraphAddEmptyNode"] = <_cyb_intptr_t>__cuGraphAddEmptyNode + data["__cuGraphAddEmptyNode"] = <intptr_t>__cuGraphAddEmptyNode global __cuGraphAddEventRecordNode - data["__cuGraphAddEventRecordNode"] = <_cyb_intptr_t>__cuGraphAddEventRecordNode + data["__cuGraphAddEventRecordNode"] = <intptr_t>__cuGraphAddEventRecordNode global __cuGraphEventRecordNodeGetEvent - data["__cuGraphEventRecordNodeGetEvent"] = <_cyb_intptr_t>__cuGraphEventRecordNodeGetEvent + data["__cuGraphEventRecordNodeGetEvent"] = <intptr_t>__cuGraphEventRecordNodeGetEvent global __cuGraphEventRecordNodeSetEvent - data["__cuGraphEventRecordNodeSetEvent"] = <_cyb_intptr_t>__cuGraphEventRecordNodeSetEvent + data["__cuGraphEventRecordNodeSetEvent"] = <intptr_t>__cuGraphEventRecordNodeSetEvent global __cuGraphAddEventWaitNode - data["__cuGraphAddEventWaitNode"] = <_cyb_intptr_t>__cuGraphAddEventWaitNode + data["__cuGraphAddEventWaitNode"] = <intptr_t>__cuGraphAddEventWaitNode global __cuGraphEventWaitNodeGetEvent - data["__cuGraphEventWaitNodeGetEvent"] = <_cyb_intptr_t>__cuGraphEventWaitNodeGetEvent + data["__cuGraphEventWaitNodeGetEvent"] = <intptr_t>__cuGraphEventWaitNodeGetEvent global __cuGraphEventWaitNodeSetEvent - data["__cuGraphEventWaitNodeSetEvent"] = <_cyb_intptr_t>__cuGraphEventWaitNodeSetEvent + data["__cuGraphEventWaitNodeSetEvent"] = <intptr_t>__cuGraphEventWaitNodeSetEvent global __cuGraphAddExternalSemaphoresSignalNode - data["__cuGraphAddExternalSemaphoresSignalNode"] = <_cyb_intptr_t>__cuGraphAddExternalSemaphoresSignalNode + data["__cuGraphAddExternalSemaphoresSignalNode"] = <intptr_t>__cuGraphAddExternalSemaphoresSignalNode global __cuGraphExternalSemaphoresSignalNodeGetParams - data["__cuGraphExternalSemaphoresSignalNodeGetParams"] = <_cyb_intptr_t>__cuGraphExternalSemaphoresSignalNodeGetParams + data["__cuGraphExternalSemaphoresSignalNodeGetParams"] = <intptr_t>__cuGraphExternalSemaphoresSignalNodeGetParams global __cuGraphExternalSemaphoresSignalNodeSetParams - data["__cuGraphExternalSemaphoresSignalNodeSetParams"] = <_cyb_intptr_t>__cuGraphExternalSemaphoresSignalNodeSetParams + data["__cuGraphExternalSemaphoresSignalNodeSetParams"] = <intptr_t>__cuGraphExternalSemaphoresSignalNodeSetParams global __cuGraphAddExternalSemaphoresWaitNode - data["__cuGraphAddExternalSemaphoresWaitNode"] = <_cyb_intptr_t>__cuGraphAddExternalSemaphoresWaitNode + data["__cuGraphAddExternalSemaphoresWaitNode"] = <intptr_t>__cuGraphAddExternalSemaphoresWaitNode global __cuGraphExternalSemaphoresWaitNodeGetParams - data["__cuGraphExternalSemaphoresWaitNodeGetParams"] = <_cyb_intptr_t>__cuGraphExternalSemaphoresWaitNodeGetParams + data["__cuGraphExternalSemaphoresWaitNodeGetParams"] = <intptr_t>__cuGraphExternalSemaphoresWaitNodeGetParams global __cuGraphExternalSemaphoresWaitNodeSetParams - data["__cuGraphExternalSemaphoresWaitNodeSetParams"] = <_cyb_intptr_t>__cuGraphExternalSemaphoresWaitNodeSetParams + data["__cuGraphExternalSemaphoresWaitNodeSetParams"] = <intptr_t>__cuGraphExternalSemaphoresWaitNodeSetParams global __cuGraphAddBatchMemOpNode - data["__cuGraphAddBatchMemOpNode"] = <_cyb_intptr_t>__cuGraphAddBatchMemOpNode + data["__cuGraphAddBatchMemOpNode"] = <intptr_t>__cuGraphAddBatchMemOpNode global __cuGraphBatchMemOpNodeGetParams - data["__cuGraphBatchMemOpNodeGetParams"] = <_cyb_intptr_t>__cuGraphBatchMemOpNodeGetParams + data["__cuGraphBatchMemOpNodeGetParams"] = <intptr_t>__cuGraphBatchMemOpNodeGetParams global __cuGraphBatchMemOpNodeSetParams - data["__cuGraphBatchMemOpNodeSetParams"] = <_cyb_intptr_t>__cuGraphBatchMemOpNodeSetParams + data["__cuGraphBatchMemOpNodeSetParams"] = <intptr_t>__cuGraphBatchMemOpNodeSetParams global __cuGraphExecBatchMemOpNodeSetParams - data["__cuGraphExecBatchMemOpNodeSetParams"] = <_cyb_intptr_t>__cuGraphExecBatchMemOpNodeSetParams + data["__cuGraphExecBatchMemOpNodeSetParams"] = <intptr_t>__cuGraphExecBatchMemOpNodeSetParams global __cuGraphAddMemAllocNode - data["__cuGraphAddMemAllocNode"] = <_cyb_intptr_t>__cuGraphAddMemAllocNode + data["__cuGraphAddMemAllocNode"] = <intptr_t>__cuGraphAddMemAllocNode global __cuGraphMemAllocNodeGetParams - data["__cuGraphMemAllocNodeGetParams"] = <_cyb_intptr_t>__cuGraphMemAllocNodeGetParams + data["__cuGraphMemAllocNodeGetParams"] = <intptr_t>__cuGraphMemAllocNodeGetParams global __cuGraphAddMemFreeNode - data["__cuGraphAddMemFreeNode"] = <_cyb_intptr_t>__cuGraphAddMemFreeNode + data["__cuGraphAddMemFreeNode"] = <intptr_t>__cuGraphAddMemFreeNode global __cuGraphMemFreeNodeGetParams - data["__cuGraphMemFreeNodeGetParams"] = <_cyb_intptr_t>__cuGraphMemFreeNodeGetParams + data["__cuGraphMemFreeNodeGetParams"] = <intptr_t>__cuGraphMemFreeNodeGetParams global __cuDeviceGraphMemTrim - data["__cuDeviceGraphMemTrim"] = <_cyb_intptr_t>__cuDeviceGraphMemTrim + data["__cuDeviceGraphMemTrim"] = <intptr_t>__cuDeviceGraphMemTrim global __cuDeviceGetGraphMemAttribute - data["__cuDeviceGetGraphMemAttribute"] = <_cyb_intptr_t>__cuDeviceGetGraphMemAttribute + data["__cuDeviceGetGraphMemAttribute"] = <intptr_t>__cuDeviceGetGraphMemAttribute global __cuDeviceSetGraphMemAttribute - data["__cuDeviceSetGraphMemAttribute"] = <_cyb_intptr_t>__cuDeviceSetGraphMemAttribute + data["__cuDeviceSetGraphMemAttribute"] = <intptr_t>__cuDeviceSetGraphMemAttribute global __cuGraphClone - data["__cuGraphClone"] = <_cyb_intptr_t>__cuGraphClone + data["__cuGraphClone"] = <intptr_t>__cuGraphClone global __cuGraphNodeFindInClone - data["__cuGraphNodeFindInClone"] = <_cyb_intptr_t>__cuGraphNodeFindInClone + data["__cuGraphNodeFindInClone"] = <intptr_t>__cuGraphNodeFindInClone global __cuGraphNodeGetType - data["__cuGraphNodeGetType"] = <_cyb_intptr_t>__cuGraphNodeGetType + data["__cuGraphNodeGetType"] = <intptr_t>__cuGraphNodeGetType global __cuGraphGetNodes - data["__cuGraphGetNodes"] = <_cyb_intptr_t>__cuGraphGetNodes + data["__cuGraphGetNodes"] = <intptr_t>__cuGraphGetNodes global __cuGraphGetRootNodes - data["__cuGraphGetRootNodes"] = <_cyb_intptr_t>__cuGraphGetRootNodes + data["__cuGraphGetRootNodes"] = <intptr_t>__cuGraphGetRootNodes global __cuGraphGetEdges_v2 - data["__cuGraphGetEdges_v2"] = <_cyb_intptr_t>__cuGraphGetEdges_v2 + data["__cuGraphGetEdges_v2"] = <intptr_t>__cuGraphGetEdges_v2 global __cuGraphNodeGetDependencies_v2 - data["__cuGraphNodeGetDependencies_v2"] = <_cyb_intptr_t>__cuGraphNodeGetDependencies_v2 + data["__cuGraphNodeGetDependencies_v2"] = <intptr_t>__cuGraphNodeGetDependencies_v2 global __cuGraphNodeGetDependentNodes_v2 - data["__cuGraphNodeGetDependentNodes_v2"] = <_cyb_intptr_t>__cuGraphNodeGetDependentNodes_v2 + data["__cuGraphNodeGetDependentNodes_v2"] = <intptr_t>__cuGraphNodeGetDependentNodes_v2 global __cuGraphAddDependencies_v2 - data["__cuGraphAddDependencies_v2"] = <_cyb_intptr_t>__cuGraphAddDependencies_v2 + data["__cuGraphAddDependencies_v2"] = <intptr_t>__cuGraphAddDependencies_v2 global __cuGraphRemoveDependencies_v2 - data["__cuGraphRemoveDependencies_v2"] = <_cyb_intptr_t>__cuGraphRemoveDependencies_v2 + data["__cuGraphRemoveDependencies_v2"] = <intptr_t>__cuGraphRemoveDependencies_v2 global __cuGraphDestroyNode - data["__cuGraphDestroyNode"] = <_cyb_intptr_t>__cuGraphDestroyNode + data["__cuGraphDestroyNode"] = <intptr_t>__cuGraphDestroyNode global __cuGraphInstantiateWithFlags - data["__cuGraphInstantiateWithFlags"] = <_cyb_intptr_t>__cuGraphInstantiateWithFlags + data["__cuGraphInstantiateWithFlags"] = <intptr_t>__cuGraphInstantiateWithFlags global __cuGraphInstantiateWithParams - data["__cuGraphInstantiateWithParams"] = <_cyb_intptr_t>__cuGraphInstantiateWithParams + data["__cuGraphInstantiateWithParams"] = <intptr_t>__cuGraphInstantiateWithParams global __cuGraphExecGetFlags - data["__cuGraphExecGetFlags"] = <_cyb_intptr_t>__cuGraphExecGetFlags + data["__cuGraphExecGetFlags"] = <intptr_t>__cuGraphExecGetFlags global __cuGraphExecKernelNodeSetParams_v2 - data["__cuGraphExecKernelNodeSetParams_v2"] = <_cyb_intptr_t>__cuGraphExecKernelNodeSetParams_v2 + data["__cuGraphExecKernelNodeSetParams_v2"] = <intptr_t>__cuGraphExecKernelNodeSetParams_v2 global __cuGraphExecMemcpyNodeSetParams - data["__cuGraphExecMemcpyNodeSetParams"] = <_cyb_intptr_t>__cuGraphExecMemcpyNodeSetParams + data["__cuGraphExecMemcpyNodeSetParams"] = <intptr_t>__cuGraphExecMemcpyNodeSetParams global __cuGraphExecMemsetNodeSetParams - data["__cuGraphExecMemsetNodeSetParams"] = <_cyb_intptr_t>__cuGraphExecMemsetNodeSetParams + data["__cuGraphExecMemsetNodeSetParams"] = <intptr_t>__cuGraphExecMemsetNodeSetParams global __cuGraphExecHostNodeSetParams - data["__cuGraphExecHostNodeSetParams"] = <_cyb_intptr_t>__cuGraphExecHostNodeSetParams + data["__cuGraphExecHostNodeSetParams"] = <intptr_t>__cuGraphExecHostNodeSetParams global __cuGraphExecChildGraphNodeSetParams - data["__cuGraphExecChildGraphNodeSetParams"] = <_cyb_intptr_t>__cuGraphExecChildGraphNodeSetParams + data["__cuGraphExecChildGraphNodeSetParams"] = <intptr_t>__cuGraphExecChildGraphNodeSetParams global __cuGraphExecEventRecordNodeSetEvent - data["__cuGraphExecEventRecordNodeSetEvent"] = <_cyb_intptr_t>__cuGraphExecEventRecordNodeSetEvent + data["__cuGraphExecEventRecordNodeSetEvent"] = <intptr_t>__cuGraphExecEventRecordNodeSetEvent global __cuGraphExecEventWaitNodeSetEvent - data["__cuGraphExecEventWaitNodeSetEvent"] = <_cyb_intptr_t>__cuGraphExecEventWaitNodeSetEvent + data["__cuGraphExecEventWaitNodeSetEvent"] = <intptr_t>__cuGraphExecEventWaitNodeSetEvent global __cuGraphExecExternalSemaphoresSignalNodeSetParams - data["__cuGraphExecExternalSemaphoresSignalNodeSetParams"] = <_cyb_intptr_t>__cuGraphExecExternalSemaphoresSignalNodeSetParams + data["__cuGraphExecExternalSemaphoresSignalNodeSetParams"] = <intptr_t>__cuGraphExecExternalSemaphoresSignalNodeSetParams global __cuGraphExecExternalSemaphoresWaitNodeSetParams - data["__cuGraphExecExternalSemaphoresWaitNodeSetParams"] = <_cyb_intptr_t>__cuGraphExecExternalSemaphoresWaitNodeSetParams + data["__cuGraphExecExternalSemaphoresWaitNodeSetParams"] = <intptr_t>__cuGraphExecExternalSemaphoresWaitNodeSetParams global __cuGraphNodeSetEnabled - data["__cuGraphNodeSetEnabled"] = <_cyb_intptr_t>__cuGraphNodeSetEnabled + data["__cuGraphNodeSetEnabled"] = <intptr_t>__cuGraphNodeSetEnabled global __cuGraphNodeGetEnabled - data["__cuGraphNodeGetEnabled"] = <_cyb_intptr_t>__cuGraphNodeGetEnabled + data["__cuGraphNodeGetEnabled"] = <intptr_t>__cuGraphNodeGetEnabled global __cuGraphUpload - data["__cuGraphUpload"] = <_cyb_intptr_t>__cuGraphUpload + data["__cuGraphUpload"] = <intptr_t>__cuGraphUpload global __cuGraphLaunch - data["__cuGraphLaunch"] = <_cyb_intptr_t>__cuGraphLaunch + data["__cuGraphLaunch"] = <intptr_t>__cuGraphLaunch global __cuGraphExecDestroy - data["__cuGraphExecDestroy"] = <_cyb_intptr_t>__cuGraphExecDestroy + data["__cuGraphExecDestroy"] = <intptr_t>__cuGraphExecDestroy global __cuGraphDestroy - data["__cuGraphDestroy"] = <_cyb_intptr_t>__cuGraphDestroy + data["__cuGraphDestroy"] = <intptr_t>__cuGraphDestroy global __cuGraphExecUpdate_v2 - data["__cuGraphExecUpdate_v2"] = <_cyb_intptr_t>__cuGraphExecUpdate_v2 + data["__cuGraphExecUpdate_v2"] = <intptr_t>__cuGraphExecUpdate_v2 global __cuGraphKernelNodeCopyAttributes - data["__cuGraphKernelNodeCopyAttributes"] = <_cyb_intptr_t>__cuGraphKernelNodeCopyAttributes + data["__cuGraphKernelNodeCopyAttributes"] = <intptr_t>__cuGraphKernelNodeCopyAttributes global __cuGraphKernelNodeGetAttribute - data["__cuGraphKernelNodeGetAttribute"] = <_cyb_intptr_t>__cuGraphKernelNodeGetAttribute + data["__cuGraphKernelNodeGetAttribute"] = <intptr_t>__cuGraphKernelNodeGetAttribute global __cuGraphKernelNodeSetAttribute - data["__cuGraphKernelNodeSetAttribute"] = <_cyb_intptr_t>__cuGraphKernelNodeSetAttribute + data["__cuGraphKernelNodeSetAttribute"] = <intptr_t>__cuGraphKernelNodeSetAttribute global __cuGraphDebugDotPrint - data["__cuGraphDebugDotPrint"] = <_cyb_intptr_t>__cuGraphDebugDotPrint + data["__cuGraphDebugDotPrint"] = <intptr_t>__cuGraphDebugDotPrint global __cuUserObjectCreate - data["__cuUserObjectCreate"] = <_cyb_intptr_t>__cuUserObjectCreate + data["__cuUserObjectCreate"] = <intptr_t>__cuUserObjectCreate global __cuUserObjectRetain - data["__cuUserObjectRetain"] = <_cyb_intptr_t>__cuUserObjectRetain + data["__cuUserObjectRetain"] = <intptr_t>__cuUserObjectRetain global __cuUserObjectRelease - data["__cuUserObjectRelease"] = <_cyb_intptr_t>__cuUserObjectRelease + data["__cuUserObjectRelease"] = <intptr_t>__cuUserObjectRelease global __cuGraphRetainUserObject - data["__cuGraphRetainUserObject"] = <_cyb_intptr_t>__cuGraphRetainUserObject + data["__cuGraphRetainUserObject"] = <intptr_t>__cuGraphRetainUserObject global __cuGraphReleaseUserObject - data["__cuGraphReleaseUserObject"] = <_cyb_intptr_t>__cuGraphReleaseUserObject + data["__cuGraphReleaseUserObject"] = <intptr_t>__cuGraphReleaseUserObject global __cuGraphAddNode_v2 - data["__cuGraphAddNode_v2"] = <_cyb_intptr_t>__cuGraphAddNode_v2 + data["__cuGraphAddNode_v2"] = <intptr_t>__cuGraphAddNode_v2 global __cuGraphNodeSetParams - data["__cuGraphNodeSetParams"] = <_cyb_intptr_t>__cuGraphNodeSetParams + data["__cuGraphNodeSetParams"] = <intptr_t>__cuGraphNodeSetParams global __cuGraphExecNodeSetParams - data["__cuGraphExecNodeSetParams"] = <_cyb_intptr_t>__cuGraphExecNodeSetParams + data["__cuGraphExecNodeSetParams"] = <intptr_t>__cuGraphExecNodeSetParams global __cuGraphConditionalHandleCreate - data["__cuGraphConditionalHandleCreate"] = <_cyb_intptr_t>__cuGraphConditionalHandleCreate + data["__cuGraphConditionalHandleCreate"] = <intptr_t>__cuGraphConditionalHandleCreate global __cuOccupancyMaxActiveBlocksPerMultiprocessor - data["__cuOccupancyMaxActiveBlocksPerMultiprocessor"] = <_cyb_intptr_t>__cuOccupancyMaxActiveBlocksPerMultiprocessor + data["__cuOccupancyMaxActiveBlocksPerMultiprocessor"] = <intptr_t>__cuOccupancyMaxActiveBlocksPerMultiprocessor global __cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags - data["__cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags"] = <_cyb_intptr_t>__cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags + data["__cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags"] = <intptr_t>__cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags global __cuOccupancyMaxPotentialBlockSize - data["__cuOccupancyMaxPotentialBlockSize"] = <_cyb_intptr_t>__cuOccupancyMaxPotentialBlockSize + data["__cuOccupancyMaxPotentialBlockSize"] = <intptr_t>__cuOccupancyMaxPotentialBlockSize global __cuOccupancyMaxPotentialBlockSizeWithFlags - data["__cuOccupancyMaxPotentialBlockSizeWithFlags"] = <_cyb_intptr_t>__cuOccupancyMaxPotentialBlockSizeWithFlags + data["__cuOccupancyMaxPotentialBlockSizeWithFlags"] = <intptr_t>__cuOccupancyMaxPotentialBlockSizeWithFlags global __cuOccupancyAvailableDynamicSMemPerBlock - data["__cuOccupancyAvailableDynamicSMemPerBlock"] = <_cyb_intptr_t>__cuOccupancyAvailableDynamicSMemPerBlock + data["__cuOccupancyAvailableDynamicSMemPerBlock"] = <intptr_t>__cuOccupancyAvailableDynamicSMemPerBlock global __cuOccupancyMaxPotentialClusterSize - data["__cuOccupancyMaxPotentialClusterSize"] = <_cyb_intptr_t>__cuOccupancyMaxPotentialClusterSize + data["__cuOccupancyMaxPotentialClusterSize"] = <intptr_t>__cuOccupancyMaxPotentialClusterSize global __cuOccupancyMaxActiveClusters - data["__cuOccupancyMaxActiveClusters"] = <_cyb_intptr_t>__cuOccupancyMaxActiveClusters + data["__cuOccupancyMaxActiveClusters"] = <intptr_t>__cuOccupancyMaxActiveClusters global __cuTexRefSetArray - data["__cuTexRefSetArray"] = <_cyb_intptr_t>__cuTexRefSetArray + data["__cuTexRefSetArray"] = <intptr_t>__cuTexRefSetArray global __cuTexRefSetMipmappedArray - data["__cuTexRefSetMipmappedArray"] = <_cyb_intptr_t>__cuTexRefSetMipmappedArray + data["__cuTexRefSetMipmappedArray"] = <intptr_t>__cuTexRefSetMipmappedArray global __cuTexRefSetAddress_v2 - data["__cuTexRefSetAddress_v2"] = <_cyb_intptr_t>__cuTexRefSetAddress_v2 + data["__cuTexRefSetAddress_v2"] = <intptr_t>__cuTexRefSetAddress_v2 global __cuTexRefSetAddress2D_v3 - data["__cuTexRefSetAddress2D_v3"] = <_cyb_intptr_t>__cuTexRefSetAddress2D_v3 + data["__cuTexRefSetAddress2D_v3"] = <intptr_t>__cuTexRefSetAddress2D_v3 global __cuTexRefSetFormat - data["__cuTexRefSetFormat"] = <_cyb_intptr_t>__cuTexRefSetFormat + data["__cuTexRefSetFormat"] = <intptr_t>__cuTexRefSetFormat global __cuTexRefSetAddressMode - data["__cuTexRefSetAddressMode"] = <_cyb_intptr_t>__cuTexRefSetAddressMode + data["__cuTexRefSetAddressMode"] = <intptr_t>__cuTexRefSetAddressMode global __cuTexRefSetFilterMode - data["__cuTexRefSetFilterMode"] = <_cyb_intptr_t>__cuTexRefSetFilterMode + data["__cuTexRefSetFilterMode"] = <intptr_t>__cuTexRefSetFilterMode global __cuTexRefSetMipmapFilterMode - data["__cuTexRefSetMipmapFilterMode"] = <_cyb_intptr_t>__cuTexRefSetMipmapFilterMode + data["__cuTexRefSetMipmapFilterMode"] = <intptr_t>__cuTexRefSetMipmapFilterMode global __cuTexRefSetMipmapLevelBias - data["__cuTexRefSetMipmapLevelBias"] = <_cyb_intptr_t>__cuTexRefSetMipmapLevelBias + data["__cuTexRefSetMipmapLevelBias"] = <intptr_t>__cuTexRefSetMipmapLevelBias global __cuTexRefSetMipmapLevelClamp - data["__cuTexRefSetMipmapLevelClamp"] = <_cyb_intptr_t>__cuTexRefSetMipmapLevelClamp + data["__cuTexRefSetMipmapLevelClamp"] = <intptr_t>__cuTexRefSetMipmapLevelClamp global __cuTexRefSetMaxAnisotropy - data["__cuTexRefSetMaxAnisotropy"] = <_cyb_intptr_t>__cuTexRefSetMaxAnisotropy + data["__cuTexRefSetMaxAnisotropy"] = <intptr_t>__cuTexRefSetMaxAnisotropy global __cuTexRefSetBorderColor - data["__cuTexRefSetBorderColor"] = <_cyb_intptr_t>__cuTexRefSetBorderColor + data["__cuTexRefSetBorderColor"] = <intptr_t>__cuTexRefSetBorderColor global __cuTexRefSetFlags - data["__cuTexRefSetFlags"] = <_cyb_intptr_t>__cuTexRefSetFlags + data["__cuTexRefSetFlags"] = <intptr_t>__cuTexRefSetFlags global __cuTexRefGetAddress_v2 - data["__cuTexRefGetAddress_v2"] = <_cyb_intptr_t>__cuTexRefGetAddress_v2 + data["__cuTexRefGetAddress_v2"] = <intptr_t>__cuTexRefGetAddress_v2 global __cuTexRefGetArray - data["__cuTexRefGetArray"] = <_cyb_intptr_t>__cuTexRefGetArray + data["__cuTexRefGetArray"] = <intptr_t>__cuTexRefGetArray global __cuTexRefGetMipmappedArray - data["__cuTexRefGetMipmappedArray"] = <_cyb_intptr_t>__cuTexRefGetMipmappedArray + data["__cuTexRefGetMipmappedArray"] = <intptr_t>__cuTexRefGetMipmappedArray global __cuTexRefGetAddressMode - data["__cuTexRefGetAddressMode"] = <_cyb_intptr_t>__cuTexRefGetAddressMode + data["__cuTexRefGetAddressMode"] = <intptr_t>__cuTexRefGetAddressMode global __cuTexRefGetFilterMode - data["__cuTexRefGetFilterMode"] = <_cyb_intptr_t>__cuTexRefGetFilterMode + data["__cuTexRefGetFilterMode"] = <intptr_t>__cuTexRefGetFilterMode global __cuTexRefGetFormat - data["__cuTexRefGetFormat"] = <_cyb_intptr_t>__cuTexRefGetFormat + data["__cuTexRefGetFormat"] = <intptr_t>__cuTexRefGetFormat global __cuTexRefGetMipmapFilterMode - data["__cuTexRefGetMipmapFilterMode"] = <_cyb_intptr_t>__cuTexRefGetMipmapFilterMode + data["__cuTexRefGetMipmapFilterMode"] = <intptr_t>__cuTexRefGetMipmapFilterMode global __cuTexRefGetMipmapLevelBias - data["__cuTexRefGetMipmapLevelBias"] = <_cyb_intptr_t>__cuTexRefGetMipmapLevelBias + data["__cuTexRefGetMipmapLevelBias"] = <intptr_t>__cuTexRefGetMipmapLevelBias global __cuTexRefGetMipmapLevelClamp - data["__cuTexRefGetMipmapLevelClamp"] = <_cyb_intptr_t>__cuTexRefGetMipmapLevelClamp + data["__cuTexRefGetMipmapLevelClamp"] = <intptr_t>__cuTexRefGetMipmapLevelClamp global __cuTexRefGetMaxAnisotropy - data["__cuTexRefGetMaxAnisotropy"] = <_cyb_intptr_t>__cuTexRefGetMaxAnisotropy + data["__cuTexRefGetMaxAnisotropy"] = <intptr_t>__cuTexRefGetMaxAnisotropy global __cuTexRefGetBorderColor - data["__cuTexRefGetBorderColor"] = <_cyb_intptr_t>__cuTexRefGetBorderColor + data["__cuTexRefGetBorderColor"] = <intptr_t>__cuTexRefGetBorderColor global __cuTexRefGetFlags - data["__cuTexRefGetFlags"] = <_cyb_intptr_t>__cuTexRefGetFlags + data["__cuTexRefGetFlags"] = <intptr_t>__cuTexRefGetFlags global __cuTexRefCreate - data["__cuTexRefCreate"] = <_cyb_intptr_t>__cuTexRefCreate + data["__cuTexRefCreate"] = <intptr_t>__cuTexRefCreate global __cuTexRefDestroy - data["__cuTexRefDestroy"] = <_cyb_intptr_t>__cuTexRefDestroy + data["__cuTexRefDestroy"] = <intptr_t>__cuTexRefDestroy global __cuSurfRefSetArray - data["__cuSurfRefSetArray"] = <_cyb_intptr_t>__cuSurfRefSetArray + data["__cuSurfRefSetArray"] = <intptr_t>__cuSurfRefSetArray global __cuSurfRefGetArray - data["__cuSurfRefGetArray"] = <_cyb_intptr_t>__cuSurfRefGetArray + data["__cuSurfRefGetArray"] = <intptr_t>__cuSurfRefGetArray global __cuTexObjectCreate - data["__cuTexObjectCreate"] = <_cyb_intptr_t>__cuTexObjectCreate + data["__cuTexObjectCreate"] = <intptr_t>__cuTexObjectCreate global __cuTexObjectDestroy - data["__cuTexObjectDestroy"] = <_cyb_intptr_t>__cuTexObjectDestroy + data["__cuTexObjectDestroy"] = <intptr_t>__cuTexObjectDestroy global __cuTexObjectGetResourceDesc - data["__cuTexObjectGetResourceDesc"] = <_cyb_intptr_t>__cuTexObjectGetResourceDesc + data["__cuTexObjectGetResourceDesc"] = <intptr_t>__cuTexObjectGetResourceDesc global __cuTexObjectGetTextureDesc - data["__cuTexObjectGetTextureDesc"] = <_cyb_intptr_t>__cuTexObjectGetTextureDesc + data["__cuTexObjectGetTextureDesc"] = <intptr_t>__cuTexObjectGetTextureDesc global __cuTexObjectGetResourceViewDesc - data["__cuTexObjectGetResourceViewDesc"] = <_cyb_intptr_t>__cuTexObjectGetResourceViewDesc + data["__cuTexObjectGetResourceViewDesc"] = <intptr_t>__cuTexObjectGetResourceViewDesc global __cuSurfObjectCreate - data["__cuSurfObjectCreate"] = <_cyb_intptr_t>__cuSurfObjectCreate + data["__cuSurfObjectCreate"] = <intptr_t>__cuSurfObjectCreate global __cuSurfObjectDestroy - data["__cuSurfObjectDestroy"] = <_cyb_intptr_t>__cuSurfObjectDestroy + data["__cuSurfObjectDestroy"] = <intptr_t>__cuSurfObjectDestroy global __cuSurfObjectGetResourceDesc - data["__cuSurfObjectGetResourceDesc"] = <_cyb_intptr_t>__cuSurfObjectGetResourceDesc + data["__cuSurfObjectGetResourceDesc"] = <intptr_t>__cuSurfObjectGetResourceDesc global __cuTensorMapEncodeTiled - data["__cuTensorMapEncodeTiled"] = <_cyb_intptr_t>__cuTensorMapEncodeTiled + data["__cuTensorMapEncodeTiled"] = <intptr_t>__cuTensorMapEncodeTiled global __cuTensorMapEncodeIm2col - data["__cuTensorMapEncodeIm2col"] = <_cyb_intptr_t>__cuTensorMapEncodeIm2col + data["__cuTensorMapEncodeIm2col"] = <intptr_t>__cuTensorMapEncodeIm2col global __cuTensorMapEncodeIm2colWide - data["__cuTensorMapEncodeIm2colWide"] = <_cyb_intptr_t>__cuTensorMapEncodeIm2colWide + data["__cuTensorMapEncodeIm2colWide"] = <intptr_t>__cuTensorMapEncodeIm2colWide global __cuTensorMapReplaceAddress - data["__cuTensorMapReplaceAddress"] = <_cyb_intptr_t>__cuTensorMapReplaceAddress + data["__cuTensorMapReplaceAddress"] = <intptr_t>__cuTensorMapReplaceAddress global __cuDeviceCanAccessPeer - data["__cuDeviceCanAccessPeer"] = <_cyb_intptr_t>__cuDeviceCanAccessPeer + data["__cuDeviceCanAccessPeer"] = <intptr_t>__cuDeviceCanAccessPeer global __cuCtxEnablePeerAccess - data["__cuCtxEnablePeerAccess"] = <_cyb_intptr_t>__cuCtxEnablePeerAccess + data["__cuCtxEnablePeerAccess"] = <intptr_t>__cuCtxEnablePeerAccess global __cuCtxDisablePeerAccess - data["__cuCtxDisablePeerAccess"] = <_cyb_intptr_t>__cuCtxDisablePeerAccess + data["__cuCtxDisablePeerAccess"] = <intptr_t>__cuCtxDisablePeerAccess global __cuDeviceGetP2PAttribute - data["__cuDeviceGetP2PAttribute"] = <_cyb_intptr_t>__cuDeviceGetP2PAttribute + data["__cuDeviceGetP2PAttribute"] = <intptr_t>__cuDeviceGetP2PAttribute global __cuGraphicsUnregisterResource - data["__cuGraphicsUnregisterResource"] = <_cyb_intptr_t>__cuGraphicsUnregisterResource + data["__cuGraphicsUnregisterResource"] = <intptr_t>__cuGraphicsUnregisterResource global __cuGraphicsSubResourceGetMappedArray - data["__cuGraphicsSubResourceGetMappedArray"] = <_cyb_intptr_t>__cuGraphicsSubResourceGetMappedArray + data["__cuGraphicsSubResourceGetMappedArray"] = <intptr_t>__cuGraphicsSubResourceGetMappedArray global __cuGraphicsResourceGetMappedMipmappedArray - data["__cuGraphicsResourceGetMappedMipmappedArray"] = <_cyb_intptr_t>__cuGraphicsResourceGetMappedMipmappedArray + data["__cuGraphicsResourceGetMappedMipmappedArray"] = <intptr_t>__cuGraphicsResourceGetMappedMipmappedArray global __cuGraphicsResourceGetMappedPointer_v2 - data["__cuGraphicsResourceGetMappedPointer_v2"] = <_cyb_intptr_t>__cuGraphicsResourceGetMappedPointer_v2 + data["__cuGraphicsResourceGetMappedPointer_v2"] = <intptr_t>__cuGraphicsResourceGetMappedPointer_v2 global __cuGraphicsResourceSetMapFlags_v2 - data["__cuGraphicsResourceSetMapFlags_v2"] = <_cyb_intptr_t>__cuGraphicsResourceSetMapFlags_v2 + data["__cuGraphicsResourceSetMapFlags_v2"] = <intptr_t>__cuGraphicsResourceSetMapFlags_v2 global __cuGraphicsMapResources - data["__cuGraphicsMapResources"] = <_cyb_intptr_t>__cuGraphicsMapResources + data["__cuGraphicsMapResources"] = <intptr_t>__cuGraphicsMapResources global __cuGraphicsUnmapResources - data["__cuGraphicsUnmapResources"] = <_cyb_intptr_t>__cuGraphicsUnmapResources + data["__cuGraphicsUnmapResources"] = <intptr_t>__cuGraphicsUnmapResources global __cuGetProcAddress_v2 - data["__cuGetProcAddress_v2"] = <_cyb_intptr_t>__cuGetProcAddress_v2 + data["__cuGetProcAddress_v2"] = <intptr_t>__cuGetProcAddress_v2 global __cuCoredumpGetAttribute - data["__cuCoredumpGetAttribute"] = <_cyb_intptr_t>__cuCoredumpGetAttribute + data["__cuCoredumpGetAttribute"] = <intptr_t>__cuCoredumpGetAttribute global __cuCoredumpGetAttributeGlobal - data["__cuCoredumpGetAttributeGlobal"] = <_cyb_intptr_t>__cuCoredumpGetAttributeGlobal + data["__cuCoredumpGetAttributeGlobal"] = <intptr_t>__cuCoredumpGetAttributeGlobal global __cuCoredumpSetAttribute - data["__cuCoredumpSetAttribute"] = <_cyb_intptr_t>__cuCoredumpSetAttribute + data["__cuCoredumpSetAttribute"] = <intptr_t>__cuCoredumpSetAttribute global __cuCoredumpSetAttributeGlobal - data["__cuCoredumpSetAttributeGlobal"] = <_cyb_intptr_t>__cuCoredumpSetAttributeGlobal + data["__cuCoredumpSetAttributeGlobal"] = <intptr_t>__cuCoredumpSetAttributeGlobal global __cuGetExportTable - data["__cuGetExportTable"] = <_cyb_intptr_t>__cuGetExportTable + data["__cuGetExportTable"] = <intptr_t>__cuGetExportTable global __cuGreenCtxCreate - data["__cuGreenCtxCreate"] = <_cyb_intptr_t>__cuGreenCtxCreate + data["__cuGreenCtxCreate"] = <intptr_t>__cuGreenCtxCreate global __cuGreenCtxDestroy - data["__cuGreenCtxDestroy"] = <_cyb_intptr_t>__cuGreenCtxDestroy + data["__cuGreenCtxDestroy"] = <intptr_t>__cuGreenCtxDestroy global __cuCtxFromGreenCtx - data["__cuCtxFromGreenCtx"] = <_cyb_intptr_t>__cuCtxFromGreenCtx + data["__cuCtxFromGreenCtx"] = <intptr_t>__cuCtxFromGreenCtx global __cuDeviceGetDevResource - data["__cuDeviceGetDevResource"] = <_cyb_intptr_t>__cuDeviceGetDevResource + data["__cuDeviceGetDevResource"] = <intptr_t>__cuDeviceGetDevResource global __cuCtxGetDevResource - data["__cuCtxGetDevResource"] = <_cyb_intptr_t>__cuCtxGetDevResource + data["__cuCtxGetDevResource"] = <intptr_t>__cuCtxGetDevResource global __cuGreenCtxGetDevResource - data["__cuGreenCtxGetDevResource"] = <_cyb_intptr_t>__cuGreenCtxGetDevResource + data["__cuGreenCtxGetDevResource"] = <intptr_t>__cuGreenCtxGetDevResource global __cuDevSmResourceSplitByCount - data["__cuDevSmResourceSplitByCount"] = <_cyb_intptr_t>__cuDevSmResourceSplitByCount + data["__cuDevSmResourceSplitByCount"] = <intptr_t>__cuDevSmResourceSplitByCount global __cuDevResourceGenerateDesc - data["__cuDevResourceGenerateDesc"] = <_cyb_intptr_t>__cuDevResourceGenerateDesc + data["__cuDevResourceGenerateDesc"] = <intptr_t>__cuDevResourceGenerateDesc global __cuGreenCtxRecordEvent - data["__cuGreenCtxRecordEvent"] = <_cyb_intptr_t>__cuGreenCtxRecordEvent + data["__cuGreenCtxRecordEvent"] = <intptr_t>__cuGreenCtxRecordEvent global __cuGreenCtxWaitEvent - data["__cuGreenCtxWaitEvent"] = <_cyb_intptr_t>__cuGreenCtxWaitEvent + data["__cuGreenCtxWaitEvent"] = <intptr_t>__cuGreenCtxWaitEvent global __cuStreamGetGreenCtx - data["__cuStreamGetGreenCtx"] = <_cyb_intptr_t>__cuStreamGetGreenCtx + data["__cuStreamGetGreenCtx"] = <intptr_t>__cuStreamGetGreenCtx global __cuGreenCtxStreamCreate - data["__cuGreenCtxStreamCreate"] = <_cyb_intptr_t>__cuGreenCtxStreamCreate + data["__cuGreenCtxStreamCreate"] = <intptr_t>__cuGreenCtxStreamCreate global __cuLogsRegisterCallback - data["__cuLogsRegisterCallback"] = <_cyb_intptr_t>__cuLogsRegisterCallback + data["__cuLogsRegisterCallback"] = <intptr_t>__cuLogsRegisterCallback global __cuLogsUnregisterCallback - data["__cuLogsUnregisterCallback"] = <_cyb_intptr_t>__cuLogsUnregisterCallback + data["__cuLogsUnregisterCallback"] = <intptr_t>__cuLogsUnregisterCallback global __cuLogsCurrent - data["__cuLogsCurrent"] = <_cyb_intptr_t>__cuLogsCurrent + data["__cuLogsCurrent"] = <intptr_t>__cuLogsCurrent global __cuLogsDumpToFile - data["__cuLogsDumpToFile"] = <_cyb_intptr_t>__cuLogsDumpToFile + data["__cuLogsDumpToFile"] = <intptr_t>__cuLogsDumpToFile global __cuLogsDumpToMemory - data["__cuLogsDumpToMemory"] = <_cyb_intptr_t>__cuLogsDumpToMemory + data["__cuLogsDumpToMemory"] = <intptr_t>__cuLogsDumpToMemory global __cuCheckpointProcessGetRestoreThreadId - data["__cuCheckpointProcessGetRestoreThreadId"] = <_cyb_intptr_t>__cuCheckpointProcessGetRestoreThreadId + data["__cuCheckpointProcessGetRestoreThreadId"] = <intptr_t>__cuCheckpointProcessGetRestoreThreadId global __cuCheckpointProcessGetState - data["__cuCheckpointProcessGetState"] = <_cyb_intptr_t>__cuCheckpointProcessGetState + data["__cuCheckpointProcessGetState"] = <intptr_t>__cuCheckpointProcessGetState global __cuCheckpointProcessLock - data["__cuCheckpointProcessLock"] = <_cyb_intptr_t>__cuCheckpointProcessLock + data["__cuCheckpointProcessLock"] = <intptr_t>__cuCheckpointProcessLock global __cuCheckpointProcessCheckpoint - data["__cuCheckpointProcessCheckpoint"] = <_cyb_intptr_t>__cuCheckpointProcessCheckpoint + data["__cuCheckpointProcessCheckpoint"] = <intptr_t>__cuCheckpointProcessCheckpoint global __cuCheckpointProcessRestore - data["__cuCheckpointProcessRestore"] = <_cyb_intptr_t>__cuCheckpointProcessRestore + data["__cuCheckpointProcessRestore"] = <intptr_t>__cuCheckpointProcessRestore global __cuCheckpointProcessUnlock - data["__cuCheckpointProcessUnlock"] = <_cyb_intptr_t>__cuCheckpointProcessUnlock + data["__cuCheckpointProcessUnlock"] = <intptr_t>__cuCheckpointProcessUnlock global __cuGraphicsEGLRegisterImage - data["__cuGraphicsEGLRegisterImage"] = <_cyb_intptr_t>__cuGraphicsEGLRegisterImage + data["__cuGraphicsEGLRegisterImage"] = <intptr_t>__cuGraphicsEGLRegisterImage global __cuEGLStreamConsumerConnect - data["__cuEGLStreamConsumerConnect"] = <_cyb_intptr_t>__cuEGLStreamConsumerConnect + data["__cuEGLStreamConsumerConnect"] = <intptr_t>__cuEGLStreamConsumerConnect global __cuEGLStreamConsumerConnectWithFlags - data["__cuEGLStreamConsumerConnectWithFlags"] = <_cyb_intptr_t>__cuEGLStreamConsumerConnectWithFlags + data["__cuEGLStreamConsumerConnectWithFlags"] = <intptr_t>__cuEGLStreamConsumerConnectWithFlags global __cuEGLStreamConsumerDisconnect - data["__cuEGLStreamConsumerDisconnect"] = <_cyb_intptr_t>__cuEGLStreamConsumerDisconnect + data["__cuEGLStreamConsumerDisconnect"] = <intptr_t>__cuEGLStreamConsumerDisconnect global __cuEGLStreamConsumerAcquireFrame - data["__cuEGLStreamConsumerAcquireFrame"] = <_cyb_intptr_t>__cuEGLStreamConsumerAcquireFrame + data["__cuEGLStreamConsumerAcquireFrame"] = <intptr_t>__cuEGLStreamConsumerAcquireFrame global __cuEGLStreamConsumerReleaseFrame - data["__cuEGLStreamConsumerReleaseFrame"] = <_cyb_intptr_t>__cuEGLStreamConsumerReleaseFrame + data["__cuEGLStreamConsumerReleaseFrame"] = <intptr_t>__cuEGLStreamConsumerReleaseFrame global __cuEGLStreamProducerConnect - data["__cuEGLStreamProducerConnect"] = <_cyb_intptr_t>__cuEGLStreamProducerConnect + data["__cuEGLStreamProducerConnect"] = <intptr_t>__cuEGLStreamProducerConnect global __cuEGLStreamProducerDisconnect - data["__cuEGLStreamProducerDisconnect"] = <_cyb_intptr_t>__cuEGLStreamProducerDisconnect + data["__cuEGLStreamProducerDisconnect"] = <intptr_t>__cuEGLStreamProducerDisconnect global __cuEGLStreamProducerPresentFrame - data["__cuEGLStreamProducerPresentFrame"] = <_cyb_intptr_t>__cuEGLStreamProducerPresentFrame + data["__cuEGLStreamProducerPresentFrame"] = <intptr_t>__cuEGLStreamProducerPresentFrame global __cuEGLStreamProducerReturnFrame - data["__cuEGLStreamProducerReturnFrame"] = <_cyb_intptr_t>__cuEGLStreamProducerReturnFrame + data["__cuEGLStreamProducerReturnFrame"] = <intptr_t>__cuEGLStreamProducerReturnFrame global __cuGraphicsResourceGetMappedEglFrame - data["__cuGraphicsResourceGetMappedEglFrame"] = <_cyb_intptr_t>__cuGraphicsResourceGetMappedEglFrame + data["__cuGraphicsResourceGetMappedEglFrame"] = <intptr_t>__cuGraphicsResourceGetMappedEglFrame global __cuEventCreateFromEGLSync - data["__cuEventCreateFromEGLSync"] = <_cyb_intptr_t>__cuEventCreateFromEGLSync + data["__cuEventCreateFromEGLSync"] = <intptr_t>__cuEventCreateFromEGLSync global __cuGraphicsGLRegisterBuffer - data["__cuGraphicsGLRegisterBuffer"] = <_cyb_intptr_t>__cuGraphicsGLRegisterBuffer + data["__cuGraphicsGLRegisterBuffer"] = <intptr_t>__cuGraphicsGLRegisterBuffer global __cuGraphicsGLRegisterImage - data["__cuGraphicsGLRegisterImage"] = <_cyb_intptr_t>__cuGraphicsGLRegisterImage + data["__cuGraphicsGLRegisterImage"] = <intptr_t>__cuGraphicsGLRegisterImage global __cuGLGetDevices_v2 - data["__cuGLGetDevices_v2"] = <_cyb_intptr_t>__cuGLGetDevices_v2 + data["__cuGLGetDevices_v2"] = <intptr_t>__cuGLGetDevices_v2 global __cuGLCtxCreate_v2 - data["__cuGLCtxCreate_v2"] = <_cyb_intptr_t>__cuGLCtxCreate_v2 + data["__cuGLCtxCreate_v2"] = <intptr_t>__cuGLCtxCreate_v2 global __cuGLInit - data["__cuGLInit"] = <_cyb_intptr_t>__cuGLInit + data["__cuGLInit"] = <intptr_t>__cuGLInit global __cuGLRegisterBufferObject - data["__cuGLRegisterBufferObject"] = <_cyb_intptr_t>__cuGLRegisterBufferObject + data["__cuGLRegisterBufferObject"] = <intptr_t>__cuGLRegisterBufferObject global __cuGLMapBufferObject_v2 - data["__cuGLMapBufferObject_v2"] = <_cyb_intptr_t>__cuGLMapBufferObject_v2 + data["__cuGLMapBufferObject_v2"] = <intptr_t>__cuGLMapBufferObject_v2 global __cuGLUnmapBufferObject - data["__cuGLUnmapBufferObject"] = <_cyb_intptr_t>__cuGLUnmapBufferObject + data["__cuGLUnmapBufferObject"] = <intptr_t>__cuGLUnmapBufferObject global __cuGLUnregisterBufferObject - data["__cuGLUnregisterBufferObject"] = <_cyb_intptr_t>__cuGLUnregisterBufferObject + data["__cuGLUnregisterBufferObject"] = <intptr_t>__cuGLUnregisterBufferObject global __cuGLSetBufferObjectMapFlags - data["__cuGLSetBufferObjectMapFlags"] = <_cyb_intptr_t>__cuGLSetBufferObjectMapFlags + data["__cuGLSetBufferObjectMapFlags"] = <intptr_t>__cuGLSetBufferObjectMapFlags global __cuGLMapBufferObjectAsync_v2 - data["__cuGLMapBufferObjectAsync_v2"] = <_cyb_intptr_t>__cuGLMapBufferObjectAsync_v2 + data["__cuGLMapBufferObjectAsync_v2"] = <intptr_t>__cuGLMapBufferObjectAsync_v2 global __cuGLUnmapBufferObjectAsync - data["__cuGLUnmapBufferObjectAsync"] = <_cyb_intptr_t>__cuGLUnmapBufferObjectAsync + data["__cuGLUnmapBufferObjectAsync"] = <intptr_t>__cuGLUnmapBufferObjectAsync global __cuProfilerInitialize - data["__cuProfilerInitialize"] = <_cyb_intptr_t>__cuProfilerInitialize + data["__cuProfilerInitialize"] = <intptr_t>__cuProfilerInitialize global __cuProfilerStart - data["__cuProfilerStart"] = <_cyb_intptr_t>__cuProfilerStart + data["__cuProfilerStart"] = <intptr_t>__cuProfilerStart global __cuProfilerStop - data["__cuProfilerStop"] = <_cyb_intptr_t>__cuProfilerStop + data["__cuProfilerStop"] = <intptr_t>__cuProfilerStop global __cuVDPAUGetDevice - data["__cuVDPAUGetDevice"] = <_cyb_intptr_t>__cuVDPAUGetDevice + data["__cuVDPAUGetDevice"] = <intptr_t>__cuVDPAUGetDevice global __cuVDPAUCtxCreate_v2 - data["__cuVDPAUCtxCreate_v2"] = <_cyb_intptr_t>__cuVDPAUCtxCreate_v2 + data["__cuVDPAUCtxCreate_v2"] = <intptr_t>__cuVDPAUCtxCreate_v2 global __cuGraphicsVDPAURegisterVideoSurface - data["__cuGraphicsVDPAURegisterVideoSurface"] = <_cyb_intptr_t>__cuGraphicsVDPAURegisterVideoSurface + data["__cuGraphicsVDPAURegisterVideoSurface"] = <intptr_t>__cuGraphicsVDPAURegisterVideoSurface global __cuGraphicsVDPAURegisterOutputSurface - data["__cuGraphicsVDPAURegisterOutputSurface"] = <_cyb_intptr_t>__cuGraphicsVDPAURegisterOutputSurface + data["__cuGraphicsVDPAURegisterOutputSurface"] = <intptr_t>__cuGraphicsVDPAURegisterOutputSurface global __cuDeviceGetHostAtomicCapabilities - data["__cuDeviceGetHostAtomicCapabilities"] = <_cyb_intptr_t>__cuDeviceGetHostAtomicCapabilities + data["__cuDeviceGetHostAtomicCapabilities"] = <intptr_t>__cuDeviceGetHostAtomicCapabilities global __cuCtxGetDevice_v2 - data["__cuCtxGetDevice_v2"] = <_cyb_intptr_t>__cuCtxGetDevice_v2 + data["__cuCtxGetDevice_v2"] = <intptr_t>__cuCtxGetDevice_v2 global __cuCtxSynchronize_v2 - data["__cuCtxSynchronize_v2"] = <_cyb_intptr_t>__cuCtxSynchronize_v2 + data["__cuCtxSynchronize_v2"] = <intptr_t>__cuCtxSynchronize_v2 global __cuMemcpyBatchAsync_v2 - data["__cuMemcpyBatchAsync_v2"] = <_cyb_intptr_t>__cuMemcpyBatchAsync_v2 + data["__cuMemcpyBatchAsync_v2"] = <intptr_t>__cuMemcpyBatchAsync_v2 global __cuMemcpy3DBatchAsync_v2 - data["__cuMemcpy3DBatchAsync_v2"] = <_cyb_intptr_t>__cuMemcpy3DBatchAsync_v2 + data["__cuMemcpy3DBatchAsync_v2"] = <intptr_t>__cuMemcpy3DBatchAsync_v2 global __cuMemGetDefaultMemPool - data["__cuMemGetDefaultMemPool"] = <_cyb_intptr_t>__cuMemGetDefaultMemPool + data["__cuMemGetDefaultMemPool"] = <intptr_t>__cuMemGetDefaultMemPool global __cuMemGetMemPool - data["__cuMemGetMemPool"] = <_cyb_intptr_t>__cuMemGetMemPool + data["__cuMemGetMemPool"] = <intptr_t>__cuMemGetMemPool global __cuMemSetMemPool - data["__cuMemSetMemPool"] = <_cyb_intptr_t>__cuMemSetMemPool + data["__cuMemSetMemPool"] = <intptr_t>__cuMemSetMemPool global __cuMemPrefetchBatchAsync - data["__cuMemPrefetchBatchAsync"] = <_cyb_intptr_t>__cuMemPrefetchBatchAsync + data["__cuMemPrefetchBatchAsync"] = <intptr_t>__cuMemPrefetchBatchAsync global __cuMemDiscardBatchAsync - data["__cuMemDiscardBatchAsync"] = <_cyb_intptr_t>__cuMemDiscardBatchAsync + data["__cuMemDiscardBatchAsync"] = <intptr_t>__cuMemDiscardBatchAsync global __cuMemDiscardAndPrefetchBatchAsync - data["__cuMemDiscardAndPrefetchBatchAsync"] = <_cyb_intptr_t>__cuMemDiscardAndPrefetchBatchAsync + data["__cuMemDiscardAndPrefetchBatchAsync"] = <intptr_t>__cuMemDiscardAndPrefetchBatchAsync global __cuDeviceGetP2PAtomicCapabilities - data["__cuDeviceGetP2PAtomicCapabilities"] = <_cyb_intptr_t>__cuDeviceGetP2PAtomicCapabilities + data["__cuDeviceGetP2PAtomicCapabilities"] = <intptr_t>__cuDeviceGetP2PAtomicCapabilities global __cuGreenCtxGetId - data["__cuGreenCtxGetId"] = <_cyb_intptr_t>__cuGreenCtxGetId + data["__cuGreenCtxGetId"] = <intptr_t>__cuGreenCtxGetId global __cuMulticastBindMem_v2 - data["__cuMulticastBindMem_v2"] = <_cyb_intptr_t>__cuMulticastBindMem_v2 + data["__cuMulticastBindMem_v2"] = <intptr_t>__cuMulticastBindMem_v2 global __cuMulticastBindAddr_v2 - data["__cuMulticastBindAddr_v2"] = <_cyb_intptr_t>__cuMulticastBindAddr_v2 + data["__cuMulticastBindAddr_v2"] = <intptr_t>__cuMulticastBindAddr_v2 global __cuGraphNodeGetContainingGraph - data["__cuGraphNodeGetContainingGraph"] = <_cyb_intptr_t>__cuGraphNodeGetContainingGraph + data["__cuGraphNodeGetContainingGraph"] = <intptr_t>__cuGraphNodeGetContainingGraph global __cuGraphNodeGetLocalId - data["__cuGraphNodeGetLocalId"] = <_cyb_intptr_t>__cuGraphNodeGetLocalId + data["__cuGraphNodeGetLocalId"] = <intptr_t>__cuGraphNodeGetLocalId global __cuGraphNodeGetToolsId - data["__cuGraphNodeGetToolsId"] = <_cyb_intptr_t>__cuGraphNodeGetToolsId + data["__cuGraphNodeGetToolsId"] = <intptr_t>__cuGraphNodeGetToolsId global __cuGraphGetId - data["__cuGraphGetId"] = <_cyb_intptr_t>__cuGraphGetId + data["__cuGraphGetId"] = <intptr_t>__cuGraphGetId global __cuGraphExecGetId - data["__cuGraphExecGetId"] = <_cyb_intptr_t>__cuGraphExecGetId + data["__cuGraphExecGetId"] = <intptr_t>__cuGraphExecGetId global __cuDevSmResourceSplit - data["__cuDevSmResourceSplit"] = <_cyb_intptr_t>__cuDevSmResourceSplit + data["__cuDevSmResourceSplit"] = <intptr_t>__cuDevSmResourceSplit global __cuStreamGetDevResource - data["__cuStreamGetDevResource"] = <_cyb_intptr_t>__cuStreamGetDevResource + data["__cuStreamGetDevResource"] = <intptr_t>__cuStreamGetDevResource global __cuKernelGetParamCount - data["__cuKernelGetParamCount"] = <_cyb_intptr_t>__cuKernelGetParamCount + data["__cuKernelGetParamCount"] = <intptr_t>__cuKernelGetParamCount global __cuMemcpyWithAttributesAsync - data["__cuMemcpyWithAttributesAsync"] = <_cyb_intptr_t>__cuMemcpyWithAttributesAsync + data["__cuMemcpyWithAttributesAsync"] = <intptr_t>__cuMemcpyWithAttributesAsync global __cuMemcpy3DWithAttributesAsync - data["__cuMemcpy3DWithAttributesAsync"] = <_cyb_intptr_t>__cuMemcpy3DWithAttributesAsync + data["__cuMemcpy3DWithAttributesAsync"] = <intptr_t>__cuMemcpy3DWithAttributesAsync global __cuStreamBeginCaptureToCig - data["__cuStreamBeginCaptureToCig"] = <_cyb_intptr_t>__cuStreamBeginCaptureToCig + data["__cuStreamBeginCaptureToCig"] = <intptr_t>__cuStreamBeginCaptureToCig global __cuStreamEndCaptureToCig - data["__cuStreamEndCaptureToCig"] = <_cyb_intptr_t>__cuStreamEndCaptureToCig + data["__cuStreamEndCaptureToCig"] = <intptr_t>__cuStreamEndCaptureToCig global __cuFuncGetParamCount - data["__cuFuncGetParamCount"] = <_cyb_intptr_t>__cuFuncGetParamCount + data["__cuFuncGetParamCount"] = <intptr_t>__cuFuncGetParamCount global __cuLaunchHostFunc_v2 - data["__cuLaunchHostFunc_v2"] = <_cyb_intptr_t>__cuLaunchHostFunc_v2 + data["__cuLaunchHostFunc_v2"] = <intptr_t>__cuLaunchHostFunc_v2 global __cuGraphNodeGetParams - data["__cuGraphNodeGetParams"] = <_cyb_intptr_t>__cuGraphNodeGetParams + data["__cuGraphNodeGetParams"] = <intptr_t>__cuGraphNodeGetParams global __cuCoredumpRegisterStartCallback - data["__cuCoredumpRegisterStartCallback"] = <_cyb_intptr_t>__cuCoredumpRegisterStartCallback + data["__cuCoredumpRegisterStartCallback"] = <intptr_t>__cuCoredumpRegisterStartCallback global __cuCoredumpRegisterCompleteCallback - data["__cuCoredumpRegisterCompleteCallback"] = <_cyb_intptr_t>__cuCoredumpRegisterCompleteCallback + data["__cuCoredumpRegisterCompleteCallback"] = <intptr_t>__cuCoredumpRegisterCompleteCallback global __cuCoredumpDeregisterStartCallback - data["__cuCoredumpDeregisterStartCallback"] = <_cyb_intptr_t>__cuCoredumpDeregisterStartCallback + data["__cuCoredumpDeregisterStartCallback"] = <intptr_t>__cuCoredumpDeregisterStartCallback global __cuCoredumpDeregisterCompleteCallback - data["__cuCoredumpDeregisterCompleteCallback"] = <_cyb_intptr_t>__cuCoredumpDeregisterCompleteCallback + data["__cuCoredumpDeregisterCompleteCallback"] = <intptr_t>__cuCoredumpDeregisterCompleteCallback global __cuLogicalEndpointIdReserve - data["__cuLogicalEndpointIdReserve"] = <_cyb_intptr_t>__cuLogicalEndpointIdReserve + data["__cuLogicalEndpointIdReserve"] = <intptr_t>__cuLogicalEndpointIdReserve global __cuLogicalEndpointIdRelease - data["__cuLogicalEndpointIdRelease"] = <_cyb_intptr_t>__cuLogicalEndpointIdRelease + data["__cuLogicalEndpointIdRelease"] = <intptr_t>__cuLogicalEndpointIdRelease global __cuLogicalEndpointCreate - data["__cuLogicalEndpointCreate"] = <_cyb_intptr_t>__cuLogicalEndpointCreate + data["__cuLogicalEndpointCreate"] = <intptr_t>__cuLogicalEndpointCreate global __cuLogicalEndpointAddDevice - data["__cuLogicalEndpointAddDevice"] = <_cyb_intptr_t>__cuLogicalEndpointAddDevice + data["__cuLogicalEndpointAddDevice"] = <intptr_t>__cuLogicalEndpointAddDevice global __cuLogicalEndpointDestroy - data["__cuLogicalEndpointDestroy"] = <_cyb_intptr_t>__cuLogicalEndpointDestroy + data["__cuLogicalEndpointDestroy"] = <intptr_t>__cuLogicalEndpointDestroy global __cuLogicalEndpointBindAddr - data["__cuLogicalEndpointBindAddr"] = <_cyb_intptr_t>__cuLogicalEndpointBindAddr + data["__cuLogicalEndpointBindAddr"] = <intptr_t>__cuLogicalEndpointBindAddr global __cuLogicalEndpointBindMem - data["__cuLogicalEndpointBindMem"] = <_cyb_intptr_t>__cuLogicalEndpointBindMem + data["__cuLogicalEndpointBindMem"] = <intptr_t>__cuLogicalEndpointBindMem global __cuLogicalEndpointUnbind - data["__cuLogicalEndpointUnbind"] = <_cyb_intptr_t>__cuLogicalEndpointUnbind + data["__cuLogicalEndpointUnbind"] = <intptr_t>__cuLogicalEndpointUnbind global __cuLogicalEndpointExport - data["__cuLogicalEndpointExport"] = <_cyb_intptr_t>__cuLogicalEndpointExport + data["__cuLogicalEndpointExport"] = <intptr_t>__cuLogicalEndpointExport global __cuLogicalEndpointImport - data["__cuLogicalEndpointImport"] = <_cyb_intptr_t>__cuLogicalEndpointImport + data["__cuLogicalEndpointImport"] = <intptr_t>__cuLogicalEndpointImport global __cuLogicalEndpointGetLimits - data["__cuLogicalEndpointGetLimits"] = <_cyb_intptr_t>__cuLogicalEndpointGetLimits + data["__cuLogicalEndpointGetLimits"] = <intptr_t>__cuLogicalEndpointGetLimits global __cuLogicalEndpointQuery - data["__cuLogicalEndpointQuery"] = <_cyb_intptr_t>__cuLogicalEndpointQuery + data["__cuLogicalEndpointQuery"] = <intptr_t>__cuLogicalEndpointQuery global __cuStreamBeginRecaptureToGraph - data["__cuStreamBeginRecaptureToGraph"] = <_cyb_intptr_t>__cuStreamBeginRecaptureToGraph + data["__cuStreamBeginRecaptureToGraph"] = <intptr_t>__cuStreamBeginRecaptureToGraph global __cuDeviceGetFabricClusterUuid - data["__cuDeviceGetFabricClusterUuid"] = <_cyb_intptr_t>__cuDeviceGetFabricClusterUuid + data["__cuDeviceGetFabricClusterUuid"] = <intptr_t>__cuDeviceGetFabricClusterUuid global __cuDeviceGetCliqueCount - data["__cuDeviceGetCliqueCount"] = <_cyb_intptr_t>__cuDeviceGetCliqueCount + data["__cuDeviceGetCliqueCount"] = <intptr_t>__cuDeviceGetCliqueCount global __cuDeviceGetCliqueInfo - data["__cuDeviceGetCliqueInfo"] = <_cyb_intptr_t>__cuDeviceGetCliqueInfo + data["__cuDeviceGetCliqueInfo"] = <intptr_t>__cuDeviceGetCliqueInfo global __cuMemGetLocationInfo - data["__cuMemGetLocationInfo"] = <_cyb_intptr_t>__cuMemGetLocationInfo + data["__cuMemGetLocationInfo"] = <intptr_t>__cuMemGetLocationInfo global __cuGraphAddNode_v3 - data["__cuGraphAddNode_v3"] = <_cyb_intptr_t>__cuGraphAddNode_v3 + data["__cuGraphAddNode_v3"] = <intptr_t>__cuGraphAddNode_v3 global __cuGraphNodeSetParams_v2 - data["__cuGraphNodeSetParams_v2"] = <_cyb_intptr_t>__cuGraphNodeSetParams_v2 + data["__cuGraphNodeSetParams_v2"] = <intptr_t>__cuGraphNodeSetParams_v2 global __cuCheckpointOperationComplete - data["__cuCheckpointOperationComplete"] = <_cyb_intptr_t>__cuCheckpointOperationComplete + data["__cuCheckpointOperationComplete"] = <intptr_t>__cuCheckpointOperationComplete _cyb_func_ptrs = data return data diff --git a/cuda_bindings/cuda/bindings/_internal/nvfatbin_linux.pyx b/cuda_bindings/cuda/bindings/_internal/nvfatbin_linux.pyx index 09cefc0c8f9..75b3e0f0318 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvfatbin_linux.pyx +++ b/cuda_bindings/cuda/bindings/_internal/nvfatbin_linux.pyx @@ -4,7 +4,7 @@ # # This code was automatically generated across versions from 12.4.1 to 13.4.0. Do not modify it directly. # !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=5351e00f0cca82ccf833f27a4729a538b46110830393e49526539505d0fbe1e9 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=fadf16eb0438f5de3a2f7630ac890066716952b8f0c9656148ee0b1928a9f167 # <<<< PREAMBLE CONTENT >>>> @@ -45,7 +45,7 @@ cdef extern from "<dlfcn.h>": void* _cyb_dlsym "dlsym"(void*, const char*) nogil const void * _cyb_RTLD_DEFAULT "RTLD_DEFAULT" -from libc.stdint cimport intptr_t as _cyb_intptr_t +from libc.stdint cimport intptr_t import threading as _cyb_threading @@ -186,40 +186,40 @@ cpdef dict _inspect_function_pointers(): _check_or_init_nvfatbin() cdef dict data = {} global __nvFatbinGetErrorString - data["__nvFatbinGetErrorString"] = <_cyb_intptr_t>__nvFatbinGetErrorString + data["__nvFatbinGetErrorString"] = <intptr_t>__nvFatbinGetErrorString global __nvFatbinCreate - data["__nvFatbinCreate"] = <_cyb_intptr_t>__nvFatbinCreate + data["__nvFatbinCreate"] = <intptr_t>__nvFatbinCreate global __nvFatbinDestroy - data["__nvFatbinDestroy"] = <_cyb_intptr_t>__nvFatbinDestroy + data["__nvFatbinDestroy"] = <intptr_t>__nvFatbinDestroy global __nvFatbinAddPTX - data["__nvFatbinAddPTX"] = <_cyb_intptr_t>__nvFatbinAddPTX + data["__nvFatbinAddPTX"] = <intptr_t>__nvFatbinAddPTX global __nvFatbinAddCubin - data["__nvFatbinAddCubin"] = <_cyb_intptr_t>__nvFatbinAddCubin + data["__nvFatbinAddCubin"] = <intptr_t>__nvFatbinAddCubin global __nvFatbinAddLTOIR - data["__nvFatbinAddLTOIR"] = <_cyb_intptr_t>__nvFatbinAddLTOIR + data["__nvFatbinAddLTOIR"] = <intptr_t>__nvFatbinAddLTOIR global __nvFatbinSize - data["__nvFatbinSize"] = <_cyb_intptr_t>__nvFatbinSize + data["__nvFatbinSize"] = <intptr_t>__nvFatbinSize global __nvFatbinGet - data["__nvFatbinGet"] = <_cyb_intptr_t>__nvFatbinGet + data["__nvFatbinGet"] = <intptr_t>__nvFatbinGet global __nvFatbinVersion - data["__nvFatbinVersion"] = <_cyb_intptr_t>__nvFatbinVersion + data["__nvFatbinVersion"] = <intptr_t>__nvFatbinVersion global __nvFatbinAddIndex - data["__nvFatbinAddIndex"] = <_cyb_intptr_t>__nvFatbinAddIndex + data["__nvFatbinAddIndex"] = <intptr_t>__nvFatbinAddIndex global __nvFatbinAddReloc - data["__nvFatbinAddReloc"] = <_cyb_intptr_t>__nvFatbinAddReloc + data["__nvFatbinAddReloc"] = <intptr_t>__nvFatbinAddReloc global __nvFatbinAddTileIR - data["__nvFatbinAddTileIR"] = <_cyb_intptr_t>__nvFatbinAddTileIR + data["__nvFatbinAddTileIR"] = <intptr_t>__nvFatbinAddTileIR _cyb_func_ptrs = data return data diff --git a/cuda_bindings/cuda/bindings/_internal/nvfatbin_windows.pyx b/cuda_bindings/cuda/bindings/_internal/nvfatbin_windows.pyx index e0abd202bbe..4992bf673bf 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvfatbin_windows.pyx +++ b/cuda_bindings/cuda/bindings/_internal/nvfatbin_windows.pyx @@ -4,7 +4,7 @@ # # This code was automatically generated across versions from 12.4.1 to 13.4.0. Do not modify it directly. # !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=91a09cd316df7848a0f2c3fba5e516a6e94749e3259b0fbd6f57e9b9873fce55 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=cc0423037f7d52a9e232562afbe97749dc86c0cdae28640a1c94bd250ad5ecfe # <<<< PREAMBLE CONTENT >>>> @@ -45,7 +45,10 @@ cdef extern from "<windows.h>": ctypedef void* HMODULE void* _cyb_GetProcAddress "GetProcAddress"(HMODULE, const char*) nogil -from libc.stdint cimport intptr_t as _cyb_intptr_t +from libc.stdint cimport ( + intptr_t, + uintptr_t, +) import threading as _cyb_threading @@ -138,40 +141,40 @@ cpdef dict _inspect_function_pointers(): _check_or_init_nvfatbin() cdef dict data = {} global __nvFatbinGetErrorString - data["__nvFatbinGetErrorString"] = <_cyb_intptr_t>__nvFatbinGetErrorString + data["__nvFatbinGetErrorString"] = <intptr_t>__nvFatbinGetErrorString global __nvFatbinCreate - data["__nvFatbinCreate"] = <_cyb_intptr_t>__nvFatbinCreate + data["__nvFatbinCreate"] = <intptr_t>__nvFatbinCreate global __nvFatbinDestroy - data["__nvFatbinDestroy"] = <_cyb_intptr_t>__nvFatbinDestroy + data["__nvFatbinDestroy"] = <intptr_t>__nvFatbinDestroy global __nvFatbinAddPTX - data["__nvFatbinAddPTX"] = <_cyb_intptr_t>__nvFatbinAddPTX + data["__nvFatbinAddPTX"] = <intptr_t>__nvFatbinAddPTX global __nvFatbinAddCubin - data["__nvFatbinAddCubin"] = <_cyb_intptr_t>__nvFatbinAddCubin + data["__nvFatbinAddCubin"] = <intptr_t>__nvFatbinAddCubin global __nvFatbinAddLTOIR - data["__nvFatbinAddLTOIR"] = <_cyb_intptr_t>__nvFatbinAddLTOIR + data["__nvFatbinAddLTOIR"] = <intptr_t>__nvFatbinAddLTOIR global __nvFatbinSize - data["__nvFatbinSize"] = <_cyb_intptr_t>__nvFatbinSize + data["__nvFatbinSize"] = <intptr_t>__nvFatbinSize global __nvFatbinGet - data["__nvFatbinGet"] = <_cyb_intptr_t>__nvFatbinGet + data["__nvFatbinGet"] = <intptr_t>__nvFatbinGet global __nvFatbinVersion - data["__nvFatbinVersion"] = <_cyb_intptr_t>__nvFatbinVersion + data["__nvFatbinVersion"] = <intptr_t>__nvFatbinVersion global __nvFatbinAddIndex - data["__nvFatbinAddIndex"] = <_cyb_intptr_t>__nvFatbinAddIndex + data["__nvFatbinAddIndex"] = <intptr_t>__nvFatbinAddIndex global __nvFatbinAddReloc - data["__nvFatbinAddReloc"] = <_cyb_intptr_t>__nvFatbinAddReloc + data["__nvFatbinAddReloc"] = <intptr_t>__nvFatbinAddReloc global __nvFatbinAddTileIR - data["__nvFatbinAddTileIR"] = <_cyb_intptr_t>__nvFatbinAddTileIR + data["__nvFatbinAddTileIR"] = <intptr_t>__nvFatbinAddTileIR _cyb_func_ptrs = data return data diff --git a/cuda_bindings/cuda/bindings/_internal/nvjitlink.pxd b/cuda_bindings/cuda/bindings/_internal/nvjitlink.pxd index 21d527a3c16..961ff3d5a5f 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvjitlink.pxd +++ b/cuda_bindings/cuda/bindings/_internal/nvjitlink.pxd @@ -3,9 +3,17 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.0.1 to 13.4.0. Do not modify it directly. - # !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=05522f152eb6cf5e4b8fc2c0bd25362366a36c9d3c976321ba0155ba330c6209 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=3e1f6ec58cb4b29e88525e739f1d3db206da5c337a8ec26f06320e9674d2f979 + + +# <<<< PREAMBLE CONTENT >>>> + +from libc.stdint cimport uint32_t + + +# <<<< END OF PREAMBLE CONTENT >>>> + from ..cynvjitlink cimport * diff --git a/cuda_bindings/cuda/bindings/_internal/nvjitlink_linux.pyx b/cuda_bindings/cuda/bindings/_internal/nvjitlink_linux.pyx index 7458f5b88e8..67e48c340a8 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvjitlink_linux.pyx +++ b/cuda_bindings/cuda/bindings/_internal/nvjitlink_linux.pyx @@ -4,7 +4,7 @@ # # This code was automatically generated across versions from 12.0.1 to 13.4.0. Do not modify it directly. # !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=539829faeb71eb1d20a60f5e4ad835826eee873b96694b6db8809b9b904bc7b8 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=e158103a4665c0761ccda489c9850866bdb7729095e6c776a88a78b51c2111c4 # <<<< PREAMBLE CONTENT >>>> @@ -45,7 +45,10 @@ cdef extern from "<dlfcn.h>": void* _cyb_dlsym "dlsym"(void*, const char*) nogil const void * _cyb_RTLD_DEFAULT "RTLD_DEFAULT" -from libc.stdint cimport intptr_t as _cyb_intptr_t +from libc.stdint cimport ( + intptr_t, + uint32_t, +) import threading as _cyb_threading @@ -218,52 +221,52 @@ cpdef dict _inspect_function_pointers(): _check_or_init_nvjitlink() cdef dict data = {} global __nvJitLinkCreate - data["__nvJitLinkCreate"] = <_cyb_intptr_t>__nvJitLinkCreate + data["__nvJitLinkCreate"] = <intptr_t>__nvJitLinkCreate global __nvJitLinkDestroy - data["__nvJitLinkDestroy"] = <_cyb_intptr_t>__nvJitLinkDestroy + data["__nvJitLinkDestroy"] = <intptr_t>__nvJitLinkDestroy global __nvJitLinkAddData - data["__nvJitLinkAddData"] = <_cyb_intptr_t>__nvJitLinkAddData + data["__nvJitLinkAddData"] = <intptr_t>__nvJitLinkAddData global __nvJitLinkAddFile - data["__nvJitLinkAddFile"] = <_cyb_intptr_t>__nvJitLinkAddFile + data["__nvJitLinkAddFile"] = <intptr_t>__nvJitLinkAddFile global __nvJitLinkComplete - data["__nvJitLinkComplete"] = <_cyb_intptr_t>__nvJitLinkComplete + data["__nvJitLinkComplete"] = <intptr_t>__nvJitLinkComplete global __nvJitLinkGetLinkedCubinSize - data["__nvJitLinkGetLinkedCubinSize"] = <_cyb_intptr_t>__nvJitLinkGetLinkedCubinSize + data["__nvJitLinkGetLinkedCubinSize"] = <intptr_t>__nvJitLinkGetLinkedCubinSize global __nvJitLinkGetLinkedCubin - data["__nvJitLinkGetLinkedCubin"] = <_cyb_intptr_t>__nvJitLinkGetLinkedCubin + data["__nvJitLinkGetLinkedCubin"] = <intptr_t>__nvJitLinkGetLinkedCubin global __nvJitLinkGetLinkedPtxSize - data["__nvJitLinkGetLinkedPtxSize"] = <_cyb_intptr_t>__nvJitLinkGetLinkedPtxSize + data["__nvJitLinkGetLinkedPtxSize"] = <intptr_t>__nvJitLinkGetLinkedPtxSize global __nvJitLinkGetLinkedPtx - data["__nvJitLinkGetLinkedPtx"] = <_cyb_intptr_t>__nvJitLinkGetLinkedPtx + data["__nvJitLinkGetLinkedPtx"] = <intptr_t>__nvJitLinkGetLinkedPtx global __nvJitLinkGetErrorLogSize - data["__nvJitLinkGetErrorLogSize"] = <_cyb_intptr_t>__nvJitLinkGetErrorLogSize + data["__nvJitLinkGetErrorLogSize"] = <intptr_t>__nvJitLinkGetErrorLogSize global __nvJitLinkGetErrorLog - data["__nvJitLinkGetErrorLog"] = <_cyb_intptr_t>__nvJitLinkGetErrorLog + data["__nvJitLinkGetErrorLog"] = <intptr_t>__nvJitLinkGetErrorLog global __nvJitLinkGetInfoLogSize - data["__nvJitLinkGetInfoLogSize"] = <_cyb_intptr_t>__nvJitLinkGetInfoLogSize + data["__nvJitLinkGetInfoLogSize"] = <intptr_t>__nvJitLinkGetInfoLogSize global __nvJitLinkGetInfoLog - data["__nvJitLinkGetInfoLog"] = <_cyb_intptr_t>__nvJitLinkGetInfoLog + data["__nvJitLinkGetInfoLog"] = <intptr_t>__nvJitLinkGetInfoLog global __nvJitLinkVersion - data["__nvJitLinkVersion"] = <_cyb_intptr_t>__nvJitLinkVersion + data["__nvJitLinkVersion"] = <intptr_t>__nvJitLinkVersion global __nvJitLinkGetLinkedLTOIRSize - data["__nvJitLinkGetLinkedLTOIRSize"] = <_cyb_intptr_t>__nvJitLinkGetLinkedLTOIRSize + data["__nvJitLinkGetLinkedLTOIRSize"] = <intptr_t>__nvJitLinkGetLinkedLTOIRSize global __nvJitLinkGetLinkedLTOIR - data["__nvJitLinkGetLinkedLTOIR"] = <_cyb_intptr_t>__nvJitLinkGetLinkedLTOIR + data["__nvJitLinkGetLinkedLTOIR"] = <intptr_t>__nvJitLinkGetLinkedLTOIR _cyb_func_ptrs = data return data diff --git a/cuda_bindings/cuda/bindings/_internal/nvjitlink_windows.pyx b/cuda_bindings/cuda/bindings/_internal/nvjitlink_windows.pyx index 9e279570c8d..9f67f750f3d 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvjitlink_windows.pyx +++ b/cuda_bindings/cuda/bindings/_internal/nvjitlink_windows.pyx @@ -4,7 +4,7 @@ # # This code was automatically generated across versions from 12.0.1 to 13.4.0. Do not modify it directly. # !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=d90e50b8ffd6f1d66aa26e5a0d38b9e3a3c7a801114de8feabe626d622d50f81 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=aba925fa52cf3b835f062b3c99d60fe59165d177075696a46f0f7c4b42ead221 # <<<< PREAMBLE CONTENT >>>> @@ -45,7 +45,11 @@ cdef extern from "<windows.h>": ctypedef void* HMODULE void* _cyb_GetProcAddress "GetProcAddress"(HMODULE, const char*) nogil -from libc.stdint cimport intptr_t as _cyb_intptr_t +from libc.stdint cimport ( + intptr_t, + uint32_t, + uintptr_t, +) import threading as _cyb_threading @@ -154,52 +158,52 @@ cpdef dict _inspect_function_pointers(): _check_or_init_nvjitlink() cdef dict data = {} global __nvJitLinkCreate - data["__nvJitLinkCreate"] = <_cyb_intptr_t>__nvJitLinkCreate + data["__nvJitLinkCreate"] = <intptr_t>__nvJitLinkCreate global __nvJitLinkDestroy - data["__nvJitLinkDestroy"] = <_cyb_intptr_t>__nvJitLinkDestroy + data["__nvJitLinkDestroy"] = <intptr_t>__nvJitLinkDestroy global __nvJitLinkAddData - data["__nvJitLinkAddData"] = <_cyb_intptr_t>__nvJitLinkAddData + data["__nvJitLinkAddData"] = <intptr_t>__nvJitLinkAddData global __nvJitLinkAddFile - data["__nvJitLinkAddFile"] = <_cyb_intptr_t>__nvJitLinkAddFile + data["__nvJitLinkAddFile"] = <intptr_t>__nvJitLinkAddFile global __nvJitLinkComplete - data["__nvJitLinkComplete"] = <_cyb_intptr_t>__nvJitLinkComplete + data["__nvJitLinkComplete"] = <intptr_t>__nvJitLinkComplete global __nvJitLinkGetLinkedCubinSize - data["__nvJitLinkGetLinkedCubinSize"] = <_cyb_intptr_t>__nvJitLinkGetLinkedCubinSize + data["__nvJitLinkGetLinkedCubinSize"] = <intptr_t>__nvJitLinkGetLinkedCubinSize global __nvJitLinkGetLinkedCubin - data["__nvJitLinkGetLinkedCubin"] = <_cyb_intptr_t>__nvJitLinkGetLinkedCubin + data["__nvJitLinkGetLinkedCubin"] = <intptr_t>__nvJitLinkGetLinkedCubin global __nvJitLinkGetLinkedPtxSize - data["__nvJitLinkGetLinkedPtxSize"] = <_cyb_intptr_t>__nvJitLinkGetLinkedPtxSize + data["__nvJitLinkGetLinkedPtxSize"] = <intptr_t>__nvJitLinkGetLinkedPtxSize global __nvJitLinkGetLinkedPtx - data["__nvJitLinkGetLinkedPtx"] = <_cyb_intptr_t>__nvJitLinkGetLinkedPtx + data["__nvJitLinkGetLinkedPtx"] = <intptr_t>__nvJitLinkGetLinkedPtx global __nvJitLinkGetErrorLogSize - data["__nvJitLinkGetErrorLogSize"] = <_cyb_intptr_t>__nvJitLinkGetErrorLogSize + data["__nvJitLinkGetErrorLogSize"] = <intptr_t>__nvJitLinkGetErrorLogSize global __nvJitLinkGetErrorLog - data["__nvJitLinkGetErrorLog"] = <_cyb_intptr_t>__nvJitLinkGetErrorLog + data["__nvJitLinkGetErrorLog"] = <intptr_t>__nvJitLinkGetErrorLog global __nvJitLinkGetInfoLogSize - data["__nvJitLinkGetInfoLogSize"] = <_cyb_intptr_t>__nvJitLinkGetInfoLogSize + data["__nvJitLinkGetInfoLogSize"] = <intptr_t>__nvJitLinkGetInfoLogSize global __nvJitLinkGetInfoLog - data["__nvJitLinkGetInfoLog"] = <_cyb_intptr_t>__nvJitLinkGetInfoLog + data["__nvJitLinkGetInfoLog"] = <intptr_t>__nvJitLinkGetInfoLog global __nvJitLinkVersion - data["__nvJitLinkVersion"] = <_cyb_intptr_t>__nvJitLinkVersion + data["__nvJitLinkVersion"] = <intptr_t>__nvJitLinkVersion global __nvJitLinkGetLinkedLTOIRSize - data["__nvJitLinkGetLinkedLTOIRSize"] = <_cyb_intptr_t>__nvJitLinkGetLinkedLTOIRSize + data["__nvJitLinkGetLinkedLTOIRSize"] = <intptr_t>__nvJitLinkGetLinkedLTOIRSize global __nvJitLinkGetLinkedLTOIR - data["__nvJitLinkGetLinkedLTOIR"] = <_cyb_intptr_t>__nvJitLinkGetLinkedLTOIR + data["__nvJitLinkGetLinkedLTOIR"] = <intptr_t>__nvJitLinkGetLinkedLTOIR _cyb_func_ptrs = data return data diff --git a/cuda_bindings/cuda/bindings/_internal/nvml_linux.pyx b/cuda_bindings/cuda/bindings/_internal/nvml_linux.pyx index c61714f77dd..1f487e492ee 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvml_linux.pyx +++ b/cuda_bindings/cuda/bindings/_internal/nvml_linux.pyx @@ -4,7 +4,7 @@ # # This code was automatically generated across versions from 12.9.1 to 13.4.0. Do not modify it directly. # !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=735d5128e04ed65d3517e4315b5c05f9f1731c2f4dd00460925bb30f7090f6f5 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=0087568b9b3f0b61ae1648aa3f7c9f3f3f72791a06b94797834eb6c1072a676d # <<<< PREAMBLE CONTENT >>>> @@ -45,7 +45,7 @@ cdef extern from "<dlfcn.h>": void* _cyb_dlsym "dlsym"(void*, const char*) nogil const void * _cyb_RTLD_DEFAULT "RTLD_DEFAULT" -from libc.stdint cimport intptr_t as _cyb_intptr_t +from libc.stdint cimport intptr_t import threading as _cyb_threading @@ -3050,1114 +3050,1114 @@ cpdef dict _inspect_function_pointers(): _check_or_init_nvml() cdef dict data = {} global __nvmlInit_v2 - data["__nvmlInit_v2"] = <_cyb_intptr_t>__nvmlInit_v2 + data["__nvmlInit_v2"] = <intptr_t>__nvmlInit_v2 global __nvmlInitWithFlags - data["__nvmlInitWithFlags"] = <_cyb_intptr_t>__nvmlInitWithFlags + data["__nvmlInitWithFlags"] = <intptr_t>__nvmlInitWithFlags global __nvmlShutdown - data["__nvmlShutdown"] = <_cyb_intptr_t>__nvmlShutdown + data["__nvmlShutdown"] = <intptr_t>__nvmlShutdown global __nvmlErrorString - data["__nvmlErrorString"] = <_cyb_intptr_t>__nvmlErrorString + data["__nvmlErrorString"] = <intptr_t>__nvmlErrorString global __nvmlSystemGetDriverVersion - data["__nvmlSystemGetDriverVersion"] = <_cyb_intptr_t>__nvmlSystemGetDriverVersion + data["__nvmlSystemGetDriverVersion"] = <intptr_t>__nvmlSystemGetDriverVersion global __nvmlSystemGetNVMLVersion - data["__nvmlSystemGetNVMLVersion"] = <_cyb_intptr_t>__nvmlSystemGetNVMLVersion + data["__nvmlSystemGetNVMLVersion"] = <intptr_t>__nvmlSystemGetNVMLVersion global __nvmlSystemGetCudaDriverVersion - data["__nvmlSystemGetCudaDriverVersion"] = <_cyb_intptr_t>__nvmlSystemGetCudaDriverVersion + data["__nvmlSystemGetCudaDriverVersion"] = <intptr_t>__nvmlSystemGetCudaDriverVersion global __nvmlSystemGetCudaDriverVersion_v2 - data["__nvmlSystemGetCudaDriverVersion_v2"] = <_cyb_intptr_t>__nvmlSystemGetCudaDriverVersion_v2 + data["__nvmlSystemGetCudaDriverVersion_v2"] = <intptr_t>__nvmlSystemGetCudaDriverVersion_v2 global __nvmlSystemGetProcessName - data["__nvmlSystemGetProcessName"] = <_cyb_intptr_t>__nvmlSystemGetProcessName + data["__nvmlSystemGetProcessName"] = <intptr_t>__nvmlSystemGetProcessName global __nvmlSystemGetHicVersion - data["__nvmlSystemGetHicVersion"] = <_cyb_intptr_t>__nvmlSystemGetHicVersion + data["__nvmlSystemGetHicVersion"] = <intptr_t>__nvmlSystemGetHicVersion global __nvmlSystemGetTopologyGpuSet - data["__nvmlSystemGetTopologyGpuSet"] = <_cyb_intptr_t>__nvmlSystemGetTopologyGpuSet + data["__nvmlSystemGetTopologyGpuSet"] = <intptr_t>__nvmlSystemGetTopologyGpuSet global __nvmlSystemGetDriverBranch - data["__nvmlSystemGetDriverBranch"] = <_cyb_intptr_t>__nvmlSystemGetDriverBranch + data["__nvmlSystemGetDriverBranch"] = <intptr_t>__nvmlSystemGetDriverBranch global __nvmlUnitGetCount - data["__nvmlUnitGetCount"] = <_cyb_intptr_t>__nvmlUnitGetCount + data["__nvmlUnitGetCount"] = <intptr_t>__nvmlUnitGetCount global __nvmlUnitGetHandleByIndex - data["__nvmlUnitGetHandleByIndex"] = <_cyb_intptr_t>__nvmlUnitGetHandleByIndex + data["__nvmlUnitGetHandleByIndex"] = <intptr_t>__nvmlUnitGetHandleByIndex global __nvmlUnitGetUnitInfo - data["__nvmlUnitGetUnitInfo"] = <_cyb_intptr_t>__nvmlUnitGetUnitInfo + data["__nvmlUnitGetUnitInfo"] = <intptr_t>__nvmlUnitGetUnitInfo global __nvmlUnitGetLedState - data["__nvmlUnitGetLedState"] = <_cyb_intptr_t>__nvmlUnitGetLedState + data["__nvmlUnitGetLedState"] = <intptr_t>__nvmlUnitGetLedState global __nvmlUnitGetPsuInfo - data["__nvmlUnitGetPsuInfo"] = <_cyb_intptr_t>__nvmlUnitGetPsuInfo + data["__nvmlUnitGetPsuInfo"] = <intptr_t>__nvmlUnitGetPsuInfo global __nvmlUnitGetTemperature - data["__nvmlUnitGetTemperature"] = <_cyb_intptr_t>__nvmlUnitGetTemperature + data["__nvmlUnitGetTemperature"] = <intptr_t>__nvmlUnitGetTemperature global __nvmlUnitGetFanSpeedInfo - data["__nvmlUnitGetFanSpeedInfo"] = <_cyb_intptr_t>__nvmlUnitGetFanSpeedInfo + data["__nvmlUnitGetFanSpeedInfo"] = <intptr_t>__nvmlUnitGetFanSpeedInfo global __nvmlUnitGetDevices - data["__nvmlUnitGetDevices"] = <_cyb_intptr_t>__nvmlUnitGetDevices + data["__nvmlUnitGetDevices"] = <intptr_t>__nvmlUnitGetDevices global __nvmlDeviceGetCount_v2 - data["__nvmlDeviceGetCount_v2"] = <_cyb_intptr_t>__nvmlDeviceGetCount_v2 + data["__nvmlDeviceGetCount_v2"] = <intptr_t>__nvmlDeviceGetCount_v2 global __nvmlDeviceGetAttributes_v2 - data["__nvmlDeviceGetAttributes_v2"] = <_cyb_intptr_t>__nvmlDeviceGetAttributes_v2 + data["__nvmlDeviceGetAttributes_v2"] = <intptr_t>__nvmlDeviceGetAttributes_v2 global __nvmlDeviceGetHandleByIndex_v2 - data["__nvmlDeviceGetHandleByIndex_v2"] = <_cyb_intptr_t>__nvmlDeviceGetHandleByIndex_v2 + data["__nvmlDeviceGetHandleByIndex_v2"] = <intptr_t>__nvmlDeviceGetHandleByIndex_v2 global __nvmlDeviceGetHandleBySerial - data["__nvmlDeviceGetHandleBySerial"] = <_cyb_intptr_t>__nvmlDeviceGetHandleBySerial + data["__nvmlDeviceGetHandleBySerial"] = <intptr_t>__nvmlDeviceGetHandleBySerial global __nvmlDeviceGetHandleByUUID - data["__nvmlDeviceGetHandleByUUID"] = <_cyb_intptr_t>__nvmlDeviceGetHandleByUUID + data["__nvmlDeviceGetHandleByUUID"] = <intptr_t>__nvmlDeviceGetHandleByUUID global __nvmlDeviceGetHandleByUUIDV - data["__nvmlDeviceGetHandleByUUIDV"] = <_cyb_intptr_t>__nvmlDeviceGetHandleByUUIDV + data["__nvmlDeviceGetHandleByUUIDV"] = <intptr_t>__nvmlDeviceGetHandleByUUIDV global __nvmlDeviceGetHandleByPciBusId_v2 - data["__nvmlDeviceGetHandleByPciBusId_v2"] = <_cyb_intptr_t>__nvmlDeviceGetHandleByPciBusId_v2 + data["__nvmlDeviceGetHandleByPciBusId_v2"] = <intptr_t>__nvmlDeviceGetHandleByPciBusId_v2 global __nvmlDeviceGetName - data["__nvmlDeviceGetName"] = <_cyb_intptr_t>__nvmlDeviceGetName + data["__nvmlDeviceGetName"] = <intptr_t>__nvmlDeviceGetName global __nvmlDeviceGetBrand - data["__nvmlDeviceGetBrand"] = <_cyb_intptr_t>__nvmlDeviceGetBrand + data["__nvmlDeviceGetBrand"] = <intptr_t>__nvmlDeviceGetBrand global __nvmlDeviceGetIndex - data["__nvmlDeviceGetIndex"] = <_cyb_intptr_t>__nvmlDeviceGetIndex + data["__nvmlDeviceGetIndex"] = <intptr_t>__nvmlDeviceGetIndex global __nvmlDeviceGetSerial - data["__nvmlDeviceGetSerial"] = <_cyb_intptr_t>__nvmlDeviceGetSerial + data["__nvmlDeviceGetSerial"] = <intptr_t>__nvmlDeviceGetSerial global __nvmlDeviceGetModuleId - data["__nvmlDeviceGetModuleId"] = <_cyb_intptr_t>__nvmlDeviceGetModuleId + data["__nvmlDeviceGetModuleId"] = <intptr_t>__nvmlDeviceGetModuleId global __nvmlDeviceGetC2cModeInfoV - data["__nvmlDeviceGetC2cModeInfoV"] = <_cyb_intptr_t>__nvmlDeviceGetC2cModeInfoV + data["__nvmlDeviceGetC2cModeInfoV"] = <intptr_t>__nvmlDeviceGetC2cModeInfoV global __nvmlDeviceGetMemoryAffinity - data["__nvmlDeviceGetMemoryAffinity"] = <_cyb_intptr_t>__nvmlDeviceGetMemoryAffinity + data["__nvmlDeviceGetMemoryAffinity"] = <intptr_t>__nvmlDeviceGetMemoryAffinity global __nvmlDeviceGetCpuAffinityWithinScope - data["__nvmlDeviceGetCpuAffinityWithinScope"] = <_cyb_intptr_t>__nvmlDeviceGetCpuAffinityWithinScope + data["__nvmlDeviceGetCpuAffinityWithinScope"] = <intptr_t>__nvmlDeviceGetCpuAffinityWithinScope global __nvmlDeviceGetCpuAffinity - data["__nvmlDeviceGetCpuAffinity"] = <_cyb_intptr_t>__nvmlDeviceGetCpuAffinity + data["__nvmlDeviceGetCpuAffinity"] = <intptr_t>__nvmlDeviceGetCpuAffinity global __nvmlDeviceSetCpuAffinity - data["__nvmlDeviceSetCpuAffinity"] = <_cyb_intptr_t>__nvmlDeviceSetCpuAffinity + data["__nvmlDeviceSetCpuAffinity"] = <intptr_t>__nvmlDeviceSetCpuAffinity global __nvmlDeviceClearCpuAffinity - data["__nvmlDeviceClearCpuAffinity"] = <_cyb_intptr_t>__nvmlDeviceClearCpuAffinity + data["__nvmlDeviceClearCpuAffinity"] = <intptr_t>__nvmlDeviceClearCpuAffinity global __nvmlDeviceGetNumaNodeId - data["__nvmlDeviceGetNumaNodeId"] = <_cyb_intptr_t>__nvmlDeviceGetNumaNodeId + data["__nvmlDeviceGetNumaNodeId"] = <intptr_t>__nvmlDeviceGetNumaNodeId global __nvmlDeviceGetTopologyCommonAncestor - data["__nvmlDeviceGetTopologyCommonAncestor"] = <_cyb_intptr_t>__nvmlDeviceGetTopologyCommonAncestor + data["__nvmlDeviceGetTopologyCommonAncestor"] = <intptr_t>__nvmlDeviceGetTopologyCommonAncestor global __nvmlDeviceGetTopologyNearestGpus - data["__nvmlDeviceGetTopologyNearestGpus"] = <_cyb_intptr_t>__nvmlDeviceGetTopologyNearestGpus + data["__nvmlDeviceGetTopologyNearestGpus"] = <intptr_t>__nvmlDeviceGetTopologyNearestGpus global __nvmlDeviceGetP2PStatus - data["__nvmlDeviceGetP2PStatus"] = <_cyb_intptr_t>__nvmlDeviceGetP2PStatus + data["__nvmlDeviceGetP2PStatus"] = <intptr_t>__nvmlDeviceGetP2PStatus global __nvmlDeviceGetUUID - data["__nvmlDeviceGetUUID"] = <_cyb_intptr_t>__nvmlDeviceGetUUID + data["__nvmlDeviceGetUUID"] = <intptr_t>__nvmlDeviceGetUUID global __nvmlDeviceGetMinorNumber - data["__nvmlDeviceGetMinorNumber"] = <_cyb_intptr_t>__nvmlDeviceGetMinorNumber + data["__nvmlDeviceGetMinorNumber"] = <intptr_t>__nvmlDeviceGetMinorNumber global __nvmlDeviceGetBoardPartNumber - data["__nvmlDeviceGetBoardPartNumber"] = <_cyb_intptr_t>__nvmlDeviceGetBoardPartNumber + data["__nvmlDeviceGetBoardPartNumber"] = <intptr_t>__nvmlDeviceGetBoardPartNumber global __nvmlDeviceGetInforomVersion - data["__nvmlDeviceGetInforomVersion"] = <_cyb_intptr_t>__nvmlDeviceGetInforomVersion + data["__nvmlDeviceGetInforomVersion"] = <intptr_t>__nvmlDeviceGetInforomVersion global __nvmlDeviceGetInforomImageVersion - data["__nvmlDeviceGetInforomImageVersion"] = <_cyb_intptr_t>__nvmlDeviceGetInforomImageVersion + data["__nvmlDeviceGetInforomImageVersion"] = <intptr_t>__nvmlDeviceGetInforomImageVersion global __nvmlDeviceGetInforomConfigurationChecksum - data["__nvmlDeviceGetInforomConfigurationChecksum"] = <_cyb_intptr_t>__nvmlDeviceGetInforomConfigurationChecksum + data["__nvmlDeviceGetInforomConfigurationChecksum"] = <intptr_t>__nvmlDeviceGetInforomConfigurationChecksum global __nvmlDeviceValidateInforom - data["__nvmlDeviceValidateInforom"] = <_cyb_intptr_t>__nvmlDeviceValidateInforom + data["__nvmlDeviceValidateInforom"] = <intptr_t>__nvmlDeviceValidateInforom global __nvmlDeviceGetLastBBXFlushTime - data["__nvmlDeviceGetLastBBXFlushTime"] = <_cyb_intptr_t>__nvmlDeviceGetLastBBXFlushTime + data["__nvmlDeviceGetLastBBXFlushTime"] = <intptr_t>__nvmlDeviceGetLastBBXFlushTime global __nvmlDeviceGetDisplayMode - data["__nvmlDeviceGetDisplayMode"] = <_cyb_intptr_t>__nvmlDeviceGetDisplayMode + data["__nvmlDeviceGetDisplayMode"] = <intptr_t>__nvmlDeviceGetDisplayMode global __nvmlDeviceGetDisplayActive - data["__nvmlDeviceGetDisplayActive"] = <_cyb_intptr_t>__nvmlDeviceGetDisplayActive + data["__nvmlDeviceGetDisplayActive"] = <intptr_t>__nvmlDeviceGetDisplayActive global __nvmlDeviceGetPersistenceMode - data["__nvmlDeviceGetPersistenceMode"] = <_cyb_intptr_t>__nvmlDeviceGetPersistenceMode + data["__nvmlDeviceGetPersistenceMode"] = <intptr_t>__nvmlDeviceGetPersistenceMode global __nvmlDeviceGetPciInfoExt - data["__nvmlDeviceGetPciInfoExt"] = <_cyb_intptr_t>__nvmlDeviceGetPciInfoExt + data["__nvmlDeviceGetPciInfoExt"] = <intptr_t>__nvmlDeviceGetPciInfoExt global __nvmlDeviceGetPciInfo_v3 - data["__nvmlDeviceGetPciInfo_v3"] = <_cyb_intptr_t>__nvmlDeviceGetPciInfo_v3 + data["__nvmlDeviceGetPciInfo_v3"] = <intptr_t>__nvmlDeviceGetPciInfo_v3 global __nvmlDeviceGetMaxPcieLinkGeneration - data["__nvmlDeviceGetMaxPcieLinkGeneration"] = <_cyb_intptr_t>__nvmlDeviceGetMaxPcieLinkGeneration + data["__nvmlDeviceGetMaxPcieLinkGeneration"] = <intptr_t>__nvmlDeviceGetMaxPcieLinkGeneration global __nvmlDeviceGetGpuMaxPcieLinkGeneration - data["__nvmlDeviceGetGpuMaxPcieLinkGeneration"] = <_cyb_intptr_t>__nvmlDeviceGetGpuMaxPcieLinkGeneration + data["__nvmlDeviceGetGpuMaxPcieLinkGeneration"] = <intptr_t>__nvmlDeviceGetGpuMaxPcieLinkGeneration global __nvmlDeviceGetMaxPcieLinkWidth - data["__nvmlDeviceGetMaxPcieLinkWidth"] = <_cyb_intptr_t>__nvmlDeviceGetMaxPcieLinkWidth + data["__nvmlDeviceGetMaxPcieLinkWidth"] = <intptr_t>__nvmlDeviceGetMaxPcieLinkWidth global __nvmlDeviceGetCurrPcieLinkGeneration - data["__nvmlDeviceGetCurrPcieLinkGeneration"] = <_cyb_intptr_t>__nvmlDeviceGetCurrPcieLinkGeneration + data["__nvmlDeviceGetCurrPcieLinkGeneration"] = <intptr_t>__nvmlDeviceGetCurrPcieLinkGeneration global __nvmlDeviceGetCurrPcieLinkWidth - data["__nvmlDeviceGetCurrPcieLinkWidth"] = <_cyb_intptr_t>__nvmlDeviceGetCurrPcieLinkWidth + data["__nvmlDeviceGetCurrPcieLinkWidth"] = <intptr_t>__nvmlDeviceGetCurrPcieLinkWidth global __nvmlDeviceGetPcieThroughput - data["__nvmlDeviceGetPcieThroughput"] = <_cyb_intptr_t>__nvmlDeviceGetPcieThroughput + data["__nvmlDeviceGetPcieThroughput"] = <intptr_t>__nvmlDeviceGetPcieThroughput global __nvmlDeviceGetPcieReplayCounter - data["__nvmlDeviceGetPcieReplayCounter"] = <_cyb_intptr_t>__nvmlDeviceGetPcieReplayCounter + data["__nvmlDeviceGetPcieReplayCounter"] = <intptr_t>__nvmlDeviceGetPcieReplayCounter global __nvmlDeviceGetClockInfo - data["__nvmlDeviceGetClockInfo"] = <_cyb_intptr_t>__nvmlDeviceGetClockInfo + data["__nvmlDeviceGetClockInfo"] = <intptr_t>__nvmlDeviceGetClockInfo global __nvmlDeviceGetMaxClockInfo - data["__nvmlDeviceGetMaxClockInfo"] = <_cyb_intptr_t>__nvmlDeviceGetMaxClockInfo + data["__nvmlDeviceGetMaxClockInfo"] = <intptr_t>__nvmlDeviceGetMaxClockInfo global __nvmlDeviceGetGpcClkVfOffset - data["__nvmlDeviceGetGpcClkVfOffset"] = <_cyb_intptr_t>__nvmlDeviceGetGpcClkVfOffset + data["__nvmlDeviceGetGpcClkVfOffset"] = <intptr_t>__nvmlDeviceGetGpcClkVfOffset global __nvmlDeviceGetClock - data["__nvmlDeviceGetClock"] = <_cyb_intptr_t>__nvmlDeviceGetClock + data["__nvmlDeviceGetClock"] = <intptr_t>__nvmlDeviceGetClock global __nvmlDeviceGetMaxCustomerBoostClock - data["__nvmlDeviceGetMaxCustomerBoostClock"] = <_cyb_intptr_t>__nvmlDeviceGetMaxCustomerBoostClock + data["__nvmlDeviceGetMaxCustomerBoostClock"] = <intptr_t>__nvmlDeviceGetMaxCustomerBoostClock global __nvmlDeviceGetSupportedMemoryClocks - data["__nvmlDeviceGetSupportedMemoryClocks"] = <_cyb_intptr_t>__nvmlDeviceGetSupportedMemoryClocks + data["__nvmlDeviceGetSupportedMemoryClocks"] = <intptr_t>__nvmlDeviceGetSupportedMemoryClocks global __nvmlDeviceGetSupportedGraphicsClocks - data["__nvmlDeviceGetSupportedGraphicsClocks"] = <_cyb_intptr_t>__nvmlDeviceGetSupportedGraphicsClocks + data["__nvmlDeviceGetSupportedGraphicsClocks"] = <intptr_t>__nvmlDeviceGetSupportedGraphicsClocks global __nvmlDeviceGetAutoBoostedClocksEnabled - data["__nvmlDeviceGetAutoBoostedClocksEnabled"] = <_cyb_intptr_t>__nvmlDeviceGetAutoBoostedClocksEnabled + data["__nvmlDeviceGetAutoBoostedClocksEnabled"] = <intptr_t>__nvmlDeviceGetAutoBoostedClocksEnabled global __nvmlDeviceGetFanSpeed - data["__nvmlDeviceGetFanSpeed"] = <_cyb_intptr_t>__nvmlDeviceGetFanSpeed + data["__nvmlDeviceGetFanSpeed"] = <intptr_t>__nvmlDeviceGetFanSpeed global __nvmlDeviceGetFanSpeed_v2 - data["__nvmlDeviceGetFanSpeed_v2"] = <_cyb_intptr_t>__nvmlDeviceGetFanSpeed_v2 + data["__nvmlDeviceGetFanSpeed_v2"] = <intptr_t>__nvmlDeviceGetFanSpeed_v2 global __nvmlDeviceGetFanSpeedRPM - data["__nvmlDeviceGetFanSpeedRPM"] = <_cyb_intptr_t>__nvmlDeviceGetFanSpeedRPM + data["__nvmlDeviceGetFanSpeedRPM"] = <intptr_t>__nvmlDeviceGetFanSpeedRPM global __nvmlDeviceGetTargetFanSpeed - data["__nvmlDeviceGetTargetFanSpeed"] = <_cyb_intptr_t>__nvmlDeviceGetTargetFanSpeed + data["__nvmlDeviceGetTargetFanSpeed"] = <intptr_t>__nvmlDeviceGetTargetFanSpeed global __nvmlDeviceGetMinMaxFanSpeed - data["__nvmlDeviceGetMinMaxFanSpeed"] = <_cyb_intptr_t>__nvmlDeviceGetMinMaxFanSpeed + data["__nvmlDeviceGetMinMaxFanSpeed"] = <intptr_t>__nvmlDeviceGetMinMaxFanSpeed global __nvmlDeviceGetFanControlPolicy_v2 - data["__nvmlDeviceGetFanControlPolicy_v2"] = <_cyb_intptr_t>__nvmlDeviceGetFanControlPolicy_v2 + data["__nvmlDeviceGetFanControlPolicy_v2"] = <intptr_t>__nvmlDeviceGetFanControlPolicy_v2 global __nvmlDeviceGetNumFans - data["__nvmlDeviceGetNumFans"] = <_cyb_intptr_t>__nvmlDeviceGetNumFans + data["__nvmlDeviceGetNumFans"] = <intptr_t>__nvmlDeviceGetNumFans global __nvmlDeviceGetCoolerInfo - data["__nvmlDeviceGetCoolerInfo"] = <_cyb_intptr_t>__nvmlDeviceGetCoolerInfo + data["__nvmlDeviceGetCoolerInfo"] = <intptr_t>__nvmlDeviceGetCoolerInfo global __nvmlDeviceGetTemperatureV - data["__nvmlDeviceGetTemperatureV"] = <_cyb_intptr_t>__nvmlDeviceGetTemperatureV + data["__nvmlDeviceGetTemperatureV"] = <intptr_t>__nvmlDeviceGetTemperatureV global __nvmlDeviceGetTemperatureThreshold - data["__nvmlDeviceGetTemperatureThreshold"] = <_cyb_intptr_t>__nvmlDeviceGetTemperatureThreshold + data["__nvmlDeviceGetTemperatureThreshold"] = <intptr_t>__nvmlDeviceGetTemperatureThreshold global __nvmlDeviceGetMarginTemperature - data["__nvmlDeviceGetMarginTemperature"] = <_cyb_intptr_t>__nvmlDeviceGetMarginTemperature + data["__nvmlDeviceGetMarginTemperature"] = <intptr_t>__nvmlDeviceGetMarginTemperature global __nvmlDeviceGetThermalSettings - data["__nvmlDeviceGetThermalSettings"] = <_cyb_intptr_t>__nvmlDeviceGetThermalSettings + data["__nvmlDeviceGetThermalSettings"] = <intptr_t>__nvmlDeviceGetThermalSettings global __nvmlDeviceGetPerformanceState - data["__nvmlDeviceGetPerformanceState"] = <_cyb_intptr_t>__nvmlDeviceGetPerformanceState + data["__nvmlDeviceGetPerformanceState"] = <intptr_t>__nvmlDeviceGetPerformanceState global __nvmlDeviceGetCurrentClocksEventReasons - data["__nvmlDeviceGetCurrentClocksEventReasons"] = <_cyb_intptr_t>__nvmlDeviceGetCurrentClocksEventReasons + data["__nvmlDeviceGetCurrentClocksEventReasons"] = <intptr_t>__nvmlDeviceGetCurrentClocksEventReasons global __nvmlDeviceGetSupportedClocksEventReasons - data["__nvmlDeviceGetSupportedClocksEventReasons"] = <_cyb_intptr_t>__nvmlDeviceGetSupportedClocksEventReasons + data["__nvmlDeviceGetSupportedClocksEventReasons"] = <intptr_t>__nvmlDeviceGetSupportedClocksEventReasons global __nvmlDeviceGetPowerState - data["__nvmlDeviceGetPowerState"] = <_cyb_intptr_t>__nvmlDeviceGetPowerState + data["__nvmlDeviceGetPowerState"] = <intptr_t>__nvmlDeviceGetPowerState global __nvmlDeviceGetDynamicPstatesInfo - data["__nvmlDeviceGetDynamicPstatesInfo"] = <_cyb_intptr_t>__nvmlDeviceGetDynamicPstatesInfo + data["__nvmlDeviceGetDynamicPstatesInfo"] = <intptr_t>__nvmlDeviceGetDynamicPstatesInfo global __nvmlDeviceGetMemClkVfOffset - data["__nvmlDeviceGetMemClkVfOffset"] = <_cyb_intptr_t>__nvmlDeviceGetMemClkVfOffset + data["__nvmlDeviceGetMemClkVfOffset"] = <intptr_t>__nvmlDeviceGetMemClkVfOffset global __nvmlDeviceGetMinMaxClockOfPState - data["__nvmlDeviceGetMinMaxClockOfPState"] = <_cyb_intptr_t>__nvmlDeviceGetMinMaxClockOfPState + data["__nvmlDeviceGetMinMaxClockOfPState"] = <intptr_t>__nvmlDeviceGetMinMaxClockOfPState global __nvmlDeviceGetSupportedPerformanceStates - data["__nvmlDeviceGetSupportedPerformanceStates"] = <_cyb_intptr_t>__nvmlDeviceGetSupportedPerformanceStates + data["__nvmlDeviceGetSupportedPerformanceStates"] = <intptr_t>__nvmlDeviceGetSupportedPerformanceStates global __nvmlDeviceGetGpcClkMinMaxVfOffset - data["__nvmlDeviceGetGpcClkMinMaxVfOffset"] = <_cyb_intptr_t>__nvmlDeviceGetGpcClkMinMaxVfOffset + data["__nvmlDeviceGetGpcClkMinMaxVfOffset"] = <intptr_t>__nvmlDeviceGetGpcClkMinMaxVfOffset global __nvmlDeviceGetMemClkMinMaxVfOffset - data["__nvmlDeviceGetMemClkMinMaxVfOffset"] = <_cyb_intptr_t>__nvmlDeviceGetMemClkMinMaxVfOffset + data["__nvmlDeviceGetMemClkMinMaxVfOffset"] = <intptr_t>__nvmlDeviceGetMemClkMinMaxVfOffset global __nvmlDeviceGetClockOffsets - data["__nvmlDeviceGetClockOffsets"] = <_cyb_intptr_t>__nvmlDeviceGetClockOffsets + data["__nvmlDeviceGetClockOffsets"] = <intptr_t>__nvmlDeviceGetClockOffsets global __nvmlDeviceSetClockOffsets - data["__nvmlDeviceSetClockOffsets"] = <_cyb_intptr_t>__nvmlDeviceSetClockOffsets + data["__nvmlDeviceSetClockOffsets"] = <intptr_t>__nvmlDeviceSetClockOffsets global __nvmlDeviceGetPerformanceModes - data["__nvmlDeviceGetPerformanceModes"] = <_cyb_intptr_t>__nvmlDeviceGetPerformanceModes + data["__nvmlDeviceGetPerformanceModes"] = <intptr_t>__nvmlDeviceGetPerformanceModes global __nvmlDeviceGetCurrentClockFreqs - data["__nvmlDeviceGetCurrentClockFreqs"] = <_cyb_intptr_t>__nvmlDeviceGetCurrentClockFreqs + data["__nvmlDeviceGetCurrentClockFreqs"] = <intptr_t>__nvmlDeviceGetCurrentClockFreqs global __nvmlDeviceGetPowerManagementLimit - data["__nvmlDeviceGetPowerManagementLimit"] = <_cyb_intptr_t>__nvmlDeviceGetPowerManagementLimit + data["__nvmlDeviceGetPowerManagementLimit"] = <intptr_t>__nvmlDeviceGetPowerManagementLimit global __nvmlDeviceGetPowerManagementLimitConstraints - data["__nvmlDeviceGetPowerManagementLimitConstraints"] = <_cyb_intptr_t>__nvmlDeviceGetPowerManagementLimitConstraints + data["__nvmlDeviceGetPowerManagementLimitConstraints"] = <intptr_t>__nvmlDeviceGetPowerManagementLimitConstraints global __nvmlDeviceGetPowerManagementDefaultLimit - data["__nvmlDeviceGetPowerManagementDefaultLimit"] = <_cyb_intptr_t>__nvmlDeviceGetPowerManagementDefaultLimit + data["__nvmlDeviceGetPowerManagementDefaultLimit"] = <intptr_t>__nvmlDeviceGetPowerManagementDefaultLimit global __nvmlDeviceGetPowerUsage - data["__nvmlDeviceGetPowerUsage"] = <_cyb_intptr_t>__nvmlDeviceGetPowerUsage + data["__nvmlDeviceGetPowerUsage"] = <intptr_t>__nvmlDeviceGetPowerUsage global __nvmlDeviceGetTotalEnergyConsumption - data["__nvmlDeviceGetTotalEnergyConsumption"] = <_cyb_intptr_t>__nvmlDeviceGetTotalEnergyConsumption + data["__nvmlDeviceGetTotalEnergyConsumption"] = <intptr_t>__nvmlDeviceGetTotalEnergyConsumption global __nvmlDeviceGetEnforcedPowerLimit - data["__nvmlDeviceGetEnforcedPowerLimit"] = <_cyb_intptr_t>__nvmlDeviceGetEnforcedPowerLimit + data["__nvmlDeviceGetEnforcedPowerLimit"] = <intptr_t>__nvmlDeviceGetEnforcedPowerLimit global __nvmlDeviceGetGpuOperationMode - data["__nvmlDeviceGetGpuOperationMode"] = <_cyb_intptr_t>__nvmlDeviceGetGpuOperationMode + data["__nvmlDeviceGetGpuOperationMode"] = <intptr_t>__nvmlDeviceGetGpuOperationMode global __nvmlDeviceGetMemoryInfo_v2 - data["__nvmlDeviceGetMemoryInfo_v2"] = <_cyb_intptr_t>__nvmlDeviceGetMemoryInfo_v2 + data["__nvmlDeviceGetMemoryInfo_v2"] = <intptr_t>__nvmlDeviceGetMemoryInfo_v2 global __nvmlDeviceGetComputeMode - data["__nvmlDeviceGetComputeMode"] = <_cyb_intptr_t>__nvmlDeviceGetComputeMode + data["__nvmlDeviceGetComputeMode"] = <intptr_t>__nvmlDeviceGetComputeMode global __nvmlDeviceGetCudaComputeCapability - data["__nvmlDeviceGetCudaComputeCapability"] = <_cyb_intptr_t>__nvmlDeviceGetCudaComputeCapability + data["__nvmlDeviceGetCudaComputeCapability"] = <intptr_t>__nvmlDeviceGetCudaComputeCapability global __nvmlDeviceGetDramEncryptionMode - data["__nvmlDeviceGetDramEncryptionMode"] = <_cyb_intptr_t>__nvmlDeviceGetDramEncryptionMode + data["__nvmlDeviceGetDramEncryptionMode"] = <intptr_t>__nvmlDeviceGetDramEncryptionMode global __nvmlDeviceSetDramEncryptionMode - data["__nvmlDeviceSetDramEncryptionMode"] = <_cyb_intptr_t>__nvmlDeviceSetDramEncryptionMode + data["__nvmlDeviceSetDramEncryptionMode"] = <intptr_t>__nvmlDeviceSetDramEncryptionMode global __nvmlDeviceGetEccMode - data["__nvmlDeviceGetEccMode"] = <_cyb_intptr_t>__nvmlDeviceGetEccMode + data["__nvmlDeviceGetEccMode"] = <intptr_t>__nvmlDeviceGetEccMode global __nvmlDeviceGetDefaultEccMode - data["__nvmlDeviceGetDefaultEccMode"] = <_cyb_intptr_t>__nvmlDeviceGetDefaultEccMode + data["__nvmlDeviceGetDefaultEccMode"] = <intptr_t>__nvmlDeviceGetDefaultEccMode global __nvmlDeviceGetBoardId - data["__nvmlDeviceGetBoardId"] = <_cyb_intptr_t>__nvmlDeviceGetBoardId + data["__nvmlDeviceGetBoardId"] = <intptr_t>__nvmlDeviceGetBoardId global __nvmlDeviceGetMultiGpuBoard - data["__nvmlDeviceGetMultiGpuBoard"] = <_cyb_intptr_t>__nvmlDeviceGetMultiGpuBoard + data["__nvmlDeviceGetMultiGpuBoard"] = <intptr_t>__nvmlDeviceGetMultiGpuBoard global __nvmlDeviceGetTotalEccErrors - data["__nvmlDeviceGetTotalEccErrors"] = <_cyb_intptr_t>__nvmlDeviceGetTotalEccErrors + data["__nvmlDeviceGetTotalEccErrors"] = <intptr_t>__nvmlDeviceGetTotalEccErrors global __nvmlDeviceGetMemoryErrorCounter - data["__nvmlDeviceGetMemoryErrorCounter"] = <_cyb_intptr_t>__nvmlDeviceGetMemoryErrorCounter + data["__nvmlDeviceGetMemoryErrorCounter"] = <intptr_t>__nvmlDeviceGetMemoryErrorCounter global __nvmlDeviceGetUtilizationRates - data["__nvmlDeviceGetUtilizationRates"] = <_cyb_intptr_t>__nvmlDeviceGetUtilizationRates + data["__nvmlDeviceGetUtilizationRates"] = <intptr_t>__nvmlDeviceGetUtilizationRates global __nvmlDeviceGetEncoderUtilization - data["__nvmlDeviceGetEncoderUtilization"] = <_cyb_intptr_t>__nvmlDeviceGetEncoderUtilization + data["__nvmlDeviceGetEncoderUtilization"] = <intptr_t>__nvmlDeviceGetEncoderUtilization global __nvmlDeviceGetEncoderCapacity - data["__nvmlDeviceGetEncoderCapacity"] = <_cyb_intptr_t>__nvmlDeviceGetEncoderCapacity + data["__nvmlDeviceGetEncoderCapacity"] = <intptr_t>__nvmlDeviceGetEncoderCapacity global __nvmlDeviceGetEncoderStats - data["__nvmlDeviceGetEncoderStats"] = <_cyb_intptr_t>__nvmlDeviceGetEncoderStats + data["__nvmlDeviceGetEncoderStats"] = <intptr_t>__nvmlDeviceGetEncoderStats global __nvmlDeviceGetEncoderSessions - data["__nvmlDeviceGetEncoderSessions"] = <_cyb_intptr_t>__nvmlDeviceGetEncoderSessions + data["__nvmlDeviceGetEncoderSessions"] = <intptr_t>__nvmlDeviceGetEncoderSessions global __nvmlDeviceGetDecoderUtilization - data["__nvmlDeviceGetDecoderUtilization"] = <_cyb_intptr_t>__nvmlDeviceGetDecoderUtilization + data["__nvmlDeviceGetDecoderUtilization"] = <intptr_t>__nvmlDeviceGetDecoderUtilization global __nvmlDeviceGetJpgUtilization - data["__nvmlDeviceGetJpgUtilization"] = <_cyb_intptr_t>__nvmlDeviceGetJpgUtilization + data["__nvmlDeviceGetJpgUtilization"] = <intptr_t>__nvmlDeviceGetJpgUtilization global __nvmlDeviceGetOfaUtilization - data["__nvmlDeviceGetOfaUtilization"] = <_cyb_intptr_t>__nvmlDeviceGetOfaUtilization + data["__nvmlDeviceGetOfaUtilization"] = <intptr_t>__nvmlDeviceGetOfaUtilization global __nvmlDeviceGetFBCStats - data["__nvmlDeviceGetFBCStats"] = <_cyb_intptr_t>__nvmlDeviceGetFBCStats + data["__nvmlDeviceGetFBCStats"] = <intptr_t>__nvmlDeviceGetFBCStats global __nvmlDeviceGetFBCSessions - data["__nvmlDeviceGetFBCSessions"] = <_cyb_intptr_t>__nvmlDeviceGetFBCSessions + data["__nvmlDeviceGetFBCSessions"] = <intptr_t>__nvmlDeviceGetFBCSessions global __nvmlDeviceGetDriverModel_v2 - data["__nvmlDeviceGetDriverModel_v2"] = <_cyb_intptr_t>__nvmlDeviceGetDriverModel_v2 + data["__nvmlDeviceGetDriverModel_v2"] = <intptr_t>__nvmlDeviceGetDriverModel_v2 global __nvmlDeviceGetVbiosVersion - data["__nvmlDeviceGetVbiosVersion"] = <_cyb_intptr_t>__nvmlDeviceGetVbiosVersion + data["__nvmlDeviceGetVbiosVersion"] = <intptr_t>__nvmlDeviceGetVbiosVersion global __nvmlDeviceGetBridgeChipInfo - data["__nvmlDeviceGetBridgeChipInfo"] = <_cyb_intptr_t>__nvmlDeviceGetBridgeChipInfo + data["__nvmlDeviceGetBridgeChipInfo"] = <intptr_t>__nvmlDeviceGetBridgeChipInfo global __nvmlDeviceGetComputeRunningProcesses_v3 - data["__nvmlDeviceGetComputeRunningProcesses_v3"] = <_cyb_intptr_t>__nvmlDeviceGetComputeRunningProcesses_v3 + data["__nvmlDeviceGetComputeRunningProcesses_v3"] = <intptr_t>__nvmlDeviceGetComputeRunningProcesses_v3 global __nvmlDeviceGetGraphicsRunningProcesses_v3 - data["__nvmlDeviceGetGraphicsRunningProcesses_v3"] = <_cyb_intptr_t>__nvmlDeviceGetGraphicsRunningProcesses_v3 + data["__nvmlDeviceGetGraphicsRunningProcesses_v3"] = <intptr_t>__nvmlDeviceGetGraphicsRunningProcesses_v3 global __nvmlDeviceGetMPSComputeRunningProcesses_v3 - data["__nvmlDeviceGetMPSComputeRunningProcesses_v3"] = <_cyb_intptr_t>__nvmlDeviceGetMPSComputeRunningProcesses_v3 + data["__nvmlDeviceGetMPSComputeRunningProcesses_v3"] = <intptr_t>__nvmlDeviceGetMPSComputeRunningProcesses_v3 global __nvmlDeviceGetRunningProcessDetailList - data["__nvmlDeviceGetRunningProcessDetailList"] = <_cyb_intptr_t>__nvmlDeviceGetRunningProcessDetailList + data["__nvmlDeviceGetRunningProcessDetailList"] = <intptr_t>__nvmlDeviceGetRunningProcessDetailList global __nvmlDeviceOnSameBoard - data["__nvmlDeviceOnSameBoard"] = <_cyb_intptr_t>__nvmlDeviceOnSameBoard + data["__nvmlDeviceOnSameBoard"] = <intptr_t>__nvmlDeviceOnSameBoard global __nvmlDeviceGetAPIRestriction - data["__nvmlDeviceGetAPIRestriction"] = <_cyb_intptr_t>__nvmlDeviceGetAPIRestriction + data["__nvmlDeviceGetAPIRestriction"] = <intptr_t>__nvmlDeviceGetAPIRestriction global __nvmlDeviceGetSamples - data["__nvmlDeviceGetSamples"] = <_cyb_intptr_t>__nvmlDeviceGetSamples + data["__nvmlDeviceGetSamples"] = <intptr_t>__nvmlDeviceGetSamples global __nvmlDeviceGetBAR1MemoryInfo - data["__nvmlDeviceGetBAR1MemoryInfo"] = <_cyb_intptr_t>__nvmlDeviceGetBAR1MemoryInfo + data["__nvmlDeviceGetBAR1MemoryInfo"] = <intptr_t>__nvmlDeviceGetBAR1MemoryInfo global __nvmlDeviceGetIrqNum - data["__nvmlDeviceGetIrqNum"] = <_cyb_intptr_t>__nvmlDeviceGetIrqNum + data["__nvmlDeviceGetIrqNum"] = <intptr_t>__nvmlDeviceGetIrqNum global __nvmlDeviceGetNumGpuCores - data["__nvmlDeviceGetNumGpuCores"] = <_cyb_intptr_t>__nvmlDeviceGetNumGpuCores + data["__nvmlDeviceGetNumGpuCores"] = <intptr_t>__nvmlDeviceGetNumGpuCores global __nvmlDeviceGetPowerSource - data["__nvmlDeviceGetPowerSource"] = <_cyb_intptr_t>__nvmlDeviceGetPowerSource + data["__nvmlDeviceGetPowerSource"] = <intptr_t>__nvmlDeviceGetPowerSource global __nvmlDeviceGetMemoryBusWidth - data["__nvmlDeviceGetMemoryBusWidth"] = <_cyb_intptr_t>__nvmlDeviceGetMemoryBusWidth + data["__nvmlDeviceGetMemoryBusWidth"] = <intptr_t>__nvmlDeviceGetMemoryBusWidth global __nvmlDeviceGetPcieLinkMaxSpeed - data["__nvmlDeviceGetPcieLinkMaxSpeed"] = <_cyb_intptr_t>__nvmlDeviceGetPcieLinkMaxSpeed + data["__nvmlDeviceGetPcieLinkMaxSpeed"] = <intptr_t>__nvmlDeviceGetPcieLinkMaxSpeed global __nvmlDeviceGetPcieSpeed - data["__nvmlDeviceGetPcieSpeed"] = <_cyb_intptr_t>__nvmlDeviceGetPcieSpeed + data["__nvmlDeviceGetPcieSpeed"] = <intptr_t>__nvmlDeviceGetPcieSpeed global __nvmlDeviceGetAdaptiveClockInfoStatus - data["__nvmlDeviceGetAdaptiveClockInfoStatus"] = <_cyb_intptr_t>__nvmlDeviceGetAdaptiveClockInfoStatus + data["__nvmlDeviceGetAdaptiveClockInfoStatus"] = <intptr_t>__nvmlDeviceGetAdaptiveClockInfoStatus global __nvmlDeviceGetBusType - data["__nvmlDeviceGetBusType"] = <_cyb_intptr_t>__nvmlDeviceGetBusType + data["__nvmlDeviceGetBusType"] = <intptr_t>__nvmlDeviceGetBusType global __nvmlDeviceGetGpuFabricInfoV - data["__nvmlDeviceGetGpuFabricInfoV"] = <_cyb_intptr_t>__nvmlDeviceGetGpuFabricInfoV + data["__nvmlDeviceGetGpuFabricInfoV"] = <intptr_t>__nvmlDeviceGetGpuFabricInfoV global __nvmlSystemGetConfComputeCapabilities - data["__nvmlSystemGetConfComputeCapabilities"] = <_cyb_intptr_t>__nvmlSystemGetConfComputeCapabilities + data["__nvmlSystemGetConfComputeCapabilities"] = <intptr_t>__nvmlSystemGetConfComputeCapabilities global __nvmlSystemGetConfComputeState - data["__nvmlSystemGetConfComputeState"] = <_cyb_intptr_t>__nvmlSystemGetConfComputeState + data["__nvmlSystemGetConfComputeState"] = <intptr_t>__nvmlSystemGetConfComputeState global __nvmlDeviceGetConfComputeMemSizeInfo - data["__nvmlDeviceGetConfComputeMemSizeInfo"] = <_cyb_intptr_t>__nvmlDeviceGetConfComputeMemSizeInfo + data["__nvmlDeviceGetConfComputeMemSizeInfo"] = <intptr_t>__nvmlDeviceGetConfComputeMemSizeInfo global __nvmlSystemGetConfComputeGpusReadyState - data["__nvmlSystemGetConfComputeGpusReadyState"] = <_cyb_intptr_t>__nvmlSystemGetConfComputeGpusReadyState + data["__nvmlSystemGetConfComputeGpusReadyState"] = <intptr_t>__nvmlSystemGetConfComputeGpusReadyState global __nvmlDeviceGetConfComputeProtectedMemoryUsage - data["__nvmlDeviceGetConfComputeProtectedMemoryUsage"] = <_cyb_intptr_t>__nvmlDeviceGetConfComputeProtectedMemoryUsage + data["__nvmlDeviceGetConfComputeProtectedMemoryUsage"] = <intptr_t>__nvmlDeviceGetConfComputeProtectedMemoryUsage global __nvmlDeviceGetConfComputeGpuCertificate - data["__nvmlDeviceGetConfComputeGpuCertificate"] = <_cyb_intptr_t>__nvmlDeviceGetConfComputeGpuCertificate + data["__nvmlDeviceGetConfComputeGpuCertificate"] = <intptr_t>__nvmlDeviceGetConfComputeGpuCertificate global __nvmlDeviceGetConfComputeGpuAttestationReport - data["__nvmlDeviceGetConfComputeGpuAttestationReport"] = <_cyb_intptr_t>__nvmlDeviceGetConfComputeGpuAttestationReport + data["__nvmlDeviceGetConfComputeGpuAttestationReport"] = <intptr_t>__nvmlDeviceGetConfComputeGpuAttestationReport global __nvmlSystemGetConfComputeKeyRotationThresholdInfo - data["__nvmlSystemGetConfComputeKeyRotationThresholdInfo"] = <_cyb_intptr_t>__nvmlSystemGetConfComputeKeyRotationThresholdInfo + data["__nvmlSystemGetConfComputeKeyRotationThresholdInfo"] = <intptr_t>__nvmlSystemGetConfComputeKeyRotationThresholdInfo global __nvmlDeviceSetConfComputeUnprotectedMemSize - data["__nvmlDeviceSetConfComputeUnprotectedMemSize"] = <_cyb_intptr_t>__nvmlDeviceSetConfComputeUnprotectedMemSize + data["__nvmlDeviceSetConfComputeUnprotectedMemSize"] = <intptr_t>__nvmlDeviceSetConfComputeUnprotectedMemSize global __nvmlSystemSetConfComputeGpusReadyState - data["__nvmlSystemSetConfComputeGpusReadyState"] = <_cyb_intptr_t>__nvmlSystemSetConfComputeGpusReadyState + data["__nvmlSystemSetConfComputeGpusReadyState"] = <intptr_t>__nvmlSystemSetConfComputeGpusReadyState global __nvmlSystemSetConfComputeKeyRotationThresholdInfo - data["__nvmlSystemSetConfComputeKeyRotationThresholdInfo"] = <_cyb_intptr_t>__nvmlSystemSetConfComputeKeyRotationThresholdInfo + data["__nvmlSystemSetConfComputeKeyRotationThresholdInfo"] = <intptr_t>__nvmlSystemSetConfComputeKeyRotationThresholdInfo global __nvmlSystemGetConfComputeSettings - data["__nvmlSystemGetConfComputeSettings"] = <_cyb_intptr_t>__nvmlSystemGetConfComputeSettings + data["__nvmlSystemGetConfComputeSettings"] = <intptr_t>__nvmlSystemGetConfComputeSettings global __nvmlDeviceGetGspFirmwareVersion - data["__nvmlDeviceGetGspFirmwareVersion"] = <_cyb_intptr_t>__nvmlDeviceGetGspFirmwareVersion + data["__nvmlDeviceGetGspFirmwareVersion"] = <intptr_t>__nvmlDeviceGetGspFirmwareVersion global __nvmlDeviceGetGspFirmwareMode - data["__nvmlDeviceGetGspFirmwareMode"] = <_cyb_intptr_t>__nvmlDeviceGetGspFirmwareMode + data["__nvmlDeviceGetGspFirmwareMode"] = <intptr_t>__nvmlDeviceGetGspFirmwareMode global __nvmlDeviceGetSramEccErrorStatus - data["__nvmlDeviceGetSramEccErrorStatus"] = <_cyb_intptr_t>__nvmlDeviceGetSramEccErrorStatus + data["__nvmlDeviceGetSramEccErrorStatus"] = <intptr_t>__nvmlDeviceGetSramEccErrorStatus global __nvmlDeviceGetAccountingMode - data["__nvmlDeviceGetAccountingMode"] = <_cyb_intptr_t>__nvmlDeviceGetAccountingMode + data["__nvmlDeviceGetAccountingMode"] = <intptr_t>__nvmlDeviceGetAccountingMode global __nvmlDeviceGetAccountingStats - data["__nvmlDeviceGetAccountingStats"] = <_cyb_intptr_t>__nvmlDeviceGetAccountingStats + data["__nvmlDeviceGetAccountingStats"] = <intptr_t>__nvmlDeviceGetAccountingStats global __nvmlDeviceGetAccountingPids - data["__nvmlDeviceGetAccountingPids"] = <_cyb_intptr_t>__nvmlDeviceGetAccountingPids + data["__nvmlDeviceGetAccountingPids"] = <intptr_t>__nvmlDeviceGetAccountingPids global __nvmlDeviceGetAccountingBufferSize - data["__nvmlDeviceGetAccountingBufferSize"] = <_cyb_intptr_t>__nvmlDeviceGetAccountingBufferSize + data["__nvmlDeviceGetAccountingBufferSize"] = <intptr_t>__nvmlDeviceGetAccountingBufferSize global __nvmlDeviceGetRetiredPages - data["__nvmlDeviceGetRetiredPages"] = <_cyb_intptr_t>__nvmlDeviceGetRetiredPages + data["__nvmlDeviceGetRetiredPages"] = <intptr_t>__nvmlDeviceGetRetiredPages global __nvmlDeviceGetRetiredPages_v2 - data["__nvmlDeviceGetRetiredPages_v2"] = <_cyb_intptr_t>__nvmlDeviceGetRetiredPages_v2 + data["__nvmlDeviceGetRetiredPages_v2"] = <intptr_t>__nvmlDeviceGetRetiredPages_v2 global __nvmlDeviceGetRetiredPagesPendingStatus - data["__nvmlDeviceGetRetiredPagesPendingStatus"] = <_cyb_intptr_t>__nvmlDeviceGetRetiredPagesPendingStatus + data["__nvmlDeviceGetRetiredPagesPendingStatus"] = <intptr_t>__nvmlDeviceGetRetiredPagesPendingStatus global __nvmlDeviceGetRemappedRows - data["__nvmlDeviceGetRemappedRows"] = <_cyb_intptr_t>__nvmlDeviceGetRemappedRows + data["__nvmlDeviceGetRemappedRows"] = <intptr_t>__nvmlDeviceGetRemappedRows global __nvmlDeviceGetRowRemapperHistogram - data["__nvmlDeviceGetRowRemapperHistogram"] = <_cyb_intptr_t>__nvmlDeviceGetRowRemapperHistogram + data["__nvmlDeviceGetRowRemapperHistogram"] = <intptr_t>__nvmlDeviceGetRowRemapperHistogram global __nvmlDeviceGetArchitecture - data["__nvmlDeviceGetArchitecture"] = <_cyb_intptr_t>__nvmlDeviceGetArchitecture + data["__nvmlDeviceGetArchitecture"] = <intptr_t>__nvmlDeviceGetArchitecture global __nvmlDeviceGetClkMonStatus - data["__nvmlDeviceGetClkMonStatus"] = <_cyb_intptr_t>__nvmlDeviceGetClkMonStatus + data["__nvmlDeviceGetClkMonStatus"] = <intptr_t>__nvmlDeviceGetClkMonStatus global __nvmlDeviceGetProcessUtilization - data["__nvmlDeviceGetProcessUtilization"] = <_cyb_intptr_t>__nvmlDeviceGetProcessUtilization + data["__nvmlDeviceGetProcessUtilization"] = <intptr_t>__nvmlDeviceGetProcessUtilization global __nvmlDeviceGetProcessesUtilizationInfo - data["__nvmlDeviceGetProcessesUtilizationInfo"] = <_cyb_intptr_t>__nvmlDeviceGetProcessesUtilizationInfo + data["__nvmlDeviceGetProcessesUtilizationInfo"] = <intptr_t>__nvmlDeviceGetProcessesUtilizationInfo global __nvmlDeviceGetPlatformInfo - data["__nvmlDeviceGetPlatformInfo"] = <_cyb_intptr_t>__nvmlDeviceGetPlatformInfo + data["__nvmlDeviceGetPlatformInfo"] = <intptr_t>__nvmlDeviceGetPlatformInfo global __nvmlUnitSetLedState - data["__nvmlUnitSetLedState"] = <_cyb_intptr_t>__nvmlUnitSetLedState + data["__nvmlUnitSetLedState"] = <intptr_t>__nvmlUnitSetLedState global __nvmlDeviceSetPersistenceMode - data["__nvmlDeviceSetPersistenceMode"] = <_cyb_intptr_t>__nvmlDeviceSetPersistenceMode + data["__nvmlDeviceSetPersistenceMode"] = <intptr_t>__nvmlDeviceSetPersistenceMode global __nvmlDeviceSetComputeMode - data["__nvmlDeviceSetComputeMode"] = <_cyb_intptr_t>__nvmlDeviceSetComputeMode + data["__nvmlDeviceSetComputeMode"] = <intptr_t>__nvmlDeviceSetComputeMode global __nvmlDeviceSetEccMode - data["__nvmlDeviceSetEccMode"] = <_cyb_intptr_t>__nvmlDeviceSetEccMode + data["__nvmlDeviceSetEccMode"] = <intptr_t>__nvmlDeviceSetEccMode global __nvmlDeviceClearEccErrorCounts - data["__nvmlDeviceClearEccErrorCounts"] = <_cyb_intptr_t>__nvmlDeviceClearEccErrorCounts + data["__nvmlDeviceClearEccErrorCounts"] = <intptr_t>__nvmlDeviceClearEccErrorCounts global __nvmlDeviceSetDriverModel - data["__nvmlDeviceSetDriverModel"] = <_cyb_intptr_t>__nvmlDeviceSetDriverModel + data["__nvmlDeviceSetDriverModel"] = <intptr_t>__nvmlDeviceSetDriverModel global __nvmlDeviceSetGpuLockedClocks - data["__nvmlDeviceSetGpuLockedClocks"] = <_cyb_intptr_t>__nvmlDeviceSetGpuLockedClocks + data["__nvmlDeviceSetGpuLockedClocks"] = <intptr_t>__nvmlDeviceSetGpuLockedClocks global __nvmlDeviceResetGpuLockedClocks - data["__nvmlDeviceResetGpuLockedClocks"] = <_cyb_intptr_t>__nvmlDeviceResetGpuLockedClocks + data["__nvmlDeviceResetGpuLockedClocks"] = <intptr_t>__nvmlDeviceResetGpuLockedClocks global __nvmlDeviceSetMemoryLockedClocks - data["__nvmlDeviceSetMemoryLockedClocks"] = <_cyb_intptr_t>__nvmlDeviceSetMemoryLockedClocks + data["__nvmlDeviceSetMemoryLockedClocks"] = <intptr_t>__nvmlDeviceSetMemoryLockedClocks global __nvmlDeviceResetMemoryLockedClocks - data["__nvmlDeviceResetMemoryLockedClocks"] = <_cyb_intptr_t>__nvmlDeviceResetMemoryLockedClocks + data["__nvmlDeviceResetMemoryLockedClocks"] = <intptr_t>__nvmlDeviceResetMemoryLockedClocks global __nvmlDeviceSetAutoBoostedClocksEnabled - data["__nvmlDeviceSetAutoBoostedClocksEnabled"] = <_cyb_intptr_t>__nvmlDeviceSetAutoBoostedClocksEnabled + data["__nvmlDeviceSetAutoBoostedClocksEnabled"] = <intptr_t>__nvmlDeviceSetAutoBoostedClocksEnabled global __nvmlDeviceSetDefaultAutoBoostedClocksEnabled - data["__nvmlDeviceSetDefaultAutoBoostedClocksEnabled"] = <_cyb_intptr_t>__nvmlDeviceSetDefaultAutoBoostedClocksEnabled + data["__nvmlDeviceSetDefaultAutoBoostedClocksEnabled"] = <intptr_t>__nvmlDeviceSetDefaultAutoBoostedClocksEnabled global __nvmlDeviceSetDefaultFanSpeed_v2 - data["__nvmlDeviceSetDefaultFanSpeed_v2"] = <_cyb_intptr_t>__nvmlDeviceSetDefaultFanSpeed_v2 + data["__nvmlDeviceSetDefaultFanSpeed_v2"] = <intptr_t>__nvmlDeviceSetDefaultFanSpeed_v2 global __nvmlDeviceSetFanControlPolicy - data["__nvmlDeviceSetFanControlPolicy"] = <_cyb_intptr_t>__nvmlDeviceSetFanControlPolicy + data["__nvmlDeviceSetFanControlPolicy"] = <intptr_t>__nvmlDeviceSetFanControlPolicy global __nvmlDeviceSetTemperatureThreshold - data["__nvmlDeviceSetTemperatureThreshold"] = <_cyb_intptr_t>__nvmlDeviceSetTemperatureThreshold + data["__nvmlDeviceSetTemperatureThreshold"] = <intptr_t>__nvmlDeviceSetTemperatureThreshold global __nvmlDeviceSetGpuOperationMode - data["__nvmlDeviceSetGpuOperationMode"] = <_cyb_intptr_t>__nvmlDeviceSetGpuOperationMode + data["__nvmlDeviceSetGpuOperationMode"] = <intptr_t>__nvmlDeviceSetGpuOperationMode global __nvmlDeviceSetAPIRestriction - data["__nvmlDeviceSetAPIRestriction"] = <_cyb_intptr_t>__nvmlDeviceSetAPIRestriction + data["__nvmlDeviceSetAPIRestriction"] = <intptr_t>__nvmlDeviceSetAPIRestriction global __nvmlDeviceSetFanSpeed_v2 - data["__nvmlDeviceSetFanSpeed_v2"] = <_cyb_intptr_t>__nvmlDeviceSetFanSpeed_v2 + data["__nvmlDeviceSetFanSpeed_v2"] = <intptr_t>__nvmlDeviceSetFanSpeed_v2 global __nvmlDeviceSetAccountingMode - data["__nvmlDeviceSetAccountingMode"] = <_cyb_intptr_t>__nvmlDeviceSetAccountingMode + data["__nvmlDeviceSetAccountingMode"] = <intptr_t>__nvmlDeviceSetAccountingMode global __nvmlDeviceClearAccountingPids - data["__nvmlDeviceClearAccountingPids"] = <_cyb_intptr_t>__nvmlDeviceClearAccountingPids + data["__nvmlDeviceClearAccountingPids"] = <intptr_t>__nvmlDeviceClearAccountingPids global __nvmlDeviceSetPowerManagementLimit_v2 - data["__nvmlDeviceSetPowerManagementLimit_v2"] = <_cyb_intptr_t>__nvmlDeviceSetPowerManagementLimit_v2 + data["__nvmlDeviceSetPowerManagementLimit_v2"] = <intptr_t>__nvmlDeviceSetPowerManagementLimit_v2 global __nvmlDeviceGetNvLinkState - data["__nvmlDeviceGetNvLinkState"] = <_cyb_intptr_t>__nvmlDeviceGetNvLinkState + data["__nvmlDeviceGetNvLinkState"] = <intptr_t>__nvmlDeviceGetNvLinkState global __nvmlDeviceGetNvLinkVersion - data["__nvmlDeviceGetNvLinkVersion"] = <_cyb_intptr_t>__nvmlDeviceGetNvLinkVersion + data["__nvmlDeviceGetNvLinkVersion"] = <intptr_t>__nvmlDeviceGetNvLinkVersion global __nvmlDeviceGetNvLinkCapability - data["__nvmlDeviceGetNvLinkCapability"] = <_cyb_intptr_t>__nvmlDeviceGetNvLinkCapability + data["__nvmlDeviceGetNvLinkCapability"] = <intptr_t>__nvmlDeviceGetNvLinkCapability global __nvmlDeviceGetNvLinkRemotePciInfo_v2 - data["__nvmlDeviceGetNvLinkRemotePciInfo_v2"] = <_cyb_intptr_t>__nvmlDeviceGetNvLinkRemotePciInfo_v2 + data["__nvmlDeviceGetNvLinkRemotePciInfo_v2"] = <intptr_t>__nvmlDeviceGetNvLinkRemotePciInfo_v2 global __nvmlDeviceGetNvLinkErrorCounter - data["__nvmlDeviceGetNvLinkErrorCounter"] = <_cyb_intptr_t>__nvmlDeviceGetNvLinkErrorCounter + data["__nvmlDeviceGetNvLinkErrorCounter"] = <intptr_t>__nvmlDeviceGetNvLinkErrorCounter global __nvmlDeviceResetNvLinkErrorCounters - data["__nvmlDeviceResetNvLinkErrorCounters"] = <_cyb_intptr_t>__nvmlDeviceResetNvLinkErrorCounters + data["__nvmlDeviceResetNvLinkErrorCounters"] = <intptr_t>__nvmlDeviceResetNvLinkErrorCounters global __nvmlDeviceGetNvLinkRemoteDeviceType - data["__nvmlDeviceGetNvLinkRemoteDeviceType"] = <_cyb_intptr_t>__nvmlDeviceGetNvLinkRemoteDeviceType + data["__nvmlDeviceGetNvLinkRemoteDeviceType"] = <intptr_t>__nvmlDeviceGetNvLinkRemoteDeviceType global __nvmlDeviceSetNvLinkDeviceLowPowerThreshold - data["__nvmlDeviceSetNvLinkDeviceLowPowerThreshold"] = <_cyb_intptr_t>__nvmlDeviceSetNvLinkDeviceLowPowerThreshold + data["__nvmlDeviceSetNvLinkDeviceLowPowerThreshold"] = <intptr_t>__nvmlDeviceSetNvLinkDeviceLowPowerThreshold global __nvmlSystemSetNvlinkBwMode - data["__nvmlSystemSetNvlinkBwMode"] = <_cyb_intptr_t>__nvmlSystemSetNvlinkBwMode + data["__nvmlSystemSetNvlinkBwMode"] = <intptr_t>__nvmlSystemSetNvlinkBwMode global __nvmlSystemGetNvlinkBwMode - data["__nvmlSystemGetNvlinkBwMode"] = <_cyb_intptr_t>__nvmlSystemGetNvlinkBwMode + data["__nvmlSystemGetNvlinkBwMode"] = <intptr_t>__nvmlSystemGetNvlinkBwMode global __nvmlDeviceGetNvlinkSupportedBwModes - data["__nvmlDeviceGetNvlinkSupportedBwModes"] = <_cyb_intptr_t>__nvmlDeviceGetNvlinkSupportedBwModes + data["__nvmlDeviceGetNvlinkSupportedBwModes"] = <intptr_t>__nvmlDeviceGetNvlinkSupportedBwModes global __nvmlDeviceGetNvlinkBwMode - data["__nvmlDeviceGetNvlinkBwMode"] = <_cyb_intptr_t>__nvmlDeviceGetNvlinkBwMode + data["__nvmlDeviceGetNvlinkBwMode"] = <intptr_t>__nvmlDeviceGetNvlinkBwMode global __nvmlDeviceSetNvlinkBwMode - data["__nvmlDeviceSetNvlinkBwMode"] = <_cyb_intptr_t>__nvmlDeviceSetNvlinkBwMode + data["__nvmlDeviceSetNvlinkBwMode"] = <intptr_t>__nvmlDeviceSetNvlinkBwMode global __nvmlEventSetCreate - data["__nvmlEventSetCreate"] = <_cyb_intptr_t>__nvmlEventSetCreate + data["__nvmlEventSetCreate"] = <intptr_t>__nvmlEventSetCreate global __nvmlDeviceRegisterEvents - data["__nvmlDeviceRegisterEvents"] = <_cyb_intptr_t>__nvmlDeviceRegisterEvents + data["__nvmlDeviceRegisterEvents"] = <intptr_t>__nvmlDeviceRegisterEvents global __nvmlDeviceGetSupportedEventTypes - data["__nvmlDeviceGetSupportedEventTypes"] = <_cyb_intptr_t>__nvmlDeviceGetSupportedEventTypes + data["__nvmlDeviceGetSupportedEventTypes"] = <intptr_t>__nvmlDeviceGetSupportedEventTypes global __nvmlEventSetWait_v2 - data["__nvmlEventSetWait_v2"] = <_cyb_intptr_t>__nvmlEventSetWait_v2 + data["__nvmlEventSetWait_v2"] = <intptr_t>__nvmlEventSetWait_v2 global __nvmlEventSetFree - data["__nvmlEventSetFree"] = <_cyb_intptr_t>__nvmlEventSetFree + data["__nvmlEventSetFree"] = <intptr_t>__nvmlEventSetFree global __nvmlSystemEventSetCreate - data["__nvmlSystemEventSetCreate"] = <_cyb_intptr_t>__nvmlSystemEventSetCreate + data["__nvmlSystemEventSetCreate"] = <intptr_t>__nvmlSystemEventSetCreate global __nvmlSystemEventSetFree - data["__nvmlSystemEventSetFree"] = <_cyb_intptr_t>__nvmlSystemEventSetFree + data["__nvmlSystemEventSetFree"] = <intptr_t>__nvmlSystemEventSetFree global __nvmlSystemRegisterEvents - data["__nvmlSystemRegisterEvents"] = <_cyb_intptr_t>__nvmlSystemRegisterEvents + data["__nvmlSystemRegisterEvents"] = <intptr_t>__nvmlSystemRegisterEvents global __nvmlSystemEventSetWait - data["__nvmlSystemEventSetWait"] = <_cyb_intptr_t>__nvmlSystemEventSetWait + data["__nvmlSystemEventSetWait"] = <intptr_t>__nvmlSystemEventSetWait global __nvmlDeviceModifyDrainState - data["__nvmlDeviceModifyDrainState"] = <_cyb_intptr_t>__nvmlDeviceModifyDrainState + data["__nvmlDeviceModifyDrainState"] = <intptr_t>__nvmlDeviceModifyDrainState global __nvmlDeviceQueryDrainState - data["__nvmlDeviceQueryDrainState"] = <_cyb_intptr_t>__nvmlDeviceQueryDrainState + data["__nvmlDeviceQueryDrainState"] = <intptr_t>__nvmlDeviceQueryDrainState global __nvmlDeviceRemoveGpu_v2 - data["__nvmlDeviceRemoveGpu_v2"] = <_cyb_intptr_t>__nvmlDeviceRemoveGpu_v2 + data["__nvmlDeviceRemoveGpu_v2"] = <intptr_t>__nvmlDeviceRemoveGpu_v2 global __nvmlDeviceDiscoverGpus - data["__nvmlDeviceDiscoverGpus"] = <_cyb_intptr_t>__nvmlDeviceDiscoverGpus + data["__nvmlDeviceDiscoverGpus"] = <intptr_t>__nvmlDeviceDiscoverGpus global __nvmlDeviceGetFieldValues - data["__nvmlDeviceGetFieldValues"] = <_cyb_intptr_t>__nvmlDeviceGetFieldValues + data["__nvmlDeviceGetFieldValues"] = <intptr_t>__nvmlDeviceGetFieldValues global __nvmlDeviceClearFieldValues - data["__nvmlDeviceClearFieldValues"] = <_cyb_intptr_t>__nvmlDeviceClearFieldValues + data["__nvmlDeviceClearFieldValues"] = <intptr_t>__nvmlDeviceClearFieldValues global __nvmlDeviceGetVirtualizationMode - data["__nvmlDeviceGetVirtualizationMode"] = <_cyb_intptr_t>__nvmlDeviceGetVirtualizationMode + data["__nvmlDeviceGetVirtualizationMode"] = <intptr_t>__nvmlDeviceGetVirtualizationMode global __nvmlDeviceGetHostVgpuMode - data["__nvmlDeviceGetHostVgpuMode"] = <_cyb_intptr_t>__nvmlDeviceGetHostVgpuMode + data["__nvmlDeviceGetHostVgpuMode"] = <intptr_t>__nvmlDeviceGetHostVgpuMode global __nvmlDeviceSetVirtualizationMode - data["__nvmlDeviceSetVirtualizationMode"] = <_cyb_intptr_t>__nvmlDeviceSetVirtualizationMode + data["__nvmlDeviceSetVirtualizationMode"] = <intptr_t>__nvmlDeviceSetVirtualizationMode global __nvmlDeviceGetVgpuHeterogeneousMode - data["__nvmlDeviceGetVgpuHeterogeneousMode"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuHeterogeneousMode + data["__nvmlDeviceGetVgpuHeterogeneousMode"] = <intptr_t>__nvmlDeviceGetVgpuHeterogeneousMode global __nvmlDeviceSetVgpuHeterogeneousMode - data["__nvmlDeviceSetVgpuHeterogeneousMode"] = <_cyb_intptr_t>__nvmlDeviceSetVgpuHeterogeneousMode + data["__nvmlDeviceSetVgpuHeterogeneousMode"] = <intptr_t>__nvmlDeviceSetVgpuHeterogeneousMode global __nvmlVgpuInstanceGetPlacementId - data["__nvmlVgpuInstanceGetPlacementId"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetPlacementId + data["__nvmlVgpuInstanceGetPlacementId"] = <intptr_t>__nvmlVgpuInstanceGetPlacementId global __nvmlDeviceGetVgpuTypeSupportedPlacements - data["__nvmlDeviceGetVgpuTypeSupportedPlacements"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuTypeSupportedPlacements + data["__nvmlDeviceGetVgpuTypeSupportedPlacements"] = <intptr_t>__nvmlDeviceGetVgpuTypeSupportedPlacements global __nvmlDeviceGetVgpuTypeCreatablePlacements - data["__nvmlDeviceGetVgpuTypeCreatablePlacements"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuTypeCreatablePlacements + data["__nvmlDeviceGetVgpuTypeCreatablePlacements"] = <intptr_t>__nvmlDeviceGetVgpuTypeCreatablePlacements global __nvmlVgpuTypeGetGspHeapSize - data["__nvmlVgpuTypeGetGspHeapSize"] = <_cyb_intptr_t>__nvmlVgpuTypeGetGspHeapSize + data["__nvmlVgpuTypeGetGspHeapSize"] = <intptr_t>__nvmlVgpuTypeGetGspHeapSize global __nvmlVgpuTypeGetFbReservation - data["__nvmlVgpuTypeGetFbReservation"] = <_cyb_intptr_t>__nvmlVgpuTypeGetFbReservation + data["__nvmlVgpuTypeGetFbReservation"] = <intptr_t>__nvmlVgpuTypeGetFbReservation global __nvmlVgpuInstanceGetRuntimeStateSize - data["__nvmlVgpuInstanceGetRuntimeStateSize"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetRuntimeStateSize + data["__nvmlVgpuInstanceGetRuntimeStateSize"] = <intptr_t>__nvmlVgpuInstanceGetRuntimeStateSize global __nvmlDeviceSetVgpuCapabilities - data["__nvmlDeviceSetVgpuCapabilities"] = <_cyb_intptr_t>__nvmlDeviceSetVgpuCapabilities + data["__nvmlDeviceSetVgpuCapabilities"] = <intptr_t>__nvmlDeviceSetVgpuCapabilities global __nvmlDeviceGetGridLicensableFeatures_v4 - data["__nvmlDeviceGetGridLicensableFeatures_v4"] = <_cyb_intptr_t>__nvmlDeviceGetGridLicensableFeatures_v4 + data["__nvmlDeviceGetGridLicensableFeatures_v4"] = <intptr_t>__nvmlDeviceGetGridLicensableFeatures_v4 global __nvmlGetVgpuDriverCapabilities - data["__nvmlGetVgpuDriverCapabilities"] = <_cyb_intptr_t>__nvmlGetVgpuDriverCapabilities + data["__nvmlGetVgpuDriverCapabilities"] = <intptr_t>__nvmlGetVgpuDriverCapabilities global __nvmlDeviceGetVgpuCapabilities - data["__nvmlDeviceGetVgpuCapabilities"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuCapabilities + data["__nvmlDeviceGetVgpuCapabilities"] = <intptr_t>__nvmlDeviceGetVgpuCapabilities global __nvmlDeviceGetSupportedVgpus - data["__nvmlDeviceGetSupportedVgpus"] = <_cyb_intptr_t>__nvmlDeviceGetSupportedVgpus + data["__nvmlDeviceGetSupportedVgpus"] = <intptr_t>__nvmlDeviceGetSupportedVgpus global __nvmlDeviceGetCreatableVgpus - data["__nvmlDeviceGetCreatableVgpus"] = <_cyb_intptr_t>__nvmlDeviceGetCreatableVgpus + data["__nvmlDeviceGetCreatableVgpus"] = <intptr_t>__nvmlDeviceGetCreatableVgpus global __nvmlVgpuTypeGetClass - data["__nvmlVgpuTypeGetClass"] = <_cyb_intptr_t>__nvmlVgpuTypeGetClass + data["__nvmlVgpuTypeGetClass"] = <intptr_t>__nvmlVgpuTypeGetClass global __nvmlVgpuTypeGetName - data["__nvmlVgpuTypeGetName"] = <_cyb_intptr_t>__nvmlVgpuTypeGetName + data["__nvmlVgpuTypeGetName"] = <intptr_t>__nvmlVgpuTypeGetName global __nvmlVgpuTypeGetGpuInstanceProfileId - data["__nvmlVgpuTypeGetGpuInstanceProfileId"] = <_cyb_intptr_t>__nvmlVgpuTypeGetGpuInstanceProfileId + data["__nvmlVgpuTypeGetGpuInstanceProfileId"] = <intptr_t>__nvmlVgpuTypeGetGpuInstanceProfileId global __nvmlVgpuTypeGetDeviceID - data["__nvmlVgpuTypeGetDeviceID"] = <_cyb_intptr_t>__nvmlVgpuTypeGetDeviceID + data["__nvmlVgpuTypeGetDeviceID"] = <intptr_t>__nvmlVgpuTypeGetDeviceID global __nvmlVgpuTypeGetFramebufferSize - data["__nvmlVgpuTypeGetFramebufferSize"] = <_cyb_intptr_t>__nvmlVgpuTypeGetFramebufferSize + data["__nvmlVgpuTypeGetFramebufferSize"] = <intptr_t>__nvmlVgpuTypeGetFramebufferSize global __nvmlVgpuTypeGetNumDisplayHeads - data["__nvmlVgpuTypeGetNumDisplayHeads"] = <_cyb_intptr_t>__nvmlVgpuTypeGetNumDisplayHeads + data["__nvmlVgpuTypeGetNumDisplayHeads"] = <intptr_t>__nvmlVgpuTypeGetNumDisplayHeads global __nvmlVgpuTypeGetResolution - data["__nvmlVgpuTypeGetResolution"] = <_cyb_intptr_t>__nvmlVgpuTypeGetResolution + data["__nvmlVgpuTypeGetResolution"] = <intptr_t>__nvmlVgpuTypeGetResolution global __nvmlVgpuTypeGetLicense - data["__nvmlVgpuTypeGetLicense"] = <_cyb_intptr_t>__nvmlVgpuTypeGetLicense + data["__nvmlVgpuTypeGetLicense"] = <intptr_t>__nvmlVgpuTypeGetLicense global __nvmlVgpuTypeGetFrameRateLimit - data["__nvmlVgpuTypeGetFrameRateLimit"] = <_cyb_intptr_t>__nvmlVgpuTypeGetFrameRateLimit + data["__nvmlVgpuTypeGetFrameRateLimit"] = <intptr_t>__nvmlVgpuTypeGetFrameRateLimit global __nvmlVgpuTypeGetMaxInstances - data["__nvmlVgpuTypeGetMaxInstances"] = <_cyb_intptr_t>__nvmlVgpuTypeGetMaxInstances + data["__nvmlVgpuTypeGetMaxInstances"] = <intptr_t>__nvmlVgpuTypeGetMaxInstances global __nvmlVgpuTypeGetMaxInstancesPerVm - data["__nvmlVgpuTypeGetMaxInstancesPerVm"] = <_cyb_intptr_t>__nvmlVgpuTypeGetMaxInstancesPerVm + data["__nvmlVgpuTypeGetMaxInstancesPerVm"] = <intptr_t>__nvmlVgpuTypeGetMaxInstancesPerVm global __nvmlVgpuTypeGetBAR1Info - data["__nvmlVgpuTypeGetBAR1Info"] = <_cyb_intptr_t>__nvmlVgpuTypeGetBAR1Info + data["__nvmlVgpuTypeGetBAR1Info"] = <intptr_t>__nvmlVgpuTypeGetBAR1Info global __nvmlDeviceGetActiveVgpus - data["__nvmlDeviceGetActiveVgpus"] = <_cyb_intptr_t>__nvmlDeviceGetActiveVgpus + data["__nvmlDeviceGetActiveVgpus"] = <intptr_t>__nvmlDeviceGetActiveVgpus global __nvmlVgpuInstanceGetVmID - data["__nvmlVgpuInstanceGetVmID"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetVmID + data["__nvmlVgpuInstanceGetVmID"] = <intptr_t>__nvmlVgpuInstanceGetVmID global __nvmlVgpuInstanceGetUUID - data["__nvmlVgpuInstanceGetUUID"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetUUID + data["__nvmlVgpuInstanceGetUUID"] = <intptr_t>__nvmlVgpuInstanceGetUUID global __nvmlVgpuInstanceGetVmDriverVersion - data["__nvmlVgpuInstanceGetVmDriverVersion"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetVmDriverVersion + data["__nvmlVgpuInstanceGetVmDriverVersion"] = <intptr_t>__nvmlVgpuInstanceGetVmDriverVersion global __nvmlVgpuInstanceGetFbUsage - data["__nvmlVgpuInstanceGetFbUsage"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetFbUsage + data["__nvmlVgpuInstanceGetFbUsage"] = <intptr_t>__nvmlVgpuInstanceGetFbUsage global __nvmlVgpuInstanceGetLicenseStatus - data["__nvmlVgpuInstanceGetLicenseStatus"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetLicenseStatus + data["__nvmlVgpuInstanceGetLicenseStatus"] = <intptr_t>__nvmlVgpuInstanceGetLicenseStatus global __nvmlVgpuInstanceGetType - data["__nvmlVgpuInstanceGetType"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetType + data["__nvmlVgpuInstanceGetType"] = <intptr_t>__nvmlVgpuInstanceGetType global __nvmlVgpuInstanceGetFrameRateLimit - data["__nvmlVgpuInstanceGetFrameRateLimit"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetFrameRateLimit + data["__nvmlVgpuInstanceGetFrameRateLimit"] = <intptr_t>__nvmlVgpuInstanceGetFrameRateLimit global __nvmlVgpuInstanceGetEccMode - data["__nvmlVgpuInstanceGetEccMode"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetEccMode + data["__nvmlVgpuInstanceGetEccMode"] = <intptr_t>__nvmlVgpuInstanceGetEccMode global __nvmlVgpuInstanceGetEncoderCapacity - data["__nvmlVgpuInstanceGetEncoderCapacity"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetEncoderCapacity + data["__nvmlVgpuInstanceGetEncoderCapacity"] = <intptr_t>__nvmlVgpuInstanceGetEncoderCapacity global __nvmlVgpuInstanceSetEncoderCapacity - data["__nvmlVgpuInstanceSetEncoderCapacity"] = <_cyb_intptr_t>__nvmlVgpuInstanceSetEncoderCapacity + data["__nvmlVgpuInstanceSetEncoderCapacity"] = <intptr_t>__nvmlVgpuInstanceSetEncoderCapacity global __nvmlVgpuInstanceGetEncoderStats - data["__nvmlVgpuInstanceGetEncoderStats"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetEncoderStats + data["__nvmlVgpuInstanceGetEncoderStats"] = <intptr_t>__nvmlVgpuInstanceGetEncoderStats global __nvmlVgpuInstanceGetEncoderSessions - data["__nvmlVgpuInstanceGetEncoderSessions"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetEncoderSessions + data["__nvmlVgpuInstanceGetEncoderSessions"] = <intptr_t>__nvmlVgpuInstanceGetEncoderSessions global __nvmlVgpuInstanceGetFBCStats - data["__nvmlVgpuInstanceGetFBCStats"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetFBCStats + data["__nvmlVgpuInstanceGetFBCStats"] = <intptr_t>__nvmlVgpuInstanceGetFBCStats global __nvmlVgpuInstanceGetFBCSessions - data["__nvmlVgpuInstanceGetFBCSessions"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetFBCSessions + data["__nvmlVgpuInstanceGetFBCSessions"] = <intptr_t>__nvmlVgpuInstanceGetFBCSessions global __nvmlVgpuInstanceGetGpuInstanceId - data["__nvmlVgpuInstanceGetGpuInstanceId"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetGpuInstanceId + data["__nvmlVgpuInstanceGetGpuInstanceId"] = <intptr_t>__nvmlVgpuInstanceGetGpuInstanceId global __nvmlVgpuInstanceGetGpuPciId - data["__nvmlVgpuInstanceGetGpuPciId"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetGpuPciId + data["__nvmlVgpuInstanceGetGpuPciId"] = <intptr_t>__nvmlVgpuInstanceGetGpuPciId global __nvmlVgpuTypeGetCapabilities - data["__nvmlVgpuTypeGetCapabilities"] = <_cyb_intptr_t>__nvmlVgpuTypeGetCapabilities + data["__nvmlVgpuTypeGetCapabilities"] = <intptr_t>__nvmlVgpuTypeGetCapabilities global __nvmlVgpuInstanceGetMdevUUID - data["__nvmlVgpuInstanceGetMdevUUID"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetMdevUUID + data["__nvmlVgpuInstanceGetMdevUUID"] = <intptr_t>__nvmlVgpuInstanceGetMdevUUID global __nvmlGpuInstanceGetCreatableVgpus - data["__nvmlGpuInstanceGetCreatableVgpus"] = <_cyb_intptr_t>__nvmlGpuInstanceGetCreatableVgpus + data["__nvmlGpuInstanceGetCreatableVgpus"] = <intptr_t>__nvmlGpuInstanceGetCreatableVgpus global __nvmlVgpuTypeGetMaxInstancesPerGpuInstance - data["__nvmlVgpuTypeGetMaxInstancesPerGpuInstance"] = <_cyb_intptr_t>__nvmlVgpuTypeGetMaxInstancesPerGpuInstance + data["__nvmlVgpuTypeGetMaxInstancesPerGpuInstance"] = <intptr_t>__nvmlVgpuTypeGetMaxInstancesPerGpuInstance global __nvmlGpuInstanceGetActiveVgpus - data["__nvmlGpuInstanceGetActiveVgpus"] = <_cyb_intptr_t>__nvmlGpuInstanceGetActiveVgpus + data["__nvmlGpuInstanceGetActiveVgpus"] = <intptr_t>__nvmlGpuInstanceGetActiveVgpus global __nvmlGpuInstanceSetVgpuSchedulerState - data["__nvmlGpuInstanceSetVgpuSchedulerState"] = <_cyb_intptr_t>__nvmlGpuInstanceSetVgpuSchedulerState + data["__nvmlGpuInstanceSetVgpuSchedulerState"] = <intptr_t>__nvmlGpuInstanceSetVgpuSchedulerState global __nvmlGpuInstanceGetVgpuSchedulerState - data["__nvmlGpuInstanceGetVgpuSchedulerState"] = <_cyb_intptr_t>__nvmlGpuInstanceGetVgpuSchedulerState + data["__nvmlGpuInstanceGetVgpuSchedulerState"] = <intptr_t>__nvmlGpuInstanceGetVgpuSchedulerState global __nvmlGpuInstanceGetVgpuSchedulerLog - data["__nvmlGpuInstanceGetVgpuSchedulerLog"] = <_cyb_intptr_t>__nvmlGpuInstanceGetVgpuSchedulerLog + data["__nvmlGpuInstanceGetVgpuSchedulerLog"] = <intptr_t>__nvmlGpuInstanceGetVgpuSchedulerLog global __nvmlGpuInstanceGetVgpuTypeCreatablePlacements - data["__nvmlGpuInstanceGetVgpuTypeCreatablePlacements"] = <_cyb_intptr_t>__nvmlGpuInstanceGetVgpuTypeCreatablePlacements + data["__nvmlGpuInstanceGetVgpuTypeCreatablePlacements"] = <intptr_t>__nvmlGpuInstanceGetVgpuTypeCreatablePlacements global __nvmlGpuInstanceGetVgpuHeterogeneousMode - data["__nvmlGpuInstanceGetVgpuHeterogeneousMode"] = <_cyb_intptr_t>__nvmlGpuInstanceGetVgpuHeterogeneousMode + data["__nvmlGpuInstanceGetVgpuHeterogeneousMode"] = <intptr_t>__nvmlGpuInstanceGetVgpuHeterogeneousMode global __nvmlGpuInstanceSetVgpuHeterogeneousMode - data["__nvmlGpuInstanceSetVgpuHeterogeneousMode"] = <_cyb_intptr_t>__nvmlGpuInstanceSetVgpuHeterogeneousMode + data["__nvmlGpuInstanceSetVgpuHeterogeneousMode"] = <intptr_t>__nvmlGpuInstanceSetVgpuHeterogeneousMode global __nvmlVgpuInstanceGetMetadata - data["__nvmlVgpuInstanceGetMetadata"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetMetadata + data["__nvmlVgpuInstanceGetMetadata"] = <intptr_t>__nvmlVgpuInstanceGetMetadata global __nvmlDeviceGetVgpuMetadata - data["__nvmlDeviceGetVgpuMetadata"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuMetadata + data["__nvmlDeviceGetVgpuMetadata"] = <intptr_t>__nvmlDeviceGetVgpuMetadata global __nvmlGetVgpuCompatibility - data["__nvmlGetVgpuCompatibility"] = <_cyb_intptr_t>__nvmlGetVgpuCompatibility + data["__nvmlGetVgpuCompatibility"] = <intptr_t>__nvmlGetVgpuCompatibility global __nvmlDeviceGetPgpuMetadataString - data["__nvmlDeviceGetPgpuMetadataString"] = <_cyb_intptr_t>__nvmlDeviceGetPgpuMetadataString + data["__nvmlDeviceGetPgpuMetadataString"] = <intptr_t>__nvmlDeviceGetPgpuMetadataString global __nvmlDeviceGetVgpuSchedulerLog - data["__nvmlDeviceGetVgpuSchedulerLog"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuSchedulerLog + data["__nvmlDeviceGetVgpuSchedulerLog"] = <intptr_t>__nvmlDeviceGetVgpuSchedulerLog global __nvmlDeviceGetVgpuSchedulerState - data["__nvmlDeviceGetVgpuSchedulerState"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuSchedulerState + data["__nvmlDeviceGetVgpuSchedulerState"] = <intptr_t>__nvmlDeviceGetVgpuSchedulerState global __nvmlDeviceGetVgpuSchedulerCapabilities - data["__nvmlDeviceGetVgpuSchedulerCapabilities"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuSchedulerCapabilities + data["__nvmlDeviceGetVgpuSchedulerCapabilities"] = <intptr_t>__nvmlDeviceGetVgpuSchedulerCapabilities global __nvmlDeviceSetVgpuSchedulerState - data["__nvmlDeviceSetVgpuSchedulerState"] = <_cyb_intptr_t>__nvmlDeviceSetVgpuSchedulerState + data["__nvmlDeviceSetVgpuSchedulerState"] = <intptr_t>__nvmlDeviceSetVgpuSchedulerState global __nvmlGetVgpuVersion - data["__nvmlGetVgpuVersion"] = <_cyb_intptr_t>__nvmlGetVgpuVersion + data["__nvmlGetVgpuVersion"] = <intptr_t>__nvmlGetVgpuVersion global __nvmlSetVgpuVersion - data["__nvmlSetVgpuVersion"] = <_cyb_intptr_t>__nvmlSetVgpuVersion + data["__nvmlSetVgpuVersion"] = <intptr_t>__nvmlSetVgpuVersion global __nvmlDeviceGetVgpuUtilization - data["__nvmlDeviceGetVgpuUtilization"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuUtilization + data["__nvmlDeviceGetVgpuUtilization"] = <intptr_t>__nvmlDeviceGetVgpuUtilization global __nvmlDeviceGetVgpuInstancesUtilizationInfo - data["__nvmlDeviceGetVgpuInstancesUtilizationInfo"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuInstancesUtilizationInfo + data["__nvmlDeviceGetVgpuInstancesUtilizationInfo"] = <intptr_t>__nvmlDeviceGetVgpuInstancesUtilizationInfo global __nvmlDeviceGetVgpuProcessUtilization - data["__nvmlDeviceGetVgpuProcessUtilization"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuProcessUtilization + data["__nvmlDeviceGetVgpuProcessUtilization"] = <intptr_t>__nvmlDeviceGetVgpuProcessUtilization global __nvmlDeviceGetVgpuProcessesUtilizationInfo - data["__nvmlDeviceGetVgpuProcessesUtilizationInfo"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuProcessesUtilizationInfo + data["__nvmlDeviceGetVgpuProcessesUtilizationInfo"] = <intptr_t>__nvmlDeviceGetVgpuProcessesUtilizationInfo global __nvmlVgpuInstanceGetAccountingMode - data["__nvmlVgpuInstanceGetAccountingMode"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetAccountingMode + data["__nvmlVgpuInstanceGetAccountingMode"] = <intptr_t>__nvmlVgpuInstanceGetAccountingMode global __nvmlVgpuInstanceGetAccountingPids - data["__nvmlVgpuInstanceGetAccountingPids"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetAccountingPids + data["__nvmlVgpuInstanceGetAccountingPids"] = <intptr_t>__nvmlVgpuInstanceGetAccountingPids global __nvmlVgpuInstanceGetAccountingStats - data["__nvmlVgpuInstanceGetAccountingStats"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetAccountingStats + data["__nvmlVgpuInstanceGetAccountingStats"] = <intptr_t>__nvmlVgpuInstanceGetAccountingStats global __nvmlVgpuInstanceClearAccountingPids - data["__nvmlVgpuInstanceClearAccountingPids"] = <_cyb_intptr_t>__nvmlVgpuInstanceClearAccountingPids + data["__nvmlVgpuInstanceClearAccountingPids"] = <intptr_t>__nvmlVgpuInstanceClearAccountingPids global __nvmlVgpuInstanceGetLicenseInfo_v2 - data["__nvmlVgpuInstanceGetLicenseInfo_v2"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetLicenseInfo_v2 + data["__nvmlVgpuInstanceGetLicenseInfo_v2"] = <intptr_t>__nvmlVgpuInstanceGetLicenseInfo_v2 global __nvmlGetExcludedDeviceCount - data["__nvmlGetExcludedDeviceCount"] = <_cyb_intptr_t>__nvmlGetExcludedDeviceCount + data["__nvmlGetExcludedDeviceCount"] = <intptr_t>__nvmlGetExcludedDeviceCount global __nvmlGetExcludedDeviceInfoByIndex - data["__nvmlGetExcludedDeviceInfoByIndex"] = <_cyb_intptr_t>__nvmlGetExcludedDeviceInfoByIndex + data["__nvmlGetExcludedDeviceInfoByIndex"] = <intptr_t>__nvmlGetExcludedDeviceInfoByIndex global __nvmlDeviceSetMigMode - data["__nvmlDeviceSetMigMode"] = <_cyb_intptr_t>__nvmlDeviceSetMigMode + data["__nvmlDeviceSetMigMode"] = <intptr_t>__nvmlDeviceSetMigMode global __nvmlDeviceGetMigMode - data["__nvmlDeviceGetMigMode"] = <_cyb_intptr_t>__nvmlDeviceGetMigMode + data["__nvmlDeviceGetMigMode"] = <intptr_t>__nvmlDeviceGetMigMode global __nvmlDeviceGetGpuInstanceProfileInfoV - data["__nvmlDeviceGetGpuInstanceProfileInfoV"] = <_cyb_intptr_t>__nvmlDeviceGetGpuInstanceProfileInfoV + data["__nvmlDeviceGetGpuInstanceProfileInfoV"] = <intptr_t>__nvmlDeviceGetGpuInstanceProfileInfoV global __nvmlDeviceGetGpuInstancePossiblePlacements_v2 - data["__nvmlDeviceGetGpuInstancePossiblePlacements_v2"] = <_cyb_intptr_t>__nvmlDeviceGetGpuInstancePossiblePlacements_v2 + data["__nvmlDeviceGetGpuInstancePossiblePlacements_v2"] = <intptr_t>__nvmlDeviceGetGpuInstancePossiblePlacements_v2 global __nvmlDeviceGetGpuInstanceRemainingCapacity - data["__nvmlDeviceGetGpuInstanceRemainingCapacity"] = <_cyb_intptr_t>__nvmlDeviceGetGpuInstanceRemainingCapacity + data["__nvmlDeviceGetGpuInstanceRemainingCapacity"] = <intptr_t>__nvmlDeviceGetGpuInstanceRemainingCapacity global __nvmlDeviceCreateGpuInstance - data["__nvmlDeviceCreateGpuInstance"] = <_cyb_intptr_t>__nvmlDeviceCreateGpuInstance + data["__nvmlDeviceCreateGpuInstance"] = <intptr_t>__nvmlDeviceCreateGpuInstance global __nvmlDeviceCreateGpuInstanceWithPlacement - data["__nvmlDeviceCreateGpuInstanceWithPlacement"] = <_cyb_intptr_t>__nvmlDeviceCreateGpuInstanceWithPlacement + data["__nvmlDeviceCreateGpuInstanceWithPlacement"] = <intptr_t>__nvmlDeviceCreateGpuInstanceWithPlacement global __nvmlGpuInstanceDestroy - data["__nvmlGpuInstanceDestroy"] = <_cyb_intptr_t>__nvmlGpuInstanceDestroy + data["__nvmlGpuInstanceDestroy"] = <intptr_t>__nvmlGpuInstanceDestroy global __nvmlDeviceGetGpuInstances - data["__nvmlDeviceGetGpuInstances"] = <_cyb_intptr_t>__nvmlDeviceGetGpuInstances + data["__nvmlDeviceGetGpuInstances"] = <intptr_t>__nvmlDeviceGetGpuInstances global __nvmlDeviceGetGpuInstanceById - data["__nvmlDeviceGetGpuInstanceById"] = <_cyb_intptr_t>__nvmlDeviceGetGpuInstanceById + data["__nvmlDeviceGetGpuInstanceById"] = <intptr_t>__nvmlDeviceGetGpuInstanceById global __nvmlGpuInstanceGetInfo - data["__nvmlGpuInstanceGetInfo"] = <_cyb_intptr_t>__nvmlGpuInstanceGetInfo + data["__nvmlGpuInstanceGetInfo"] = <intptr_t>__nvmlGpuInstanceGetInfo global __nvmlGpuInstanceGetComputeInstanceProfileInfoV - data["__nvmlGpuInstanceGetComputeInstanceProfileInfoV"] = <_cyb_intptr_t>__nvmlGpuInstanceGetComputeInstanceProfileInfoV + data["__nvmlGpuInstanceGetComputeInstanceProfileInfoV"] = <intptr_t>__nvmlGpuInstanceGetComputeInstanceProfileInfoV global __nvmlGpuInstanceGetComputeInstanceRemainingCapacity - data["__nvmlGpuInstanceGetComputeInstanceRemainingCapacity"] = <_cyb_intptr_t>__nvmlGpuInstanceGetComputeInstanceRemainingCapacity + data["__nvmlGpuInstanceGetComputeInstanceRemainingCapacity"] = <intptr_t>__nvmlGpuInstanceGetComputeInstanceRemainingCapacity global __nvmlGpuInstanceGetComputeInstancePossiblePlacements - data["__nvmlGpuInstanceGetComputeInstancePossiblePlacements"] = <_cyb_intptr_t>__nvmlGpuInstanceGetComputeInstancePossiblePlacements + data["__nvmlGpuInstanceGetComputeInstancePossiblePlacements"] = <intptr_t>__nvmlGpuInstanceGetComputeInstancePossiblePlacements global __nvmlGpuInstanceCreateComputeInstance - data["__nvmlGpuInstanceCreateComputeInstance"] = <_cyb_intptr_t>__nvmlGpuInstanceCreateComputeInstance + data["__nvmlGpuInstanceCreateComputeInstance"] = <intptr_t>__nvmlGpuInstanceCreateComputeInstance global __nvmlGpuInstanceCreateComputeInstanceWithPlacement - data["__nvmlGpuInstanceCreateComputeInstanceWithPlacement"] = <_cyb_intptr_t>__nvmlGpuInstanceCreateComputeInstanceWithPlacement + data["__nvmlGpuInstanceCreateComputeInstanceWithPlacement"] = <intptr_t>__nvmlGpuInstanceCreateComputeInstanceWithPlacement global __nvmlComputeInstanceDestroy - data["__nvmlComputeInstanceDestroy"] = <_cyb_intptr_t>__nvmlComputeInstanceDestroy + data["__nvmlComputeInstanceDestroy"] = <intptr_t>__nvmlComputeInstanceDestroy global __nvmlGpuInstanceGetComputeInstances - data["__nvmlGpuInstanceGetComputeInstances"] = <_cyb_intptr_t>__nvmlGpuInstanceGetComputeInstances + data["__nvmlGpuInstanceGetComputeInstances"] = <intptr_t>__nvmlGpuInstanceGetComputeInstances global __nvmlGpuInstanceGetComputeInstanceById - data["__nvmlGpuInstanceGetComputeInstanceById"] = <_cyb_intptr_t>__nvmlGpuInstanceGetComputeInstanceById + data["__nvmlGpuInstanceGetComputeInstanceById"] = <intptr_t>__nvmlGpuInstanceGetComputeInstanceById global __nvmlComputeInstanceGetInfo_v2 - data["__nvmlComputeInstanceGetInfo_v2"] = <_cyb_intptr_t>__nvmlComputeInstanceGetInfo_v2 + data["__nvmlComputeInstanceGetInfo_v2"] = <intptr_t>__nvmlComputeInstanceGetInfo_v2 global __nvmlDeviceIsMigDeviceHandle - data["__nvmlDeviceIsMigDeviceHandle"] = <_cyb_intptr_t>__nvmlDeviceIsMigDeviceHandle + data["__nvmlDeviceIsMigDeviceHandle"] = <intptr_t>__nvmlDeviceIsMigDeviceHandle global __nvmlDeviceGetGpuInstanceId - data["__nvmlDeviceGetGpuInstanceId"] = <_cyb_intptr_t>__nvmlDeviceGetGpuInstanceId + data["__nvmlDeviceGetGpuInstanceId"] = <intptr_t>__nvmlDeviceGetGpuInstanceId global __nvmlDeviceGetComputeInstanceId - data["__nvmlDeviceGetComputeInstanceId"] = <_cyb_intptr_t>__nvmlDeviceGetComputeInstanceId + data["__nvmlDeviceGetComputeInstanceId"] = <intptr_t>__nvmlDeviceGetComputeInstanceId global __nvmlDeviceGetMaxMigDeviceCount - data["__nvmlDeviceGetMaxMigDeviceCount"] = <_cyb_intptr_t>__nvmlDeviceGetMaxMigDeviceCount + data["__nvmlDeviceGetMaxMigDeviceCount"] = <intptr_t>__nvmlDeviceGetMaxMigDeviceCount global __nvmlDeviceGetMigDeviceHandleByIndex - data["__nvmlDeviceGetMigDeviceHandleByIndex"] = <_cyb_intptr_t>__nvmlDeviceGetMigDeviceHandleByIndex + data["__nvmlDeviceGetMigDeviceHandleByIndex"] = <intptr_t>__nvmlDeviceGetMigDeviceHandleByIndex global __nvmlDeviceGetDeviceHandleFromMigDeviceHandle - data["__nvmlDeviceGetDeviceHandleFromMigDeviceHandle"] = <_cyb_intptr_t>__nvmlDeviceGetDeviceHandleFromMigDeviceHandle + data["__nvmlDeviceGetDeviceHandleFromMigDeviceHandle"] = <intptr_t>__nvmlDeviceGetDeviceHandleFromMigDeviceHandle global __nvmlDeviceGetCapabilities - data["__nvmlDeviceGetCapabilities"] = <_cyb_intptr_t>__nvmlDeviceGetCapabilities + data["__nvmlDeviceGetCapabilities"] = <intptr_t>__nvmlDeviceGetCapabilities global __nvmlDevicePowerSmoothingActivatePresetProfile - data["__nvmlDevicePowerSmoothingActivatePresetProfile"] = <_cyb_intptr_t>__nvmlDevicePowerSmoothingActivatePresetProfile + data["__nvmlDevicePowerSmoothingActivatePresetProfile"] = <intptr_t>__nvmlDevicePowerSmoothingActivatePresetProfile global __nvmlDevicePowerSmoothingUpdatePresetProfileParam - data["__nvmlDevicePowerSmoothingUpdatePresetProfileParam"] = <_cyb_intptr_t>__nvmlDevicePowerSmoothingUpdatePresetProfileParam + data["__nvmlDevicePowerSmoothingUpdatePresetProfileParam"] = <intptr_t>__nvmlDevicePowerSmoothingUpdatePresetProfileParam global __nvmlDevicePowerSmoothingSetState - data["__nvmlDevicePowerSmoothingSetState"] = <_cyb_intptr_t>__nvmlDevicePowerSmoothingSetState + data["__nvmlDevicePowerSmoothingSetState"] = <intptr_t>__nvmlDevicePowerSmoothingSetState global __nvmlDeviceGetAddressingMode - data["__nvmlDeviceGetAddressingMode"] = <_cyb_intptr_t>__nvmlDeviceGetAddressingMode + data["__nvmlDeviceGetAddressingMode"] = <intptr_t>__nvmlDeviceGetAddressingMode global __nvmlDeviceGetRepairStatus - data["__nvmlDeviceGetRepairStatus"] = <_cyb_intptr_t>__nvmlDeviceGetRepairStatus + data["__nvmlDeviceGetRepairStatus"] = <intptr_t>__nvmlDeviceGetRepairStatus global __nvmlDeviceGetPowerMizerMode_v1 - data["__nvmlDeviceGetPowerMizerMode_v1"] = <_cyb_intptr_t>__nvmlDeviceGetPowerMizerMode_v1 + data["__nvmlDeviceGetPowerMizerMode_v1"] = <intptr_t>__nvmlDeviceGetPowerMizerMode_v1 global __nvmlDeviceSetPowerMizerMode_v1 - data["__nvmlDeviceSetPowerMizerMode_v1"] = <_cyb_intptr_t>__nvmlDeviceSetPowerMizerMode_v1 + data["__nvmlDeviceSetPowerMizerMode_v1"] = <intptr_t>__nvmlDeviceSetPowerMizerMode_v1 global __nvmlDeviceGetPdi - data["__nvmlDeviceGetPdi"] = <_cyb_intptr_t>__nvmlDeviceGetPdi + data["__nvmlDeviceGetPdi"] = <intptr_t>__nvmlDeviceGetPdi global __nvmlDeviceSetHostname_v1 - data["__nvmlDeviceSetHostname_v1"] = <_cyb_intptr_t>__nvmlDeviceSetHostname_v1 + data["__nvmlDeviceSetHostname_v1"] = <intptr_t>__nvmlDeviceSetHostname_v1 global __nvmlDeviceGetHostname_v1 - data["__nvmlDeviceGetHostname_v1"] = <_cyb_intptr_t>__nvmlDeviceGetHostname_v1 + data["__nvmlDeviceGetHostname_v1"] = <intptr_t>__nvmlDeviceGetHostname_v1 global __nvmlDeviceGetNvLinkInfo - data["__nvmlDeviceGetNvLinkInfo"] = <_cyb_intptr_t>__nvmlDeviceGetNvLinkInfo + data["__nvmlDeviceGetNvLinkInfo"] = <intptr_t>__nvmlDeviceGetNvLinkInfo global __nvmlDeviceReadWritePRM_v1 - data["__nvmlDeviceReadWritePRM_v1"] = <_cyb_intptr_t>__nvmlDeviceReadWritePRM_v1 + data["__nvmlDeviceReadWritePRM_v1"] = <intptr_t>__nvmlDeviceReadWritePRM_v1 global __nvmlDeviceGetGpuInstanceProfileInfoByIdV - data["__nvmlDeviceGetGpuInstanceProfileInfoByIdV"] = <_cyb_intptr_t>__nvmlDeviceGetGpuInstanceProfileInfoByIdV + data["__nvmlDeviceGetGpuInstanceProfileInfoByIdV"] = <intptr_t>__nvmlDeviceGetGpuInstanceProfileInfoByIdV global __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts - data["__nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts"] = <_cyb_intptr_t>__nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts + data["__nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts"] = <intptr_t>__nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts global __nvmlDeviceGetUnrepairableMemoryFlag_v1 - data["__nvmlDeviceGetUnrepairableMemoryFlag_v1"] = <_cyb_intptr_t>__nvmlDeviceGetUnrepairableMemoryFlag_v1 + data["__nvmlDeviceGetUnrepairableMemoryFlag_v1"] = <intptr_t>__nvmlDeviceGetUnrepairableMemoryFlag_v1 global __nvmlDeviceReadPRMCounters_v1 - data["__nvmlDeviceReadPRMCounters_v1"] = <_cyb_intptr_t>__nvmlDeviceReadPRMCounters_v1 + data["__nvmlDeviceReadPRMCounters_v1"] = <intptr_t>__nvmlDeviceReadPRMCounters_v1 global __nvmlDeviceSetRusdSettings_v1 - data["__nvmlDeviceSetRusdSettings_v1"] = <_cyb_intptr_t>__nvmlDeviceSetRusdSettings_v1 + data["__nvmlDeviceSetRusdSettings_v1"] = <intptr_t>__nvmlDeviceSetRusdSettings_v1 global __nvmlDeviceVgpuForceGspUnload - data["__nvmlDeviceVgpuForceGspUnload"] = <_cyb_intptr_t>__nvmlDeviceVgpuForceGspUnload + data["__nvmlDeviceVgpuForceGspUnload"] = <intptr_t>__nvmlDeviceVgpuForceGspUnload global __nvmlDeviceGetVgpuSchedulerState_v2 - data["__nvmlDeviceGetVgpuSchedulerState_v2"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuSchedulerState_v2 + data["__nvmlDeviceGetVgpuSchedulerState_v2"] = <intptr_t>__nvmlDeviceGetVgpuSchedulerState_v2 global __nvmlGpuInstanceGetVgpuSchedulerState_v2 - data["__nvmlGpuInstanceGetVgpuSchedulerState_v2"] = <_cyb_intptr_t>__nvmlGpuInstanceGetVgpuSchedulerState_v2 + data["__nvmlGpuInstanceGetVgpuSchedulerState_v2"] = <intptr_t>__nvmlGpuInstanceGetVgpuSchedulerState_v2 global __nvmlDeviceGetVgpuSchedulerLog_v2 - data["__nvmlDeviceGetVgpuSchedulerLog_v2"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuSchedulerLog_v2 + data["__nvmlDeviceGetVgpuSchedulerLog_v2"] = <intptr_t>__nvmlDeviceGetVgpuSchedulerLog_v2 global __nvmlGpuInstanceGetVgpuSchedulerLog_v2 - data["__nvmlGpuInstanceGetVgpuSchedulerLog_v2"] = <_cyb_intptr_t>__nvmlGpuInstanceGetVgpuSchedulerLog_v2 + data["__nvmlGpuInstanceGetVgpuSchedulerLog_v2"] = <intptr_t>__nvmlGpuInstanceGetVgpuSchedulerLog_v2 global __nvmlDeviceSetVgpuSchedulerState_v2 - data["__nvmlDeviceSetVgpuSchedulerState_v2"] = <_cyb_intptr_t>__nvmlDeviceSetVgpuSchedulerState_v2 + data["__nvmlDeviceSetVgpuSchedulerState_v2"] = <intptr_t>__nvmlDeviceSetVgpuSchedulerState_v2 global __nvmlGpuInstanceSetVgpuSchedulerState_v2 - data["__nvmlGpuInstanceSetVgpuSchedulerState_v2"] = <_cyb_intptr_t>__nvmlGpuInstanceSetVgpuSchedulerState_v2 + data["__nvmlGpuInstanceSetVgpuSchedulerState_v2"] = <intptr_t>__nvmlGpuInstanceSetVgpuSchedulerState_v2 global __nvmlSystemGetCPER_v1 - data["__nvmlSystemGetCPER_v1"] = <_cyb_intptr_t>__nvmlSystemGetCPER_v1 + data["__nvmlSystemGetCPER_v1"] = <intptr_t>__nvmlSystemGetCPER_v1 global __nvmlDeviceGetBBXTimeData_v1 - data["__nvmlDeviceGetBBXTimeData_v1"] = <_cyb_intptr_t>__nvmlDeviceGetBBXTimeData_v1 + data["__nvmlDeviceGetBBXTimeData_v1"] = <intptr_t>__nvmlDeviceGetBBXTimeData_v1 global __nvmlDeviceGetAccountingStats_v2 - data["__nvmlDeviceGetAccountingStats_v2"] = <_cyb_intptr_t>__nvmlDeviceGetAccountingStats_v2 + data["__nvmlDeviceGetAccountingStats_v2"] = <intptr_t>__nvmlDeviceGetAccountingStats_v2 global __nvmlDeviceGetRemappedRows_v2 - data["__nvmlDeviceGetRemappedRows_v2"] = <_cyb_intptr_t>__nvmlDeviceGetRemappedRows_v2 + data["__nvmlDeviceGetRemappedRows_v2"] = <intptr_t>__nvmlDeviceGetRemappedRows_v2 global __nvmlDeviceSetAdaptiveTgpMode_v1 - data["__nvmlDeviceSetAdaptiveTgpMode_v1"] = <_cyb_intptr_t>__nvmlDeviceSetAdaptiveTgpMode_v1 + data["__nvmlDeviceSetAdaptiveTgpMode_v1"] = <intptr_t>__nvmlDeviceSetAdaptiveTgpMode_v1 global __nvmlDeviceGetAdaptiveTgpModeInfo_v1 - data["__nvmlDeviceGetAdaptiveTgpModeInfo_v1"] = <_cyb_intptr_t>__nvmlDeviceGetAdaptiveTgpModeInfo_v1 + data["__nvmlDeviceGetAdaptiveTgpModeInfo_v1"] = <intptr_t>__nvmlDeviceGetAdaptiveTgpModeInfo_v1 global __nvmlDeviceSetMemoryLimits_v1 - data["__nvmlDeviceSetMemoryLimits_v1"] = <_cyb_intptr_t>__nvmlDeviceSetMemoryLimits_v1 + data["__nvmlDeviceSetMemoryLimits_v1"] = <intptr_t>__nvmlDeviceSetMemoryLimits_v1 global __nvmlDeviceGetMemoryLimits_v1 - data["__nvmlDeviceGetMemoryLimits_v1"] = <_cyb_intptr_t>__nvmlDeviceGetMemoryLimits_v1 + data["__nvmlDeviceGetMemoryLimits_v1"] = <intptr_t>__nvmlDeviceGetMemoryLimits_v1 global __nvmlDeviceGetGpuFabricInfo_v4 - data["__nvmlDeviceGetGpuFabricInfo_v4"] = <_cyb_intptr_t>__nvmlDeviceGetGpuFabricInfo_v4 + data["__nvmlDeviceGetGpuFabricInfo_v4"] = <intptr_t>__nvmlDeviceGetGpuFabricInfo_v4 global __nvmlDevicePerfMetricsGetSamples_v1 - data["__nvmlDevicePerfMetricsGetSamples_v1"] = <_cyb_intptr_t>__nvmlDevicePerfMetricsGetSamples_v1 + data["__nvmlDevicePerfMetricsGetSamples_v1"] = <intptr_t>__nvmlDevicePerfMetricsGetSamples_v1 global __nvmlDeviceSetNvlinkBwModeAsync_v1 - data["__nvmlDeviceSetNvlinkBwModeAsync_v1"] = <_cyb_intptr_t>__nvmlDeviceSetNvlinkBwModeAsync_v1 + data["__nvmlDeviceSetNvlinkBwModeAsync_v1"] = <intptr_t>__nvmlDeviceSetNvlinkBwModeAsync_v1 global __nvmlDeviceGetNvLinkTelemetrySamples_v1 - data["__nvmlDeviceGetNvLinkTelemetrySamples_v1"] = <_cyb_intptr_t>__nvmlDeviceGetNvLinkTelemetrySamples_v1 + data["__nvmlDeviceGetNvLinkTelemetrySamples_v1"] = <intptr_t>__nvmlDeviceGetNvLinkTelemetrySamples_v1 global __nvmlEventSetRegisterGpuOperationalEvents_v1 - data["__nvmlEventSetRegisterGpuOperationalEvents_v1"] = <_cyb_intptr_t>__nvmlEventSetRegisterGpuOperationalEvents_v1 + data["__nvmlEventSetRegisterGpuOperationalEvents_v1"] = <intptr_t>__nvmlEventSetRegisterGpuOperationalEvents_v1 global __nvmlEventSetWait_v3 - data["__nvmlEventSetWait_v3"] = <_cyb_intptr_t>__nvmlEventSetWait_v3 + data["__nvmlEventSetWait_v3"] = <intptr_t>__nvmlEventSetWait_v3 global __nvmlEventSetGetContextCount_v1 - data["__nvmlEventSetGetContextCount_v1"] = <_cyb_intptr_t>__nvmlEventSetGetContextCount_v1 + data["__nvmlEventSetGetContextCount_v1"] = <intptr_t>__nvmlEventSetGetContextCount_v1 global __nvmlEventSetGetContextInfo_v1 - data["__nvmlEventSetGetContextInfo_v1"] = <_cyb_intptr_t>__nvmlEventSetGetContextInfo_v1 + data["__nvmlEventSetGetContextInfo_v1"] = <intptr_t>__nvmlEventSetGetContextInfo_v1 global __nvmlEventSetGetContextData_v1 - data["__nvmlEventSetGetContextData_v1"] = <_cyb_intptr_t>__nvmlEventSetGetContextData_v1 + data["__nvmlEventSetGetContextData_v1"] = <intptr_t>__nvmlEventSetGetContextData_v1 global __nvmlEventSetGetGpuOperationalEventContextLegacyXid_v1 - data["__nvmlEventSetGetGpuOperationalEventContextLegacyXid_v1"] = <_cyb_intptr_t>__nvmlEventSetGetGpuOperationalEventContextLegacyXid_v1 + data["__nvmlEventSetGetGpuOperationalEventContextLegacyXid_v1"] = <intptr_t>__nvmlEventSetGetGpuOperationalEventContextLegacyXid_v1 global __nvmlDeviceGetBankRemapperStatus_v1 - data["__nvmlDeviceGetBankRemapperStatus_v1"] = <_cyb_intptr_t>__nvmlDeviceGetBankRemapperStatus_v1 + data["__nvmlDeviceGetBankRemapperStatus_v1"] = <intptr_t>__nvmlDeviceGetBankRemapperStatus_v1 _cyb_func_ptrs = data return data diff --git a/cuda_bindings/cuda/bindings/_internal/nvml_windows.pyx b/cuda_bindings/cuda/bindings/_internal/nvml_windows.pyx index 7b851e1aa4e..b46526faf3c 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvml_windows.pyx +++ b/cuda_bindings/cuda/bindings/_internal/nvml_windows.pyx @@ -4,7 +4,7 @@ # # This code was automatically generated across versions from 12.9.1 to 13.4.0. Do not modify it directly. # !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=10e6cb1d192514ece92e863cbebdde5c60b94cdc58d27a8c2e4cf9af1a27c968 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=f8ac1d1064f1a58e57afc40dda00cd9d33f82f2cb25ca246244019324d14e1aa # <<<< PREAMBLE CONTENT >>>> @@ -45,7 +45,10 @@ cdef extern from "<windows.h>": ctypedef void* HMODULE void* _cyb_GetProcAddress "GetProcAddress"(HMODULE, const char*) nogil -from libc.stdint cimport intptr_t as _cyb_intptr_t +from libc.stdint cimport ( + intptr_t, + uintptr_t, +) import threading as _cyb_threading @@ -1570,1114 +1573,1114 @@ cpdef dict _inspect_function_pointers(): _check_or_init_nvml() cdef dict data = {} global __nvmlInit_v2 - data["__nvmlInit_v2"] = <_cyb_intptr_t>__nvmlInit_v2 + data["__nvmlInit_v2"] = <intptr_t>__nvmlInit_v2 global __nvmlInitWithFlags - data["__nvmlInitWithFlags"] = <_cyb_intptr_t>__nvmlInitWithFlags + data["__nvmlInitWithFlags"] = <intptr_t>__nvmlInitWithFlags global __nvmlShutdown - data["__nvmlShutdown"] = <_cyb_intptr_t>__nvmlShutdown + data["__nvmlShutdown"] = <intptr_t>__nvmlShutdown global __nvmlErrorString - data["__nvmlErrorString"] = <_cyb_intptr_t>__nvmlErrorString + data["__nvmlErrorString"] = <intptr_t>__nvmlErrorString global __nvmlSystemGetDriverVersion - data["__nvmlSystemGetDriverVersion"] = <_cyb_intptr_t>__nvmlSystemGetDriverVersion + data["__nvmlSystemGetDriverVersion"] = <intptr_t>__nvmlSystemGetDriverVersion global __nvmlSystemGetNVMLVersion - data["__nvmlSystemGetNVMLVersion"] = <_cyb_intptr_t>__nvmlSystemGetNVMLVersion + data["__nvmlSystemGetNVMLVersion"] = <intptr_t>__nvmlSystemGetNVMLVersion global __nvmlSystemGetCudaDriverVersion - data["__nvmlSystemGetCudaDriverVersion"] = <_cyb_intptr_t>__nvmlSystemGetCudaDriverVersion + data["__nvmlSystemGetCudaDriverVersion"] = <intptr_t>__nvmlSystemGetCudaDriverVersion global __nvmlSystemGetCudaDriverVersion_v2 - data["__nvmlSystemGetCudaDriverVersion_v2"] = <_cyb_intptr_t>__nvmlSystemGetCudaDriverVersion_v2 + data["__nvmlSystemGetCudaDriverVersion_v2"] = <intptr_t>__nvmlSystemGetCudaDriverVersion_v2 global __nvmlSystemGetProcessName - data["__nvmlSystemGetProcessName"] = <_cyb_intptr_t>__nvmlSystemGetProcessName + data["__nvmlSystemGetProcessName"] = <intptr_t>__nvmlSystemGetProcessName global __nvmlSystemGetHicVersion - data["__nvmlSystemGetHicVersion"] = <_cyb_intptr_t>__nvmlSystemGetHicVersion + data["__nvmlSystemGetHicVersion"] = <intptr_t>__nvmlSystemGetHicVersion global __nvmlSystemGetTopologyGpuSet - data["__nvmlSystemGetTopologyGpuSet"] = <_cyb_intptr_t>__nvmlSystemGetTopologyGpuSet + data["__nvmlSystemGetTopologyGpuSet"] = <intptr_t>__nvmlSystemGetTopologyGpuSet global __nvmlSystemGetDriverBranch - data["__nvmlSystemGetDriverBranch"] = <_cyb_intptr_t>__nvmlSystemGetDriverBranch + data["__nvmlSystemGetDriverBranch"] = <intptr_t>__nvmlSystemGetDriverBranch global __nvmlUnitGetCount - data["__nvmlUnitGetCount"] = <_cyb_intptr_t>__nvmlUnitGetCount + data["__nvmlUnitGetCount"] = <intptr_t>__nvmlUnitGetCount global __nvmlUnitGetHandleByIndex - data["__nvmlUnitGetHandleByIndex"] = <_cyb_intptr_t>__nvmlUnitGetHandleByIndex + data["__nvmlUnitGetHandleByIndex"] = <intptr_t>__nvmlUnitGetHandleByIndex global __nvmlUnitGetUnitInfo - data["__nvmlUnitGetUnitInfo"] = <_cyb_intptr_t>__nvmlUnitGetUnitInfo + data["__nvmlUnitGetUnitInfo"] = <intptr_t>__nvmlUnitGetUnitInfo global __nvmlUnitGetLedState - data["__nvmlUnitGetLedState"] = <_cyb_intptr_t>__nvmlUnitGetLedState + data["__nvmlUnitGetLedState"] = <intptr_t>__nvmlUnitGetLedState global __nvmlUnitGetPsuInfo - data["__nvmlUnitGetPsuInfo"] = <_cyb_intptr_t>__nvmlUnitGetPsuInfo + data["__nvmlUnitGetPsuInfo"] = <intptr_t>__nvmlUnitGetPsuInfo global __nvmlUnitGetTemperature - data["__nvmlUnitGetTemperature"] = <_cyb_intptr_t>__nvmlUnitGetTemperature + data["__nvmlUnitGetTemperature"] = <intptr_t>__nvmlUnitGetTemperature global __nvmlUnitGetFanSpeedInfo - data["__nvmlUnitGetFanSpeedInfo"] = <_cyb_intptr_t>__nvmlUnitGetFanSpeedInfo + data["__nvmlUnitGetFanSpeedInfo"] = <intptr_t>__nvmlUnitGetFanSpeedInfo global __nvmlUnitGetDevices - data["__nvmlUnitGetDevices"] = <_cyb_intptr_t>__nvmlUnitGetDevices + data["__nvmlUnitGetDevices"] = <intptr_t>__nvmlUnitGetDevices global __nvmlDeviceGetCount_v2 - data["__nvmlDeviceGetCount_v2"] = <_cyb_intptr_t>__nvmlDeviceGetCount_v2 + data["__nvmlDeviceGetCount_v2"] = <intptr_t>__nvmlDeviceGetCount_v2 global __nvmlDeviceGetAttributes_v2 - data["__nvmlDeviceGetAttributes_v2"] = <_cyb_intptr_t>__nvmlDeviceGetAttributes_v2 + data["__nvmlDeviceGetAttributes_v2"] = <intptr_t>__nvmlDeviceGetAttributes_v2 global __nvmlDeviceGetHandleByIndex_v2 - data["__nvmlDeviceGetHandleByIndex_v2"] = <_cyb_intptr_t>__nvmlDeviceGetHandleByIndex_v2 + data["__nvmlDeviceGetHandleByIndex_v2"] = <intptr_t>__nvmlDeviceGetHandleByIndex_v2 global __nvmlDeviceGetHandleBySerial - data["__nvmlDeviceGetHandleBySerial"] = <_cyb_intptr_t>__nvmlDeviceGetHandleBySerial + data["__nvmlDeviceGetHandleBySerial"] = <intptr_t>__nvmlDeviceGetHandleBySerial global __nvmlDeviceGetHandleByUUID - data["__nvmlDeviceGetHandleByUUID"] = <_cyb_intptr_t>__nvmlDeviceGetHandleByUUID + data["__nvmlDeviceGetHandleByUUID"] = <intptr_t>__nvmlDeviceGetHandleByUUID global __nvmlDeviceGetHandleByUUIDV - data["__nvmlDeviceGetHandleByUUIDV"] = <_cyb_intptr_t>__nvmlDeviceGetHandleByUUIDV + data["__nvmlDeviceGetHandleByUUIDV"] = <intptr_t>__nvmlDeviceGetHandleByUUIDV global __nvmlDeviceGetHandleByPciBusId_v2 - data["__nvmlDeviceGetHandleByPciBusId_v2"] = <_cyb_intptr_t>__nvmlDeviceGetHandleByPciBusId_v2 + data["__nvmlDeviceGetHandleByPciBusId_v2"] = <intptr_t>__nvmlDeviceGetHandleByPciBusId_v2 global __nvmlDeviceGetName - data["__nvmlDeviceGetName"] = <_cyb_intptr_t>__nvmlDeviceGetName + data["__nvmlDeviceGetName"] = <intptr_t>__nvmlDeviceGetName global __nvmlDeviceGetBrand - data["__nvmlDeviceGetBrand"] = <_cyb_intptr_t>__nvmlDeviceGetBrand + data["__nvmlDeviceGetBrand"] = <intptr_t>__nvmlDeviceGetBrand global __nvmlDeviceGetIndex - data["__nvmlDeviceGetIndex"] = <_cyb_intptr_t>__nvmlDeviceGetIndex + data["__nvmlDeviceGetIndex"] = <intptr_t>__nvmlDeviceGetIndex global __nvmlDeviceGetSerial - data["__nvmlDeviceGetSerial"] = <_cyb_intptr_t>__nvmlDeviceGetSerial + data["__nvmlDeviceGetSerial"] = <intptr_t>__nvmlDeviceGetSerial global __nvmlDeviceGetModuleId - data["__nvmlDeviceGetModuleId"] = <_cyb_intptr_t>__nvmlDeviceGetModuleId + data["__nvmlDeviceGetModuleId"] = <intptr_t>__nvmlDeviceGetModuleId global __nvmlDeviceGetC2cModeInfoV - data["__nvmlDeviceGetC2cModeInfoV"] = <_cyb_intptr_t>__nvmlDeviceGetC2cModeInfoV + data["__nvmlDeviceGetC2cModeInfoV"] = <intptr_t>__nvmlDeviceGetC2cModeInfoV global __nvmlDeviceGetMemoryAffinity - data["__nvmlDeviceGetMemoryAffinity"] = <_cyb_intptr_t>__nvmlDeviceGetMemoryAffinity + data["__nvmlDeviceGetMemoryAffinity"] = <intptr_t>__nvmlDeviceGetMemoryAffinity global __nvmlDeviceGetCpuAffinityWithinScope - data["__nvmlDeviceGetCpuAffinityWithinScope"] = <_cyb_intptr_t>__nvmlDeviceGetCpuAffinityWithinScope + data["__nvmlDeviceGetCpuAffinityWithinScope"] = <intptr_t>__nvmlDeviceGetCpuAffinityWithinScope global __nvmlDeviceGetCpuAffinity - data["__nvmlDeviceGetCpuAffinity"] = <_cyb_intptr_t>__nvmlDeviceGetCpuAffinity + data["__nvmlDeviceGetCpuAffinity"] = <intptr_t>__nvmlDeviceGetCpuAffinity global __nvmlDeviceSetCpuAffinity - data["__nvmlDeviceSetCpuAffinity"] = <_cyb_intptr_t>__nvmlDeviceSetCpuAffinity + data["__nvmlDeviceSetCpuAffinity"] = <intptr_t>__nvmlDeviceSetCpuAffinity global __nvmlDeviceClearCpuAffinity - data["__nvmlDeviceClearCpuAffinity"] = <_cyb_intptr_t>__nvmlDeviceClearCpuAffinity + data["__nvmlDeviceClearCpuAffinity"] = <intptr_t>__nvmlDeviceClearCpuAffinity global __nvmlDeviceGetNumaNodeId - data["__nvmlDeviceGetNumaNodeId"] = <_cyb_intptr_t>__nvmlDeviceGetNumaNodeId + data["__nvmlDeviceGetNumaNodeId"] = <intptr_t>__nvmlDeviceGetNumaNodeId global __nvmlDeviceGetTopologyCommonAncestor - data["__nvmlDeviceGetTopologyCommonAncestor"] = <_cyb_intptr_t>__nvmlDeviceGetTopologyCommonAncestor + data["__nvmlDeviceGetTopologyCommonAncestor"] = <intptr_t>__nvmlDeviceGetTopologyCommonAncestor global __nvmlDeviceGetTopologyNearestGpus - data["__nvmlDeviceGetTopologyNearestGpus"] = <_cyb_intptr_t>__nvmlDeviceGetTopologyNearestGpus + data["__nvmlDeviceGetTopologyNearestGpus"] = <intptr_t>__nvmlDeviceGetTopologyNearestGpus global __nvmlDeviceGetP2PStatus - data["__nvmlDeviceGetP2PStatus"] = <_cyb_intptr_t>__nvmlDeviceGetP2PStatus + data["__nvmlDeviceGetP2PStatus"] = <intptr_t>__nvmlDeviceGetP2PStatus global __nvmlDeviceGetUUID - data["__nvmlDeviceGetUUID"] = <_cyb_intptr_t>__nvmlDeviceGetUUID + data["__nvmlDeviceGetUUID"] = <intptr_t>__nvmlDeviceGetUUID global __nvmlDeviceGetMinorNumber - data["__nvmlDeviceGetMinorNumber"] = <_cyb_intptr_t>__nvmlDeviceGetMinorNumber + data["__nvmlDeviceGetMinorNumber"] = <intptr_t>__nvmlDeviceGetMinorNumber global __nvmlDeviceGetBoardPartNumber - data["__nvmlDeviceGetBoardPartNumber"] = <_cyb_intptr_t>__nvmlDeviceGetBoardPartNumber + data["__nvmlDeviceGetBoardPartNumber"] = <intptr_t>__nvmlDeviceGetBoardPartNumber global __nvmlDeviceGetInforomVersion - data["__nvmlDeviceGetInforomVersion"] = <_cyb_intptr_t>__nvmlDeviceGetInforomVersion + data["__nvmlDeviceGetInforomVersion"] = <intptr_t>__nvmlDeviceGetInforomVersion global __nvmlDeviceGetInforomImageVersion - data["__nvmlDeviceGetInforomImageVersion"] = <_cyb_intptr_t>__nvmlDeviceGetInforomImageVersion + data["__nvmlDeviceGetInforomImageVersion"] = <intptr_t>__nvmlDeviceGetInforomImageVersion global __nvmlDeviceGetInforomConfigurationChecksum - data["__nvmlDeviceGetInforomConfigurationChecksum"] = <_cyb_intptr_t>__nvmlDeviceGetInforomConfigurationChecksum + data["__nvmlDeviceGetInforomConfigurationChecksum"] = <intptr_t>__nvmlDeviceGetInforomConfigurationChecksum global __nvmlDeviceValidateInforom - data["__nvmlDeviceValidateInforom"] = <_cyb_intptr_t>__nvmlDeviceValidateInforom + data["__nvmlDeviceValidateInforom"] = <intptr_t>__nvmlDeviceValidateInforom global __nvmlDeviceGetLastBBXFlushTime - data["__nvmlDeviceGetLastBBXFlushTime"] = <_cyb_intptr_t>__nvmlDeviceGetLastBBXFlushTime + data["__nvmlDeviceGetLastBBXFlushTime"] = <intptr_t>__nvmlDeviceGetLastBBXFlushTime global __nvmlDeviceGetDisplayMode - data["__nvmlDeviceGetDisplayMode"] = <_cyb_intptr_t>__nvmlDeviceGetDisplayMode + data["__nvmlDeviceGetDisplayMode"] = <intptr_t>__nvmlDeviceGetDisplayMode global __nvmlDeviceGetDisplayActive - data["__nvmlDeviceGetDisplayActive"] = <_cyb_intptr_t>__nvmlDeviceGetDisplayActive + data["__nvmlDeviceGetDisplayActive"] = <intptr_t>__nvmlDeviceGetDisplayActive global __nvmlDeviceGetPersistenceMode - data["__nvmlDeviceGetPersistenceMode"] = <_cyb_intptr_t>__nvmlDeviceGetPersistenceMode + data["__nvmlDeviceGetPersistenceMode"] = <intptr_t>__nvmlDeviceGetPersistenceMode global __nvmlDeviceGetPciInfoExt - data["__nvmlDeviceGetPciInfoExt"] = <_cyb_intptr_t>__nvmlDeviceGetPciInfoExt + data["__nvmlDeviceGetPciInfoExt"] = <intptr_t>__nvmlDeviceGetPciInfoExt global __nvmlDeviceGetPciInfo_v3 - data["__nvmlDeviceGetPciInfo_v3"] = <_cyb_intptr_t>__nvmlDeviceGetPciInfo_v3 + data["__nvmlDeviceGetPciInfo_v3"] = <intptr_t>__nvmlDeviceGetPciInfo_v3 global __nvmlDeviceGetMaxPcieLinkGeneration - data["__nvmlDeviceGetMaxPcieLinkGeneration"] = <_cyb_intptr_t>__nvmlDeviceGetMaxPcieLinkGeneration + data["__nvmlDeviceGetMaxPcieLinkGeneration"] = <intptr_t>__nvmlDeviceGetMaxPcieLinkGeneration global __nvmlDeviceGetGpuMaxPcieLinkGeneration - data["__nvmlDeviceGetGpuMaxPcieLinkGeneration"] = <_cyb_intptr_t>__nvmlDeviceGetGpuMaxPcieLinkGeneration + data["__nvmlDeviceGetGpuMaxPcieLinkGeneration"] = <intptr_t>__nvmlDeviceGetGpuMaxPcieLinkGeneration global __nvmlDeviceGetMaxPcieLinkWidth - data["__nvmlDeviceGetMaxPcieLinkWidth"] = <_cyb_intptr_t>__nvmlDeviceGetMaxPcieLinkWidth + data["__nvmlDeviceGetMaxPcieLinkWidth"] = <intptr_t>__nvmlDeviceGetMaxPcieLinkWidth global __nvmlDeviceGetCurrPcieLinkGeneration - data["__nvmlDeviceGetCurrPcieLinkGeneration"] = <_cyb_intptr_t>__nvmlDeviceGetCurrPcieLinkGeneration + data["__nvmlDeviceGetCurrPcieLinkGeneration"] = <intptr_t>__nvmlDeviceGetCurrPcieLinkGeneration global __nvmlDeviceGetCurrPcieLinkWidth - data["__nvmlDeviceGetCurrPcieLinkWidth"] = <_cyb_intptr_t>__nvmlDeviceGetCurrPcieLinkWidth + data["__nvmlDeviceGetCurrPcieLinkWidth"] = <intptr_t>__nvmlDeviceGetCurrPcieLinkWidth global __nvmlDeviceGetPcieThroughput - data["__nvmlDeviceGetPcieThroughput"] = <_cyb_intptr_t>__nvmlDeviceGetPcieThroughput + data["__nvmlDeviceGetPcieThroughput"] = <intptr_t>__nvmlDeviceGetPcieThroughput global __nvmlDeviceGetPcieReplayCounter - data["__nvmlDeviceGetPcieReplayCounter"] = <_cyb_intptr_t>__nvmlDeviceGetPcieReplayCounter + data["__nvmlDeviceGetPcieReplayCounter"] = <intptr_t>__nvmlDeviceGetPcieReplayCounter global __nvmlDeviceGetClockInfo - data["__nvmlDeviceGetClockInfo"] = <_cyb_intptr_t>__nvmlDeviceGetClockInfo + data["__nvmlDeviceGetClockInfo"] = <intptr_t>__nvmlDeviceGetClockInfo global __nvmlDeviceGetMaxClockInfo - data["__nvmlDeviceGetMaxClockInfo"] = <_cyb_intptr_t>__nvmlDeviceGetMaxClockInfo + data["__nvmlDeviceGetMaxClockInfo"] = <intptr_t>__nvmlDeviceGetMaxClockInfo global __nvmlDeviceGetGpcClkVfOffset - data["__nvmlDeviceGetGpcClkVfOffset"] = <_cyb_intptr_t>__nvmlDeviceGetGpcClkVfOffset + data["__nvmlDeviceGetGpcClkVfOffset"] = <intptr_t>__nvmlDeviceGetGpcClkVfOffset global __nvmlDeviceGetClock - data["__nvmlDeviceGetClock"] = <_cyb_intptr_t>__nvmlDeviceGetClock + data["__nvmlDeviceGetClock"] = <intptr_t>__nvmlDeviceGetClock global __nvmlDeviceGetMaxCustomerBoostClock - data["__nvmlDeviceGetMaxCustomerBoostClock"] = <_cyb_intptr_t>__nvmlDeviceGetMaxCustomerBoostClock + data["__nvmlDeviceGetMaxCustomerBoostClock"] = <intptr_t>__nvmlDeviceGetMaxCustomerBoostClock global __nvmlDeviceGetSupportedMemoryClocks - data["__nvmlDeviceGetSupportedMemoryClocks"] = <_cyb_intptr_t>__nvmlDeviceGetSupportedMemoryClocks + data["__nvmlDeviceGetSupportedMemoryClocks"] = <intptr_t>__nvmlDeviceGetSupportedMemoryClocks global __nvmlDeviceGetSupportedGraphicsClocks - data["__nvmlDeviceGetSupportedGraphicsClocks"] = <_cyb_intptr_t>__nvmlDeviceGetSupportedGraphicsClocks + data["__nvmlDeviceGetSupportedGraphicsClocks"] = <intptr_t>__nvmlDeviceGetSupportedGraphicsClocks global __nvmlDeviceGetAutoBoostedClocksEnabled - data["__nvmlDeviceGetAutoBoostedClocksEnabled"] = <_cyb_intptr_t>__nvmlDeviceGetAutoBoostedClocksEnabled + data["__nvmlDeviceGetAutoBoostedClocksEnabled"] = <intptr_t>__nvmlDeviceGetAutoBoostedClocksEnabled global __nvmlDeviceGetFanSpeed - data["__nvmlDeviceGetFanSpeed"] = <_cyb_intptr_t>__nvmlDeviceGetFanSpeed + data["__nvmlDeviceGetFanSpeed"] = <intptr_t>__nvmlDeviceGetFanSpeed global __nvmlDeviceGetFanSpeed_v2 - data["__nvmlDeviceGetFanSpeed_v2"] = <_cyb_intptr_t>__nvmlDeviceGetFanSpeed_v2 + data["__nvmlDeviceGetFanSpeed_v2"] = <intptr_t>__nvmlDeviceGetFanSpeed_v2 global __nvmlDeviceGetFanSpeedRPM - data["__nvmlDeviceGetFanSpeedRPM"] = <_cyb_intptr_t>__nvmlDeviceGetFanSpeedRPM + data["__nvmlDeviceGetFanSpeedRPM"] = <intptr_t>__nvmlDeviceGetFanSpeedRPM global __nvmlDeviceGetTargetFanSpeed - data["__nvmlDeviceGetTargetFanSpeed"] = <_cyb_intptr_t>__nvmlDeviceGetTargetFanSpeed + data["__nvmlDeviceGetTargetFanSpeed"] = <intptr_t>__nvmlDeviceGetTargetFanSpeed global __nvmlDeviceGetMinMaxFanSpeed - data["__nvmlDeviceGetMinMaxFanSpeed"] = <_cyb_intptr_t>__nvmlDeviceGetMinMaxFanSpeed + data["__nvmlDeviceGetMinMaxFanSpeed"] = <intptr_t>__nvmlDeviceGetMinMaxFanSpeed global __nvmlDeviceGetFanControlPolicy_v2 - data["__nvmlDeviceGetFanControlPolicy_v2"] = <_cyb_intptr_t>__nvmlDeviceGetFanControlPolicy_v2 + data["__nvmlDeviceGetFanControlPolicy_v2"] = <intptr_t>__nvmlDeviceGetFanControlPolicy_v2 global __nvmlDeviceGetNumFans - data["__nvmlDeviceGetNumFans"] = <_cyb_intptr_t>__nvmlDeviceGetNumFans + data["__nvmlDeviceGetNumFans"] = <intptr_t>__nvmlDeviceGetNumFans global __nvmlDeviceGetCoolerInfo - data["__nvmlDeviceGetCoolerInfo"] = <_cyb_intptr_t>__nvmlDeviceGetCoolerInfo + data["__nvmlDeviceGetCoolerInfo"] = <intptr_t>__nvmlDeviceGetCoolerInfo global __nvmlDeviceGetTemperatureV - data["__nvmlDeviceGetTemperatureV"] = <_cyb_intptr_t>__nvmlDeviceGetTemperatureV + data["__nvmlDeviceGetTemperatureV"] = <intptr_t>__nvmlDeviceGetTemperatureV global __nvmlDeviceGetTemperatureThreshold - data["__nvmlDeviceGetTemperatureThreshold"] = <_cyb_intptr_t>__nvmlDeviceGetTemperatureThreshold + data["__nvmlDeviceGetTemperatureThreshold"] = <intptr_t>__nvmlDeviceGetTemperatureThreshold global __nvmlDeviceGetMarginTemperature - data["__nvmlDeviceGetMarginTemperature"] = <_cyb_intptr_t>__nvmlDeviceGetMarginTemperature + data["__nvmlDeviceGetMarginTemperature"] = <intptr_t>__nvmlDeviceGetMarginTemperature global __nvmlDeviceGetThermalSettings - data["__nvmlDeviceGetThermalSettings"] = <_cyb_intptr_t>__nvmlDeviceGetThermalSettings + data["__nvmlDeviceGetThermalSettings"] = <intptr_t>__nvmlDeviceGetThermalSettings global __nvmlDeviceGetPerformanceState - data["__nvmlDeviceGetPerformanceState"] = <_cyb_intptr_t>__nvmlDeviceGetPerformanceState + data["__nvmlDeviceGetPerformanceState"] = <intptr_t>__nvmlDeviceGetPerformanceState global __nvmlDeviceGetCurrentClocksEventReasons - data["__nvmlDeviceGetCurrentClocksEventReasons"] = <_cyb_intptr_t>__nvmlDeviceGetCurrentClocksEventReasons + data["__nvmlDeviceGetCurrentClocksEventReasons"] = <intptr_t>__nvmlDeviceGetCurrentClocksEventReasons global __nvmlDeviceGetSupportedClocksEventReasons - data["__nvmlDeviceGetSupportedClocksEventReasons"] = <_cyb_intptr_t>__nvmlDeviceGetSupportedClocksEventReasons + data["__nvmlDeviceGetSupportedClocksEventReasons"] = <intptr_t>__nvmlDeviceGetSupportedClocksEventReasons global __nvmlDeviceGetPowerState - data["__nvmlDeviceGetPowerState"] = <_cyb_intptr_t>__nvmlDeviceGetPowerState + data["__nvmlDeviceGetPowerState"] = <intptr_t>__nvmlDeviceGetPowerState global __nvmlDeviceGetDynamicPstatesInfo - data["__nvmlDeviceGetDynamicPstatesInfo"] = <_cyb_intptr_t>__nvmlDeviceGetDynamicPstatesInfo + data["__nvmlDeviceGetDynamicPstatesInfo"] = <intptr_t>__nvmlDeviceGetDynamicPstatesInfo global __nvmlDeviceGetMemClkVfOffset - data["__nvmlDeviceGetMemClkVfOffset"] = <_cyb_intptr_t>__nvmlDeviceGetMemClkVfOffset + data["__nvmlDeviceGetMemClkVfOffset"] = <intptr_t>__nvmlDeviceGetMemClkVfOffset global __nvmlDeviceGetMinMaxClockOfPState - data["__nvmlDeviceGetMinMaxClockOfPState"] = <_cyb_intptr_t>__nvmlDeviceGetMinMaxClockOfPState + data["__nvmlDeviceGetMinMaxClockOfPState"] = <intptr_t>__nvmlDeviceGetMinMaxClockOfPState global __nvmlDeviceGetSupportedPerformanceStates - data["__nvmlDeviceGetSupportedPerformanceStates"] = <_cyb_intptr_t>__nvmlDeviceGetSupportedPerformanceStates + data["__nvmlDeviceGetSupportedPerformanceStates"] = <intptr_t>__nvmlDeviceGetSupportedPerformanceStates global __nvmlDeviceGetGpcClkMinMaxVfOffset - data["__nvmlDeviceGetGpcClkMinMaxVfOffset"] = <_cyb_intptr_t>__nvmlDeviceGetGpcClkMinMaxVfOffset + data["__nvmlDeviceGetGpcClkMinMaxVfOffset"] = <intptr_t>__nvmlDeviceGetGpcClkMinMaxVfOffset global __nvmlDeviceGetMemClkMinMaxVfOffset - data["__nvmlDeviceGetMemClkMinMaxVfOffset"] = <_cyb_intptr_t>__nvmlDeviceGetMemClkMinMaxVfOffset + data["__nvmlDeviceGetMemClkMinMaxVfOffset"] = <intptr_t>__nvmlDeviceGetMemClkMinMaxVfOffset global __nvmlDeviceGetClockOffsets - data["__nvmlDeviceGetClockOffsets"] = <_cyb_intptr_t>__nvmlDeviceGetClockOffsets + data["__nvmlDeviceGetClockOffsets"] = <intptr_t>__nvmlDeviceGetClockOffsets global __nvmlDeviceSetClockOffsets - data["__nvmlDeviceSetClockOffsets"] = <_cyb_intptr_t>__nvmlDeviceSetClockOffsets + data["__nvmlDeviceSetClockOffsets"] = <intptr_t>__nvmlDeviceSetClockOffsets global __nvmlDeviceGetPerformanceModes - data["__nvmlDeviceGetPerformanceModes"] = <_cyb_intptr_t>__nvmlDeviceGetPerformanceModes + data["__nvmlDeviceGetPerformanceModes"] = <intptr_t>__nvmlDeviceGetPerformanceModes global __nvmlDeviceGetCurrentClockFreqs - data["__nvmlDeviceGetCurrentClockFreqs"] = <_cyb_intptr_t>__nvmlDeviceGetCurrentClockFreqs + data["__nvmlDeviceGetCurrentClockFreqs"] = <intptr_t>__nvmlDeviceGetCurrentClockFreqs global __nvmlDeviceGetPowerManagementLimit - data["__nvmlDeviceGetPowerManagementLimit"] = <_cyb_intptr_t>__nvmlDeviceGetPowerManagementLimit + data["__nvmlDeviceGetPowerManagementLimit"] = <intptr_t>__nvmlDeviceGetPowerManagementLimit global __nvmlDeviceGetPowerManagementLimitConstraints - data["__nvmlDeviceGetPowerManagementLimitConstraints"] = <_cyb_intptr_t>__nvmlDeviceGetPowerManagementLimitConstraints + data["__nvmlDeviceGetPowerManagementLimitConstraints"] = <intptr_t>__nvmlDeviceGetPowerManagementLimitConstraints global __nvmlDeviceGetPowerManagementDefaultLimit - data["__nvmlDeviceGetPowerManagementDefaultLimit"] = <_cyb_intptr_t>__nvmlDeviceGetPowerManagementDefaultLimit + data["__nvmlDeviceGetPowerManagementDefaultLimit"] = <intptr_t>__nvmlDeviceGetPowerManagementDefaultLimit global __nvmlDeviceGetPowerUsage - data["__nvmlDeviceGetPowerUsage"] = <_cyb_intptr_t>__nvmlDeviceGetPowerUsage + data["__nvmlDeviceGetPowerUsage"] = <intptr_t>__nvmlDeviceGetPowerUsage global __nvmlDeviceGetTotalEnergyConsumption - data["__nvmlDeviceGetTotalEnergyConsumption"] = <_cyb_intptr_t>__nvmlDeviceGetTotalEnergyConsumption + data["__nvmlDeviceGetTotalEnergyConsumption"] = <intptr_t>__nvmlDeviceGetTotalEnergyConsumption global __nvmlDeviceGetEnforcedPowerLimit - data["__nvmlDeviceGetEnforcedPowerLimit"] = <_cyb_intptr_t>__nvmlDeviceGetEnforcedPowerLimit + data["__nvmlDeviceGetEnforcedPowerLimit"] = <intptr_t>__nvmlDeviceGetEnforcedPowerLimit global __nvmlDeviceGetGpuOperationMode - data["__nvmlDeviceGetGpuOperationMode"] = <_cyb_intptr_t>__nvmlDeviceGetGpuOperationMode + data["__nvmlDeviceGetGpuOperationMode"] = <intptr_t>__nvmlDeviceGetGpuOperationMode global __nvmlDeviceGetMemoryInfo_v2 - data["__nvmlDeviceGetMemoryInfo_v2"] = <_cyb_intptr_t>__nvmlDeviceGetMemoryInfo_v2 + data["__nvmlDeviceGetMemoryInfo_v2"] = <intptr_t>__nvmlDeviceGetMemoryInfo_v2 global __nvmlDeviceGetComputeMode - data["__nvmlDeviceGetComputeMode"] = <_cyb_intptr_t>__nvmlDeviceGetComputeMode + data["__nvmlDeviceGetComputeMode"] = <intptr_t>__nvmlDeviceGetComputeMode global __nvmlDeviceGetCudaComputeCapability - data["__nvmlDeviceGetCudaComputeCapability"] = <_cyb_intptr_t>__nvmlDeviceGetCudaComputeCapability + data["__nvmlDeviceGetCudaComputeCapability"] = <intptr_t>__nvmlDeviceGetCudaComputeCapability global __nvmlDeviceGetDramEncryptionMode - data["__nvmlDeviceGetDramEncryptionMode"] = <_cyb_intptr_t>__nvmlDeviceGetDramEncryptionMode + data["__nvmlDeviceGetDramEncryptionMode"] = <intptr_t>__nvmlDeviceGetDramEncryptionMode global __nvmlDeviceSetDramEncryptionMode - data["__nvmlDeviceSetDramEncryptionMode"] = <_cyb_intptr_t>__nvmlDeviceSetDramEncryptionMode + data["__nvmlDeviceSetDramEncryptionMode"] = <intptr_t>__nvmlDeviceSetDramEncryptionMode global __nvmlDeviceGetEccMode - data["__nvmlDeviceGetEccMode"] = <_cyb_intptr_t>__nvmlDeviceGetEccMode + data["__nvmlDeviceGetEccMode"] = <intptr_t>__nvmlDeviceGetEccMode global __nvmlDeviceGetDefaultEccMode - data["__nvmlDeviceGetDefaultEccMode"] = <_cyb_intptr_t>__nvmlDeviceGetDefaultEccMode + data["__nvmlDeviceGetDefaultEccMode"] = <intptr_t>__nvmlDeviceGetDefaultEccMode global __nvmlDeviceGetBoardId - data["__nvmlDeviceGetBoardId"] = <_cyb_intptr_t>__nvmlDeviceGetBoardId + data["__nvmlDeviceGetBoardId"] = <intptr_t>__nvmlDeviceGetBoardId global __nvmlDeviceGetMultiGpuBoard - data["__nvmlDeviceGetMultiGpuBoard"] = <_cyb_intptr_t>__nvmlDeviceGetMultiGpuBoard + data["__nvmlDeviceGetMultiGpuBoard"] = <intptr_t>__nvmlDeviceGetMultiGpuBoard global __nvmlDeviceGetTotalEccErrors - data["__nvmlDeviceGetTotalEccErrors"] = <_cyb_intptr_t>__nvmlDeviceGetTotalEccErrors + data["__nvmlDeviceGetTotalEccErrors"] = <intptr_t>__nvmlDeviceGetTotalEccErrors global __nvmlDeviceGetMemoryErrorCounter - data["__nvmlDeviceGetMemoryErrorCounter"] = <_cyb_intptr_t>__nvmlDeviceGetMemoryErrorCounter + data["__nvmlDeviceGetMemoryErrorCounter"] = <intptr_t>__nvmlDeviceGetMemoryErrorCounter global __nvmlDeviceGetUtilizationRates - data["__nvmlDeviceGetUtilizationRates"] = <_cyb_intptr_t>__nvmlDeviceGetUtilizationRates + data["__nvmlDeviceGetUtilizationRates"] = <intptr_t>__nvmlDeviceGetUtilizationRates global __nvmlDeviceGetEncoderUtilization - data["__nvmlDeviceGetEncoderUtilization"] = <_cyb_intptr_t>__nvmlDeviceGetEncoderUtilization + data["__nvmlDeviceGetEncoderUtilization"] = <intptr_t>__nvmlDeviceGetEncoderUtilization global __nvmlDeviceGetEncoderCapacity - data["__nvmlDeviceGetEncoderCapacity"] = <_cyb_intptr_t>__nvmlDeviceGetEncoderCapacity + data["__nvmlDeviceGetEncoderCapacity"] = <intptr_t>__nvmlDeviceGetEncoderCapacity global __nvmlDeviceGetEncoderStats - data["__nvmlDeviceGetEncoderStats"] = <_cyb_intptr_t>__nvmlDeviceGetEncoderStats + data["__nvmlDeviceGetEncoderStats"] = <intptr_t>__nvmlDeviceGetEncoderStats global __nvmlDeviceGetEncoderSessions - data["__nvmlDeviceGetEncoderSessions"] = <_cyb_intptr_t>__nvmlDeviceGetEncoderSessions + data["__nvmlDeviceGetEncoderSessions"] = <intptr_t>__nvmlDeviceGetEncoderSessions global __nvmlDeviceGetDecoderUtilization - data["__nvmlDeviceGetDecoderUtilization"] = <_cyb_intptr_t>__nvmlDeviceGetDecoderUtilization + data["__nvmlDeviceGetDecoderUtilization"] = <intptr_t>__nvmlDeviceGetDecoderUtilization global __nvmlDeviceGetJpgUtilization - data["__nvmlDeviceGetJpgUtilization"] = <_cyb_intptr_t>__nvmlDeviceGetJpgUtilization + data["__nvmlDeviceGetJpgUtilization"] = <intptr_t>__nvmlDeviceGetJpgUtilization global __nvmlDeviceGetOfaUtilization - data["__nvmlDeviceGetOfaUtilization"] = <_cyb_intptr_t>__nvmlDeviceGetOfaUtilization + data["__nvmlDeviceGetOfaUtilization"] = <intptr_t>__nvmlDeviceGetOfaUtilization global __nvmlDeviceGetFBCStats - data["__nvmlDeviceGetFBCStats"] = <_cyb_intptr_t>__nvmlDeviceGetFBCStats + data["__nvmlDeviceGetFBCStats"] = <intptr_t>__nvmlDeviceGetFBCStats global __nvmlDeviceGetFBCSessions - data["__nvmlDeviceGetFBCSessions"] = <_cyb_intptr_t>__nvmlDeviceGetFBCSessions + data["__nvmlDeviceGetFBCSessions"] = <intptr_t>__nvmlDeviceGetFBCSessions global __nvmlDeviceGetDriverModel_v2 - data["__nvmlDeviceGetDriverModel_v2"] = <_cyb_intptr_t>__nvmlDeviceGetDriverModel_v2 + data["__nvmlDeviceGetDriverModel_v2"] = <intptr_t>__nvmlDeviceGetDriverModel_v2 global __nvmlDeviceGetVbiosVersion - data["__nvmlDeviceGetVbiosVersion"] = <_cyb_intptr_t>__nvmlDeviceGetVbiosVersion + data["__nvmlDeviceGetVbiosVersion"] = <intptr_t>__nvmlDeviceGetVbiosVersion global __nvmlDeviceGetBridgeChipInfo - data["__nvmlDeviceGetBridgeChipInfo"] = <_cyb_intptr_t>__nvmlDeviceGetBridgeChipInfo + data["__nvmlDeviceGetBridgeChipInfo"] = <intptr_t>__nvmlDeviceGetBridgeChipInfo global __nvmlDeviceGetComputeRunningProcesses_v3 - data["__nvmlDeviceGetComputeRunningProcesses_v3"] = <_cyb_intptr_t>__nvmlDeviceGetComputeRunningProcesses_v3 + data["__nvmlDeviceGetComputeRunningProcesses_v3"] = <intptr_t>__nvmlDeviceGetComputeRunningProcesses_v3 global __nvmlDeviceGetGraphicsRunningProcesses_v3 - data["__nvmlDeviceGetGraphicsRunningProcesses_v3"] = <_cyb_intptr_t>__nvmlDeviceGetGraphicsRunningProcesses_v3 + data["__nvmlDeviceGetGraphicsRunningProcesses_v3"] = <intptr_t>__nvmlDeviceGetGraphicsRunningProcesses_v3 global __nvmlDeviceGetMPSComputeRunningProcesses_v3 - data["__nvmlDeviceGetMPSComputeRunningProcesses_v3"] = <_cyb_intptr_t>__nvmlDeviceGetMPSComputeRunningProcesses_v3 + data["__nvmlDeviceGetMPSComputeRunningProcesses_v3"] = <intptr_t>__nvmlDeviceGetMPSComputeRunningProcesses_v3 global __nvmlDeviceGetRunningProcessDetailList - data["__nvmlDeviceGetRunningProcessDetailList"] = <_cyb_intptr_t>__nvmlDeviceGetRunningProcessDetailList + data["__nvmlDeviceGetRunningProcessDetailList"] = <intptr_t>__nvmlDeviceGetRunningProcessDetailList global __nvmlDeviceOnSameBoard - data["__nvmlDeviceOnSameBoard"] = <_cyb_intptr_t>__nvmlDeviceOnSameBoard + data["__nvmlDeviceOnSameBoard"] = <intptr_t>__nvmlDeviceOnSameBoard global __nvmlDeviceGetAPIRestriction - data["__nvmlDeviceGetAPIRestriction"] = <_cyb_intptr_t>__nvmlDeviceGetAPIRestriction + data["__nvmlDeviceGetAPIRestriction"] = <intptr_t>__nvmlDeviceGetAPIRestriction global __nvmlDeviceGetSamples - data["__nvmlDeviceGetSamples"] = <_cyb_intptr_t>__nvmlDeviceGetSamples + data["__nvmlDeviceGetSamples"] = <intptr_t>__nvmlDeviceGetSamples global __nvmlDeviceGetBAR1MemoryInfo - data["__nvmlDeviceGetBAR1MemoryInfo"] = <_cyb_intptr_t>__nvmlDeviceGetBAR1MemoryInfo + data["__nvmlDeviceGetBAR1MemoryInfo"] = <intptr_t>__nvmlDeviceGetBAR1MemoryInfo global __nvmlDeviceGetIrqNum - data["__nvmlDeviceGetIrqNum"] = <_cyb_intptr_t>__nvmlDeviceGetIrqNum + data["__nvmlDeviceGetIrqNum"] = <intptr_t>__nvmlDeviceGetIrqNum global __nvmlDeviceGetNumGpuCores - data["__nvmlDeviceGetNumGpuCores"] = <_cyb_intptr_t>__nvmlDeviceGetNumGpuCores + data["__nvmlDeviceGetNumGpuCores"] = <intptr_t>__nvmlDeviceGetNumGpuCores global __nvmlDeviceGetPowerSource - data["__nvmlDeviceGetPowerSource"] = <_cyb_intptr_t>__nvmlDeviceGetPowerSource + data["__nvmlDeviceGetPowerSource"] = <intptr_t>__nvmlDeviceGetPowerSource global __nvmlDeviceGetMemoryBusWidth - data["__nvmlDeviceGetMemoryBusWidth"] = <_cyb_intptr_t>__nvmlDeviceGetMemoryBusWidth + data["__nvmlDeviceGetMemoryBusWidth"] = <intptr_t>__nvmlDeviceGetMemoryBusWidth global __nvmlDeviceGetPcieLinkMaxSpeed - data["__nvmlDeviceGetPcieLinkMaxSpeed"] = <_cyb_intptr_t>__nvmlDeviceGetPcieLinkMaxSpeed + data["__nvmlDeviceGetPcieLinkMaxSpeed"] = <intptr_t>__nvmlDeviceGetPcieLinkMaxSpeed global __nvmlDeviceGetPcieSpeed - data["__nvmlDeviceGetPcieSpeed"] = <_cyb_intptr_t>__nvmlDeviceGetPcieSpeed + data["__nvmlDeviceGetPcieSpeed"] = <intptr_t>__nvmlDeviceGetPcieSpeed global __nvmlDeviceGetAdaptiveClockInfoStatus - data["__nvmlDeviceGetAdaptiveClockInfoStatus"] = <_cyb_intptr_t>__nvmlDeviceGetAdaptiveClockInfoStatus + data["__nvmlDeviceGetAdaptiveClockInfoStatus"] = <intptr_t>__nvmlDeviceGetAdaptiveClockInfoStatus global __nvmlDeviceGetBusType - data["__nvmlDeviceGetBusType"] = <_cyb_intptr_t>__nvmlDeviceGetBusType + data["__nvmlDeviceGetBusType"] = <intptr_t>__nvmlDeviceGetBusType global __nvmlDeviceGetGpuFabricInfoV - data["__nvmlDeviceGetGpuFabricInfoV"] = <_cyb_intptr_t>__nvmlDeviceGetGpuFabricInfoV + data["__nvmlDeviceGetGpuFabricInfoV"] = <intptr_t>__nvmlDeviceGetGpuFabricInfoV global __nvmlSystemGetConfComputeCapabilities - data["__nvmlSystemGetConfComputeCapabilities"] = <_cyb_intptr_t>__nvmlSystemGetConfComputeCapabilities + data["__nvmlSystemGetConfComputeCapabilities"] = <intptr_t>__nvmlSystemGetConfComputeCapabilities global __nvmlSystemGetConfComputeState - data["__nvmlSystemGetConfComputeState"] = <_cyb_intptr_t>__nvmlSystemGetConfComputeState + data["__nvmlSystemGetConfComputeState"] = <intptr_t>__nvmlSystemGetConfComputeState global __nvmlDeviceGetConfComputeMemSizeInfo - data["__nvmlDeviceGetConfComputeMemSizeInfo"] = <_cyb_intptr_t>__nvmlDeviceGetConfComputeMemSizeInfo + data["__nvmlDeviceGetConfComputeMemSizeInfo"] = <intptr_t>__nvmlDeviceGetConfComputeMemSizeInfo global __nvmlSystemGetConfComputeGpusReadyState - data["__nvmlSystemGetConfComputeGpusReadyState"] = <_cyb_intptr_t>__nvmlSystemGetConfComputeGpusReadyState + data["__nvmlSystemGetConfComputeGpusReadyState"] = <intptr_t>__nvmlSystemGetConfComputeGpusReadyState global __nvmlDeviceGetConfComputeProtectedMemoryUsage - data["__nvmlDeviceGetConfComputeProtectedMemoryUsage"] = <_cyb_intptr_t>__nvmlDeviceGetConfComputeProtectedMemoryUsage + data["__nvmlDeviceGetConfComputeProtectedMemoryUsage"] = <intptr_t>__nvmlDeviceGetConfComputeProtectedMemoryUsage global __nvmlDeviceGetConfComputeGpuCertificate - data["__nvmlDeviceGetConfComputeGpuCertificate"] = <_cyb_intptr_t>__nvmlDeviceGetConfComputeGpuCertificate + data["__nvmlDeviceGetConfComputeGpuCertificate"] = <intptr_t>__nvmlDeviceGetConfComputeGpuCertificate global __nvmlDeviceGetConfComputeGpuAttestationReport - data["__nvmlDeviceGetConfComputeGpuAttestationReport"] = <_cyb_intptr_t>__nvmlDeviceGetConfComputeGpuAttestationReport + data["__nvmlDeviceGetConfComputeGpuAttestationReport"] = <intptr_t>__nvmlDeviceGetConfComputeGpuAttestationReport global __nvmlSystemGetConfComputeKeyRotationThresholdInfo - data["__nvmlSystemGetConfComputeKeyRotationThresholdInfo"] = <_cyb_intptr_t>__nvmlSystemGetConfComputeKeyRotationThresholdInfo + data["__nvmlSystemGetConfComputeKeyRotationThresholdInfo"] = <intptr_t>__nvmlSystemGetConfComputeKeyRotationThresholdInfo global __nvmlDeviceSetConfComputeUnprotectedMemSize - data["__nvmlDeviceSetConfComputeUnprotectedMemSize"] = <_cyb_intptr_t>__nvmlDeviceSetConfComputeUnprotectedMemSize + data["__nvmlDeviceSetConfComputeUnprotectedMemSize"] = <intptr_t>__nvmlDeviceSetConfComputeUnprotectedMemSize global __nvmlSystemSetConfComputeGpusReadyState - data["__nvmlSystemSetConfComputeGpusReadyState"] = <_cyb_intptr_t>__nvmlSystemSetConfComputeGpusReadyState + data["__nvmlSystemSetConfComputeGpusReadyState"] = <intptr_t>__nvmlSystemSetConfComputeGpusReadyState global __nvmlSystemSetConfComputeKeyRotationThresholdInfo - data["__nvmlSystemSetConfComputeKeyRotationThresholdInfo"] = <_cyb_intptr_t>__nvmlSystemSetConfComputeKeyRotationThresholdInfo + data["__nvmlSystemSetConfComputeKeyRotationThresholdInfo"] = <intptr_t>__nvmlSystemSetConfComputeKeyRotationThresholdInfo global __nvmlSystemGetConfComputeSettings - data["__nvmlSystemGetConfComputeSettings"] = <_cyb_intptr_t>__nvmlSystemGetConfComputeSettings + data["__nvmlSystemGetConfComputeSettings"] = <intptr_t>__nvmlSystemGetConfComputeSettings global __nvmlDeviceGetGspFirmwareVersion - data["__nvmlDeviceGetGspFirmwareVersion"] = <_cyb_intptr_t>__nvmlDeviceGetGspFirmwareVersion + data["__nvmlDeviceGetGspFirmwareVersion"] = <intptr_t>__nvmlDeviceGetGspFirmwareVersion global __nvmlDeviceGetGspFirmwareMode - data["__nvmlDeviceGetGspFirmwareMode"] = <_cyb_intptr_t>__nvmlDeviceGetGspFirmwareMode + data["__nvmlDeviceGetGspFirmwareMode"] = <intptr_t>__nvmlDeviceGetGspFirmwareMode global __nvmlDeviceGetSramEccErrorStatus - data["__nvmlDeviceGetSramEccErrorStatus"] = <_cyb_intptr_t>__nvmlDeviceGetSramEccErrorStatus + data["__nvmlDeviceGetSramEccErrorStatus"] = <intptr_t>__nvmlDeviceGetSramEccErrorStatus global __nvmlDeviceGetAccountingMode - data["__nvmlDeviceGetAccountingMode"] = <_cyb_intptr_t>__nvmlDeviceGetAccountingMode + data["__nvmlDeviceGetAccountingMode"] = <intptr_t>__nvmlDeviceGetAccountingMode global __nvmlDeviceGetAccountingStats - data["__nvmlDeviceGetAccountingStats"] = <_cyb_intptr_t>__nvmlDeviceGetAccountingStats + data["__nvmlDeviceGetAccountingStats"] = <intptr_t>__nvmlDeviceGetAccountingStats global __nvmlDeviceGetAccountingPids - data["__nvmlDeviceGetAccountingPids"] = <_cyb_intptr_t>__nvmlDeviceGetAccountingPids + data["__nvmlDeviceGetAccountingPids"] = <intptr_t>__nvmlDeviceGetAccountingPids global __nvmlDeviceGetAccountingBufferSize - data["__nvmlDeviceGetAccountingBufferSize"] = <_cyb_intptr_t>__nvmlDeviceGetAccountingBufferSize + data["__nvmlDeviceGetAccountingBufferSize"] = <intptr_t>__nvmlDeviceGetAccountingBufferSize global __nvmlDeviceGetRetiredPages - data["__nvmlDeviceGetRetiredPages"] = <_cyb_intptr_t>__nvmlDeviceGetRetiredPages + data["__nvmlDeviceGetRetiredPages"] = <intptr_t>__nvmlDeviceGetRetiredPages global __nvmlDeviceGetRetiredPages_v2 - data["__nvmlDeviceGetRetiredPages_v2"] = <_cyb_intptr_t>__nvmlDeviceGetRetiredPages_v2 + data["__nvmlDeviceGetRetiredPages_v2"] = <intptr_t>__nvmlDeviceGetRetiredPages_v2 global __nvmlDeviceGetRetiredPagesPendingStatus - data["__nvmlDeviceGetRetiredPagesPendingStatus"] = <_cyb_intptr_t>__nvmlDeviceGetRetiredPagesPendingStatus + data["__nvmlDeviceGetRetiredPagesPendingStatus"] = <intptr_t>__nvmlDeviceGetRetiredPagesPendingStatus global __nvmlDeviceGetRemappedRows - data["__nvmlDeviceGetRemappedRows"] = <_cyb_intptr_t>__nvmlDeviceGetRemappedRows + data["__nvmlDeviceGetRemappedRows"] = <intptr_t>__nvmlDeviceGetRemappedRows global __nvmlDeviceGetRowRemapperHistogram - data["__nvmlDeviceGetRowRemapperHistogram"] = <_cyb_intptr_t>__nvmlDeviceGetRowRemapperHistogram + data["__nvmlDeviceGetRowRemapperHistogram"] = <intptr_t>__nvmlDeviceGetRowRemapperHistogram global __nvmlDeviceGetArchitecture - data["__nvmlDeviceGetArchitecture"] = <_cyb_intptr_t>__nvmlDeviceGetArchitecture + data["__nvmlDeviceGetArchitecture"] = <intptr_t>__nvmlDeviceGetArchitecture global __nvmlDeviceGetClkMonStatus - data["__nvmlDeviceGetClkMonStatus"] = <_cyb_intptr_t>__nvmlDeviceGetClkMonStatus + data["__nvmlDeviceGetClkMonStatus"] = <intptr_t>__nvmlDeviceGetClkMonStatus global __nvmlDeviceGetProcessUtilization - data["__nvmlDeviceGetProcessUtilization"] = <_cyb_intptr_t>__nvmlDeviceGetProcessUtilization + data["__nvmlDeviceGetProcessUtilization"] = <intptr_t>__nvmlDeviceGetProcessUtilization global __nvmlDeviceGetProcessesUtilizationInfo - data["__nvmlDeviceGetProcessesUtilizationInfo"] = <_cyb_intptr_t>__nvmlDeviceGetProcessesUtilizationInfo + data["__nvmlDeviceGetProcessesUtilizationInfo"] = <intptr_t>__nvmlDeviceGetProcessesUtilizationInfo global __nvmlDeviceGetPlatformInfo - data["__nvmlDeviceGetPlatformInfo"] = <_cyb_intptr_t>__nvmlDeviceGetPlatformInfo + data["__nvmlDeviceGetPlatformInfo"] = <intptr_t>__nvmlDeviceGetPlatformInfo global __nvmlUnitSetLedState - data["__nvmlUnitSetLedState"] = <_cyb_intptr_t>__nvmlUnitSetLedState + data["__nvmlUnitSetLedState"] = <intptr_t>__nvmlUnitSetLedState global __nvmlDeviceSetPersistenceMode - data["__nvmlDeviceSetPersistenceMode"] = <_cyb_intptr_t>__nvmlDeviceSetPersistenceMode + data["__nvmlDeviceSetPersistenceMode"] = <intptr_t>__nvmlDeviceSetPersistenceMode global __nvmlDeviceSetComputeMode - data["__nvmlDeviceSetComputeMode"] = <_cyb_intptr_t>__nvmlDeviceSetComputeMode + data["__nvmlDeviceSetComputeMode"] = <intptr_t>__nvmlDeviceSetComputeMode global __nvmlDeviceSetEccMode - data["__nvmlDeviceSetEccMode"] = <_cyb_intptr_t>__nvmlDeviceSetEccMode + data["__nvmlDeviceSetEccMode"] = <intptr_t>__nvmlDeviceSetEccMode global __nvmlDeviceClearEccErrorCounts - data["__nvmlDeviceClearEccErrorCounts"] = <_cyb_intptr_t>__nvmlDeviceClearEccErrorCounts + data["__nvmlDeviceClearEccErrorCounts"] = <intptr_t>__nvmlDeviceClearEccErrorCounts global __nvmlDeviceSetDriverModel - data["__nvmlDeviceSetDriverModel"] = <_cyb_intptr_t>__nvmlDeviceSetDriverModel + data["__nvmlDeviceSetDriverModel"] = <intptr_t>__nvmlDeviceSetDriverModel global __nvmlDeviceSetGpuLockedClocks - data["__nvmlDeviceSetGpuLockedClocks"] = <_cyb_intptr_t>__nvmlDeviceSetGpuLockedClocks + data["__nvmlDeviceSetGpuLockedClocks"] = <intptr_t>__nvmlDeviceSetGpuLockedClocks global __nvmlDeviceResetGpuLockedClocks - data["__nvmlDeviceResetGpuLockedClocks"] = <_cyb_intptr_t>__nvmlDeviceResetGpuLockedClocks + data["__nvmlDeviceResetGpuLockedClocks"] = <intptr_t>__nvmlDeviceResetGpuLockedClocks global __nvmlDeviceSetMemoryLockedClocks - data["__nvmlDeviceSetMemoryLockedClocks"] = <_cyb_intptr_t>__nvmlDeviceSetMemoryLockedClocks + data["__nvmlDeviceSetMemoryLockedClocks"] = <intptr_t>__nvmlDeviceSetMemoryLockedClocks global __nvmlDeviceResetMemoryLockedClocks - data["__nvmlDeviceResetMemoryLockedClocks"] = <_cyb_intptr_t>__nvmlDeviceResetMemoryLockedClocks + data["__nvmlDeviceResetMemoryLockedClocks"] = <intptr_t>__nvmlDeviceResetMemoryLockedClocks global __nvmlDeviceSetAutoBoostedClocksEnabled - data["__nvmlDeviceSetAutoBoostedClocksEnabled"] = <_cyb_intptr_t>__nvmlDeviceSetAutoBoostedClocksEnabled + data["__nvmlDeviceSetAutoBoostedClocksEnabled"] = <intptr_t>__nvmlDeviceSetAutoBoostedClocksEnabled global __nvmlDeviceSetDefaultAutoBoostedClocksEnabled - data["__nvmlDeviceSetDefaultAutoBoostedClocksEnabled"] = <_cyb_intptr_t>__nvmlDeviceSetDefaultAutoBoostedClocksEnabled + data["__nvmlDeviceSetDefaultAutoBoostedClocksEnabled"] = <intptr_t>__nvmlDeviceSetDefaultAutoBoostedClocksEnabled global __nvmlDeviceSetDefaultFanSpeed_v2 - data["__nvmlDeviceSetDefaultFanSpeed_v2"] = <_cyb_intptr_t>__nvmlDeviceSetDefaultFanSpeed_v2 + data["__nvmlDeviceSetDefaultFanSpeed_v2"] = <intptr_t>__nvmlDeviceSetDefaultFanSpeed_v2 global __nvmlDeviceSetFanControlPolicy - data["__nvmlDeviceSetFanControlPolicy"] = <_cyb_intptr_t>__nvmlDeviceSetFanControlPolicy + data["__nvmlDeviceSetFanControlPolicy"] = <intptr_t>__nvmlDeviceSetFanControlPolicy global __nvmlDeviceSetTemperatureThreshold - data["__nvmlDeviceSetTemperatureThreshold"] = <_cyb_intptr_t>__nvmlDeviceSetTemperatureThreshold + data["__nvmlDeviceSetTemperatureThreshold"] = <intptr_t>__nvmlDeviceSetTemperatureThreshold global __nvmlDeviceSetGpuOperationMode - data["__nvmlDeviceSetGpuOperationMode"] = <_cyb_intptr_t>__nvmlDeviceSetGpuOperationMode + data["__nvmlDeviceSetGpuOperationMode"] = <intptr_t>__nvmlDeviceSetGpuOperationMode global __nvmlDeviceSetAPIRestriction - data["__nvmlDeviceSetAPIRestriction"] = <_cyb_intptr_t>__nvmlDeviceSetAPIRestriction + data["__nvmlDeviceSetAPIRestriction"] = <intptr_t>__nvmlDeviceSetAPIRestriction global __nvmlDeviceSetFanSpeed_v2 - data["__nvmlDeviceSetFanSpeed_v2"] = <_cyb_intptr_t>__nvmlDeviceSetFanSpeed_v2 + data["__nvmlDeviceSetFanSpeed_v2"] = <intptr_t>__nvmlDeviceSetFanSpeed_v2 global __nvmlDeviceSetAccountingMode - data["__nvmlDeviceSetAccountingMode"] = <_cyb_intptr_t>__nvmlDeviceSetAccountingMode + data["__nvmlDeviceSetAccountingMode"] = <intptr_t>__nvmlDeviceSetAccountingMode global __nvmlDeviceClearAccountingPids - data["__nvmlDeviceClearAccountingPids"] = <_cyb_intptr_t>__nvmlDeviceClearAccountingPids + data["__nvmlDeviceClearAccountingPids"] = <intptr_t>__nvmlDeviceClearAccountingPids global __nvmlDeviceSetPowerManagementLimit_v2 - data["__nvmlDeviceSetPowerManagementLimit_v2"] = <_cyb_intptr_t>__nvmlDeviceSetPowerManagementLimit_v2 + data["__nvmlDeviceSetPowerManagementLimit_v2"] = <intptr_t>__nvmlDeviceSetPowerManagementLimit_v2 global __nvmlDeviceGetNvLinkState - data["__nvmlDeviceGetNvLinkState"] = <_cyb_intptr_t>__nvmlDeviceGetNvLinkState + data["__nvmlDeviceGetNvLinkState"] = <intptr_t>__nvmlDeviceGetNvLinkState global __nvmlDeviceGetNvLinkVersion - data["__nvmlDeviceGetNvLinkVersion"] = <_cyb_intptr_t>__nvmlDeviceGetNvLinkVersion + data["__nvmlDeviceGetNvLinkVersion"] = <intptr_t>__nvmlDeviceGetNvLinkVersion global __nvmlDeviceGetNvLinkCapability - data["__nvmlDeviceGetNvLinkCapability"] = <_cyb_intptr_t>__nvmlDeviceGetNvLinkCapability + data["__nvmlDeviceGetNvLinkCapability"] = <intptr_t>__nvmlDeviceGetNvLinkCapability global __nvmlDeviceGetNvLinkRemotePciInfo_v2 - data["__nvmlDeviceGetNvLinkRemotePciInfo_v2"] = <_cyb_intptr_t>__nvmlDeviceGetNvLinkRemotePciInfo_v2 + data["__nvmlDeviceGetNvLinkRemotePciInfo_v2"] = <intptr_t>__nvmlDeviceGetNvLinkRemotePciInfo_v2 global __nvmlDeviceGetNvLinkErrorCounter - data["__nvmlDeviceGetNvLinkErrorCounter"] = <_cyb_intptr_t>__nvmlDeviceGetNvLinkErrorCounter + data["__nvmlDeviceGetNvLinkErrorCounter"] = <intptr_t>__nvmlDeviceGetNvLinkErrorCounter global __nvmlDeviceResetNvLinkErrorCounters - data["__nvmlDeviceResetNvLinkErrorCounters"] = <_cyb_intptr_t>__nvmlDeviceResetNvLinkErrorCounters + data["__nvmlDeviceResetNvLinkErrorCounters"] = <intptr_t>__nvmlDeviceResetNvLinkErrorCounters global __nvmlDeviceGetNvLinkRemoteDeviceType - data["__nvmlDeviceGetNvLinkRemoteDeviceType"] = <_cyb_intptr_t>__nvmlDeviceGetNvLinkRemoteDeviceType + data["__nvmlDeviceGetNvLinkRemoteDeviceType"] = <intptr_t>__nvmlDeviceGetNvLinkRemoteDeviceType global __nvmlDeviceSetNvLinkDeviceLowPowerThreshold - data["__nvmlDeviceSetNvLinkDeviceLowPowerThreshold"] = <_cyb_intptr_t>__nvmlDeviceSetNvLinkDeviceLowPowerThreshold + data["__nvmlDeviceSetNvLinkDeviceLowPowerThreshold"] = <intptr_t>__nvmlDeviceSetNvLinkDeviceLowPowerThreshold global __nvmlSystemSetNvlinkBwMode - data["__nvmlSystemSetNvlinkBwMode"] = <_cyb_intptr_t>__nvmlSystemSetNvlinkBwMode + data["__nvmlSystemSetNvlinkBwMode"] = <intptr_t>__nvmlSystemSetNvlinkBwMode global __nvmlSystemGetNvlinkBwMode - data["__nvmlSystemGetNvlinkBwMode"] = <_cyb_intptr_t>__nvmlSystemGetNvlinkBwMode + data["__nvmlSystemGetNvlinkBwMode"] = <intptr_t>__nvmlSystemGetNvlinkBwMode global __nvmlDeviceGetNvlinkSupportedBwModes - data["__nvmlDeviceGetNvlinkSupportedBwModes"] = <_cyb_intptr_t>__nvmlDeviceGetNvlinkSupportedBwModes + data["__nvmlDeviceGetNvlinkSupportedBwModes"] = <intptr_t>__nvmlDeviceGetNvlinkSupportedBwModes global __nvmlDeviceGetNvlinkBwMode - data["__nvmlDeviceGetNvlinkBwMode"] = <_cyb_intptr_t>__nvmlDeviceGetNvlinkBwMode + data["__nvmlDeviceGetNvlinkBwMode"] = <intptr_t>__nvmlDeviceGetNvlinkBwMode global __nvmlDeviceSetNvlinkBwMode - data["__nvmlDeviceSetNvlinkBwMode"] = <_cyb_intptr_t>__nvmlDeviceSetNvlinkBwMode + data["__nvmlDeviceSetNvlinkBwMode"] = <intptr_t>__nvmlDeviceSetNvlinkBwMode global __nvmlEventSetCreate - data["__nvmlEventSetCreate"] = <_cyb_intptr_t>__nvmlEventSetCreate + data["__nvmlEventSetCreate"] = <intptr_t>__nvmlEventSetCreate global __nvmlDeviceRegisterEvents - data["__nvmlDeviceRegisterEvents"] = <_cyb_intptr_t>__nvmlDeviceRegisterEvents + data["__nvmlDeviceRegisterEvents"] = <intptr_t>__nvmlDeviceRegisterEvents global __nvmlDeviceGetSupportedEventTypes - data["__nvmlDeviceGetSupportedEventTypes"] = <_cyb_intptr_t>__nvmlDeviceGetSupportedEventTypes + data["__nvmlDeviceGetSupportedEventTypes"] = <intptr_t>__nvmlDeviceGetSupportedEventTypes global __nvmlEventSetWait_v2 - data["__nvmlEventSetWait_v2"] = <_cyb_intptr_t>__nvmlEventSetWait_v2 + data["__nvmlEventSetWait_v2"] = <intptr_t>__nvmlEventSetWait_v2 global __nvmlEventSetFree - data["__nvmlEventSetFree"] = <_cyb_intptr_t>__nvmlEventSetFree + data["__nvmlEventSetFree"] = <intptr_t>__nvmlEventSetFree global __nvmlSystemEventSetCreate - data["__nvmlSystemEventSetCreate"] = <_cyb_intptr_t>__nvmlSystemEventSetCreate + data["__nvmlSystemEventSetCreate"] = <intptr_t>__nvmlSystemEventSetCreate global __nvmlSystemEventSetFree - data["__nvmlSystemEventSetFree"] = <_cyb_intptr_t>__nvmlSystemEventSetFree + data["__nvmlSystemEventSetFree"] = <intptr_t>__nvmlSystemEventSetFree global __nvmlSystemRegisterEvents - data["__nvmlSystemRegisterEvents"] = <_cyb_intptr_t>__nvmlSystemRegisterEvents + data["__nvmlSystemRegisterEvents"] = <intptr_t>__nvmlSystemRegisterEvents global __nvmlSystemEventSetWait - data["__nvmlSystemEventSetWait"] = <_cyb_intptr_t>__nvmlSystemEventSetWait + data["__nvmlSystemEventSetWait"] = <intptr_t>__nvmlSystemEventSetWait global __nvmlDeviceModifyDrainState - data["__nvmlDeviceModifyDrainState"] = <_cyb_intptr_t>__nvmlDeviceModifyDrainState + data["__nvmlDeviceModifyDrainState"] = <intptr_t>__nvmlDeviceModifyDrainState global __nvmlDeviceQueryDrainState - data["__nvmlDeviceQueryDrainState"] = <_cyb_intptr_t>__nvmlDeviceQueryDrainState + data["__nvmlDeviceQueryDrainState"] = <intptr_t>__nvmlDeviceQueryDrainState global __nvmlDeviceRemoveGpu_v2 - data["__nvmlDeviceRemoveGpu_v2"] = <_cyb_intptr_t>__nvmlDeviceRemoveGpu_v2 + data["__nvmlDeviceRemoveGpu_v2"] = <intptr_t>__nvmlDeviceRemoveGpu_v2 global __nvmlDeviceDiscoverGpus - data["__nvmlDeviceDiscoverGpus"] = <_cyb_intptr_t>__nvmlDeviceDiscoverGpus + data["__nvmlDeviceDiscoverGpus"] = <intptr_t>__nvmlDeviceDiscoverGpus global __nvmlDeviceGetFieldValues - data["__nvmlDeviceGetFieldValues"] = <_cyb_intptr_t>__nvmlDeviceGetFieldValues + data["__nvmlDeviceGetFieldValues"] = <intptr_t>__nvmlDeviceGetFieldValues global __nvmlDeviceClearFieldValues - data["__nvmlDeviceClearFieldValues"] = <_cyb_intptr_t>__nvmlDeviceClearFieldValues + data["__nvmlDeviceClearFieldValues"] = <intptr_t>__nvmlDeviceClearFieldValues global __nvmlDeviceGetVirtualizationMode - data["__nvmlDeviceGetVirtualizationMode"] = <_cyb_intptr_t>__nvmlDeviceGetVirtualizationMode + data["__nvmlDeviceGetVirtualizationMode"] = <intptr_t>__nvmlDeviceGetVirtualizationMode global __nvmlDeviceGetHostVgpuMode - data["__nvmlDeviceGetHostVgpuMode"] = <_cyb_intptr_t>__nvmlDeviceGetHostVgpuMode + data["__nvmlDeviceGetHostVgpuMode"] = <intptr_t>__nvmlDeviceGetHostVgpuMode global __nvmlDeviceSetVirtualizationMode - data["__nvmlDeviceSetVirtualizationMode"] = <_cyb_intptr_t>__nvmlDeviceSetVirtualizationMode + data["__nvmlDeviceSetVirtualizationMode"] = <intptr_t>__nvmlDeviceSetVirtualizationMode global __nvmlDeviceGetVgpuHeterogeneousMode - data["__nvmlDeviceGetVgpuHeterogeneousMode"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuHeterogeneousMode + data["__nvmlDeviceGetVgpuHeterogeneousMode"] = <intptr_t>__nvmlDeviceGetVgpuHeterogeneousMode global __nvmlDeviceSetVgpuHeterogeneousMode - data["__nvmlDeviceSetVgpuHeterogeneousMode"] = <_cyb_intptr_t>__nvmlDeviceSetVgpuHeterogeneousMode + data["__nvmlDeviceSetVgpuHeterogeneousMode"] = <intptr_t>__nvmlDeviceSetVgpuHeterogeneousMode global __nvmlVgpuInstanceGetPlacementId - data["__nvmlVgpuInstanceGetPlacementId"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetPlacementId + data["__nvmlVgpuInstanceGetPlacementId"] = <intptr_t>__nvmlVgpuInstanceGetPlacementId global __nvmlDeviceGetVgpuTypeSupportedPlacements - data["__nvmlDeviceGetVgpuTypeSupportedPlacements"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuTypeSupportedPlacements + data["__nvmlDeviceGetVgpuTypeSupportedPlacements"] = <intptr_t>__nvmlDeviceGetVgpuTypeSupportedPlacements global __nvmlDeviceGetVgpuTypeCreatablePlacements - data["__nvmlDeviceGetVgpuTypeCreatablePlacements"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuTypeCreatablePlacements + data["__nvmlDeviceGetVgpuTypeCreatablePlacements"] = <intptr_t>__nvmlDeviceGetVgpuTypeCreatablePlacements global __nvmlVgpuTypeGetGspHeapSize - data["__nvmlVgpuTypeGetGspHeapSize"] = <_cyb_intptr_t>__nvmlVgpuTypeGetGspHeapSize + data["__nvmlVgpuTypeGetGspHeapSize"] = <intptr_t>__nvmlVgpuTypeGetGspHeapSize global __nvmlVgpuTypeGetFbReservation - data["__nvmlVgpuTypeGetFbReservation"] = <_cyb_intptr_t>__nvmlVgpuTypeGetFbReservation + data["__nvmlVgpuTypeGetFbReservation"] = <intptr_t>__nvmlVgpuTypeGetFbReservation global __nvmlVgpuInstanceGetRuntimeStateSize - data["__nvmlVgpuInstanceGetRuntimeStateSize"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetRuntimeStateSize + data["__nvmlVgpuInstanceGetRuntimeStateSize"] = <intptr_t>__nvmlVgpuInstanceGetRuntimeStateSize global __nvmlDeviceSetVgpuCapabilities - data["__nvmlDeviceSetVgpuCapabilities"] = <_cyb_intptr_t>__nvmlDeviceSetVgpuCapabilities + data["__nvmlDeviceSetVgpuCapabilities"] = <intptr_t>__nvmlDeviceSetVgpuCapabilities global __nvmlDeviceGetGridLicensableFeatures_v4 - data["__nvmlDeviceGetGridLicensableFeatures_v4"] = <_cyb_intptr_t>__nvmlDeviceGetGridLicensableFeatures_v4 + data["__nvmlDeviceGetGridLicensableFeatures_v4"] = <intptr_t>__nvmlDeviceGetGridLicensableFeatures_v4 global __nvmlGetVgpuDriverCapabilities - data["__nvmlGetVgpuDriverCapabilities"] = <_cyb_intptr_t>__nvmlGetVgpuDriverCapabilities + data["__nvmlGetVgpuDriverCapabilities"] = <intptr_t>__nvmlGetVgpuDriverCapabilities global __nvmlDeviceGetVgpuCapabilities - data["__nvmlDeviceGetVgpuCapabilities"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuCapabilities + data["__nvmlDeviceGetVgpuCapabilities"] = <intptr_t>__nvmlDeviceGetVgpuCapabilities global __nvmlDeviceGetSupportedVgpus - data["__nvmlDeviceGetSupportedVgpus"] = <_cyb_intptr_t>__nvmlDeviceGetSupportedVgpus + data["__nvmlDeviceGetSupportedVgpus"] = <intptr_t>__nvmlDeviceGetSupportedVgpus global __nvmlDeviceGetCreatableVgpus - data["__nvmlDeviceGetCreatableVgpus"] = <_cyb_intptr_t>__nvmlDeviceGetCreatableVgpus + data["__nvmlDeviceGetCreatableVgpus"] = <intptr_t>__nvmlDeviceGetCreatableVgpus global __nvmlVgpuTypeGetClass - data["__nvmlVgpuTypeGetClass"] = <_cyb_intptr_t>__nvmlVgpuTypeGetClass + data["__nvmlVgpuTypeGetClass"] = <intptr_t>__nvmlVgpuTypeGetClass global __nvmlVgpuTypeGetName - data["__nvmlVgpuTypeGetName"] = <_cyb_intptr_t>__nvmlVgpuTypeGetName + data["__nvmlVgpuTypeGetName"] = <intptr_t>__nvmlVgpuTypeGetName global __nvmlVgpuTypeGetGpuInstanceProfileId - data["__nvmlVgpuTypeGetGpuInstanceProfileId"] = <_cyb_intptr_t>__nvmlVgpuTypeGetGpuInstanceProfileId + data["__nvmlVgpuTypeGetGpuInstanceProfileId"] = <intptr_t>__nvmlVgpuTypeGetGpuInstanceProfileId global __nvmlVgpuTypeGetDeviceID - data["__nvmlVgpuTypeGetDeviceID"] = <_cyb_intptr_t>__nvmlVgpuTypeGetDeviceID + data["__nvmlVgpuTypeGetDeviceID"] = <intptr_t>__nvmlVgpuTypeGetDeviceID global __nvmlVgpuTypeGetFramebufferSize - data["__nvmlVgpuTypeGetFramebufferSize"] = <_cyb_intptr_t>__nvmlVgpuTypeGetFramebufferSize + data["__nvmlVgpuTypeGetFramebufferSize"] = <intptr_t>__nvmlVgpuTypeGetFramebufferSize global __nvmlVgpuTypeGetNumDisplayHeads - data["__nvmlVgpuTypeGetNumDisplayHeads"] = <_cyb_intptr_t>__nvmlVgpuTypeGetNumDisplayHeads + data["__nvmlVgpuTypeGetNumDisplayHeads"] = <intptr_t>__nvmlVgpuTypeGetNumDisplayHeads global __nvmlVgpuTypeGetResolution - data["__nvmlVgpuTypeGetResolution"] = <_cyb_intptr_t>__nvmlVgpuTypeGetResolution + data["__nvmlVgpuTypeGetResolution"] = <intptr_t>__nvmlVgpuTypeGetResolution global __nvmlVgpuTypeGetLicense - data["__nvmlVgpuTypeGetLicense"] = <_cyb_intptr_t>__nvmlVgpuTypeGetLicense + data["__nvmlVgpuTypeGetLicense"] = <intptr_t>__nvmlVgpuTypeGetLicense global __nvmlVgpuTypeGetFrameRateLimit - data["__nvmlVgpuTypeGetFrameRateLimit"] = <_cyb_intptr_t>__nvmlVgpuTypeGetFrameRateLimit + data["__nvmlVgpuTypeGetFrameRateLimit"] = <intptr_t>__nvmlVgpuTypeGetFrameRateLimit global __nvmlVgpuTypeGetMaxInstances - data["__nvmlVgpuTypeGetMaxInstances"] = <_cyb_intptr_t>__nvmlVgpuTypeGetMaxInstances + data["__nvmlVgpuTypeGetMaxInstances"] = <intptr_t>__nvmlVgpuTypeGetMaxInstances global __nvmlVgpuTypeGetMaxInstancesPerVm - data["__nvmlVgpuTypeGetMaxInstancesPerVm"] = <_cyb_intptr_t>__nvmlVgpuTypeGetMaxInstancesPerVm + data["__nvmlVgpuTypeGetMaxInstancesPerVm"] = <intptr_t>__nvmlVgpuTypeGetMaxInstancesPerVm global __nvmlVgpuTypeGetBAR1Info - data["__nvmlVgpuTypeGetBAR1Info"] = <_cyb_intptr_t>__nvmlVgpuTypeGetBAR1Info + data["__nvmlVgpuTypeGetBAR1Info"] = <intptr_t>__nvmlVgpuTypeGetBAR1Info global __nvmlDeviceGetActiveVgpus - data["__nvmlDeviceGetActiveVgpus"] = <_cyb_intptr_t>__nvmlDeviceGetActiveVgpus + data["__nvmlDeviceGetActiveVgpus"] = <intptr_t>__nvmlDeviceGetActiveVgpus global __nvmlVgpuInstanceGetVmID - data["__nvmlVgpuInstanceGetVmID"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetVmID + data["__nvmlVgpuInstanceGetVmID"] = <intptr_t>__nvmlVgpuInstanceGetVmID global __nvmlVgpuInstanceGetUUID - data["__nvmlVgpuInstanceGetUUID"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetUUID + data["__nvmlVgpuInstanceGetUUID"] = <intptr_t>__nvmlVgpuInstanceGetUUID global __nvmlVgpuInstanceGetVmDriverVersion - data["__nvmlVgpuInstanceGetVmDriverVersion"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetVmDriverVersion + data["__nvmlVgpuInstanceGetVmDriverVersion"] = <intptr_t>__nvmlVgpuInstanceGetVmDriverVersion global __nvmlVgpuInstanceGetFbUsage - data["__nvmlVgpuInstanceGetFbUsage"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetFbUsage + data["__nvmlVgpuInstanceGetFbUsage"] = <intptr_t>__nvmlVgpuInstanceGetFbUsage global __nvmlVgpuInstanceGetLicenseStatus - data["__nvmlVgpuInstanceGetLicenseStatus"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetLicenseStatus + data["__nvmlVgpuInstanceGetLicenseStatus"] = <intptr_t>__nvmlVgpuInstanceGetLicenseStatus global __nvmlVgpuInstanceGetType - data["__nvmlVgpuInstanceGetType"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetType + data["__nvmlVgpuInstanceGetType"] = <intptr_t>__nvmlVgpuInstanceGetType global __nvmlVgpuInstanceGetFrameRateLimit - data["__nvmlVgpuInstanceGetFrameRateLimit"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetFrameRateLimit + data["__nvmlVgpuInstanceGetFrameRateLimit"] = <intptr_t>__nvmlVgpuInstanceGetFrameRateLimit global __nvmlVgpuInstanceGetEccMode - data["__nvmlVgpuInstanceGetEccMode"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetEccMode + data["__nvmlVgpuInstanceGetEccMode"] = <intptr_t>__nvmlVgpuInstanceGetEccMode global __nvmlVgpuInstanceGetEncoderCapacity - data["__nvmlVgpuInstanceGetEncoderCapacity"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetEncoderCapacity + data["__nvmlVgpuInstanceGetEncoderCapacity"] = <intptr_t>__nvmlVgpuInstanceGetEncoderCapacity global __nvmlVgpuInstanceSetEncoderCapacity - data["__nvmlVgpuInstanceSetEncoderCapacity"] = <_cyb_intptr_t>__nvmlVgpuInstanceSetEncoderCapacity + data["__nvmlVgpuInstanceSetEncoderCapacity"] = <intptr_t>__nvmlVgpuInstanceSetEncoderCapacity global __nvmlVgpuInstanceGetEncoderStats - data["__nvmlVgpuInstanceGetEncoderStats"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetEncoderStats + data["__nvmlVgpuInstanceGetEncoderStats"] = <intptr_t>__nvmlVgpuInstanceGetEncoderStats global __nvmlVgpuInstanceGetEncoderSessions - data["__nvmlVgpuInstanceGetEncoderSessions"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetEncoderSessions + data["__nvmlVgpuInstanceGetEncoderSessions"] = <intptr_t>__nvmlVgpuInstanceGetEncoderSessions global __nvmlVgpuInstanceGetFBCStats - data["__nvmlVgpuInstanceGetFBCStats"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetFBCStats + data["__nvmlVgpuInstanceGetFBCStats"] = <intptr_t>__nvmlVgpuInstanceGetFBCStats global __nvmlVgpuInstanceGetFBCSessions - data["__nvmlVgpuInstanceGetFBCSessions"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetFBCSessions + data["__nvmlVgpuInstanceGetFBCSessions"] = <intptr_t>__nvmlVgpuInstanceGetFBCSessions global __nvmlVgpuInstanceGetGpuInstanceId - data["__nvmlVgpuInstanceGetGpuInstanceId"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetGpuInstanceId + data["__nvmlVgpuInstanceGetGpuInstanceId"] = <intptr_t>__nvmlVgpuInstanceGetGpuInstanceId global __nvmlVgpuInstanceGetGpuPciId - data["__nvmlVgpuInstanceGetGpuPciId"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetGpuPciId + data["__nvmlVgpuInstanceGetGpuPciId"] = <intptr_t>__nvmlVgpuInstanceGetGpuPciId global __nvmlVgpuTypeGetCapabilities - data["__nvmlVgpuTypeGetCapabilities"] = <_cyb_intptr_t>__nvmlVgpuTypeGetCapabilities + data["__nvmlVgpuTypeGetCapabilities"] = <intptr_t>__nvmlVgpuTypeGetCapabilities global __nvmlVgpuInstanceGetMdevUUID - data["__nvmlVgpuInstanceGetMdevUUID"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetMdevUUID + data["__nvmlVgpuInstanceGetMdevUUID"] = <intptr_t>__nvmlVgpuInstanceGetMdevUUID global __nvmlGpuInstanceGetCreatableVgpus - data["__nvmlGpuInstanceGetCreatableVgpus"] = <_cyb_intptr_t>__nvmlGpuInstanceGetCreatableVgpus + data["__nvmlGpuInstanceGetCreatableVgpus"] = <intptr_t>__nvmlGpuInstanceGetCreatableVgpus global __nvmlVgpuTypeGetMaxInstancesPerGpuInstance - data["__nvmlVgpuTypeGetMaxInstancesPerGpuInstance"] = <_cyb_intptr_t>__nvmlVgpuTypeGetMaxInstancesPerGpuInstance + data["__nvmlVgpuTypeGetMaxInstancesPerGpuInstance"] = <intptr_t>__nvmlVgpuTypeGetMaxInstancesPerGpuInstance global __nvmlGpuInstanceGetActiveVgpus - data["__nvmlGpuInstanceGetActiveVgpus"] = <_cyb_intptr_t>__nvmlGpuInstanceGetActiveVgpus + data["__nvmlGpuInstanceGetActiveVgpus"] = <intptr_t>__nvmlGpuInstanceGetActiveVgpus global __nvmlGpuInstanceSetVgpuSchedulerState - data["__nvmlGpuInstanceSetVgpuSchedulerState"] = <_cyb_intptr_t>__nvmlGpuInstanceSetVgpuSchedulerState + data["__nvmlGpuInstanceSetVgpuSchedulerState"] = <intptr_t>__nvmlGpuInstanceSetVgpuSchedulerState global __nvmlGpuInstanceGetVgpuSchedulerState - data["__nvmlGpuInstanceGetVgpuSchedulerState"] = <_cyb_intptr_t>__nvmlGpuInstanceGetVgpuSchedulerState + data["__nvmlGpuInstanceGetVgpuSchedulerState"] = <intptr_t>__nvmlGpuInstanceGetVgpuSchedulerState global __nvmlGpuInstanceGetVgpuSchedulerLog - data["__nvmlGpuInstanceGetVgpuSchedulerLog"] = <_cyb_intptr_t>__nvmlGpuInstanceGetVgpuSchedulerLog + data["__nvmlGpuInstanceGetVgpuSchedulerLog"] = <intptr_t>__nvmlGpuInstanceGetVgpuSchedulerLog global __nvmlGpuInstanceGetVgpuTypeCreatablePlacements - data["__nvmlGpuInstanceGetVgpuTypeCreatablePlacements"] = <_cyb_intptr_t>__nvmlGpuInstanceGetVgpuTypeCreatablePlacements + data["__nvmlGpuInstanceGetVgpuTypeCreatablePlacements"] = <intptr_t>__nvmlGpuInstanceGetVgpuTypeCreatablePlacements global __nvmlGpuInstanceGetVgpuHeterogeneousMode - data["__nvmlGpuInstanceGetVgpuHeterogeneousMode"] = <_cyb_intptr_t>__nvmlGpuInstanceGetVgpuHeterogeneousMode + data["__nvmlGpuInstanceGetVgpuHeterogeneousMode"] = <intptr_t>__nvmlGpuInstanceGetVgpuHeterogeneousMode global __nvmlGpuInstanceSetVgpuHeterogeneousMode - data["__nvmlGpuInstanceSetVgpuHeterogeneousMode"] = <_cyb_intptr_t>__nvmlGpuInstanceSetVgpuHeterogeneousMode + data["__nvmlGpuInstanceSetVgpuHeterogeneousMode"] = <intptr_t>__nvmlGpuInstanceSetVgpuHeterogeneousMode global __nvmlVgpuInstanceGetMetadata - data["__nvmlVgpuInstanceGetMetadata"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetMetadata + data["__nvmlVgpuInstanceGetMetadata"] = <intptr_t>__nvmlVgpuInstanceGetMetadata global __nvmlDeviceGetVgpuMetadata - data["__nvmlDeviceGetVgpuMetadata"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuMetadata + data["__nvmlDeviceGetVgpuMetadata"] = <intptr_t>__nvmlDeviceGetVgpuMetadata global __nvmlGetVgpuCompatibility - data["__nvmlGetVgpuCompatibility"] = <_cyb_intptr_t>__nvmlGetVgpuCompatibility + data["__nvmlGetVgpuCompatibility"] = <intptr_t>__nvmlGetVgpuCompatibility global __nvmlDeviceGetPgpuMetadataString - data["__nvmlDeviceGetPgpuMetadataString"] = <_cyb_intptr_t>__nvmlDeviceGetPgpuMetadataString + data["__nvmlDeviceGetPgpuMetadataString"] = <intptr_t>__nvmlDeviceGetPgpuMetadataString global __nvmlDeviceGetVgpuSchedulerLog - data["__nvmlDeviceGetVgpuSchedulerLog"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuSchedulerLog + data["__nvmlDeviceGetVgpuSchedulerLog"] = <intptr_t>__nvmlDeviceGetVgpuSchedulerLog global __nvmlDeviceGetVgpuSchedulerState - data["__nvmlDeviceGetVgpuSchedulerState"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuSchedulerState + data["__nvmlDeviceGetVgpuSchedulerState"] = <intptr_t>__nvmlDeviceGetVgpuSchedulerState global __nvmlDeviceGetVgpuSchedulerCapabilities - data["__nvmlDeviceGetVgpuSchedulerCapabilities"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuSchedulerCapabilities + data["__nvmlDeviceGetVgpuSchedulerCapabilities"] = <intptr_t>__nvmlDeviceGetVgpuSchedulerCapabilities global __nvmlDeviceSetVgpuSchedulerState - data["__nvmlDeviceSetVgpuSchedulerState"] = <_cyb_intptr_t>__nvmlDeviceSetVgpuSchedulerState + data["__nvmlDeviceSetVgpuSchedulerState"] = <intptr_t>__nvmlDeviceSetVgpuSchedulerState global __nvmlGetVgpuVersion - data["__nvmlGetVgpuVersion"] = <_cyb_intptr_t>__nvmlGetVgpuVersion + data["__nvmlGetVgpuVersion"] = <intptr_t>__nvmlGetVgpuVersion global __nvmlSetVgpuVersion - data["__nvmlSetVgpuVersion"] = <_cyb_intptr_t>__nvmlSetVgpuVersion + data["__nvmlSetVgpuVersion"] = <intptr_t>__nvmlSetVgpuVersion global __nvmlDeviceGetVgpuUtilization - data["__nvmlDeviceGetVgpuUtilization"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuUtilization + data["__nvmlDeviceGetVgpuUtilization"] = <intptr_t>__nvmlDeviceGetVgpuUtilization global __nvmlDeviceGetVgpuInstancesUtilizationInfo - data["__nvmlDeviceGetVgpuInstancesUtilizationInfo"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuInstancesUtilizationInfo + data["__nvmlDeviceGetVgpuInstancesUtilizationInfo"] = <intptr_t>__nvmlDeviceGetVgpuInstancesUtilizationInfo global __nvmlDeviceGetVgpuProcessUtilization - data["__nvmlDeviceGetVgpuProcessUtilization"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuProcessUtilization + data["__nvmlDeviceGetVgpuProcessUtilization"] = <intptr_t>__nvmlDeviceGetVgpuProcessUtilization global __nvmlDeviceGetVgpuProcessesUtilizationInfo - data["__nvmlDeviceGetVgpuProcessesUtilizationInfo"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuProcessesUtilizationInfo + data["__nvmlDeviceGetVgpuProcessesUtilizationInfo"] = <intptr_t>__nvmlDeviceGetVgpuProcessesUtilizationInfo global __nvmlVgpuInstanceGetAccountingMode - data["__nvmlVgpuInstanceGetAccountingMode"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetAccountingMode + data["__nvmlVgpuInstanceGetAccountingMode"] = <intptr_t>__nvmlVgpuInstanceGetAccountingMode global __nvmlVgpuInstanceGetAccountingPids - data["__nvmlVgpuInstanceGetAccountingPids"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetAccountingPids + data["__nvmlVgpuInstanceGetAccountingPids"] = <intptr_t>__nvmlVgpuInstanceGetAccountingPids global __nvmlVgpuInstanceGetAccountingStats - data["__nvmlVgpuInstanceGetAccountingStats"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetAccountingStats + data["__nvmlVgpuInstanceGetAccountingStats"] = <intptr_t>__nvmlVgpuInstanceGetAccountingStats global __nvmlVgpuInstanceClearAccountingPids - data["__nvmlVgpuInstanceClearAccountingPids"] = <_cyb_intptr_t>__nvmlVgpuInstanceClearAccountingPids + data["__nvmlVgpuInstanceClearAccountingPids"] = <intptr_t>__nvmlVgpuInstanceClearAccountingPids global __nvmlVgpuInstanceGetLicenseInfo_v2 - data["__nvmlVgpuInstanceGetLicenseInfo_v2"] = <_cyb_intptr_t>__nvmlVgpuInstanceGetLicenseInfo_v2 + data["__nvmlVgpuInstanceGetLicenseInfo_v2"] = <intptr_t>__nvmlVgpuInstanceGetLicenseInfo_v2 global __nvmlGetExcludedDeviceCount - data["__nvmlGetExcludedDeviceCount"] = <_cyb_intptr_t>__nvmlGetExcludedDeviceCount + data["__nvmlGetExcludedDeviceCount"] = <intptr_t>__nvmlGetExcludedDeviceCount global __nvmlGetExcludedDeviceInfoByIndex - data["__nvmlGetExcludedDeviceInfoByIndex"] = <_cyb_intptr_t>__nvmlGetExcludedDeviceInfoByIndex + data["__nvmlGetExcludedDeviceInfoByIndex"] = <intptr_t>__nvmlGetExcludedDeviceInfoByIndex global __nvmlDeviceSetMigMode - data["__nvmlDeviceSetMigMode"] = <_cyb_intptr_t>__nvmlDeviceSetMigMode + data["__nvmlDeviceSetMigMode"] = <intptr_t>__nvmlDeviceSetMigMode global __nvmlDeviceGetMigMode - data["__nvmlDeviceGetMigMode"] = <_cyb_intptr_t>__nvmlDeviceGetMigMode + data["__nvmlDeviceGetMigMode"] = <intptr_t>__nvmlDeviceGetMigMode global __nvmlDeviceGetGpuInstanceProfileInfoV - data["__nvmlDeviceGetGpuInstanceProfileInfoV"] = <_cyb_intptr_t>__nvmlDeviceGetGpuInstanceProfileInfoV + data["__nvmlDeviceGetGpuInstanceProfileInfoV"] = <intptr_t>__nvmlDeviceGetGpuInstanceProfileInfoV global __nvmlDeviceGetGpuInstancePossiblePlacements_v2 - data["__nvmlDeviceGetGpuInstancePossiblePlacements_v2"] = <_cyb_intptr_t>__nvmlDeviceGetGpuInstancePossiblePlacements_v2 + data["__nvmlDeviceGetGpuInstancePossiblePlacements_v2"] = <intptr_t>__nvmlDeviceGetGpuInstancePossiblePlacements_v2 global __nvmlDeviceGetGpuInstanceRemainingCapacity - data["__nvmlDeviceGetGpuInstanceRemainingCapacity"] = <_cyb_intptr_t>__nvmlDeviceGetGpuInstanceRemainingCapacity + data["__nvmlDeviceGetGpuInstanceRemainingCapacity"] = <intptr_t>__nvmlDeviceGetGpuInstanceRemainingCapacity global __nvmlDeviceCreateGpuInstance - data["__nvmlDeviceCreateGpuInstance"] = <_cyb_intptr_t>__nvmlDeviceCreateGpuInstance + data["__nvmlDeviceCreateGpuInstance"] = <intptr_t>__nvmlDeviceCreateGpuInstance global __nvmlDeviceCreateGpuInstanceWithPlacement - data["__nvmlDeviceCreateGpuInstanceWithPlacement"] = <_cyb_intptr_t>__nvmlDeviceCreateGpuInstanceWithPlacement + data["__nvmlDeviceCreateGpuInstanceWithPlacement"] = <intptr_t>__nvmlDeviceCreateGpuInstanceWithPlacement global __nvmlGpuInstanceDestroy - data["__nvmlGpuInstanceDestroy"] = <_cyb_intptr_t>__nvmlGpuInstanceDestroy + data["__nvmlGpuInstanceDestroy"] = <intptr_t>__nvmlGpuInstanceDestroy global __nvmlDeviceGetGpuInstances - data["__nvmlDeviceGetGpuInstances"] = <_cyb_intptr_t>__nvmlDeviceGetGpuInstances + data["__nvmlDeviceGetGpuInstances"] = <intptr_t>__nvmlDeviceGetGpuInstances global __nvmlDeviceGetGpuInstanceById - data["__nvmlDeviceGetGpuInstanceById"] = <_cyb_intptr_t>__nvmlDeviceGetGpuInstanceById + data["__nvmlDeviceGetGpuInstanceById"] = <intptr_t>__nvmlDeviceGetGpuInstanceById global __nvmlGpuInstanceGetInfo - data["__nvmlGpuInstanceGetInfo"] = <_cyb_intptr_t>__nvmlGpuInstanceGetInfo + data["__nvmlGpuInstanceGetInfo"] = <intptr_t>__nvmlGpuInstanceGetInfo global __nvmlGpuInstanceGetComputeInstanceProfileInfoV - data["__nvmlGpuInstanceGetComputeInstanceProfileInfoV"] = <_cyb_intptr_t>__nvmlGpuInstanceGetComputeInstanceProfileInfoV + data["__nvmlGpuInstanceGetComputeInstanceProfileInfoV"] = <intptr_t>__nvmlGpuInstanceGetComputeInstanceProfileInfoV global __nvmlGpuInstanceGetComputeInstanceRemainingCapacity - data["__nvmlGpuInstanceGetComputeInstanceRemainingCapacity"] = <_cyb_intptr_t>__nvmlGpuInstanceGetComputeInstanceRemainingCapacity + data["__nvmlGpuInstanceGetComputeInstanceRemainingCapacity"] = <intptr_t>__nvmlGpuInstanceGetComputeInstanceRemainingCapacity global __nvmlGpuInstanceGetComputeInstancePossiblePlacements - data["__nvmlGpuInstanceGetComputeInstancePossiblePlacements"] = <_cyb_intptr_t>__nvmlGpuInstanceGetComputeInstancePossiblePlacements + data["__nvmlGpuInstanceGetComputeInstancePossiblePlacements"] = <intptr_t>__nvmlGpuInstanceGetComputeInstancePossiblePlacements global __nvmlGpuInstanceCreateComputeInstance - data["__nvmlGpuInstanceCreateComputeInstance"] = <_cyb_intptr_t>__nvmlGpuInstanceCreateComputeInstance + data["__nvmlGpuInstanceCreateComputeInstance"] = <intptr_t>__nvmlGpuInstanceCreateComputeInstance global __nvmlGpuInstanceCreateComputeInstanceWithPlacement - data["__nvmlGpuInstanceCreateComputeInstanceWithPlacement"] = <_cyb_intptr_t>__nvmlGpuInstanceCreateComputeInstanceWithPlacement + data["__nvmlGpuInstanceCreateComputeInstanceWithPlacement"] = <intptr_t>__nvmlGpuInstanceCreateComputeInstanceWithPlacement global __nvmlComputeInstanceDestroy - data["__nvmlComputeInstanceDestroy"] = <_cyb_intptr_t>__nvmlComputeInstanceDestroy + data["__nvmlComputeInstanceDestroy"] = <intptr_t>__nvmlComputeInstanceDestroy global __nvmlGpuInstanceGetComputeInstances - data["__nvmlGpuInstanceGetComputeInstances"] = <_cyb_intptr_t>__nvmlGpuInstanceGetComputeInstances + data["__nvmlGpuInstanceGetComputeInstances"] = <intptr_t>__nvmlGpuInstanceGetComputeInstances global __nvmlGpuInstanceGetComputeInstanceById - data["__nvmlGpuInstanceGetComputeInstanceById"] = <_cyb_intptr_t>__nvmlGpuInstanceGetComputeInstanceById + data["__nvmlGpuInstanceGetComputeInstanceById"] = <intptr_t>__nvmlGpuInstanceGetComputeInstanceById global __nvmlComputeInstanceGetInfo_v2 - data["__nvmlComputeInstanceGetInfo_v2"] = <_cyb_intptr_t>__nvmlComputeInstanceGetInfo_v2 + data["__nvmlComputeInstanceGetInfo_v2"] = <intptr_t>__nvmlComputeInstanceGetInfo_v2 global __nvmlDeviceIsMigDeviceHandle - data["__nvmlDeviceIsMigDeviceHandle"] = <_cyb_intptr_t>__nvmlDeviceIsMigDeviceHandle + data["__nvmlDeviceIsMigDeviceHandle"] = <intptr_t>__nvmlDeviceIsMigDeviceHandle global __nvmlDeviceGetGpuInstanceId - data["__nvmlDeviceGetGpuInstanceId"] = <_cyb_intptr_t>__nvmlDeviceGetGpuInstanceId + data["__nvmlDeviceGetGpuInstanceId"] = <intptr_t>__nvmlDeviceGetGpuInstanceId global __nvmlDeviceGetComputeInstanceId - data["__nvmlDeviceGetComputeInstanceId"] = <_cyb_intptr_t>__nvmlDeviceGetComputeInstanceId + data["__nvmlDeviceGetComputeInstanceId"] = <intptr_t>__nvmlDeviceGetComputeInstanceId global __nvmlDeviceGetMaxMigDeviceCount - data["__nvmlDeviceGetMaxMigDeviceCount"] = <_cyb_intptr_t>__nvmlDeviceGetMaxMigDeviceCount + data["__nvmlDeviceGetMaxMigDeviceCount"] = <intptr_t>__nvmlDeviceGetMaxMigDeviceCount global __nvmlDeviceGetMigDeviceHandleByIndex - data["__nvmlDeviceGetMigDeviceHandleByIndex"] = <_cyb_intptr_t>__nvmlDeviceGetMigDeviceHandleByIndex + data["__nvmlDeviceGetMigDeviceHandleByIndex"] = <intptr_t>__nvmlDeviceGetMigDeviceHandleByIndex global __nvmlDeviceGetDeviceHandleFromMigDeviceHandle - data["__nvmlDeviceGetDeviceHandleFromMigDeviceHandle"] = <_cyb_intptr_t>__nvmlDeviceGetDeviceHandleFromMigDeviceHandle + data["__nvmlDeviceGetDeviceHandleFromMigDeviceHandle"] = <intptr_t>__nvmlDeviceGetDeviceHandleFromMigDeviceHandle global __nvmlDeviceGetCapabilities - data["__nvmlDeviceGetCapabilities"] = <_cyb_intptr_t>__nvmlDeviceGetCapabilities + data["__nvmlDeviceGetCapabilities"] = <intptr_t>__nvmlDeviceGetCapabilities global __nvmlDevicePowerSmoothingActivatePresetProfile - data["__nvmlDevicePowerSmoothingActivatePresetProfile"] = <_cyb_intptr_t>__nvmlDevicePowerSmoothingActivatePresetProfile + data["__nvmlDevicePowerSmoothingActivatePresetProfile"] = <intptr_t>__nvmlDevicePowerSmoothingActivatePresetProfile global __nvmlDevicePowerSmoothingUpdatePresetProfileParam - data["__nvmlDevicePowerSmoothingUpdatePresetProfileParam"] = <_cyb_intptr_t>__nvmlDevicePowerSmoothingUpdatePresetProfileParam + data["__nvmlDevicePowerSmoothingUpdatePresetProfileParam"] = <intptr_t>__nvmlDevicePowerSmoothingUpdatePresetProfileParam global __nvmlDevicePowerSmoothingSetState - data["__nvmlDevicePowerSmoothingSetState"] = <_cyb_intptr_t>__nvmlDevicePowerSmoothingSetState + data["__nvmlDevicePowerSmoothingSetState"] = <intptr_t>__nvmlDevicePowerSmoothingSetState global __nvmlDeviceGetAddressingMode - data["__nvmlDeviceGetAddressingMode"] = <_cyb_intptr_t>__nvmlDeviceGetAddressingMode + data["__nvmlDeviceGetAddressingMode"] = <intptr_t>__nvmlDeviceGetAddressingMode global __nvmlDeviceGetRepairStatus - data["__nvmlDeviceGetRepairStatus"] = <_cyb_intptr_t>__nvmlDeviceGetRepairStatus + data["__nvmlDeviceGetRepairStatus"] = <intptr_t>__nvmlDeviceGetRepairStatus global __nvmlDeviceGetPowerMizerMode_v1 - data["__nvmlDeviceGetPowerMizerMode_v1"] = <_cyb_intptr_t>__nvmlDeviceGetPowerMizerMode_v1 + data["__nvmlDeviceGetPowerMizerMode_v1"] = <intptr_t>__nvmlDeviceGetPowerMizerMode_v1 global __nvmlDeviceSetPowerMizerMode_v1 - data["__nvmlDeviceSetPowerMizerMode_v1"] = <_cyb_intptr_t>__nvmlDeviceSetPowerMizerMode_v1 + data["__nvmlDeviceSetPowerMizerMode_v1"] = <intptr_t>__nvmlDeviceSetPowerMizerMode_v1 global __nvmlDeviceGetPdi - data["__nvmlDeviceGetPdi"] = <_cyb_intptr_t>__nvmlDeviceGetPdi + data["__nvmlDeviceGetPdi"] = <intptr_t>__nvmlDeviceGetPdi global __nvmlDeviceSetHostname_v1 - data["__nvmlDeviceSetHostname_v1"] = <_cyb_intptr_t>__nvmlDeviceSetHostname_v1 + data["__nvmlDeviceSetHostname_v1"] = <intptr_t>__nvmlDeviceSetHostname_v1 global __nvmlDeviceGetHostname_v1 - data["__nvmlDeviceGetHostname_v1"] = <_cyb_intptr_t>__nvmlDeviceGetHostname_v1 + data["__nvmlDeviceGetHostname_v1"] = <intptr_t>__nvmlDeviceGetHostname_v1 global __nvmlDeviceGetNvLinkInfo - data["__nvmlDeviceGetNvLinkInfo"] = <_cyb_intptr_t>__nvmlDeviceGetNvLinkInfo + data["__nvmlDeviceGetNvLinkInfo"] = <intptr_t>__nvmlDeviceGetNvLinkInfo global __nvmlDeviceReadWritePRM_v1 - data["__nvmlDeviceReadWritePRM_v1"] = <_cyb_intptr_t>__nvmlDeviceReadWritePRM_v1 + data["__nvmlDeviceReadWritePRM_v1"] = <intptr_t>__nvmlDeviceReadWritePRM_v1 global __nvmlDeviceGetGpuInstanceProfileInfoByIdV - data["__nvmlDeviceGetGpuInstanceProfileInfoByIdV"] = <_cyb_intptr_t>__nvmlDeviceGetGpuInstanceProfileInfoByIdV + data["__nvmlDeviceGetGpuInstanceProfileInfoByIdV"] = <intptr_t>__nvmlDeviceGetGpuInstanceProfileInfoByIdV global __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts - data["__nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts"] = <_cyb_intptr_t>__nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts + data["__nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts"] = <intptr_t>__nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts global __nvmlDeviceGetUnrepairableMemoryFlag_v1 - data["__nvmlDeviceGetUnrepairableMemoryFlag_v1"] = <_cyb_intptr_t>__nvmlDeviceGetUnrepairableMemoryFlag_v1 + data["__nvmlDeviceGetUnrepairableMemoryFlag_v1"] = <intptr_t>__nvmlDeviceGetUnrepairableMemoryFlag_v1 global __nvmlDeviceReadPRMCounters_v1 - data["__nvmlDeviceReadPRMCounters_v1"] = <_cyb_intptr_t>__nvmlDeviceReadPRMCounters_v1 + data["__nvmlDeviceReadPRMCounters_v1"] = <intptr_t>__nvmlDeviceReadPRMCounters_v1 global __nvmlDeviceSetRusdSettings_v1 - data["__nvmlDeviceSetRusdSettings_v1"] = <_cyb_intptr_t>__nvmlDeviceSetRusdSettings_v1 + data["__nvmlDeviceSetRusdSettings_v1"] = <intptr_t>__nvmlDeviceSetRusdSettings_v1 global __nvmlDeviceVgpuForceGspUnload - data["__nvmlDeviceVgpuForceGspUnload"] = <_cyb_intptr_t>__nvmlDeviceVgpuForceGspUnload + data["__nvmlDeviceVgpuForceGspUnload"] = <intptr_t>__nvmlDeviceVgpuForceGspUnload global __nvmlDeviceGetVgpuSchedulerState_v2 - data["__nvmlDeviceGetVgpuSchedulerState_v2"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuSchedulerState_v2 + data["__nvmlDeviceGetVgpuSchedulerState_v2"] = <intptr_t>__nvmlDeviceGetVgpuSchedulerState_v2 global __nvmlGpuInstanceGetVgpuSchedulerState_v2 - data["__nvmlGpuInstanceGetVgpuSchedulerState_v2"] = <_cyb_intptr_t>__nvmlGpuInstanceGetVgpuSchedulerState_v2 + data["__nvmlGpuInstanceGetVgpuSchedulerState_v2"] = <intptr_t>__nvmlGpuInstanceGetVgpuSchedulerState_v2 global __nvmlDeviceGetVgpuSchedulerLog_v2 - data["__nvmlDeviceGetVgpuSchedulerLog_v2"] = <_cyb_intptr_t>__nvmlDeviceGetVgpuSchedulerLog_v2 + data["__nvmlDeviceGetVgpuSchedulerLog_v2"] = <intptr_t>__nvmlDeviceGetVgpuSchedulerLog_v2 global __nvmlGpuInstanceGetVgpuSchedulerLog_v2 - data["__nvmlGpuInstanceGetVgpuSchedulerLog_v2"] = <_cyb_intptr_t>__nvmlGpuInstanceGetVgpuSchedulerLog_v2 + data["__nvmlGpuInstanceGetVgpuSchedulerLog_v2"] = <intptr_t>__nvmlGpuInstanceGetVgpuSchedulerLog_v2 global __nvmlDeviceSetVgpuSchedulerState_v2 - data["__nvmlDeviceSetVgpuSchedulerState_v2"] = <_cyb_intptr_t>__nvmlDeviceSetVgpuSchedulerState_v2 + data["__nvmlDeviceSetVgpuSchedulerState_v2"] = <intptr_t>__nvmlDeviceSetVgpuSchedulerState_v2 global __nvmlGpuInstanceSetVgpuSchedulerState_v2 - data["__nvmlGpuInstanceSetVgpuSchedulerState_v2"] = <_cyb_intptr_t>__nvmlGpuInstanceSetVgpuSchedulerState_v2 + data["__nvmlGpuInstanceSetVgpuSchedulerState_v2"] = <intptr_t>__nvmlGpuInstanceSetVgpuSchedulerState_v2 global __nvmlSystemGetCPER_v1 - data["__nvmlSystemGetCPER_v1"] = <_cyb_intptr_t>__nvmlSystemGetCPER_v1 + data["__nvmlSystemGetCPER_v1"] = <intptr_t>__nvmlSystemGetCPER_v1 global __nvmlDeviceGetBBXTimeData_v1 - data["__nvmlDeviceGetBBXTimeData_v1"] = <_cyb_intptr_t>__nvmlDeviceGetBBXTimeData_v1 + data["__nvmlDeviceGetBBXTimeData_v1"] = <intptr_t>__nvmlDeviceGetBBXTimeData_v1 global __nvmlDeviceGetAccountingStats_v2 - data["__nvmlDeviceGetAccountingStats_v2"] = <_cyb_intptr_t>__nvmlDeviceGetAccountingStats_v2 + data["__nvmlDeviceGetAccountingStats_v2"] = <intptr_t>__nvmlDeviceGetAccountingStats_v2 global __nvmlDeviceGetRemappedRows_v2 - data["__nvmlDeviceGetRemappedRows_v2"] = <_cyb_intptr_t>__nvmlDeviceGetRemappedRows_v2 + data["__nvmlDeviceGetRemappedRows_v2"] = <intptr_t>__nvmlDeviceGetRemappedRows_v2 global __nvmlDeviceSetAdaptiveTgpMode_v1 - data["__nvmlDeviceSetAdaptiveTgpMode_v1"] = <_cyb_intptr_t>__nvmlDeviceSetAdaptiveTgpMode_v1 + data["__nvmlDeviceSetAdaptiveTgpMode_v1"] = <intptr_t>__nvmlDeviceSetAdaptiveTgpMode_v1 global __nvmlDeviceGetAdaptiveTgpModeInfo_v1 - data["__nvmlDeviceGetAdaptiveTgpModeInfo_v1"] = <_cyb_intptr_t>__nvmlDeviceGetAdaptiveTgpModeInfo_v1 + data["__nvmlDeviceGetAdaptiveTgpModeInfo_v1"] = <intptr_t>__nvmlDeviceGetAdaptiveTgpModeInfo_v1 global __nvmlDeviceSetMemoryLimits_v1 - data["__nvmlDeviceSetMemoryLimits_v1"] = <_cyb_intptr_t>__nvmlDeviceSetMemoryLimits_v1 + data["__nvmlDeviceSetMemoryLimits_v1"] = <intptr_t>__nvmlDeviceSetMemoryLimits_v1 global __nvmlDeviceGetMemoryLimits_v1 - data["__nvmlDeviceGetMemoryLimits_v1"] = <_cyb_intptr_t>__nvmlDeviceGetMemoryLimits_v1 + data["__nvmlDeviceGetMemoryLimits_v1"] = <intptr_t>__nvmlDeviceGetMemoryLimits_v1 global __nvmlDeviceGetGpuFabricInfo_v4 - data["__nvmlDeviceGetGpuFabricInfo_v4"] = <_cyb_intptr_t>__nvmlDeviceGetGpuFabricInfo_v4 + data["__nvmlDeviceGetGpuFabricInfo_v4"] = <intptr_t>__nvmlDeviceGetGpuFabricInfo_v4 global __nvmlDevicePerfMetricsGetSamples_v1 - data["__nvmlDevicePerfMetricsGetSamples_v1"] = <_cyb_intptr_t>__nvmlDevicePerfMetricsGetSamples_v1 + data["__nvmlDevicePerfMetricsGetSamples_v1"] = <intptr_t>__nvmlDevicePerfMetricsGetSamples_v1 global __nvmlDeviceSetNvlinkBwModeAsync_v1 - data["__nvmlDeviceSetNvlinkBwModeAsync_v1"] = <_cyb_intptr_t>__nvmlDeviceSetNvlinkBwModeAsync_v1 + data["__nvmlDeviceSetNvlinkBwModeAsync_v1"] = <intptr_t>__nvmlDeviceSetNvlinkBwModeAsync_v1 global __nvmlDeviceGetNvLinkTelemetrySamples_v1 - data["__nvmlDeviceGetNvLinkTelemetrySamples_v1"] = <_cyb_intptr_t>__nvmlDeviceGetNvLinkTelemetrySamples_v1 + data["__nvmlDeviceGetNvLinkTelemetrySamples_v1"] = <intptr_t>__nvmlDeviceGetNvLinkTelemetrySamples_v1 global __nvmlEventSetRegisterGpuOperationalEvents_v1 - data["__nvmlEventSetRegisterGpuOperationalEvents_v1"] = <_cyb_intptr_t>__nvmlEventSetRegisterGpuOperationalEvents_v1 + data["__nvmlEventSetRegisterGpuOperationalEvents_v1"] = <intptr_t>__nvmlEventSetRegisterGpuOperationalEvents_v1 global __nvmlEventSetWait_v3 - data["__nvmlEventSetWait_v3"] = <_cyb_intptr_t>__nvmlEventSetWait_v3 + data["__nvmlEventSetWait_v3"] = <intptr_t>__nvmlEventSetWait_v3 global __nvmlEventSetGetContextCount_v1 - data["__nvmlEventSetGetContextCount_v1"] = <_cyb_intptr_t>__nvmlEventSetGetContextCount_v1 + data["__nvmlEventSetGetContextCount_v1"] = <intptr_t>__nvmlEventSetGetContextCount_v1 global __nvmlEventSetGetContextInfo_v1 - data["__nvmlEventSetGetContextInfo_v1"] = <_cyb_intptr_t>__nvmlEventSetGetContextInfo_v1 + data["__nvmlEventSetGetContextInfo_v1"] = <intptr_t>__nvmlEventSetGetContextInfo_v1 global __nvmlEventSetGetContextData_v1 - data["__nvmlEventSetGetContextData_v1"] = <_cyb_intptr_t>__nvmlEventSetGetContextData_v1 + data["__nvmlEventSetGetContextData_v1"] = <intptr_t>__nvmlEventSetGetContextData_v1 global __nvmlEventSetGetGpuOperationalEventContextLegacyXid_v1 - data["__nvmlEventSetGetGpuOperationalEventContextLegacyXid_v1"] = <_cyb_intptr_t>__nvmlEventSetGetGpuOperationalEventContextLegacyXid_v1 + data["__nvmlEventSetGetGpuOperationalEventContextLegacyXid_v1"] = <intptr_t>__nvmlEventSetGetGpuOperationalEventContextLegacyXid_v1 global __nvmlDeviceGetBankRemapperStatus_v1 - data["__nvmlDeviceGetBankRemapperStatus_v1"] = <_cyb_intptr_t>__nvmlDeviceGetBankRemapperStatus_v1 + data["__nvmlDeviceGetBankRemapperStatus_v1"] = <intptr_t>__nvmlDeviceGetBankRemapperStatus_v1 _cyb_func_ptrs = data return data diff --git a/cuda_bindings/cuda/bindings/_internal/nvrtc_linux.pyx b/cuda_bindings/cuda/bindings/_internal/nvrtc_linux.pyx index 06a6277d829..a946c5f7436 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvrtc_linux.pyx +++ b/cuda_bindings/cuda/bindings/_internal/nvrtc_linux.pyx @@ -4,7 +4,7 @@ # # This code was automatically generated across versions from 12.9.0 to 13.4.0. Do not modify it directly. # !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=3d6013b99cb59aaab8ae661d838401b123ed27efda53268eab153c7add7ca3a8 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=ff8ab1d01d04a6bc7ea43685ddbd6512479385981974c6a7e08bacbb0e651602 # <<<< PREAMBLE CONTENT >>>> @@ -45,7 +45,7 @@ cdef extern from "<dlfcn.h>": void* _cyb_dlsym "dlsym"(void*, const char*) nogil const void * _cyb_RTLD_DEFAULT "RTLD_DEFAULT" -from libc.stdint cimport intptr_t as _cyb_intptr_t +from libc.stdint cimport intptr_t import threading as _cyb_threading @@ -322,91 +322,91 @@ cpdef dict _inspect_function_pointers(): _check_or_init_nvrtc() cdef dict data = {} global __nvrtcGetErrorString - data["__nvrtcGetErrorString"] = <_cyb_intptr_t>__nvrtcGetErrorString + data["__nvrtcGetErrorString"] = <intptr_t>__nvrtcGetErrorString global __nvrtcVersion - data["__nvrtcVersion"] = <_cyb_intptr_t>__nvrtcVersion + data["__nvrtcVersion"] = <intptr_t>__nvrtcVersion global __nvrtcGetNumSupportedArchs - data["__nvrtcGetNumSupportedArchs"] = <_cyb_intptr_t>__nvrtcGetNumSupportedArchs + data["__nvrtcGetNumSupportedArchs"] = <intptr_t>__nvrtcGetNumSupportedArchs global __nvrtcGetSupportedArchs - data["__nvrtcGetSupportedArchs"] = <_cyb_intptr_t>__nvrtcGetSupportedArchs + data["__nvrtcGetSupportedArchs"] = <intptr_t>__nvrtcGetSupportedArchs global __nvrtcCreateProgram - data["__nvrtcCreateProgram"] = <_cyb_intptr_t>__nvrtcCreateProgram + data["__nvrtcCreateProgram"] = <intptr_t>__nvrtcCreateProgram global __nvrtcDestroyProgram - data["__nvrtcDestroyProgram"] = <_cyb_intptr_t>__nvrtcDestroyProgram + data["__nvrtcDestroyProgram"] = <intptr_t>__nvrtcDestroyProgram global __nvrtcCompileProgram - data["__nvrtcCompileProgram"] = <_cyb_intptr_t>__nvrtcCompileProgram + data["__nvrtcCompileProgram"] = <intptr_t>__nvrtcCompileProgram global __nvrtcGetPTXSize - data["__nvrtcGetPTXSize"] = <_cyb_intptr_t>__nvrtcGetPTXSize + data["__nvrtcGetPTXSize"] = <intptr_t>__nvrtcGetPTXSize global __nvrtcGetPTX - data["__nvrtcGetPTX"] = <_cyb_intptr_t>__nvrtcGetPTX + data["__nvrtcGetPTX"] = <intptr_t>__nvrtcGetPTX global __nvrtcGetCUBINSize - data["__nvrtcGetCUBINSize"] = <_cyb_intptr_t>__nvrtcGetCUBINSize + data["__nvrtcGetCUBINSize"] = <intptr_t>__nvrtcGetCUBINSize global __nvrtcGetCUBIN - data["__nvrtcGetCUBIN"] = <_cyb_intptr_t>__nvrtcGetCUBIN + data["__nvrtcGetCUBIN"] = <intptr_t>__nvrtcGetCUBIN global __nvrtcGetLTOIRSize - data["__nvrtcGetLTOIRSize"] = <_cyb_intptr_t>__nvrtcGetLTOIRSize + data["__nvrtcGetLTOIRSize"] = <intptr_t>__nvrtcGetLTOIRSize global __nvrtcGetLTOIR - data["__nvrtcGetLTOIR"] = <_cyb_intptr_t>__nvrtcGetLTOIR + data["__nvrtcGetLTOIR"] = <intptr_t>__nvrtcGetLTOIR global __nvrtcGetOptiXIRSize - data["__nvrtcGetOptiXIRSize"] = <_cyb_intptr_t>__nvrtcGetOptiXIRSize + data["__nvrtcGetOptiXIRSize"] = <intptr_t>__nvrtcGetOptiXIRSize global __nvrtcGetOptiXIR - data["__nvrtcGetOptiXIR"] = <_cyb_intptr_t>__nvrtcGetOptiXIR + data["__nvrtcGetOptiXIR"] = <intptr_t>__nvrtcGetOptiXIR global __nvrtcGetProgramLogSize - data["__nvrtcGetProgramLogSize"] = <_cyb_intptr_t>__nvrtcGetProgramLogSize + data["__nvrtcGetProgramLogSize"] = <intptr_t>__nvrtcGetProgramLogSize global __nvrtcGetProgramLog - data["__nvrtcGetProgramLog"] = <_cyb_intptr_t>__nvrtcGetProgramLog + data["__nvrtcGetProgramLog"] = <intptr_t>__nvrtcGetProgramLog global __nvrtcAddNameExpression - data["__nvrtcAddNameExpression"] = <_cyb_intptr_t>__nvrtcAddNameExpression + data["__nvrtcAddNameExpression"] = <intptr_t>__nvrtcAddNameExpression global __nvrtcGetLoweredName - data["__nvrtcGetLoweredName"] = <_cyb_intptr_t>__nvrtcGetLoweredName + data["__nvrtcGetLoweredName"] = <intptr_t>__nvrtcGetLoweredName global __nvrtcGetPCHHeapSize - data["__nvrtcGetPCHHeapSize"] = <_cyb_intptr_t>__nvrtcGetPCHHeapSize + data["__nvrtcGetPCHHeapSize"] = <intptr_t>__nvrtcGetPCHHeapSize global __nvrtcSetPCHHeapSize - data["__nvrtcSetPCHHeapSize"] = <_cyb_intptr_t>__nvrtcSetPCHHeapSize + data["__nvrtcSetPCHHeapSize"] = <intptr_t>__nvrtcSetPCHHeapSize global __nvrtcGetPCHCreateStatus - data["__nvrtcGetPCHCreateStatus"] = <_cyb_intptr_t>__nvrtcGetPCHCreateStatus + data["__nvrtcGetPCHCreateStatus"] = <intptr_t>__nvrtcGetPCHCreateStatus global __nvrtcGetPCHHeapSizeRequired - data["__nvrtcGetPCHHeapSizeRequired"] = <_cyb_intptr_t>__nvrtcGetPCHHeapSizeRequired + data["__nvrtcGetPCHHeapSizeRequired"] = <intptr_t>__nvrtcGetPCHHeapSizeRequired global __nvrtcSetFlowCallback - data["__nvrtcSetFlowCallback"] = <_cyb_intptr_t>__nvrtcSetFlowCallback + data["__nvrtcSetFlowCallback"] = <intptr_t>__nvrtcSetFlowCallback global __nvrtcGetTileIRSize - data["__nvrtcGetTileIRSize"] = <_cyb_intptr_t>__nvrtcGetTileIRSize + data["__nvrtcGetTileIRSize"] = <intptr_t>__nvrtcGetTileIRSize global __nvrtcGetTileIR - data["__nvrtcGetTileIR"] = <_cyb_intptr_t>__nvrtcGetTileIR + data["__nvrtcGetTileIR"] = <intptr_t>__nvrtcGetTileIR global __nvrtcInstallBundledHeaders - data["__nvrtcInstallBundledHeaders"] = <_cyb_intptr_t>__nvrtcInstallBundledHeaders + data["__nvrtcInstallBundledHeaders"] = <intptr_t>__nvrtcInstallBundledHeaders global __nvrtcGetBundledHeadersInfo - data["__nvrtcGetBundledHeadersInfo"] = <_cyb_intptr_t>__nvrtcGetBundledHeadersInfo + data["__nvrtcGetBundledHeadersInfo"] = <intptr_t>__nvrtcGetBundledHeadersInfo global __nvrtcRemoveBundledHeaders - data["__nvrtcRemoveBundledHeaders"] = <_cyb_intptr_t>__nvrtcRemoveBundledHeaders + data["__nvrtcRemoveBundledHeaders"] = <intptr_t>__nvrtcRemoveBundledHeaders _cyb_func_ptrs = data return data diff --git a/cuda_bindings/cuda/bindings/_internal/nvrtc_windows.pyx b/cuda_bindings/cuda/bindings/_internal/nvrtc_windows.pyx index 752c659677f..5e343e3033e 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvrtc_windows.pyx +++ b/cuda_bindings/cuda/bindings/_internal/nvrtc_windows.pyx @@ -4,7 +4,7 @@ # # This code was automatically generated across versions from 12.9.0 to 13.4.0. Do not modify it directly. # !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=574a59b0c82321fb7c287f06c11dd873715e47bea253df57466f0cfc29d8f5de +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=7e09096317d97b6fa04099e31ae2ab90d762f42a7dbd13ce79fe865737b746e4 # <<<< PREAMBLE CONTENT >>>> @@ -45,7 +45,10 @@ cdef extern from "<windows.h>": ctypedef void* HMODULE void* _cyb_GetProcAddress "GetProcAddress"(HMODULE, const char*) nogil -from libc.stdint cimport intptr_t as _cyb_intptr_t +from libc.stdint cimport ( + intptr_t, + uintptr_t, +) import threading as _cyb_threading @@ -206,91 +209,91 @@ cpdef dict _inspect_function_pointers(): _check_or_init_nvrtc() cdef dict data = {} global __nvrtcGetErrorString - data["__nvrtcGetErrorString"] = <_cyb_intptr_t>__nvrtcGetErrorString + data["__nvrtcGetErrorString"] = <intptr_t>__nvrtcGetErrorString global __nvrtcVersion - data["__nvrtcVersion"] = <_cyb_intptr_t>__nvrtcVersion + data["__nvrtcVersion"] = <intptr_t>__nvrtcVersion global __nvrtcGetNumSupportedArchs - data["__nvrtcGetNumSupportedArchs"] = <_cyb_intptr_t>__nvrtcGetNumSupportedArchs + data["__nvrtcGetNumSupportedArchs"] = <intptr_t>__nvrtcGetNumSupportedArchs global __nvrtcGetSupportedArchs - data["__nvrtcGetSupportedArchs"] = <_cyb_intptr_t>__nvrtcGetSupportedArchs + data["__nvrtcGetSupportedArchs"] = <intptr_t>__nvrtcGetSupportedArchs global __nvrtcCreateProgram - data["__nvrtcCreateProgram"] = <_cyb_intptr_t>__nvrtcCreateProgram + data["__nvrtcCreateProgram"] = <intptr_t>__nvrtcCreateProgram global __nvrtcDestroyProgram - data["__nvrtcDestroyProgram"] = <_cyb_intptr_t>__nvrtcDestroyProgram + data["__nvrtcDestroyProgram"] = <intptr_t>__nvrtcDestroyProgram global __nvrtcCompileProgram - data["__nvrtcCompileProgram"] = <_cyb_intptr_t>__nvrtcCompileProgram + data["__nvrtcCompileProgram"] = <intptr_t>__nvrtcCompileProgram global __nvrtcGetPTXSize - data["__nvrtcGetPTXSize"] = <_cyb_intptr_t>__nvrtcGetPTXSize + data["__nvrtcGetPTXSize"] = <intptr_t>__nvrtcGetPTXSize global __nvrtcGetPTX - data["__nvrtcGetPTX"] = <_cyb_intptr_t>__nvrtcGetPTX + data["__nvrtcGetPTX"] = <intptr_t>__nvrtcGetPTX global __nvrtcGetCUBINSize - data["__nvrtcGetCUBINSize"] = <_cyb_intptr_t>__nvrtcGetCUBINSize + data["__nvrtcGetCUBINSize"] = <intptr_t>__nvrtcGetCUBINSize global __nvrtcGetCUBIN - data["__nvrtcGetCUBIN"] = <_cyb_intptr_t>__nvrtcGetCUBIN + data["__nvrtcGetCUBIN"] = <intptr_t>__nvrtcGetCUBIN global __nvrtcGetLTOIRSize - data["__nvrtcGetLTOIRSize"] = <_cyb_intptr_t>__nvrtcGetLTOIRSize + data["__nvrtcGetLTOIRSize"] = <intptr_t>__nvrtcGetLTOIRSize global __nvrtcGetLTOIR - data["__nvrtcGetLTOIR"] = <_cyb_intptr_t>__nvrtcGetLTOIR + data["__nvrtcGetLTOIR"] = <intptr_t>__nvrtcGetLTOIR global __nvrtcGetOptiXIRSize - data["__nvrtcGetOptiXIRSize"] = <_cyb_intptr_t>__nvrtcGetOptiXIRSize + data["__nvrtcGetOptiXIRSize"] = <intptr_t>__nvrtcGetOptiXIRSize global __nvrtcGetOptiXIR - data["__nvrtcGetOptiXIR"] = <_cyb_intptr_t>__nvrtcGetOptiXIR + data["__nvrtcGetOptiXIR"] = <intptr_t>__nvrtcGetOptiXIR global __nvrtcGetProgramLogSize - data["__nvrtcGetProgramLogSize"] = <_cyb_intptr_t>__nvrtcGetProgramLogSize + data["__nvrtcGetProgramLogSize"] = <intptr_t>__nvrtcGetProgramLogSize global __nvrtcGetProgramLog - data["__nvrtcGetProgramLog"] = <_cyb_intptr_t>__nvrtcGetProgramLog + data["__nvrtcGetProgramLog"] = <intptr_t>__nvrtcGetProgramLog global __nvrtcAddNameExpression - data["__nvrtcAddNameExpression"] = <_cyb_intptr_t>__nvrtcAddNameExpression + data["__nvrtcAddNameExpression"] = <intptr_t>__nvrtcAddNameExpression global __nvrtcGetLoweredName - data["__nvrtcGetLoweredName"] = <_cyb_intptr_t>__nvrtcGetLoweredName + data["__nvrtcGetLoweredName"] = <intptr_t>__nvrtcGetLoweredName global __nvrtcGetPCHHeapSize - data["__nvrtcGetPCHHeapSize"] = <_cyb_intptr_t>__nvrtcGetPCHHeapSize + data["__nvrtcGetPCHHeapSize"] = <intptr_t>__nvrtcGetPCHHeapSize global __nvrtcSetPCHHeapSize - data["__nvrtcSetPCHHeapSize"] = <_cyb_intptr_t>__nvrtcSetPCHHeapSize + data["__nvrtcSetPCHHeapSize"] = <intptr_t>__nvrtcSetPCHHeapSize global __nvrtcGetPCHCreateStatus - data["__nvrtcGetPCHCreateStatus"] = <_cyb_intptr_t>__nvrtcGetPCHCreateStatus + data["__nvrtcGetPCHCreateStatus"] = <intptr_t>__nvrtcGetPCHCreateStatus global __nvrtcGetPCHHeapSizeRequired - data["__nvrtcGetPCHHeapSizeRequired"] = <_cyb_intptr_t>__nvrtcGetPCHHeapSizeRequired + data["__nvrtcGetPCHHeapSizeRequired"] = <intptr_t>__nvrtcGetPCHHeapSizeRequired global __nvrtcSetFlowCallback - data["__nvrtcSetFlowCallback"] = <_cyb_intptr_t>__nvrtcSetFlowCallback + data["__nvrtcSetFlowCallback"] = <intptr_t>__nvrtcSetFlowCallback global __nvrtcGetTileIRSize - data["__nvrtcGetTileIRSize"] = <_cyb_intptr_t>__nvrtcGetTileIRSize + data["__nvrtcGetTileIRSize"] = <intptr_t>__nvrtcGetTileIRSize global __nvrtcGetTileIR - data["__nvrtcGetTileIR"] = <_cyb_intptr_t>__nvrtcGetTileIR + data["__nvrtcGetTileIR"] = <intptr_t>__nvrtcGetTileIR global __nvrtcInstallBundledHeaders - data["__nvrtcInstallBundledHeaders"] = <_cyb_intptr_t>__nvrtcInstallBundledHeaders + data["__nvrtcInstallBundledHeaders"] = <intptr_t>__nvrtcInstallBundledHeaders global __nvrtcGetBundledHeadersInfo - data["__nvrtcGetBundledHeadersInfo"] = <_cyb_intptr_t>__nvrtcGetBundledHeadersInfo + data["__nvrtcGetBundledHeadersInfo"] = <intptr_t>__nvrtcGetBundledHeadersInfo global __nvrtcRemoveBundledHeaders - data["__nvrtcRemoveBundledHeaders"] = <_cyb_intptr_t>__nvrtcRemoveBundledHeaders + data["__nvrtcRemoveBundledHeaders"] = <intptr_t>__nvrtcRemoveBundledHeaders _cyb_func_ptrs = data return data diff --git a/cuda_bindings/cuda/bindings/_internal/nvvm_linux.pyx b/cuda_bindings/cuda/bindings/_internal/nvvm_linux.pyx index 08f74faa61b..15295e29d0f 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvvm_linux.pyx +++ b/cuda_bindings/cuda/bindings/_internal/nvvm_linux.pyx @@ -4,7 +4,7 @@ # # This code was automatically generated across versions from 12.0.1 to 13.4.0. Do not modify it directly. # !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=b8fe65feec44ce979fc981ea49fefa1b8bdd487092159d597ba5b18b427cc74d +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=d15f388e4d48b2d20cd688b2dcc6494a9f62fcf39bf4498bfe868231b54ab79a # <<<< PREAMBLE CONTENT >>>> @@ -45,7 +45,7 @@ cdef extern from "<dlfcn.h>": void* _cyb_dlsym "dlsym"(void*, const char*) nogil const void * _cyb_RTLD_DEFAULT "RTLD_DEFAULT" -from libc.stdint cimport intptr_t as _cyb_intptr_t +from libc.stdint cimport intptr_t import threading as _cyb_threading @@ -202,46 +202,46 @@ cpdef dict _inspect_function_pointers(): _check_or_init_nvvm() cdef dict data = {} global __nvvmGetErrorString - data["__nvvmGetErrorString"] = <_cyb_intptr_t>__nvvmGetErrorString + data["__nvvmGetErrorString"] = <intptr_t>__nvvmGetErrorString global __nvvmVersion - data["__nvvmVersion"] = <_cyb_intptr_t>__nvvmVersion + data["__nvvmVersion"] = <intptr_t>__nvvmVersion global __nvvmIRVersion - data["__nvvmIRVersion"] = <_cyb_intptr_t>__nvvmIRVersion + data["__nvvmIRVersion"] = <intptr_t>__nvvmIRVersion global __nvvmCreateProgram - data["__nvvmCreateProgram"] = <_cyb_intptr_t>__nvvmCreateProgram + data["__nvvmCreateProgram"] = <intptr_t>__nvvmCreateProgram global __nvvmDestroyProgram - data["__nvvmDestroyProgram"] = <_cyb_intptr_t>__nvvmDestroyProgram + data["__nvvmDestroyProgram"] = <intptr_t>__nvvmDestroyProgram global __nvvmAddModuleToProgram - data["__nvvmAddModuleToProgram"] = <_cyb_intptr_t>__nvvmAddModuleToProgram + data["__nvvmAddModuleToProgram"] = <intptr_t>__nvvmAddModuleToProgram global __nvvmLazyAddModuleToProgram - data["__nvvmLazyAddModuleToProgram"] = <_cyb_intptr_t>__nvvmLazyAddModuleToProgram + data["__nvvmLazyAddModuleToProgram"] = <intptr_t>__nvvmLazyAddModuleToProgram global __nvvmCompileProgram - data["__nvvmCompileProgram"] = <_cyb_intptr_t>__nvvmCompileProgram + data["__nvvmCompileProgram"] = <intptr_t>__nvvmCompileProgram global __nvvmVerifyProgram - data["__nvvmVerifyProgram"] = <_cyb_intptr_t>__nvvmVerifyProgram + data["__nvvmVerifyProgram"] = <intptr_t>__nvvmVerifyProgram global __nvvmGetCompiledResultSize - data["__nvvmGetCompiledResultSize"] = <_cyb_intptr_t>__nvvmGetCompiledResultSize + data["__nvvmGetCompiledResultSize"] = <intptr_t>__nvvmGetCompiledResultSize global __nvvmGetCompiledResult - data["__nvvmGetCompiledResult"] = <_cyb_intptr_t>__nvvmGetCompiledResult + data["__nvvmGetCompiledResult"] = <intptr_t>__nvvmGetCompiledResult global __nvvmGetProgramLogSize - data["__nvvmGetProgramLogSize"] = <_cyb_intptr_t>__nvvmGetProgramLogSize + data["__nvvmGetProgramLogSize"] = <intptr_t>__nvvmGetProgramLogSize global __nvvmGetProgramLog - data["__nvvmGetProgramLog"] = <_cyb_intptr_t>__nvvmGetProgramLog + data["__nvvmGetProgramLog"] = <intptr_t>__nvvmGetProgramLog global __nvvmLLVMVersion - data["__nvvmLLVMVersion"] = <_cyb_intptr_t>__nvvmLLVMVersion + data["__nvvmLLVMVersion"] = <intptr_t>__nvvmLLVMVersion _cyb_func_ptrs = data return data diff --git a/cuda_bindings/cuda/bindings/_internal/nvvm_windows.pyx b/cuda_bindings/cuda/bindings/_internal/nvvm_windows.pyx index 2a6754f0450..76648d88c4d 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvvm_windows.pyx +++ b/cuda_bindings/cuda/bindings/_internal/nvvm_windows.pyx @@ -4,7 +4,7 @@ # # This code was automatically generated across versions from 12.0.1 to 13.4.0. Do not modify it directly. # !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=1a8d9ee78bc417c85345caf1dd580ac660ab437cd874a89d6924786f4ad7aade +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=c34f226d941a77ab78685766f1df3af41e44e3c34580ac476391e2918ee2a15b # <<<< PREAMBLE CONTENT >>>> @@ -45,7 +45,10 @@ cdef extern from "<windows.h>": ctypedef void* HMODULE void* _cyb_GetProcAddress "GetProcAddress"(HMODULE, const char*) nogil -from libc.stdint cimport intptr_t as _cyb_intptr_t +from libc.stdint cimport ( + intptr_t, + uintptr_t, +) import threading as _cyb_threading @@ -146,46 +149,46 @@ cpdef dict _inspect_function_pointers(): _check_or_init_nvvm() cdef dict data = {} global __nvvmGetErrorString - data["__nvvmGetErrorString"] = <_cyb_intptr_t>__nvvmGetErrorString + data["__nvvmGetErrorString"] = <intptr_t>__nvvmGetErrorString global __nvvmVersion - data["__nvvmVersion"] = <_cyb_intptr_t>__nvvmVersion + data["__nvvmVersion"] = <intptr_t>__nvvmVersion global __nvvmIRVersion - data["__nvvmIRVersion"] = <_cyb_intptr_t>__nvvmIRVersion + data["__nvvmIRVersion"] = <intptr_t>__nvvmIRVersion global __nvvmCreateProgram - data["__nvvmCreateProgram"] = <_cyb_intptr_t>__nvvmCreateProgram + data["__nvvmCreateProgram"] = <intptr_t>__nvvmCreateProgram global __nvvmDestroyProgram - data["__nvvmDestroyProgram"] = <_cyb_intptr_t>__nvvmDestroyProgram + data["__nvvmDestroyProgram"] = <intptr_t>__nvvmDestroyProgram global __nvvmAddModuleToProgram - data["__nvvmAddModuleToProgram"] = <_cyb_intptr_t>__nvvmAddModuleToProgram + data["__nvvmAddModuleToProgram"] = <intptr_t>__nvvmAddModuleToProgram global __nvvmLazyAddModuleToProgram - data["__nvvmLazyAddModuleToProgram"] = <_cyb_intptr_t>__nvvmLazyAddModuleToProgram + data["__nvvmLazyAddModuleToProgram"] = <intptr_t>__nvvmLazyAddModuleToProgram global __nvvmCompileProgram - data["__nvvmCompileProgram"] = <_cyb_intptr_t>__nvvmCompileProgram + data["__nvvmCompileProgram"] = <intptr_t>__nvvmCompileProgram global __nvvmVerifyProgram - data["__nvvmVerifyProgram"] = <_cyb_intptr_t>__nvvmVerifyProgram + data["__nvvmVerifyProgram"] = <intptr_t>__nvvmVerifyProgram global __nvvmGetCompiledResultSize - data["__nvvmGetCompiledResultSize"] = <_cyb_intptr_t>__nvvmGetCompiledResultSize + data["__nvvmGetCompiledResultSize"] = <intptr_t>__nvvmGetCompiledResultSize global __nvvmGetCompiledResult - data["__nvvmGetCompiledResult"] = <_cyb_intptr_t>__nvvmGetCompiledResult + data["__nvvmGetCompiledResult"] = <intptr_t>__nvvmGetCompiledResult global __nvvmGetProgramLogSize - data["__nvvmGetProgramLogSize"] = <_cyb_intptr_t>__nvvmGetProgramLogSize + data["__nvvmGetProgramLogSize"] = <intptr_t>__nvvmGetProgramLogSize global __nvvmGetProgramLog - data["__nvvmGetProgramLog"] = <_cyb_intptr_t>__nvvmGetProgramLog + data["__nvvmGetProgramLog"] = <intptr_t>__nvvmGetProgramLog global __nvvmLLVMVersion - data["__nvvmLLVMVersion"] = <_cyb_intptr_t>__nvvmLLVMVersion + data["__nvvmLLVMVersion"] = <intptr_t>__nvvmLLVMVersion _cyb_func_ptrs = data return data diff --git a/cuda_bindings/cuda/bindings/_lib/windll.pxd b/cuda_bindings/cuda/bindings/_lib/windll.pxd index 294a1a9fd90..b5fd5c4db90 100644 --- a/cuda_bindings/cuda/bindings/_lib/windll.pxd +++ b/cuda_bindings/cuda/bindings/_lib/windll.pxd @@ -14,7 +14,7 @@ cdef extern from "windows.h" nogil: ctypedef const char *LPCSTR ctypedef int BOOL - cdef DWORD LOAD_LIBRARY_SEARCH_SYSTEM32 = 0x00000800 + const DWORD LOAD_LIBRARY_SEARCH_SYSTEM32 HMODULE _LoadLibraryExW "LoadLibraryExW"( LPCWSTR lpLibFileName, diff --git a/cuda_bindings/cuda/bindings/_v2/nvrtc.pxd b/cuda_bindings/cuda/bindings/_v2/nvrtc.pxd index 3e8aa8a3675..8e49c44a782 100644 --- a/cuda_bindings/cuda/bindings/_v2/nvrtc.pxd +++ b/cuda_bindings/cuda/bindings/_v2/nvrtc.pxd @@ -3,9 +3,17 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.9.0 to 13.4.0. Do not modify it directly. - # !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=632bbedaee3acec49d09764a74b02343ada9ddc14f52c6fe00843d62e147006b +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=d60da53322a0c187f791aa742fc10141626385989be92d1170f17e71328df4b5 + + +# <<<< PREAMBLE CONTENT >>>> + +from libc.stdint cimport intptr_t + + +# <<<< END OF PREAMBLE CONTENT >>>> + from libc.stdint cimport intptr_t from ..cynvrtc cimport * diff --git a/cuda_bindings/cuda/bindings/_v2/nvrtc.pyx b/cuda_bindings/cuda/bindings/_v2/nvrtc.pyx index 4e267b1bd47..747fe108309 100644 --- a/cuda_bindings/cuda/bindings/_v2/nvrtc.pyx +++ b/cuda_bindings/cuda/bindings/_v2/nvrtc.pyx @@ -4,7 +4,7 @@ # # This code was automatically generated across versions from 12.9.0 to 13.4.0. Do not modify it directly. # !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=b919b9cb09a71e4b2f6ad7dd1f76c7e3bf92b5cb1dd51c0d83087d2ce0cab581 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=bfdc6e06639d60b7bfeb85d99575a89addb69548b11343689696df1b857b6940 # <<<< PREAMBLE CONTENT >>>> @@ -12,6 +12,7 @@ cimport cpython as _cyb_cpython cimport cpython.buffer as _cyb_cpython_buffer from cython cimport view as _cyb_view +from libc.stdint cimport intptr_t from libc.stdlib cimport ( calloc as _cyb_calloc, free as _cyb_free, @@ -657,6 +658,8 @@ cpdef tuple version(): cpdef int get_num_supported_archs() except? -1: """nvrtcGetNumSupportedArchs sets the output parameter ``num_archs`` with the number of architectures supported by NVRTC. This can then be used to pass an array to ``nvrtcGetSupportedArchs`` to get the supported architectures. + see ``nvrtcGetSupportedArchs``. + Returns: int: number of supported architectures. @@ -672,6 +675,8 @@ cpdef int get_num_supported_archs() except? -1: cpdef object get_supported_archs(): """nvrtcGetSupportedArchs populates the array passed via the output parameter ``supported_archs`` with the architectures supported by NVRTC. The array is sorted in the ascending order. The size of the array to be passed can be determined using ``nvrtcGetNumSupportedArchs``. + see ``nvrtcGetNumSupportedArchs``. + Returns: int: sorted array of supported architectures. @@ -881,6 +886,9 @@ cpdef bytes get_optix_ir(intptr_t prog): cpdef size_t get_program_log_size(intptr_t prog) except? 0: """nvrtcGetProgramLogSize sets ``log_size_ret`` with the size of the log generated by the previous compilation of ``prog`` (including the trailing ``NULL``). + Note that compilation log may be generated with warnings and informative + messages, even when the compilation of ``prog`` succeeds. + Args: prog (intptr_t): CUDA Runtime Compilation program. @@ -925,6 +933,9 @@ cpdef bytes get_program_log(intptr_t prog): cpdef add_name_expression(intptr_t prog, name_expression): """nvrtcAddNameExpression notes the given name expression denoting the address of a global function or device/__constant__ variable. + The identical name expression string must be provided on a subsequent call + to nvrtcGetLoweredName to extract the lowered name. + Args: prog (intptr_t): CUDA Runtime Compilation program. name_expression (str): constant expression denoting the @@ -961,6 +972,10 @@ cpdef size_t get_pch_heap_size() except? 0: cpdef set_pch_heap_size(size_t size): """set the size of the PCH Heap. + The requested size may be rounded up to a platform dependent alignment + (e.g. page size). If the PCH Heap has already been allocated, the heap + memory will be freed and a new PCH Heap will be allocated. + Args: size (size_t): requested size of the PCH Heap, in bytes. @@ -974,6 +989,20 @@ cpdef set_pch_heap_size(size_t size): cpdef int get_pch_create_status(intptr_t prog) except? -1: """returns the PCH creation status. + NVRTC_SUCCESS indicates that the PCH was successfully created. + NVRTC_ERROR_NO_PCH_CREATE_ATTEMPTED indicates that no PCH creation was + attempted, either because PCH functionality was not requested during the + preceding nvrtcCompileProgram call, or automatic PCH processing was + requested, and compiler chose not to create a PCH file. + NVRTC_ERROR_PCH_CREATE_HEAP_EXHAUSTED indicates that a PCH file could + potentially have been created, but the compiler ran out space in the PCH + heap. In this scenario, the :func:`get_pch_heap_size_required` can be used + to query the required heap size, the heap can be reallocated for this size + with :func:`set_pch_heap_size` and PCH creation may be reattempted again + invoking :func:`compile_program` with a new NVRTC program instance. + NVRTC_ERROR_PCH_CREATE indicates that an error condition prevented the PCH + file from being created. + Args: prog (intptr_t): CUDA Runtime Compilation program. diff --git a/cuda_bindings/cuda/bindings/cudla.pxd b/cuda_bindings/cuda/bindings/cudla.pxd index 97ecfb1bf25..ac79e7024bb 100644 --- a/cuda_bindings/cuda/bindings/cudla.pxd +++ b/cuda_bindings/cuda/bindings/cudla.pxd @@ -2,9 +2,21 @@ # SPDX-License-Identifier: Apache-2.0 # This code was automatically generated across versions from 1.5.0 to 13.4.0. Do not modify it directly. - # !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=436984a783ea5e6bef13945d0b6d60b4143aa08131c82cdea619337233b15737 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=1897e221f7cea1db8c935488157e3b929f4225e2de3eb5bdc80d302fc35d7e96 + + +# <<<< PREAMBLE CONTENT >>>> + +from libc.stdint cimport ( + intptr_t, + uint32_t, + uint64_t, +) + + +# <<<< END OF PREAMBLE CONTENT >>>> + from libc.stdint cimport intptr_t from .cycudla cimport * @@ -45,10 +57,10 @@ cpdef intptr_t mem_register(intptr_t dev_handle, intptr_t ptr, size_t size, uint cpdef intptr_t module_load_from_memory(intptr_t dev_handle, p_module, size_t module_size, uint32_t flags) except * cpdef module_unload(intptr_t h_module, uint32_t flags) cpdef submit_task(intptr_t dev_handle, intptr_t ptr_to_tasks, uint32_t num_tasks, intptr_t stream, uint32_t flags) -cpdef object device_get_attribute(intptr_t dev_handle, int attrib) except * +cpdef object device_get_attribute(intptr_t dev_handle, int attrib) cpdef mem_unregister(intptr_t dev_handle, intptr_t dev_ptr) cpdef int get_last_error(intptr_t dev_handle) except? 0 cpdef destroy_device(intptr_t dev_handle) cpdef set_task_timeout_in_ms(intptr_t dev_handle, uint32_t timeout) -cpdef module_get_attributes(intptr_t h_module, int attr_type) except * +cpdef module_get_attributes(intptr_t h_module, int attr_type) diff --git a/cuda_bindings/cuda/bindings/cudla.pyx b/cuda_bindings/cuda/bindings/cudla.pyx index 4532ebaeb97..a82f7164b53 100644 --- a/cuda_bindings/cuda/bindings/cudla.pyx +++ b/cuda_bindings/cuda/bindings/cudla.pyx @@ -3,7 +3,7 @@ # This code was automatically generated across versions from 1.5.0 to 13.4.0. Do not modify it directly. # !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=37c4218155319e18c12093c50fd40d05d05035b9625c2aaf8c111b0ab26d3c8c +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=e2fb6627d8729b1cbfc97858f01ebe848153980f9fa958bd031225e3232f3485 # <<<< PREAMBLE CONTENT >>>> @@ -11,6 +11,12 @@ cimport cpython as _cyb_cpython cimport cpython.buffer as _cyb_cpython_buffer from cython cimport view as _cyb_view +from libc.stdint cimport ( + intptr_t, + uint32_t, + uint64_t, + uint8_t, +) from libc.stdlib cimport ( calloc as _cyb_calloc, free as _cyb_free, @@ -63,6 +69,35 @@ 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) +cdef intptr_t _cyb_get_buffer_pointer(buf, Py_ssize_t size, readonly=True) except?-1: + cdef intptr_t ptr + cdef int flags = _cyb_cpython.PyBUF_ANY_CONTIGUOUS + if not readonly: + flags |= _cyb_cpython.PyBUF_WRITABLE + cdef int status = -1 + cdef _cyb_cpython.Py_buffer view + if isinstance(buf, int): + ptr = <intptr_t>buf + else: + try: + status = _cyb_cpython.PyObject_GetBuffer(buf, &view, flags) + if size != -1: + assert view.len == size + assert view.ndim == 1 + except Exception as e: + adj = "writable " if not readonly else "" + raise ValueError( + "buf must be either a Python int representing the pointer " + f"address to a valid buffer, or a 1D contiguous {adj}" + f"buffer, of size {size}" + ) from e + else: + ptr = <intptr_t>view.buf + finally: + if status == 0: + _cyb_cpython.PyBuffer_Release(&view) + return ptr + # <<<< END OF PREAMBLE CONTENT >>>> @@ -70,7 +105,6 @@ cimport cython # NOQA from libc.stdint cimport intptr_t, uintptr_t from libc.stdlib cimport malloc, free -from ._internal.utils cimport get_buffer_pointer @@ -1740,7 +1774,7 @@ cpdef uint64_t device_get_count() except? -1: cpdef intptr_t create_device(uint64_t device, uint32_t flags) except *: cdef DevHandle dev_handle - if flags == CUDLA_STANDALONE: + if flags & CUDLA_STANDALONE: raise CudlaError(cudlaErrorUnsupportedOperation) with nogil: __status__ = cudlaCreateDevice(<const uint64_t>device, &dev_handle, <const uint32_t>flags) @@ -1757,7 +1791,7 @@ cpdef intptr_t mem_register(intptr_t dev_handle, intptr_t ptr, size_t size, uint cpdef intptr_t module_load_from_memory(intptr_t dev_handle, p_module, size_t module_size, uint32_t flags) except *: - cdef void* _p_module_ = get_buffer_pointer(p_module, module_size, readonly=True) + cdef void* _p_module_ = <void *>_cyb_get_buffer_pointer(p_module, module_size, readonly=True) cdef Module h_module with nogil: __status__ = cudlaModuleLoadFromMemory(<const DevHandle>dev_handle, <const uint8_t* const>_p_module_, <const size_t>module_size, &h_module, <const uint32_t>flags) @@ -1777,7 +1811,7 @@ cpdef submit_task(intptr_t dev_handle, intptr_t ptr_to_tasks, uint32_t num_tasks check_status(__status__) -cpdef object device_get_attribute(intptr_t dev_handle, int attrib) except *: +cpdef object device_get_attribute(intptr_t dev_handle, int attrib): cdef DevAttribute p_attribute_py = DevAttribute() cdef cudlaDevAttribute *p_attribute = <cudlaDevAttribute *><intptr_t>(p_attribute_py._get_ptr()) with nogil: @@ -1811,7 +1845,7 @@ cpdef set_task_timeout_in_ms(intptr_t dev_handle, uint32_t timeout): check_status(__status__) -cpdef module_get_attributes(intptr_t h_module, int attr_type) except *: +cpdef module_get_attributes(intptr_t h_module, int attr_type): """Query module attributes, interpreting the cudlaModuleAttribute union based on the requested attribute type. diff --git a/cuda_bindings/cuda/bindings/cufile.pxd b/cuda_bindings/cuda/bindings/cufile.pxd index 35b6271e529..a99f2ea16b4 100644 --- a/cuda_bindings/cuda/bindings/cufile.pxd +++ b/cuda_bindings/cuda/bindings/cufile.pxd @@ -3,10 +3,18 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.9.1 to 13.4.0. Do not modify it directly. - # !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=1d85ffab055c92f1ea96fc186f7ede91090e0d65388d2a03591d374f74937209 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=434eee0d83610eff4f57f8530176efdd91369fa3f56eae651ef2a8e5f96ed063 + + + +# <<<< PREAMBLE CONTENT >>>> + from libc.stdint cimport intptr_t +from libcpp cimport bool as _cyb_bool + + +# <<<< END OF PREAMBLE CONTENT >>>> from .cycufile cimport * diff --git a/cuda_bindings/cuda/bindings/cufile.pyx b/cuda_bindings/cuda/bindings/cufile.pyx index 15eedf9708f..a2fc10d0291 100644 --- a/cuda_bindings/cuda/bindings/cufile.pyx +++ b/cuda_bindings/cuda/bindings/cufile.pyx @@ -4,7 +4,7 @@ # # This code was automatically generated across versions from 12.9.1 to 13.4.0. Do not modify it directly. # !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=9bb12d58d34130a4d23007783ff3b16344fd90af5d0977196234ced1b9e6574d +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=597b2c9e8f97786ca7a037c256f812e294b936e9776179ab066f597739300d17 # <<<< PREAMBLE CONTENT >>>> @@ -13,6 +13,10 @@ cimport cpython as _cyb_cpython cimport cpython.buffer as _cyb_cpython_buffer cimport cpython.memoryview as _cyb_cpython_memoryview from cython cimport view as _cyb_view +from libc.stdint cimport ( + intptr_t, + uint64_t, +) from libc.stdlib cimport ( calloc as _cyb_calloc, free as _cyb_free, @@ -22,6 +26,7 @@ from libc.string cimport ( memcmp as _cyb_memcmp, memcpy as _cyb_memcpy, ) +from libcpp cimport bool as _cyb_bool from cuda.bindings._internal._fast_enum import FastEnum as _cyb_FastEnum @@ -70,7 +75,7 @@ cdef _cyb_from_data(data, dtype_name, expected_dtype, lowpp_type): cimport cython # NOQA from libc cimport errno -from ._internal.utils cimport (get_buffer_pointer, get_nested_resource_ptr, +from ._internal.utils cimport (get_nested_resource_ptr, nested_resource) import cython @@ -3302,9 +3307,12 @@ class cuFileError(Exception): @cython.profile(False) cdef int check_status(ReturnT status) except 1 nogil: if ReturnT is CUfileError_t: - if status.err != 0 or status.cu_err != 0: + if IS_CUDA_ERR(status): with gil: raise cuFileError(status.err, status.cu_err) + elif IS_CUFILE_ERR(status.err): + with gil: + raise cuFileError(status.err) elif ReturnT is ssize_t: if status == -1: # note: this assumes cuFile already properly resets errno in each API @@ -3423,7 +3431,7 @@ cpdef driver_set_poll_mode(bint poll, size_t poll_threshold_size): .. seealso:: `cuFileDriverSetPollMode` """ with nogil: - __status__ = cuFileDriverSetPollMode(<cpp_bool>poll, poll_threshold_size) + __status__ = cuFileDriverSetPollMode(<_cyb_bool>poll, poll_threshold_size) check_status(__status__) @@ -3548,7 +3556,7 @@ cpdef size_t get_parameter_size_t(int param) except? 0: cpdef bint get_parameter_bool(int param) except? 0: - cdef cpp_bool value + cdef _cyb_bool value with nogil: __status__ = cuFileGetParameterBool(<_BoolConfigParameter>param, &value) check_status(__status__) @@ -3572,7 +3580,7 @@ cpdef set_parameter_size_t(int param, size_t value): cpdef set_parameter_bool(int param, bint value): with nogil: - __status__ = cuFileSetParameterBool(<_BoolConfigParameter>param, <cpp_bool>value) + __status__ = cuFileSetParameterBool(<_BoolConfigParameter>param, <_cyb_bool>value) check_status(__status__) diff --git a/cuda_bindings/cuda/bindings/cycudla.pxd b/cuda_bindings/cuda/bindings/cycudla.pxd index 5f42abe0de5..9d5f2bd8e66 100644 --- a/cuda_bindings/cuda/bindings/cycudla.pxd +++ b/cuda_bindings/cuda/bindings/cycudla.pxd @@ -3,12 +3,21 @@ # This code was automatically generated across versions from 1.5.0 to 13.4.0. Do not modify it directly. # This layer exposes the C header to Cython as-is. - # !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=f24f3dc6fe7d137fe1753e5eb4ebb613d631f984996f6dbb859befed8211c73b -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 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=ba14530d880001870d344c52df77dcaaede52ae6421387f08cac4624003f683e + + +# <<<< PREAMBLE CONTENT >>>> + +from libc.stdint cimport ( + uint32_t, + uint64_t, + uint8_t, +) + + +# <<<< END OF PREAMBLE CONTENT >>>> + from libc.stddef cimport size_t diff --git a/cuda_bindings/cuda/bindings/cycudla.pyx b/cuda_bindings/cuda/bindings/cycudla.pyx index df23650e881..3128e105ab5 100644 --- a/cuda_bindings/cuda/bindings/cycudla.pyx +++ b/cuda_bindings/cuda/bindings/cycudla.pyx @@ -2,9 +2,21 @@ # SPDX-License-Identifier: Apache-2.0 # This code was automatically generated across versions from 1.5.0 to 13.4.0. Do not modify it directly. - # !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=71bfc67b64e7e78ba54303e68d8df46f44f73c601c5d303926a46e261b3fd042 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=b7b38cce9b72640bc4cb706f26610c8ec12472eb0f37d50336c2722382c04f8e + + +# <<<< PREAMBLE CONTENT >>>> + +from libc.stdint cimport ( + uint32_t, + uint64_t, + uint8_t, +) + + +# <<<< END OF PREAMBLE CONTENT >>>> + from ._internal cimport cudla as _cudla diff --git a/cuda_bindings/cuda/bindings/cycufile.pxd b/cuda_bindings/cuda/bindings/cycufile.pxd index 47aa51465fe..c259b4a282f 100644 --- a/cuda_bindings/cuda/bindings/cycufile.pxd +++ b/cuda_bindings/cuda/bindings/cycufile.pxd @@ -3,12 +3,22 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.9.1 to 13.4.0. Do not modify it directly. - # !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=7961eb9a31b8ad5274ddd2a6357f2f75c1004c44ee4a5edeadf22674f1833d3e -from libc.stdint cimport uint32_t, uint64_t +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=e2826fd354311fb0e8b09a69465f585b46982968694efaf4416db0b2b5761d69 + + +# <<<< PREAMBLE CONTENT >>>> + +from libc.stdint cimport ( + uint32_t, + uint64_t, +) +from libcpp cimport bool as _cyb_bool + + +# <<<< END OF PREAMBLE CONTENT >>>> + from libc.time cimport time_t -from libcpp cimport bool as cpp_bool from posix.types cimport off_t cimport cuda.bindings.cydriver @@ -393,6 +403,13 @@ cdef extern from 'cufile.h': CUfilePerGpuStats_t per_gpu_stats[16] +# Error-inspection macros from cufile.h (declared as functions so Cython +# emits calls that the C preprocessor expands). +cdef extern from 'cufile.h' nogil: + bint IS_CUDA_ERR(CUfileError_t status) + bint IS_CUFILE_ERR(CUfileOpError err) + + cdef extern from *: """ // This is the missing piece we need to supply to help Cython & C++ compilers. @@ -422,7 +439,7 @@ cdef CUfileError_t cuFileDriverClose() except?<CUfileError_t>CUFILE_LOADING_ERRO cdef CUfileError_t cuFileDriverClose_v2() except?<CUfileError_t>CUFILE_LOADING_ERROR nogil cdef long cuFileUseCount() except* nogil cdef CUfileError_t cuFileDriverGetProperties(CUfileDrvProps_t* props) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil -cdef CUfileError_t cuFileDriverSetPollMode(cpp_bool poll, size_t poll_threshold_size) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil +cdef CUfileError_t cuFileDriverSetPollMode(_cyb_bool poll, size_t poll_threshold_size) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil cdef CUfileError_t cuFileDriverSetMaxDirectIOSize(size_t max_direct_io_size) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil cdef CUfileError_t cuFileDriverSetMaxCacheSize(size_t max_cache_size) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil cdef CUfileError_t cuFileDriverSetMaxPinnedMemSize(size_t max_pinned_size) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil @@ -437,10 +454,10 @@ cdef CUfileError_t cuFileStreamRegister(CUstream stream, unsigned flags) except? cdef CUfileError_t cuFileStreamDeregister(CUstream stream) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil cdef CUfileError_t cuFileGetVersion(int* version) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil cdef CUfileError_t cuFileGetParameterSizeT(CUFileSizeTConfigParameter_t param, size_t* value) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil -cdef CUfileError_t cuFileGetParameterBool(CUFileBoolConfigParameter_t param, cpp_bool* value) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil +cdef CUfileError_t cuFileGetParameterBool(CUFileBoolConfigParameter_t param, _cyb_bool* value) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil cdef CUfileError_t cuFileGetParameterString(CUFileStringConfigParameter_t param, char* desc_str, int len) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil cdef CUfileError_t cuFileSetParameterSizeT(CUFileSizeTConfigParameter_t param, size_t value) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil -cdef CUfileError_t cuFileSetParameterBool(CUFileBoolConfigParameter_t param, cpp_bool value) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil +cdef CUfileError_t cuFileSetParameterBool(CUFileBoolConfigParameter_t param, _cyb_bool value) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil cdef CUfileError_t cuFileSetParameterString(CUFileStringConfigParameter_t param, const char* desc_str) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil cdef CUfileError_t cuFileGetParameterMinMaxValue(CUFileSizeTConfigParameter_t param, size_t* min_value, size_t* max_value) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil cdef CUfileError_t cuFileSetStatsLevel(int level) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil diff --git a/cuda_bindings/cuda/bindings/cycufile.pyx b/cuda_bindings/cuda/bindings/cycufile.pyx index 5c6ac42c8cd..5d1d5b5e599 100644 --- a/cuda_bindings/cuda/bindings/cycufile.pyx +++ b/cuda_bindings/cuda/bindings/cycufile.pyx @@ -4,12 +4,13 @@ # # This code was automatically generated across versions from 12.9.1 to 13.4.0. Do not modify it directly. # !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=f665ca316ab6166959a5f3338c901e698617b31146000a9d99422dcf9849d3fc +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=e57d69f406c760d8e1164f96ab601735651181d13db254ea6e0c3a9d66b72b9b # <<<< PREAMBLE CONTENT >>>> cimport cython as _cyb_cython +from libcpp cimport bool as _cyb_bool # <<<< END OF PREAMBLE CONTENT >>>> @@ -67,7 +68,7 @@ cdef CUfileError_t cuFileDriverGetProperties(CUfileDrvProps_t* props) except?<CU return _cufile._cuFileDriverGetProperties(props) -cdef CUfileError_t cuFileDriverSetPollMode(cpp_bool poll, size_t poll_threshold_size) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: +cdef CUfileError_t cuFileDriverSetPollMode(_cyb_bool poll, size_t poll_threshold_size) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: return _cufile._cuFileDriverSetPollMode(poll, poll_threshold_size) @@ -128,7 +129,7 @@ cdef CUfileError_t cuFileGetParameterSizeT(CUFileSizeTConfigParameter_t param, s return _cufile._cuFileGetParameterSizeT(param, value) -cdef CUfileError_t cuFileGetParameterBool(CUFileBoolConfigParameter_t param, cpp_bool* value) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: +cdef CUfileError_t cuFileGetParameterBool(CUFileBoolConfigParameter_t param, _cyb_bool* value) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: return _cufile._cuFileGetParameterBool(param, value) @@ -140,7 +141,7 @@ cdef CUfileError_t cuFileSetParameterSizeT(CUFileSizeTConfigParameter_t param, s return _cufile._cuFileSetParameterSizeT(param, value) -cdef CUfileError_t cuFileSetParameterBool(CUFileBoolConfigParameter_t param, cpp_bool value) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: +cdef CUfileError_t cuFileSetParameterBool(CUFileBoolConfigParameter_t param, _cyb_bool value) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: return _cufile._cuFileSetParameterBool(param, value) diff --git a/cuda_bindings/cuda/bindings/cydriver.pxd b/cuda_bindings/cuda/bindings/cydriver.pxd index da6754e7af2..0be5396d160 100644 --- a/cuda_bindings/cuda/bindings/cydriver.pxd +++ b/cuda_bindings/cuda/bindings/cydriver.pxd @@ -3,9 +3,20 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.9.0 to 13.4.0. Do not modify it directly. - # !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=9e145065ec8a0e7780c0d8e38d0cec7a9b4bf2512e8a745f32593531bbb64676 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=b2499d947f781ee7e8b828134b2549b45e0771780adfd0ad62871bb735a19891 + + +# <<<< PREAMBLE CONTENT >>>> + +from libc.stdint cimport ( + uint32_t, + uint64_t, +) + + +# <<<< END OF PREAMBLE CONTENT >>>> + from libc.stdint cimport uint32_t, uint64_t diff --git a/cuda_bindings/cuda/bindings/cynvfatbin.pxd b/cuda_bindings/cuda/bindings/cynvfatbin.pxd index c9d844c6da9..47b4c4c8efe 100644 --- a/cuda_bindings/cuda/bindings/cynvfatbin.pxd +++ b/cuda_bindings/cuda/bindings/cynvfatbin.pxd @@ -4,9 +4,6 @@ # # This code was automatically generated across versions from 12.4.1 to 13.4.0. Do not modify it directly. -# !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=350ce092394c88b497887fcb76999a31e960cb7c395fbc50aadd7d5ce174ffc7 -from libc.stdint cimport intptr_t, uint32_t ############################################################################### @@ -14,6 +11,8 @@ from libc.stdint cimport intptr_t, uint32_t ############################################################################### # enums +# !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=15a32de9a2c28520e84759f8eb508b8ca7dd4f3e5b462d70ed9b252240a4ac55 ctypedef enum nvFatbinResult "nvFatbinResult": NVFATBIN_SUCCESS "NVFATBIN_SUCCESS" = 0 NVFATBIN_ERROR_INTERNAL "NVFATBIN_ERROR_INTERNAL" diff --git a/cuda_bindings/cuda/bindings/cynvjitlink.pxd b/cuda_bindings/cuda/bindings/cynvjitlink.pxd index b6bc62c1d7b..78020419b59 100644 --- a/cuda_bindings/cuda/bindings/cynvjitlink.pxd +++ b/cuda_bindings/cuda/bindings/cynvjitlink.pxd @@ -4,9 +4,6 @@ # # This code was automatically generated across versions from 12.0.1 to 13.4.0. Do not modify it directly. -# !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=19b54696d673ac6a15251d0a9fb4d23d19a3ed87a31a38a1727cf89a4a1a8383 -from libc.stdint cimport intptr_t, uint32_t ############################################################################### @@ -14,6 +11,16 @@ from libc.stdint cimport intptr_t, uint32_t ############################################################################### # enums +# !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=4e2f2fa7cdc6275ba2b8bd666047fe788152a7daa8f4d2fc9cc9b0e48f43ca86 + +# <<<< PREAMBLE CONTENT >>>> + +from libc.stdint cimport uint32_t + + +# <<<< END OF PREAMBLE CONTENT >>>> + ctypedef enum nvJitLinkResult "nvJitLinkResult": NVJITLINK_SUCCESS "NVJITLINK_SUCCESS" = 0 NVJITLINK_ERROR_UNRECOGNIZED_OPTION "NVJITLINK_ERROR_UNRECOGNIZED_OPTION" diff --git a/cuda_bindings/cuda/bindings/cynvjitlink.pyx b/cuda_bindings/cuda/bindings/cynvjitlink.pyx index fd20bfee10f..c8546283741 100644 --- a/cuda_bindings/cuda/bindings/cynvjitlink.pyx +++ b/cuda_bindings/cuda/bindings/cynvjitlink.pyx @@ -3,9 +3,17 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.0.1 to 13.4.0. Do not modify it directly. - # !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=f91e9f01600d3933b3489ae1d9963b33f8095779168d3b27949645eb41926ec3 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=47897bfaeb454861edbe979303c63d0f1740d920a7cdd24e3b22a5e221830fba + + +# <<<< PREAMBLE CONTENT >>>> + +from libc.stdint cimport uint32_t + + +# <<<< END OF PREAMBLE CONTENT >>>> + from ._internal cimport nvjitlink as _nvjitlink diff --git a/cuda_bindings/cuda/bindings/cynvml.pxd b/cuda_bindings/cuda/bindings/cynvml.pxd index be3ab2da3ae..2891b867473 100644 --- a/cuda_bindings/cuda/bindings/cynvml.pxd +++ b/cuda_bindings/cuda/bindings/cynvml.pxd @@ -4,9 +4,6 @@ # # This code was automatically generated across versions from 12.9.1 to 13.4.0. Do not modify it directly. -# !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=6cd5217ee9e8afc03e6cce40801c8b2ad5f105d1fb2a1528910955e91e3cc570 -from libc.stdint cimport int64_t ############################################################################### @@ -14,6 +11,8 @@ from libc.stdint cimport int64_t ############################################################################### # enums +# !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=924be66344cb7c8837c46976a9f394569b0e5d00df6b5026ad42ef6d1258984f ctypedef enum nvmlBridgeChipType_t "nvmlBridgeChipType_t": NVML_BRIDGE_CHIP_PLX "NVML_BRIDGE_CHIP_PLX" = 0 NVML_BRIDGE_CHIP_BRO4 "NVML_BRIDGE_CHIP_BRO4" = 1 diff --git a/cuda_bindings/cuda/bindings/cynvrtc.pxd b/cuda_bindings/cuda/bindings/cynvrtc.pxd index 37e76005971..70beba81b68 100644 --- a/cuda_bindings/cuda/bindings/cynvrtc.pxd +++ b/cuda_bindings/cuda/bindings/cynvrtc.pxd @@ -4,12 +4,11 @@ # # This code was automatically generated across versions from 12.9.0 to 13.4.0. Do not modify it directly. -# !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=a5984ec05eaf04c2ac41c7771b8f7b364aeab3379ee9785f1b24be8d3cf54996 -from libc.stdint cimport uint32_t, uint64_t # ENUMS +# !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=9b3dd5d3dc0c812b2b9f95e2d50a082efc2735744e0187108b1639c26f494c94 cdef extern from 'nvrtc.h': ctypedef enum nvrtcResult "nvrtcResult": NVRTC_SUCCESS diff --git a/cuda_bindings/cuda/bindings/nvfatbin.pxd b/cuda_bindings/cuda/bindings/nvfatbin.pxd index aca95c85185..5d3e8d51836 100644 --- a/cuda_bindings/cuda/bindings/nvfatbin.pxd +++ b/cuda_bindings/cuda/bindings/nvfatbin.pxd @@ -3,10 +3,17 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.4.1 to 13.4.0. Do not modify it directly. - # !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=f9455d8c181ccdf20d59511bf1236f302dbe9ef903b61035cc1dd971e278caa1 -from libc.stdint cimport intptr_t, uint32_t +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=f5f385bd424c3bc290ea11bc66661b9eaba40a07b5a232a9f515dd2c884343db + + + +# <<<< PREAMBLE CONTENT >>>> + +from libc.stdint cimport intptr_t + + +# <<<< END OF PREAMBLE CONTENT >>>> from .cynvfatbin cimport * diff --git a/cuda_bindings/cuda/bindings/nvfatbin.pyx b/cuda_bindings/cuda/bindings/nvfatbin.pyx index 8e640a970d3..13477d3c554 100644 --- a/cuda_bindings/cuda/bindings/nvfatbin.pyx +++ b/cuda_bindings/cuda/bindings/nvfatbin.pyx @@ -4,20 +4,52 @@ # # This code was automatically generated across versions from 12.4.1 to 13.4.0. Do not modify it directly. # !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=a9f06b8372f6c9da9bd1056df4fe0095a6e4a2b85496da6cca9a5496b641a909 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=4e110b2c731e012ecdcb6a537d79d3e9276c287056daf67650c5c895cf368d24 # <<<< PREAMBLE CONTENT >>>> +cimport cpython as _cyb_cpython +from libc.stdint cimport intptr_t + from cuda.bindings._internal._fast_enum import FastEnum as _cyb_FastEnum +cdef intptr_t _cyb_get_buffer_pointer(buf, Py_ssize_t size, readonly=True) except?-1: + cdef intptr_t ptr + cdef int flags = _cyb_cpython.PyBUF_ANY_CONTIGUOUS + if not readonly: + flags |= _cyb_cpython.PyBUF_WRITABLE + cdef int status = -1 + cdef _cyb_cpython.Py_buffer view + if isinstance(buf, int): + ptr = <intptr_t>buf + else: + try: + status = _cyb_cpython.PyObject_GetBuffer(buf, &view, flags) + if size != -1: + assert view.len == size + assert view.ndim == 1 + except Exception as e: + adj = "writable " if not readonly else "" + raise ValueError( + "buf must be either a Python int representing the pointer " + f"address to a valid buffer, or a 1D contiguous {adj}" + f"buffer, of size {size}" + ) from e + else: + ptr = <intptr_t>view.buf + finally: + if status == 0: + _cyb_cpython.PyBuffer_Release(&view) + return ptr + # <<<< END OF PREAMBLE CONTENT >>>> cimport cython # NOQA from ._internal.utils cimport (get_resource_ptr, get_nested_resource_ptr, nested_resource, nullable_unique_ptr, - get_buffer_pointer, get_resource_ptrs) + get_resource_ptrs) from libcpp.vector cimport vector @@ -157,7 +189,7 @@ cpdef add_ptx(intptr_t handle, code, size_t size, arch, identifier, options_cmd_ .. seealso:: `nvFatbinAddPTX` """ - cdef void* _code_ = get_buffer_pointer(code, size, readonly=True) + cdef void* _code_ = <void *>_cyb_get_buffer_pointer(code, size, readonly=True) if not isinstance(arch, str): raise TypeError("arch must be a Python str") cdef bytes _temp_arch_ = (<str>arch).encode() @@ -189,7 +221,7 @@ cpdef add_cubin(intptr_t handle, code, size_t size, arch, identifier): .. seealso:: `nvFatbinAddCubin` """ - cdef void* _code_ = get_buffer_pointer(code, size, readonly=True) + cdef void* _code_ = <void *>_cyb_get_buffer_pointer(code, size, readonly=True) if not isinstance(arch, str): raise TypeError("arch must be a Python str") cdef bytes _temp_arch_ = (<str>arch).encode() @@ -218,7 +250,7 @@ cpdef add_ltoir(intptr_t handle, code, size_t size, arch, identifier, options_cm .. seealso:: `nvFatbinAddLTOIR` """ - cdef void* _code_ = get_buffer_pointer(code, size, readonly=True) + cdef void* _code_ = <void *>_cyb_get_buffer_pointer(code, size, readonly=True) if not isinstance(arch, str): raise TypeError("arch must be a Python str") cdef bytes _temp_arch_ = (<str>arch).encode() @@ -263,7 +295,7 @@ cpdef get(intptr_t handle, buffer): .. seealso:: `nvFatbinGet` """ - cdef void* _buffer_ = get_buffer_pointer(buffer, -1, readonly=False) + cdef void* _buffer_ = <void *>_cyb_get_buffer_pointer(buffer, -1, readonly=False) with nogil: __status__ = nvFatbinGet(<Handle>handle, <void*>_buffer_) check_status(__status__) @@ -289,7 +321,7 @@ cpdef tuple version(): cpdef add_index(intptr_t handle, code, size_t size, identifier): - cdef void* _code_ = get_buffer_pointer(code, size, readonly=True) + cdef void* _code_ = <void *>_cyb_get_buffer_pointer(code, size, readonly=True) if not isinstance(identifier, str): raise TypeError("identifier must be a Python str") cdef bytes _temp_identifier_ = (<str>identifier).encode() @@ -309,7 +341,7 @@ cpdef add_reloc(intptr_t handle, code, size_t size): .. seealso:: `nvFatbinAddReloc` """ - cdef void* _code_ = get_buffer_pointer(code, size, readonly=True) + cdef void* _code_ = <void *>_cyb_get_buffer_pointer(code, size, readonly=True) with nogil: __status__ = nvFatbinAddReloc(<Handle>handle, <const void*>_code_, size) check_status(__status__) @@ -328,7 +360,7 @@ cpdef add_tile_ir(intptr_t handle, code, size_t size, identifier, options_cmd_li .. seealso:: `nvFatbinAddTileIR` """ - cdef void* _code_ = get_buffer_pointer(code, size, readonly=True) + cdef void* _code_ = <void *>_cyb_get_buffer_pointer(code, size, readonly=True) if not isinstance(identifier, str): raise TypeError("identifier must be a Python str") cdef bytes _temp_identifier_ = (<str>identifier).encode() diff --git a/cuda_bindings/cuda/bindings/nvjitlink.pxd b/cuda_bindings/cuda/bindings/nvjitlink.pxd index 7c55364f171..76ce8e0c2d9 100644 --- a/cuda_bindings/cuda/bindings/nvjitlink.pxd +++ b/cuda_bindings/cuda/bindings/nvjitlink.pxd @@ -3,10 +3,20 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.0.1 to 13.4.0. Do not modify it directly. - # !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=71dbc31e82ef2e456eb1a686757dc7a9f951a37f7c4d813d8b4ed92956a0f225 -from libc.stdint cimport intptr_t, uint32_t +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=825a8ba33da8bf973732e0796858beef6b72c920f964b67e6a28434eda495b66 + + + +# <<<< PREAMBLE CONTENT >>>> + +from libc.stdint cimport ( + intptr_t, + uint32_t, +) + + +# <<<< END OF PREAMBLE CONTENT >>>> from .cynvjitlink cimport * diff --git a/cuda_bindings/cuda/bindings/nvjitlink.pyx b/cuda_bindings/cuda/bindings/nvjitlink.pyx index adeb4c40de9..f2ca7be9b50 100644 --- a/cuda_bindings/cuda/bindings/nvjitlink.pyx +++ b/cuda_bindings/cuda/bindings/nvjitlink.pyx @@ -4,20 +4,55 @@ # # This code was automatically generated across versions from 12.0.1 to 13.4.0. Do not modify it directly. # !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=f722861e068fe62c47806f8fc7757afc24a313435cc14026e1b4f59d1b7f2be7 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=aa44e59efcaf2832770b60a168b74cc79bc06d1a35dcbf78c90f7917f3c900a4 # <<<< PREAMBLE CONTENT >>>> +cimport cpython as _cyb_cpython +from libc.stdint cimport ( + intptr_t, + uint32_t, +) + from cuda.bindings._internal._fast_enum import FastEnum as _cyb_FastEnum +cdef intptr_t _cyb_get_buffer_pointer(buf, Py_ssize_t size, readonly=True) except?-1: + cdef intptr_t ptr + cdef int flags = _cyb_cpython.PyBUF_ANY_CONTIGUOUS + if not readonly: + flags |= _cyb_cpython.PyBUF_WRITABLE + cdef int status = -1 + cdef _cyb_cpython.Py_buffer view + if isinstance(buf, int): + ptr = <intptr_t>buf + else: + try: + status = _cyb_cpython.PyObject_GetBuffer(buf, &view, flags) + if size != -1: + assert view.len == size + assert view.ndim == 1 + except Exception as e: + adj = "writable " if not readonly else "" + raise ValueError( + "buf must be either a Python int representing the pointer " + f"address to a valid buffer, or a 1D contiguous {adj}" + f"buffer, of size {size}" + ) from e + else: + ptr = <intptr_t>view.buf + finally: + if status == 0: + _cyb_cpython.PyBuffer_Release(&view) + return ptr + # <<<< END OF PREAMBLE CONTENT >>>> cimport cython # NOQA from ._internal.utils cimport (get_resource_ptr, get_nested_resource_ptr, nested_resource, nullable_unique_ptr, - get_buffer_pointer, get_resource_ptrs) + get_resource_ptrs) from libcpp.vector cimport vector @@ -153,7 +188,7 @@ cpdef add_data(intptr_t handle, int input_type, data, size_t size, name): .. seealso:: `nvJitLinkAddData` """ - cdef void* _data_ = get_buffer_pointer(data, size, readonly=True) + cdef void* _data_ = <void *>_cyb_get_buffer_pointer(data, size, readonly=True) if not isinstance(name, str): raise TypeError("name must be a Python str") cdef bytes _temp_name_ = (<str>name).encode() @@ -222,7 +257,7 @@ cpdef get_linked_cubin(intptr_t handle, cubin): .. seealso:: `nvJitLinkGetLinkedCubin` """ - cdef void* _cubin_ = get_buffer_pointer(cubin, -1, readonly=False) + cdef void* _cubin_ = <void *>_cyb_get_buffer_pointer(cubin, -1, readonly=False) with nogil: __status__ = nvJitLinkGetLinkedCubin(<Handle>handle, <void*>_cubin_) check_status(__status__) @@ -255,7 +290,7 @@ cpdef get_linked_ptx(intptr_t handle, ptx): .. seealso:: `nvJitLinkGetLinkedPtx` """ - cdef void* _ptx_ = get_buffer_pointer(ptx, -1, readonly=False) + cdef void* _ptx_ = <void *>_cyb_get_buffer_pointer(ptx, -1, readonly=False) with nogil: __status__ = nvJitLinkGetLinkedPtx(<Handle>handle, <char*>_ptx_) check_status(__status__) @@ -288,7 +323,7 @@ cpdef get_error_log(intptr_t handle, log): .. seealso:: `nvJitLinkGetErrorLog` """ - cdef void* _log_ = get_buffer_pointer(log, -1, readonly=False) + cdef void* _log_ = <void *>_cyb_get_buffer_pointer(log, -1, readonly=False) with nogil: __status__ = nvJitLinkGetErrorLog(<Handle>handle, <char*>_log_) check_status(__status__) @@ -321,7 +356,7 @@ cpdef get_info_log(intptr_t handle, log): .. seealso:: `nvJitLinkGetInfoLog` """ - cdef void* _log_ = get_buffer_pointer(log, -1, readonly=False) + cdef void* _log_ = <void *>_cyb_get_buffer_pointer(log, -1, readonly=False) with nogil: __status__ = nvJitLinkGetInfoLog(<Handle>handle, <char*>_log_) check_status(__status__) @@ -373,7 +408,7 @@ cpdef get_linked_ltoir(intptr_t handle, ltoir): .. seealso:: `nvJitLinkGetLinkedLTOIR` """ - cdef void* _ltoir_ = get_buffer_pointer(ltoir, -1, readonly=False) + cdef void* _ltoir_ = <void *>_cyb_get_buffer_pointer(ltoir, -1, readonly=False) with nogil: __status__ = nvJitLinkGetLinkedLTOIR(<Handle>handle, <void*>_ltoir_) check_status(__status__) diff --git a/cuda_bindings/cuda/bindings/nvml.pxd b/cuda_bindings/cuda/bindings/nvml.pxd index 40546231530..debb18ad75a 100644 --- a/cuda_bindings/cuda/bindings/nvml.pxd +++ b/cuda_bindings/cuda/bindings/nvml.pxd @@ -3,11 +3,18 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.9.1 to 13.4.0. Do not modify it directly. - # !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=f699a98280e825837b6ddf7fb083deca9f51318e2406acefd67481a68b43a165 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=48a7b0d320e83e759cdd3e877e32713c97676a35b51aa327521880e783c7ea01 + + + +# <<<< PREAMBLE CONTENT >>>> + from libc.stdint cimport intptr_t + +# <<<< END OF PREAMBLE CONTENT >>>> + from .cynvml cimport * diff --git a/cuda_bindings/cuda/bindings/nvml.pyx b/cuda_bindings/cuda/bindings/nvml.pyx index b8b720ee11f..a936780a795 100644 --- a/cuda_bindings/cuda/bindings/nvml.pyx +++ b/cuda_bindings/cuda/bindings/nvml.pyx @@ -4,7 +4,7 @@ # # This code was automatically generated across versions from 12.9.1 to 13.4.0. Do not modify it directly. # !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=e6637452fb185e3d30ab3d126d11f1f4de18b77785d64948b4ee580f4ddf03fe +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=331cd635d123e94faac2d9b218fae5a0f778c93a6b3dbf2040a0c9831f631975 # <<<< PREAMBLE CONTENT >>>> @@ -13,6 +13,7 @@ cimport cpython as _cyb_cpython cimport cpython.buffer as _cyb_cpython_buffer cimport cpython.memoryview as _cyb_cpython_memoryview from cython cimport view as _cyb_view +from libc.stdint cimport intptr_t from libc.stdlib cimport ( calloc as _cyb_calloc, free as _cyb_free, @@ -73,7 +74,7 @@ from cython cimport view cimport cpython from libc.string cimport memcpy -from ._internal.utils cimport (get_buffer_pointer, get_nested_resource_ptr, +from ._internal.utils cimport (get_nested_resource_ptr, nested_resource) from cuda.bindings._internal._fast_enum import FastEnum as _FastEnum @@ -1392,7 +1393,7 @@ class CPERType(_cyb_FastEnum): class GpuOperationalEventLogLevel(_cyb_FastEnum): """ - Log-level values used by GPU Operational Events.These values are used + Log-level values used by GPU Operational Events. These values are used both for event reporting in `nvmlEventData_v2_t` and for subscription filtering in `nvmlGpuOperationalEventConfig_v1_t`. Higher numeric values represent more selective log levels. @@ -1412,7 +1413,7 @@ class GpuOperationalEventLogLevel(_cyb_FastEnum): class OperationalEventSeverity(_cyb_FastEnum): """ - Severity values used by Operational Events.These values are used both + Severity values used by Operational Events. These values are used both for event reporting in `nvmlEventData_v2_t` and for subscription filtering in `nvmlGpuOperationalEventConfig_v1_t`. Higher numeric values represent more selective severities. @@ -1440,9 +1441,9 @@ class EventDataType(_cyb_FastEnum): class GpuOperationalEventContextType(_cyb_FastEnum): """ - NVML-defined GPU Operational Event context classifications.These values - describe the NVML public interpretation of a context payload. The - original source-defined context type is returned separately in + NVML-defined GPU Operational Event context classifications. These + values describe the NVML public interpretation of a context payload. + The original source-defined context type is returned separately in `nvmlOperationalEventContextInfo_v1_t.sourceEventContextType`. See `nvmlGpuOperationalEventContextType_t`. @@ -14943,7 +14944,7 @@ cdef class DevicePowerMizerModes_v1: @property def supported_power_mizer_modes(self): - """int: OUT: Bitmask of supported powermizer modes. The bitmask of supported power mizer modes on this device. The supported modes can be combined using the bitwise OR operator '|'. For example, if a device supports all PowerMizer modes, the bitmask would be: supportedPowerMizerModes = ((1 << NVML_POWER_MIZER_MODE_ADAPTIVE) | (1 << NVML_POWER_MIZER_MODE_PREFER_MAXIMUM_PERFORMANCE) | (1 << NVML_POWER_MIZER_MODE_AUTO) | (1 << NVML_POWER_MIZER_MODE_PREFER_CONSISTENT_PERFORMANCE)); This bitmask can be used to check which power mizer modes are available on the device by performing a bitwise AND operation with the specific mode you want to check.""" + """int: OUT: Bitmask of supported powermizer modes. The bitmask of supported power mizer modes on this device. The supported modes can be combined using the bitwise OR operator '|'. For example, if a device supports all PowerMizer modes, the bitmask would be: supportedPowerMizerModes = ((1 << NVML_POWER_MIZER_MODE_ADAPTIVE) | (1 << NVML_POWER_MIZER_MODE_PREFER_MAXIMUM_PERFORMANCE) | (1 << NVML_POWER_MIZER_MODE_AUTO) | (1 << NVML_POWER_MIZER_MODE_PREFER_CONSISTENT_PERFORMANCE)); This bitmask can be used to check which power mizer modes are available on the device by performing a bitwise AND operation with the specific mode you want to check.""" return self._ptr[0].supportedPowerMizerModes @supported_power_mizer_modes.setter diff --git a/cuda_bindings/cuda/bindings/nvrtc.pyx b/cuda_bindings/cuda/bindings/nvrtc.pyx index b4b4d713579..ebf3810e2f6 100644 --- a/cuda_bindings/cuda/bindings/nvrtc.pyx +++ b/cuda_bindings/cuda/bindings/nvrtc.pyx @@ -3,7 +3,7 @@ # This code was automatically generated with version 13.4.0. Do not modify it directly. # !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=9dcd9e24a5962a3fa156378497290ef95c84fb433d2c31c6e2a5da5528391fe8 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=d5cf00b9db7880e26f7f555cc4d96bc106638d06f9470281879fee44d0fcd767 from typing import Any, Optional import cython import ctypes @@ -45,8 +45,10 @@ ctypedef unsigned long long float_ptr ctypedef unsigned long long double_ptr ctypedef unsigned long long void_ptr -#: Flags for nvrtcInstallBundledHeaders.Skip installation if version marker -#: exists and version matches. This is the default behavior when flags=0. +#: Flags for nvrtcInstallBundledHeaders. +#: +#: Skip installation if version marker exists and version matches. This is +#: the default behavior when flags=0. NVRTC_INSTALL_HEADERS_SKIP_IF_EXISTS = cynvrtc.NVRTC_INSTALL_HEADERS_SKIP_IF_EXISTS #: Clear existing directory contents before installation. Guarantees diff --git a/cuda_bindings/cuda/bindings/nvvm.pxd b/cuda_bindings/cuda/bindings/nvvm.pxd index 6e96ef7c920..0d22bdc9a94 100644 --- a/cuda_bindings/cuda/bindings/nvvm.pxd +++ b/cuda_bindings/cuda/bindings/nvvm.pxd @@ -3,11 +3,18 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.0.1 to 13.4.0. Do not modify it directly. - # !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=64399bc158dff1d573ee582b859de69945c0aa7daca57980ad1372b441bd0fbd +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=42bff00f1f4c3a045096af6f33066dd5ec597905d19a6fbb3434f96bd9a2d6d4 + + + +# <<<< PREAMBLE CONTENT >>>> + from libc.stdint cimport intptr_t + +# <<<< END OF PREAMBLE CONTENT >>>> + from .cynvvm cimport * diff --git a/cuda_bindings/cuda/bindings/nvvm.pyx b/cuda_bindings/cuda/bindings/nvvm.pyx index fecc9c36856..bd54d1b1e59 100644 --- a/cuda_bindings/cuda/bindings/nvvm.pyx +++ b/cuda_bindings/cuda/bindings/nvvm.pyx @@ -4,19 +4,51 @@ # # This code was automatically generated across versions from 12.0.1 to 13.4.0. Do not modify it directly. # !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=c4c368f2adb8e24c25c067370ec9263cbd656df971795916276cdd859d339743 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=c70e229488a1b3c07944e0e086b17572e1c23a6176a7f63c2e54ee9756d8c29c # <<<< PREAMBLE CONTENT >>>> +cimport cpython as _cyb_cpython +from libc.stdint cimport intptr_t + from cuda.bindings._internal._fast_enum import FastEnum as _cyb_FastEnum +cdef intptr_t _cyb_get_buffer_pointer(buf, Py_ssize_t size, readonly=True) except?-1: + cdef intptr_t ptr + cdef int flags = _cyb_cpython.PyBUF_ANY_CONTIGUOUS + if not readonly: + flags |= _cyb_cpython.PyBUF_WRITABLE + cdef int status = -1 + cdef _cyb_cpython.Py_buffer view + if isinstance(buf, int): + ptr = <intptr_t>buf + else: + try: + status = _cyb_cpython.PyObject_GetBuffer(buf, &view, flags) + if size != -1: + assert view.len == size + assert view.ndim == 1 + except Exception as e: + adj = "writable " if not readonly else "" + raise ValueError( + "buf must be either a Python int representing the pointer " + f"address to a valid buffer, or a 1D contiguous {adj}" + f"buffer, of size {size}" + ) from e + else: + ptr = <intptr_t>view.buf + finally: + if status == 0: + _cyb_cpython.PyBuffer_Release(&view) + return ptr + # <<<< END OF PREAMBLE CONTENT >>>> cimport cython # NOQA -from ._internal.utils cimport (get_buffer_pointer, get_nested_resource_ptr, +from ._internal.utils cimport (get_nested_resource_ptr, nested_resource) @@ -171,7 +203,7 @@ cpdef add_module_to_program(intptr_t prog, buffer, size_t size, name): .. seealso:: `nvvmAddModuleToProgram` """ - cdef void* _buffer_ = get_buffer_pointer(buffer, size, readonly=True) + cdef void* _buffer_ = <void *>_cyb_get_buffer_pointer(buffer, size, readonly=True) if not isinstance(name, str): raise TypeError("name must be a Python str") cdef bytes _temp_name_ = (<str>name).encode() @@ -193,7 +225,7 @@ cpdef lazy_add_module_to_program(intptr_t prog, buffer, size_t size, name): .. seealso:: `nvvmLazyAddModuleToProgram` """ - cdef void* _buffer_ = get_buffer_pointer(buffer, size, readonly=True) + cdef void* _buffer_ = <void *>_cyb_get_buffer_pointer(buffer, size, readonly=True) if not isinstance(name, str): raise TypeError("name must be a Python str") cdef bytes _temp_name_ = (<str>name).encode() @@ -279,7 +311,7 @@ cpdef get_compiled_result(intptr_t prog, buffer): .. seealso:: `nvvmGetCompiledResult` """ - cdef void* _buffer_ = get_buffer_pointer(buffer, -1, readonly=False) + cdef void* _buffer_ = <void *>_cyb_get_buffer_pointer(buffer, -1, readonly=False) with nogil: __status__ = nvvmGetCompiledResult(<Program>prog, <char*>_buffer_) check_status(__status__) @@ -313,7 +345,7 @@ cpdef get_program_log(intptr_t prog, buffer): .. seealso:: `nvvmGetProgramLog` """ - cdef void* _buffer_ = get_buffer_pointer(buffer, -1, readonly=False) + cdef void* _buffer_ = <void *>_cyb_get_buffer_pointer(buffer, -1, readonly=False) with nogil: __status__ = nvvmGetProgramLog(<Program>prog, <char*>_buffer_) check_status(__status__) diff --git a/cuda_bindings/cuda/bindings/utils/__init__.py b/cuda_bindings/cuda/bindings/utils/__init__.py index 0bfff4b78be..9c29bb4dd81 100644 --- a/cuda_bindings/cuda/bindings/utils/__init__.py +++ b/cuda_bindings/cuda/bindings/utils/__init__.py @@ -27,6 +27,9 @@ def get_cuda_native_handle(obj: Any) -> int: """ obj_type = type(obj) try: - return _handle_getters[obj_type](obj) + getter = _handle_getters[obj_type] except KeyError: raise TypeError("Unknown type: " + str(obj_type)) from None + # Deliberately outside the try: a KeyError raised by the getter itself is a + # bug in that getter, not an unregistered type. + return getter(obj) diff --git a/cuda_bindings/docs/source/module/nvrtc.rst b/cuda_bindings/docs/source/module/nvrtc.rst index c4e453bee6b..d4a85257a73 100644 --- a/cuda_bindings/docs/source/module/nvrtc.rst +++ b/cuda_bindings/docs/source/module/nvrtc.rst @@ -4,7 +4,7 @@ .. This code was automatically generated with version 13.4.0. Do not modify it directly. .. !!! WARNING: THIS FILE CONTAINS PRERELEASE APIs !!! -.. CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=e81ae93eee7b54340488dc4be19f2767d6c7316292571214623473e1d8452da7 +.. CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=e76a612b65e25ae5ed1d2a8527e929bb3df7e42fb4c61e274e9fa8ec740142fa ----- nvrtc ----- @@ -129,7 +129,11 @@ NVRTC defines the following types and functions for bundled headers installation .. autofunction:: cuda.bindings.nvrtc.nvrtcRemoveBundledHeaders .. autoattribute:: cuda.bindings.nvrtc.NVRTC_INSTALL_HEADERS_SKIP_IF_EXISTS - Flags for nvrtcInstallBundledHeaders.Skip installation if version marker exists and version matches. This is the default behavior when flags=0. + Flags for nvrtcInstallBundledHeaders. + + + + Skip installation if version marker exists and version matches. This is the default behavior when flags=0. .. autoattribute:: cuda.bindings.nvrtc.NVRTC_INSTALL_HEADERS_FORCE_OVERWRITE diff --git a/cuda_bindings/examples/0_Introduction/clock_nvrtc.py b/cuda_bindings/examples/0_Introduction/clock_nvrtc.py index 14572469e79..71b30d7efb0 100644 --- a/cuda_bindings/examples/0_Introduction/clock_nvrtc.py +++ b/cuda_bindings/examples/0_Introduction/clock_nvrtc.py @@ -1,4 +1,4 @@ -# Copyright 2021-2026 NVIDIA Corporation. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2021-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: Apache-2.0 # ################################################################################ diff --git a/cuda_bindings/examples/0_Introduction/simple_cubemap_texture.py b/cuda_bindings/examples/0_Introduction/simple_cubemap_texture.py index cad35990e91..17ecb83adf5 100644 --- a/cuda_bindings/examples/0_Introduction/simple_cubemap_texture.py +++ b/cuda_bindings/examples/0_Introduction/simple_cubemap_texture.py @@ -1,4 +1,4 @@ -# Copyright 2021-2026 NVIDIA Corporation. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2021-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: Apache-2.0 # ################################################################################ diff --git a/cuda_bindings/examples/0_Introduction/simple_p2p.py b/cuda_bindings/examples/0_Introduction/simple_p2p.py index 0c6700bc8df..61b021c1793 100644 --- a/cuda_bindings/examples/0_Introduction/simple_p2p.py +++ b/cuda_bindings/examples/0_Introduction/simple_p2p.py @@ -1,4 +1,4 @@ -# Copyright 2021-2026 NVIDIA Corporation. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2021-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: Apache-2.0 # ################################################################################ diff --git a/cuda_bindings/examples/0_Introduction/simple_zero_copy.py b/cuda_bindings/examples/0_Introduction/simple_zero_copy.py index 72c5fe8b701..2c0692abcfb 100644 --- a/cuda_bindings/examples/0_Introduction/simple_zero_copy.py +++ b/cuda_bindings/examples/0_Introduction/simple_zero_copy.py @@ -1,4 +1,4 @@ -# Copyright 2021-2026 NVIDIA Corporation. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2021-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: Apache-2.0 # ################################################################################ diff --git a/cuda_bindings/examples/0_Introduction/system_wide_atomics.py b/cuda_bindings/examples/0_Introduction/system_wide_atomics.py index fde3e67ad8f..5d98a74f8a9 100644 --- a/cuda_bindings/examples/0_Introduction/system_wide_atomics.py +++ b/cuda_bindings/examples/0_Introduction/system_wide_atomics.py @@ -1,4 +1,4 @@ -# Copyright 2021-2026 NVIDIA Corporation. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2021-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: Apache-2.0 # ################################################################################ diff --git a/cuda_bindings/examples/0_Introduction/vector_add_drv.py b/cuda_bindings/examples/0_Introduction/vector_add_drv.py index d2356c0d3a1..7a987126f52 100644 --- a/cuda_bindings/examples/0_Introduction/vector_add_drv.py +++ b/cuda_bindings/examples/0_Introduction/vector_add_drv.py @@ -1,4 +1,4 @@ -# Copyright 2021-2026 NVIDIA Corporation. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2021-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: Apache-2.0 # ################################################################################ diff --git a/cuda_bindings/examples/0_Introduction/vector_add_mmap.py b/cuda_bindings/examples/0_Introduction/vector_add_mmap.py index 9faa45bedb8..2a8f4a99a1d 100644 --- a/cuda_bindings/examples/0_Introduction/vector_add_mmap.py +++ b/cuda_bindings/examples/0_Introduction/vector_add_mmap.py @@ -1,4 +1,4 @@ -# Copyright 2021-2026 NVIDIA Corporation. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2021-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: Apache-2.0 # ################################################################################ diff --git a/cuda_bindings/examples/2_Concepts_and_Techniques/stream_ordered_allocation.py b/cuda_bindings/examples/2_Concepts_and_Techniques/stream_ordered_allocation.py index b45f11f317b..5118600a493 100644 --- a/cuda_bindings/examples/2_Concepts_and_Techniques/stream_ordered_allocation.py +++ b/cuda_bindings/examples/2_Concepts_and_Techniques/stream_ordered_allocation.py @@ -1,4 +1,4 @@ -# Copyright 2021-2026 NVIDIA Corporation. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2021-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: Apache-2.0 # ################################################################################ diff --git a/cuda_bindings/examples/3_CUDA_Features/global_to_shmem_async_copy.py b/cuda_bindings/examples/3_CUDA_Features/global_to_shmem_async_copy.py index 9a2ec3dec3b..615006049fd 100644 --- a/cuda_bindings/examples/3_CUDA_Features/global_to_shmem_async_copy.py +++ b/cuda_bindings/examples/3_CUDA_Features/global_to_shmem_async_copy.py @@ -1,4 +1,4 @@ -# Copyright 2021-2026 NVIDIA Corporation. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2021-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: Apache-2.0 # ################################################################################ diff --git a/cuda_bindings/examples/3_CUDA_Features/simple_cuda_graphs.py b/cuda_bindings/examples/3_CUDA_Features/simple_cuda_graphs.py index 317a774d5df..816bc84e274 100644 --- a/cuda_bindings/examples/3_CUDA_Features/simple_cuda_graphs.py +++ b/cuda_bindings/examples/3_CUDA_Features/simple_cuda_graphs.py @@ -1,4 +1,4 @@ -# Copyright 2021-2026 NVIDIA Corporation. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2021-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: Apache-2.0 # ################################################################################ diff --git a/cuda_bindings/examples/4_CUDA_Libraries/conjugate_gradient_multi_block_cg.py b/cuda_bindings/examples/4_CUDA_Libraries/conjugate_gradient_multi_block_cg.py index 83d359b1e93..488f57d03ab 100644 --- a/cuda_bindings/examples/4_CUDA_Libraries/conjugate_gradient_multi_block_cg.py +++ b/cuda_bindings/examples/4_CUDA_Libraries/conjugate_gradient_multi_block_cg.py @@ -1,4 +1,4 @@ -# Copyright 2021-2026 NVIDIA Corporation. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2021-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: Apache-2.0 # ################################################################################ diff --git a/cuda_bindings/examples/4_CUDA_Libraries/nvidia_smi.py b/cuda_bindings/examples/4_CUDA_Libraries/nvidia_smi.py index 459022784b3..348e8c38236 100644 --- a/cuda_bindings/examples/4_CUDA_Libraries/nvidia_smi.py +++ b/cuda_bindings/examples/4_CUDA_Libraries/nvidia_smi.py @@ -1,4 +1,4 @@ -# Copyright 2026 NVIDIA Corporation. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: Apache-2.0 diff --git a/cuda_bindings/examples/extra/iso_fd_modelling.py b/cuda_bindings/examples/extra/iso_fd_modelling.py index 9fe9432862c..e1f29936a9f 100644 --- a/cuda_bindings/examples/extra/iso_fd_modelling.py +++ b/cuda_bindings/examples/extra/iso_fd_modelling.py @@ -1,4 +1,4 @@ -# Copyright 2021-2026 NVIDIA Corporation. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2021-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: Apache-2.0 # ################################################################################ diff --git a/cuda_bindings/examples/extra/jit_program.py b/cuda_bindings/examples/extra/jit_program.py index 7a5cc1495fc..ad3409c1f68 100644 --- a/cuda_bindings/examples/extra/jit_program.py +++ b/cuda_bindings/examples/extra/jit_program.py @@ -1,4 +1,4 @@ -# Copyright 2021-2026 NVIDIA Corporation. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2021-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: Apache-2.0 # ################################################################################ diff --git a/cuda_bindings/tests/nvml/test_compute_mode.py b/cuda_bindings/tests/nvml/test_compute_mode.py index 83c7827f53a..3392a71e23b 100644 --- a/cuda_bindings/tests/nvml/test_compute_mode.py +++ b/cuda_bindings/tests/nvml/test_compute_mode.py @@ -18,15 +18,28 @@ @pytest.mark.skipif(sys.platform == "win32", reason="Test not supported on Windows") -def test_compute_mode_supported_nonroot(all_devices): +def test_compute_mode_supported_nonroot(all_devices, subtests): for device in all_devices: - with unsupported_before(device, None): + device_index = nvml.device_get_index(device) + original_compute_mode = None + with ( + subtests.test(device_index=device_index, compute_mode_api="get_compute_mode"), + unsupported_before(device, None), + ): original_compute_mode = nvml.device_get_compute_mode(device) + if original_compute_mode is None: + continue for cm in COMPUTE_MODES: - try: - nvml.device_set_compute_mode(device, cm) - except nvml.NoPermissionError: - pytest.skip("Insufficient permissions to set compute mode") - nvml.device_set_compute_mode(device, original_compute_mode) - assert original_compute_mode == nvml.device_get_compute_mode(device), "Compute mode shouldn't have changed" + with subtests.test(device_index=device_index, compute_mode=cm.name): + try: + nvml.device_set_compute_mode(device, cm) + except nvml.NoPermissionError: + pytest.skip("Insufficient permissions to set compute mode") + except nvml.NvmlError: + nvml.device_set_compute_mode(device, original_compute_mode) + raise + nvml.device_set_compute_mode(device, original_compute_mode) + assert original_compute_mode == nvml.device_get_compute_mode(device), ( + "Compute mode shouldn't have changed" + ) diff --git a/cuda_bindings/tests/nvml/test_device.py b/cuda_bindings/tests/nvml/test_device.py index 0d412ab24bd..e07f8748113 100644 --- a/cuda_bindings/tests/nvml/test_device.py +++ b/cuda_bindings/tests/nvml/test_device.py @@ -39,11 +39,12 @@ def test_clk_mon_status_t(): assert not hasattr(obj, "clk_mon_list_size") -def test_current_clock_freqs(all_devices): +def test_current_clock_freqs(all_devices, subtests): for device in all_devices: - with unsupported_before(device, None): - clk_freqs = nvml.device_get_current_clock_freqs(device) - assert isinstance(clk_freqs, str) + with subtests.test(device_index=nvml.device_get_index(device)): + with unsupported_before(device, None): + clk_freqs = nvml.device_get_current_clock_freqs(device) + assert isinstance(clk_freqs, str) def test_grid_licensable_features(all_devices): @@ -71,17 +72,18 @@ def test_get_handle_by_uuidv(all_devices): assert new_handle == device -def test_get_nv_link_supported_bw_modes(all_devices): +def test_get_nv_link_supported_bw_modes(all_devices, subtests): for device in all_devices: - with unsupported_before(device, None): - modes = nvml.device_get_nvlink_supported_bw_modes(device) - assert isinstance(modes, nvml.NvlinkSupportedBwModes_v1) - # #define NVML_NVLINK_TOTAL_SUPPORTED_BW_MODES 23 - assert len(modes.bw_modes) <= 23 - assert not hasattr(modes, "total_bw_modes") + with subtests.test(device_index=nvml.device_get_index(device)): + with unsupported_before(device, None): + modes = nvml.device_get_nvlink_supported_bw_modes(device) + assert isinstance(modes, nvml.NvlinkSupportedBwModes_v1) + # #define NVML_NVLINK_TOTAL_SUPPORTED_BW_MODES 23 + assert len(modes.bw_modes) <= 23 + assert not hasattr(modes, "total_bw_modes") - for mode in modes.bw_modes: - assert isinstance(mode, np.uint8) + for mode in modes.bw_modes: + assert isinstance(mode, np.uint8) def test_device_get_pdi(all_devices): @@ -91,62 +93,70 @@ def test_device_get_pdi(all_devices): assert isinstance(pdi, int) -def test_device_get_performance_modes(all_devices): +def test_device_get_performance_modes(all_devices, subtests): for device in all_devices: - with unsupported_before(device, None): - modes = nvml.device_get_performance_modes(device) - assert isinstance(modes, str) + with subtests.test(device_index=nvml.device_get_index(device)): + with unsupported_before(device, None): + modes = nvml.device_get_performance_modes(device) + assert isinstance(modes, str) @pytest.mark.skipif(cuda_version_less_than(13010), reason="Introduced in 13.1") -def test_device_get_unrepairable_memory_flag(all_devices): +def test_device_get_unrepairable_memory_flag(all_devices, subtests): for device in all_devices: - with unsupported_before(device, None): - status = nvml.device_get_unrepairable_memory_flag_v1(device) - assert isinstance(status, int) + with subtests.test(device_index=nvml.device_get_index(device)): + with unsupported_before(device, None): + status = nvml.device_get_unrepairable_memory_flag_v1(device) + assert isinstance(status, int) -def test_device_vgpu_get_heterogeneous_mode(all_devices): +def test_device_vgpu_get_heterogeneous_mode(all_devices, subtests): for device in all_devices: - with unsupported_before(device, None): - mode = nvml.device_get_vgpu_heterogeneous_mode(device) - assert isinstance(mode, int) + with subtests.test(device_index=nvml.device_get_index(device)): + with unsupported_before(device, None): + mode = nvml.device_get_vgpu_heterogeneous_mode(device) + assert isinstance(mode, int) @pytest.mark.skipif(cuda_version_less_than(13010), reason="Introduced in 13.1") -def test_read_prm_counters(all_devices): +def test_read_prm_counters(all_devices, subtests): for device in all_devices: - counters = nvml.PRMCounter_v1(5) - with unsupported_before(device, None): - read_counters = nvml.device_read_prm_counters_v1(device, counters) - assert counters is read_counters - assert len(read_counters) == 5 + with subtests.test(device_index=nvml.device_get_index(device)): + counters = nvml.PRMCounter_v1(5) + with unsupported_before(device, None): + read_counters = nvml.device_read_prm_counters_v1(device, counters) + assert counters is read_counters + assert len(read_counters) == 5 @pytest.mark.thread_unsafe(reason="API appears to be thread-unsafe (2026-06)") -def test_read_write_prm(all_devices): +def test_read_write_prm(all_devices, subtests): for device in all_devices: - # Docs say supported in BLACKWELL or later - with unsupported_before(device, None): - try: - result = nvml.device_read_write_prm_v1(device, b"012345678") - except nvml.NoPermissionError: - pytest.skip("No permission to read/write PRM") - assert isinstance(result, tuple) - assert isinstance(result[0], int) - assert isinstance(result[1], bytes) - - -def test_get_power_management_limit(all_devices): + with subtests.test(device_index=nvml.device_get_index(device)): + # Docs say supported in BLACKWELL or later + with unsupported_before(device, None): + try: + result = nvml.device_read_write_prm_v1(device, b"012345678") + except nvml.NoPermissionError: + pytest.skip("No permission to read/write PRM") + assert isinstance(result, tuple) + assert isinstance(result[0], int) + assert isinstance(result[1], bytes) + + +def test_get_power_management_limit(all_devices, subtests): for device in all_devices: # Docs say supported on KEPLER or later - with unsupported_before(device, None): + with subtests.test(device_index=nvml.device_get_index(device)), unsupported_before(device, None): nvml.device_get_power_management_limit(device) -def test_set_power_management_limit(all_devices): +def test_set_power_management_limit(all_devices, subtests): for device in all_devices: - with unsupported_before(device, None): + with ( + subtests.test(device_index=nvml.device_get_index(device)), + unsupported_before(device, None), + ): try: nvml.device_set_power_management_limit_v2(device, nvml.PowerScope.GPU, 10000) except nvml.NoPermissionError: @@ -155,18 +165,19 @@ def test_set_power_management_limit(all_devices): pytest.skip("Invalid argument when setting power management limit -- probably unsupported") -def test_set_temperature_threshold(all_devices): +def test_set_temperature_threshold(all_devices, subtests): for device in all_devices: - # Docs say supported on MAXWELL or newer - with unsupported_before(device, None): - temp = nvml.device_get_temperature_threshold( - device, nvml.TemperatureThresholds.TEMPERATURE_THRESHOLD_ACOUSTIC_CURR - ) - try: - nvml.device_set_temperature_threshold( - device, nvml.TemperatureThresholds.TEMPERATURE_THRESHOLD_ACOUSTIC_CURR, temp - ) - except nvml.NoPermissionError: - pytest.skip("No permission to set temperature threshold") - except nvml.InvalidArgumentError: - pytest.skip("Invalid argument when setting temperature threshold -- this is probably the temp type") + with subtests.test(device_index=nvml.device_get_index(device)): + # Docs say supported on MAXWELL or newer + with unsupported_before(device, None): + temp = nvml.device_get_temperature_threshold( + device, nvml.TemperatureThresholds.TEMPERATURE_THRESHOLD_ACOUSTIC_CURR + ) + try: + nvml.device_set_temperature_threshold( + device, nvml.TemperatureThresholds.TEMPERATURE_THRESHOLD_ACOUSTIC_CURR, temp + ) + except nvml.NoPermissionError: + pytest.skip("No permission to set temperature threshold") + except nvml.InvalidArgumentError: + pytest.skip("Invalid argument when setting temperature threshold -- this is probably the temp type") diff --git a/cuda_bindings/tests/nvml/test_gpu.py b/cuda_bindings/tests/nvml/test_gpu.py index 6757e4760f1..74d4f7489dc 100644 --- a/cuda_bindings/tests/nvml/test_gpu.py +++ b/cuda_bindings/tests/nvml/test_gpu.py @@ -10,7 +10,7 @@ from .conftest import unsupported_before -def test_gpu_get_module_id(nvml_init): +def test_gpu_get_module_id(nvml_init, subtests): # Unique module IDs cannot exceed the number of GPUs on the system device_count = nvml.device_get_count_v2() @@ -21,23 +21,25 @@ def test_gpu_get_module_id(nvml_init): if util.is_vgpu(device): continue - with unsupported_before(device, None): - module_id = nvml.device_get_module_id(device) - assert isinstance(module_id, int) + with subtests.test(device_index=i): + with unsupported_before(device, None): + module_id = nvml.device_get_module_id(device) + assert isinstance(module_id, int) -def test_gpu_get_platform_info(all_devices): +def test_gpu_get_platform_info(all_devices, subtests): for device in all_devices: - if util.is_vgpu(device): - pytest.skip(f"Not supported on vGPU device {device}") + with subtests.test(device_index=nvml.device_get_index(device)): + if util.is_vgpu(device): + pytest.skip(f"Not supported on vGPU device {device}") - # Documentation says Blackwell or newer only, but this does seem to pass - # on some newer GPUs. + # Documentation says Blackwell or newer only, but this does seem to pass + # on some newer GPUs. - with unsupported_before(device, None): - platform_info = nvml.device_get_platform_info(device) + with unsupported_before(device, None): + platform_info = nvml.device_get_platform_info(device) - assert isinstance(platform_info, (nvml.PlatformInfo_v1, nvml.PlatformInfo_v2)) + assert isinstance(platform_info, (nvml.PlatformInfo_v1, nvml.PlatformInfo_v2)) # TODO: Test APIs related to GPU instances, which require specific hardware and root @@ -58,10 +60,14 @@ def test_conf_compute_attestation_report_t(all_devices): assert report.nonce.dtype == np.uint8 -def test_gpu_conf_compute_attestation_report(all_devices): +def test_gpu_conf_compute_attestation_report(all_devices, subtests): for device in all_devices: # Documentation says AMPERE or newer - with unsupported_before(device, None), pytest.raises(nvml.UnknownError): + with ( + subtests.test(device_index=nvml.device_get_index(device)), + unsupported_before(device, None), + pytest.raises(nvml.UnknownError), + ): # The nonce string is nonsensical, so if this "works", we expect an UnknownError nvml.device_get_conf_compute_gpu_attestation_report(device, nonce=b"12345678") @@ -74,9 +80,13 @@ def test_conf_compute_gpu_certificate_t(): assert len(cert.attestation_cert_chain) == 0 -def test_conf_compute_gpu_certificate(all_devices): +def test_conf_compute_gpu_certificate(all_devices, subtests): for device in all_devices: # Documentation says AMPERE or newer - with unsupported_before(device, None), pytest.raises(nvml.UnknownError): + with ( + subtests.test(device_index=nvml.device_get_index(device)), + unsupported_before(device, None), + pytest.raises(nvml.UnknownError), + ): # This is expected to fail if the device doesn't have a proper certificate nvml.device_get_conf_compute_gpu_certificate(device) diff --git a/cuda_bindings/tests/nvml/test_pci.py b/cuda_bindings/tests/nvml/test_pci.py index 74c7a65a655..877f9d2998a 100644 --- a/cuda_bindings/tests/nvml/test_pci.py +++ b/cuda_bindings/tests/nvml/test_pci.py @@ -9,12 +9,13 @@ from .conftest import unsupported_before -def test_discover_gpus(all_devices): +def test_discover_gpus(all_devices, subtests): for device in all_devices: - pci_info = nvml.device_get_pci_info_v3(device) - # Docs say this should be supported on PASCAL and later - with unsupported_before(device, None), contextlib.suppress(nvml.OperatingSystemError): - nvml.device_discover_gpus(pci_info.ptr) + with subtests.test(device_index=nvml.device_get_index(device)): + pci_info = nvml.device_get_pci_info_v3(device) + # Docs say this should be supported on PASCAL and later + with unsupported_before(device, None), contextlib.suppress(nvml.OperatingSystemError): + nvml.device_discover_gpus(pci_info.ptr) def test_bridge_chip_hierarchy_t(): @@ -24,12 +25,13 @@ def test_bridge_chip_hierarchy_t(): assert isinstance(hierarchy.bridge_chip_info, nvml.BridgeChipInfo) -def test_bridge_chip_info(all_devices): +def test_bridge_chip_info(all_devices, subtests): for device in all_devices: - with unsupported_before(device, None): - info = nvml.device_get_bridge_chip_info(device) - assert isinstance(info, nvml.BridgeChipHierarchy) - for entry in info.bridge_chip_info: - assert isinstance(entry, nvml.BridgeChipInfo) - assert isinstance(entry.type, int) - assert isinstance(entry.fw_version, int) + with subtests.test(device_index=nvml.device_get_index(device)): + with unsupported_before(device, None): + info = nvml.device_get_bridge_chip_info(device) + assert isinstance(info, nvml.BridgeChipHierarchy) + for entry in info.bridge_chip_info: + assert isinstance(entry, nvml.BridgeChipInfo) + assert isinstance(entry.type, int) + assert isinstance(entry.fw_version, int) diff --git a/cuda_bindings/tests/nvml/test_pynvml.py b/cuda_bindings/tests/nvml/test_pynvml.py index 64a08fbf5c9..2a753291351 100644 --- a/cuda_bindings/tests/nvml/test_pynvml.py +++ b/cuda_bindings/tests/nvml/test_pynvml.py @@ -72,24 +72,26 @@ def test_device_get_handle_by_pci_bus_id(ngpus): @pytest.mark.parametrize("scope", [nvml.AffinityScope.NODE, nvml.AffinityScope.SOCKET]) @pytest.mark.skipif(IS_WSL or IS_WINDOWS, reason="Not supported on WSL or Windows") -def test_device_get_memory_affinity(handles, scope): +def test_device_get_memory_affinity(handles, scope, subtests): size = 1024 - for handle in handles: - with unsupported_before(handle, nvml.DeviceArch.KEPLER): - node_set = nvml.device_get_memory_affinity(handle, size, scope) - assert node_set is not None - assert len(node_set) == size + for device_index, handle in enumerate(handles): + with subtests.test(device_index=device_index): + with unsupported_before(handle, nvml.DeviceArch.KEPLER): + node_set = nvml.device_get_memory_affinity(handle, size, scope) + assert node_set is not None + assert len(node_set) == size @pytest.mark.parametrize("scope", [nvml.AffinityScope.NODE, nvml.AffinityScope.SOCKET]) @pytest.mark.skipif(IS_WSL or IS_WINDOWS, reason="Not supported on WSL or Windows") -def test_device_get_cpu_affinity_within_scope(handles, scope): +def test_device_get_cpu_affinity_within_scope(handles, scope, subtests): size = 1024 - for handle in handles: - with unsupported_before(handle, nvml.DeviceArch.KEPLER): - cpu_set = nvml.device_get_cpu_affinity_within_scope(handle, size, scope) - assert cpu_set is not None - assert len(cpu_set) == size + for device_index, handle in enumerate(handles): + with subtests.test(device_index=device_index): + with unsupported_before(handle, nvml.DeviceArch.KEPLER): + cpu_set = nvml.device_get_cpu_affinity_within_scope(handle, size, scope) + assert cpu_set is not None + assert len(cpu_set) == size @pytest.mark.parametrize( @@ -150,29 +152,31 @@ def test_device_get_p2p_status(handles, index): # [Skipping] pynvml.nvmlDeviceGetEnforcedPowerLimit -def test_device_get_power_usage(ngpus, handles): +def test_device_get_power_usage(ngpus, handles, subtests): for i in range(ngpus): - # Note: documentation says this is supported on Fermi or newer, - # but in practice it fails on some later architectures. - with unsupported_before(handles[i], None): - power_mwatts = nvml.device_get_power_usage(handles[i]) - assert power_mwatts >= 0.0 + with subtests.test(device_index=i): + # Note: documentation says this is supported on Fermi or newer, + # but in practice it fails on some later architectures. + with unsupported_before(handles[i], None): + power_mwatts = nvml.device_get_power_usage(handles[i]) + assert power_mwatts >= 0.0 -def test_device_get_total_energy_consumption(ngpus, handles): +def test_device_get_total_energy_consumption(ngpus, handles, subtests): for i in range(ngpus): - with unsupported_before(handles[i], None): - energy_mjoules1 = nvml.device_get_total_energy_consumption(handles[i]) - - for j in range(10): # idle for 150 ms - time.sleep(0.015) # and check for increase every 15 ms + with subtests.test(device_index=i): with unsupported_before(handles[i], None): - energy_mjoules2 = nvml.device_get_total_energy_consumption(handles[i]) - assert energy_mjoules2 >= energy_mjoules1 - if energy_mjoules2 > energy_mjoules1: - break - else: - raise AssertionError("energy did not increase across 150 ms interval") + energy_mjoules1 = nvml.device_get_total_energy_consumption(handles[i]) + + for _ in range(10): # idle for 150 ms + time.sleep(0.015) # and check for increase every 15 ms + with unsupported_before(handles[i], None): + energy_mjoules2 = nvml.device_get_total_energy_consumption(handles[i]) + assert energy_mjoules2 >= energy_mjoules1 + if energy_mjoules2 > energy_mjoules1: + break + else: + raise AssertionError("energy did not increase across 150 ms interval") # [Skipping] pynvml.nvmlDeviceGetGpuOperationMode @@ -180,11 +184,12 @@ def test_device_get_total_energy_consumption(ngpus, handles): # [Skipping] pynvml.nvmlDeviceGetPendingGpuOperationMode -def test_device_get_memory_info(ngpus, handles): +def test_device_get_memory_info(ngpus, handles, subtests): for i in range(ngpus): - with unsupported_before(handles[i], None): - meminfo = nvml.device_get_memory_info_v2(handles[i]) - assert (meminfo.used <= meminfo.total) and (meminfo.free <= meminfo.total) + with subtests.test(device_index=i): + with unsupported_before(handles[i], None): + meminfo = nvml.device_get_memory_info_v2(handles[i]) + assert (meminfo.used <= meminfo.total) and (meminfo.free <= meminfo.total) # [Skipping] pynvml.nvmlDeviceGetBAR1MemoryInfo @@ -197,12 +202,13 @@ def test_device_get_memory_info(ngpus, handles): # [Skipping] pynvml.nvmlDeviceGetMemoryErrorCounter -def test_device_get_utilization_rates(ngpus, handles): +def test_device_get_utilization_rates(ngpus, handles, subtests): for i in range(ngpus): - with unsupported_before(handles[i], None): - urate = nvml.device_get_utilization_rates(handles[i]) - assert urate.gpu >= 0 - assert urate.memory >= 0 + with subtests.test(device_index=i): + with unsupported_before(handles[i], None): + urate = nvml.device_get_utilization_rates(handles[i]) + assert urate.gpu >= 0 + assert urate.memory >= 0 # [Skipping] pynvml.nvmlDeviceGetEncoderUtilization @@ -255,14 +261,15 @@ def test_device_get_utilization_rates(ngpus, handles): # [Skipping] pynvml.nvmlDeviceGetViolationStatus -def test_device_get_pcie_throughput(ngpus, handles): +def test_device_get_pcie_throughput(ngpus, handles, subtests): for i in range(ngpus): - with unsupported_before(handles[i], None): - tx_bytes_tp = nvml.device_get_pcie_throughput(handles[i], nvml.PcieUtilCounter.PCIE_UTIL_TX_BYTES) - assert tx_bytes_tp >= 0 - with unsupported_before(handles[i], None): - rx_bytes_tp = nvml.device_get_pcie_throughput(handles[i], nvml.PcieUtilCounter.PCIE_UTIL_RX_BYTES) - assert rx_bytes_tp >= 0 + with subtests.test(device_index=i): + with unsupported_before(handles[i], None): + tx_bytes_tp = nvml.device_get_pcie_throughput(handles[i], nvml.PcieUtilCounter.PCIE_UTIL_TX_BYTES) + assert tx_bytes_tp >= 0 + with unsupported_before(handles[i], None): + rx_bytes_tp = nvml.device_get_pcie_throughput(handles[i], nvml.PcieUtilCounter.PCIE_UTIL_RX_BYTES) + assert rx_bytes_tp >= 0 # with pytest.raises(nvml.InvalidArgumentError): # nvml.device_get_pcie_throughput(handles[i], nvml.PcieUtilCounter.PCIE_UTIL_COUNT) diff --git a/cuda_bindings/tests/nvml/test_util.py b/cuda_bindings/tests/nvml/test_util.py new file mode 100644 index 00000000000..2eb46647777 --- /dev/null +++ b/cuda_bindings/tests/nvml/test_util.py @@ -0,0 +1,28 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 + + +import pytest + +from cuda.bindings import nvml + +from . import util + + +class _FakeFieldValue: + nvml_return = nvml.Return.SUCCESS + + +@pytest.mark.agent_authored(model="claude-opus-5") +def test_supports_nvlink_queries_a_real_field_id(monkeypatch): + """The helper has to name an enum that exists; nvml.FI never did.""" + queried = {} + + def fake_device_get_field_values(device, fields): + queried["field_id"] = fields[0].field_id + return [_FakeFieldValue()] + + monkeypatch.setattr(nvml, "device_get_field_values", fake_device_get_field_values) + + assert util.supports_nvlink(object()) is True + assert queried["field_id"] == nvml.FieldId.DEV_NVLINK_GET_STATE diff --git a/cuda_bindings/tests/nvml/util.py b/cuda_bindings/tests/nvml/util.py index 129ded8f83c..7d63a141706 100644 --- a/cuda_bindings/tests/nvml/util.py +++ b/cuda_bindings/tests/nvml/util.py @@ -22,5 +22,5 @@ def supports_ecc(device): def supports_nvlink(device): fields = nvml.FieldValue(1) - fields[0].field_id = nvml.FI.DEV_NVLINK_GET_STATE + fields[0].field_id = nvml.FieldId.DEV_NVLINK_GET_STATE return nvml.device_get_field_values(device, fields)[0].nvml_return == nvml.Return.SUCCESS diff --git a/cuda_bindings/tests/test_cudart.py b/cuda_bindings/tests/test_cudart.py index 12d6d4352ca..53702280679 100644 --- a/cuda_bindings/tests/test_cudart.py +++ b/cuda_bindings/tests/test_cudart.py @@ -34,7 +34,16 @@ def supportsSparseTexturesDeviceFilter(): def supportsCudaAPI(name): - return name in dir(cuda) or dir(cudart) + return name in dir(cuda) or name in dir(cudart) + + +@pytest.mark.agent_authored(model="claude-opus-5") +def test_supportsCudaAPI(): + # Guards the operator precedence: `name in dir(cuda) or dir(cudart)` parses + # as `(name in dir(cuda)) or dir(cudart)`, which is truthy for every name. + assert supportsCudaAPI("cudaMalloc") is True # runtime module + assert supportsCudaAPI("cuInit") is True # driver module + assert supportsCudaAPI("this_is_not_a_cuda_api") is False def test_cudart_memcpy(): diff --git a/cuda_bindings/tests/test_utils.py b/cuda_bindings/tests/test_utils.py index c767996bced..84f7ca7b722 100644 --- a/cuda_bindings/tests/test_utils.py +++ b/cuda_bindings/tests/test_utils.py @@ -115,6 +115,27 @@ def test_get_handle_error(target): handle = get_cuda_native_handle(target) +@pytest.mark.agent_authored(model="claude-opus-5") +def test_get_handle_does_not_report_a_registered_type_as_unknown(monkeypatch): + """A KeyError from inside a handle getter is a bug in that getter. + + Reporting it as "Unknown type" is wrong twice over: the type *is* + registered, and `from None` hides the traceback that would say otherwise. + """ + from cuda.bindings.utils import _handle_getters + + class Registered: + pass + + def getter(_obj): + raise KeyError("lookup inside the getter failed") + + monkeypatch.setitem(_handle_getters, Registered, getter) + + with pytest.raises(KeyError, match="lookup inside the getter failed"): + get_cuda_native_handle(Registered()) + + @pytest.mark.parametrize( "module", # Top-level modules for external Python use diff --git a/cuda_core/AGENTS.md b/cuda_core/AGENTS.md index 83c96800e9d..9d80ab74aaa 100644 --- a/cuda_core/AGENTS.md +++ b/cuda_core/AGENTS.md @@ -151,6 +151,13 @@ a `StrEnum` is accepted as an argument, a `str` should also be acceptable. An invalid value should raise an exception. When a function returns a `str` drawn from a small number of values, return a `StrEnum` subclass instead. +For `__post_init__` validation in frozen dataclasses, use the +`not isinstance(value, EnumType) → try EnumType(value) except (ValueError, +TypeError)` pattern (modelled on `_normalize_enum` in +`cuda/core/texture/_texture.pyx`). This accepts the enum itself or a valid +string, and raises `ValueError` eagerly for any other type rather than +silently storing it. + ### Exception handling Raising exceptions is preferred over a C-style return code that must be checked diff --git a/cuda_core/LICENSE b/cuda_core/LICENSE index d6f74778be8..f3fe76ecadf 100644 --- a/cuda_core/LICENSE +++ b/cuda_core/LICENSE @@ -176,3 +176,28 @@ Copyright (c) 2024-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/cuda_core/NOTICE b/cuda_core/NOTICE index c4625e23899..f58d516a4ba 100644 --- a/cuda_core/NOTICE +++ b/cuda_core/NOTICE @@ -11,3 +11,20 @@ DLPack Copyright (c) 2017 by Contributors Licensed under the Apache License, Version 2.0. Source: https://github.com/dmlc/dlpack +Vendored at: cuda/core/_include/dlpack.h + +PyTorch +Copyright (c) 2016- Facebook, Inc (Adam Paszke) +Copyright (c) 2014- Facebook, Inc (Soumith Chintala) +Copyright (c) 2011-2014 Idiap Research Institute (Ronan Collobert) +Copyright (c) 2012-2014 Deepmind Technologies (Koray Kavukcuoglu) +Copyright (c) 2011-2012 NEC Laboratories America (Koray Kavukcuoglu) +Copyright (c) 2011-2013 NYU (Clement Farabet) +Copyright (c) 2006-2010 NEC Laboratories America (Ronan Collobert, Leon Bottou, Iain Melvin, Jason Weston) +Copyright (c) 2006 Idiap Research Institute (Samy Bengio) +Copyright (c) 2001-2004 Idiap Research Institute (Ronan Collobert, Samy Bengio, Johnny Mariethoz) +Licensed under the BSD 3-Clause License. +Source: https://github.com/pytorch/pytorch +Vendored at: cuda/core/_include/aoti_shim.h, and the accompanying +cuda/core/_include/aoti_shim.def, which declares the same AOT Inductor +stable C ABI symbol names for the MSVC linker on Windows. diff --git a/cuda_core/cuda/core/__init__.py b/cuda_core/cuda/core/__init__.py index b9a36e3dee7..7864ae794ca 100644 --- a/cuda_core/cuda/core/__init__.py +++ b/cuda_core/cuda/core/__init__.py @@ -36,12 +36,17 @@ def _patch_rlcompleter_for_cython_properties() -> None: # which rlcompleter's narrow isinstance(..., property) check misses; the # fallback getattr() then invokes the descriptor and any non-AttributeError # it raises kills tab completion. Extend that isinstance check to also - # match getset_descriptor / member_descriptor. Only installed in - # interactive mode so library users running scripts see no global - # rlcompleter side effect. + # match getset_descriptor / member_descriptor. Installed unconditionally + # (the patch is scoped to the rlcompleter module, so non-interactive users + # only pay for the import). import os - if int(os.environ.get("CUDA_CORE_DONT_FIX_TAB_COMPLETION", "0")): + raw_opt_out = os.environ.get("CUDA_CORE_DONT_FIX_TAB_COMPLETION", "").strip() + try: + opt_out = int(raw_opt_out) != 0 + except ValueError: + opt_out = raw_opt_out != "" + if opt_out: # Explicit opt-out for users who don't want the global rlcompleter # side effect, even in an interactive session. return diff --git a/cuda_core/cuda/core/_cpp/resource_handles.cpp b/cuda_core/cuda/core/_cpp/resource_handles.cpp index ef1b8d0f2f8..ed6e630b9d9 100644 --- a/cuda_core/cuda/core/_cpp/resource_handles.cpp +++ b/cuda_core/cuda/core/_cpp/resource_handles.cpp @@ -9,12 +9,14 @@ #include <atomic> #include <array> #include <cstdint> +#include <cstdio> #include <cstdlib> #include <cstring> #include <list> #include <map> #include <mutex> #include <stdexcept> +#include <thread> #include <unordered_map> #include <vector> @@ -34,6 +36,7 @@ namespace cuda_core { decltype(&cuDevicePrimaryCtxRetain) p_cuDevicePrimaryCtxRetain = nullptr; decltype(&cuDevicePrimaryCtxRelease) p_cuDevicePrimaryCtxRelease = nullptr; decltype(&cuCtxGetCurrent) p_cuCtxGetCurrent = nullptr; +decltype(&cuCtxSetCurrent) p_cuCtxSetCurrent = nullptr; decltype(&cuGreenCtxCreate) p_cuGreenCtxCreate = nullptr; decltype(&cuGreenCtxDestroy) p_cuGreenCtxDestroy = nullptr; decltype(&cuCtxFromGreenCtx) p_cuCtxFromGreenCtx = nullptr; @@ -190,6 +193,53 @@ class GILAcquireGuard { bool acquired_; }; +// Temporarily make a context current, restoring the caller's prior binding +// (including having no context current) on scope exit. The handle is held for +// the duration so the context cannot be destroyed mid-scope. +class ScopedCurrentContext { +public: + explicit ScopedCurrentContext(ContextHandle h_context) noexcept + : h_context_(std::move(h_context)) { + CUcontext target = as_cu(h_context_); + if (!target) { + return; + } + + GILReleaseGuard gil; + status_ = p_cuCtxGetCurrent(&previous_); + if (status_ != CUDA_SUCCESS || previous_ == target) { + return; + } + status_ = p_cuCtxSetCurrent(target); + changed_ = status_ == CUDA_SUCCESS; + } + + ~ScopedCurrentContext() { + if (changed_) { + GILReleaseGuard gil; + CUresult status = p_cuCtxSetCurrent(previous_); + if (status != CUDA_SUCCESS) { + std::fprintf( + stderr, + "Warning: cuCtxSetCurrent (restoring the caller's context) " + "failed (CUDA error %d)\n", + static_cast<int>(status)); + } + } + } + + CUresult status() const noexcept { return status_; } + + ScopedCurrentContext(const ScopedCurrentContext&) = delete; + ScopedCurrentContext& operator=(const ScopedCurrentContext&) = delete; + +private: + ContextHandle h_context_; + CUcontext previous_ = nullptr; + bool changed_ = false; + CUresult status_ = CUDA_SUCCESS; +}; + } // namespace // ============================================================================ @@ -726,6 +776,97 @@ StreamHandle get_per_thread_stream() { return handle; } +// ============================================================================ +// Deallocation streams +// +// A DeallocationStream is a StreamHandle used for ordering frees. It differs +// from an ordinary StreamHandle only for default-stream tokens, for which it +// stores the (de)allocation context. Ordinarily, the LEGACY and PER_THREAD +// default streams resolve to whichever context is active at the time they are +// used, but for storing deallocation recipes we need to pin the context. With +// the PER_THREAD token, it is not possible to restore the original stream when +// deallocation runs on a different thread. Therefore, in that case the +// allocating host thread id is also stored so that cross-thread frees can be +// detected and warnings can be issued. +// ============================================================================ + +// ptds_tid is std::thread::id{} except for CU_STREAM_PER_THREAD. +struct DeallocationStream { + StreamHandle h_stream; + std::thread::id ptds_tid{}; +}; + +// Real streams are copied unchanged. Default-stream tokens without an embedded +// context are bound to the current context. Returns false (and sets err) when a +// default-stream token cannot be bound because no context is current. +static bool make_deallocation_stream( + const StreamHandle& h, DeallocationStream& out) noexcept { + out = {}; + if (!h) { + return true; + } + + const CUstream stream = as_cu(h); + if (stream != nullptr + && stream != CU_STREAM_LEGACY + && stream != CU_STREAM_PER_THREAD) { + out = DeallocationStream{h, {}}; + return true; + } + + StreamHandle h_bound = h; + if (!get_stream_context(h)) { + ContextHandle h_ctx = get_current_context(); + if (!h_ctx) { + if (err == CUDA_SUCCESS) { + err = CUDA_ERROR_INVALID_CONTEXT; + } + return false; + } + // Do not register in stream_registry: the token value alone is not + // a unique stream identity (context is part of the meaning). + auto box = std::shared_ptr<const StreamBox>( + new StreamBox{stream, h_ctx}); + h_bound = StreamHandle(box, &box->resource); + } + + std::thread::id ptds_tid{}; + if (stream == CU_STREAM_PER_THREAD) { + ptds_tid = std::this_thread::get_id(); + } + out = DeallocationStream{std::move(h_bound), ptds_tid}; + return true; +} + +template <typename Fn> +CUresult with_deallocation_context( + const DeallocationStream& stream, + const char* operation, + Fn&& fn) noexcept { + if (stream.ptds_tid != std::thread::id{} + && stream.ptds_tid != std::this_thread::get_id()) { + std::fprintf( + stderr, + "Warning: Buffer deallocation for a per-thread default stream " + "is running on a different host thread than the one that recorded " + "the deallocation stream; ordering relative to the allocating " + "thread's PTDS is not preserved\n"); + } + ScopedCurrentContext context(get_stream_context(stream.h_stream)); + CUresult status = context.status(); + if (status == CUDA_SUCCESS) { + status = fn(stream); + } + if (status != CUDA_SUCCESS) { + std::fprintf( + stderr, + "Warning: %s failed during resource destruction (CUDA error %d)\n", + operation, + static_cast<int>(status)); + } + return status; +} + // ============================================================================ // Event Handles // ============================================================================ @@ -913,10 +1054,10 @@ MemoryPoolHandle create_mempool_handle_ipc(int fd, CUmemAllocationHandleType han namespace { struct DevicePtrBox { CUdeviceptr resource; - // Mutable to allow set_deallocation_stream() to update the stream - // through a const DevicePtrHandle. The stream can be changed after - // allocation (e.g., to synchronize deallocation with a different stream). - mutable StreamHandle h_stream; + // Mutable so set_deallocation_stream() can update free ordering through a + // const DevicePtrHandle. Built with make_deallocation_stream so default- + // stream tokens carry a bound context. + mutable DeallocationStream deallocation; }; } // namespace @@ -924,7 +1065,7 @@ struct DevicePtrBox { // This works because DevicePtrHandle is a shared_ptr alias pointing to // &box->resource, so we can compute the containing struct using offsetof. // The const_cast is safe because we only use this to access the mutable -// h_stream member or in the deleter (where the box is being destroyed). +// deallocation member or in the deleter (where the box is being destroyed). static DevicePtrBox* get_box(const DevicePtrHandle& h) { const CUdeviceptr* p = h.get(); return reinterpret_cast<DevicePtrBox*>( @@ -933,11 +1074,20 @@ static DevicePtrBox* get_box(const DevicePtrHandle& h) { } StreamHandle deallocation_stream(const DevicePtrHandle& h) noexcept { - return get_box(h)->h_stream; + return get_box(h)->deallocation.h_stream; } -void set_deallocation_stream(const DevicePtrHandle& h, const StreamHandle& h_stream) noexcept { - get_box(h)->h_stream = h_stream; +CUresult set_deallocation_stream( + const DevicePtrHandle& h, const StreamHandle& h_stream) noexcept { + if (!h) { + return CUDA_ERROR_INVALID_VALUE; + } + DeallocationStream ds; + if (!make_deallocation_stream(h_stream, ds)) { + return err != CUDA_SUCCESS ? err : CUDA_ERROR_INVALID_CONTEXT; + } + get_box(h)->deallocation = std::move(ds); + return CUDA_SUCCESS; } DevicePtrHandle deviceptr_alloc_from_pool(size_t size, const MemoryPoolHandle& h_pool, const StreamHandle& h_stream) { @@ -947,11 +1097,23 @@ DevicePtrHandle deviceptr_alloc_from_pool(size_t size, const MemoryPoolHandle& h return {}; } + DeallocationStream ds; + if (!make_deallocation_stream(h_stream, ds)) { + p_cuMemFreeAsync(ptr, as_cu(h_stream)); + return {}; + } + auto box = std::shared_ptr<DevicePtrBox>( - new DevicePtrBox{ptr, h_stream}, + new DevicePtrBox{ptr, std::move(ds)}, [h_pool](DevicePtrBox* b) { GILReleaseGuard gil; - p_cuMemFreeAsync(b->resource, as_cu(b->h_stream)); + with_deallocation_context( + b->deallocation, + "cuMemFreeAsync", + [b](const DeallocationStream& stream) { + return p_cuMemFreeAsync( + b->resource, as_cu(stream.h_stream)); + }); delete b; } ); @@ -965,11 +1127,23 @@ DevicePtrHandle deviceptr_alloc_async(size_t size, const StreamHandle& h_stream) return {}; } + DeallocationStream ds; + if (!make_deallocation_stream(h_stream, ds)) { + p_cuMemFreeAsync(ptr, as_cu(h_stream)); + return {}; + } + auto box = std::shared_ptr<DevicePtrBox>( - new DevicePtrBox{ptr, h_stream}, + new DevicePtrBox{ptr, std::move(ds)}, [](DevicePtrBox* b) { GILReleaseGuard gil; - p_cuMemFreeAsync(b->resource, as_cu(b->h_stream)); + with_deallocation_context( + b->deallocation, + "cuMemFreeAsync", + [b](const DeallocationStream& stream) { + return p_cuMemFreeAsync( + b->resource, as_cu(stream.h_stream)); + }); delete b; } ); @@ -984,7 +1158,7 @@ DevicePtrHandle deviceptr_alloc(size_t size) { } auto box = std::shared_ptr<DevicePtrBox>( - new DevicePtrBox{ptr, StreamHandle{}}, + new DevicePtrBox{ptr, DeallocationStream{}}, [](DevicePtrBox* b) { GILReleaseGuard gil; p_cuMemFree(b->resource); @@ -1002,7 +1176,7 @@ DevicePtrHandle deviceptr_alloc_host(size_t size) { } auto box = std::shared_ptr<DevicePtrBox>( - new DevicePtrBox{reinterpret_cast<CUdeviceptr>(ptr), StreamHandle{}}, + new DevicePtrBox{reinterpret_cast<CUdeviceptr>(ptr), DeallocationStream{}}, [](DevicePtrBox* b) { GILReleaseGuard gil; p_cuMemFreeHost(reinterpret_cast<void*>(b->resource)); @@ -1013,7 +1187,7 @@ DevicePtrHandle deviceptr_alloc_host(size_t size) { } DevicePtrHandle deviceptr_create_ref(CUdeviceptr ptr) { - auto box = std::make_shared<DevicePtrBox>(DevicePtrBox{ptr, StreamHandle{}}); + auto box = std::make_shared<DevicePtrBox>(DevicePtrBox{ptr, DeallocationStream{}}); return DevicePtrHandle(box, &box->resource); } @@ -1029,7 +1203,7 @@ DevicePtrHandle deviceptr_create_with_owner(CUdeviceptr ptr, PyObject* owner) { } Py_INCREF(owner); auto box = std::shared_ptr<DevicePtrBox>( - new DevicePtrBox{ptr, StreamHandle{}}, + new DevicePtrBox{ptr, DeallocationStream{}}, [owner](DevicePtrBox* b) { GILAcquireGuard gil; if (gil.acquired()) { @@ -1046,12 +1220,22 @@ DevicePtrHandle deviceptr_create_mapped_graphics( const GraphicsResourceHandle& h_resource, const StreamHandle& h_stream ) { + DeallocationStream ds; + if (!make_deallocation_stream(h_stream, ds)) { + return {}; + } auto box = std::shared_ptr<DevicePtrBox>( - new DevicePtrBox{ptr, h_stream}, + new DevicePtrBox{ptr, std::move(ds)}, [h_resource](DevicePtrBox* b) { GILReleaseGuard gil; CUgraphicsResource resource = as_cu(h_resource); - p_cuGraphicsUnmapResources(1, &resource, as_cu(b->h_stream)); + with_deallocation_context( + b->deallocation, + "cuGraphicsUnmapResources", + [b, &resource](const DeallocationStream& stream) { + return p_cuGraphicsUnmapResources( + 1, &resource, as_cu(stream.h_stream)); + }); delete b; } ); @@ -1079,12 +1263,19 @@ DevicePtrHandle deviceptr_create_with_mr(CUdeviceptr ptr, size_t size, PyObject* } Py_INCREF(mr); auto box = std::shared_ptr<DevicePtrBox>( - new DevicePtrBox{ptr, StreamHandle{}}, + new DevicePtrBox{ptr, DeallocationStream{}}, [mr, size](DevicePtrBox* b) { GILAcquireGuard gil; if (gil.acquired()) { if (mr_dealloc_cb) { - mr_dealloc_cb(mr, b->resource, size, b->h_stream); + with_deallocation_context( + b->deallocation, + "MemoryResource deallocate", + [mr, size, b](const DeallocationStream& stream) { + mr_dealloc_cb( + mr, b->resource, size, stream.h_stream); + return CUDA_SUCCESS; + }); } Py_DECREF(mr); } @@ -1172,12 +1363,24 @@ DevicePtrHandle deviceptr_import_ipc(const MemoryPoolHandle& h_pool, const void* return {}; } + DeallocationStream ds; + if (!make_deallocation_stream(h_stream, ds)) { + p_cuMemFreeAsync(ptr, as_cu(h_stream)); + return {}; + } + auto box = std::shared_ptr<DevicePtrBox>( - new DevicePtrBox{ptr, h_stream}, + new DevicePtrBox{ptr, std::move(ds)}, [h_pool, key](DevicePtrBox* b) { ipc_ptr_cache.unregister_handle(key); GILReleaseGuard gil; - p_cuMemFreeAsync(b->resource, as_cu(b->h_stream)); + with_deallocation_context( + b->deallocation, + "cuMemFreeAsync", + [b](const DeallocationStream& stream) { + return p_cuMemFreeAsync( + b->resource, as_cu(stream.h_stream)); + }); delete b; } ); @@ -1192,11 +1395,23 @@ DevicePtrHandle deviceptr_import_ipc(const MemoryPoolHandle& h_pool, const void* return {}; } + DeallocationStream ds; + if (!make_deallocation_stream(h_stream, ds)) { + p_cuMemFreeAsync(ptr, as_cu(h_stream)); + return {}; + } + auto box = std::shared_ptr<DevicePtrBox>( - new DevicePtrBox{ptr, h_stream}, + new DevicePtrBox{ptr, std::move(ds)}, [h_pool](DevicePtrBox* b) { GILReleaseGuard gil; - p_cuMemFreeAsync(b->resource, as_cu(b->h_stream)); + with_deallocation_context( + b->deallocation, + "cuMemFreeAsync", + [b](const DeallocationStream& stream) { + return p_cuMemFreeAsync( + b->resource, as_cu(stream.h_stream)); + }); delete b; } ); diff --git a/cuda_core/cuda/core/_cpp/resource_handles.hpp b/cuda_core/cuda/core/_cpp/resource_handles.hpp index 6a1a0edd6c7..a55353bb0ec 100644 --- a/cuda_core/cuda/core/_cpp/resource_handles.hpp +++ b/cuda_core/cuda/core/_cpp/resource_handles.hpp @@ -67,6 +67,7 @@ void clear_last_error() noexcept; extern decltype(&cuDevicePrimaryCtxRetain) p_cuDevicePrimaryCtxRetain; extern decltype(&cuDevicePrimaryCtxRelease) p_cuDevicePrimaryCtxRelease; extern decltype(&cuCtxGetCurrent) p_cuCtxGetCurrent; +extern decltype(&cuCtxSetCurrent) p_cuCtxSetCurrent; extern decltype(&cuGreenCtxCreate) p_cuGreenCtxCreate; extern decltype(&cuGreenCtxDestroy) p_cuGreenCtxDestroy; extern decltype(&cuCtxFromGreenCtx) p_cuCtxFromGreenCtx; @@ -423,7 +424,10 @@ DevicePtrHandle deviceptr_import_ipc( StreamHandle deallocation_stream(const DevicePtrHandle& h) noexcept; // Set the deallocation stream for a device pointer handle. -void set_deallocation_stream(const DevicePtrHandle& h, const StreamHandle& h_stream) noexcept; +// Returns CUDA_ERROR_INVALID_CONTEXT when a default-stream token cannot be +// bound because no CUDA context is current. +CUresult set_deallocation_stream( + const DevicePtrHandle& h, const StreamHandle& h_stream) noexcept; // ============================================================================ // Library handle functions diff --git a/cuda_core/cuda/core/_device.pyi b/cuda_core/cuda/core/_device.pyi index a086f0d2523..19883620cea 100644 --- a/cuda_core/cuda/core/_device.pyi +++ b/cuda_core/cuda/core/_device.pyi @@ -1027,4 +1027,5 @@ class Device: .. versionadded:: 1.1.0 """ _tls = threading.local() -_lock = threading.Lock() \ No newline at end of file +_lock = threading.Lock() +__all__ = ['Device'] \ No newline at end of file diff --git a/cuda_core/cuda/core/_event.pyi b/cuda_core/cuda/core/_event.pyi index 1ea91308bc1..9391735b6ab 100644 --- a/cuda_core/cuda/core/_event.pyi +++ b/cuda_core/cuda/core/_event.pyi @@ -180,6 +180,7 @@ class IPCEventDescriptor: def __reduce__(self) -> tuple[object, ...]: ... +__all__ = ['Event', 'EventOptions'] def _reduce_event(event: Event) -> tuple[object, ...]: ... \ No newline at end of file diff --git a/cuda_core/cuda/core/_include/layout.hpp b/cuda_core/cuda/core/_include/layout.hpp index b5da219df34..d76e2ca5a80 100644 --- a/cuda_core/cuda/core/_include/layout.hpp +++ b/cuda_core/cuda/core/_include/layout.hpp @@ -1,5 +1,4 @@ -// SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. -// All rights reserved. +// SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. // // SPDX-License-Identifier: Apache-2.0 diff --git a/cuda_core/cuda/core/_launch_config.pyi b/cuda_core/cuda/core/_launch_config.pyi index eac16c1878f..47187fb03d6 100644 --- a/cuda_core/cuda/core/_launch_config.pyi +++ b/cuda_core/cuda/core/_launch_config.pyi @@ -18,15 +18,15 @@ class LaunchConfig: Attributes ---------- - grid : Union[tuple, int] + grid : tuple | int Collection of threads that will execute a kernel function. When cluster is not specified, this represents the number of blocks, otherwise this represents the number of clusters. - cluster : Union[tuple, int] + cluster : tuple | int Group of blocks (Thread Block Cluster) that will execute on the same GPU Processing Cluster (GPC). Blocks within a cluster have access to distributed shared memory and can be explicitly synchronized. - block : Union[tuple, int] + block : tuple | int Group of threads (Thread Block) that will execute on the same streaming multiprocessor (SM). Threads within a thread blocks have access to shared memory and can be explicitly synchronized. @@ -35,23 +35,29 @@ class LaunchConfig: (Default to size 0) is_cooperative : bool, optional Whether this config can be used to launch a cooperative kernel. + programmatic_stream_serialization : bool, optional + Whether to allow programmatic stream serialization (PDL). When True, + the kernel may overlap with a previous kernel in the same stream that + signals completion via programmatic means. """ - def __init__(self, grid: int | tuple[int, ...] | None=None, cluster: int | tuple[int, ...] | None=None, block: int | tuple[int, ...] | None=None, shmem_size: int | None=None, is_cooperative: bool=False) -> None: + def __init__(self, grid: int | tuple[int, ...] | None=None, cluster: int | tuple[int, ...] | None=None, block: int | tuple[int, ...] | None=None, shmem_size: int | None=None, is_cooperative: bool=False, programmatic_stream_serialization: bool=False) -> None: """Initialize LaunchConfig with validation. Parameters ---------- - grid : Union[tuple, int], optional + grid : tuple | int, optional Grid dimensions (number of blocks or clusters if cluster is specified) - cluster : Union[tuple, int], optional + cluster : tuple | int, optional Cluster dimensions (Thread Block Cluster) - block : Union[tuple, int], optional + block : tuple | int, optional Block dimensions (threads per block) shmem_size : int, optional Dynamic shared memory size in bytes (default: 0) is_cooperative : bool, optional Whether to launch as cooperative kernel (default: False) + programmatic_stream_serialization : bool, optional + Whether to allow programmatic stream serialization / PDL (default: False) """ def _identity(self) -> tuple[Any, ...]: @@ -65,7 +71,8 @@ class LaunchConfig: def __hash__(self) -> int: ... -_LAUNCH_CONFIG_ATTRS = ('grid', 'cluster', 'block', 'shmem_size', 'is_cooperative') +_LAUNCH_CONFIG_ATTRS = ('grid', 'cluster', 'block', 'shmem_size', 'is_cooperative', 'programmatic_stream_serialization') +__all__ = ['LaunchConfig'] def _to_native_launch_config(config: LaunchConfig) -> object: """Convert LaunchConfig to native driver CUlaunchConfig. diff --git a/cuda_core/cuda/core/_launch_config.pyx b/cuda_core/cuda/core/_launch_config.pyx index 3a2f36a4dff..adbf9a16c5d 100644 --- a/cuda_core/cuda/core/_launch_config.pyx +++ b/cuda_core/cuda/core/_launch_config.pyx @@ -38,15 +38,15 @@ cdef class LaunchConfig: Attributes ---------- - grid : Union[tuple, int] + grid : tuple | int Collection of threads that will execute a kernel function. When cluster is not specified, this represents the number of blocks, otherwise this represents the number of clusters. - cluster : Union[tuple, int] + cluster : tuple | int Group of blocks (Thread Block Cluster) that will execute on the same GPU Processing Cluster (GPC). Blocks within a cluster have access to distributed shared memory and can be explicitly synchronized. - block : Union[tuple, int] + block : tuple | int Group of threads (Thread Block) that will execute on the same streaming multiprocessor (SM). Threads within a thread blocks have access to shared memory and can be explicitly synchronized. @@ -77,11 +77,11 @@ cdef class LaunchConfig: Parameters ---------- - grid : Union[tuple, int], optional + grid : tuple | int, optional Grid dimensions (number of blocks or clusters if cluster is specified) - cluster : Union[tuple, int], optional + cluster : tuple | int, optional Cluster dimensions (Thread Block Cluster) - block : Union[tuple, int], optional + block : tuple | int, optional Block dimensions (threads per block) shmem_size : int, optional Dynamic shared memory size in bytes (default: 0) diff --git a/cuda_core/cuda/core/_launcher.pyi b/cuda_core/cuda/core/_launcher.pyi index a292c3eec95..27ed7e86da7 100644 --- a/cuda_core/cuda/core/_launcher.pyi +++ b/cuda_core/cuda/core/_launcher.pyi @@ -8,6 +8,7 @@ from cuda.core._stream import Stream from cuda.core.graph import GraphBuilder from cuda.core.typing import IsStreamType +__all__ = ['launch'] def launch(stream: Stream | GraphBuilder | IsStreamType, config: LaunchConfig, kernel: Kernel, *kernel_args) -> None: """Launches a :obj:`~_module.Kernel` diff --git a/cuda_core/cuda/core/_memory/_buffer.pxd b/cuda_core/cuda/core/_memory/_buffer.pxd index b552e69554d..a9fa0d7e99c 100644 --- a/cuda_core/cuda/core/_memory/_buffer.pxd +++ b/cuda_core/cuda/core/_memory/_buffer.pxd @@ -44,3 +44,9 @@ cdef Buffer Buffer_from_deviceptr_handle( object ipc_descriptor = *, type cls = *, ) + + +# Shared argument coercion for the batched free functions (copy_batch, +# prefetch_batch, discard_batch, discard_prefetch_batch). `single_hint` +# names the per-buffer API to use instead when a bare Buffer is passed. +cdef tuple Buffer_coerce_batch(object buffers, str what, str single_hint) diff --git a/cuda_core/cuda/core/_memory/_buffer.pyi b/cuda_core/cuda/core/_memory/_buffer.pyi index 1d824cf6fc0..4d8bd657968 100644 --- a/cuda_core/cuda/core/_memory/_buffer.pyi +++ b/cuda_core/cuda/core/_memory/_buffer.pyi @@ -39,12 +39,15 @@ class Buffer: ... @classmethod - def _init(cls, ptr: DevicePointerType, size: int, mr: MemoryResource | None=None, ipc_descriptor: IPCBufferDescriptor | None=None, owner: object | None=None) -> Buffer: + def _init(cls, ptr: DevicePointerType, size: int, mr: MemoryResource | None=None, ipc_descriptor: IPCBufferDescriptor | None=None, owner: object | None=None, *, stream: Stream | GraphBuilder | None=None) -> Buffer: """Create a Buffer from a raw pointer. When ``mr`` is provided, the buffer takes ownership: ``mr.deallocate()`` is called when the buffer is closed or garbage collected. When ``owner`` is provided, the owner is kept alive but no deallocation is performed. + When ``mr`` is provided, a deallocation stream is recorded at creation + (``stream`` if given, otherwise ``default_stream()``). Recording a + default-stream token requires a CUDA context to be current. """ @staticmethod @@ -55,7 +58,7 @@ class Buffer: ... @staticmethod - def from_handle(ptr: DevicePointerType, size: int, mr: MemoryResource | None=None, owner: object | None=None) -> Buffer: + def from_handle(ptr: DevicePointerType, size: int, mr: MemoryResource | None=None, owner: object | None=None, *, stream: Stream | GraphBuilder | None=None) -> Buffer: """Create a new :class:`Buffer` object from a pointer. Parameters @@ -72,6 +75,13 @@ class Buffer: An object holding external allocation that the ``ptr`` points to. The reference is kept as long as the buffer is alive. The ``owner`` and ``mr`` cannot be specified together. + stream : :obj:`~_stream.Stream` | :obj:`~graph.GraphBuilder`, optional + Keyword-only. The stream used to order the buffer's deallocation + when ``mr`` owns the pointer. Defaults to ``default_stream()``. + Recording a default-stream token requires a CUDA context to be + current. If the buffer may be freed from a different host thread, + pass a stream other than the per-thread default stream, which + refers to a different stream on each thread. Note ---- @@ -264,7 +274,12 @@ class MemoryResource: stream : :obj:`~_stream.Stream` | :obj:`~graph.GraphBuilder` Keyword-only. The stream on which to perform the allocation asynchronously. Must be passed explicitly; pass - ``device.default_stream`` to use the default stream. + ``device.default_stream`` to use the default stream. For subclasses + that support stream-ordered deallocation, this stream also orders + the buffer's eventual deallocation, so if the buffer may be freed + from a different host thread, prefer a stream other than the + per-thread default stream, which refers to a different stream on + each thread. Returns ------- diff --git a/cuda_core/cuda/core/_memory/_buffer.pyx b/cuda_core/cuda/core/_memory/_buffer.pyx index 2506331d0fd..2f9d3bce218 100644 --- a/cuda_core/cuda/core/_memory/_buffer.pyx +++ b/cuda_core/cuda/core/_memory/_buffer.pyx @@ -16,11 +16,13 @@ from cuda.core._memory cimport _ipc from cuda.core._resource_handles cimport ( DevicePtrHandle, StreamHandle, + ContextHandle, deviceptr_create_with_owner, deviceptr_create_with_mr, register_mr_dealloc_callback, as_intptr, as_cu, + get_current_context, set_deallocation_stream, ) from cuda.core.typing import DevicePointerType @@ -29,6 +31,7 @@ from cuda.core._stream cimport Stream, Stream_accept, default_stream from cuda.core._utils.cuda_utils cimport HANDLE_RETURN, _parse_fill_value import sys +from collections.abc import Sequence from typing import TYPE_CHECKING from cuda.core._utils.pycompat import BufferProtocol @@ -49,23 +52,21 @@ cdef void _mr_dealloc_callback( size_t size, const StreamHandle& h_stream, ) noexcept: - """Called by the C++ deleter to deallocate via MemoryResource.deallocate. - - This is the C++ teardown path: there is no Python caller frame from - which to obtain a stream. If the device-pointer handle was created - without ``set_deallocation_stream`` being called (e.g. buffers minted - via ``Buffer.from_handle(ptr, size, mr=mr)`` from DLPack import, - third-party adapters, or other foreign sources), ``h_stream`` is - empty here. Stream-ordered MR ``deallocate`` overrides reject - ``stream=None`` (issue #2001), so without a fallback the destructor - would print a warning and leak the allocation. Fall back to the - legacy/per-thread default stream so the free still happens; this is - the unique exception to the "no implicit default-stream fallback" - policy because the teardown has no other source of truth. - """ + """Called by the C++ deleter to deallocate via MemoryResource.deallocate.""" cdef Stream stream try: - stream = Stream._from_handle(Stream, h_stream) if h_stream else default_stream() + if not h_stream: + print( + "Warning: no deallocation stream was recorded; falling back to " + "the default stream for mr.deallocate() during Buffer " + "destruction. This is an internal cuda-core error; please " + "report it with your CUDA driver, CUDA Toolkit, and " + "cuda-python versions.", + file=sys.stderr, + ) + stream = default_stream() + else: + stream = Stream._from_handle(Stream, h_stream) mr.deallocate(int(ptr), size, stream=stream) except Exception as exc: print(f"Warning: mr.deallocate() failed during Buffer destruction: {exc}", @@ -74,6 +75,23 @@ cdef void _mr_dealloc_callback( register_mr_dealloc_callback(_mr_dealloc_callback) +cdef inline void _apply_deallocation_stream( + const DevicePtrHandle& h_ptr, const StreamHandle& h_stream) except *: + """Record h_stream as the deallocation stream for h_ptr. + + Translates CUDA_ERROR_INVALID_CONTEXT (default-stream token with no current + context) into a descriptive RuntimeError instead of a raw CUDAError. + """ + cdef cydriver.CUresult status = set_deallocation_stream(h_ptr, h_stream) + if status == cydriver.CUresult.CUDA_ERROR_INVALID_CONTEXT: + raise RuntimeError( + "Cannot record a default deallocation stream when no CUDA context is " + "current. Call Device.set_current() first, or pass stream= with a " + "non-default Stream." + ) + HANDLE_RETURN(status) + + __all__ = ['Buffer', 'MemoryResource'] @@ -176,20 +194,43 @@ cdef class Buffer: def _init( cls, ptr: DevicePointerType, size_t size, mr: MemoryResource | None = None, ipc_descriptor: IPCBufferDescriptor | None = None, - owner : object | None = None + owner : object | None = None, + *, + stream: Stream | GraphBuilder | None = None, ) -> Buffer: """Create a Buffer from a raw pointer. When ``mr`` is provided, the buffer takes ownership: ``mr.deallocate()`` is called when the buffer is closed or garbage collected. When ``owner`` is provided, the owner is kept alive but no deallocation is performed. + When ``mr`` is provided, a deallocation stream is recorded at creation + (``stream`` if given, otherwise ``default_stream()``). Recording a + default-stream token requires a CUDA context to be current. """ if mr is not None and owner is not None: raise ValueError("owner and memory resource cannot be both specified together") + if stream is not None and mr is None: + raise ValueError("stream requires a memory resource (mr)") cdef Buffer self = Buffer.__new__(cls) cdef uintptr_t c_ptr = <uintptr_t>(int(ptr)) + cdef Stream s + cdef cydriver.CUresult _ds_status if mr is not None: + s = Stream_accept(default_stream() if stream is None else stream) self._h_ptr = deviceptr_create_with_mr(c_ptr, size, mr) + _ds_status = set_deallocation_stream(self._h_ptr, s._h_stream) + if _ds_status != cydriver.CUresult.CUDA_SUCCESS: + # Reset before raising: the DevicePtrHandle destructor would otherwise + # invoke _mr_dealloc_callback, which catches any inner exception and + # clears the exception state, swallowing the error we're about to raise. + self._h_ptr.reset() + if _ds_status == cydriver.CUresult.CUDA_ERROR_INVALID_CONTEXT: + raise RuntimeError( + "Cannot record a default deallocation stream when no CUDA context is " + "current. Call Device.set_current() first, or pass stream= with a " + "non-default Stream." + ) + HANDLE_RETURN(_ds_status) else: self._h_ptr = deviceptr_create_with_owner(c_ptr, owner) self._size = size @@ -201,6 +242,13 @@ cdef class Buffer: @staticmethod def _reduce_helper(mr, ipc_descriptor): + cdef ContextHandle h_ctx = get_current_context() + cdef int device_id + if not h_ctx: + # Spawned processes unpickle arguments before entering their target, + # so initialize the context needed to bind the default-stream token. + device_id = mr.device_id + (Device(device_id) if device_id >= 0 else Device()).set_current() # The parent process's stream is not portable across processes, so the # pickle path cannot thread an explicit stream through. Seed the # imported buffer's deallocation with the current context's default @@ -217,6 +265,8 @@ cdef class Buffer: def from_handle( ptr: DevicePointerType, size_t size, mr: MemoryResource | None = None, owner: object | None = None, + *, + stream: Stream | GraphBuilder | None = None, ) -> Buffer: """Create a new :class:`Buffer` object from a pointer. @@ -234,6 +284,13 @@ cdef class Buffer: An object holding external allocation that the ``ptr`` points to. The reference is kept as long as the buffer is alive. The ``owner`` and ``mr`` cannot be specified together. + stream : :obj:`~_stream.Stream` | :obj:`~graph.GraphBuilder`, optional + Keyword-only. The stream used to order the buffer's deallocation + when ``mr`` owns the pointer. Defaults to ``default_stream()``. + Recording a default-stream token requires a CUDA context to be + current. If the buffer may be freed from a different host thread, + pass a stream other than the per-thread default stream, which + refers to a different stream on each thread. Note ---- @@ -241,7 +298,7 @@ cdef class Buffer: non-owning reference. The pointer will NOT be freed when the :class:`Buffer` is closed or garbage collected. """ - return Buffer._init(ptr, size, mr=mr, owner=owner) + return Buffer._init(ptr, size, mr=mr, owner=owner, stream=stream) @classmethod def from_ipc_descriptor( @@ -546,7 +603,12 @@ cdef class MemoryResource: stream : :obj:`~_stream.Stream` | :obj:`~graph.GraphBuilder` Keyword-only. The stream on which to perform the allocation asynchronously. Must be passed explicitly; pass - ``device.default_stream`` to use the default stream. + ``device.default_stream`` to use the default stream. For subclasses + that support stream-ordered deallocation, this stream also orders + the buffer's eventual deallocation, so if the buffer may be freed + from a different host thread, prefer a stream other than the + per-thread default stream, which refers to a different stream on + each thread. Returns ------- @@ -619,6 +681,32 @@ cdef Buffer Buffer_from_deviceptr_handle( return buf +cdef tuple Buffer_coerce_batch(object buffers, str what, str single_hint): + """Coerce ``buffers`` to a ``tuple[Buffer, ...]``; reject a bare Buffer. + + Shared by the batched free functions. Passing one Buffer is rejected + rather than treated as a one-element batch so that the per-buffer API + named by ``single_hint`` stays the single obvious way to do it. + """ + cdef list out + if isinstance(buffers, Buffer): + raise TypeError( + f"{what}: pass a sequence of Buffers; for a single buffer use {single_hint}" + ) + if not isinstance(buffers, Sequence): + raise TypeError( + f"{what}: buffers must be a sequence of Buffer, got {type(buffers).__name__}" + ) + if not buffers: + raise ValueError(f"{what}: empty buffers sequence") + out = [] + for item in buffers: + if not isinstance(item, Buffer): + raise TypeError(f"{what}: expected Buffer, got {type(item).__name__}") + out.append(item) + return tuple(out) + + cdef inline void Buffer_close(Buffer self, object stream): """Close a buffer, freeing its memory.""" cdef Stream s @@ -627,7 +715,7 @@ cdef inline void Buffer_close(Buffer self, object stream): # Update deallocation stream if provided if stream is not None: s = Stream_accept(stream) - set_deallocation_stream(self._h_ptr, s._h_stream) + _apply_deallocation_stream(self._h_ptr, s._h_stream) # Reset handle - RAII deleter will free the memory (and release owner ref in C++) self._h_ptr.reset() self._size = 0 diff --git a/cuda_core/cuda/core/_memory/_copy_attributes.pxd b/cuda_core/cuda/core/_memory/_copy_attributes.pxd new file mode 100644 index 00000000000..726e2553922 --- /dev/null +++ b/cuda_core/cuda/core/_memory/_copy_attributes.pxd @@ -0,0 +1,20 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# SPDX-License-Identifier: Apache-2.0 + +# Neutral leaf module: declares the CopyOptions-to-CUmemcpyAttributes converter +# and the 13.2 availability gate so both _buffer and _copy_ops can cimport them +# without either depending on the other. + +from cuda.bindings cimport cydriver +from cuda.core._utils.version cimport cy_binding_version, cy_driver_version # no-cython-lint + + +IF CUDA_CORE_BUILD_MAJOR >= 13: + cdef inline bint _with_attributes_available(): + return cy_driver_version() >= (13, 2, 0) and cy_binding_version() >= (13, 2, 0) +ELSE: + cdef inline bint _with_attributes_available(): + return False + +cdef cydriver.CUmemcpyAttributes _to_cu_memcpy_attributes(object attr) diff --git a/cuda_core/cuda/core/_memory/_copy_attributes.pyi b/cuda_core/cuda/core/_memory/_copy_attributes.pyi new file mode 100644 index 00000000000..0fceb058f53 --- /dev/null +++ b/cuda_core/cuda/core/_memory/_copy_attributes.pyi @@ -0,0 +1,3 @@ +# This file was generated by stubgen-pyx v0.2.6 from cuda_core/cuda/core/_memory/_copy_attributes.pyx + +from __future__ import annotations \ No newline at end of file diff --git a/cuda_core/cuda/core/_memory/_copy_attributes.pyx b/cuda_core/cuda/core/_memory/_copy_attributes.pyx new file mode 100644 index 00000000000..5618cf35527 --- /dev/null +++ b/cuda_core/cuda/core/_memory/_copy_attributes.pyx @@ -0,0 +1,28 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# SPDX-License-Identifier: Apache-2.0 + +from libc.string cimport memset + +from cuda.bindings cimport cydriver +from cuda.core._memory._location cimport to_cumemlocation + +from cuda.core._memory._managed_location import _coerce_location + + +cdef cydriver.CUmemcpyAttributes _to_cu_memcpy_attributes(object attr): + """Convert a CopyOptions to a cydriver.CUmemcpyAttributes struct.""" + cdef cydriver.CUmemcpyAttributes cu_attr + memset(&cu_attr, 0, sizeof(cydriver.CUmemcpyAttributes)) + cu_attr.srcAccessOrder = <cydriver.CUmemcpySrcAccessOrder>(<int>attr._to_driver_enum()) + cu_attr.flags = <unsigned int>(<int>attr._to_driver_flags()) + + cdef object src_loc = _coerce_location(attr.src_location_hint, allow_none=True) + cdef object dst_loc = _coerce_location(attr.dst_location_hint, allow_none=True) + + if src_loc is not None: + cu_attr.srcLocHint = to_cumemlocation(src_loc.kind, src_loc.id) + if dst_loc is not None: + cu_attr.dstLocHint = to_cumemlocation(dst_loc.kind, dst_loc.id) + + return cu_attr diff --git a/cuda_core/cuda/core/_memory/_copy_enums.py b/cuda_core/cuda/core/_memory/_copy_enums.py new file mode 100644 index 00000000000..568aca02ddf --- /dev/null +++ b/cuda_core/cuda/core/_memory/_copy_enums.py @@ -0,0 +1,178 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# SPDX-License-Identifier: Apache-2.0 + +from __future__ import annotations + +import dataclasses +from collections.abc import Sequence + +from cuda.core._device import Device +from cuda.core._host import Host +from cuda.core._utils.cuda_utils import driver +from cuda.core._utils.pycompat import StrEnum +from cuda.core._utils.version import binding_version + +__all__ = ["CopyOptions", "MemcpyOverlapMode", "MemcpySrcAccessOrder"] + + +class MemcpySrcAccessOrder(StrEnum): + """Source access order hint for batched memcpy operations. + + Maps to ``CUmemcpySrcAccessOrder``. + + ``STREAM`` + Source reads follow stream order. Earlier stream work may still be + accessing the source when the copy is enqueued. + ``DURING_API_CALL`` + The driver may read the source out of stream order, but all reads + are complete before :func:`copy_batch` returns. No earlier stream + work may be accessing the source at the time of the call. + ``ANY`` + The driver may read the source after the call returns. The caller + must keep the source unchanged until the copy completes in stream + order. No earlier stream work may be accessing the source. + """ + + STREAM = "stream" + DURING_API_CALL = "during_api_call" + ANY = "any" + + +class MemcpyOverlapMode(StrEnum): + """Overlap mode hint for batched memcpy operations. + + Maps to ``CUmemcpyFlags``. + + ``DEFAULT`` + No overlap preference; the driver uses its default scheduling. + ``PREFER_OVERLAP_WITH_COMPUTE`` + Hint that the copy should preferably overlap with concurrent + compute work. This is advisory and may be ignored depending on + the platform and copy parameters. + """ + + DEFAULT = "default" + PREFER_OVERLAP_WITH_COMPUTE = "prefer_overlap_with_compute" + + +@dataclasses.dataclass(frozen=True) +class CopyOptions: + """Attribute bundle for a single copy within a batched memcpy. + + Parameters + ---------- + src_access_order : :class:`MemcpySrcAccessOrder` or str + Hint describing how the source will be accessed. + Default is ``"stream"`` (stream-ordered access). + src_location_hint : :class:`cuda.core.Device` | :class:`cuda.core.Host` | None + Hint for the source memory location. Honored only for managed + memory on devices with concurrent managed access and for + system-allocated pageable memory on devices with pageable memory + access; ignored for all other memory types. Does not prefetch + memory and does not set persistent memory advice. + ``None`` means no hint. + dst_location_hint : :class:`cuda.core.Device` | :class:`cuda.core.Host` | None + Hint for the destination memory location. Same semantics and + restrictions as ``src_location_hint``. ``None`` means no hint. + overlap_mode : :class:`MemcpyOverlapMode` or str + Hint requesting that the copy overlap with concurrent compute work. + This is advisory; it has an effect only on devices that support it. + Default is ``"default"``. + """ + + src_access_order: MemcpySrcAccessOrder | str = "stream" + src_location_hint: Device | Host | None = None + dst_location_hint: Device | Host | None = None + overlap_mode: MemcpyOverlapMode | str = "default" + + def __post_init__(self): + # Frozen, unlike the other *Options dataclasses in cuda.core, because + # the batched-API contract agreed in NVIDIA/cuda-python#1775 specifies + # immutable per-call options: + # https://github.com/NVIDIA/cuda-python/pull/1775#issuecomment-4355502334 + # + # Normalizing str -> StrEnum therefore has to go through + # object.__setattr__; a plain assignment would raise + # FrozenInstanceError. Done here rather than at use so that a typo + # fails at construction and the field always holds the enum. + if not isinstance(self.src_access_order, MemcpySrcAccessOrder): + try: + object.__setattr__( + self, + "src_access_order", + MemcpySrcAccessOrder(self.src_access_order), + ) + except (ValueError, TypeError) as exc: + raise ValueError(f"invalid src_access_order: {self.src_access_order!r}") from exc + if not isinstance(self.overlap_mode, MemcpyOverlapMode): + try: + object.__setattr__( + self, + "overlap_mode", + MemcpyOverlapMode(self.overlap_mode), + ) + except (ValueError, TypeError) as exc: + raise ValueError(f"invalid overlap_mode: {self.overlap_mode!r}") from exc + + def _to_driver_enum(self) -> int: + """Return the driver CUmemcpySrcAccessOrder value.""" + if not _SRC_ACCESS_ORDER_TO_DRIVER: + raise NotImplementedError(_CUDA13_REQUIRED) + return _SRC_ACCESS_ORDER_TO_DRIVER[MemcpySrcAccessOrder(self.src_access_order)] + + def _to_driver_flags(self) -> int: + """Return the driver CUmemcpyFlags value.""" + if not _OVERLAP_MODE_TO_DRIVER: + raise NotImplementedError(_CUDA13_REQUIRED) + return _OVERLAP_MODE_TO_DRIVER[MemcpyOverlapMode(self.overlap_mode)] + + +_CUDA13_REQUIRED = "copy attributes require cuda.bindings 13.0 or newer" + +# CUmemcpySrcAccessOrder and CUmemcpyFlags are exposed by cuda.bindings 13.0+, +# so these maps are empty when it is older. Nothing reaches them there: +# copy_batch refuses non-default CopyOptions when the batched entry point is +# unavailable. +# +# Keyed by ``str``: under ``python_version = "3.10"`` mypy resolves StrEnum to +# the unstubbed backports shim and so infers the members as plain ``str``. +# StrEnum members are ``str`` instances, so this holds on every version. The +# values are wrapped in ``int()`` because the driver enums are untyped. +_SRC_ACCESS_ORDER_TO_DRIVER: dict[str, int] +_OVERLAP_MODE_TO_DRIVER: dict[str, int] + +if binding_version() >= (13, 0, 0): + _src_order = driver.CUmemcpySrcAccessOrder + _flags = driver.CUmemcpyFlags + _SRC_ACCESS_ORDER_TO_DRIVER = { + MemcpySrcAccessOrder.STREAM: int(_src_order.CU_MEMCPY_SRC_ACCESS_ORDER_STREAM), + MemcpySrcAccessOrder.DURING_API_CALL: int(_src_order.CU_MEMCPY_SRC_ACCESS_ORDER_DURING_API_CALL), + MemcpySrcAccessOrder.ANY: int(_src_order.CU_MEMCPY_SRC_ACCESS_ORDER_ANY), + } + _OVERLAP_MODE_TO_DRIVER = { + MemcpyOverlapMode.DEFAULT: int(_flags.CU_MEMCPY_FLAG_DEFAULT), + MemcpyOverlapMode.PREFER_OVERLAP_WITH_COMPUTE: int(_flags.CU_MEMCPY_FLAG_PREFER_OVERLAP_WITH_COMPUTE), + } + del _src_order, _flags +else: + _SRC_ACCESS_ORDER_TO_DRIVER = {} + _OVERLAP_MODE_TO_DRIVER = {} + + +def _attr_run_starts(attrs: Sequence[CopyOptions]) -> list[int]: + """Return the start index of each maximal run of equal attributes. + + This mirrors the ``attrsIdxs`` indirection that ``cuMemcpyBatchAsync`` + expects: ``attrs[k]`` applies to the copies in + ``[starts[k], starts[k + 1])``. Collapsing equal neighbours means a + broadcast attribute is passed to the driver once (``numAttrs == 1``) + rather than repeated per copy. + """ + starts: list[int] = [] + prev: CopyOptions | None = None + for i, attr in enumerate(attrs): + if i == 0 or attr != prev: + starts.append(i) + prev = attr + return starts diff --git a/cuda_core/cuda/core/_memory/_copy_ops.pyi b/cuda_core/cuda/core/_memory/_copy_ops.pyi new file mode 100644 index 00000000000..f281f0913c7 --- /dev/null +++ b/cuda_core/cuda/core/_memory/_copy_ops.pyi @@ -0,0 +1,85 @@ +# This file was generated by stubgen-pyx v0.2.6 from cuda_core/cuda/core/_memory/_copy_ops.pyx + +from __future__ import annotations + +from collections.abc import Sequence + +from cuda.core._memory._buffer import Buffer +from cuda.core._memory._copy_enums import CopyOptions +from cuda.core._stream import Stream + +_SINGLE_COPY_HINT = 'Buffer.copy_to / Buffer.copy_from' + +def _normalize_copy_options(options: CopyOptions | Sequence[CopyOptions] | None, n: int) -> tuple[CopyOptions, ...]: + """Expand ``options`` to exactly one :class:`CopyOptions` per copy. + + ``None`` and a scalar broadcast; a sequence pairs by index and must + already have length ``n``. + + Internal, but deliberately importable: options are hints that change + how the driver stages a transfer and never the bytes it produces, so + this expansion (and the run encoding applied to it) is the only + observable evidence that a scalar reached every copy. + """ + +def copy_batch(stream: Stream, srcs: Sequence[Buffer], dsts: Sequence[Buffer], *, options: CopyOptions | Sequence[CopyOptions] | None=None) -> None: + """Copy a batch of buffers asynchronously. + + Source buffer and destination buffer sizes must match. For a single + buffer, use :meth:`Buffer.copy_to` or :meth:`Buffer.copy_from`. + + The driver provides no graph-node form of ``cuMemcpyBatchAsync``, so + this cannot be captured into a graph. Both passing a + :class:`~graph.GraphBuilder` and passing its underlying + :attr:`~graph.GraphBuilder.stream` while capture is active are + rejected. Build graph copies with + :meth:`graph.GraphNode.memcpy` or per-buffer :meth:`Buffer.copy_to`. + + Parameters + ---------- + stream : :class:`~_stream.Stream` + Stream for the asynchronous copy. First positional and required + (mirrors :func:`launch`). Does not accept a capturing stream + (including a :class:`~graph.GraphBuilder`'s underlying stream); use + :meth:`graph.GraphNode.memcpy` or per-buffer + :meth:`Buffer.copy_to` to build copies into a graph. + srcs : Sequence[:class:`Buffer`] + Source buffers. Must be a sequence, not a single Buffer. + dsts : Sequence[:class:`Buffer`] + Destination buffers. Must match ``len(srcs)``. + options : :class:`CopyOptions` | Sequence[:class:`CopyOptions`] | None + Per-copy options. A single value applies to every copy; a + sequence pairs by index and must match ``len(srcs)``. ``None`` + uses stream-ordered defaults. + + Raises + ------ + ValueError + If lengths or sizes mismatch. + TypeError + If a single Buffer is passed instead of a sequence, if a + default-stream token (``LEGACY_DEFAULT_STREAM`` / + ``PER_THREAD_DEFAULT_STREAM``) is passed, or if the stream is + currently in graph capture mode. + + Notes + ----- + Batching through ``cuMemcpyBatchAsync`` requires all three of: + ``cuda.core`` built against CUDA 13 headers, ``cuda.bindings`` 13.0 or + newer, and a driver reporting CUDA 13.0 or newer + (``cuDriverGetVersion() >= 13000``). ``cuda.bindings`` binds only the + CUDA 13.0 revision of the entry point, so a driver that predates it is + refused even where it implements the earlier CUDA 12.8 signature. + + The driver may execute batch items concurrently and in any order. + A batch must therefore not contain copies where the source range of + one copy overlaps the destination range of another; such aliasing + produces undefined results. Detecting overlaps at runtime is + impractical; callers are responsible for ensuring no aliasing exists. + + On pre-CUDA 13 installs the copies fall back to a Python-level loop + over ``cuMemcpyAsync``, so the potential performance benefit of + asynchronous batched copies is not realized. :class:`CopyOptions` are + silently ignored on the fallback path. + + """ \ No newline at end of file diff --git a/cuda_core/cuda/core/_memory/_copy_ops.pyx b/cuda_core/cuda/core/_memory/_copy_ops.pyx new file mode 100644 index 00000000000..646ce9000dd --- /dev/null +++ b/cuda_core/cuda/core/_memory/_copy_ops.pyx @@ -0,0 +1,284 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# SPDX-License-Identifier: Apache-2.0 + +from __future__ import annotations + +from collections.abc import Sequence + +IF CUDA_CORE_BUILD_MAJOR >= 13: + from libcpp.vector cimport vector + +from cuda.bindings cimport cydriver +from cuda.core._memory._buffer cimport Buffer, Buffer_coerce_batch +from cuda.core._memory._copy_attributes cimport _to_cu_memcpy_attributes # no-cython-lint +from cuda.core._resource_handles cimport as_cu +from cuda.core._stream cimport Stream, Stream_accept, Stream_is_default_token +from cuda.core._utils.cuda_utils cimport HANDLE_RETURN + +# cy_driver_version and _attr_run_starts are referenced only from CUDA 13 +# branches. cython-lint does not evaluate compile-time IF blocks, so they need +# a pragma to be seen as used. +from cuda.core._utils.version cimport cy_driver_version # no-cython-lint + +from cuda.core._memory._copy_enums import CopyOptions, _attr_run_starts # no-cython-lint + +_SINGLE_COPY_HINT = "Buffer.copy_to / Buffer.copy_from" + + +cdef inline bint _batch_entry_point_available(): + """Whether cuMemcpyBatchAsync can actually be called here. + + Requires ``cuda.core`` built against CUDA 13 headers (compile time) and + a driver reporting CUDA 13.0 or newer, i.e. + ``cuDriverGetVersion() >= 13000`` (run time). + + The run-time bound is set by the binding layer, not by when the driver + gained the feature. CUDA 12.8 already exposed a ``cuMemcpyBatchAsync``, + but its signature carried a ``failIdx`` out-parameter that CUDA 13.0 + dropped. ``cuda.bindings`` resolves only the 13.0 revision, via + ``cuGetProcAddress_v2('cuMemcpyBatchAsync', ..., 13000, ...)``, so an + older driver yields a NULL pointer even though it may implement the + earlier entry point. + """ + IF CUDA_CORE_BUILD_MAJOR >= 13: + return cy_driver_version() >= (13, 0, 0) + ELSE: + return False + + +def _normalize_copy_options( + options: CopyOptions | Sequence[CopyOptions] | None, + Py_ssize_t n, +) -> tuple[CopyOptions, ...]: + """Expand ``options`` to exactly one :class:`CopyOptions` per copy. + + ``None`` and a scalar broadcast; a sequence pairs by index and must + already have length ``n``. + + Internal, but deliberately importable: options are hints that change + how the driver stages a transfer and never the bytes it produces, so + this expansion (and the run encoding applied to it) is the only + observable evidence that a scalar reached every copy. + """ + if options is None: + return (CopyOptions(),) * n + if isinstance(options, CopyOptions): + return (options,) * n + if isinstance(options, Sequence): + if len(options) != n: + raise ValueError( + f"copy_batch: options length {len(options)} does not match " + f"buffers length {n}" + ) + for a in options: + if not isinstance(a, CopyOptions): + raise TypeError( + f"copy_batch: each options element must be CopyOptions, " + f"got {type(a).__name__}" + ) + return tuple(options) + raise TypeError( + f"copy_batch: options must be CopyOptions or a sequence of " + f"CopyOptions, got {type(options).__name__}" + ) + + +def copy_batch( + stream: Stream, + srcs: Sequence[Buffer], + dsts: Sequence[Buffer], + *, + options: CopyOptions | Sequence[CopyOptions] | None = None, +) -> None: + """Copy a batch of buffers asynchronously. + + Source buffer and destination buffer sizes must match. For a single + buffer, use :meth:`Buffer.copy_to` or :meth:`Buffer.copy_from`. + + The driver provides no graph-node form of ``cuMemcpyBatchAsync``, so + this cannot be captured into a graph. Both passing a + :class:`~graph.GraphBuilder` and passing its underlying + :attr:`~graph.GraphBuilder.stream` while capture is active are + rejected. Build graph copies with + :meth:`graph.GraphNode.memcpy` or per-buffer :meth:`Buffer.copy_to`. + + Parameters + ---------- + stream : :class:`~_stream.Stream` + Stream for the asynchronous copy. First positional and required + (mirrors :func:`launch`). Does not accept a capturing stream + (including a :class:`~graph.GraphBuilder`\'s underlying stream); use + :meth:`graph.GraphNode.memcpy` or per-buffer + :meth:`Buffer.copy_to` to build copies into a graph. + srcs : Sequence[:class:`Buffer`] + Source buffers. Must be a sequence, not a single Buffer. + dsts : Sequence[:class:`Buffer`] + Destination buffers. Must match ``len(srcs)``. + options : :class:`CopyOptions` | Sequence[:class:`CopyOptions`] | None + Per-copy options. A single value applies to every copy; a + sequence pairs by index and must match ``len(srcs)``. ``None`` + uses stream-ordered defaults. + + Raises + ------ + ValueError + If lengths or sizes mismatch. + TypeError + If a single Buffer is passed instead of a sequence, if a + default-stream token (``LEGACY_DEFAULT_STREAM`` / + ``PER_THREAD_DEFAULT_STREAM``) is passed, or if the stream is + currently in graph capture mode. + + Notes + ----- + Batching through ``cuMemcpyBatchAsync`` requires all three of: + ``cuda.core`` built against CUDA 13 headers, ``cuda.bindings`` 13.0 or + newer, and a driver reporting CUDA 13.0 or newer + (``cuDriverGetVersion() >= 13000``). ``cuda.bindings`` binds only the + CUDA 13.0 revision of the entry point, so a driver that predates it is + refused even where it implements the earlier CUDA 12.8 signature. + + The driver may execute batch items concurrently and in any order. + A batch must therefore not contain copies where the source range of + one copy overlaps the destination range of another; such aliasing + produces undefined results. Detecting overlaps at runtime is + impractical; callers are responsible for ensuring no aliasing exists. + + On pre-CUDA 13 installs the copies fall back to a Python-level loop + over ``cuMemcpyAsync``, so the potential performance benefit of + asynchronous batched copies is not realized. :class:`CopyOptions` are + silently ignored on the fallback path. + + """ + cdef tuple src_bufs = Buffer_coerce_batch(srcs, "copy_batch", _SINGLE_COPY_HINT) + cdef tuple dst_bufs = Buffer_coerce_batch(dsts, "copy_batch", _SINGLE_COPY_HINT) + cdef Py_ssize_t n = len(src_bufs) + + if len(dst_bufs) != n: + raise ValueError( + f"copy_batch: srcs length {n} does not match dsts length {len(dst_bufs)}" + ) + + cdef Stream s = Stream_accept(stream) + + if Stream_is_default_token(s): + raise TypeError( + "copy_batch does not accept a default-stream token " + "(LEGACY_DEFAULT_STREAM / PER_THREAD_DEFAULT_STREAM); " + "pass an explicit stream" + ) + + cdef cydriver.CUstreamCaptureStatus _cap_status + IF CUDA_CORE_BUILD_MAJOR >= 13: + HANDLE_RETURN(cydriver.cuStreamGetCaptureInfo(as_cu(s._h_stream), &_cap_status, + NULL, NULL, NULL, NULL, NULL)) + ELSE: + HANDLE_RETURN(cydriver.cuStreamGetCaptureInfo(as_cu(s._h_stream), &_cap_status, + NULL, NULL, NULL, NULL)) + if _cap_status == cydriver.CU_STREAM_CAPTURE_STATUS_ACTIVE: + raise TypeError( + "copy_batch does not support graph capture; " + "use GraphNode.memcpy or per-buffer Buffer.copy_to instead" + ) + + cdef Buffer src_buf + cdef Buffer dst_buf + cdef Py_ssize_t i + + for i in range(n): + src_buf = <Buffer>src_bufs[i] + dst_buf = <Buffer>dst_bufs[i] + if src_buf.size != dst_buf.size: + raise ValueError( + f"copy_batch: buffer size mismatch at index {i} " + f"(src={src_buf.size}, dst={dst_buf.size})" + ) + + cdef tuple attr_tuple = _normalize_copy_options(options, n) + + _do_copy_batch(src_bufs, dst_bufs, s, attr_tuple) + + +cdef void _do_copy_batch(tuple src_bufs, tuple dst_bufs, Stream s, tuple attr_tuple): + IF CUDA_CORE_BUILD_MAJOR >= 13: + # Building against CUDA 13 headers says nothing about the installed + # driver, so the run-time version still has to be checked before + # calling a 13.0-only entry point (see PRs #2054 / #2064). + if _batch_entry_point_available(): + _do_copy_batch_native(src_bufs, dst_bufs, s, attr_tuple) + else: + _do_copy_batch_loop(src_bufs, dst_bufs, s) + ELSE: + _do_copy_batch_loop(src_bufs, dst_bufs, s) + + +cdef void _do_copy_batch_loop(tuple src_bufs, tuple dst_bufs, Stream s): + """Per-copy cuMemcpyAsync fallback where the batch entry point is absent. + + Issues copies one at a time, so the performance benefit of batching is + not realized. Callers guarantee the options are defaults; copy_batch + rejects anything else before reaching here. + """ + cdef Py_ssize_t n = len(src_bufs) + cdef Py_ssize_t i + cdef Buffer src_buf + cdef Buffer dst_buf + cdef size_t nbytes + cdef cydriver.CUstream hstream = as_cu(s._h_stream) + + for i in range(n): + src_buf = <Buffer>src_bufs[i] + dst_buf = <Buffer>dst_bufs[i] + nbytes = src_buf._size + with nogil: + HANDLE_RETURN(cydriver.cuMemcpyAsync( + as_cu(dst_buf._h_ptr), as_cu(src_buf._h_ptr), nbytes, hstream)) + + +IF CUDA_CORE_BUILD_MAJOR >= 13: + cdef void _do_copy_batch_native(tuple src_bufs, tuple dst_bufs, Stream s, tuple attr_tuple): + cdef Py_ssize_t n = len(src_bufs) + cdef cydriver.CUstream hstream = as_cu(s._h_stream) + cdef vector[cydriver.CUdeviceptr] dst_ptrs + cdef vector[cydriver.CUdeviceptr] src_ptrs + cdef vector[size_t] sizes + cdef vector[size_t] attrs_idxs + dst_ptrs.resize(n) + src_ptrs.resize(n) + sizes.resize(n) + + cdef Buffer src_buf + cdef Buffer dst_buf + cdef Py_ssize_t i + + # Collapse equal neighbouring attributes into runs so a broadcast + # attribute reaches the driver once (numAttrs == 1) instead of being + # repeated per copy. attrs[k] applies to [attrsIdxs[k], attrsIdxs[k+1]). + cdef list run_starts = _attr_run_starts(attr_tuple) + cdef vector[cydriver.CUmemcpyAttributes] cu_attrs + cdef size_t num_attrs = <size_t>len(run_starts) + cu_attrs.reserve(num_attrs) + attrs_idxs.reserve(num_attrs) + for i in run_starts: + cu_attrs.push_back(_to_cu_memcpy_attributes(attr_tuple[i])) + attrs_idxs.push_back(<size_t>i) + + for i in range(n): + src_buf = <Buffer>src_bufs[i] + dst_buf = <Buffer>dst_bufs[i] + src_ptrs[i] = as_cu(src_buf._h_ptr) + dst_ptrs[i] = as_cu(dst_buf._h_ptr) + sizes[i] = src_buf.size + + with nogil: + HANDLE_RETURN(cydriver.cuMemcpyBatchAsync( + dst_ptrs.data(), + src_ptrs.data(), + sizes.data(), + <size_t>n, + cu_attrs.data(), + attrs_idxs.data(), + num_attrs, + hstream, + )) diff --git a/cuda_core/cuda/core/_memory/_device_memory_resource.pyx b/cuda_core/cuda/core/_memory/_device_memory_resource.pyx index 22b1488f638..114259544a8 100644 --- a/cuda_core/cuda/core/_memory/_device_memory_resource.pyx +++ b/cuda_core/cuda/core/_memory/_device_memory_resource.pyx @@ -321,10 +321,9 @@ cpdef str DMR_mempool_get_access(DeviceMemoryResource dmr, int device_id): cdef int dev_id = Device(device_id).device_id cdef cydriver.CUmemAccess_flags flags - cdef cydriver.CUmemLocation location = cydriver.CUmemLocation( - type=cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_DEVICE, - id=dev_id, - ) + cdef cydriver.CUmemLocation location + location.type = cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_DEVICE + location.id = dev_id with nogil: HANDLE_RETURN(cydriver.cuMemPoolGetAccess(&flags, as_cu(dmr._h_pool), &location)) diff --git a/cuda_core/cuda/core/_memory/_graph_memory_resource.pyx b/cuda_core/cuda/core/_memory/_graph_memory_resource.pyx index e845a47b080..67ecf97f58c 100644 --- a/cuda_core/cuda/core/_memory/_graph_memory_resource.pyx +++ b/cuda_core/cuda/core/_memory/_graph_memory_resource.pyx @@ -225,7 +225,7 @@ cdef inline Buffer GMR_allocate(cyGraphMemoryResource self, size_t size, Stream return Buffer_from_deviceptr_handle(h_ptr, size, self, None) -cdef inline void GMR_deallocate(intptr_t ptr, size_t size, Stream stream) noexcept: +cdef inline void GMR_deallocate(intptr_t ptr, size_t size, Stream stream) except *: cdef cydriver.CUstream s = as_cu(stream._h_stream) cdef cydriver.CUdeviceptr devptr = <cydriver.CUdeviceptr>ptr with nogil: diff --git a/cuda_core/cuda/core/_memory/_ipc.pyi b/cuda_core/cuda/core/_memory/_ipc.pyi index 0c912a567bd..7c707ab0418 100644 --- a/cuda_core/cuda/core/_memory/_ipc.pyi +++ b/cuda_core/cuda/core/_memory/_ipc.pyi @@ -84,7 +84,7 @@ class IPCAllocationHandle: @property def uuid(self) -> uuid.UUID: ... -__all__ = ['IPCBufferDescriptor', 'IPCAllocationHandle'] +__all__ = [] def _reduce_allocation_handle(alloc_handle: IPCAllocationHandle) -> tuple[object, ...]: ... diff --git a/cuda_core/cuda/core/_memory/_location.pxd b/cuda_core/cuda/core/_memory/_location.pxd new file mode 100644 index 00000000000..7cee3c6564e --- /dev/null +++ b/cuda_core/cuda/core/_memory/_location.pxd @@ -0,0 +1,38 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# SPDX-License-Identifier: Apache-2.0 + +# Conversion from the internal ``_LocSpec`` record produced by +# ``_managed_location._coerce_location`` to the driver's ``CUmemLocation``. +# +# Header-only so both the managed-memory ops and the batched copy path can +# cimport it without either module depending on the other. ``CUmemLocation`` +# is only populated on a CUDA 13 build; the CUDA 12 stub exists so callers +# compiled there still resolve the symbol. + +from cuda.bindings cimport cydriver + + +IF CUDA_CORE_BUILD_MAJOR >= 13: + cdef inline cydriver.CUmemLocation to_cumemlocation(str kind, int loc_id): + cdef cydriver.CUmemLocation cu_loc + if kind == "device": + cu_loc.type = cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_DEVICE + cu_loc.id = loc_id + elif kind == "host": + cu_loc.type = cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_HOST + cu_loc.id = 0 + elif kind == "host_numa": + cu_loc.type = cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_HOST_NUMA + cu_loc.id = loc_id + elif kind == "host_numa_current": + cu_loc.type = cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_HOST_NUMA_CURRENT + cu_loc.id = 0 + else: + raise ValueError(f"unknown location kind: {kind!r}") + return cu_loc +ELSE: + cdef inline cydriver.CUmemLocation to_cumemlocation(str kind, int loc_id): + raise NotImplementedError( + "CUmemLocation requires cuda.core built against CUDA 13 headers" + ) diff --git a/cuda_core/cuda/core/_memory/_managed_buffer.py b/cuda_core/cuda/core/_memory/_managed_buffer.py index 83a6c618864..d00c4d0ec88 100644 --- a/cuda_core/cuda/core/_memory/_managed_buffer.py +++ b/cuda_core/cuda/core/_memory/_managed_buffer.py @@ -154,6 +154,8 @@ def from_handle( size: int, mr: MemoryResource | None = None, owner: object | None = None, + *, + stream: Stream | GraphBuilder | None = None, ) -> Buffer: """Wrap an existing managed-memory pointer in a :class:`ManagedBuffer`. @@ -173,8 +175,15 @@ def from_handle( owner : object, optional An object that keeps the underlying allocation alive. ``owner`` and ``mr`` cannot both be specified. + stream : Stream | GraphBuilder, optional + Keyword-only. The stream used to order the buffer's deallocation + when ``mr`` owns the pointer. Defaults to ``default_stream()``. + Recording a default-stream token requires a CUDA context to be + current. If the buffer may be freed from a different host thread, + pass a stream other than the per-thread default stream, which + refers to a different stream on each thread. """ - return cls._init(ptr, size, mr=mr, owner=owner) + return cls._init(ptr, size, mr=mr, owner=owner, stream=stream) @property def read_mostly(self) -> bool: diff --git a/cuda_core/cuda/core/_memory/_managed_memory_ops.pyi b/cuda_core/cuda/core/_memory/_managed_memory_ops.pyi index ca29265f103..a72bc52827f 100644 --- a/cuda_core/cuda/core/_memory/_managed_memory_ops.pyi +++ b/cuda_core/cuda/core/_memory/_managed_memory_ops.pyi @@ -11,6 +11,7 @@ from cuda.core._memory._buffer import Buffer from cuda.core._stream import Stream from cuda.core._utils.cuda_utils import driver +_SINGLE_MANAGED_HINT = 'the ManagedBuffer instance method' def discard_batch(stream: Stream | GraphBuilder, buffers: Sequence[Buffer]) -> None: """Discard a batch of managed-memory ranges. diff --git a/cuda_core/cuda/core/_memory/_managed_memory_ops.pyx b/cuda_core/cuda/core/_memory/_managed_memory_ops.pyx index b2ecde29f39..6d504670f36 100644 --- a/cuda_core/cuda/core/_memory/_managed_memory_ops.pyx +++ b/cuda_core/cuda/core/_memory/_managed_memory_ops.pyx @@ -11,7 +11,11 @@ IF CUDA_CORE_BUILD_MAJOR >= 13: from libcpp.vector cimport vector from cuda.bindings cimport cydriver -from cuda.core._memory._buffer cimport Buffer +from cuda.core._memory._buffer cimport Buffer, Buffer_coerce_batch + +# to_cumemlocation is referenced only from CUDA 13 branches. cython-lint does +# not evaluate compile-time IF blocks, so it needs a pragma to be seen as used. +from cuda.core._memory._location cimport to_cumemlocation # no-cython-lint from cuda.core._resource_handles cimport as_cu from cuda.core._stream cimport Stream, Stream_accept from cuda.core._utils.cuda_utils cimport HANDLE_RETURN @@ -52,31 +56,16 @@ cdef void _require_managed_buffer(Buffer self, str what): raise ValueError(f"{what} requires a managed-memory allocation") -cdef tuple _coerce_batch_buffers(object buffers, str what): +_SINGLE_MANAGED_HINT = "the ManagedBuffer instance method" + + +cdef inline tuple _coerce_batch_buffers(object buffers, str what): """Coerce ``buffers`` to a tuple[Buffer, ...]; rejects a single Buffer. For single-buffer operations, use the corresponding ManagedBuffer instance method instead. """ - cdef Buffer buf - cdef list out - if isinstance(buffers, Buffer): - raise TypeError( - f"{what}: pass a sequence of Buffers; for a single buffer use " - f"the ManagedBuffer instance method" - ) - if isinstance(buffers, Sequence): - if not buffers: - raise ValueError(f"{what}: empty buffers sequence") - out = [] - for t in buffers: - buf = <Buffer?>t - out.append(buf) - return tuple(out) - raise TypeError( - f"{what}: buffers must be a sequence of Buffer, " - f"got {type(buffers).__name__}" - ) + return Buffer_coerce_batch(buffers, what, _SINGLE_MANAGED_HINT) cdef tuple _broadcast_locations(object location, Py_ssize_t n, bint allow_none, str what): @@ -91,27 +80,7 @@ cdef tuple _broadcast_locations(object location, Py_ssize_t n, bint allow_none, return tuple([coerced] * n) -IF CUDA_CORE_BUILD_MAJOR >= 13: - # Convert a _LocSpec dataclass to a cydriver.CUmemLocation struct. - cdef inline cydriver.CUmemLocation _to_cumemlocation(object loc): - cdef str kind = loc.kind - if kind == "device": - return cydriver.CUmemLocation( - type=cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_DEVICE, - id=<int>loc.id) - elif kind == "host": - return cydriver.CUmemLocation( - type=cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_HOST, - id=0) - elif kind == "host_numa": - return cydriver.CUmemLocation( - type=cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_HOST_NUMA, - id=<int>loc.id) - else: # host_numa_current - return cydriver.CUmemLocation( - type=cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_HOST_NUMA_CURRENT, - id=0) -ELSE: +IF CUDA_CORE_BUILD_MAJOR < 13: # CUDA 12 cuMemPrefetchAsync takes a device ordinal (-1 = host). cdef inline int _to_legacy_device(object loc) except? -2: cdef str kind = loc.kind @@ -224,11 +193,10 @@ cdef void _do_single_advise(Buffer buf, object advice_value, object loc, bint al # Driver ignores location for read_mostly / unset_preferred_location # advice values but still validates the CUmemLocation; pass a # host placeholder. - cu_loc = cydriver.CUmemLocation( - type=cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_HOST, - id=0) + cu_loc.type = cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_HOST + cu_loc.id = 0 else: - cu_loc = _to_cumemlocation(loc) + cu_loc = to_cumemlocation(loc.kind, loc.id) with nogil: HANDLE_RETURN(cydriver.cuMemAdvise(cu_ptr, nbytes, advice_enum, cu_loc)) ELSE: @@ -292,7 +260,7 @@ cdef void _do_single_prefetch(Buffer buf, object loc, Stream s): cdef size_t nbytes = buf._size cdef cydriver.CUstream hstream = as_cu(s._h_stream) IF CUDA_CORE_BUILD_MAJOR >= 13: - cdef cydriver.CUmemLocation cu_loc = _to_cumemlocation(loc) + cdef cydriver.CUmemLocation cu_loc = to_cumemlocation(loc.kind, loc.id) with nogil: HANDLE_RETURN(cydriver.cuMemPrefetchAsync(cu_ptr, nbytes, cu_loc, 0, hstream)) ELSE: @@ -361,11 +329,13 @@ IF CUDA_CORE_BUILD_MAJOR >= 13: loc_indices.resize(n) cdef Buffer buf cdef Py_ssize_t i + cdef object loc_spec for i in range(n): buf = <Buffer>bufs[i] ptrs[i] = as_cu(buf._h_ptr) sizes[i] = buf._size - loc_arr[i] = _to_cumemlocation(locs[i]) + loc_spec = locs[i] + loc_arr[i] = to_cumemlocation(loc_spec.kind, loc_spec.id) loc_indices[i] = <size_t>i with nogil: HANDLE_RETURN(fn( diff --git a/cuda_core/cuda/core/_memory/_memory_pool.pyx b/cuda_core/cuda/core/_memory/_memory_pool.pyx index 8f9a4354b84..988c3ab532b 100644 --- a/cuda_core/cuda/core/_memory/_memory_pool.pyx +++ b/cuda_core/cuda/core/_memory/_memory_pool.pyx @@ -279,8 +279,9 @@ cdef int MP_init_current_pool( """ IF CUDA_CORE_BUILD_MAJOR >= 13: cdef cydriver.CUmemoryPool pool - cdef cydriver.CUmemLocation loc = cydriver.CUmemLocation( - type=loc_type, id=loc_id) + cdef cydriver.CUmemLocation loc + loc.type = loc_type + loc.id = loc_id with nogil: HANDLE_RETURN(cydriver.cuMemGetMemPool(&pool, &loc, alloc_type)) self._h_pool = create_mempool_handle_ref(pool) @@ -347,14 +348,11 @@ cdef Buffer _MP_allocate(_MemPool self, size_t size, Stream stream, type cls = B cdef inline void _MP_deallocate( _MemPool self, uintptr_t ptr, size_t size, Stream stream -) noexcept nogil: +) except *: cdef cydriver.CUstream s = as_cu(stream._h_stream) cdef cydriver.CUdeviceptr devptr = <cydriver.CUdeviceptr>ptr - cdef cydriver.CUresult r with nogil: - r = cydriver.cuMemFreeAsync(devptr, s) - if r != cydriver.CUDA_ERROR_INVALID_CONTEXT: - HANDLE_RETURN(r) + HANDLE_RETURN(cydriver.cuMemFreeAsync(devptr, s)) cdef inline _MP_close(_MemPool self): diff --git a/cuda_core/cuda/core/_memory/_peer_access_utils.pyx b/cuda_core/cuda/core/_memory/_peer_access_utils.pyx index 69d59f9e005..b39a1838f79 100644 --- a/cuda_core/cuda/core/_memory/_peer_access_utils.pyx +++ b/cuda_core/cuda/core/_memory/_peer_access_utils.pyx @@ -113,10 +113,9 @@ cdef inline tuple _query_peer_access_ids(DeviceMemoryResource mr): cdef inline bint _peer_access_includes(DeviceMemoryResource mr, int dev_id): """Return True if peer access from ``dev_id`` is currently granted.""" cdef cydriver.CUmemAccess_flags flags - cdef cydriver.CUmemLocation location = cydriver.CUmemLocation( - type=cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_DEVICE, - id=dev_id, - ) + cdef cydriver.CUmemLocation location + location.type = cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_DEVICE + location.id = dev_id with nogil: HANDLE_RETURN(cydriver.cuMemPoolGetAccess(&flags, as_cu(mr._h_pool), &location)) return flags == cydriver.CUmemAccess_flags.CU_MEM_ACCESS_FLAGS_PROT_READWRITE diff --git a/cuda_core/cuda/core/_memory/_pinned_memory_resource.pyi b/cuda_core/cuda/core/_memory/_pinned_memory_resource.pyi index a83cd8ea581..9cad97a1d0d 100644 --- a/cuda_core/cuda/core/_memory/_pinned_memory_resource.pyi +++ b/cuda_core/cuda/core/_memory/_pinned_memory_resource.pyi @@ -5,8 +5,11 @@ from __future__ import annotations import uuid from dataclasses import dataclass +from cuda.core._memory._buffer import Buffer from cuda.core._memory._ipc import IPCAllocationHandle from cuda.core._memory._memory_pool import _MemPool +from cuda.core._stream import Stream +from cuda.core.graph import GraphBuilder @dataclass @@ -63,6 +66,14 @@ class PinnedMemoryResource(_MemPool): Notes ----- + The device associated with ``stream`` must support host memory pools. If + ``numa_id`` is set or derived for IPC, it must support host NUMA memory pools. + You can query these capabilities through + ``Device.properties.host_memory_pools_supported`` and + ``Device.properties.host_numa_memory_pools_supported``. If the required pool + is unsupported and stream-ordered allocation is not needed, use + :class:`LegacyPinnedMemoryResource`. + To create an IPC-Enabled memory resource (MR) that is capable of sharing allocations between processes, specify ``ipc_enabled=True`` in the initializer option. When IPC is enabled and ``numa_id`` is not specified, the NUMA node @@ -76,6 +87,9 @@ class PinnedMemoryResource(_MemPool): def __init__(self, options: PinnedMemoryResourceOptions | dict[str, object] | None=None) -> None: ... + def allocate(self, size: int, *, stream: Stream | GraphBuilder) -> Buffer: + """Allocate a host-pinned buffer asynchronously on the supplied stream.""" + def __reduce__(self) -> tuple[object, ...]: ... diff --git a/cuda_core/cuda/core/_module.pyi b/cuda_core/cuda/core/_module.pyi index f51b4cb2817..e8604af012c 100644 --- a/cuda_core/cuda/core/_module.pyi +++ b/cuda_core/cuda/core/_module.pyi @@ -158,7 +158,7 @@ class KernelOccupancy: Parameters ---------- - dynamic_shared_memory_needed: Union[int, driver.CUoccupancyB2DSize] + dynamic_shared_memory_needed: int | driver.CUoccupancyB2DSize The amount of dynamic shared memory in bytes needed by block. Use `0` if block does not need shared memory. Use C-callable represented by :obj:`~driver.CUoccupancyB2DSize` to encode @@ -343,13 +343,13 @@ class ObjectCode: Parameters ---------- - module : Union[bytes, str, os.PathLike] + module : bytes | str | os.PathLike Either a bytes object containing the in-memory cubin to load, or a file path object (or its string representation) pointing to the on-disk cubin to load. - name : Optional[str] + name : str | None A human-readable identifier representing this code object. - symbol_mapping : Optional[dict] + symbol_mapping : dict | None A dictionary specifying how the unmangled symbol names (as keys) should be mapped to the mangled names before trying to retrieve them (default to no mappings). @@ -361,13 +361,13 @@ class ObjectCode: Parameters ---------- - module : Union[bytes, str, os.PathLike] + module : bytes | str | os.PathLike Either a bytes object containing the in-memory ptx code to load, or a file path object (or its string representation) pointing to the on-disk ptx file to load. - name : Optional[str] + name : str | None A human-readable identifier representing this code object. - symbol_mapping : Optional[dict] + symbol_mapping : dict | None A dictionary specifying how the unmangled symbol names (as keys) should be mapped to the mangled names before trying to retrieve them (default to no mappings). @@ -379,13 +379,13 @@ class ObjectCode: Parameters ---------- - module : Union[bytes, str, os.PathLike] + module : bytes | str | os.PathLike Either a bytes object containing the in-memory ltoir code to load, or a file path object (or its string representation) pointing to the on-disk ltoir file to load. - name : Optional[str] + name : str | None A human-readable identifier representing this code object. - symbol_mapping : Optional[dict] + symbol_mapping : dict | None A dictionary specifying how the unmangled symbol names (as keys) should be mapped to the mangled names before trying to retrieve them (default to no mappings). @@ -397,13 +397,13 @@ class ObjectCode: Parameters ---------- - module : Union[bytes, str, os.PathLike] + module : bytes | str | os.PathLike Either a bytes object containing the in-memory fatbin to load, or or a file path object (or its string representation) pointing to the on-disk fatbin to load. - name : Optional[str] + name : str | None A human-readable identifier representing this code object. - symbol_mapping : Optional[dict] + symbol_mapping : dict | None A dictionary specifying how the unmangled symbol names (as keys) should be mapped to the mangled names before trying to retrieve them (default to no mappings). @@ -415,12 +415,12 @@ class ObjectCode: Parameters ---------- - module : Union[bytes, str] + module : bytes | str Either a bytes object containing the in-memory object code to load, or a file path string pointing to the on-disk object code to load. - name : Optional[str] + name : str | None A human-readable identifier representing this code object. - symbol_mapping : Optional[dict] + symbol_mapping : dict | None A dictionary specifying how the unmangled symbol names (as keys) should be mapped to the mangled names before trying to retrieve them (default to no mappings). @@ -432,12 +432,12 @@ class ObjectCode: Parameters ---------- - module : Union[bytes, str] + module : bytes | str Either a bytes object containing the in-memory library to load, or a file path string pointing to the on-disk library to load. - name : Optional[str] + name : str | None A human-readable identifier representing this code object. - symbol_mapping : Optional[dict] + symbol_mapping : dict | None A dictionary specifying how the unmangled symbol names (as keys) should be mapped to the mangled names before trying to retrieve them (default to no mappings). @@ -458,7 +458,7 @@ class ObjectCode: """ - def get_module(self) -> object: + def get_module(self) -> driver.CUmodule: """Return a context-dependent :obj:`~driver.CUmodule` for legacy interop. Bridges the native :obj:`~driver.CUlibrary` (see :attr:`handle`) to a diff --git a/cuda_core/cuda/core/_module.pyx b/cuda_core/cuda/core/_module.pyx index 95e149065bf..a350f14887f 100644 --- a/cuda_core/cuda/core/_module.pyx +++ b/cuda_core/cuda/core/_module.pyx @@ -300,7 +300,7 @@ cdef class KernelOccupancy: Parameters ---------- - dynamic_shared_memory_needed: Union[int, driver.CUoccupancyB2DSize] + dynamic_shared_memory_needed: int | driver.CUoccupancyB2DSize The amount of dynamic shared memory in bytes needed by block. Use `0` if block does not need shared memory. Use C-callable represented by :obj:`~driver.CUoccupancyB2DSize` to encode @@ -669,13 +669,13 @@ cdef class ObjectCode: Parameters ---------- - module : Union[bytes, str, os.PathLike] + module : bytes | str | os.PathLike Either a bytes object containing the in-memory cubin to load, or a file path object (or its string representation) pointing to the on-disk cubin to load. - name : Optional[str] + name : str | None A human-readable identifier representing this code object. - symbol_mapping : Optional[dict] + symbol_mapping : dict | None A dictionary specifying how the unmangled symbol names (as keys) should be mapped to the mangled names before trying to retrieve them (default to no mappings). @@ -688,13 +688,13 @@ cdef class ObjectCode: Parameters ---------- - module : Union[bytes, str, os.PathLike] + module : bytes | str | os.PathLike Either a bytes object containing the in-memory ptx code to load, or a file path object (or its string representation) pointing to the on-disk ptx file to load. - name : Optional[str] + name : str | None A human-readable identifier representing this code object. - symbol_mapping : Optional[dict] + symbol_mapping : dict | None A dictionary specifying how the unmangled symbol names (as keys) should be mapped to the mangled names before trying to retrieve them (default to no mappings). @@ -707,13 +707,13 @@ cdef class ObjectCode: Parameters ---------- - module : Union[bytes, str, os.PathLike] + module : bytes | str | os.PathLike Either a bytes object containing the in-memory ltoir code to load, or a file path object (or its string representation) pointing to the on-disk ltoir file to load. - name : Optional[str] + name : str | None A human-readable identifier representing this code object. - symbol_mapping : Optional[dict] + symbol_mapping : dict | None A dictionary specifying how the unmangled symbol names (as keys) should be mapped to the mangled names before trying to retrieve them (default to no mappings). @@ -726,13 +726,13 @@ cdef class ObjectCode: Parameters ---------- - module : Union[bytes, str, os.PathLike] + module : bytes | str | os.PathLike Either a bytes object containing the in-memory fatbin to load, or or a file path object (or its string representation) pointing to the on-disk fatbin to load. - name : Optional[str] + name : str | None A human-readable identifier representing this code object. - symbol_mapping : Optional[dict] + symbol_mapping : dict | None A dictionary specifying how the unmangled symbol names (as keys) should be mapped to the mangled names before trying to retrieve them (default to no mappings). @@ -745,12 +745,12 @@ cdef class ObjectCode: Parameters ---------- - module : Union[bytes, str] + module : bytes | str Either a bytes object containing the in-memory object code to load, or a file path string pointing to the on-disk object code to load. - name : Optional[str] + name : str | None A human-readable identifier representing this code object. - symbol_mapping : Optional[dict] + symbol_mapping : dict | None A dictionary specifying how the unmangled symbol names (as keys) should be mapped to the mangled names before trying to retrieve them (default to no mappings). @@ -763,12 +763,12 @@ cdef class ObjectCode: Parameters ---------- - module : Union[bytes, str] + module : bytes | str Either a bytes object containing the in-memory library to load, or a file path string pointing to the on-disk library to load. - name : Optional[str] + name : str | None A human-readable identifier representing this code object. - symbol_mapping : Optional[dict] + symbol_mapping : dict | None A dictionary specifying how the unmangled symbol names (as keys) should be mapped to the mangled names before trying to retrieve them (default to no mappings). diff --git a/cuda_core/cuda/core/_program.pyi b/cuda_core/cuda/core/_program.pyi index df7ed66446a..d6ffb706331 100644 --- a/cuda_core/cuda/core/_program.pyi +++ b/cuda_core/cuda/core/_program.pyi @@ -145,6 +145,7 @@ class ProgramOptions: ---------- name : str, optional Name of the program. If the compilation succeeds, the name is passed down to the generated :class:`ObjectCode`. + When set to `None`, ``"default_program"`` is used. arch : str, optional Pass the SM architecture value, such as ``sm_<CC>`` (for generating CUBIN) or ``compute_<CC>`` (for generating PTX). If not provided, the current device's architecture @@ -165,7 +166,7 @@ class ProgramOptions: Enable device code optimization. When specified along with '-G', enables limited debug information generation for optimized device code. Default: None - ptxas_options : Union[str, list[str]], optional + ptxas_options : str | list[str], optional Specify one or more options directly to ptxas, the PTX optimizing assembler. Options should be strings. For example ["-v", "-O2"]. Default: None @@ -199,17 +200,17 @@ class ProgramOptions: gen_opt_lto : bool, optional Run the optimizer passes before generating the LTO IR. Default: False - define_macro : Union[str, tuple[str, str], list[Union[str, tuple[str, str]]]], optional + define_macro : str | tuple[str, str] | list[str | tuple[str, str]], optional Predefine a macro. Can be either a string, in which case that macro will be set to 1, a 2 element tuple of strings, in which case the first element is defined as the second, or a list of strings or tuples. Default: None - undefine_macro : Union[str, list[str]], optional + undefine_macro : str | list[str], optional Cancel any previous definition of a macro, or list of macros. Default: None - include_path : Union[str, list[str]], optional + include_path : str | list[str], optional Add the directory or directories to the list of directories to be searched for headers. Default: None - pre_include : Union[str, list[str]], optional + pre_include : str | list[str], optional Preinclude one or more headers during preprocessing. Can be either a string or a list of strings. Default: None no_source_include : bool, optional @@ -242,13 +243,13 @@ class ProgramOptions: no_display_error_number : bool, optional Disable the display of a diagnostic number for warning messages. Default: False - diag_error : Union[int, list[int]], optional + diag_error : int | list[int], optional Emit error for a specified diagnostic message number or comma-separated list of numbers. Default: None - diag_suppress : Union[int, list[int]], optional + diag_suppress : int | list[int], optional Suppress a specified diagnostic message number or comma-separated list of numbers. Default: None - diag_warn : Union[int, list[int]], optional + diag_warn : int | list[int], optional Emit warning for a specified diagnostic message number or comma-separated list of numbers. Default: None brief_diagnostics : bool, optional diff --git a/cuda_core/cuda/core/_program.pyx b/cuda_core/cuda/core/_program.pyx index 7fb099b06d2..5edf429cf11 100644 --- a/cuda_core/cuda/core/_program.pyx +++ b/cuda_core/cuda/core/_program.pyx @@ -319,7 +319,7 @@ class ProgramOptions: Enable device code optimization. When specified along with '-G', enables limited debug information generation for optimized device code. Default: None - ptxas_options : Union[str, list[str]], optional + ptxas_options : str | list[str], optional Specify one or more options directly to ptxas, the PTX optimizing assembler. Options should be strings. For example ["-v", "-O2"]. Default: None @@ -353,17 +353,17 @@ class ProgramOptions: gen_opt_lto : bool, optional Run the optimizer passes before generating the LTO IR. Default: False - define_macro : Union[str, tuple[str, str], list[Union[str, tuple[str, str]]]], optional + define_macro : str | tuple[str, str] | list[str | tuple[str, str]], optional Predefine a macro. Can be either a string, in which case that macro will be set to 1, a 2 element tuple of strings, in which case the first element is defined as the second, or a list of strings or tuples. Default: None - undefine_macro : Union[str, list[str]], optional + undefine_macro : str | list[str], optional Cancel any previous definition of a macro, or list of macros. Default: None - include_path : Union[str, list[str]], optional + include_path : str | list[str], optional Add the directory or directories to the list of directories to be searched for headers. Default: None - pre_include : Union[str, list[str]], optional + pre_include : str | list[str], optional Preinclude one or more headers during preprocessing. Can be either a string or a list of strings. Default: None no_source_include : bool, optional @@ -396,13 +396,13 @@ class ProgramOptions: no_display_error_number : bool, optional Disable the display of a diagnostic number for warning messages. Default: False - diag_error : Union[int, list[int]], optional + diag_error : int | list[int], optional Emit error for a specified diagnostic message number or comma-separated list of numbers. Default: None - diag_suppress : Union[int, list[int]], optional + diag_suppress : int | list[int], optional Suppress a specified diagnostic message number or comma-separated list of numbers. Default: None - diag_warn : Union[int, list[int]], optional + diag_warn : int | list[int], optional Emit warning for a specified diagnostic message number or comma-separated list of numbers. Default: None brief_diagnostics : bool, optional diff --git a/cuda_core/cuda/core/_resource_handles.pxd b/cuda_core/cuda/core/_resource_handles.pxd index 2637abb5137..2717610a01a 100644 --- a/cuda_core/cuda/core/_resource_handles.pxd +++ b/cuda_core/cuda/core/_resource_handles.pxd @@ -239,7 +239,7 @@ cdef void register_mr_dealloc_callback(MRDeallocCallback cb) noexcept cdef DevicePtrHandle deviceptr_import_ipc( const MemoryPoolHandle& h_pool, const void* export_data, const StreamHandle& h_stream) except+ nogil cdef StreamHandle deallocation_stream(const DevicePtrHandle& h) noexcept nogil -cdef void set_deallocation_stream(const DevicePtrHandle& h, const StreamHandle& h_stream) noexcept nogil +cdef cydriver.CUresult set_deallocation_stream(const DevicePtrHandle& h, const StreamHandle& h_stream) noexcept nogil # Library handles cdef LibraryHandle create_library_handle_from_file(const char* path) except+ nogil diff --git a/cuda_core/cuda/core/_resource_handles.pyi b/cuda_core/cuda/core/_resource_handles.pyi index f11f6f08e00..f9b10d4db3d 100644 --- a/cuda_core/cuda/core/_resource_handles.pyi +++ b/cuda_core/cuda/core/_resource_handles.pyi @@ -26,4 +26,6 @@ MipmappedArrayHandle = shared_ptr TexObjectHandle = shared_ptr SurfObjectHandle = shared_ptr OpaqueHandle = shared_ptr -PreparedAttachment = unique_ptr \ No newline at end of file +PreparedAttachment = unique_ptr +PreparedChildGraphUpdate = shared_ptr +PreparedExecAttachment = unique_ptr \ No newline at end of file diff --git a/cuda_core/cuda/core/_resource_handles.pyx b/cuda_core/cuda/core/_resource_handles.pyx index 464fad6c1bf..aabdb2ea51e 100644 --- a/cuda_core/cuda/core/_resource_handles.pyx +++ b/cuda_core/cuda/core/_resource_handles.pyx @@ -128,7 +128,7 @@ cdef extern from "_cpp/resource_handles.hpp" namespace "cuda_core": const MemoryPoolHandle& h_pool, const void* export_data, const StreamHandle& h_stream) except+ nogil StreamHandle deallocation_stream "cuda_core::deallocation_stream" ( const DevicePtrHandle& h) noexcept nogil - void set_deallocation_stream "cuda_core::set_deallocation_stream" ( + cydriver.CUresult set_deallocation_stream "cuda_core::set_deallocation_stream" ( const DevicePtrHandle& h, const StreamHandle& h_stream) noexcept nogil # Library handles @@ -293,6 +293,7 @@ cdef extern from "_cpp/resource_handles.hpp" namespace "cuda_core": void* p_cuDevicePrimaryCtxRetain "reinterpret_cast<void*&>(cuda_core::p_cuDevicePrimaryCtxRetain)" void* p_cuDevicePrimaryCtxRelease "reinterpret_cast<void*&>(cuda_core::p_cuDevicePrimaryCtxRelease)" void* p_cuCtxGetCurrent "reinterpret_cast<void*&>(cuda_core::p_cuCtxGetCurrent)" + void* p_cuCtxSetCurrent "reinterpret_cast<void*&>(cuda_core::p_cuCtxSetCurrent)" void* p_cuGreenCtxCreate "reinterpret_cast<void*&>(cuda_core::p_cuGreenCtxCreate)" void* p_cuGreenCtxDestroy "reinterpret_cast<void*&>(cuda_core::p_cuGreenCtxDestroy)" void* p_cuCtxFromGreenCtx "reinterpret_cast<void*&>(cuda_core::p_cuCtxFromGreenCtx)" @@ -397,6 +398,7 @@ cdef void* _get_optional_driver_fn(str name): cdef void _init_driver_fn_pointers() noexcept: global p_cuDevicePrimaryCtxRetain, p_cuDevicePrimaryCtxRelease, p_cuCtxGetCurrent + global p_cuCtxSetCurrent global p_cuGreenCtxCreate, p_cuGreenCtxDestroy, p_cuCtxFromGreenCtx global p_cuDevResourceGenerateDesc, p_cuGreenCtxStreamCreate global p_cuStreamCreateWithPriority, p_cuStreamDestroy @@ -425,6 +427,7 @@ cdef void _init_driver_fn_pointers() noexcept: p_cuDevicePrimaryCtxRetain = _get_driver_fn("cuDevicePrimaryCtxRetain") p_cuDevicePrimaryCtxRelease = _get_driver_fn("cuDevicePrimaryCtxRelease") p_cuCtxGetCurrent = _get_driver_fn("cuCtxGetCurrent") + p_cuCtxSetCurrent = _get_driver_fn("cuCtxSetCurrent") p_cuGreenCtxCreate = _get_optional_driver_fn("cuGreenCtxCreate") p_cuGreenCtxDestroy = _get_optional_driver_fn("cuGreenCtxDestroy") p_cuCtxFromGreenCtx = _get_optional_driver_fn("cuCtxFromGreenCtx") diff --git a/cuda_core/cuda/core/_stream.pxd b/cuda_core/cuda/core/_stream.pxd index de16b84bde2..dc9a2da826c 100644 --- a/cuda_core/cuda/core/_stream.pxd +++ b/cuda_core/cuda/core/_stream.pxd @@ -23,3 +23,4 @@ cdef class Stream: cpdef Stream default_stream() cpdef Stream Stream_accept(arg, bint allow_stream_protocol=*) +cdef bint Stream_is_default_token(Stream self) noexcept nogil diff --git a/cuda_core/cuda/core/_stream.pyi b/cuda_core/cuda/core/_stream.pyi index f4d78982a1d..99af5f9b15b 100644 --- a/cuda_core/cuda/core/_stream.pyi +++ b/cuda_core/cuda/core/_stream.pyi @@ -131,6 +131,13 @@ class Stream: :obj:`~_event.Event` Newly created event object. + Note + ---- + A default stream (:obj:`LEGACY_DEFAULT_STREAM` or + :obj:`PER_THREAD_DEFAULT_STREAM`) carries no context of its own; it + refers to whichever context is current, so a newly created event is + associated with the current context at call time. + """ def wait(self, event_or_stream: Event | Stream) -> None: @@ -157,15 +164,29 @@ class Stream: Note ---- - The current context on the device may differ from this - stream's context. This case occurs when a different CUDA - context is set current after a stream is created. + A default stream (:obj:`LEGACY_DEFAULT_STREAM` or + :obj:`PER_THREAD_DEFAULT_STREAM`) carries no context of its own; it + refers to whichever context is current, so this returns the device for + the current context at call time. + + For a created stream, the current context on the device may differ from + this stream's context. That case occurs when a different CUDA context is + set current after the stream is created. """ @property def context(self) -> Context: - """Return the :obj:`~_context.Context` associated with this stream.""" + """Return the :obj:`~_context.Context` associated with this stream. + + Note + ---- + A default stream (:obj:`LEGACY_DEFAULT_STREAM` or + :obj:`PER_THREAD_DEFAULT_STREAM`) carries no context of its own; it + refers to whichever context is current, so this returns the current + context at call time. + + """ @property def resources(self) -> DeviceResources: @@ -174,6 +195,14 @@ class Stream: For streams created from a green context, returns the resources that context was provisioned with. For streams on the primary context, returns the full device resources. + + Note + ---- + A default stream (:obj:`LEGACY_DEFAULT_STREAM` or + :obj:`PER_THREAD_DEFAULT_STREAM`) carries no context of its own; it + refers to whichever context is current, so this queries the current + context at call time. + """ @staticmethod @@ -212,6 +241,7 @@ class Stream: Newly created graph builder object. """ +__all__ = ['LEGACY_DEFAULT_STREAM', 'PER_THREAD_DEFAULT_STREAM', 'Stream', 'StreamOptions'] LEGACY_DEFAULT_STREAM: Stream = Stream._legacy_default() PER_THREAD_DEFAULT_STREAM: Stream = Stream._per_thread_default() diff --git a/cuda_core/cuda/core/_tensor_map.pyi b/cuda_core/cuda/core/_tensor_map.pyi index 986ab41549f..c6a18ad2399 100644 --- a/cuda_core/cuda/core/_tensor_map.pyi +++ b/cuda_core/cuda/core/_tensor_map.pyi @@ -284,6 +284,7 @@ class TensorMapDescriptor: def __repr__(self) -> str: ... +__all__ = ['TensorMapDescriptor', 'TensorMapDescriptorOptions'] _TMA_DT_UINT8 = int(cydriver.CU_TENSOR_MAP_DATA_TYPE_UINT8) _TMA_DT_UINT16 = int(cydriver.CU_TENSOR_MAP_DATA_TYPE_UINT16) _TMA_DT_UINT32 = int(cydriver.CU_TENSOR_MAP_DATA_TYPE_UINT32) diff --git a/cuda_core/cuda/core/_utils/_weak_handles.pyi b/cuda_core/cuda/core/_utils/_weak_handles.pyi index 3cf095d7b87..5b7913e008a 100644 --- a/cuda_core/cuda/core/_utils/_weak_handles.pyi +++ b/cuda_core/cuda/core/_utils/_weak_handles.pyi @@ -43,8 +43,9 @@ class WeakHandle: def weak_handle(obj): """Return a :class:`WeakHandle` observing the resource behind ``obj``. - Currently supports :class:`~cuda.core.Buffer` (device allocation handle). - See the module docstring for how to add more types. + Currently supports :class:`~cuda.core.Buffer` (allocation handle) and + :class:`~cuda.core.graph.GraphDefinition` (graph hierarchy handle). See + the module docstring for how to add more types. Raises ------ diff --git a/cuda_core/cuda/core/_utils/cuda_utils.pxd b/cuda_core/cuda/core/_utils/cuda_utils.pxd index 11e464e6381..9b485597912 100644 --- a/cuda_core/cuda/core/_utils/cuda_utils.pxd +++ b/cuda_core/cuda/core/_utils/cuda_utils.pxd @@ -18,11 +18,35 @@ ctypedef fused integer_t: cdef const cydriver.CUcontext CU_CONTEXT_INVALID = <cydriver.CUcontext>(-2) -cdef int HANDLE_RETURN(cydriver.CUresult err) except?-1 nogil -cdef int HANDLE_RETURN_NVRTC(cynvrtc.nvrtcProgram prog, cynvrtc.nvrtcResult err) except?-1 nogil -cdef int HANDLE_RETURN_NVVM(cynvvm.nvvmProgram prog, cynvvm.nvvmResult err) except?-1 nogil -cdef int HANDLE_RETURN_NVJITLINK( - cynvjitlink.nvJitLinkHandle handle, cynvjitlink.nvJitLinkResult err) except?-1 nogil +cdef inline int HANDLE_RETURN(cydriver.CUresult err) except?-1 nogil: + if err != cydriver.CUresult.CUDA_SUCCESS: + return _check_driver_error(err) + return 0 + + +cdef inline int HANDLE_RETURN_NVRTC(cynvrtc.nvrtcProgram prog, cynvrtc.nvrtcResult err) except?-1 nogil: + """Handle NVRTC result codes, raising NVRTCError with program log on failure.""" + if err == cynvrtc.nvrtcResult.NVRTC_SUCCESS: + return 0 + with gil: + _raise_nvrtc_error(prog, err) + + +cdef inline int HANDLE_RETURN_NVVM(cynvvm.nvvmProgram prog, cynvvm.nvvmResult err) except?-1 nogil: + """Handle NVVM result codes, raising nvvmError with program log on failure.""" + if err == cynvvm.nvvmResult.NVVM_SUCCESS: + return 0 + with gil: + _raise_nvvm_error(prog, err) + + +cdef inline int HANDLE_RETURN_NVJITLINK( + cynvjitlink.nvJitLinkHandle handle, cynvjitlink.nvJitLinkResult err) except?-1 nogil: + """Handle nvJitLink result codes, raising nvJitLinkError with error log on failure.""" + if err == cynvjitlink.nvJitLinkResult.NVJITLINK_SUCCESS: + return 0 + with gil: + _raise_nvjitlink_error(handle, err) # Helper for retrieving the current CUDA device. Raises if no active context @@ -34,7 +58,9 @@ cdef int _get_current_device_id() except? -1 cpdef int _check_driver_error(cydriver.CUresult error) except?-1 nogil cpdef int _check_runtime_error(error) except?-1 cpdef int _check_nvrtc_error(error) except?-1 - +cdef int _raise_nvrtc_error(cynvrtc.nvrtcProgram prog, cynvrtc.nvrtcResult err) except -1 +cdef int _raise_nvvm_error(cynvvm.nvvmProgram prog, cynvvm.nvvmResult err) except -1 +cdef int _raise_nvjitlink_error(cynvjitlink.nvJitLinkHandle handle, cynvjitlink.nvJitLinkResult err) except -1 cpdef check_or_create_options(type cls, options, str options_description=*, bint keep_none=*) diff --git a/cuda_core/cuda/core/_utils/cuda_utils.pyx b/cuda_core/cuda/core/_utils/cuda_utils.pyx index 318d4466bee..cf3415b3458 100644 --- a/cuda_core/cuda/core/_utils/cuda_utils.pyx +++ b/cuda_core/cuda/core/_utils/cuda_utils.pyx @@ -63,12 +63,6 @@ def cast_to_3_tuple(label: str, cfg: int | tuple[int, ...]) -> tuple[int, int, i return cfg + (1,) * (3 - len(cfg)) -cdef int HANDLE_RETURN(cydriver.CUresult err) except?-1 nogil: - if err != cydriver.CUresult.CUDA_SUCCESS: - return _check_driver_error(err) - return 0 - - cdef int _get_current_device_id() except? -1: """Return the current thread's bound CUdevice ordinal.""" cdef cydriver.CUdevice dev @@ -77,14 +71,6 @@ cdef int _get_current_device_id() except? -1: return <int>dev -cdef int HANDLE_RETURN_NVRTC(cynvrtc.nvrtcProgram prog, cynvrtc.nvrtcResult err) except?-1 nogil: - """Handle NVRTC result codes, raising NVRTCError with program log on failure.""" - if err == cynvrtc.nvrtcResult.NVRTC_SUCCESS: - return 0 - with gil: - _raise_nvrtc_error(prog, err) - - cdef int _raise_nvrtc_error(cynvrtc.nvrtcProgram prog, cynvrtc.nvrtcResult err) except -1: """Build error message with program log and raise NVRTCError.""" cdef const char* err_str = cynvrtc.nvrtcGetErrorString(err) @@ -103,14 +89,6 @@ cdef int _raise_nvrtc_error(cynvrtc.nvrtcProgram prog, cynvrtc.nvrtcResult err) raise NVRTCError(err_msg) -cdef int HANDLE_RETURN_NVVM(cynvvm.nvvmProgram prog, cynvvm.nvvmResult err) except?-1 nogil: - """Handle NVVM result codes, raising nvvmError with program log on failure.""" - if err == cynvvm.nvvmResult.NVVM_SUCCESS: - return 0 - with gil: - _raise_nvvm_error(prog, err) - - cdef int _raise_nvvm_error(cynvvm.nvvmProgram prog, cynvvm.nvvmResult err) except -1: """Raise nvvmError annotated with the program log.""" cdef size_t logsize = 0 @@ -128,15 +106,6 @@ cdef int _raise_nvvm_error(cynvvm.nvvmProgram prog, cynvvm.nvvmResult err) excep raise exc -cdef int HANDLE_RETURN_NVJITLINK( - cynvjitlink.nvJitLinkHandle handle, cynvjitlink.nvJitLinkResult err) except?-1 nogil: - """Handle nvJitLink result codes, raising nvJitLinkError with error log on failure.""" - if err == cynvjitlink.nvJitLinkResult.NVJITLINK_SUCCESS: - return 0 - with gil: - _raise_nvjitlink_error(handle, err) - - cdef int _raise_nvjitlink_error( cynvjitlink.nvJitLinkHandle handle, cynvjitlink.nvJitLinkResult err) except -1: """Raise nvJitLinkError annotated with the error log.""" diff --git a/cuda_core/cuda/core/_utils/version.pyi b/cuda_core/cuda/core/_utils/version.pyi index bb7f0129917..a577e037bf7 100644 --- a/cuda_core/cuda/core/_utils/version.pyi +++ b/cuda_core/cuda/core/_utils/version.pyi @@ -5,6 +5,14 @@ from __future__ import annotations import functools +def _parse_version_triple(version_str: str) -> tuple[int, int, int]: + """Parse a PEP 440 version string into a (major, minor, patch) triple. + + Strips local-version identifiers and handles pre-release suffixes such as + ``0b1`` or ``0rc1`` by extracting only the leading integer from each + release segment. + """ + @functools.cache def binding_version() -> tuple[int, int, int]: """Return the cuda-bindings version as a (major, minor, patch) triple.""" diff --git a/cuda_core/cuda/core/graph/_adjacency_set_proxy.pyx b/cuda_core/cuda/core/graph/_adjacency_set_proxy.pyx index e1762321ce0..971e418a428 100644 --- a/cuda_core/cuda/core/graph/_adjacency_set_proxy.pyx +++ b/cuda_core/cuda/core/graph/_adjacency_set_proxy.pyx @@ -144,20 +144,23 @@ cdef class _AdjacencySetCore: cdef cydriver.CUgraphNode c_node = as_cu(self._h_node) if c_node == NULL: return [] - cdef cydriver.CUgraphNode buf[16] - cdef size_t count = 16 + cdef cydriver.CUgraphNode stack_buf[16] + cdef cydriver.CUgraphNode* nodes + cdef size_t count = 0 cdef size_t i with nogil: - HANDLE_RETURN(self._query_fn(c_node, buf, &count)) - if count <= 16: - return [GraphNode._create(self._h_graph, buf[i]) - for i in range(count)] + HANDLE_RETURN(self._query_fn(c_node, NULL, &count)) + if count == 0: + return [] cdef vector[cydriver.CUgraphNode] nodes_vec - nodes_vec.resize(count) + if count <= 16: + nodes = stack_buf + else: + nodes_vec.resize(count) + nodes = nodes_vec.data() with nogil: - HANDLE_RETURN(self._query_fn( - c_node, nodes_vec.data(), &count)) - return [GraphNode._create(self._h_graph, nodes_vec[i]) + HANDLE_RETURN(self._query_fn(c_node, nodes, &count)) + return [GraphNode._create(self._h_graph, nodes[i]) for i in range(count)] cdef bint contains(self, GraphNode other): @@ -165,27 +168,24 @@ cdef class _AdjacencySetCore: cdef cydriver.CUgraphNode target = as_cu(other._h_node) if c_node == NULL or target == NULL: return False - cdef cydriver.CUgraphNode buf[16] - cdef size_t count = 16 + cdef cydriver.CUgraphNode stack_buf[16] + cdef cydriver.CUgraphNode* nodes + cdef size_t count = 0 cdef size_t i with nogil: - HANDLE_RETURN(self._query_fn(c_node, buf, &count)) - - # Fast path for small sets. - if count <= 16: - for i in range(count): - if buf[i] == target: - return True + HANDLE_RETURN(self._query_fn(c_node, NULL, &count)) + if count == 0: return False - - # Fallback for large sets. cdef vector[cydriver.CUgraphNode] nodes_vec - nodes_vec.resize(count) + if count <= 16: + nodes = stack_buf + else: + nodes_vec.resize(count) + nodes = nodes_vec.data() with nogil: - HANDLE_RETURN(self._query_fn(c_node, nodes_vec.data(), &count)) - assert count == nodes_vec.size() + HANDLE_RETURN(self._query_fn(c_node, nodes, &count)) for i in range(count): - if nodes_vec[i] == target: + if nodes[i] == target: return True return False diff --git a/cuda_core/cuda/core/graph/_graph_builder.pyi b/cuda_core/cuda/core/graph/_graph_builder.pyi index 4fbc6fb3903..d238b419be1 100644 --- a/cuda_core/cuda/core/graph/_graph_builder.pyi +++ b/cuda_core/cuda/core/graph/_graph_builder.pyi @@ -7,6 +7,8 @@ from dataclasses import dataclass from cuda.core._stream import Stream from cuda.core._utils.cuda_utils import driver from cuda.core.graph._graph_definition import GraphCondition, GraphDefinition +from cuda.core.graph._graph_node import GraphNode +from cuda.core.graph._subclasses import ExecutableGraphNode _BuilderKind = int _CaptureState = int @@ -407,10 +409,12 @@ class GraphBuilder: - **Python callable**: Pass any callable. The GIL is acquired automatically. The callable must take no arguments; use closures or ``functools.partial`` to bind state. - - **ctypes function pointer**: Pass a ``ctypes.CFUNCTYPE`` instance. - The function receives a single ``void*`` argument (the - ``user_data``). The caller must keep the ctypes wrapper alive - for the lifetime of the graph. + - **ctypes function pointer**: The function receives a single + ``void*`` argument (the ``user_data``), and the caller must keep + the ctypes wrapper alive for the lifetime of the graph. Its + declared prototype must match the driver's ``CUhostFn`` + (``void (*)(void*)``): ``ctypes.CFUNCTYPE(None, ctypes.c_void_p)``, + or ``ctypes.WINFUNCTYPE(None, ctypes.c_void_p)`` on Windows. .. warning:: @@ -430,6 +434,14 @@ class GraphBuilder: Only for ctypes function pointers. If ``int``, passed as a raw pointer (caller manages lifetime). If bytes-like, the data is copied and its lifetime is tied to the graph. + + Raises + ------ + TypeError + If ``fn`` is a ctypes function pointer whose declared prototype + does not match ``CUhostFn``. + ValueError + If ``user_data`` is given for a Python callable. """ class Graph: @@ -460,6 +472,15 @@ class Graph: """ + def __getitem__(self, node: GraphNode) -> ExecutableGraphNode: + """Return a view for updating *node* in this executable graph. + + *node* is a definition node from the graph used to instantiate this + executable. Call ``update()`` on the returned view to replace that + node's parameters for future launches. Kernel, memcpy, and memset + views also support enabling and disabling the node. + """ + def update(self, source: 'GraphBuilder | GraphDefinition') -> None: """Update the graph using a new graph definition. @@ -494,7 +515,7 @@ class Graph: """ __all__ = ['Graph', 'GraphBuilder', 'GraphCompleteOptions', 'GraphDebugPrintOptions'] -def _instantiate_graph(h_graph, options: GraphCompleteOptions | None=None) -> Graph: +def _instantiate_graph(source, options: GraphCompleteOptions | None=None) -> Graph: ... def _capture_callback_with_tail_failure_for_testing(gb: GraphBuilder, fn, *, user_data=None): diff --git a/cuda_core/cuda/core/graph/_graph_definition.pyx b/cuda_core/cuda/core/graph/_graph_definition.pyx index 46896899ecd..e4bed7eef15 100644 --- a/cuda_core/cuda/core/graph/_graph_definition.pyx +++ b/cuda_core/cuda/core/graph/_graph_definition.pyx @@ -361,19 +361,17 @@ cdef class GraphDefinition: All nodes in the graph. """ cdef vector[cydriver.CUgraphNode] nodes_vec - nodes_vec.resize(128) - cdef size_t num_nodes = 128 + cdef size_t num_nodes = 0 with nogil: - HANDLE_RETURN(cydriver.cuGraphGetNodes(as_cu(self._h_graph), nodes_vec.data(), &num_nodes)) + HANDLE_RETURN(cydriver.cuGraphGetNodes(as_cu(self._h_graph), NULL, &num_nodes)) if num_nodes == 0: return set() - if num_nodes > 128: - nodes_vec.resize(num_nodes) - with nogil: - HANDLE_RETURN(cydriver.cuGraphGetNodes(as_cu(self._h_graph), nodes_vec.data(), &num_nodes)) + nodes_vec.resize(num_nodes) + with nogil: + HANDLE_RETURN(cydriver.cuGraphGetNodes(as_cu(self._h_graph), nodes_vec.data(), &num_nodes)) return {GraphNode._create(self._h_graph, nodes_vec[i]) for i in range(num_nodes)} @@ -388,31 +386,28 @@ cdef class GraphDefinition: """ cdef vector[cydriver.CUgraphNode] from_nodes cdef vector[cydriver.CUgraphNode] to_nodes - from_nodes.resize(128) - to_nodes.resize(128) - cdef size_t num_edges = 128 + cdef size_t num_edges = 0 with nogil: IF CUDA_CORE_BUILD_MAJOR >= 13: HANDLE_RETURN(cydriver.cuGraphGetEdges( - as_cu(self._h_graph), from_nodes.data(), to_nodes.data(), NULL, &num_edges)) + as_cu(self._h_graph), NULL, NULL, NULL, &num_edges)) ELSE: HANDLE_RETURN(cydriver.cuGraphGetEdges( - as_cu(self._h_graph), from_nodes.data(), to_nodes.data(), &num_edges)) + as_cu(self._h_graph), NULL, NULL, &num_edges)) if num_edges == 0: return set() - if num_edges > 128: - from_nodes.resize(num_edges) - to_nodes.resize(num_edges) - with nogil: - IF CUDA_CORE_BUILD_MAJOR >= 13: - HANDLE_RETURN(cydriver.cuGraphGetEdges( - as_cu(self._h_graph), from_nodes.data(), to_nodes.data(), NULL, &num_edges)) - ELSE: - HANDLE_RETURN(cydriver.cuGraphGetEdges( - as_cu(self._h_graph), from_nodes.data(), to_nodes.data(), &num_edges)) + from_nodes.resize(num_edges) + to_nodes.resize(num_edges) + with nogil: + IF CUDA_CORE_BUILD_MAJOR >= 13: + HANDLE_RETURN(cydriver.cuGraphGetEdges( + as_cu(self._h_graph), from_nodes.data(), to_nodes.data(), NULL, &num_edges)) + ELSE: + HANDLE_RETURN(cydriver.cuGraphGetEdges( + as_cu(self._h_graph), from_nodes.data(), to_nodes.data(), &num_edges)) return { (GraphNode._create(self._h_graph, from_nodes[i]), diff --git a/cuda_core/cuda/core/graph/_graph_node.pyi b/cuda_core/cuda/core/graph/_graph_node.pyi index 23bcbf191a3..0e3cac045d2 100644 --- a/cuda_core/cuda/core/graph/_graph_node.pyi +++ b/cuda_core/cuda/core/graph/_graph_node.pyi @@ -94,6 +94,9 @@ class GraphNode: def launch(self, config: LaunchConfig, kernel: Kernel, *args) -> KernelNode: """Add a kernel launch node depending on this node. + Clustered and cooperative launch configurations are not currently + supported for graph kernel nodes. + .. warning:: Use caution when a retained kernel argument directly or indirectly @@ -330,10 +333,12 @@ class GraphNode: - **Python callable**: Pass any callable. The GIL is acquired automatically. The callable must take no arguments; use closures or ``functools.partial`` to bind state. - - **ctypes function pointer**: Pass a ``ctypes.CFUNCTYPE`` instance. - The function receives a single ``void*`` argument (the - ``user_data``). The caller must keep the ctypes wrapper alive - for the lifetime of the graph. + - **ctypes function pointer**: The function receives a single + ``void*`` argument (the ``user_data``), and the caller must keep + the ctypes wrapper alive for the lifetime of the graph. Its + declared prototype must match the driver's ``CUhostFn`` + (``void (*)(void*)``): ``ctypes.CFUNCTYPE(None, ctypes.c_void_p)``, + or ``ctypes.WINFUNCTYPE(None, ctypes.c_void_p)`` on Windows. .. warning:: @@ -358,6 +363,14 @@ class GraphNode: ------- HostCallbackNode A new HostCallbackNode representing the callback. + + Raises + ------ + TypeError + If ``fn`` is a ctypes function pointer whose declared prototype + does not match ``CUhostFn``. + ValueError + If ``user_data`` is given for a Python callable. """ def if_then(self, condition: GraphCondition) -> IfNode: diff --git a/cuda_core/cuda/core/graph/_graph_node.pyx b/cuda_core/cuda/core/graph/_graph_node.pyx index 2c9c07e6b3a..c4b6b02bf37 100644 --- a/cuda_core/cuda/core/graph/_graph_node.pyx +++ b/cuda_core/cuda/core/graph/_graph_node.pyx @@ -827,6 +827,7 @@ cdef inline AllocNode GN_alloc(GraphNode self, size_t size, object device, num_deps = 1 cdef vector[cydriver.CUmemAccessDesc] access_descs + cdef cydriver.CUmemAccessDesc access_desc cdef int peer_id cdef list peer_ids = [] @@ -834,13 +835,10 @@ cdef inline AllocNode GN_alloc(GraphNode self, size_t size, object device, for peer_dev in peer_access: peer_id = getattr(peer_dev, 'device_id', peer_dev) peer_ids.append(peer_id) - access_descs.push_back(cydriver.CUmemAccessDesc_st( - cydriver.CUmemLocation_st( - cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_DEVICE, - peer_id - ), - cydriver.CUmemAccess_flags.CU_MEM_ACCESS_FLAGS_PROT_READWRITE - )) + access_desc.location.type = cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_DEVICE + access_desc.location.id = peer_id + access_desc.flags = cydriver.CUmemAccess_flags.CU_MEM_ACCESS_FLAGS_PROT_READWRITE + access_descs.push_back(access_desc) cdef str memory_type_str = "device" if memory_type is None else str(memory_type) diff --git a/cuda_core/cuda/core/graph/_host_callback.pyi b/cuda_core/cuda/core/graph/_host_callback.pyi index 6c9d0ead317..1c642abf501 100644 --- a/cuda_core/cuda/core/graph/_host_callback.pyi +++ b/cuda_core/cuda/core/graph/_host_callback.pyi @@ -1,3 +1,19 @@ # This file was generated by stubgen-pyx v0.2.6 from cuda_core/cuda/core/graph/_host_callback.pyx -from __future__ import annotations \ No newline at end of file +from __future__ import annotations + +import sys + +_CUHOSTFN_HINT = 'ctypes.CFUNCTYPE(None, ctypes.c_void_p)' if sys.platform != 'win32' else 'ctypes.CFUNCTYPE(None, ctypes.c_void_p) or ctypes.WINFUNCTYPE(None, ctypes.c_void_p)' + +def _cuhostfn_type_error(detail): + """Build the rejection message for a non-conforming ctypes callback.""" + +def _validate_ctypes_host_callback(fn): + """Reject ctypes callbacks whose declared prototype is not CUhostFn. + + ``restype`` and ``argtypes`` are the prototype the caller declared, and are + what CUDA calls through. A function pointer taken from a shared library + keeps ctypes' defaults -- a ``c_int`` result and unspecified arguments -- + until the caller declares otherwise, so it must be declared to be accepted. + """ \ No newline at end of file diff --git a/cuda_core/cuda/core/graph/_subclasses.pyi b/cuda_core/cuda/core/graph/_subclasses.pyi index 345e6417c4d..a68e500f7f2 100644 --- a/cuda_core/cuda/core/graph/_subclasses.pyi +++ b/cuda_core/cuda/core/graph/_subclasses.pyi @@ -5,6 +5,7 @@ from __future__ import annotations from cuda.core._event import Event from cuda.core._launch_config import LaunchConfig +from cuda.core._memory._buffer import Buffer from cuda.core._module import Kernel from cuda.core.graph._graph_definition import GraphCondition, GraphDefinition from cuda.core.graph._graph_node import GraphNode @@ -37,6 +38,21 @@ class KernelNode(GraphNode): def __repr__(self) -> str: ... + def update(self, *, config: LaunchConfig | None=None, kernel: Kernel | None=None, args=None) -> None: + """Replace selected kernel launch parameters. + + Omitted parameters preserve their current values. Changing ``kernel`` + requires ``args``, including ``args=()`` for a no-argument kernel. + Clustered and cooperative kernel nodes are not supported. + + .. warning:: + + Use caution when a retained kernel argument directly or indirectly + owns a graph. Any reference cycle involving the argument and a + graph that retains it cannot be broken by Python's cyclic garbage + collector. Use a weak reference to break such cycles. + """ + @property def grid(self) -> tuple[int, int, int]: """Grid dimensions as a 3-tuple (gridDimX, gridDimY, gridDimZ).""" @@ -139,6 +155,24 @@ class MemsetNode(GraphNode): def __repr__(self) -> str: ... + def update(self, *, dst: Buffer | int | None=None, value=None, width: int | None=None, height: int | None=None, pitch: int | None=None, dst_owner=None) -> None: + """Replace selected memset parameters. + + Omitted parameters preserve their current values. ``dst_owner`` may + only accompany a raw-address ``dst``. + + With CUDA 12.2 through 13.1, the node's intended CUDA context must be + current when this method is called. CUDA driver and ``cuda.bindings`` + versions 13.2 and newer preserve the recorded context automatically. + + .. warning:: + + Use caution when a retained operand owner directly or indirectly + owns a graph. Any reference cycle involving the owner and a graph + that retains it cannot be broken by Python's cyclic garbage + collector. Use a weak reference to break such cycles. + """ + @property def dptr(self) -> int: """The destination device pointer.""" @@ -179,6 +213,26 @@ class MemcpyNode(GraphNode): def __repr__(self) -> str: ... + def update(self, *, dst: Buffer | int | None=None, src: Buffer | int | None=None, size: int | None=None, dst_owner=None, src_owner=None) -> None: + """Replace selected memcpy parameters. + + Omitted parameters preserve their current values. ``dst_owner`` and + ``src_owner`` may only accompany their corresponding raw addresses. + Multidimensional, pitched, offset, and array-backed memcpy nodes are + not supported. + + With CUDA 12.2 through 13.1, the node's intended CUDA context must be + current when this method is called. CUDA driver and ``cuda.bindings`` + versions 13.2 and newer preserve the recorded context automatically. + + .. warning:: + + Use caution when a retained operand owner directly or indirectly + owns a graph. Any reference cycle involving the owner and a graph + that retains it cannot be broken by Python's cyclic garbage + collector. Use a weak reference to break such cycles. + """ + @property def dst(self) -> int: """The destination pointer.""" @@ -203,6 +257,12 @@ class ChildGraphNode(GraphNode): def __repr__(self) -> str: ... + def update(self, child: GraphDefinition) -> None: + """Replace the embedded graph with a clone of ``child``. + + ``child`` must belong to an independent graph hierarchy. + """ + @property def child_graph(self) -> GraphDefinition: """The embedded graph definition (non-owning wrapper).""" @@ -219,6 +279,9 @@ class EventRecordNode(GraphNode): def __repr__(self) -> str: ... + def update(self, event: Event) -> None: + """Replace the event recorded by this node.""" + @property def event(self) -> Event: """The event being recorded.""" @@ -235,6 +298,9 @@ class EventWaitNode(GraphNode): def __repr__(self) -> str: ... + def update(self, event: Event) -> None: + """Replace the event waited on by this node.""" + @property def event(self) -> Event: """The event being waited on.""" @@ -251,6 +317,25 @@ class HostCallbackNode(GraphNode): def __repr__(self) -> str: ... + def update(self, fn, *, user_data=None) -> None: + """Replace the callback and user-data binding for this node. + + ``fn`` accepts the same forms as :meth:`~graph.GraphNode.callback`: a + Python callable, or a ctypes function pointer whose declared prototype + matches ``CUhostFn`` (``void (*)(void*)``). A mismatched ctypes + prototype raises ``TypeError``. + + .. warning:: + + Callbacks must not call CUDA API functions. Doing so may + deadlock or corrupt driver state. + + Use caution when a Python callback retains an object that owns a + graph. Any reference cycle involving the callback and a graph that + retains it cannot be broken by Python's cyclic garbage collector. + Use a weak reference to break such cycles. + """ + @property def callback(self): """The Python callable, or None for ctypes function pointer callbacks.""" @@ -336,4 +421,105 @@ class SwitchNode(ConditionalNode): def __repr__(self) -> str: ... -__all__ = ['AllocNode', 'ChildGraphNode', 'ConditionalNode', 'EmptyNode', 'EventRecordNode', 'EventWaitNode', 'FreeNode', 'HostCallbackNode', 'IfElseNode', 'IfNode', 'KernelNode', 'MemcpyNode', 'MemsetNode', 'SwitchNode', 'WhileNode'] \ No newline at end of file + +class ExecutableGraphNode: + """A lightweight view pairing an executable graph with a source node. + + Create executable-node views with ``graph[node]``. CUDA validates that the + node identifies a node in the executable graph when an operation is + performed. + """ + + def __init__(self): + ... + + def __repr__(self) -> str: + ... + +class ExecutableKernelNode(ExecutableGraphNode): + """An executable kernel-node view.""" + + def update(self, *, config: LaunchConfig, kernel: Kernel, args) -> None: + """Replace all kernel launch parameters for future launches. + + ``args`` must contain the complete argument sequence; use ``args=()`` + for a no-argument kernel. Clustered and cooperative launch + configurations are not supported. + """ + + @property + def is_enabled(self) -> bool: + """Whether this node is enabled in the executable graph.""" + + def enable(self) -> None: + """Enable this node in the executable graph.""" + + def disable(self) -> None: + """Disable this node in the executable graph.""" + +class ExecutableMemsetNode(ExecutableGraphNode): + """An executable memset-node view.""" + + def update(self, *, dst: Buffer | int, value, width: int, height: int=1, pitch: int=0) -> None: + """Replace all memset parameters for future launches.""" + + @property + def is_enabled(self) -> bool: + """Whether this node is enabled in the executable graph.""" + + def enable(self) -> None: + """Enable this node in the executable graph.""" + + def disable(self) -> None: + """Disable this node in the executable graph.""" + +class ExecutableMemcpyNode(ExecutableGraphNode): + """An executable memcpy-node view.""" + + def update(self, *, dst: Buffer | int, src: Buffer | int, size: int) -> None: + """Replace all one-dimensional memcpy parameters for future launches.""" + + @property + def is_enabled(self) -> bool: + """Whether this node is enabled in the executable graph.""" + + def enable(self) -> None: + """Enable this node in the executable graph.""" + + def disable(self) -> None: + """Disable this node in the executable graph.""" + +class ExecutableChildGraphNode(ExecutableGraphNode): + """An executable child-graph-node view.""" + + def update(self, child: GraphDefinition) -> None: + """Replace the embedded graph parameters for future launches.""" + +class ExecutableEventRecordNode(ExecutableGraphNode): + """An executable event-record-node view.""" + + def update(self, event: Event) -> None: + """Replace the event recorded by future launches.""" + +class ExecutableEventWaitNode(ExecutableGraphNode): + """An executable event-wait-node view.""" + + def update(self, event: Event) -> None: + """Replace the event waited on by future launches.""" + +class ExecutableHostCallbackNode(ExecutableGraphNode): + """An executable host-callback-node view.""" + + def update(self, fn, *, user_data=None) -> None: + """Replace the callback and user-data binding for future launches. + + ``fn`` may be a Python callable, or a ctypes function pointer whose + declared prototype matches ``CUhostFn`` (``void (*)(void*)``); a + mismatched prototype raises ``TypeError``. + + .. warning:: + + Callbacks must not call CUDA API functions. Doing so may deadlock + or corrupt driver state. + """ +__all__ = ['AllocNode', 'ChildGraphNode', 'ConditionalNode', 'EmptyNode', 'EventRecordNode', 'EventWaitNode', 'ExecutableChildGraphNode', 'ExecutableEventRecordNode', 'ExecutableEventWaitNode', 'ExecutableGraphNode', 'ExecutableHostCallbackNode', 'ExecutableKernelNode', 'ExecutableMemcpyNode', 'ExecutableMemsetNode', 'FreeNode', 'HostCallbackNode', 'IfElseNode', 'IfNode', 'KernelNode', 'MemcpyNode', 'MemsetNode', 'SwitchNode', 'WhileNode'] \ No newline at end of file diff --git a/cuda_core/cuda/core/system/_device.pyi b/cuda_core/cuda/core/system/_device.pyi index 4e0fa8cbb88..44e27fce607 100644 --- a/cuda_core/cuda/core/system/_device.pyi +++ b/cuda_core/cuda/core/system/_device.pyi @@ -1036,7 +1036,7 @@ class ProcessInfo: Information about running compute processes on the GPU. """ - def __init__(self, device: 'Device', process_info: nvml.ProcessInfo): + def __init__(self, device: Device, process_info: nvml.ProcessInfo): ... @property diff --git a/cuda_core/cuda/core/utils/__init__.py b/cuda_core/cuda/core/utils/__init__.py index 93a4c14c083..bc0a38f2b40 100644 --- a/cuda_core/cuda/core/utils/__init__.py +++ b/cuda_core/cuda/core/utils/__init__.py @@ -2,6 +2,12 @@ # # SPDX-License-Identifier: Apache-2.0 +from cuda.core._memory._copy_enums import ( + CopyOptions, + MemcpyOverlapMode, + MemcpySrcAccessOrder, +) +from cuda.core._memory._copy_ops import copy_batch from cuda.core._memory._managed_memory_ops import ( discard_batch, discard_prefetch_batch, @@ -19,11 +25,15 @@ ) __all__ = [ + "CopyOptions", "FileStreamProgramCache", "InMemoryProgramCache", + "MemcpyOverlapMode", + "MemcpySrcAccessOrder", "ProgramCacheResource", "StridedMemoryView", "args_viewable_as_strided_memory", + "copy_batch", "discard_batch", "discard_prefetch_batch", "make_program_cache_key", diff --git a/cuda_core/docs/source/api.rst b/cuda_core/docs/source/api.rst index e903a46a7ee..38ff695ace5 100644 --- a/cuda_core/docs/source/api.rst +++ b/cuda_core/docs/source/api.rst @@ -377,6 +377,7 @@ Utility functions :toctree: generated/ utils.args_viewable_as_strided_memory + utils.copy_batch utils.prefetch_batch utils.discard_batch utils.discard_prefetch_batch @@ -384,3 +385,20 @@ Utility functions :template: autosummary/cyclass.rst utils.StridedMemoryView + +Data transfer options +````````````````````` + +.. currentmodule:: cuda.core + +.. autosummary:: + :toctree: generated/ + + :template: dataclass.rst + + utils.CopyOptions + + :template: class.rst + + utils.MemcpySrcAccessOrder + utils.MemcpyOverlapMode diff --git a/cuda_core/docs/source/environment_variables.rst b/cuda_core/docs/source/environment_variables.rst index b9201abc505..b7e4418bb58 100644 --- a/cuda_core/docs/source/environment_variables.rst +++ b/cuda_core/docs/source/environment_variables.rst @@ -24,3 +24,10 @@ Runtime Environment Variables warnings about CUDA major version mismatches between ``cuda-bindings`` and the installed driver. This warning occurs when ``cuda-bindings`` was built for a newer CUDA major version than the installed driver supports. + +- ``CUDA_CORE_DONT_FIX_TAB_COMPLETION`` : When set to 1, ``import cuda.core`` + does not patch the standard library's :mod:`rlcompleter` module. The patch + works around a CPython bug (fixed in Python 3.13.13, 3.14.6 and 3.15) that + makes tab completion fail on Cython properties, and it changes global + interpreter state; set this variable to opt out. Unset, empty, and ``0`` + leave the patch enabled; any other value disables it. diff --git a/cuda_core/docs/source/release/1.2.0-notes.rst b/cuda_core/docs/source/release/1.2.0-notes.rst index ef28e7931e4..9e96d54b3d2 100644 --- a/cuda_core/docs/source/release/1.2.0-notes.rst +++ b/cuda_core/docs/source/release/1.2.0-notes.rst @@ -6,9 +6,40 @@ ``cuda.core`` 1.2.0 Release Notes ================================== +New features +------------ + +- Added :func:`utils.copy_batch`, which submits many buffer-to-buffer copies + in a single ``cuMemcpyBatchAsync`` call. Per-copy behavior is controlled + by the new :class:`utils.CopyOptions` dataclass. Requires ``cuda.core`` + built against CUDA 13, ``cuda.bindings`` 13.0+, and a driver reporting + CUDA 13.0 or newer; otherwise falls back to a per-copy ``cuMemcpyAsync`` + loop with options silently ignored. Graph capture and default-stream tokens + are rejected. Copies within a batch must not alias. + (`#1333 <https://github.com/NVIDIA/cuda-python/issues/1333>`__) + Fixes and enhancements ---------------------- +- A :class:`Buffer` is now freed correctly even when the CUDA context current + at teardown is not the one it was allocated in, or when no context is current + at all. This happens routinely when a buffer is released by the garbage + collector on another thread or by deferred CUDA graph cleanup; previously the + free could fail or be skipped, leaking the allocation. + (`#2497 <https://github.com/NVIDIA/cuda-python/issues/2497>`__) + +- :meth:`Buffer.from_handle` and :meth:`ManagedBuffer.from_handle` accept a + keyword-only ``stream`` that records the stream used to order the buffer's + deallocation when the memory resource owns the pointer. It defaults to + ``default_stream()``, which requires a CUDA context to be current so the + free recipe can pin that context. + (`#2497 <https://github.com/NVIDIA/cuda-python/issues/2497>`__) + +- Explicit calls to ``deallocate()`` on pool-backed memory resources and + :class:`GraphMemoryResource` now propagate errors from the underlying CUDA + free operation. Previously, these errors could be suppressed. Automatic + buffer cleanup remains non-raising and reports failures as warnings. + - Graph node resources are now retained independently across graph clones, executable graphs, updates, node deletion, and in-flight launches. Previously, modifying a graph definition could release resources still used by an diff --git a/cuda_core/examples/batched_memcpy.py b/cuda_core/examples/batched_memcpy.py new file mode 100644 index 00000000000..bb85b6e7995 --- /dev/null +++ b/cuda_core/examples/batched_memcpy.py @@ -0,0 +1,168 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# SPDX-License-Identifier: Apache-2.0 + +# ################################################################################ +# +# This example demonstrates the batched memory copy API (copy_batch) for +# performing multiple async memory transfers in a single driver call. It +# covers homogeneous batches (all copies share one CopyOptions), +# heterogeneous batches (per-copy attributes), and verifies equivalence +# with sequential Buffer.copy_to calls. +# +# Requires CUDA 13+ (cuMemcpyBatchAsync is not available on CUDA 12). +# +# ################################################################################ + +# /// script +# dependencies = ["cuda_bindings", "cuda_core"] +# /// + +import ctypes +import sys + +from cuda.core import Device, Host, LegacyPinnedMemoryResource, ManagedMemoryResource +from cuda.core.utils import CopyOptions, MemcpySrcAccessOrder, copy_batch + + +def readback(any_buf, pinned_mr, *, stream): + """Copy a buffer to a new pinned buffer and return the bytes.""" + host_buf = pinned_mr.allocate(any_buf.size) + any_buf.copy_to(host_buf, stream=stream) + stream.sync() + + ptr = ctypes.cast(int(host_buf.handle), ctypes.POINTER(ctypes.c_byte)) + data = ctypes.string_at(ptr, host_buf.size) + host_buf.close() + return data + + +def main(dev: Device): + dev.set_current() + stream = dev.create_stream() + pinned_mr = LegacyPinnedMemoryResource() + device_mr = dev.memory_resource + + num_copies = 4 + buf_size = 4096 + + # ---- Allocate source (pinned) and destination (device) buffers ---------- + + srcs = [] + dsts = [] + for i in range(num_copies): + src = pinned_mr.allocate(buf_size) + dst = device_mr.allocate(buf_size, stream=stream) + + # Fill each source with a distinct byte pattern so we can verify + fill_byte = (i + 1) % 256 + src.fill(fill_byte, stream=stream) + + srcs.append(src) + dsts.append(dst) + + # ---- 1. Homogeneous batch: all copies share a single CopyOptions ----- + + print("1. Homogeneous batched H2D copy...", file=sys.stderr) + + options = CopyOptions(src_access_order=MemcpySrcAccessOrder.STREAM) + copy_batch(stream, srcs, dsts, options=options) + + for i, dst in enumerate(dsts): + expected_byte = (i + 1) % 256 + data = readback(dst, pinned_mr, stream=stream) + assert all(b == expected_byte for b in data), f"Copy {i}: expected byte {expected_byte}, got {data[:8]!r}..." + + print(" All copies verified.", file=sys.stderr) + + # ---- 2. Equivalence with sequential Buffer.copy_to ---------------------- + + print("2. Verifying batched == sequential copy_to...", file=sys.stderr) + + # Re-fill sources with new patterns + for i, src in enumerate(srcs): + src.fill((i + 100) % 256, stream=stream) + + # Sequential path: individual copy_to calls + seq_dsts = [device_mr.allocate(buf_size, stream=stream) for _ in range(num_copies)] + for src, dst in zip(srcs, seq_dsts): + src.copy_to(dst, stream=stream) + + # Batched path: single copy_batch call + batch_dsts = [device_mr.allocate(buf_size, stream=stream) for _ in range(num_copies)] + copy_batch(stream, srcs, batch_dsts, options=CopyOptions(src_access_order=MemcpySrcAccessOrder.STREAM)) + + # Compare results + for i in range(num_copies): + seq_data = readback(seq_dsts[i], pinned_mr, stream=stream) + batch_data = readback(batch_dsts[i], pinned_mr, stream=stream) + assert seq_data == batch_data, f"Copy {i}: sequential and batched results differ" + + print(" Batched and sequential results match.", file=sys.stderr) + + # ---- 3. Heterogeneous batch: per-copy attributes ------------------------ + # + # src_access_order controls how the driver accesses source memory: + # STREAM - source read respects stream ordering (pinned/device memory) + # DURING_API_CALL - source read during the API call itself (ephemeral host ptrs) + # ANY - driver picks best strategy (pageable or HMM-backed memory) + + print("3. Heterogeneous batch with per-copy attributes...", file=sys.stderr) + + per_copy_options = [ + CopyOptions(src_access_order=MemcpySrcAccessOrder.STREAM), + CopyOptions(src_access_order=MemcpySrcAccessOrder.ANY), + CopyOptions(src_access_order=MemcpySrcAccessOrder.STREAM), + CopyOptions(src_access_order=MemcpySrcAccessOrder.ANY), + ] + hetero_dsts = [device_mr.allocate(buf_size, stream=stream) for _ in range(num_copies)] + copy_batch(stream, srcs, hetero_dsts, options=per_copy_options) + + for i in range(num_copies): + expected_byte = (i + 100) % 256 + data = readback(hetero_dsts[i], pinned_mr, stream=stream) + assert all(b == expected_byte for b in data), f"Heterogeneous copy {i}: expected byte {expected_byte}" + + print(" Heterogeneous batch verified.", file=sys.stderr) + + # ---- 4. Location hints with managed memory ------------------------------ + # + # When copying managed-memory buffers, src_location_hint and + # dst_location_hint tell the driver where the data currently lives and + # where it is going, enabling optimized transfer paths. + + print("4. Batched copy with location hints (managed memory)...", file=sys.stderr) + + managed_mr = ManagedMemoryResource() + managed_srcs = [managed_mr.allocate(buf_size, stream=stream) for _ in range(2)] + managed_dsts = [managed_mr.allocate(buf_size, stream=stream) for _ in range(2)] + + for i, src in enumerate(managed_srcs): + src.fill((i + 200) % 256, stream=stream) + + hint_options = CopyOptions( + src_access_order=MemcpySrcAccessOrder.STREAM, + src_location_hint=dev, + dst_location_hint=Host(), + ) + copy_batch(stream, managed_srcs, managed_dsts, options=hint_options) + + for i in range(2): + expected_byte = (i + 200) % 256 + data = readback(managed_dsts[i], pinned_mr, stream=stream) + assert all(b == expected_byte for b in data), f"Managed copy {i}: expected byte {expected_byte}" + + print(" Location-hinted batch verified.", file=sys.stderr) + + # ---- Cleanup ------------------------------------------------------------ + + all_bufs = srcs + dsts + seq_dsts + batch_dsts + hetero_dsts + managed_srcs + managed_dsts + for buf in all_bufs: + buf.close(stream) + stream.close() + + print("Batched memcpy example completed!") + + +if __name__ == "__main__": + main(Device(0)) diff --git a/cuda_core/tests/conftest.py b/cuda_core/tests/conftest.py index dfe97b265eb..b212633ebcf 100644 --- a/cuda_core/tests/conftest.py +++ b/cuda_core/tests/conftest.py @@ -179,6 +179,8 @@ def create_managed_memory_resource_or_skip(*args, xfail_device=None, **kwargs): except RuntimeError as e: if "requires CUDA 13.0" in str(e): pytest.skip("ManagedMemoryResource requires CUDA 13.0 or later") + if "concurrent managed access is not available" in str(e).lower(): + pytest.skip("Device does not support concurrent managed memory access") raise diff --git a/cuda_core/tests/example_tests/test_basic_examples.py b/cuda_core/tests/example_tests/test_basic_examples.py index bf423758366..8cca9e2a7bc 100644 --- a/cuda_core/tests/example_tests/test_basic_examples.py +++ b/cuda_core/tests/example_tests/test_basic_examples.py @@ -76,6 +76,7 @@ def has_recent_memory_pool_support() -> bool: SYSTEM_REQUIREMENTS = { "memory_pool_resources.py": has_recent_memory_pool_support, + "batched_memcpy.py": has_recent_memory_pool_support, "gl_interop_plasma.py": has_display, "gl_interop_fluid.py": has_display, "gl_interop_mipmap_lod.py": has_display, diff --git a/cuda_core/tests/graph/test_graph_definition.py b/cuda_core/tests/graph/test_graph_definition.py index 0aeb5a9d527..a273e8b6a01 100644 --- a/cuda_core/tests/graph/test_graph_definition.py +++ b/cuda_core/tests/graph/test_graph_definition.py @@ -633,6 +633,43 @@ def test_succ(nonempty_graph_spec): assert actual == spec.expected_succ[name], f"succ mismatch for node {name}" +@pytest.mark.parametrize("adjacency_name", ("pred", "succ")) +@pytest.mark.agent_authored(model="gpt-5.6") +def test_large_adjacency_set_is_not_truncated(init_cuda, adjacency_name): + """Adjacency queries return and remove edges beyond the old 16-edge buffer.""" + g = GraphDefinition() + hub = g.empty() + neighbors = [g.empty() for _ in range(20)] + adjacency = getattr(hub, adjacency_name) + adjacency.update(neighbors) + + expected_edges = ( + {(node, hub) for node in neighbors} if adjacency_name == "pred" else {(hub, node) for node in neighbors} + ) + assert len(adjacency) == 20 + assert set(adjacency) == set(neighbors) + assert neighbors[-1] in adjacency + assert g.edges() == expected_edges + + adjacency.clear() + assert len(adjacency) == 0 + assert g.edges() == set() + + +@pytest.mark.agent_authored(model="gpt-5.6") +def test_large_graph_queries_are_not_truncated(init_cuda): + """Graph queries return nodes and edges beyond the old 128-item buffers.""" + g = GraphDefinition() + nodes = [g.empty() for _ in range(130)] + nodes[0].succ.update(nodes[1:]) + nodes[1].succ.add(nodes[2]) + + expected_edges = {(nodes[0], node) for node in nodes[1:]} + expected_edges.add((nodes[1], nodes[2])) + assert g.nodes() == set(nodes) + assert g.edges() == expected_edges + + def test_node_graph_property(nonempty_graph_spec): """Every node's .graph property returns the parent GraphDefinition.""" spec = nonempty_graph_spec diff --git a/cuda_core/tests/helpers/copy_batch.py b/cuda_core/tests/helpers/copy_batch.py new file mode 100644 index 00000000000..2c517e3c66c --- /dev/null +++ b/cuda_core/tests/helpers/copy_batch.py @@ -0,0 +1,38 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# SPDX-License-Identifier: Apache-2.0 + +"""Shared constants and helpers for the ``copy_batch`` tests. + +Fixtures live in ``tests/memory/conftest.py``; this module holds the +pieces that tests import by name. +""" + +from cuda.core import LegacyPinnedMemoryResource +from helpers.buffers import compare_equal_buffers, make_scratch_buffer + +COPY_BATCH_SIZE = 4096 +COPY_BATCH_COUNT = 4 + + +def assert_managed_holds(dev, buf, value, *, stream): + """Assert a managed buffer holds ``value``. + + Reads via an explicit device-to-host copy rather than dereferencing + the managed pointer from the host. Managed pages carry residency and + ``cuMemAdvise`` state that earlier tests in the suite can leave + behind, which makes direct host reads order-dependent. Also avoids + ``compare_buffer_to_constant``, which resolves a ``Device`` from + ``memory_resource.device_id`` -- that is -1 for + ``ManagedMemoryResource``. + """ + host = LegacyPinnedMemoryResource().allocate(buf.size) + expected = make_scratch_buffer(dev, value, buf.size) + try: + buf.copy_to(host, stream=stream) + stream.sync() + assert compare_equal_buffers(expected, host) + finally: + expected.close() + host.close(stream) + stream.sync() diff --git a/cuda_core/tests/memory/__init__.py b/cuda_core/tests/memory/__init__.py new file mode 100644 index 00000000000..27422b3cb7e --- /dev/null +++ b/cuda_core/tests/memory/__init__.py @@ -0,0 +1,3 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# SPDX-License-Identifier: Apache-2.0 diff --git a/cuda_core/tests/memory/conftest.py b/cuda_core/tests/memory/conftest.py new file mode 100644 index 00000000000..ed950df830f --- /dev/null +++ b/cuda_core/tests/memory/conftest.py @@ -0,0 +1,66 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 + +"""Per-directory conftest for the ``copy_batch`` test modules. + +Provides the device, stream and buffer fixtures shared by +``test_copy_batch.py`` (data movement) and ``test_copy_batch_options.py`` +(options and validation). +""" + +import pytest +from helpers.copy_batch import COPY_BATCH_COUNT, COPY_BATCH_SIZE + +from cuda.core import Device, LegacyPinnedMemoryResource + + +@pytest.fixture +def copy_batch_device(init_cuda): + """``copy_batch`` works on every supported toolkit, so this never skips.""" + device = Device() + device.set_current() + return device + + +@pytest.fixture +def copy_stream(copy_batch_device): + """The single stream used for both allocation and copies in a test. + + Stream-ordered pool allocations are only guaranteed usable on the + stream that allocated them, so tests allocate and copy on this one + stream rather than mixing it with ``device.default_stream``. + """ + s = copy_batch_device.create_stream() + yield s + s.close() + + +@pytest.fixture +def h2d_bufs(copy_batch_device, copy_stream): + """Pinned-host source / device destination pairs.""" + pinned_mr = LegacyPinnedMemoryResource() + device_mr = copy_batch_device.memory_resource + + srcs = [pinned_mr.allocate(COPY_BATCH_SIZE) for _ in range(COPY_BATCH_COUNT)] + dsts = [device_mr.allocate(COPY_BATCH_SIZE, stream=copy_stream) for _ in range(COPY_BATCH_COUNT)] + + yield srcs, dsts + + for buf in srcs + dsts: + buf.close(copy_stream) + copy_stream.sync() + + +@pytest.fixture +def device_bufs(copy_batch_device, copy_stream): + """Device source / device destination pairs.""" + device_mr = copy_batch_device.memory_resource + + srcs = [device_mr.allocate(COPY_BATCH_SIZE, stream=copy_stream) for _ in range(COPY_BATCH_COUNT)] + dsts = [device_mr.allocate(COPY_BATCH_SIZE, stream=copy_stream) for _ in range(COPY_BATCH_COUNT)] + + yield srcs, dsts + + for buf in srcs + dsts: + buf.close(copy_stream) + copy_stream.sync() diff --git a/cuda_core/tests/memory/test_copy_batch.py b/cuda_core/tests/memory/test_copy_batch.py new file mode 100644 index 00000000000..81abe9f9636 --- /dev/null +++ b/cuda_core/tests/memory/test_copy_batch.py @@ -0,0 +1,287 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 + +"""Data movement behaviour of ``copy_batch``. + +Covers that the right bytes reach the right destination, that batched +results agree with the per-buffer ``Buffer.copy_to`` path, and that the +batch is correctly ordered on its stream. +""" + +import pytest +from helpers.buffers import ( + compare_buffer_to_constant, + compare_equal_buffers, + make_scratch_buffer, + set_buffer, +) +from helpers.copy_batch import COPY_BATCH_SIZE + +from cuda.core import LegacyPinnedMemoryResource +from cuda.core._stream import LEGACY_DEFAULT_STREAM, PER_THREAD_DEFAULT_STREAM +from cuda.core.utils import copy_batch + + +class TestCopyBatchCore: + """Each transfer direction moves the expected bytes.""" + + @pytest.mark.agent_authored(model="Claude Opus 5") + def test_h2d_batch(self, h2d_bufs, copy_stream): + srcs, dsts = h2d_bufs + for i, src in enumerate(srcs): + set_buffer(src, i + 1) + + copy_batch(copy_stream, srcs, dsts) + copy_stream.sync() + + for i, dst in enumerate(dsts): + assert compare_buffer_to_constant(dst, i + 1) + + @pytest.mark.agent_authored(model="Claude Opus 5") + def test_d2h_batch(self, copy_batch_device, h2d_bufs, copy_stream): + dev = copy_batch_device + _, device_dsts = h2d_bufs + pinned_mr = LegacyPinnedMemoryResource() + + for i, buf in enumerate(device_dsts): + buf.fill(i + 10, stream=copy_stream) + + host_bufs = [pinned_mr.allocate(COPY_BATCH_SIZE) for _ in device_dsts] + copy_batch(copy_stream, device_dsts, host_bufs) + copy_stream.sync() + + for i, host_buf in enumerate(host_bufs): + expected = make_scratch_buffer(dev, i + 10, COPY_BATCH_SIZE) + assert compare_equal_buffers(expected, host_buf) + expected.close() + host_buf.close(copy_stream) + copy_stream.sync() + + @pytest.mark.agent_authored(model="Claude Opus 5") + def test_d2d_batch(self, device_bufs, copy_stream): + srcs, dsts = device_bufs + for i, src in enumerate(srcs): + src.fill(i + 20, stream=copy_stream) + + copy_batch(copy_stream, srcs, dsts) + copy_stream.sync() + + for i, dst in enumerate(dsts): + assert compare_buffer_to_constant(dst, i + 20) + + @pytest.mark.agent_authored(model="Claude Opus 5") + def test_various_sizes(self, copy_batch_device, copy_stream): + pinned_mr = LegacyPinnedMemoryResource() + device_mr = copy_batch_device.memory_resource + sizes = [1024, 2048, 512, 4096] + + srcs = [pinned_mr.allocate(size) for size in sizes] + dsts = [device_mr.allocate(size, stream=copy_stream) for size in sizes] + for i, src in enumerate(srcs): + set_buffer(src, i + 1) + + copy_batch(copy_stream, srcs, dsts) + copy_stream.sync() + + for i, dst in enumerate(dsts): + assert compare_buffer_to_constant(dst, i + 1) + + for buf in srcs + dsts: + buf.close(copy_stream) + copy_stream.sync() + + @pytest.mark.agent_authored(model="Claude Opus 5") + def test_single_element_batch(self, copy_batch_device, copy_stream): + """A one-element batch is legal; only a bare Buffer is rejected.""" + pinned_mr = LegacyPinnedMemoryResource() + src = pinned_mr.allocate(COPY_BATCH_SIZE) + dst = copy_batch_device.memory_resource.allocate(COPY_BATCH_SIZE, stream=copy_stream) + set_buffer(src, 7) + + copy_batch(copy_stream, [src], [dst]) + copy_stream.sync() + + assert compare_buffer_to_constant(dst, 7) + src.close(copy_stream) + dst.close(copy_stream) + copy_stream.sync() + + +class TestCopyBatchEquivalence: + """Batched results must agree with the already-tested per-buffer path. + + ``Buffer.copy_to`` and ``Buffer.copy_from`` have their own coverage in + ``tests/test_memory.py``, so agreement between the two paths is the + property under test here. + """ + + @pytest.mark.agent_authored(model="Claude Opus 5") + def test_batch_matches_sequential_copy_to(self, copy_batch_device, h2d_bufs, copy_stream): + srcs, _ = h2d_bufs + device_mr = copy_batch_device.memory_resource + pinned_mr = LegacyPinnedMemoryResource() + + for i, src in enumerate(srcs): + set_buffer(src, i + 50) + + seq_dsts = [device_mr.allocate(COPY_BATCH_SIZE, stream=copy_stream) for _ in srcs] + for src, dst in zip(srcs, seq_dsts): + src.copy_to(dst, stream=copy_stream) + + batch_dsts = [device_mr.allocate(COPY_BATCH_SIZE, stream=copy_stream) for _ in srcs] + copy_batch(copy_stream, srcs, batch_dsts) + copy_stream.sync() + + for seq_dst, batch_dst in zip(seq_dsts, batch_dsts): + seq_host = pinned_mr.allocate(COPY_BATCH_SIZE) + batch_host = pinned_mr.allocate(COPY_BATCH_SIZE) + seq_dst.copy_to(seq_host, stream=copy_stream) + batch_dst.copy_to(batch_host, stream=copy_stream) + copy_stream.sync() + assert compare_equal_buffers(seq_host, batch_host) + seq_host.close(copy_stream) + batch_host.close(copy_stream) + + for buf in seq_dsts + batch_dsts: + buf.close(copy_stream) + copy_stream.sync() + + @pytest.mark.agent_authored(model="Claude Opus 5") + def test_batch_matches_sequential_varied_sizes(self, copy_batch_device, copy_stream): + device_mr = copy_batch_device.memory_resource + pinned_mr = LegacyPinnedMemoryResource() + sizes = [1024, 2048, 512] + + srcs = [pinned_mr.allocate(size) for size in sizes] + for i, src in enumerate(srcs): + set_buffer(src, i + 60) + + seq_dsts = [device_mr.allocate(size, stream=copy_stream) for size in sizes] + for src, dst in zip(srcs, seq_dsts): + src.copy_to(dst, stream=copy_stream) + + batch_dsts = [device_mr.allocate(size, stream=copy_stream) for size in sizes] + copy_batch(copy_stream, srcs, batch_dsts) + copy_stream.sync() + + for size, seq_dst, batch_dst in zip(sizes, seq_dsts, batch_dsts): + seq_host = pinned_mr.allocate(size) + batch_host = pinned_mr.allocate(size) + seq_dst.copy_to(seq_host, stream=copy_stream) + batch_dst.copy_to(batch_host, stream=copy_stream) + copy_stream.sync() + assert compare_equal_buffers(seq_host, batch_host) + seq_host.close(copy_stream) + batch_host.close(copy_stream) + + for buf in srcs + seq_dsts + batch_dsts: + buf.close(copy_stream) + copy_stream.sync() + + @pytest.mark.agent_authored(model="Claude Opus 5") + def test_batch_matches_sequential_d2d(self, copy_batch_device, device_bufs, copy_stream): + srcs, seq_dsts = device_bufs + device_mr = copy_batch_device.memory_resource + pinned_mr = LegacyPinnedMemoryResource() + + for i, src in enumerate(srcs): + src.fill(i + 70, stream=copy_stream) + + for src, dst in zip(srcs, seq_dsts): + src.copy_to(dst, stream=copy_stream) + + batch_dsts = [device_mr.allocate(COPY_BATCH_SIZE, stream=copy_stream) for _ in srcs] + copy_batch(copy_stream, srcs, batch_dsts) + copy_stream.sync() + + for seq_dst, batch_dst in zip(seq_dsts, batch_dsts): + seq_host = pinned_mr.allocate(COPY_BATCH_SIZE) + batch_host = pinned_mr.allocate(COPY_BATCH_SIZE) + seq_dst.copy_to(seq_host, stream=copy_stream) + batch_dst.copy_to(batch_host, stream=copy_stream) + copy_stream.sync() + assert compare_equal_buffers(seq_host, batch_host) + seq_host.close(copy_stream) + batch_host.close(copy_stream) + + for buf in batch_dsts: + buf.close(copy_stream) + copy_stream.sync() + + +class TestCopyBatchStreamSemantics: + """Where the batch sits in stream order, and what it cannot be part of.""" + + @pytest.mark.agent_authored(model="Claude Opus 5") + def test_ordered_between_prior_and_later_stream_work(self, device_bufs, copy_stream): + """The batch must observe prior stream work and precede later work. + + Each source is filled with ``before``, copied, then refilled with + ``after`` -- all enqueued on one stream with no intervening sync. + Destinations holding ``before`` prove the copy ran after the first + fill and before the second, rather than racing either. + """ + srcs, dsts = device_bufs + before, after = 11, 22 + + for src in srcs: + src.fill(before, stream=copy_stream) + copy_batch(copy_stream, srcs, dsts) + for src in srcs: + src.fill(after, stream=copy_stream) + + copy_stream.sync() + + for dst in dsts: + assert compare_buffer_to_constant(dst, before) + for src in srcs: + assert compare_buffer_to_constant(src, after) + + @pytest.mark.agent_authored(model="Claude Opus 5") + def test_graph_builder_is_rejected(self, copy_batch_device, device_bufs, copy_stream): + """Batched memcpy cannot be captured into a graph. + + ``cuMemcpyBatchAsync`` has no graph-node form and the driver + rejects it mid-capture, so ``copy_batch`` is typed to take only a + ``Stream`` and refuses a ``GraphBuilder`` at the boundary rather + than failing later with ``CUDA_ERROR_STREAM_CAPTURE_UNSUPPORTED``. + Use ``GraphNode.memcpy`` or per-buffer ``Buffer.copy_to`` to build + copies into a graph. + """ + srcs, dsts = device_bufs + gb = copy_batch_device.create_graph_builder().begin_building() + try: + with pytest.raises(TypeError, match="Argument 'stream' has incorrect type"): + copy_batch(gb, srcs, dsts) + finally: + # Nothing was captured, so the builder still ends cleanly. + gb.end_building() + gb.close() + + @pytest.mark.agent_authored(model="Claude Sonnet 4.6") + def test_capturing_stream_is_rejected(self, copy_batch_device, device_bufs): + """Passing the GraphBuilder's underlying stream must also be rejected. + + The GraphBuilder type check is bypassed when the caller passes + ``gb.stream`` directly; the capture-status check closes that loophole. + """ + srcs, dsts = device_bufs + gb = copy_batch_device.create_graph_builder().begin_building() + try: + with pytest.raises(TypeError, match="graph capture"): + copy_batch(gb.stream, srcs, dsts) + finally: + gb.end_building() + gb.close() + + @pytest.mark.agent_authored(model="Claude Sonnet 4.6") + @pytest.mark.parametrize( + "default_stream", + [LEGACY_DEFAULT_STREAM, PER_THREAD_DEFAULT_STREAM], + ids=["legacy", "per_thread"], + ) + def test_default_stream_token_is_rejected(self, init_cuda, h2d_bufs, default_stream): + """Default-stream tokens must be rejected with a clear TypeError.""" + srcs, dsts = h2d_bufs + with pytest.raises(TypeError, match="default-stream token"): + copy_batch(default_stream, srcs, dsts) diff --git a/cuda_core/tests/memory/test_copy_batch_options.py b/cuda_core/tests/memory/test_copy_batch_options.py new file mode 100644 index 00000000000..31d3a28f4cc --- /dev/null +++ b/cuda_core/tests/memory/test_copy_batch_options.py @@ -0,0 +1,351 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 + +"""``CopyOptions`` handling and argument validation for ``copy_batch``. + +Covers how options are encoded into the driver's attribute runs, how each +option field behaves, and every rejection path. +""" + +import pytest + +# Shared with test_managed_ops.py: handles the CUDA 13 requirement, mempool +# OOM, and CUDA_ERROR_NOT_SUPPORTED (managed pools are unavailable on +# Windows), so the location-hint tests skip rather than error there. +from conftest import create_managed_memory_resource_or_skip +from helpers.buffers import compare_buffer_to_constant, set_buffer +from helpers.copy_batch import ( + COPY_BATCH_SIZE, + assert_managed_holds, +) + +from cuda.core import Host, LegacyPinnedMemoryResource +from cuda.core._memory._copy_enums import _attr_run_starts +from cuda.core._memory._copy_ops import ( + _normalize_copy_options, +) +from cuda.core.utils import ( + CopyOptions, + MemcpyOverlapMode, + MemcpySrcAccessOrder, + copy_batch, +) + + +class TestOptionsEncoding: + """How ``options`` becomes the driver's ``attrs`` / ``attrsIdxs`` pair. + + Pure logic, no CUDA. This is the only place the effect of ``options`` + is observable: they are hints that change how the driver stages a + transfer, never the bytes it produces, so no data comparison can + distinguish an option that was applied from one that was dropped. + """ + + @pytest.mark.agent_authored(model="Claude Opus 5") + def test_scalar_broadcasts_to_every_copy(self): + """A scalar must reach all N copies, not just the first.""" + n = 4 + scalar = CopyOptions(src_access_order=MemcpySrcAccessOrder.ANY) + + # copy_batch expands the scalar to one entry per copy... + assert _normalize_copy_options(scalar, n) == (scalar,) * n + # ...and the encoder collapses those to a single driver attribute. + assert _attr_run_starts(_normalize_copy_options(scalar, n)) == [0] + + # An explicit list of the same option is indistinguishable. + assert _normalize_copy_options([scalar] * n, n) == _normalize_copy_options(scalar, n) + + @pytest.mark.agent_authored(model="Claude Opus 5") + def test_none_broadcasts_defaults(self): + assert _normalize_copy_options(None, 3) == (CopyOptions(),) * 3 + + @pytest.mark.agent_authored(model="Claude Opus 5") + def test_sequence_is_never_broadcast(self): + """A sequence pairs by index, so a short one is an error.""" + scalar = CopyOptions(src_access_order=MemcpySrcAccessOrder.ANY) + with pytest.raises(ValueError, match="options length"): + _normalize_copy_options([scalar], 4) + + @pytest.mark.agent_authored(model="Claude Opus 5") + def test_equal_but_distinct_instances_collapse(self): + # Structural equality, not identity, drives the collapse. + attrs = [CopyOptions(src_access_order="stream") for _ in range(3)] + assert len({id(a) for a in attrs}) == 3 + assert _attr_run_starts(attrs) == [0] + + @pytest.mark.agent_authored(model="Claude Opus 5") + def test_all_distinct_yields_one_run_each(self): + attrs = [ + CopyOptions(src_access_order=MemcpySrcAccessOrder.STREAM), + CopyOptions(src_access_order=MemcpySrcAccessOrder.ANY), + CopyOptions(src_access_order=MemcpySrcAccessOrder.DURING_API_CALL), + ] + assert _attr_run_starts(attrs) == [0, 1, 2] + + @pytest.mark.agent_authored(model="Claude Opus 5") + def test_adjacent_runs_are_grouped(self): + stream_attr = CopyOptions(src_access_order=MemcpySrcAccessOrder.STREAM) + any_attr = CopyOptions(src_access_order=MemcpySrcAccessOrder.ANY) + attrs = [stream_attr, stream_attr, any_attr, any_attr, stream_attr] + # Runs start at 0 (stream), 2 (any) and 4 (stream again). + assert _attr_run_starts(attrs) == [0, 2, 4] + + @pytest.mark.agent_authored(model="Claude Opus 5") + def test_single_element(self): + assert _attr_run_starts([CopyOptions()]) == [0] + + +class TestCopyBatchOptions: + """Each ``CopyOptions`` field is accepted and does not corrupt the copy.""" + + @pytest.mark.agent_authored(model="Claude Opus 5") + @pytest.mark.parametrize( + ("order", "marker"), + [ + (MemcpySrcAccessOrder.STREAM, 31), + (MemcpySrcAccessOrder.DURING_API_CALL, 32), + (MemcpySrcAccessOrder.ANY, 33), + ], + ) + def test_src_access_order(self, h2d_bufs, copy_stream, order, marker): + srcs, dsts = h2d_bufs + for i, src in enumerate(srcs): + set_buffer(src, i + marker) + + copy_batch(copy_stream, srcs, dsts, options=CopyOptions(src_access_order=order)) + copy_stream.sync() + + for i, dst in enumerate(dsts): + assert compare_buffer_to_constant(dst, i + marker) + + @pytest.mark.agent_authored(model="Claude Opus 5") + def test_per_copy_options(self, h2d_bufs, copy_stream): + srcs, dsts = h2d_bufs + for i, src in enumerate(srcs): + set_buffer(src, i + 40) + + per_copy_options = [ + CopyOptions(src_access_order=MemcpySrcAccessOrder.STREAM), + CopyOptions(src_access_order=MemcpySrcAccessOrder.ANY), + CopyOptions(src_access_order=MemcpySrcAccessOrder.DURING_API_CALL), + CopyOptions(src_access_order=MemcpySrcAccessOrder.STREAM), + ] + # The encoding itself is covered by TestOptionsEncoding; here the + # point is that distinct per-copy options do not corrupt the data. + copy_batch(copy_stream, srcs, dsts, options=per_copy_options) + copy_stream.sync() + + for i, dst in enumerate(dsts): + assert compare_buffer_to_constant(dst, i + 40) + + @pytest.mark.agent_authored(model="Claude Opus 5") + def test_location_hints_do_not_corrupt_copy(self, copy_batch_device, copy_stream): + """Device and host hints are accepted and leave the bytes intact. + + Hints only steer how the driver stages a transfer, so no data + comparison can show one was *applied*; what this catches is a hint + that errors or corrupts. It is also the only test that drives the + ``device`` and ``host`` branches of ``to_cumemlocation`` and the + ``src_location_hint`` path through ``copy_batch``. + """ + dev = copy_batch_device + mr = create_managed_memory_resource_or_skip() + srcs = [mr.allocate(COPY_BATCH_SIZE, stream=copy_stream) for _ in range(2)] + dsts = [mr.allocate(COPY_BATCH_SIZE, stream=copy_stream) for _ in range(2)] + + for i, src in enumerate(srcs): + src.fill(i + 80, stream=copy_stream) + + options = CopyOptions( + src_access_order=MemcpySrcAccessOrder.STREAM, + src_location_hint=dev, + dst_location_hint=Host(), + ) + copy_batch(copy_stream, srcs, dsts, options=options) + copy_stream.sync() + + for i, dst in enumerate(dsts): + assert_managed_holds(dev, dst, i + 80, stream=copy_stream) + + for buf in srcs + dsts: + buf.close(copy_stream) + copy_stream.sync() + mr.close() + + @pytest.mark.agent_authored(model="Claude Sonnet 4.6") + def test_host_numa_location_hint(self, copy_batch_device, copy_stream): + """A NUMA-specific host hint is accepted and does not corrupt the copy.""" + dev = copy_batch_device + numa_id = dev.properties.host_numa_id + if numa_id < 0: + pytest.skip("System does not report a host NUMA node for this device") + mr = create_managed_memory_resource_or_skip() + srcs = [mr.allocate(COPY_BATCH_SIZE, stream=copy_stream) for _ in range(2)] + dsts = [mr.allocate(COPY_BATCH_SIZE, stream=copy_stream) for _ in range(2)] + for i, src in enumerate(srcs): + src.fill(i + 85, stream=copy_stream) + + copy_batch(copy_stream, srcs, dsts, options=CopyOptions(dst_location_hint=Host(numa_id=numa_id))) + copy_stream.sync() + for i, dst in enumerate(dsts): + assert_managed_holds(dev, dst, i + 85, stream=copy_stream) + + for buf in srcs + dsts: + buf.close(copy_stream) + copy_stream.sync() + mr.close() + + @pytest.mark.agent_authored(model="Claude Sonnet 4.6") + def test_host_numa_current_location_hint(self, copy_batch_device, copy_stream): + """Host.numa_current() as a location hint is accepted and does not corrupt the copy.""" + dev = copy_batch_device + if dev.properties.host_numa_id < 0: + pytest.skip("System does not report a host NUMA node for this device") + mr = create_managed_memory_resource_or_skip() + srcs = [mr.allocate(COPY_BATCH_SIZE, stream=copy_stream) for _ in range(2)] + dsts = [mr.allocate(COPY_BATCH_SIZE, stream=copy_stream) for _ in range(2)] + for i, src in enumerate(srcs): + src.fill(i + 86, stream=copy_stream) + + copy_batch(copy_stream, srcs, dsts, options=CopyOptions(dst_location_hint=Host.numa_current())) + copy_stream.sync() + for i, dst in enumerate(dsts): + assert_managed_holds(dev, dst, i + 86, stream=copy_stream) + + for buf in srcs + dsts: + buf.close(copy_stream) + copy_stream.sync() + mr.close() + + @pytest.mark.agent_authored(model="Claude Opus 5") + def test_overlap_mode_copies_correctly(self, h2d_bufs, copy_stream): + """The overlap hint is advisory and must not change the bytes copied.""" + srcs, dsts = h2d_bufs + for i, src in enumerate(srcs): + set_buffer(src, i + 90) + + copy_batch( + copy_stream, + srcs, + dsts, + options=CopyOptions(overlap_mode=MemcpyOverlapMode.PREFER_OVERLAP_WITH_COMPUTE), + ) + copy_stream.sync() + + for i, dst in enumerate(dsts): + assert compare_buffer_to_constant(dst, i + 90) + + @pytest.mark.agent_authored(model="Claude Opus 5") + def test_default_overlap_mode_does_not_warn(self, h2d_bufs, copy_stream): + srcs, dsts = h2d_bufs + copy_batch(copy_stream, srcs, dsts, options=CopyOptions()) + copy_stream.sync() + + +class TestCopyOptionsValidation: + """``CopyOptions`` rejects invalid enum values at construction.""" + + @pytest.mark.agent_authored(model="Claude Sonnet 4.6") + def test_type_hints_resolvable(self): + """All annotations on CopyOptions must resolve without NameError.""" + import typing + + typing.get_type_hints(CopyOptions) + + @pytest.mark.agent_authored(model="Claude Opus 5") + def test_invalid_access_order(self): + with pytest.raises(ValueError, match="invalid src_access_order"): + CopyOptions(src_access_order="invalid_order") + + @pytest.mark.agent_authored(model="Claude Opus 5") + def test_invalid_overlap_mode(self): + with pytest.raises(ValueError, match="invalid overlap_mode"): + CopyOptions(overlap_mode="invalid_mode") + + +class TestCopyBatchValidation: + """``copy_batch`` rejects malformed buffer and option arguments.""" + + @pytest.mark.agent_authored(model="Claude Opus 5") + def test_rejects_single_buffer(self, h2d_bufs, copy_stream): + srcs, dsts = h2d_bufs + + with pytest.raises(TypeError, match="sequence of Buffers"): + copy_batch(copy_stream, srcs[0], dsts) + + with pytest.raises(TypeError, match="sequence of Buffers"): + copy_batch(copy_stream, srcs, dsts[0]) + + @pytest.mark.agent_authored(model="Claude Opus 5") + def test_rejects_empty_sequence(self, h2d_bufs, copy_stream): + srcs, _ = h2d_bufs + + with pytest.raises(ValueError, match="empty buffers sequence"): + copy_batch(copy_stream, [], []) + + with pytest.raises(ValueError, match="empty buffers sequence"): + copy_batch(copy_stream, srcs, []) + + @pytest.mark.agent_authored(model="Claude Opus 5") + def test_rejects_non_buffer_element(self, h2d_bufs, copy_stream): + srcs, dsts = h2d_bufs + + with pytest.raises(TypeError, match="expected Buffer, got int"): + copy_batch(copy_stream, [srcs[0], 42], dsts[:2]) + + with pytest.raises(TypeError, match="expected Buffer, got NoneType"): + copy_batch(copy_stream, srcs[:2], [dsts[0], None]) + + @pytest.mark.agent_authored(model="Claude Opus 5") + def test_rejects_non_sequence(self, h2d_bufs, copy_stream): + srcs, dsts = h2d_bufs + + with pytest.raises(TypeError, match="must be a sequence of Buffer"): + copy_batch(copy_stream, 42, dsts) + + with pytest.raises(TypeError, match="must be a sequence of Buffer"): + copy_batch(copy_stream, srcs, None) + + @pytest.mark.agent_authored(model="Claude Opus 5") + def test_length_mismatch(self, h2d_bufs, copy_stream): + srcs, dsts = h2d_bufs + + with pytest.raises(ValueError, match="does not match dsts length"): + copy_batch(copy_stream, srcs[:2], dsts[:3]) + + @pytest.mark.agent_authored(model="Claude Opus 5") + @pytest.mark.parametrize(("src_size", "dst_size"), [(1024, 2048), (2048, 1024)]) + def test_size_mismatch(self, copy_batch_device, copy_stream, src_size, dst_size): + """Sizes come from the buffers, so any inequality is an error.""" + pinned_mr = LegacyPinnedMemoryResource() + src = pinned_mr.allocate(src_size) + dst = copy_batch_device.memory_resource.allocate(dst_size, stream=copy_stream) + + with pytest.raises(ValueError, match="size mismatch at index 0"): + copy_batch(copy_stream, [src], [dst]) + + src.close(copy_stream) + dst.close(copy_stream) + copy_stream.sync() + + @pytest.mark.agent_authored(model="Claude Opus 5") + def test_options_length_mismatch(self, h2d_bufs, copy_stream): + srcs, dsts = h2d_bufs + + with pytest.raises(ValueError, match="options length"): + copy_batch(copy_stream, srcs, dsts, options=[CopyOptions()] * 3) + + @pytest.mark.agent_authored(model="Claude Opus 5") + def test_rejects_bad_options_type(self, h2d_bufs, copy_stream): + srcs, dsts = h2d_bufs + + with pytest.raises(TypeError, match="options must be CopyOptions"): + copy_batch(copy_stream, srcs, dsts, options=42) + + @pytest.mark.agent_authored(model="Claude Opus 5") + def test_rejects_bad_options_element(self, h2d_bufs, copy_stream): + srcs, dsts = h2d_bufs + bad = [CopyOptions()] * (len(srcs) - 1) + ["nope"] + + with pytest.raises(TypeError, match="each options element must be CopyOptions"): + copy_batch(copy_stream, srcs, dsts, options=bad) diff --git a/cuda_core/tests/system/test_system_device.py b/cuda_core/tests/system/test_system_device.py index 2ec2d5fb41c..4f4532b067c 100644 --- a/cuda_core/tests/system/test_system_device.py +++ b/cuda_core/tests/system/test_system_device.py @@ -11,7 +11,6 @@ import multiprocessing import os import re -import warnings import helpers import pytest @@ -32,23 +31,6 @@ def check_gpu_available(): pytest.skip("No GPUs available to run device tests", allow_module_level=True) -def test_devices_are_the_same_architecture(): - # The tests in this directory that use `unsupported_before` will generally - # skip the entire test after the first device that isn't supported is found. - # This means that if subsequent devices are of a different architecture, - # they won't be tested properly. This tests for the (hopefully rare) case - # where a system has devices of different architectures and produces a warning. - - all_arches = {device.arch for device in system.Device.get_all_devices()} - - if len(all_arches) > 1: - warnings.warn( - f"System has devices of multiple architectures ({', '.join(x.name for x in all_arches)}). " - f" Some tests may be skipped unexpectedly", - UserWarning, - ) - - def test_device_count(): assert system.Device.get_device_count() == system.get_num_devices() @@ -81,55 +63,69 @@ def test_device_architecture(): assert isinstance(device_arch, typing.DeviceArch) -def test_device_bar1_memory(): +def test_device_bar1_memory(subtests): for device in system.Device.get_all_devices(): - with unsupported_before(device, None): - bar1_memory_info = device.bar1_memory_info - free, total, used = ( - bar1_memory_info.free, - bar1_memory_info.total, - bar1_memory_info.used, - ) - - assert isinstance(bar1_memory_info, _device.BAR1MemoryInfo) - assert isinstance(free, int) - assert isinstance(total, int) - assert isinstance(used, int) - - assert free >= 0 - assert total >= 0 - assert used >= 0 - assert free + used == total + with subtests.test(device_index=device.index): + with unsupported_before(device, None): + bar1_memory_info = device.bar1_memory_info + free, total, used = ( + bar1_memory_info.free, + bar1_memory_info.total, + bar1_memory_info.used, + ) + assert isinstance(bar1_memory_info, _device.BAR1MemoryInfo) + assert isinstance(free, int) + assert isinstance(total, int) + assert isinstance(used, int) -@pytest.mark.skipif(helpers.IS_WSL or helpers.IS_WINDOWS, reason="Device attributes not supported on WSL or Windows") -def test_device_cpu_affinity(): - for device in system.Device.get_all_devices(): - with unsupported_before(device, typing.DeviceArch.KEPLER): - affinity = device.get_cpu_affinity(typing.AffinityScope.NODE) - assert isinstance(affinity, list) - os.sched_setaffinity(0, affinity) - assert os.sched_getaffinity(0) == set(affinity) + assert free >= 0 + assert total >= 0 + assert used >= 0 + assert free + used == total @pytest.mark.skipif(helpers.IS_WSL or helpers.IS_WINDOWS, reason="Device attributes not supported on WSL or Windows") -def test_affinity(): +def test_device_cpu_affinity(subtests): for device in system.Device.get_all_devices(): - for scope in typing.AffinityScope.__members__.values(): + with subtests.test(device_index=device.index): with unsupported_before(device, typing.DeviceArch.KEPLER): - affinity = device.get_cpu_affinity(scope) - assert isinstance(affinity, list) - - affinity = device.get_memory_affinity(scope) + affinity = device.get_cpu_affinity(typing.AffinityScope.NODE) assert isinstance(affinity, list) + os.sched_setaffinity(0, affinity) + assert os.sched_getaffinity(0) == set(affinity) -def test_numa_node_id(): +@pytest.mark.skipif(helpers.IS_WSL or helpers.IS_WINDOWS, reason="Device attributes not supported on WSL or Windows") +def test_affinity(subtests): for device in system.Device.get_all_devices(): - with unsupported_before(device, None): - numa_node_id = device.numa_node_id - assert isinstance(numa_node_id, int) - assert numa_node_id >= -1 + for scope in typing.AffinityScope.__members__.values(): + with subtests.test( + device_index=device.index, + affinity_scope=scope.value, + affinity_api="get_cpu_affinity", + ): + with unsupported_before(device, typing.DeviceArch.KEPLER): + affinity = device.get_cpu_affinity(scope) + assert isinstance(affinity, list) + + with subtests.test( + device_index=device.index, + affinity_scope=scope.value, + affinity_api="get_memory_affinity", + ): + with unsupported_before(device, typing.DeviceArch.KEPLER): + affinity = device.get_memory_affinity(scope) + assert isinstance(affinity, list) + + +def test_numa_node_id(subtests): + for device in system.Device.get_all_devices(): + with subtests.test(device_index=device.index): + with unsupported_before(device, None): + numa_node_id = device.numa_node_id + assert isinstance(numa_node_id, int) + assert numa_node_id >= -1 def test_device_cuda_compute_capability(): @@ -143,23 +139,24 @@ def test_device_cuda_compute_capability(): assert 0 <= cuda_compute_capability[1] <= 9 -def test_device_memory(): +def test_device_memory(subtests): for device in system.Device.get_all_devices(): - with unsupported_before(device, None): - memory_info = device.memory_info - free, total, used, reserved = memory_info.free, memory_info.total, memory_info.used, memory_info.reserved + with subtests.test(device_index=device.index): + with unsupported_before(device, None): + memory_info = device.memory_info + free, total, used, reserved = memory_info.free, memory_info.total, memory_info.used, memory_info.reserved - assert isinstance(memory_info, _device.MemoryInfo) - assert isinstance(free, int) - assert isinstance(total, int) - assert isinstance(used, int) - assert isinstance(reserved, int) + assert isinstance(memory_info, _device.MemoryInfo) + assert isinstance(free, int) + assert isinstance(total, int) + assert isinstance(used, int) + assert isinstance(reserved, int) - assert free >= 0 - assert total >= 0 - assert used >= 0 - assert reserved >= 0 - assert free + used + reserved == total + assert free >= 0 + assert total >= 0 + assert used >= 0 + assert reserved >= 0 + assert free + used + reserved == total def test_device_name(): @@ -169,72 +166,74 @@ def test_device_name(): assert len(name) > 0 -def test_device_pci_info(): +def test_device_pci_info(subtests): for device in system.Device.get_all_devices(): - pci_info = device.pci_info - assert isinstance(pci_info, _device.PciInfo) + with subtests.test(device_index=device.index): + pci_info = device.pci_info + assert isinstance(pci_info, _device.PciInfo) - assert isinstance(pci_info.bus_id, str) - assert re.match("[a-f0-9]{8}:[a-f0-9]{2}:[a-f0-9]{2}.[a-f0-9]", pci_info.bus_id.lower()) - bus_id_domain = int(pci_info.bus_id.split(":")[0], 16) - bus_id_bus = int(pci_info.bus_id.split(":")[1], 16) - bus_id_device = int(pci_info.bus_id.split(":")[2][:2], 16) + assert isinstance(pci_info.bus_id, str) + assert re.match("[a-f0-9]{8}:[a-f0-9]{2}:[a-f0-9]{2}.[a-f0-9]", pci_info.bus_id.lower()) + bus_id_domain = int(pci_info.bus_id.split(":")[0], 16) + bus_id_bus = int(pci_info.bus_id.split(":")[1], 16) + bus_id_device = int(pci_info.bus_id.split(":")[2][:2], 16) - assert isinstance(pci_info.domain, int) - assert 0x00 <= pci_info.domain <= 0xFFFFFFFF - assert pci_info.domain == bus_id_domain + assert isinstance(pci_info.domain, int) + assert 0x00 <= pci_info.domain <= 0xFFFFFFFF + assert pci_info.domain == bus_id_domain - assert isinstance(pci_info.bus, int) - assert 0x00 <= pci_info.bus <= 0xFF - assert pci_info.bus == bus_id_bus + assert isinstance(pci_info.bus, int) + assert 0x00 <= pci_info.bus <= 0xFF + assert pci_info.bus == bus_id_bus - assert isinstance(pci_info.device, int) - assert 0x00 <= pci_info.device <= 0xFF - assert pci_info.device == bus_id_device + assert isinstance(pci_info.device, int) + assert 0x00 <= pci_info.device <= 0xFF + assert pci_info.device == bus_id_device - assert isinstance(pci_info.vendor_id, int) - assert 0x0000 <= pci_info.vendor_id <= 0xFFFF + assert isinstance(pci_info.vendor_id, int) + assert 0x0000 <= pci_info.vendor_id <= 0xFFFF - assert isinstance(pci_info.device_id, int) - assert 0x0000 <= pci_info.device_id <= 0xFFFF + assert isinstance(pci_info.device_id, int) + assert 0x0000 <= pci_info.device_id <= 0xFFFF - assert isinstance(pci_info.subsystem_id, int) - assert 0x00000000 <= pci_info.subsystem_id <= 0xFFFFFFFF + assert isinstance(pci_info.subsystem_id, int) + assert 0x00000000 <= pci_info.subsystem_id <= 0xFFFFFFFF - assert isinstance(pci_info.base_class, int) - assert 0x00 <= pci_info.base_class <= 0xFF + assert isinstance(pci_info.base_class, int) + assert 0x00 <= pci_info.base_class <= 0xFF - assert isinstance(pci_info.sub_class, int) - assert 0x00 <= pci_info.sub_class <= 0xFF + assert isinstance(pci_info.sub_class, int) + assert 0x00 <= pci_info.sub_class <= 0xFF - assert isinstance(pci_info.link_generation, int) - assert 0 <= pci_info.link_generation <= 0xFF + assert isinstance(pci_info.link_generation, int) + assert 0 <= pci_info.link_generation <= 0xFF - assert isinstance(pci_info.max_link_generation, int) - assert 0 <= pci_info.max_link_generation <= 0xFF + assert isinstance(pci_info.max_link_generation, int) + assert 0 <= pci_info.max_link_generation <= 0xFF - assert isinstance(pci_info.max_link_width, int) - assert 0 <= pci_info.max_link_width <= 0xFF + assert isinstance(pci_info.max_link_width, int) + assert 0 <= pci_info.max_link_width <= 0xFF - assert isinstance(pci_info.current_link_generation, int) - assert 0 <= pci_info.current_link_generation <= 0xFF + assert isinstance(pci_info.current_link_generation, int) + assert 0 <= pci_info.current_link_generation <= 0xFF - assert isinstance(pci_info.current_link_width, int) - assert 0 <= pci_info.current_link_width <= 0xFF + assert isinstance(pci_info.current_link_width, int) + assert 0 <= pci_info.current_link_width <= 0xFF - with unsupported_before(device, None): - assert isinstance(pci_info.tx_throughput, int) - assert isinstance(pci_info.rx_throughput, int) + with unsupported_before(device, None): + assert isinstance(pci_info.tx_throughput, int) + assert isinstance(pci_info.rx_throughput, int) - assert isinstance(pci_info.replay_counter, int) + assert isinstance(pci_info.replay_counter, int) -def test_device_serial(): +def test_device_serial(subtests): for device in system.Device.get_all_devices(): - with unsupported_before(device, "HAS_INFOROM"): - serial = device.serial - assert isinstance(serial, str) - assert len(serial) > 0 + with subtests.test(device_index=device.index): + with unsupported_before(device, "HAS_INFOROM"): + serial = device.serial + assert isinstance(serial, str) + assert len(serial) > 0 def test_device_uuid_without_prefix(): @@ -322,109 +321,117 @@ def test_device_pci_bus_id(): @pytest.mark.skipif(helpers.IS_WSL or helpers.IS_WINDOWS, reason="Device attributes not supported on WSL or Windows") -def test_device_attributes(): +def test_device_attributes(subtests): for device in system.Device.get_all_devices(): - # Docs say this should work on AMPERE or newer, but experimentally - # that's not the case. - with unsupported_before(device, None): - attributes = device.attributes - assert isinstance(attributes, _device.DeviceAttributes) + with subtests.test(device_index=device.index): + # Docs say this should work on AMPERE or newer, but experimentally + # that's not the case. + with unsupported_before(device, None): + attributes = device.attributes + assert isinstance(attributes, _device.DeviceAttributes) - assert isinstance(attributes.multiprocessor_count, int) - assert attributes.multiprocessor_count > 0 + assert isinstance(attributes.multiprocessor_count, int) + assert attributes.multiprocessor_count > 0 - assert isinstance(attributes.shared_copy_engine_count, int) - assert isinstance(attributes.shared_decoder_count, int) - assert isinstance(attributes.shared_encoder_count, int) - assert isinstance(attributes.shared_jpeg_count, int) - assert isinstance(attributes.shared_ofa_count, int) - assert isinstance(attributes.gpu_instance_slice_count, int) - assert isinstance(attributes.compute_instance_slice_count, int) - assert isinstance(attributes.memory_size_mb, int) - assert attributes.memory_size_mb > 0 + assert isinstance(attributes.shared_copy_engine_count, int) + assert isinstance(attributes.shared_decoder_count, int) + assert isinstance(attributes.shared_encoder_count, int) + assert isinstance(attributes.shared_jpeg_count, int) + assert isinstance(attributes.shared_ofa_count, int) + assert isinstance(attributes.gpu_instance_slice_count, int) + assert isinstance(attributes.compute_instance_slice_count, int) + assert isinstance(attributes.memory_size_mb, int) + assert attributes.memory_size_mb > 0 -def test_c2c_mode_enabled(): +def test_c2c_mode_enabled(subtests): for device in system.Device.get_all_devices(): - with unsupported_before(device, None): - is_enabled = device.is_c2c_enabled - assert isinstance(is_enabled, bool) + with subtests.test(device_index=device.index): + with unsupported_before(device, None): + is_enabled = device.is_c2c_enabled + assert isinstance(is_enabled, bool) @pytest.mark.skipif(helpers.IS_WSL or helpers.IS_WINDOWS, reason="Persistence mode not supported on WSL or Windows") -def test_persistence_mode_enabled(): +def test_persistence_mode_enabled(subtests): for device in system.Device.get_all_devices(): - is_enabled = device.is_persistence_mode_enabled - assert isinstance(is_enabled, bool) - try: - device.is_persistence_mode_enabled = False - except nvml.NoPermissionError as e: - pytest.xfail(f"nvml.NoPermissionError: {e}") - try: - assert device.is_persistence_mode_enabled is False - finally: - device.is_persistence_mode_enabled = is_enabled + with subtests.test(device_index=device.index): + is_enabled = device.is_persistence_mode_enabled + assert isinstance(is_enabled, bool) + try: + device.is_persistence_mode_enabled = False + except nvml.NoPermissionError as e: + pytest.xfail(f"nvml.NoPermissionError: {e}") + try: + assert device.is_persistence_mode_enabled is False + finally: + device.is_persistence_mode_enabled = is_enabled -def test_field_values(): +def test_field_values(subtests): for device in system.Device.get_all_devices(): - # TODO: Are there any fields that return double's? It would be good to - # test those. + with subtests.test(device_index=device.index): + # TODO: Are there any fields that return double's? It would be good to + # test those. - assert len(device.get_field_values([])) == 0 + assert len(device.get_field_values([])) == 0 - field_ids = [ - typing.FieldId.DEV_TOTAL_ENERGY_CONSUMPTION, - typing.FieldId.DEV_PCIE_COUNT_TX_BYTES, - ] - field_values = device.get_field_values(field_ids) - with unsupported_before(device, None): - field_values.validate() + field_ids = [ + typing.FieldId.DEV_TOTAL_ENERGY_CONSUMPTION, + typing.FieldId.DEV_PCIE_COUNT_TX_BYTES, + ] + field_values = device.get_field_values(field_ids) + with unsupported_before(device, None): + field_values.validate() - with pytest.raises(TypeError): - field_values["invalid_index"] + with pytest.raises(TypeError): + field_values["invalid_index"] - assert isinstance(field_values, _device.FieldValues) - assert len(field_values) == len(field_ids) + assert isinstance(field_values, _device.FieldValues) + assert len(field_values) == len(field_ids) - raw_values = field_values.get_all_values() - assert all(x == y.value for x, y in zip(raw_values, field_values)) + raw_values = field_values.get_all_values() + assert all(x == y.value for x, y in zip(raw_values, field_values)) - for field_id, field_value in zip(field_ids, field_values): - assert field_value.field_id == field_id - assert type(field_value.value) is int - assert field_value.latency_usec >= 0 - assert field_value.timestamp >= 0 + for field_id, field_value in zip(field_ids, field_values): + assert field_value.field_id == field_id + assert type(field_value.value) is int + assert field_value.latency_usec >= 0 + assert field_value.timestamp >= 0 - orig_timestamp = field_values[0].timestamp - field_values = device.get_field_values(field_ids) - assert field_values[0].timestamp >= orig_timestamp + orig_timestamp = field_values[0].timestamp + field_values = device.get_field_values(field_ids) + assert field_values[0].timestamp >= orig_timestamp - # Test only one element, because that's weirdly a special case - field_ids = [ - typing.FieldId.DEV_PCIE_REPLAY_COUNTER, - ] - field_values = device.get_field_values(field_ids) - assert len(field_values) == 1 - field_values.validate() - old_value = field_values[0].value + # Test only one element, because that's weirdly a special case + field_ids = [ + typing.FieldId.DEV_PCIE_REPLAY_COUNTER, + ] + field_values = device.get_field_values(field_ids) + assert len(field_values) == 1 + field_values.validate() + old_value = field_values[0].value - # Test clear_field_values - device.clear_field_values(field_ids) - field_values = device.get_field_values(field_ids) - field_values.validate() - assert len(field_values) == 1 - assert field_values[0].value <= old_value + # Test clear_field_values + device.clear_field_values(field_ids) + field_values = device.get_field_values(field_ids) + field_values.validate() + assert len(field_values) == 1 + assert field_values[0].value <= old_value @pytest.mark.skipif(helpers.IS_WSL or helpers.IS_WINDOWS, reason="Device attributes not supported on WSL or Windows") -def test_get_all_devices_with_cpu_affinity(): +def test_get_all_devices_with_cpu_affinity(subtests): for i in range(multiprocessing.cpu_count()): - for device in system.Device.get_all_devices_with_cpu_affinity(i): - with unsupported_before(device, DeviceArch.KEPLER): - affinity = device.get_cpu_affinity() - assert isinstance(affinity, list) - assert i in affinity + devices = [] + with subtests.test(cpu_index=i, affinity_api="get_all_devices_with_cpu_affinity"): + devices = list(system.Device.get_all_devices_with_cpu_affinity(i)) + for device in devices: + with subtests.test(cpu_index=i, device_index=device.index): + with unsupported_before(device, DeviceArch.KEPLER): + affinity = device.get_cpu_affinity() + assert isinstance(affinity, list) + assert i in affinity def test_index(): @@ -434,21 +441,23 @@ def test_index(): assert index == i -def test_module_id(): +def test_module_id(subtests): for device in system.Device.get_all_devices(): - with unsupported_before(device, None): - module_id = device.module_id - assert isinstance(module_id, int) - assert module_id >= 0 + with subtests.test(device_index=device.index): + with unsupported_before(device, None): + module_id = device.module_id + assert isinstance(module_id, int) + assert module_id >= 0 -def test_addressing_mode(): +def test_addressing_mode(subtests): for device in system.Device.get_all_devices(): - # By docs, should be supported on TURING or newer, but experimentally, - # is also unsupported on other hardware. - with unsupported_before(device, None): - addressing_mode = device.addressing_mode - assert addressing_mode is None or addressing_mode in typing.AddressingMode.__members__.values() + with subtests.test(device_index=device.index): + # By docs, should be supported on TURING or newer, but experimentally, + # is also unsupported on other hardware. + with unsupported_before(device, None): + addressing_mode = device.addressing_mode + assert addressing_mode is None or addressing_mode in typing.AddressingMode.__members__.values() def test_display_mode(): @@ -460,16 +469,17 @@ def test_display_mode(): assert isinstance(is_display_active, bool) -def test_repair_status(): +def test_repair_status(subtests): for device in system.Device.get_all_devices(): - # By docs, should be supported on AMPERE or newer, but experimentally, - # this seems to also work on some TURING systems. - with unsupported_before(device, None): - repair_status = device.repair_status - assert isinstance(repair_status, _device.RepairStatus) + with subtests.test(device_index=device.index): + # By docs, should be supported on AMPERE or newer, but experimentally, + # this seems to also work on some TURING systems. + with unsupported_before(device, None): + repair_status = device.repair_status + assert isinstance(repair_status, _device.RepairStatus) - assert isinstance(repair_status.channel_repair_pending, bool) - assert isinstance(repair_status.tpc_repair_pending, bool) + assert isinstance(repair_status.channel_repair_pending, bool) + assert isinstance(repair_status.tpc_repair_pending, bool) @pytest.mark.skipif(helpers.IS_WSL or helpers.IS_WINDOWS, reason="Device attributes not supported on WSL or Windows") @@ -520,213 +530,251 @@ def test_get_minor_number(): assert minor_number >= 0 -def test_get_inforom_version(): +def test_get_inforom_version(subtests): for device in system.Device.get_all_devices(): - with unsupported_before(device, "HAS_INFOROM"): - inforom = device.inforom + with subtests.test(device_index=device.index): + with unsupported_before(device, "HAS_INFOROM"): + inforom = device.inforom - with unsupported_before(device, "HAS_INFOROM"): - inforom_image_version = inforom.image_version - assert isinstance(inforom_image_version, str) - assert len(inforom_image_version) > 0 + with unsupported_before(device, "HAS_INFOROM"): + inforom_image_version = inforom.image_version + assert isinstance(inforom_image_version, str) + assert len(inforom_image_version) > 0 - inforom_version = inforom.get_version(typing.InforomObject.OEM) - assert isinstance(inforom_version, str) - assert len(inforom_version) > 0 + inforom_version = inforom.get_version(typing.InforomObject.OEM) + assert isinstance(inforom_version, str) + assert len(inforom_version) > 0 - checksum = inforom.configuration_checksum - assert isinstance(checksum, int) + checksum = inforom.configuration_checksum + assert isinstance(checksum, int) - # TODO: This is untested locally. - try: - timestamp, duration_us = inforom.bbx_flush_time - except (system.NotSupportedError, system.NotReadyError): - pass - else: - assert isinstance(timestamp, int) - assert timestamp > 0 - assert isinstance(duration_us, int) - assert duration_us > 0 + # TODO: This is untested locally. + try: + timestamp, duration_us = inforom.bbx_flush_time + except (system.NotSupportedError, system.NotReadyError): + pass + else: + assert isinstance(timestamp, int) + assert timestamp > 0 + assert isinstance(duration_us, int) + assert duration_us > 0 - with unsupported_before(device, "HAS_INFOROM"): - board_part_number = inforom.board_part_number - assert isinstance(board_part_number, str) + with unsupported_before(device, "HAS_INFOROM"): + board_part_number = inforom.board_part_number + assert isinstance(board_part_number, str) - # Some boards (e.g. NVIDIA T4G) do not program a board part number - assert board_part_number == "" or board_part_number.strip() == board_part_number + # Some boards (e.g. NVIDIA T4G) do not program a board part number + assert board_part_number == "" or board_part_number.strip() == board_part_number - inforom.validate() + inforom.validate() -def test_auto_boosted_clocks_enabled(): +def test_auto_boosted_clocks_enabled(subtests): for device in system.Device.get_all_devices(): - # This API is supported on KEPLER and newer, but it also seems - # unsupported elsewhere. - with unsupported_before(device, None): - current, default = device.is_auto_boosted_clocks_enabled - assert isinstance(current, bool) - assert isinstance(default, bool) + with subtests.test(device_index=device.index): + # This API is supported on KEPLER and newer, but it also seems + # unsupported elsewhere. + with unsupported_before(device, None): + current, default = device.is_auto_boosted_clocks_enabled + assert isinstance(current, bool) + assert isinstance(default, bool) -def test_clock(): +def test_clock(subtests): for device in system.Device.get_all_devices(): for clock_type in typing.ClockType: - clock = device.get_clock(clock_type) - assert isinstance(clock, _device.ClockInfo) - - # These are ordered from oldest API to newest API so we test as much - # as we can on each hardware architecture. - - with unsupported_before(device, None): - pstate = device.performance_state - - min_, max_ = clock.get_min_max_clock_of_pstate_mhz(pstate) - assert isinstance(min_, int) - assert min_ >= 0 - assert isinstance(max_, int) - assert max_ >= 0 - - with unsupported_before(device, "FERMI"): - max_mhz = clock.get_max_mhz() - assert isinstance(max_mhz, int) - assert max_mhz >= 0 + with subtests.test(device_index=device.index, clock_type=clock_type.value): + clock = device.get_clock(clock_type) + assert isinstance(clock, _device.ClockInfo) - with unsupported_before(device, DeviceArch.KEPLER): - current_mhz = clock.get_current_mhz() - assert isinstance(current_mhz, int) - assert current_mhz >= 0 + # These are ordered from oldest API to newest API so we test as much + # as we can on each hardware architecture. - # Docs say this should work on PASCAL or newer, but experimentally, - # is also unsupported on other hardware. - with unsupported_before(device, DeviceArch.MAXWELL): - try: - offsets = clock.get_offsets(pstate) - except (system.InvalidArgumentError, system.NotFoundError): - pass - else: - assert isinstance(offsets, _device.ClockOffsets) - assert isinstance(offsets.clock_offset_mhz, int) - assert isinstance(offsets.max_offset_mhz, int) - assert isinstance(offsets.min_offset_mhz, int) + with unsupported_before(device, None): + pstate = device.performance_state - # By docs, should be supported on PASCAL or newer, but experimentally, - # is also unsupported on other hardware. - with unsupported_before(device, None): - max_customer_boost = clock.get_max_customer_boost_mhz() - assert isinstance(max_customer_boost, int) - assert max_customer_boost >= 0 + min_, max_ = clock.get_min_max_clock_of_pstate_mhz(pstate) + assert isinstance(min_, int) + assert min_ >= 0 + assert isinstance(max_, int) + assert max_ >= 0 + + with unsupported_before(device, "FERMI"): + max_mhz = clock.get_max_mhz() + assert isinstance(max_mhz, int) + assert max_mhz >= 0 + + with unsupported_before(device, DeviceArch.KEPLER): + current_mhz = clock.get_current_mhz() + assert isinstance(current_mhz, int) + assert current_mhz >= 0 + + # Docs say this should work on PASCAL or newer, but experimentally, + # is also unsupported on other hardware. + with unsupported_before(device, DeviceArch.MAXWELL): + try: + offsets = clock.get_offsets(pstate) + except (system.InvalidArgumentError, system.NotFoundError): + pass + else: + assert isinstance(offsets, _device.ClockOffsets) + assert isinstance(offsets.clock_offset_mhz, int) + assert isinstance(offsets.max_offset_mhz, int) + assert isinstance(offsets.min_offset_mhz, int) + + # By docs, should be supported on PASCAL or newer, but experimentally, + # is also unsupported on other hardware. + with unsupported_before(device, None): + max_customer_boost = clock.get_max_customer_boost_mhz() + assert isinstance(max_customer_boost, int) + assert max_customer_boost >= 0 -def test_clock_event_reasons(): +def test_clock_event_reasons(subtests): for device in system.Device.get_all_devices(): - with unsupported_before(device, None): - reasons = device.current_clock_event_reasons - assert all(isinstance(reason, typing.ClocksEventReasons) for reason in reasons) + with subtests.test(device_index=device.index): + with unsupported_before(device, None): + reasons = device.current_clock_event_reasons + assert all(isinstance(reason, typing.ClocksEventReasons) for reason in reasons) - with unsupported_before(device, None): - reasons = device.supported_clock_event_reasons - assert all(isinstance(reason, typing.ClocksEventReasons) for reason in reasons) + with unsupported_before(device, None): + reasons = device.supported_clock_event_reasons + assert all(isinstance(reason, typing.ClocksEventReasons) for reason in reasons) -def test_fan(): +def test_fan(subtests): for device in system.Device.get_all_devices(): + device_index = device.index + num_fans = None # The fan APIs are only supported on discrete devices with fans, # but when they are not available `device.num_fans` returns 0. - if device.num_fans == 0: - pytest.skip("Device has no fans to test") + with subtests.test(device_index=device_index, fan_api="get_num_fans"): + value = device.num_fans + assert isinstance(value, int) + assert value >= 0 + num_fans = value + if num_fans == 0: + pytest.skip("Device has no fans to test") + if not num_fans: + continue - for fan_idx in range(device.num_fans): - fan_info = device.get_fan(fan_idx) - assert isinstance(fan_info, _device.FanInfo) + for fan_idx in range(num_fans): + with subtests.test(device_index=device_index, fan_index=fan_idx): + fan_info = device.get_fan(fan_idx) + assert isinstance(fan_info, _device.FanInfo) - speed = fan_info.speed - assert isinstance(speed, int) - assert 0 <= speed <= 200 - try: - fan_info.speed = 50 - except nvml.NoPermissionError as e: - pytest.xfail(f"nvml.NoPermissionError: {e}") - try: - fan_info.speed = speed + speed = fan_info.speed + assert isinstance(speed, int) + assert 0 <= speed <= 200 + try: + fan_info.speed = 50 + except nvml.NoPermissionError as e: + pytest.xfail(f"nvml.NoPermissionError: {e}") + try: + fan_info.speed = speed - speed_rpm = fan_info.speed_rpm - assert isinstance(speed_rpm, int) - assert speed_rpm >= 0 + speed_rpm = fan_info.speed_rpm + assert isinstance(speed_rpm, int) + assert speed_rpm >= 0 - target_speed = fan_info.target_speed - assert isinstance(target_speed, int) - assert speed <= target_speed * 2 + target_speed = fan_info.target_speed + assert isinstance(target_speed, int) + assert speed <= target_speed * 2 - min_, max_ = fan_info.min_max_speed - assert isinstance(min_, int) - assert isinstance(max_, int) - assert min_ <= max_ + min_, max_ = fan_info.min_max_speed + assert isinstance(min_, int) + assert isinstance(max_, int) + assert min_ <= max_ - control_policy = fan_info.control_policy - assert isinstance(control_policy, typing.FanControlPolicy) - finally: - fan_info.set_default_speed() + control_policy = fan_info.control_policy + assert isinstance(control_policy, typing.FanControlPolicy) + finally: + fan_info.set_default_speed() -def test_cooler(): +def test_cooler(subtests): for device in system.Device.get_all_devices(): - # The cooler APIs are only supported on discrete devices with fans, - # but when they are not available `device.num_fans` returns 0. - if device.num_fans == 0: - pytest.skip("Device has no coolers to test") + with subtests.test(device_index=device.index): + # The cooler APIs are only supported on discrete devices with fans, + # but when they are not available `device.num_fans` returns 0. + if device.num_fans == 0: + pytest.skip("Device has no coolers to test") - with unsupported_before(device, DeviceArch.MAXWELL): - cooler_info = device.cooler + with unsupported_before(device, DeviceArch.MAXWELL): + cooler_info = device.cooler - assert isinstance(cooler_info, _device.CoolerInfo) + assert isinstance(cooler_info, _device.CoolerInfo) - signal_type = cooler_info.signal_type - assert isinstance(signal_type, (typing.CoolerControl, type(None))) + signal_type = cooler_info.signal_type + assert isinstance(signal_type, (typing.CoolerControl, type(None))) - target = cooler_info.target - assert all(isinstance(t, typing.CoolerTarget) for t in target) + target = cooler_info.target + assert all(isinstance(t, typing.CoolerTarget) for t in target) @pytest.mark.filterwarnings("ignore::DeprecationWarning") -def test_temperature(): - for device in system.Device.get_all_devices(): - temperature = device.temperature - assert isinstance(temperature, _device.Temperature) +def test_temperature(subtests): + for device in system.Device.get_all_devices(): + device_index = device.index + temperature = None + with subtests.test(device_index=device_index, temperature_api="temperature"): + value = device.temperature + assert isinstance(value, _device.Temperature) + temperature = value + if temperature is None: + continue - sensor = temperature.get_sensor() - assert isinstance(sensor, int) - assert sensor >= 0 + with subtests.test(device_index=device_index, temperature_api="get_sensor"): + sensor = temperature.get_sensor() + assert isinstance(sensor, int) + assert sensor >= 0 # By docs, should be supported on KEPLER or newer, but experimentally, # is also unsupported on other hardware. # get_threshold emits DeprecationWarning for some thresholds on Ada+; # that behaviour is tested separately in # test_temperature_threshold_unrecognized_device_arch. - with unsupported_before(device, None): - for threshold in list(typing.TemperatureThresholds): - t = temperature.get_threshold(threshold) + for threshold in typing.TemperatureThresholds: + with subtests.test( + device_index=device_index, + temperature_api="get_threshold", + threshold=threshold.value, + ): + with unsupported_before(device, None): + t = temperature.get_threshold(threshold) assert isinstance(t, int) assert t >= 0 - with unsupported_before(device, None): - margin = temperature.margin - assert isinstance(margin, int) - assert margin >= 0 + with subtests.test(device_index=device_index, temperature_api="margin"): + with unsupported_before(device, None): + margin = temperature.margin + assert isinstance(margin, int) + assert margin >= 0 - with unsupported_before(device, None): - thermals = temperature.get_thermal_settings(typing.ThermalTarget.ALL) - assert isinstance(thermals, _device.ThermalSettings) + thermals = None + with subtests.test(device_index=device_index, temperature_api="get_thermal_settings"): + with unsupported_before(device, None): + value = temperature.get_thermal_settings(typing.ThermalTarget.ALL) + assert isinstance(value, _device.ThermalSettings) + thermals = value + if thermals is None: + continue for i, sensor in enumerate(thermals): - assert isinstance(sensor, _device.ThermalSensor) - assert isinstance(sensor.target, typing.ThermalTarget) - assert isinstance(sensor.controller, typing.ThermalController) - assert isinstance(sensor.default_min_temp, int) - assert sensor.default_min_temp >= 0 - assert isinstance(sensor.default_max_temp, int) - assert sensor.default_max_temp >= sensor.default_min_temp - assert isinstance(sensor.current_temp, int) - assert sensor.default_min_temp <= sensor.current_temp <= sensor.default_max_temp + with subtests.test( + device_index=device_index, + temperature_api="thermal_sensor", + sensor_index=i, + ): + assert isinstance(sensor, _device.ThermalSensor) + assert isinstance(sensor.target, typing.ThermalTarget) + assert isinstance(sensor.controller, typing.ThermalController) + assert isinstance(sensor.default_min_temp, int) + assert sensor.default_min_temp >= 0 + assert isinstance(sensor.default_max_temp, int) + assert sensor.default_max_temp >= sensor.default_min_temp + assert isinstance(sensor.current_temp, int) + assert sensor.default_min_temp <= sensor.current_temp <= sensor.default_max_temp @pytest.mark.thread_unsafe(reason="Temporarily replaces process-global NVML functions") @@ -781,51 +829,64 @@ def test_device_arg_validation(): system.get_p2p_status(device, device, "not-an-index") -def test_pstates(): +def test_pstates(subtests): for device in system.Device.get_all_devices(): - with unsupported_before(device, None): - pstate = device.performance_state - assert isinstance(pstate, int) + with subtests.test(device_index=device.index): + with unsupported_before(device, None): + pstate = device.performance_state + assert isinstance(pstate, int) - pstates = device.supported_pstates - assert all(isinstance(p, int) for p in pstates) + pstates = device.supported_pstates + assert all(isinstance(p, int) for p in pstates) - dynamic_pstates_info = device.dynamic_pstates_info - assert isinstance(dynamic_pstates_info, _device.GpuDynamicPstatesInfo) + dynamic_pstates_info = device.dynamic_pstates_info + assert isinstance(dynamic_pstates_info, _device.GpuDynamicPstatesInfo) - assert len(dynamic_pstates_info) == nvml.MAX_GPU_UTILIZATIONS + assert len(dynamic_pstates_info) == nvml.MAX_GPU_UTILIZATIONS - for utilization in dynamic_pstates_info: - assert isinstance(utilization.is_present, bool) - assert isinstance(utilization.percentage, int) - assert isinstance(utilization.inc_threshold, int) - assert isinstance(utilization.dec_threshold, int) + for utilization in dynamic_pstates_info: + assert isinstance(utilization.is_present, bool) + assert isinstance(utilization.percentage, int) + assert isinstance(utilization.inc_threshold, int) + assert isinstance(utilization.dec_threshold, int) -def test_compute_running_processes(): +def test_compute_running_processes(subtests): for cuda_device in CudaDevice.get_all_devices(): device = cuda_device.to_system_device() - with unsupported_before(device, "FERMI"): - processes = device.compute_running_processes - assert isinstance(processes, list) - for proc in processes: - assert isinstance(proc, _device.ProcessInfo) - assert isinstance(proc.pid, int) - assert isinstance(proc.used_gpu_memory, int) - if device.mig.is_mig_device: - assert isinstance(proc.gpu_instance_id, int) - assert isinstance(proc.compute_instance_id, int) - else: - with pytest.raises(nvml.NotSupportedError): - proc.gpu_instance_id # noqa: B018 - with pytest.raises(nvml.NotSupportedError): - proc.compute_instance_id # noqa: B018 - - -def test_nvlink(): - for device in system.Device.get_all_devices(): - with unsupported_before(device, None): - for link in range(device.get_nvlink_count()): + with subtests.test(device_index=device.index): + with unsupported_before(device, "FERMI"): + processes = device.compute_running_processes + assert isinstance(processes, list) + for proc in processes: + assert isinstance(proc, _device.ProcessInfo) + assert isinstance(proc.pid, int) + assert isinstance(proc.used_gpu_memory, int) + if device.mig.is_mig_device: + assert isinstance(proc.gpu_instance_id, int) + assert isinstance(proc.compute_instance_id, int) + else: + with pytest.raises(nvml.NotSupportedError): + proc.gpu_instance_id # noqa: B018 + with pytest.raises(nvml.NotSupportedError): + proc.compute_instance_id # noqa: B018 + + +def test_nvlink(subtests): + for device in system.Device.get_all_devices(): + device_index = device.index + link_count = 0 + with ( + subtests.test(device_index=device_index, nvlink_api="get_nvlink_count"), + unsupported_before(device, None), + ): + value = device.get_nvlink_count() + assert isinstance(value, int) + assert value >= 0 + link_count = value + + for link in range(link_count): + with subtests.test(device_index=device_index, nvlink_api="get_nvlink", link_index=link): with unsupported_before(device, None): nvlink_info = device.get_nvlink(link) assert isinstance(nvlink_info, _device.NvlinkInfo) @@ -843,7 +904,15 @@ def test_nvlink(): assert len(version) == 2 assert all(isinstance(i, int) for i in version) - for nvlink_info in device.get_nvlinks(): + nvlink_infos = [] + with ( + subtests.test(device_index=device_index, nvlink_api="get_nvlinks"), + unsupported_before(device, None), + ): + nvlink_infos = list(device.get_nvlinks()) + + for link, nvlink_info in enumerate(nvlink_infos): + with subtests.test(device_index=device_index, nvlink_api="get_nvlinks", link_index=link): assert isinstance(nvlink_info, _device.NvlinkInfo) with unsupported_before(device, None): @@ -865,25 +934,26 @@ def test_nvlink_max_links_deprecated(): _ = _device.NvlinkInfo.max_links -def test_utilization(): +def test_utilization(subtests): for device in system.Device.get_all_devices(): - with unsupported_before(device, None): - utilization = device.utilization - assert isinstance(utilization, _device.Utilization) + with subtests.test(device_index=device.index): + with unsupported_before(device, None): + utilization = device.utilization + assert isinstance(utilization, _device.Utilization) - gpu = utilization.gpu - assert isinstance(gpu, int) - assert 0 <= gpu <= 100 + gpu = utilization.gpu + assert isinstance(gpu, int) + assert 0 <= gpu <= 100 - memory = utilization.memory - assert isinstance(memory, int) - assert 0 <= memory <= 100 + memory = utilization.memory + assert isinstance(memory, int) + assert 0 <= memory <= 100 @pytest.mark.skipif(helpers.IS_WSL or helpers.IS_WINDOWS, reason="MIG not supported on WSL or Windows") -def test_mig(): +def test_mig(subtests): for device in system.Device.get_all_devices(): - with unsupported_before(device, None): + with subtests.test(device_index=device.index), unsupported_before(device, None): mig = device.mig assert isinstance(mig.is_mig_device, bool) diff --git a/cuda_core/tests/test_enum_coverage.py b/cuda_core/tests/test_enum_coverage.py index a121d9c1d9f..2c83d1a1f21 100644 --- a/cuda_core/tests/test_enum_coverage.py +++ b/cuda_core/tests/test_enum_coverage.py @@ -132,6 +132,15 @@ _MODULES.append(system_typing) + _CLOCKS_EVENT_REASONS_STR_UNMAPPED = { + core_member + for binding_member, core_member in ( + ("EVENT_REASON_BOARD_LIMIT", "BOARD_LIMIT"), + ("EVENT_REASON_RELIABILITY", "RELIABILITY"), + ) + if binding_member not in nvml.ClocksEventReasons.__members__ + } + _CASES.extend( [ ( @@ -164,7 +173,7 @@ system_typing.ClocksEventReasons, _device._CLOCKS_EVENT_REASONS_MAPPING, set(), - set(), + _CLOCKS_EVENT_REASONS_STR_UNMAPPED, ), ( nvml.EventType, diff --git a/cuda_core/tests/test_event.py b/cuda_core/tests/test_event.py index 79f0090ace6..3e765a9e0d0 100644 --- a/cuda_core/tests/test_event.py +++ b/cuda_core/tests/test_event.py @@ -222,6 +222,7 @@ def test_event_ipc_descriptor_non_ipc(init_cuda): _ = event.ipc_descriptor +@pytest.mark.skipif(Device().compute_capability.major < 7, reason="__nanosleep is only available starting Volta (sm70)") def test_event_is_done_false(init_cuda): """Event.is_done returns False when captured work has not yet completed.""" device = Device() diff --git a/cuda_core/tests/test_memory.py b/cuda_core/tests/test_memory.py index dff42239bd4..da44f837293 100644 --- a/cuda_core/tests/test_memory.py +++ b/cuda_core/tests/test_memory.py @@ -31,6 +31,7 @@ DeviceMemoryResourceOptions, GraphMemoryResource, LegacyPinnedMemoryResource, + ManagedBuffer, ManagedMemoryResource, ManagedMemoryResourceOptions, MemoryResource, @@ -41,6 +42,7 @@ ) from cuda.core._dlpack import DLDeviceType from cuda.core._memory._ipc import IPCBufferDescriptor +from cuda.core._stream import Stream_accept, default_stream from cuda.core._utils.cuda_utils import CUDAError, handle_return from cuda.core.typing import ( ManagedMemoryLocationType, @@ -510,20 +512,15 @@ def deallocate(self, ptr, size, *, stream=None): assert received["stream"].handle == stream.handle -def test_mr_dealloc_callback_falls_back_to_default_stream(): - """When a Buffer's device-pointer handle has no attached deallocation - stream (e.g. buffers minted via :meth:`Buffer.from_handle` from DLPack - import, IPC import, or third-party adapters), the C++ deleter callback - must fall back to the default stream rather than passing ``stream=None`` - to ``mr.deallocate``. Stream-ordered MRs validate the stream and would - otherwise raise ``TypeError`` from inside the ``noexcept`` callback, - which only logs a warning and silently leaks the allocation. See - `#2001 <https://github.com/NVIDIA/cuda-python/issues/2001>`__. +@pytest.mark.parametrize("buffer_type", [Buffer, ManagedBuffer]) +def test_from_handle_mr_records_default_stream(buffer_type): + """When a Buffer/ManagedBuffer is minted via :meth:`from_handle` with ``mr`` + but without an explicit ``stream=``, the deallocation stream is recorded at + creation as ``default_stream()`` (not chosen later in the destructor). + See `#2497`. """ import gc - from cuda.core._stream import Stream_accept, default_stream - device = Device() device.set_current() captured = {} @@ -550,9 +547,8 @@ def deallocate(self, ptr, size, *, stream): captured["stream"] = Stream_accept(stream) mr = StrictCapturingMR() - # Buffer.from_handle binds mr but does not attach a deallocation stream. # ptr=1 is fine because StrictCapturingMR.deallocate does not free. - buf = Buffer.from_handle(1, 1024, mr=mr) + buf = buffer_type.from_handle(1, 1024, mr=mr) del buf gc.collect() @@ -560,6 +556,344 @@ def deallocate(self, ptr, size, *, stream): assert captured["stream"].handle == default_stream().handle +@pytest.mark.agent_authored(model="cursor-grok-4.5") +@pytest.mark.parametrize("buffer_type", [Buffer, ManagedBuffer]) +def test_from_handle_mr_records_explicit_stream(buffer_type): + """Buffer/ManagedBuffer.from_handle(..., mr=mr, stream=s) stores s for teardown.""" + import gc + + device = Device() + device.set_current() + stream = device.create_stream() + captured = {} + + class StrictCapturingMR(MemoryResource): + @property + def is_device_accessible(self): + return True + + @property + def is_host_accessible(self): + return False + + @property + def device_id(self): + return device.device_id + + def allocate(self, size, *, stream): + raise NotImplementedError + + def deallocate(self, ptr, size, *, stream): + captured["stream"] = Stream_accept(stream) + + mr = StrictCapturingMR() + buf = buffer_type.from_handle(1, 1024, mr=mr, stream=stream) + del buf + gc.collect() + + assert captured["stream"].handle == stream.handle + + +@pytest.mark.agent_authored(model="cursor-grok-4.5") +@pytest.mark.parametrize("buffer_type", [Buffer, ManagedBuffer]) +def test_from_handle_stream_requires_mr(buffer_type): + device = Device() + device.set_current() + stream = device.create_stream() + with pytest.raises(ValueError, match="stream requires a memory resource"): + buffer_type.from_handle(1, 1024, stream=stream) + + +@pytest.mark.agent_authored(model="claude-sonnet-4-6") +def test_close_with_default_stream_requires_context(): + """Buffer.close(stream=default_stream()) raises when no context is current. + + ``default_stream()`` has no bound context, so the close path must find + a current context to anchor the free. Without one it should raise rather + than silently record an unusable stream handle. + """ + device = Device() + device.set_current() + stream = device.create_stream() + + class NoopMR(MemoryResource): + @property + def is_device_accessible(self): + return True + + @property + def is_host_accessible(self): + return False + + @property + def device_id(self): + return device.device_id + + def allocate(self, size, *, stream): + raise NotImplementedError + + def deallocate(self, ptr, size, *, stream): + pass + + mr = NoopMR() + # Use a real stream at creation so _init succeeds without a current context later. + buf = Buffer.from_handle(1, 1024, mr=mr, stream=stream) + + previous = handle_return(driver.cuCtxPopCurrent()) + assert int(previous) != 0 + try: + assert int(handle_return(driver.cuCtxGetCurrent())) == 0 + with pytest.raises(RuntimeError, match="no CUDA context is current"): + buf.close(stream=default_stream()) + finally: + handle_return(driver.cuCtxSetCurrent(previous)) + + buf.close() # clean up using the recorded stream (which carries a context) + + +@pytest.mark.agent_authored(model="cursor-grok-4.5") +@pytest.mark.parametrize("buffer_type", [Buffer, ManagedBuffer]) +def test_from_handle_mr_default_stream_requires_context(buffer_type): + """Owning from_handle with the default stream needs a current context.""" + device = Device() + device.set_current() + + class StrictCapturingMR(MemoryResource): + @property + def is_device_accessible(self): + return True + + @property + def is_host_accessible(self): + return False + + @property + def device_id(self): + return device.device_id + + def allocate(self, size, *, stream): + raise NotImplementedError + + def deallocate(self, ptr, size, *, stream): + pass + + mr = StrictCapturingMR() + previous = handle_return(driver.cuCtxPopCurrent()) + assert int(previous) != 0 + try: + assert int(handle_return(driver.cuCtxGetCurrent())) == 0 + with pytest.raises(RuntimeError, match="no CUDA context is current"): + buffer_type.from_handle(1, 1024, mr=mr) + finally: + handle_return(driver.cuCtxSetCurrent(previous)) + + +@pytest.mark.agent_authored(model="gpt-5.6") +@pytest.mark.parametrize("buffer_type", [Buffer, ManagedBuffer]) +def test_from_handle_mr_explicit_stream_without_current_context(buffer_type): + """A context-bound stream makes owning from_handle context-independent.""" + device = Device() + device.set_current() + stream = device.create_stream() + captured = {} + + class StrictCapturingMR(MemoryResource): + @property + def is_device_accessible(self): + return True + + @property + def is_host_accessible(self): + return False + + @property + def device_id(self): + return device.device_id + + def allocate(self, size, *, stream): + raise NotImplementedError + + def deallocate(self, ptr, size, *, stream): + captured["stream"] = Stream_accept(stream) + + mr = StrictCapturingMR() + previous = handle_return(driver.cuCtxPopCurrent()) + assert int(previous) != 0 + try: + assert int(handle_return(driver.cuCtxGetCurrent())) == 0 + buf = buffer_type.from_handle(1, 1024, mr=mr, stream=stream) + buf.close() + assert int(handle_return(driver.cuCtxGetCurrent())) == 0 + finally: + handle_return(driver.cuCtxSetCurrent(previous)) + + assert captured["stream"].handle == stream.handle + + +@pytest.mark.agent_authored(model="gpt-5.6") +def test_mr_deallocation_failure_warns(capfd): + """Destructor-path MR failures are contained and reported.""" + device = Device() + device.set_current() + + class FailingMR(MemoryResource): + @property + def is_device_accessible(self): + return True + + @property + def is_host_accessible(self): + return False + + @property + def device_id(self): + return device.device_id + + def allocate(self, size, *, stream): + raise NotImplementedError + + def deallocate(self, ptr, size, *, stream): + raise RuntimeError("expected deallocation failure") + + buf = Buffer.from_handle(1, 1024, mr=FailingMR()) + buf.close() + + assert ( + "Warning: mr.deallocate() failed during Buffer destruction: expected deallocation failure" + ) in capfd.readouterr().err + + +@pytest.mark.agent_authored(model="cursor-grok-4.5") +@pytest.mark.parametrize("replace_stream", [False, True]) +def test_mr_deallocation_without_current_context(init_cuda, capsys, replace_stream): + """MR-backed Buffer teardown activates the recorded context when none is current.""" + mr = TrackingMR() + buf = mr.allocate(1024) + stream = init_cuda.create_stream() if replace_stream else None + assert len(mr.active) == 1 + + previous = handle_return(driver.cuCtxPopCurrent()) + assert int(previous) != 0 + try: + assert int(handle_return(driver.cuCtxGetCurrent())) == 0 + + buf.close(stream) + + assert len(mr.active) == 0 + assert int(handle_return(driver.cuCtxGetCurrent())) == 0 + assert "mr.deallocate() failed" not in capsys.readouterr().err + finally: + handle_return(driver.cuCtxSetCurrent(previous)) + + +@pytest.mark.agent_authored(model="cursor-grok-4.5") +@pytest.mark.parametrize("replace_stream", [False, True]) +def test_mr_deallocation_with_foreign_context(capsys, replace_stream): + """MR-backed Buffer teardown switches away from an unrelated current context.""" + if len(Device.get_all_devices()) < 2: + pytest.skip("Test requires at least 2 GPUs") + + alloc_dev = Device(0) + alloc_dev.set_current() + mr = TrackingMR() + buf = mr.allocate(1024) + stream = alloc_dev.create_stream() if replace_stream else None + assert len(mr.active) == 1 + alloc_ctx = int(handle_return(driver.cuCtxGetCurrent())) + + foreign_dev = Device(1) + foreign_dev.set_current() + foreign_ctx = int(handle_return(driver.cuCtxGetCurrent())) + assert foreign_ctx != 0 + assert foreign_ctx != alloc_ctx + + try: + buf.close(stream) + + assert len(mr.active) == 0 + assert int(handle_return(driver.cuCtxGetCurrent())) == foreign_ctx + assert "mr.deallocate() failed" not in capsys.readouterr().err + finally: + alloc_dev.set_current() + + +@pytest.mark.agent_authored(model="claude-opus-5") +def test_mr_deallocate_raises_on_driver_error(mempool_device): + """An explicit mr.deallocate() call propagates driver errors to the caller. + + Buffer teardown must not raise, so the containment lives in the destruction + callback rather than in deallocate() itself. See `#2497`. + """ + dev = mempool_device + stream = dev.create_stream() + mr = DeviceMemoryResource(dev, DeviceMemoryResourceOptions(max_size=POOL_SIZE)) + + with pytest.raises(CUDAError): + mr.deallocate(0xDEADBEEF, 256, stream=stream) + + +@pytest.mark.agent_authored(model="cursor-grok-4.5") +def test_pool_buffer_deallocates_without_current_context(mempool_device, capfd): + """Pool Buffer.close frees on the recorded stream with no current context.""" + dev = mempool_device + stream = dev.create_stream() + mr = DeviceMemoryResource(dev, DeviceMemoryResourceOptions(max_size=POOL_SIZE)) + size = 256 + buf = mr.allocate(size, stream=stream) + stream.sync() + used_after_alloc = mr.attributes.used_mem_current + + previous = handle_return(driver.cuCtxPopCurrent()) + assert int(previous) != 0 + try: + assert int(handle_return(driver.cuCtxGetCurrent())) == 0 + + buf.close() + stream.sync() + + assert mr.attributes.used_mem_current < used_after_alloc + assert int(handle_return(driver.cuCtxGetCurrent())) == 0 + err = capfd.readouterr().err + assert "failed during resource destruction" not in err + assert "mr.deallocate() failed" not in err + finally: + handle_return(driver.cuCtxSetCurrent(previous)) + + +@pytest.mark.agent_authored(model="cursor-grok-4.5") +def test_pool_buffer_deallocates_with_foreign_context(mempool_device_x2, capfd): + """Pool Buffer.close frees under the recorded context while another is current.""" + alloc_dev, foreign_dev = mempool_device_x2 + alloc_dev.set_current() + stream = alloc_dev.create_stream() + mr = DeviceMemoryResource(alloc_dev, DeviceMemoryResourceOptions(max_size=POOL_SIZE)) + size = 256 + buf = mr.allocate(size, stream=stream) + stream.sync() + used_after_alloc = mr.attributes.used_mem_current + alloc_ctx = int(handle_return(driver.cuCtxGetCurrent())) + + foreign_dev.set_current() + foreign_ctx = int(handle_return(driver.cuCtxGetCurrent())) + assert foreign_ctx != 0 + assert foreign_ctx != alloc_ctx + + try: + buf.close() + assert int(handle_return(driver.cuCtxGetCurrent())) == foreign_ctx + + # Observe the free on the allocation device, then restore the foreign context. + alloc_dev.set_current() + stream.sync() + assert mr.attributes.used_mem_current < used_after_alloc + foreign_dev.set_current() + + err = capfd.readouterr().err + assert "failed during resource destruction" not in err + finally: + alloc_dev.set_current() + + def test_memory_resource_and_owner_disallowed(): with pytest.raises(ValueError, match="cannot be both specified together"): a = (ctypes.c_byte * 20)() @@ -615,6 +949,8 @@ def test_buffer_dunder_dlpack_device_success(DummyMR, expected): def test_buffer_dunder_dlpack_device_failure(): + # avoids an error capturing the default stream with no context + Device().set_current() dummy_mr = NullMemoryResource() buffer = dummy_mr.allocate(size=1024) with pytest.raises(BufferError, match=r"^buffer is neither device-accessible nor host-accessible$"): @@ -622,6 +958,8 @@ def test_buffer_dunder_dlpack_device_failure(): def test_buffer_dlpack_failure_clean_up(): + # avoids an error capturing the default stream with no context + Device().set_current() dummy_mr = NullMemoryResource() buffer = dummy_mr.allocate(size=1024) before = sys.getrefcount(buffer) diff --git a/cuda_core/tests/test_rlcompleter_patch.py b/cuda_core/tests/test_rlcompleter_patch.py index 68bd7b6e4f7..50283e62a31 100644 --- a/cuda_core/tests/test_rlcompleter_patch.py +++ b/cuda_core/tests/test_rlcompleter_patch.py @@ -107,3 +107,61 @@ def test_opt_out_env_var_disables_patch_even_when_interactive(): result = _run_probe(pythoninspect=True, opt_out=True) assert result.returncode == 0, f"stderr: {result.stderr}\nstdout: {result.stdout}" assert "crash: RuntimeError" in result.stdout, result.stdout + + +# Imports cuda.core and reports whether the rlcompleter patch was installed. +# No CUDA device is needed: the opt-out is evaluated at import time. The +# stdlib rlcompleter module has no `property` attribute of its own, so its +# presence is exactly the signal that the patch ran. +_OPT_OUT_PROBE_SCRIPT = textwrap.dedent(""" + import rlcompleter + + import cuda.core # noqa: F401 + + print(f"patched: {hasattr(rlcompleter, 'property')}") +""") + + +@pytest.mark.agent_authored(model="claude-opus-5") +@pytest.mark.parametrize( + ("value", "expect_patched"), + [ + # Empty / whitespace-only means "not set": `export VAR=` is the usual + # way to neutralize a variable in a shell profile or container spec. + ("", True), + (" ", True), + # Integer values keep their long-standing meaning. + ("0", True), + ("00", True), + ("1", False), + ("2", False), + # Non-integer values are honored as an opt-out. + ("true", False), + ("yes", False), + ], +) +def test_opt_out_env_var_values(value, expect_patched): + """`CUDA_CORE_DONT_FIX_TAB_COMPLETION` must never break `import cuda.core`. + + The opt-out used to be read with a bare `int(...)` at import time, so any + value that is not a base-10 integer -- including the empty string -- raised + `ValueError: invalid literal for int() with base 10: ''` out of + `cuda/core/__init__.py` and made the package unimportable. + """ + env = os.environ.copy() + env.pop("PYTHONPATH", None) + env["CUDA_CORE_DONT_FIX_TAB_COMPLETION"] = value + # Run from a neutral directory so a source tree next to the test run + # cannot shadow the installed package (see _run_probe). + with tempfile.TemporaryDirectory() as tmpdir: + result = subprocess.run( # noqa: S603 + [sys.executable, "-c", _OPT_OUT_PROBE_SCRIPT], + capture_output=True, + text=True, + env=env, + check=False, + stdin=subprocess.DEVNULL, + cwd=tmpdir, + ) + assert result.returncode == 0, f"stderr: {result.stderr}\nstdout: {result.stdout}" + assert result.stdout.strip() == f"patched: {expect_patched}", result.stdout diff --git a/cuda_pathfinder/LICENSE b/cuda_pathfinder/LICENSE index a4baaa2d3fa..3b3fdce8194 100644 --- a/cuda_pathfinder/LICENSE +++ b/cuda_pathfinder/LICENSE @@ -176,3 +176,28 @@ Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/cuda_pathfinder/cuda/pathfinder/_binaries/find_nvidia_binary_utility.py b/cuda_pathfinder/cuda/pathfinder/_binaries/find_nvidia_binary_utility.py index 834db8fe8fa..28082507238 100644 --- a/cuda_pathfinder/cuda/pathfinder/_binaries/find_nvidia_binary_utility.py +++ b/cuda_pathfinder/cuda/pathfinder/_binaries/find_nvidia_binary_utility.py @@ -2,13 +2,29 @@ # SPDX-License-Identifier: Apache-2.0 import functools +import importlib import os +from collections.abc import Iterable +from typing import Any from cuda.pathfinder._binaries import supported_nvidia_binaries from cuda.pathfinder._utils.ctk_root_canary import CTK_ROOT_CANARY_ANCHOR_LIBNAMES from cuda.pathfinder._utils.env_vars import get_cuda_path_or_home from cuda.pathfinder._utils.find_sub_dirs import find_sub_dirs_all_sitepackages from cuda.pathfinder._utils.platform_aware import IS_WINDOWS +from cuda.pathfinder._utils.windows_arch import windows_machine_arch + +_NSIGHT_REGISTRY_ROOT = r"SOFTWARE\NVIDIA Corporation\Installed Products\Nsight" + +_NSYS_TARGET_DIR_BY_ARCH = { + "x64": "target-windows-x64", + "arm64": "target-windows-armv8", +} + +_NCU_TARGET_DIR_BY_ARCH = { + "x64": os.path.join("target", "windows-desktop-win7-x64"), + "arm64": os.path.join("target", "windows-desktop-win10-t23x-a64"), +} class UnsupportedBinaryError(Exception): @@ -46,6 +62,82 @@ def _ctk_bin_subdirs(root: str) -> list[str]: return [os.path.join(root, "bin")] +def _resolve_candidate_paths(candidates: Iterable[str]) -> str | None: + """Return the first executable candidate, preserving candidate order.""" + seen: set[str] = set() + for candidate in candidates: + if candidate in seen: + continue + seen.add(candidate) + if _is_executable_candidate(candidate): + return os.path.abspath(candidate) + return None + + +def _find_windows_compute_sanitizer(ctk_root: str) -> str | None: + return _resolve_candidate_paths( + ( + os.path.join(ctk_root, "bin", "compute-sanitizer.bat"), + os.path.join(ctk_root, "compute-sanitizer", "compute-sanitizer.exe"), + ) + ) + + +def _windows_installed_nsight_root(product: str) -> str | None: + """Return the active Nsight product installation recorded by its MSI.""" + # ``winreg`` attributes are absent from the type stubs on non-Windows hosts. + winreg: Any = importlib.import_module("winreg") + + access = winreg.KEY_READ | winreg.KEY_WOW64_64KEY + product_key_path = rf"{_NSIGHT_REGISTRY_ROOT}\{product}" + try: + product_context = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, product_key_path, 0, access) + except FileNotFoundError: + return None + + try: + with product_context as product_key: + current_version, _ = winreg.QueryValueEx(product_key, "CurrentVersion") + if not isinstance(current_version, str) or not current_version.strip(): + raise RuntimeError( + f"Invalid CurrentVersion value {current_version!r} in " + f"Nsight {product!r} registry registration at {product_key_path!r}" + ) + with winreg.OpenKey(product_key, current_version, 0, access) as version_key: + install_root, _ = winreg.QueryValueEx(version_key, None) + except FileNotFoundError as exc: + raise RuntimeError(f"Incomplete Nsight {product!r} registry registration at {product_key_path!r}") from exc + + if not isinstance(install_root, str) or not install_root.strip(): + raise RuntimeError( + f"Invalid installation directory {install_root!r} in Nsight {product!r} " + f"registry registration at {product_key_path!r} version {current_version!r}" + ) + return install_root + + +def _find_windows_nsys() -> str | None: + install_root = _windows_installed_nsight_root("Systems") + if install_root is None: + return None + + target_dir = _NSYS_TARGET_DIR_BY_ARCH[windows_machine_arch()] + return _resolve_candidate_paths((os.path.join(install_root, target_dir, "nsys.exe"),)) + + +def _find_windows_ncu() -> str | None: + install_root = _windows_installed_nsight_root("Compute") + if install_root is None: + return None + + launcher = os.path.join(install_root, "ncu.bat") + if (found := _resolve_candidate_paths((launcher,))) is not None: + return found + + target_dir = _NCU_TARGET_DIR_BY_ARCH[windows_machine_arch()] + return _resolve_candidate_paths((os.path.join(install_root, target_dir, "ncu.exe"),)) + + def _resolve_ctk_root_via_canary() -> str | None: from cuda.pathfinder._dynamic_libs.load_nvidia_dynamic_lib import resolve_ctk_root_via_canary @@ -69,6 +161,20 @@ def _resolve_in_trusted_dirs(normalized_name: str, dirs: list[str]) -> str | Non return None +def _resolve_names_in_trusted_dirs(candidate_names: tuple[str, ...], dirs: list[str]) -> str | None: + """Resolve ordered candidate names within each trusted directory.""" + seen: set[str] = set() + for directory in dirs: + if directory in seen: + continue + assert directory + seen.add(directory) + found = _resolve_candidate_paths(os.path.join(directory, name) for name in candidate_names) + if found is not None: + return found + return None + + @functools.cache def find_nvidia_binary_utility(utility_name: str) -> str | None: """Locate a CUDA binary utility executable. @@ -87,6 +193,19 @@ def find_nvidia_binary_utility(utility_name: str) -> str | None: Raises: UnsupportedBinaryError: If ``utility_name`` is not in the supported set (see ``SUPPORTED_BINARY_UTILITIES``). + RuntimeError: If a native Windows architecture needed for an + architecture-specific utility layout cannot be determined, or an + installed Nsight product has incomplete or invalid registry data. + + Windows on ARM (WoA) Note: + Binary utilities execute in separate processes and do not need to match + the Python process architecture. When choosing among architecture-specific + Windows layouts, this API deliberately targets the native machine + architecture rather than the Python interpreter architecture. For + example, standalone ``nsys`` and ``ncu`` discovery under x64 Python on an + Arm64 machine selects the Arm64 target. This differs from + ``load_nvidia_dynamic_lib`` and ``find_static_lib``, which target the + Python interpreter architecture. Search order: 1. **NVIDIA Python wheels** @@ -100,17 +219,27 @@ def find_nvidia_binary_utility(utility_name: str) -> str | None: environment variable, which use platform-specific bin directory layouts (``Library/bin`` on Windows, ``bin`` on Linux). - 3. **CUDA Toolkit environment variables** + 3. **Library-specific standalone installations** + + - Search the installation paths for the CUDA Toolkit, Nsight Systems, + and Nsight Compute. + + 3.1. **Nsight installations**: On Windows, locate Nsight Systems and + Nsight Compute from their installer registry entries. Select + architecture-specific binaries using the native machine + architecture, independent of Python. Lookup of the standalone + ``nsys`` and ``ncu`` CLIs is terminal; a miss does not fall + through to CUDA Toolkit locations. - - Use ``CUDA_HOME`` or ``CUDA_PATH`` (in that order), searching - ``bin/x64``, ``bin/x86_64``, and ``bin`` subdirectories on Windows, - or just ``bin`` on Linux. + 3.2. **CUDA Toolkit installation**: Use ``CUDA_PATH`` or ``CUDA_HOME`` + (in that order), searching ``bin/x64``, ``bin/x86_64``, and + ``bin`` subdirectories on Windows, or just ``bin`` on Linux. 4. **CTK-root canary fallback** - - Only when steps 1-3 miss: resolve the ``cudart`` library through the - OS dynamic loader, derive the CUDA Toolkit root from it, and search - that root's bin layout. + - For utilities that reach this step after the earlier searches miss, + resolve the ``cudart`` library through the OS dynamic loader, derive + the CUDA Toolkit root from it, and search that root's bin layout. Note: Results are cached using ``@functools.cache`` for performance. The cache @@ -146,17 +275,35 @@ def find_nvidia_binary_utility(utility_name: str) -> str | None: else: dirs.append(os.path.join(conda_prefix, "bin")) - # 3. Search in CUDA Toolkit (CUDA_HOME/CUDA_PATH) - if (cuda_home := get_cuda_path_or_home()) is not None: - dirs.extend(_ctk_bin_subdirs(cuda_home)) - normalized_name = _normalize_utility_name(utility_name) - found = _resolve_in_trusted_dirs(normalized_name, dirs) + if IS_WINDOWS and utility_name in ("compute-sanitizer", "ncu"): + candidate_names = (f"{utility_name}.bat", normalized_name) + found = _resolve_names_in_trusted_dirs(candidate_names, dirs) + else: + found = _resolve_in_trusted_dirs(normalized_name, dirs) if found is not None: return found + # 3. Search library-specific standalone installations. + # 3.1. Standalone Nsight CLI lookup is terminal; CTK does not contain nsys/ncu. + if IS_WINDOWS and utility_name == "nsys": + return _find_windows_nsys() + if IS_WINDOWS and utility_name == "ncu": + return _find_windows_ncu() + + # 3.2. Search in CUDA Toolkit (CUDA_PATH/CUDA_HOME). + if (cuda_path := get_cuda_path_or_home()) is not None: + if IS_WINDOWS and utility_name == "compute-sanitizer": + found = _find_windows_compute_sanitizer(cuda_path) + else: + found = _resolve_in_trusted_dirs(normalized_name, _ctk_bin_subdirs(cuda_path)) + if found is not None: + return found + # 4. CTK-root canary fallback. ctk_root = _resolve_ctk_root_via_canary() if ctk_root is not None: + if IS_WINDOWS and utility_name == "compute-sanitizer": + return _find_windows_compute_sanitizer(ctk_root) return _resolve_in_trusted_dirs(normalized_name, _ctk_bin_subdirs(ctk_root)) return None diff --git a/cuda_pathfinder/cuda/pathfinder/_dynamic_libs/load_nvidia_dynamic_lib.py b/cuda_pathfinder/cuda/pathfinder/_dynamic_libs/load_nvidia_dynamic_lib.py index 53446107da3..61bf31720d3 100644 --- a/cuda_pathfinder/cuda/pathfinder/_dynamic_libs/load_nvidia_dynamic_lib.py +++ b/cuda_pathfinder/cuda/pathfinder/_dynamic_libs/load_nvidia_dynamic_lib.py @@ -231,6 +231,15 @@ def load_nvidia_dynamic_lib(libname: str) -> LoadedDL: DynamicLibNotFoundError: If the library cannot be found or loaded. RuntimeError: If Python is not 64-bit. + Windows on ARM (WoA) Note: + On Windows, this API aims to load a dynamic library whose architecture + matches the Python interpreter architecture. For example, x64 Python + running on an Arm64 machine targets an x64 DLL, while native Arm64 Python + targets an Arm64 DLL. A library loaded into the Python process must be + compatible with that process. This differs from + ``find_nvidia_binary_utility``, which targets the native machine + architecture when selecting architecture-specific executables. + Search order: 0. **Already loaded in the current process** diff --git a/cuda_pathfinder/cuda/pathfinder/_static_libs/find_bitcode_lib.py b/cuda_pathfinder/cuda/pathfinder/_static_libs/find_bitcode_lib.py index ac038aadfe7..803abecaaae 100644 --- a/cuda_pathfinder/cuda/pathfinder/_static_libs/find_bitcode_lib.py +++ b/cuda_pathfinder/cuda/pathfinder/_static_libs/find_bitcode_lib.py @@ -4,6 +4,7 @@ import functools import os from dataclasses import dataclass +from pathlib import Path from typing import NoReturn, TypedDict from cuda.pathfinder._utils.env_vars import get_cuda_path_or_home @@ -35,7 +36,7 @@ class _BitcodeLibInfo(TypedDict): _SUPPORTED_BITCODE_LIBS_INFO: dict[str, _BitcodeLibInfo] = { "device": { "filename": "libdevice.10.bc", - "rel_path": os.path.join("nvvm", "libdevice"), + "rel_path": "nvvm/libdevice", "site_packages_dirs": ( "nvidia/cu13/nvvm/libdevice", "nvidia/cuda_nvcc/nvvm/libdevice", @@ -64,14 +65,14 @@ class _BitcodeLibInfo(TypedDict): ) -def _no_such_file_in_dir(dir_path: str, filename: str, error_messages: list[str], attachments: list[str]) -> None: - error_messages.append(f"No such file: {os.path.join(dir_path, filename)}") - if os.path.isdir(dir_path): - attachments.append(f' listdir("{dir_path}"):') - for node in sorted(os.listdir(dir_path)): +def _no_such_file_in_dir(directory: Path, filename: str, error_messages: list[str], attachments: list[str]) -> None: + error_messages.append(f"No such file: {directory / filename}") + if directory.is_dir(): + attachments.append(f' listdir("{directory}"):') + for node in sorted(node_path.name for node_path in directory.iterdir()): attachments.append(f" {node}") else: - attachments.append(f' Directory does not exist: "{dir_path}"') + attachments.append(f' Directory does not exist: "{directory}"') class _FindBitcodeLib: @@ -86,38 +87,39 @@ def __init__(self, name: str) -> None: self.error_messages: list[str] = [] self.attachments: list[str] = [] - def try_site_packages(self) -> str | None: + def try_site_packages(self) -> Path | None: for rel_dir in self.site_packages_dirs: sub_dir = tuple(rel_dir.split("/")) for abs_dir in find_sub_dirs_all_sitepackages(sub_dir): - file_path = os.path.join(abs_dir, self.filename) - if os.path.isfile(file_path): + file_path = Path(abs_dir, self.filename) + if file_path.is_file(): return file_path return None - def try_with_conda_prefix(self) -> str | None: + def try_with_conda_prefix(self) -> Path | None: conda_prefix = os.environ.get("CONDA_PREFIX") if not conda_prefix: return None - anchor = os.path.join(conda_prefix, "Library") if IS_WINDOWS else conda_prefix - file_path = os.path.join(anchor, self.rel_path, self.filename) - if os.path.isfile(file_path): + anchor = Path(conda_prefix, "Library") if IS_WINDOWS else Path(conda_prefix) + file_path = anchor / self.rel_path / self.filename + if file_path.is_file(): return file_path return None - def try_with_cuda_home(self) -> str | None: + def try_with_cuda_home(self) -> Path | None: cuda_home = get_cuda_path_or_home() if cuda_home is None: self.error_messages.append("CUDA_HOME/CUDA_PATH not set") return None - file_path = os.path.join(cuda_home, self.rel_path, self.filename) - if os.path.isfile(file_path): + anchor = Path(cuda_home) + file_path = anchor / self.rel_path / self.filename + if file_path.is_file(): return file_path _no_such_file_in_dir( - os.path.join(cuda_home, self.rel_path), + anchor / self.rel_path, self.filename, self.error_messages, self.attachments, @@ -143,7 +145,7 @@ def locate_bitcode_lib(name: str) -> LocatedBitcodeLib: if abs_path is not None: return LocatedBitcodeLib( name=name, - abs_path=abs_path, + abs_path=str(abs_path), filename=finder.filename, found_via="site-packages", ) @@ -152,7 +154,7 @@ def locate_bitcode_lib(name: str) -> LocatedBitcodeLib: if abs_path is not None: return LocatedBitcodeLib( name=name, - abs_path=abs_path, + abs_path=str(abs_path), filename=finder.filename, found_via="conda", ) @@ -161,7 +163,7 @@ def locate_bitcode_lib(name: str) -> LocatedBitcodeLib: if abs_path is not None: return LocatedBitcodeLib( name=name, - abs_path=abs_path, + abs_path=str(abs_path), filename=finder.filename, found_via="CUDA_PATH", ) diff --git a/cuda_pathfinder/cuda/pathfinder/_static_libs/find_static_lib.py b/cuda_pathfinder/cuda/pathfinder/_static_libs/find_static_lib.py index ea5a740aec4..a5b1e84fc42 100644 --- a/cuda_pathfinder/cuda/pathfinder/_static_libs/find_static_lib.py +++ b/cuda_pathfinder/cuda/pathfinder/_static_libs/find_static_lib.py @@ -4,6 +4,7 @@ import functools import os from dataclasses import dataclass +from pathlib import Path from typing import NoReturn, TypedDict from cuda.pathfinder._utils.env_vars import get_cuda_path_or_home @@ -47,8 +48,8 @@ def _cudadevrt_info() -> _StaticLibInfo: conda_fallback_dirs = ("lib",) if arch_dir == "x64" else () return { "filename": "cudadevrt.lib", - "ctk_rel_paths": (os.path.join("lib", arch_dir),), - "conda_rel_paths": (os.path.join("lib", arch_dir), *conda_fallback_dirs), + "ctk_rel_paths": (str(Path("lib", arch_dir)),), + "conda_rel_paths": (str(Path("lib", arch_dir)), *conda_fallback_dirs), "site_packages_dirs": (f"nvidia/cu13/lib/{arch_dir}", *component_wheel_dirs), } @@ -60,14 +61,14 @@ def _cudadevrt_info() -> _StaticLibInfo: SUPPORTED_STATIC_LIBS: tuple[str, ...] = tuple(sorted(_SUPPORTED_STATIC_LIBS_INFO.keys())) -def _no_such_file_in_dir(dir_path: str, filename: str, error_messages: list[str], attachments: list[str]) -> None: - error_messages.append(f"No such file: {os.path.join(dir_path, filename)}") - if os.path.isdir(dir_path): - attachments.append(f' listdir("{dir_path}"):') - for node in sorted(os.listdir(dir_path)): +def _no_such_file_in_dir(directory: Path, filename: str, error_messages: list[str], attachments: list[str]) -> None: + error_messages.append(f"No such file: {directory / filename}") + if directory.is_dir(): + attachments.append(f' listdir("{directory}"):') + for node in sorted(node_path.name for node_path in directory.iterdir()): attachments.append(f" {node}") else: - attachments.append(f' Directory does not exist: "{dir_path}"') + attachments.append(f' Directory does not exist: "{directory}"') class _FindStaticLib: @@ -83,40 +84,41 @@ def __init__(self, name: str) -> None: self.error_messages: list[str] = [] self.attachments: list[str] = [] - def try_site_packages(self) -> str | None: + def try_site_packages(self) -> Path | None: for rel_dir in self.site_packages_dirs: sub_dir = tuple(rel_dir.split("/")) for abs_dir in find_sub_dirs_all_sitepackages(sub_dir): - file_path = os.path.join(abs_dir, self.filename) - if os.path.isfile(file_path): + file_path = Path(abs_dir, self.filename) + if file_path.is_file(): return file_path return None - def try_with_conda_prefix(self) -> str | None: + def try_with_conda_prefix(self) -> Path | None: conda_prefix = os.environ.get("CONDA_PREFIX") if not conda_prefix: return None - anchor = os.path.join(conda_prefix, "Library") if IS_WINDOWS else conda_prefix + anchor = Path(conda_prefix, "Library") if IS_WINDOWS else Path(conda_prefix) for rel_path in self.conda_rel_paths: - file_path = os.path.join(anchor, rel_path, self.filename) - if os.path.isfile(file_path): + file_path = anchor / rel_path / self.filename + if file_path.is_file(): return file_path return None - def try_with_cuda_home(self) -> str | None: + def try_with_cuda_home(self) -> Path | None: cuda_home = get_cuda_path_or_home() if cuda_home is None: self.error_messages.append("CUDA_HOME/CUDA_PATH not set") return None + anchor = Path(cuda_home) for rel_path in self.ctk_rel_paths: - file_path = os.path.join(cuda_home, rel_path, self.filename) - if os.path.isfile(file_path): + file_path = anchor / rel_path / self.filename + if file_path.is_file(): return file_path _no_such_file_in_dir( - os.path.join(cuda_home, self.ctk_rel_paths[0]), + anchor / self.ctk_rel_paths[0], self.filename, self.error_messages, self.attachments, @@ -142,7 +144,7 @@ def locate_static_lib(name: str) -> LocatedStaticLib: if abs_path is not None: return LocatedStaticLib( name=name, - abs_path=abs_path, + abs_path=str(abs_path), filename=finder.filename, found_via="site-packages", ) @@ -151,7 +153,7 @@ def locate_static_lib(name: str) -> LocatedStaticLib: if abs_path is not None: return LocatedStaticLib( name=name, - abs_path=abs_path, + abs_path=str(abs_path), filename=finder.filename, found_via="conda", ) @@ -160,7 +162,7 @@ def locate_static_lib(name: str) -> LocatedStaticLib: if abs_path is not None: return LocatedStaticLib( name=name, - abs_path=abs_path, + abs_path=str(abs_path), filename=finder.filename, found_via="CUDA_PATH", ) @@ -175,5 +177,13 @@ def find_static_lib(name: str) -> str: Raises: ValueError: If ``name`` is not a supported static library. StaticLibNotFoundError: If the static library cannot be found. + + Windows on ARM (WoA) Note: + On Windows, this API aims to return the path to a static library whose + architecture matches the Python interpreter architecture. For example, + x64 Python running on an Arm64 machine targets the x64 library, while + native Arm64 Python targets the Arm64 library. This differs from + ``find_nvidia_binary_utility``, which targets the native machine + architecture when selecting architecture-specific executables. """ return locate_static_lib(name).abs_path diff --git a/cuda_pathfinder/cuda/pathfinder/_utils/windows_arch.py b/cuda_pathfinder/cuda/pathfinder/_utils/windows_arch.py index 9313f3a9f17..fc802db370f 100644 --- a/cuda_pathfinder/cuda/pathfinder/_utils/windows_arch.py +++ b/cuda_pathfinder/cuda/pathfinder/_utils/windows_arch.py @@ -3,6 +3,7 @@ from __future__ import annotations +import platform import sysconfig WINDOWS_PE_MACHINE_BY_ARCH = { @@ -10,6 +11,8 @@ "arm64": 0xAA64, } +_WINDOWS_ARCH_BY_PE_MACHINE = {machine: arch for arch, machine in WINDOWS_PE_MACHINE_BY_ARCH.items()} + class UnsupportedArchError(RuntimeError): """Raised when Python reports an unsupported Windows architecture.""" @@ -35,6 +38,76 @@ def windows_python_arch() -> str: raise UnsupportedArchError(raw_platform_tag) +def _windows_machine_arch_from_platform() -> str: + """Return the Windows architecture reported by Python's platform module.""" + raw_machine = platform.machine() + machine = raw_machine.lower().replace("_", "-") + + if machine in ("amd64", "x86-64"): + return "x64" + + if machine in ("arm64", "aarch64"): + return "arm64" + + raise RuntimeError(f"Unsupported Windows machine architecture: {raw_machine!r}") + + +def _windows_native_machine() -> int | None: + """Return the native Windows PE machine type, or None on older Windows.""" + import ctypes + from ctypes import wintypes + + try: + # These ctypes attributes are absent from the type stubs on non-Windows hosts. + kernel32 = ctypes.WinDLL("kernel32", use_last_error=True) # type: ignore[attr-defined, unused-ignore] + except OSError as exc: + raise RuntimeError("Failed to load kernel32 while detecting the native Windows architecture") from exc + + get_current_process = kernel32.GetCurrentProcess + try: + is_wow64_process2 = kernel32.IsWow64Process2 + except AttributeError: + return None + + get_current_process.argtypes = () + get_current_process.restype = wintypes.HANDLE + is_wow64_process2.argtypes = ( + wintypes.HANDLE, + ctypes.POINTER(wintypes.USHORT), + ctypes.POINTER(wintypes.USHORT), + ) + is_wow64_process2.restype = wintypes.BOOL + + process_machine = wintypes.USHORT() + native_machine = wintypes.USHORT() + if not is_wow64_process2( + get_current_process(), + ctypes.byref(process_machine), + ctypes.byref(native_machine), + ): + error_code = ctypes.get_last_error() # type: ignore[attr-defined, unused-ignore] + error = ctypes.WinError(error_code) # type: ignore[attr-defined, unused-ignore] + raise RuntimeError( + f"IsWow64Process2 failed while detecting the native Windows architecture " + f"(Windows error {error_code}): {error}" + ) from error + return native_machine.value + + +def windows_machine_arch() -> str: + """Return the native Windows machine architecture, ignoring process emulation.""" + native_machine = _windows_native_machine() + if native_machine is None: + # IsWow64Process2 predates x64-on-Arm emulation, so this fallback is only + # needed on older Windows versions where platform.machine() is sufficient. + return _windows_machine_arch_from_platform() + + try: + return _WINDOWS_ARCH_BY_PE_MACHINE[native_machine] + except KeyError: + raise RuntimeError(f"Unsupported native Windows PE machine type: 0x{native_machine:04x}") from None + + def windows_pe_matches_arch(path: str, target_arch: str) -> bool: """Return whether a Windows Portable Executable (PE) targets the requested architecture. diff --git a/cuda_pathfinder/docs/source/install.rst b/cuda_pathfinder/docs/source/install.rst index 53f11ebbf18..078abf47ee3 100644 --- a/cuda_pathfinder/docs/source/install.rst +++ b/cuda_pathfinder/docs/source/install.rst @@ -9,7 +9,7 @@ Runtime Requirements ``cuda.pathfinder`` is a pure-Python package with no runtime dependencies: -* Linux (x86-64, arm64) and Windows (x86-64) +* Linux (x86-64, arm64) and Windows (x86-64, arm64) * Python 3.10 - 3.14 Installing from PyPI diff --git a/cuda_pathfinder/docs/source/release/1.6.1-notes.rst b/cuda_pathfinder/docs/source/release/1.6.1-notes.rst index 919963802ff..4b6e7a0a55e 100644 --- a/cuda_pathfinder/docs/source/release/1.6.1-notes.rst +++ b/cuda_pathfinder/docs/source/release/1.6.1-notes.rst @@ -29,6 +29,12 @@ Highlights ``lib/x64`` or ``lib/arm64`` CUDA Toolkit and wheel directories. CUDA 12 component-wheel and legacy Conda fallbacks remain x64-only. +* Fix Windows binary-utility discovery for CUDA 13.4 Arm64 layouts. Prefer the + Compute Sanitizer launcher, locate standalone Nsight Systems and Nsight + Compute through their installer registry entries, and select + architecture-specific executable targets using the native Windows machine + architecture. + Internal maintenance -------------------- diff --git a/cuda_pathfinder/tests/test_find_nvidia_binaries.py b/cuda_pathfinder/tests/test_find_nvidia_binaries.py index 2784633ff38..668be893863 100644 --- a/cuda_pathfinder/tests/test_find_nvidia_binaries.py +++ b/cuda_pathfinder/tests/test_find_nvidia_binaries.py @@ -58,6 +58,15 @@ def fake_is_executable_candidate(path): return checked +def _patch_winreg(mocker): + winreg = mocker.MagicMock() + winreg.HKEY_LOCAL_MACHINE = object() + winreg.KEY_READ = 0x20019 + winreg.KEY_WOW64_64KEY = 0x0100 + mocker.patch.object(binary_finder_module.importlib, "import_module", return_value=winreg) + return winreg + + @pytest.mark.usefixtures("clear_find_binary_cache") def test_find_binary_search_path_includes_site_packages_conda_cuda(monkeypatch, mocker): conda_prefix = os.path.join(os.sep, "conda") @@ -128,6 +137,415 @@ def test_find_binary_windows_extension_and_search_dirs(monkeypatch, mocker): assert checked == [os.path.join(d, "nvcc.exe") for d in expected_dirs] +@pytest.mark.parametrize( + ("launcher_exists", "expected_rel", "checked_rels"), + ( + (True, os.path.join("bin", "compute-sanitizer.bat"), (os.path.join("bin", "compute-sanitizer.bat"),)), + ( + False, + os.path.join("compute-sanitizer", "compute-sanitizer.exe"), + ( + os.path.join("bin", "compute-sanitizer.bat"), + os.path.join("compute-sanitizer", "compute-sanitizer.exe"), + ), + ), + ), +) +@pytest.mark.usefixtures("clear_find_binary_cache") +@pytest.mark.agent_authored(model="gpt-5.6") +def test_find_compute_sanitizer_prefers_ctk_launcher_with_executable_fallback( + monkeypatch, mocker, launcher_exists, expected_rel, checked_rels +): + cuda_home = os.path.join(os.sep, "cuda") + launcher = os.path.join(cuda_home, "bin", "compute-sanitizer.bat") + executable = os.path.join(cuda_home, "compute-sanitizer", "compute-sanitizer.exe") + + mocker.patch.object(binary_finder_module, "IS_WINDOWS", new=True) + mocker.patch.object(binary_finder_module.supported_nvidia_binaries, "SITE_PACKAGES_BINDIRS", {}) + monkeypatch.delenv("CONDA_PREFIX", raising=False) + mocker.patch.object(binary_finder_module, "get_cuda_path_or_home", return_value=cuda_home) + canary_mock = mocker.patch.object(binary_finder_module, "_resolve_ctk_root_via_canary") + existing = [executable] + if launcher_exists: + existing.append(launcher) + checked = _patch_exec_probe(mocker, existing=existing) + + assert find_nvidia_binary_utility("compute-sanitizer") == os.path.abspath(os.path.join(cuda_home, expected_rel)) + assert checked == [os.path.join(cuda_home, rel) for rel in checked_rels] + canary_mock.assert_not_called() + + +@pytest.mark.usefixtures("clear_find_binary_cache") +@pytest.mark.agent_authored(model="gpt-5.6") +def test_find_compute_sanitizer_uses_canary_ctk_root(monkeypatch, mocker): + ctk_root = os.path.join(os.sep, "cuda") + launcher = os.path.join(ctk_root, "bin", "compute-sanitizer.bat") + + mocker.patch.object(binary_finder_module, "IS_WINDOWS", new=True) + mocker.patch.object(binary_finder_module.supported_nvidia_binaries, "SITE_PACKAGES_BINDIRS", {}) + monkeypatch.delenv("CONDA_PREFIX", raising=False) + mocker.patch.object(binary_finder_module, "get_cuda_path_or_home", return_value=None) + canary = mocker.patch.object(binary_finder_module, "_resolve_ctk_root_via_canary", return_value=ctk_root) + checked = _patch_exec_probe(mocker, existing=[launcher]) + + assert find_nvidia_binary_utility("compute-sanitizer") == os.path.abspath(launcher) + assert checked == [launcher] + canary.assert_called_once_with() + + +@pytest.mark.parametrize( + ("machine_arch", "target_dir"), + ( + ("x64", "target-windows-x64"), + ("arm64", "target-windows-armv8"), + ), +) +@pytest.mark.agent_authored(model="gpt-5.6") +def test_find_windows_nsys_uses_machine_arch(mocker, machine_arch, target_dir): + install_root = os.path.join(os.sep, "Program Files", "Nsight Systems") + expected = os.path.join(install_root, target_dir, "nsys.exe") + mocker.patch.object(binary_finder_module, "_windows_installed_nsight_root", return_value=install_root) + mocker.patch.object(binary_finder_module, "windows_machine_arch", return_value=machine_arch) + checked = _patch_exec_probe(mocker, existing=[expected]) + + assert binary_finder_module._find_windows_nsys() == os.path.abspath(expected) + assert checked == [expected] + + +@pytest.mark.agent_authored(model="gpt-5.6") +def test_find_windows_nsys_does_not_fallback_to_other_arch(mocker): + install_root = os.path.join(os.sep, "Program Files", "Nsight Systems") + arm64 = os.path.join(install_root, "target-windows-armv8", "nsys.exe") + x64 = os.path.join(install_root, "target-windows-x64", "nsys.exe") + mocker.patch.object(binary_finder_module, "_windows_installed_nsight_root", return_value=install_root) + mocker.patch.object(binary_finder_module, "windows_machine_arch", return_value="arm64") + checked = _patch_exec_probe(mocker, existing=[x64]) + + assert binary_finder_module._find_windows_nsys() is None + assert checked == [arm64] + + +@pytest.mark.agent_authored(model="gpt-5.6") +def test_find_windows_ncu_prefers_launcher(mocker): + install_root = os.path.join(os.sep, "Program Files", "Nsight Compute") + launcher = os.path.join(install_root, "ncu.bat") + mocker.patch.object(binary_finder_module, "_windows_installed_nsight_root", return_value=install_root) + machine_arch_mock = mocker.patch.object(binary_finder_module, "windows_machine_arch") + checked = _patch_exec_probe(mocker, existing=[launcher]) + + assert binary_finder_module._find_windows_ncu() == os.path.abspath(launcher) + assert checked == [launcher] + machine_arch_mock.assert_not_called() + + +@pytest.mark.parametrize( + ("machine_arch", "target_dir"), + ( + ("x64", os.path.join("target", "windows-desktop-win7-x64")), + ("arm64", os.path.join("target", "windows-desktop-win10-t23x-a64")), + ), +) +@pytest.mark.agent_authored(model="gpt-5.6") +def test_find_windows_ncu_falls_back_to_machine_binary(mocker, machine_arch, target_dir): + install_root = os.path.join(os.sep, "Program Files", "Nsight Compute") + launcher = os.path.join(install_root, "ncu.bat") + expected = os.path.join(install_root, target_dir, "ncu.exe") + mocker.patch.object(binary_finder_module, "_windows_installed_nsight_root", return_value=install_root) + mocker.patch.object(binary_finder_module, "windows_machine_arch", return_value=machine_arch) + checked = _patch_exec_probe(mocker, existing=[expected]) + + assert binary_finder_module._find_windows_ncu() == os.path.abspath(expected) + assert checked == [launcher, expected] + + +@pytest.mark.parametrize( + ("utility_name", "candidate_names"), + ( + ("nsys", ("nsys.exe",)), + ("ncu", ("ncu.bat", "ncu.exe")), + ), +) +@pytest.mark.usefixtures("clear_find_binary_cache") +@pytest.mark.agent_authored(model="gpt-5.6") +def test_find_binary_windows_nsight_conda_precedes_registry(monkeypatch, mocker, utility_name, candidate_names): + site_dir = os.path.join(os.sep, "site-packages", utility_name, "bin") + conda_prefix = os.path.join(os.sep, "conda") + conda_bin = os.path.join(conda_prefix, "Library", "bin") + expected = os.path.join(conda_bin, candidate_names[0]) + + mocker.patch.object(binary_finder_module, "IS_WINDOWS", new=True) + mocker.patch.object(binary_finder_module, "find_sub_dirs_all_sitepackages", return_value=[site_dir]) + monkeypatch.setenv("CONDA_PREFIX", conda_prefix) + registry_root = mocker.patch.object(binary_finder_module, "_windows_installed_nsight_root") + machine_arch = mocker.patch.object(binary_finder_module, "windows_machine_arch") + get_cuda_path = mocker.patch.object(binary_finder_module, "get_cuda_path_or_home") + canary = mocker.patch.object(binary_finder_module, "_resolve_ctk_root_via_canary") + checked = _patch_exec_probe(mocker, existing=[expected]) + + assert find_nvidia_binary_utility(utility_name) == os.path.abspath(expected) + assert checked == [ + *(os.path.join(site_dir, name) for name in candidate_names), + os.path.join(conda_bin, candidate_names[0]), + ] + registry_root.assert_not_called() + machine_arch.assert_not_called() + get_cuda_path.assert_not_called() + canary.assert_not_called() + + +@pytest.mark.parametrize( + ("utility_name", "product", "machine_arch", "target_rel", "candidate_names"), + ( + ("nsys", "Systems", "x64", os.path.join("target-windows-x64", "nsys.exe"), ("nsys.exe",)), + ("nsys", "Systems", "arm64", os.path.join("target-windows-armv8", "nsys.exe"), ("nsys.exe",)), + ( + "ncu", + "Compute", + "x64", + os.path.join("target", "windows-desktop-win7-x64", "ncu.exe"), + ("ncu.bat", "ncu.exe"), + ), + ( + "ncu", + "Compute", + "arm64", + os.path.join("target", "windows-desktop-win10-t23x-a64", "ncu.exe"), + ("ncu.bat", "ncu.exe"), + ), + ), +) +@pytest.mark.usefixtures("clear_find_binary_cache") +@pytest.mark.agent_authored(model="gpt-5.6") +def test_find_binary_windows_nsight_composes_registry_and_native_target( + monkeypatch, mocker, utility_name, product, machine_arch, target_rel, candidate_names +): + site_dir = os.path.join(os.sep, "site-packages", utility_name, "bin") + conda_prefix = os.path.join(os.sep, "conda") + conda_bin = os.path.join(conda_prefix, "Library", "bin") + install_root = os.path.join(os.sep, "Program Files", utility_name) + expected = os.path.join(install_root, target_rel) + + mocker.patch.object(binary_finder_module, "IS_WINDOWS", new=True) + mocker.patch.object(binary_finder_module, "find_sub_dirs_all_sitepackages", return_value=[site_dir]) + monkeypatch.setenv("CONDA_PREFIX", conda_prefix) + registry_root = mocker.patch.object( + binary_finder_module, "_windows_installed_nsight_root", return_value=install_root + ) + machine_arch_mock = mocker.patch.object(binary_finder_module, "windows_machine_arch", return_value=machine_arch) + get_cuda_path = mocker.patch.object(binary_finder_module, "get_cuda_path_or_home") + canary = mocker.patch.object(binary_finder_module, "_resolve_ctk_root_via_canary") + checked = _patch_exec_probe(mocker, existing=[expected]) + + assert find_nvidia_binary_utility(utility_name) == os.path.abspath(expected) + assert checked == [ + *(os.path.join(directory, name) for directory in (site_dir, conda_bin) for name in candidate_names), + *((os.path.join(install_root, "ncu.bat"),) if utility_name == "ncu" else ()), + expected, + ] + registry_root.assert_called_once_with(product) + machine_arch_mock.assert_called_once_with() + get_cuda_path.assert_not_called() + canary.assert_not_called() + + +@pytest.mark.parametrize(("utility_name", "product"), (("nsys", "Systems"), ("ncu", "Compute"))) +@pytest.mark.usefixtures("clear_find_binary_cache") +@pytest.mark.agent_authored(model="gpt-5.6") +def test_find_binary_windows_nsight_registry_miss_is_terminal(monkeypatch, mocker, utility_name, product): + mocker.patch.object(binary_finder_module, "IS_WINDOWS", new=True) + mocker.patch.object(binary_finder_module.supported_nvidia_binaries, "SITE_PACKAGES_BINDIRS", {}) + monkeypatch.delenv("CONDA_PREFIX", raising=False) + registry_root = mocker.patch.object(binary_finder_module, "_windows_installed_nsight_root", return_value=None) + machine_arch = mocker.patch.object(binary_finder_module, "windows_machine_arch") + get_cuda_path = mocker.patch.object(binary_finder_module, "get_cuda_path_or_home") + canary = mocker.patch.object(binary_finder_module, "_resolve_ctk_root_via_canary") + + assert find_nvidia_binary_utility(utility_name) is None + registry_root.assert_called_once_with(product) + machine_arch.assert_not_called() + get_cuda_path.assert_not_called() + canary.assert_not_called() + + +@pytest.mark.parametrize("utility_name", ("nsight-sys", "nsight-compute")) +@pytest.mark.usefixtures("clear_find_binary_cache") +@pytest.mark.agent_authored(model="gpt-5.6") +def test_find_windows_nsight_legacy_names_remain_literal_in_early_search(monkeypatch, mocker, utility_name): + site_key = os.path.join("nvidia", utility_name, "bin") + site_dir = os.path.join(os.sep, "site-packages", utility_name, "bin") + conda_prefix = os.path.join(os.sep, "conda") + conda_bin = os.path.join(conda_prefix, "Library", "bin") + expected = os.path.join(conda_bin, f"{utility_name}.exe") + + mocker.patch.object(binary_finder_module, "IS_WINDOWS", new=True) + mocker.patch.object( + binary_finder_module.supported_nvidia_binaries, + "SITE_PACKAGES_BINDIRS", + {utility_name: (site_key,)}, + ) + find_sub_dirs = mocker.patch.object(binary_finder_module, "find_sub_dirs_all_sitepackages", return_value=[site_dir]) + monkeypatch.setenv("CONDA_PREFIX", conda_prefix) + get_cuda_path = mocker.patch.object(binary_finder_module, "get_cuda_path_or_home") + nsys_finder = mocker.patch.object(binary_finder_module, "_find_windows_nsys") + ncu_finder = mocker.patch.object(binary_finder_module, "_find_windows_ncu") + checked = _patch_exec_probe(mocker, existing=[expected]) + + assert find_nvidia_binary_utility(utility_name) == os.path.abspath(expected) + assert checked == [os.path.join(site_dir, f"{utility_name}.exe"), expected] + find_sub_dirs.assert_called_once_with(site_key.split(os.sep)) + get_cuda_path.assert_not_called() + nsys_finder.assert_not_called() + ncu_finder.assert_not_called() + + +@pytest.mark.parametrize("utility_name", ("nsight-sys", "nsight-compute")) +@pytest.mark.usefixtures("clear_find_binary_cache") +@pytest.mark.agent_authored(model="gpt-5.6") +def test_find_windows_nsight_legacy_names_remain_literal_in_ctk(monkeypatch, mocker, utility_name): + cuda_home = os.path.join(os.sep, "cuda") + expected = os.path.join(cuda_home, "bin", f"{utility_name}.exe") + + mocker.patch.object(binary_finder_module, "IS_WINDOWS", new=True) + mocker.patch.object(binary_finder_module.supported_nvidia_binaries, "SITE_PACKAGES_BINDIRS", {}) + monkeypatch.delenv("CONDA_PREFIX", raising=False) + mocker.patch.object(binary_finder_module, "get_cuda_path_or_home", return_value=cuda_home) + nsys_finder = mocker.patch.object(binary_finder_module, "_find_windows_nsys") + ncu_finder = mocker.patch.object(binary_finder_module, "_find_windows_ncu") + canary = mocker.patch.object(binary_finder_module, "_resolve_ctk_root_via_canary") + checked = _patch_exec_probe(mocker, existing=[expected]) + + assert find_nvidia_binary_utility(utility_name) == os.path.abspath(expected) + assert checked == [ + os.path.join(cuda_home, "bin", "x64", f"{utility_name}.exe"), + os.path.join(cuda_home, "bin", "x86_64", f"{utility_name}.exe"), + expected, + ] + nsys_finder.assert_not_called() + ncu_finder.assert_not_called() + canary.assert_not_called() + + +@pytest.mark.agent_authored(model="gpt-5.6") +def test_windows_installed_nsight_root_reads_64_bit_registry(mocker): + install_root = os.path.join(os.sep, "Program Files", "Nsight Systems") + product_key = mocker.MagicMock() + version_key = mocker.MagicMock() + product_context = mocker.MagicMock() + product_context.__enter__.return_value = product_key + version_context = mocker.MagicMock() + version_context.__enter__.return_value = version_key + winreg = _patch_winreg(mocker) + winreg.OpenKey.side_effect = (product_context, version_context) + winreg.QueryValueEx.side_effect = (("2026.1.3", 1), (install_root, 1)) + + assert binary_finder_module._windows_installed_nsight_root("Systems") == install_root + access = winreg.KEY_READ | winreg.KEY_WOW64_64KEY + winreg.OpenKey.assert_has_calls( + ( + mocker.call( + winreg.HKEY_LOCAL_MACHINE, + rf"{binary_finder_module._NSIGHT_REGISTRY_ROOT}\Systems", + 0, + access, + ), + mocker.call(product_key, "2026.1.3", 0, access), + ) + ) + + +@pytest.mark.agent_authored(model="gpt-5.6") +def test_windows_installed_nsight_root_returns_none_when_product_key_is_absent(mocker): + winreg = _patch_winreg(mocker) + winreg.OpenKey.side_effect = FileNotFoundError("Nsight Systems is not installed") + + assert binary_finder_module._windows_installed_nsight_root("Systems") is None + + +@pytest.mark.agent_authored(model="gpt-5.6") +def test_windows_installed_nsight_root_rejects_missing_current_version(mocker): + product_context = mocker.MagicMock() + product_context.__enter__.return_value = mocker.MagicMock() + winreg = _patch_winreg(mocker) + winreg.OpenKey.return_value = product_context + winreg.QueryValueEx.side_effect = FileNotFoundError("CurrentVersion is missing") + + with pytest.raises(RuntimeError, match=r"Incomplete Nsight 'Systems' registry registration") as exc_info: + binary_finder_module._windows_installed_nsight_root("Systems") + + assert isinstance(exc_info.value.__cause__, FileNotFoundError) + + +@pytest.mark.parametrize("current_version", (None, "", " ", 2026)) +@pytest.mark.agent_authored(model="gpt-5.6") +def test_windows_installed_nsight_root_rejects_invalid_current_version(mocker, current_version): + product_context = mocker.MagicMock() + product_context.__enter__.return_value = mocker.MagicMock() + winreg = _patch_winreg(mocker) + winreg.OpenKey.return_value = product_context + winreg.QueryValueEx.return_value = (current_version, 1) + + with pytest.raises(RuntimeError, match=r"Invalid CurrentVersion value .*Nsight 'Systems' registry registration"): + binary_finder_module._windows_installed_nsight_root("Systems") + + +@pytest.mark.agent_authored(model="gpt-5.6") +def test_windows_installed_nsight_root_rejects_missing_version_key(mocker): + product_key = mocker.MagicMock() + product_context = mocker.MagicMock() + product_context.__enter__.return_value = product_key + winreg = _patch_winreg(mocker) + winreg.OpenKey.side_effect = (product_context, FileNotFoundError("Version key is missing")) + winreg.QueryValueEx.return_value = ("2026.1.3", 1) + + with pytest.raises(RuntimeError, match=r"Incomplete Nsight 'Systems' registry registration") as exc_info: + binary_finder_module._windows_installed_nsight_root("Systems") + + assert isinstance(exc_info.value.__cause__, FileNotFoundError) + + +@pytest.mark.agent_authored(model="gpt-5.6") +def test_windows_installed_nsight_root_rejects_missing_installation_directory(mocker): + product_context = mocker.MagicMock() + product_context.__enter__.return_value = mocker.MagicMock() + version_context = mocker.MagicMock() + version_context.__enter__.return_value = mocker.MagicMock() + winreg = _patch_winreg(mocker) + winreg.OpenKey.side_effect = (product_context, version_context) + winreg.QueryValueEx.side_effect = (("2026.1.3", 1), FileNotFoundError("Installation directory is missing")) + + with pytest.raises(RuntimeError, match=r"Incomplete Nsight 'Systems' registry registration") as exc_info: + binary_finder_module._windows_installed_nsight_root("Systems") + + assert isinstance(exc_info.value.__cause__, FileNotFoundError) + + +@pytest.mark.parametrize("install_root", (None, "", " ", 2026)) +@pytest.mark.agent_authored(model="gpt-5.6") +def test_windows_installed_nsight_root_rejects_invalid_installation_directory(mocker, install_root): + product_context = mocker.MagicMock() + product_context.__enter__.return_value = mocker.MagicMock() + version_context = mocker.MagicMock() + version_context.__enter__.return_value = mocker.MagicMock() + winreg = _patch_winreg(mocker) + winreg.OpenKey.side_effect = (product_context, version_context) + winreg.QueryValueEx.side_effect = (("2026.1.3", 1), (install_root, 1)) + + with pytest.raises( + RuntimeError, + match=r"Invalid installation directory .*Nsight 'Systems' registry registration.*version '2026.1.3'", + ): + binary_finder_module._windows_installed_nsight_root("Systems") + + +@pytest.mark.agent_authored(model="gpt-5.6") +def test_windows_installed_nsight_root_propagates_access_errors(mocker): + winreg = _patch_winreg(mocker) + winreg.OpenKey.side_effect = PermissionError("Registry access denied") + + with pytest.raises(PermissionError, match="Registry access denied"): + binary_finder_module._windows_installed_nsight_root("Systems") + + @pytest.mark.usefixtures("clear_find_binary_cache") def test_find_binary_first_matching_dir_wins(monkeypatch, mocker): conda_prefix = os.path.join(os.sep, "conda") diff --git a/cuda_pathfinder/tests/test_search_steps.py b/cuda_pathfinder/tests/test_search_steps.py index 54136dc34e1..fc78e22c708 100644 --- a/cuda_pathfinder/tests/test_search_steps.py +++ b/cuda_pathfinder/tests/test_search_steps.py @@ -5,7 +5,9 @@ from __future__ import annotations +import ctypes import os +from ctypes import wintypes import pytest @@ -147,6 +149,85 @@ def test_rejects_unknown_sysconfig_tag(self, mocker): assert exc_info.value.platform_tag == "custom-win" +class TestWindowsMachineArch: + @pytest.mark.parametrize( + ("native_machine", "expected"), + ((0x8664, "x64"), (0xAA64, "arm64")), + ) + @pytest.mark.agent_authored(model="gpt-5.6") + def test_uses_native_pe_machine(self, mocker, native_machine, expected): + mocker.patch.object(windows_arch_mod, "_windows_native_machine", return_value=native_machine) + platform_machine = mocker.patch.object(windows_arch_mod.platform, "machine", return_value="AMD64") + + assert windows_arch_mod.windows_machine_arch() == expected + platform_machine.assert_not_called() + + @pytest.mark.agent_authored(model="gpt-5.6") + def test_rejects_unknown_native_pe_machine(self, mocker): + mocker.patch.object(windows_arch_mod, "_windows_native_machine", return_value=0x014C) + + with pytest.raises(RuntimeError, match=r"Unsupported native Windows PE machine type: 0x014c"): + windows_arch_mod.windows_machine_arch() + + @pytest.mark.parametrize( + ("reported_machine", "expected"), + (("AMD64", "x64"), ("x86_64", "x64"), ("ARM64", "arm64"), ("aarch64", "arm64")), + ) + @pytest.mark.agent_authored(model="gpt-5.6") + def test_old_windows_fallback_normalizes_platform_machine(self, mocker, reported_machine, expected): + mocker.patch.object(windows_arch_mod, "_windows_native_machine", return_value=None) + mocker.patch.object(windows_arch_mod.platform, "machine", return_value=reported_machine) + + assert windows_arch_mod.windows_machine_arch() == expected + + @pytest.mark.agent_authored(model="gpt-5.6") + def test_native_machine_returns_none_when_is_wow64_process2_is_unavailable(self, mocker): + kernel32 = mocker.Mock(spec=["GetCurrentProcess"]) + mocker.patch.object(ctypes, "WinDLL", create=True, return_value=kernel32) + + assert windows_arch_mod._windows_native_machine() is None + + @pytest.mark.agent_authored(model="gpt-5.6") + def test_native_machine_configures_api_and_returns_native_machine(self, mocker): + kernel32 = mocker.Mock() + kernel32.GetCurrentProcess.return_value = wintypes.HANDLE(1) + + def report_native_machine(_process, _process_machine, native_machine): + native_machine._obj.value = 0xAA64 + return True + + kernel32.IsWow64Process2.side_effect = report_native_machine + mocker.patch.object(ctypes, "WinDLL", create=True, return_value=kernel32) + + assert windows_arch_mod._windows_native_machine() == 0xAA64 + assert kernel32.GetCurrentProcess.argtypes == () + assert kernel32.GetCurrentProcess.restype is wintypes.HANDLE + assert kernel32.IsWow64Process2.argtypes == ( + wintypes.HANDLE, + ctypes.POINTER(wintypes.USHORT), + ctypes.POINTER(wintypes.USHORT), + ) + assert kernel32.IsWow64Process2.restype is wintypes.BOOL + + @pytest.mark.agent_authored(model="gpt-5.6") + def test_native_machine_raises_contextual_error_when_api_call_fails(self, mocker): + kernel32 = mocker.Mock() + kernel32.GetCurrentProcess.return_value = wintypes.HANDLE(1) + kernel32.IsWow64Process2.return_value = False + mocker.patch.object(ctypes, "WinDLL", create=True, return_value=kernel32) + mocker.patch.object(ctypes, "get_last_error", create=True, return_value=87) + windows_error = OSError(87, "The parameter is incorrect") + mocker.patch.object(ctypes, "WinError", create=True, return_value=windows_error) + + with pytest.raises( + RuntimeError, + match=r"IsWow64Process2 failed while detecting the native Windows architecture \(Windows error 87\)", + ) as exc_info: + windows_arch_mod._windows_native_machine() + + assert exc_info.value.__cause__ is windows_error + + @pytest.mark.parametrize( ("machine", "target_arch", "expected"), ( diff --git a/cuda_python/LICENSE b/cuda_python/LICENSE index d6f74778be8..f3fe76ecadf 100644 --- a/cuda_python/LICENSE +++ b/cuda_python/LICENSE @@ -176,3 +176,28 @@ Copyright (c) 2024-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/toolshed/build_static_bitcode_input.py b/toolshed/build_static_bitcode_input.py index e2400100dde..843ff9459fa 100755 --- a/toolshed/build_static_bitcode_input.py +++ b/toolshed/build_static_bitcode_input.py @@ -1,6 +1,6 @@ #!/usr/bin/env python3 -# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: Apache-2.0 """ @@ -14,9 +14,9 @@ """ import binascii -import os import sys import textwrap +from pathlib import Path import llvmlite.binding # HINT: pip install llvmlite @@ -24,11 +24,9 @@ def get_minimal_nvvmir_txt_template(): - cuda_bindings_tests_dir = os.path.normpath("cuda_bindings/tests") - assert os.path.isdir(cuda_bindings_tests_dir), ( - "Please run this helper script from the cuda-python top-level directory." - ) - sys.path.insert(0, os.path.abspath(cuda_bindings_tests_dir)) + cuda_bindings_tests_dir = Path("cuda_bindings/tests") + assert cuda_bindings_tests_dir.is_dir(), "Please run this helper script from the cuda-python top-level directory." + sys.path.insert(0, str(cuda_bindings_tests_dir.resolve())) import test_nvvm return test_nvvm.MINIMAL_NVVMIR_TXT_TEMPLATE diff --git a/toolshed/check_generated_file_seals.py b/toolshed/check_generated_file_seals.py index 1a9c45de61b..4863fe32d61 100644 --- a/toolshed/check_generated_file_seals.py +++ b/toolshed/check_generated_file_seals.py @@ -2,7 +2,6 @@ # SPDX-License-Identifier: Apache-2.0 import hashlib -import os import re import subprocess import sys @@ -17,7 +16,10 @@ assert GENERATED_FILE_MARKER_FRAGMENT in GENERATED_FILE_SEAL_TOKEN _TOKEN_BYTES = GENERATED_FILE_SEAL_TOKEN.encode("ascii") _MARKER_REGEX = re.compile( - rb"^(?P<prefix>#|\.\.) " + # Keep the alternation in sync with the values of _COMMENT_CHARS below: + # a prefix that is not matched here can never reach the + # expected_comment_prefix() comparison in validate_generated_file_seal(). + rb"^(?P<prefix>#|\.\.|//) " + re.escape(_TOKEN_BYTES) + rb" format=(?P<format>[0-9]+); content-sha256=(?P<digest>[0-9a-f]{64})\n$" ) @@ -142,7 +144,7 @@ def main(args): returncode = 0 for filepath in args: - if not os.path.isfile(filepath): + if not Path(filepath).is_file(): continue if not validate_generated_file_seal(filepath, previously_sealed_paths): returncode = 1 diff --git a/toolshed/check_spdx.py b/toolshed/check_spdx.py index a2d0c041546..d4c9430673c 100644 --- a/toolshed/check_spdx.py +++ b/toolshed/check_spdx.py @@ -2,11 +2,10 @@ # SPDX-License-Identifier: Apache-2.0 import datetime -import os import re import subprocess import sys -from pathlib import PureWindowsPath +from pathlib import Path, PureWindowsPath import pathspec @@ -22,6 +21,7 @@ # Every top-level directory needs to have an entry here, so new paths # can't slip in without a reviewed license decision. TOP_LEVEL_DIRS_LICENSE_IDENTIFIERS = { + ".agents": "Apache-2.0", ".github": "Apache-2.0", "benchmarks": "Apache-2.0", "ci": "Apache-2.0", @@ -39,7 +39,7 @@ def load_spdx_ignore(): - if os.path.exists(SPDX_IGNORE_FILENAME): + if Path(SPDX_IGNORE_FILENAME).exists(): with open(SPDX_IGNORE_FILENAME, encoding="utf-8") as f: lines = f.readlines() else: @@ -50,7 +50,7 @@ def load_spdx_ignore(): COPYRIGHT_REGEX = ( rb"Copyright \(c\) (?P<years>[0-9]{4}(-[0-9]{4})?) " - rb"(?P<affiliation>NVIDIA CORPORATION( & AFFILIATES\. All rights reserved\.)?)" + rb"(?P<affiliation>NVIDIA CORPORATION & AFFILIATES\. All rights reserved\.)" ) COPYRIGHT_SUB = r"Copyright (c) {} \g<affiliation>" CURRENT_YEAR = str(datetime.datetime.now(tz=datetime.timezone.utc).year) diff --git a/toolshed/conda_create_for_pathfinder_testing.ps1 b/toolshed/conda_create_for_pathfinder_testing.ps1 index fbdbb5a0362..0f93c3ab026 100644 --- a/toolshed/conda_create_for_pathfinder_testing.ps1 +++ b/toolshed/conda_create_for_pathfinder_testing.ps1 @@ -1,4 +1,4 @@ -# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION +# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: Apache-2.0 param( diff --git a/toolshed/dump_cutile_b64.py b/toolshed/dump_cutile_b64.py index 422bf95232b..8e58e452e02 100644 --- a/toolshed/dump_cutile_b64.py +++ b/toolshed/dump_cutile_b64.py @@ -9,9 +9,9 @@ """ import base64 -import glob import os import sys +from pathlib import Path import cupy @@ -54,13 +54,13 @@ def main(): raise # Find the .cutile file in current directory - cutile_files = glob.glob("./*.cutile") + cutile_files = list(Path().glob("*.cutile")) if not cutile_files: print("No .cutile file found in current directory", file=sys.stderr) sys.exit(1) # Use the most recently modified one if multiple exist - cutile_path = max(cutile_files, key=os.path.getmtime) + cutile_path = max(cutile_files, key=lambda path: path.stat().st_mtime) # Read the binary content with open(cutile_path, "rb") as f: diff --git a/toolshed/find_skipped_tests.py b/toolshed/find_skipped_tests.py index af44d7c0ad5..c2cb1c9777d 100755 --- a/toolshed/find_skipped_tests.py +++ b/toolshed/find_skipped_tests.py @@ -36,7 +36,10 @@ 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+" + r"(PASSED|FAILED|ERROR|SKIPPED|XFAIL|XPASS|SUBPASSED|SUBFAILED|SUBERROR|SUBSKIPPED|SUBXFAIL|SUBXPASS)\b" +) # GHA log format markers used to identify which test suite is active. # `gh api` logs: ##[group]<step-name> opens a section, ##[endgroup] closes it. @@ -194,6 +197,8 @@ def extract_test_status_sets(text: str) -> tuple[set[str], set[str], dict[str, s """Parse pytest output and return (skipped, non_skipped, test_id->suite).""" skipped: set[str] = set() non_skipped: set[str] = set() + passed: set[str] = set() + subtest_seen: set[str] = set() test_suites: dict[str, str] = {} current_suite = "" @@ -216,10 +221,20 @@ def extract_test_status_sets(text: str) -> tuple[set[str], set[str], dict[str, s # Parse per-test outcomes first so PASS/FAIL lines disqualify tests. for test_id, outcome in PYTEST_TEST_OUTCOME.findall(line): - if outcome == "SKIPPED": + if outcome.startswith("SUB"): + subtest_seen.add(test_id) + if outcome == "SUBSKIPPED": + skipped.add(test_id) + if current_suite: + test_suites.setdefault(test_id, current_suite) + else: + non_skipped.add(test_id) + elif outcome == "SKIPPED": skipped.add(test_id) if current_suite: test_suites.setdefault(test_id, current_suite) + elif outcome == "PASSED": + passed.add(test_id) else: non_skipped.add(test_id) @@ -233,6 +248,11 @@ def extract_test_status_sets(text: str) -> tuple[set[str], set[str], dict[str, s if current_suite: test_suites.setdefault(test_id, current_suite) + # Pytest reports a passing parent after its subtests even when every + # subtest skipped. Only treat that parent pass as execution evidence when + # the test did not emit subtest outcomes of its own. + non_skipped.update(passed - subtest_seen) + return skipped, non_skipped, test_suites