Skip to content

Commit 1f05f42

Browse files
Andy-JostAndy-Jost
committed
Merge remote-tracking branch 'origin/main' into ajost/core-bindings-runtime-floor
2 parents b6cbcc0 + f9ed2bd commit 1f05f42

20 files changed

Lines changed: 3168 additions & 2425 deletions

File tree

‎.github/workflows/ci-pixi-lockfile-freshness-check.yml‎

Lines changed: 193 additions & 14 deletions
Large diffs are not rendered by default.

‎benchmarks/cuda_bindings/pixi.lock‎

Lines changed: 65 additions & 69 deletions
Some generated files are not rendered by default. Learn more about customizing how changed files appear on GitHub.

‎benchmarks/cuda_core/pixi.lock‎

Lines changed: 69 additions & 75 deletions
Some generated files are not rendered by default. Learn more about customizing how changed files appear on GitHub.

‎ci/test-matrix.yml‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -111,7 +111,8 @@ linux:
111111
- { ARCH: 'amd64', PY_VER: '3.12', CUDA_VER: '13.4.2', LOCAL_CTK: '0', GPU: 'a100', GPU_COUNT: '1', DRIVER: 'latest', ENV: { MODE: 'nightly-cuda-core' } }
112112
# nightly-standard (arm64 nightly-only runners — per runner team request)
113113
- { ARCH: 'arm64', PY_VER: '3.13', CUDA_VER: '13.4.2', LOCAL_CTK: '1', GPU: 'gh200', GPU_COUNT: '1', DRIVER: 'latest', ENV: { MODE: 'nightly-standard' } }
114-
- { ARCH: 'arm64', PY_VER: '3.14', CUDA_VER: '13.4.2', LOCAL_CTK: '1', GPU: 'gb300', GPU_COUNT: '1', DRIVER: 'latest', ENV: { MODE: 'nightly-standard' } }
114+
# GB300 paused until runner thermal issues are resolved (NVBugs 6393185).
115+
# - { ARCH: 'arm64', PY_VER: '3.14', CUDA_VER: '13.4.2', LOCAL_CTK: '1', GPU: 'gb300', GPU_COUNT: '1', DRIVER: 'latest', ENV: { MODE: 'nightly-standard' } }
115116
- { ARCH: 'arm64', PY_VER: '3.14', CUDA_VER: '13.4.2', LOCAL_CTK: '1', GPU: 'l4', GPU_COUNT: '2', DRIVER: 'latest', ENV: { MODE: 'nightly-standard' } }
116117
- { ARCH: 'arm64', PY_VER: '3.14t', CUDA_VER: '13.4.2', LOCAL_CTK: '1', GPU: 'l4', GPU_COUNT: '2', DRIVER: 'latest', ENV: { MODE: 'nightly-standard' } }
117118

‎ci/tools/classify_pixi_lockfile_freshness.py‎

Lines changed: 85 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,85 @@
1+
# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
2+
# SPDX-License-Identifier: Apache-2.0
3+
4+
"""Classify a stale candidate Pixi lockfile relative to its PR base."""
5+
6+
from __future__ import annotations
7+
8+
import argparse
9+
import sys
10+
from dataclasses import dataclass
11+
from enum import Enum
12+
13+
14+
class Classification(str, Enum):
15+
"""Possible attributions for a stale candidate lockfile."""
16+
17+
PR_INDUCED = "pr-induced"
18+
BASE_MAINTENANCE = "base-maintenance"
19+
MIXED = "mixed-or-ambiguous"
20+
21+
22+
@dataclass(frozen=True)
23+
class LockfileCheck:
24+
"""Original and post-check Git blobs for one lockfile."""
25+
26+
stale: bool
27+
original_blob: str
28+
repaired_blob: str
29+
30+
def __post_init__(self) -> None:
31+
if not self.original_blob or not self.repaired_blob:
32+
raise ValueError("lockfile blob hashes must be non-empty")
33+
if not self.stale and self.original_blob != self.repaired_blob:
34+
raise ValueError("a fresh lockfile cannot have different original and repaired blobs")
35+
36+
37+
def classify(candidate: LockfileCheck, base: LockfileCheck | None) -> Classification:
38+
"""Attribute a stale candidate lockfile using its base check, if any."""
39+
if not candidate.stale:
40+
raise ValueError("candidate lockfile must be stale")
41+
if base is None or not base.stale:
42+
return Classification.PR_INDUCED
43+
if base.original_blob == candidate.original_blob and base.repaired_blob == candidate.repaired_blob:
44+
return Classification.BASE_MAINTENANCE
45+
return Classification.MIXED
46+
47+
48+
def _parse_args() -> argparse.Namespace:
49+
parser = argparse.ArgumentParser(description=__doc__)
50+
parser.add_argument("--candidate-original", required=True)
51+
parser.add_argument("--candidate-repaired", required=True)
52+
parser.add_argument("--base-result", choices=("missing", "fresh", "stale"), required=True)
53+
parser.add_argument("--base-original")
54+
parser.add_argument("--base-repaired")
55+
return parser.parse_args()
56+
57+
58+
def main() -> int:
59+
"""Print the classification for workflow consumption."""
60+
args = _parse_args()
61+
candidate = LockfileCheck(
62+
stale=True,
63+
original_blob=args.candidate_original,
64+
repaired_blob=args.candidate_repaired,
65+
)
66+
67+
if args.base_result == "missing":
68+
if args.base_original or args.base_repaired:
69+
raise ValueError("a missing base lockfile cannot have blob hashes")
70+
base = None
71+
else:
72+
if not args.base_original or not args.base_repaired:
73+
raise ValueError("base blob hashes are required for a checked base lockfile")
74+
base = LockfileCheck(
75+
stale=args.base_result == "stale",
76+
original_blob=args.base_original,
77+
repaired_blob=args.base_repaired,
78+
)
79+
80+
print(classify(candidate, base).value)
81+
return 0
82+
83+
84+
if __name__ == "__main__":
85+
sys.exit(main())

‎ci/tools/tests/test_classify_pixi_lockfile_freshness.py‎

Lines changed: 63 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,63 @@
1+
# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
2+
# SPDX-License-Identifier: Apache-2.0
3+
4+
from __future__ import annotations
5+
6+
import sys
7+
from pathlib import Path
8+
9+
import pytest
10+
11+
sys.path.insert(0, str(Path(__file__).parent.parent))
12+
from classify_pixi_lockfile_freshness import Classification, LockfileCheck, classify
13+
14+
15+
def _check(*, stale: bool, original: str, repaired: str) -> LockfileCheck:
16+
return LockfileCheck(stale=stale, original_blob=original, repaired_blob=repaired)
17+
18+
19+
@pytest.mark.agent_authored(model="gpt-5")
20+
def test_fresh_base_is_pr_induced():
21+
candidate = _check(stale=True, original="candidate-old", repaired="candidate-new")
22+
base = _check(stale=False, original="base-current", repaired="base-current")
23+
24+
assert classify(candidate, base) is Classification.PR_INDUCED
25+
26+
27+
@pytest.mark.agent_authored(model="gpt-5")
28+
def test_workspace_missing_from_base_is_pr_induced():
29+
candidate = _check(stale=True, original="candidate-old", repaired="candidate-new")
30+
31+
assert classify(candidate, None) is Classification.PR_INDUCED
32+
33+
34+
@pytest.mark.agent_authored(model="gpt-5")
35+
def test_matching_stale_blobs_are_base_maintenance():
36+
candidate = _check(stale=True, original="shared-old", repaired="shared-new")
37+
base = _check(stale=True, original="shared-old", repaired="shared-new")
38+
39+
assert classify(candidate, base) is Classification.BASE_MAINTENANCE
40+
41+
42+
@pytest.mark.parametrize(
43+
("base_original", "base_repaired"),
44+
[
45+
("base-old", "shared-new"),
46+
("shared-old", "base-new"),
47+
("base-old", "base-new"),
48+
],
49+
)
50+
@pytest.mark.agent_authored(model="gpt-5")
51+
def test_different_stale_blobs_are_mixed_or_ambiguous(base_original, base_repaired):
52+
candidate = _check(stale=True, original="shared-old", repaired="shared-new")
53+
base = _check(stale=True, original=base_original, repaired=base_repaired)
54+
55+
assert classify(candidate, base) is Classification.MIXED
56+
57+
58+
@pytest.mark.agent_authored(model="gpt-5")
59+
def test_fresh_candidate_is_rejected():
60+
candidate = _check(stale=False, original="current", repaired="current")
61+
62+
with pytest.raises(ValueError, match="candidate lockfile must be stale"):
63+
classify(candidate, None)

‎cuda_bindings/cuda/bindings/_lib/cyruntime/cyruntime.pxi‎

Lines changed: 156 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -259,6 +259,26 @@ cdef cudaError_t getDescInfo(const cudaChannelFormatDesc* d, int *numberOfChanne
259259
elif d[0].f in (cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized1010102,):
260260
if (d[0].x != 10) or (d[0].y != 10) or (d[0].z != 10) or (d[0].w != 2):
261261
return cudaErrorInvalidChannelDescriptor
262+
elif d[0].f in (cudaChannelFormatKind.cudaChannelFormatKindUnsigned8Packed422,
263+
cudaChannelFormatKind.cudaChannelFormatKindUnsigned8Packed444,):
264+
if (d[0].x != 8) or (d[0].y != 8) or (d[0].z != 8) or (d[0].w != 8):
265+
return cudaErrorInvalidChannelDescriptor
266+
elif d[0].f in (cudaChannelFormatKind.cudaChannelFormatKindUnsigned8SemiPlanar420,
267+
cudaChannelFormatKind.cudaChannelFormatKindUnsigned8SemiPlanar422,
268+
cudaChannelFormatKind.cudaChannelFormatKindUnsigned8SemiPlanar444,
269+
cudaChannelFormatKind.cudaChannelFormatKindUnsigned8Planar420,
270+
cudaChannelFormatKind.cudaChannelFormatKindUnsigned8Planar422,
271+
cudaChannelFormatKind.cudaChannelFormatKindUnsigned8Planar444,):
272+
if (d[0].x != 8) or (d[0].y != 8) or (d[0].z != 8) or (d[0].w != 0):
273+
return cudaErrorInvalidChannelDescriptor
274+
elif d[0].f in (cudaChannelFormatKind.cudaChannelFormatKindUnsigned16SemiPlanar420,
275+
cudaChannelFormatKind.cudaChannelFormatKindUnsigned16SemiPlanar422,
276+
cudaChannelFormatKind.cudaChannelFormatKindUnsigned16SemiPlanar444,
277+
cudaChannelFormatKind.cudaChannelFormatKindUnsigned16Planar420,
278+
cudaChannelFormatKind.cudaChannelFormatKindUnsigned16Planar422,
279+
cudaChannelFormatKind.cudaChannelFormatKindUnsigned16Planar444,):
280+
if (d[0].x != 16) or (d[0].y != 16) or (d[0].z != 16) or (d[0].w != 0):
281+
return cudaErrorInvalidChannelDescriptor
262282
else:
263283
return cudaErrorInvalidChannelDescriptor
264284

@@ -414,12 +434,104 @@ cdef cudaError_t getDescInfo(const cudaChannelFormatDesc* d, int *numberOfChanne
414434
elif case_desc(d, 10, 10, 10, 2, cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized1010102):
415435
numberOfChannels[0] = 4
416436
format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_UNORM_INT_101010_2
437+
# 2a: normalized 8/16-bit kinds — validated above but previously had no case_desc arm
438+
elif case_desc(d, 8, 0, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized8X1):
439+
numberOfChannels[0] = 1
440+
format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_UNORM_INT8X1
441+
elif case_desc(d, 8, 8, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized8X2):
442+
numberOfChannels[0] = 2
443+
format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_UNORM_INT8X2
444+
elif case_desc(d, 8, 8, 8, 8, cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized8X4):
445+
numberOfChannels[0] = 4
446+
format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_UNORM_INT8X4
447+
elif case_desc(d, 8, 0, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized8X1):
448+
numberOfChannels[0] = 1
449+
format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_SNORM_INT8X1
450+
elif case_desc(d, 8, 8, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized8X2):
451+
numberOfChannels[0] = 2
452+
format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_SNORM_INT8X2
453+
elif case_desc(d, 8, 8, 8, 8, cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized8X4):
454+
numberOfChannels[0] = 4
455+
format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_SNORM_INT8X4
456+
elif case_desc(d, 16, 0, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized16X1):
457+
numberOfChannels[0] = 1
458+
format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_UNORM_INT16X1
459+
elif case_desc(d, 16, 16, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized16X2):
460+
numberOfChannels[0] = 2
461+
format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_UNORM_INT16X2
462+
elif case_desc(d, 16, 16, 16, 16, cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized16X4):
463+
numberOfChannels[0] = 4
464+
format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_UNORM_INT16X4
465+
elif case_desc(d, 16, 0, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized16X1):
466+
numberOfChannels[0] = 1
467+
format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_SNORM_INT16X1
468+
elif case_desc(d, 16, 16, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized16X2):
469+
numberOfChannels[0] = 2
470+
format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_SNORM_INT16X2
471+
elif case_desc(d, 16, 16, 16, 16, cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized16X4):
472+
numberOfChannels[0] = 4
473+
format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_SNORM_INT16X4
474+
# 2b: CUDA 13.3/13.4 packed and multi-planar YUV kinds
475+
elif case_desc(d, 8, 8, 8, 8, cudaChannelFormatKind.cudaChannelFormatKindUnsigned8Packed422):
476+
numberOfChannels[0] = 4
477+
format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_UINT8_PACKED_422
478+
elif case_desc(d, 8, 8, 8, 8, cudaChannelFormatKind.cudaChannelFormatKindUnsigned8Packed444):
479+
numberOfChannels[0] = 4
480+
format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_UINT8_PACKED_444
481+
elif case_desc(d, 8, 8, 8, 0, cudaChannelFormatKind.cudaChannelFormatKindUnsigned8SemiPlanar420):
482+
numberOfChannels[0] = 3
483+
format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_UINT8_SEMIPLANAR_420
484+
elif case_desc(d, 16, 16, 16, 0, cudaChannelFormatKind.cudaChannelFormatKindUnsigned16SemiPlanar420):
485+
numberOfChannels[0] = 3
486+
format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_UINT16_SEMIPLANAR_420
487+
elif case_desc(d, 8, 8, 8, 0, cudaChannelFormatKind.cudaChannelFormatKindUnsigned8SemiPlanar422):
488+
numberOfChannels[0] = 3
489+
format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_UINT8_SEMIPLANAR_422
490+
elif case_desc(d, 16, 16, 16, 0, cudaChannelFormatKind.cudaChannelFormatKindUnsigned16SemiPlanar422):
491+
numberOfChannels[0] = 3
492+
format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_UINT16_SEMIPLANAR_422
493+
elif case_desc(d, 8, 8, 8, 0, cudaChannelFormatKind.cudaChannelFormatKindUnsigned8SemiPlanar444):
494+
numberOfChannels[0] = 3
495+
format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_UINT8_SEMIPLANAR_444
496+
elif case_desc(d, 16, 16, 16, 0, cudaChannelFormatKind.cudaChannelFormatKindUnsigned16SemiPlanar444):
497+
numberOfChannels[0] = 3
498+
format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_UINT16_SEMIPLANAR_444
499+
elif case_desc(d, 8, 8, 8, 0, cudaChannelFormatKind.cudaChannelFormatKindUnsigned8Planar420):
500+
numberOfChannels[0] = 3
501+
format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_UINT8_PLANAR_420
502+
elif case_desc(d, 16, 16, 16, 0, cudaChannelFormatKind.cudaChannelFormatKindUnsigned16Planar420):
503+
numberOfChannels[0] = 3
504+
format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_UINT16_PLANAR_420
505+
elif case_desc(d, 8, 8, 8, 0, cudaChannelFormatKind.cudaChannelFormatKindUnsigned8Planar422):
506+
numberOfChannels[0] = 3
507+
format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_UINT8_PLANAR_422
508+
elif case_desc(d, 16, 16, 16, 0, cudaChannelFormatKind.cudaChannelFormatKindUnsigned16Planar422):
509+
numberOfChannels[0] = 3
510+
format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_UINT16_PLANAR_422
511+
elif case_desc(d, 8, 8, 8, 0, cudaChannelFormatKind.cudaChannelFormatKindUnsigned8Planar444):
512+
numberOfChannels[0] = 3
513+
format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_UINT8_PLANAR_444
514+
elif case_desc(d, 16, 16, 16, 0, cudaChannelFormatKind.cudaChannelFormatKindUnsigned16Planar444):
515+
numberOfChannels[0] = 3
516+
format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_UINT16_PLANAR_444
417517
else:
418518
return cudaErrorInvalidChannelDescriptor
419519

420520
if d[0].f in (cudaChannelFormatKind.cudaChannelFormatKindNV12,
421521
cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed6H,
422-
cudaChannelFormatKind.cudaChannelFormatKindSignedBlockCompressed6H,):
522+
cudaChannelFormatKind.cudaChannelFormatKindSignedBlockCompressed6H,
523+
cudaChannelFormatKind.cudaChannelFormatKindUnsigned8SemiPlanar420,
524+
cudaChannelFormatKind.cudaChannelFormatKindUnsigned16SemiPlanar420,
525+
cudaChannelFormatKind.cudaChannelFormatKindUnsigned8SemiPlanar422,
526+
cudaChannelFormatKind.cudaChannelFormatKindUnsigned16SemiPlanar422,
527+
cudaChannelFormatKind.cudaChannelFormatKindUnsigned8SemiPlanar444,
528+
cudaChannelFormatKind.cudaChannelFormatKindUnsigned16SemiPlanar444,
529+
cudaChannelFormatKind.cudaChannelFormatKindUnsigned8Planar420,
530+
cudaChannelFormatKind.cudaChannelFormatKindUnsigned16Planar420,
531+
cudaChannelFormatKind.cudaChannelFormatKindUnsigned8Planar422,
532+
cudaChannelFormatKind.cudaChannelFormatKindUnsigned16Planar422,
533+
cudaChannelFormatKind.cudaChannelFormatKindUnsigned8Planar444,
534+
cudaChannelFormatKind.cudaChannelFormatKindUnsigned16Planar444,):
423535
if numberOfChannels[0] != 3:
424536
return cudaErrorInvalidChannelDescriptor
425537
else:
@@ -536,6 +648,49 @@ cdef cudaError_t getChannelFormatDescFromDriverDesc(cudaChannelFormatDesc* pRunt
536648
channel_size = 8
537649
elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_UNORM_INT_101010_2:
538650
pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized1010102
651+
# 2b: CUDA 13.3/13.4 packed and multi-planar YUV formats
652+
elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_UINT8_PACKED_422:
653+
pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsigned8Packed422
654+
channel_size = 8
655+
elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_UINT8_PACKED_444:
656+
pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsigned8Packed444
657+
channel_size = 8
658+
elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_UINT8_SEMIPLANAR_420:
659+
pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsigned8SemiPlanar420
660+
channel_size = 8
661+
elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_UINT16_SEMIPLANAR_420:
662+
pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsigned16SemiPlanar420
663+
channel_size = 16
664+
elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_UINT8_SEMIPLANAR_422:
665+
pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsigned8SemiPlanar422
666+
channel_size = 8
667+
elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_UINT16_SEMIPLANAR_422:
668+
pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsigned16SemiPlanar422
669+
channel_size = 16
670+
elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_UINT8_SEMIPLANAR_444:
671+
pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsigned8SemiPlanar444
672+
channel_size = 8
673+
elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_UINT16_SEMIPLANAR_444:
674+
pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsigned16SemiPlanar444
675+
channel_size = 16
676+
elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_UINT8_PLANAR_420:
677+
pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsigned8Planar420
678+
channel_size = 8
679+
elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_UINT16_PLANAR_420:
680+
pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsigned16Planar420
681+
channel_size = 16
682+
elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_UINT8_PLANAR_422:
683+
pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsigned8Planar422
684+
channel_size = 8
685+
elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_UINT16_PLANAR_422:
686+
pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsigned16Planar422
687+
channel_size = 16
688+
elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_UINT8_PLANAR_444:
689+
pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsigned8Planar444
690+
channel_size = 8
691+
elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_UINT16_PLANAR_444:
692+
pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsigned16Planar444
693+
channel_size = 16
539694
else:
540695
return cudaErrorInvalidChannelDescriptor
541696

‎cuda_bindings/cuda/bindings/_lib/utils.pxd‎

Lines changed: 5 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -5,6 +5,7 @@ cimport cuda.bindings.driver as driver
55
cimport cuda.bindings.cydriver as cydriver
66
cimport cuda.bindings.cyruntime as cyruntime
77
from libcpp.vector cimport vector
8+
from libcpp cimport bool as cpp_bool
89
from cpython.buffer cimport PyBuffer_Release, Py_buffer
910

1011
cdef class _HelperKernelParams:
@@ -35,6 +36,7 @@ cdef class _HelperCUmemPool_attribute:
3536

3637
# Return values
3738
cdef int _int_val
39+
cdef unsigned int _uint_val
3840
cdef driver.cuuint64_t _cuuint64_t_val
3941

4042

@@ -60,7 +62,7 @@ cdef class _HelperCUpointer_attribute:
6062
cdef unsigned int _uint
6163
cdef int _int
6264
cdef driver.CUdeviceptr _devptr
63-
cdef void** _void
65+
cdef void* _void
6466
cdef driver.CUDA_POINTER_ATTRIBUTE_P2P_TOKENS _token
6567
cdef bint _bool
6668
cdef unsigned long long _ull
@@ -163,5 +165,6 @@ cdef class _HelperCUcoredumpSettings:
163165
cdef object _references # keeps caller bytes alive so _charstar stays valid
164166

165167
# Return values
166-
cdef bint _bool
168+
cdef cpp_bool _bool
169+
cdef unsigned int _uint
167170
cdef char* _charstar

0 commit comments

Comments
 (0)