fix: use pytest.skip() for unsupported configs in test examples

The _test.py files in cuda_bindings/examples/ are run under pytest,
so sys.exit(1) for unsupported configurations causes SystemExit(1)
which pytest treats as a test failure. Use pytest.skip() instead for
platform/device/capability checks that indicate unsupported configs.
Actual test failures (incorrect results) still use sys.exit(1).

Made-with: Cursor

Author: cpcloud

cuda_bindings/examples/0_Introduction/clock_nvrtc_test.py

@@ -2,7 +2,6 @@
 # SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE
 
 import platform
-import sys
 
 import numpy as np
 from common import common
@@ -59,9 +58,10 @@ def elems_to_bytes(nelems, dt):
 
 
 def main():
+    import pytest
+
     if platform.machine() == "armv7l":
-        print("clock_nvrtc is not supported on ARMv7 - waiving sample", file=sys.stderr)
-        sys.exit(1)
+        pytest.skip("clock_nvrtc is not supported on ARMv7")
 
     timer = np.empty(NUM_BLOCKS * 2, dtype="int64")
     hinput = np.empty(NUM_THREADS * 2, dtype="float32")

cuda_bindings/examples/0_Introduction/simpleCubemapTexture_test.py

@@ -90,8 +90,9 @@ def main():
         f"CUDA device [{deviceProps.name}] has {deviceProps.multiProcessorCount} Multi-Processors SM {deviceProps.major}.{deviceProps.minor}"
     )
     if deviceProps.major < 2:
-        print("Test requires SM 2.0 or higher for support of Texture Arrays.", file=sys.stderr)
-        sys.exit(1)
+        import pytest
+
+        pytest.skip("Test requires SM 2.0 or higher for support of Texture Arrays.")
 
     # Generate input data for layered texture
     width = 64

cuda_bindings/examples/0_Introduction/simpleP2P_test.py

@@ -24,30 +24,27 @@
 
 
 def main():
+    import pytest
+
     if platform.system() == "Darwin":
-        print("simpleP2P is not supported on Mac OSX", file=sys.stderr)
-        sys.exit(1)
+        pytest.skip("simpleP2P is not supported on Mac OSX")
 
     if platform.machine() == "armv7l":
-        print("simpleP2P is not supported on ARMv7", file=sys.stderr)
-        sys.exit(1)
+        pytest.skip("simpleP2P is not supported on ARMv7")
 
     if platform.machine() == "aarch64":
-        print("simpleP2P is not supported on aarch64", file=sys.stderr)
-        sys.exit(1)
+        pytest.skip("simpleP2P is not supported on aarch64")
 
     if platform.machine() == "sbsa":
-        print("simpleP2P is not supported on sbsa", file=sys.stderr)
-        sys.exit(1)
+        pytest.skip("simpleP2P is not supported on sbsa")
 
     # Number of GPUs
     print("Checking for multiple GPUs...")
     gpu_n = checkCudaErrors(cudart.cudaGetDeviceCount())
     print(f"CUDA-capable device count: {gpu_n}")
 
     if gpu_n < 2:
-        print("Two or more GPUs with Peer-to-Peer access capability are required", file=sys.stderr)
-        sys.exit(1)
+        pytest.skip("Two or more GPUs with Peer-to-Peer access capability are required")
 
     prop = [checkCudaErrors(cudart.cudaGetDeviceProperties(i)) for i in range(gpu_n)]
     # Check possibility for peer access
@@ -78,9 +75,7 @@ def main():
             break
 
     if p2pCapableGPUs[0] == -1 or p2pCapableGPUs[1] == -1:
-        print("Two or more GPUs with Peer-to-Peer access capability are required.", file=sys.stderr)
-        print("Peer to Peer access is not available amongst GPUs in the system, waiving test.", file=sys.stderr)
-        sys.exit(1)
+        pytest.skip("Peer to Peer access is not available amongst GPUs in the system")
 
     # Use first pair of p2p capable GPUs detected
     gpuid = [p2pCapableGPUs[0], p2pCapableGPUs[1]]

cuda_bindings/examples/0_Introduction/simpleZeroCopy_test.py

@@ -32,21 +32,19 @@ def main():
     idev = 0
     bPinGenericMemory = False
 
+    import pytest
+
     if platform.system() == "Darwin":
-        print("simpleZeroCopy is not supported on Mac OSX", file=sys.stderr)
-        sys.exit(1)
+        pytest.skip("simpleZeroCopy is not supported on Mac OSX")
 
     if platform.machine() == "armv7l":
-        print("simpleZeroCopy is not supported on ARMv7", file=sys.stderr)
-        sys.exit(1)
+        pytest.skip("simpleZeroCopy is not supported on ARMv7")
 
     if platform.machine() == "aarch64":
-        print("simpleZeroCopy is not supported on aarch64", file=sys.stderr)
-        sys.exit(1)
+        pytest.skip("simpleZeroCopy is not supported on aarch64")
 
     if platform.machine() == "sbsa":
-        print("simpleZeroCopy is not supported on sbsa", file=sys.stderr)
-        sys.exit(1)
+        pytest.skip("simpleZeroCopy is not supported on sbsa")
 
     if checkCmdLineFlag("help"):
         print("Usage:  simpleZeroCopy [OPTION]\n", file=sys.stderr)
@@ -78,8 +76,7 @@ def main():
     deviceProp = checkCudaErrors(cudart.cudaGetDeviceProperties(idev))
 
     if not deviceProp.canMapHostMemory:
-        print(f"Device {idev} does not support mapping CPU host memory!", file=sys.stderr)
-        sys.exit(1)
+        pytest.skip(f"Device {idev} does not support mapping CPU host memory!")
 
     checkCudaErrors(cudart.cudaSetDeviceFlags(cudart.cudaDeviceMapHost))
 

cuda_bindings/examples/0_Introduction/systemWideAtomics_test.py

@@ -165,26 +165,24 @@ def verify(testData, length):
 
 
 def main():
+    import pytest
+
     if os.name == "nt":
-        print("Atomics not supported on Windows", file=sys.stderr)
-        sys.exit(1)
+        pytest.skip("Atomics not supported on Windows")
 
     # set device
     dev_id = findCudaDevice()
     device_prop = checkCudaErrors(cudart.cudaGetDeviceProperties(dev_id))
 
     if not device_prop.managedMemory:
-        print("Unified Memory not supported on this device", file=sys.stderr)
-        sys.exit(1)
+        pytest.skip("Unified Memory not supported on this device")
 
     computeMode = checkCudaErrors(cudart.cudaDeviceGetAttribute(cudart.cudaDeviceAttr.cudaDevAttrComputeMode, dev_id))
     if computeMode == cudart.cudaComputeMode.cudaComputeModeProhibited:
-        print("This sample requires a device in either default or process exclusive mode", file=sys.stderr)
-        sys.exit(1)
+        pytest.skip("This sample requires a device in either default or process exclusive mode")
 
     if device_prop.major < 6:
-        print("Requires a minimum CUDA compute 6.0 capability, waiving testing.", file=sys.stderr)
-        sys.exit(1)
+        pytest.skip("Requires a minimum CUDA compute 6.0 capability")
 
     numThreads = 256
     numBlocks = 64

cuda_bindings/examples/0_Introduction/vectorAddDrv_test.py

@@ -44,8 +44,9 @@ def main():
         cuda.cuDeviceGetAttribute(cuda.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING, cuDevice)
     )
     if not uvaSupported:
-        print("Accessing pageable memory directly requires UVA", file=sys.stderr)
-        sys.exit(1)
+        import pytest
+
+        pytest.skip("Accessing pageable memory directly requires UVA")
 
     kernelHelper = common.KernelHelper(vectorAddDrv, int(cuDevice))
     _VecAdd_kernel = kernelHelper.getFunction(b"VecAdd_kernel")

cuda_bindings/examples/0_Introduction/vectorAddMMAP_test.py

@@ -189,21 +189,19 @@ def simpleFreeMultiDeviceMmap(dptr, size):
 
 
 def main():
+    import pytest
+
     if platform.system() == "Darwin":
-        print("vectorAddMMAP is not supported on Mac OSX", file=sys.stderr)
-        sys.exit(1)
+        pytest.skip("vectorAddMMAP is not supported on Mac OSX")
 
     if platform.machine() == "armv7l":
-        print("vectorAddMMAP is not supported on ARMv7", file=sys.stderr)
-        sys.exit(1)
+        pytest.skip("vectorAddMMAP is not supported on ARMv7")
 
     if platform.machine() == "aarch64":
-        print("vectorAddMMAP is not supported on aarch64", file=sys.stderr)
-        sys.exit(1)
+        pytest.skip("vectorAddMMAP is not supported on aarch64")
 
     if platform.machine() == "sbsa":
-        print("vectorAddMMAP is not supported on sbsa", file=sys.stderr)
-        sys.exit(1)
+        pytest.skip("vectorAddMMAP is not supported on sbsa")
 
     N = 50000
     size = N * np.dtype(np.float32).itemsize
@@ -222,8 +220,7 @@ def main():
     )
     print(f"Device {cuDevice} VIRTUAL ADDRESS MANAGEMENT SUPPORTED = {attributeVal}.")
     if not attributeVal:
-        print(f"Device {cuDevice} doesn't support VIRTUAL ADDRESS MANAGEMENT.", file=sys.stderr)
-        sys.exit(1)
+        pytest.skip(f"Device {cuDevice} doesn't support VIRTUAL ADDRESS MANAGEMENT.")
 
     # The vector addition happens on cuDevice, so the allocations need to be mapped there.
     mappingDevices = [cuDevice]

cuda_bindings/examples/2_Concepts_and_Techniques/streamOrderedAllocation_test.py

@@ -191,9 +191,10 @@ def streamOrderedAllocationPostSync(dev, nelem, a, b, c):
 
 
 def main():
+    import pytest
+
     if platform.system() == "Darwin":
-        print("streamOrderedAllocation is not supported on Mac OSX", file=sys.stderr)
-        sys.exit(1)
+        pytest.skip("streamOrderedAllocation is not supported on Mac OSX")
 
     cuda.cuInit(0)
     if checkCmdLineFlag("help"):
@@ -212,8 +213,7 @@ def main():
             cudart.cudaDeviceGetAttribute(cuda.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MEMORY_POOLS_SUPPORTED, dev)
         )
     if not isMemPoolSupported:
-        print("Waiving execution as device does not support Memory Pools", file=sys.stderr)
-        sys.exit(1)
+        pytest.skip("Waiving execution as device does not support Memory Pools")
 
     global _vectorAddGPU
     kernelHelper = common.KernelHelper(streamOrderedAllocation, dev)

cuda_bindings/examples/3_CUDA_Features/globalToShmemAsyncCopy_test.py

@@ -1116,16 +1116,16 @@ def MatrixMultiply(dimsA, dimsB, kernel_number):
 
 
 def main():
+    import pytest
+
     common.pytest_skipif_compute_capability_too_low(findCudaDevice(), (7, 0))
 
     if platform.machine() == "qnx":
-        print("globalToShmemAsyncCopy is not supported on QNX", file=sys.stderr)
-        sys.exit(1)
+        pytest.skip("globalToShmemAsyncCopy is not supported on QNX")
 
     version = checkCudaErrors(cuda.cuDriverGetVersion())
     if version < 11010:
-        print("CUDA Toolkit 11.1 or greater is required", file=sys.stderr)
-        sys.exit(1)
+        pytest.skip("CUDA Toolkit 11.1 or greater is required")
 
     if checkCmdLineFlag("help") or checkCmdLineFlag("?"):
         print("Usage device=n (n >= 0 for deviceID)", file=sys.stderr)
@@ -1193,8 +1193,7 @@ def main():
         cudart.cudaDeviceGetAttribute(cudart.cudaDeviceAttr.cudaDevAttrComputeCapabilityMajor, devID)
     )
     if major < 7:
-        print("globalToShmemAsyncCopy requires SM 7.0 or higher.", file=sys.stderr)
-        sys.exit(1)
+        pytest.skip("globalToShmemAsyncCopy requires SM 7.0 or higher.")
 
     print(f"MatrixA({dimsA.x},{dimsA.y}), MatrixB({dimsB.x},{dimsB.y})")
 

cuda_bindings/examples/4_CUDA_Libraries/conjugateGradientMultiBlockCG_test.py

@@ -198,34 +198,31 @@ def genTridiag(I, J, val, N, nz):
 def main():
     tol = 1e-5
 
+    import pytest
+
     # WAIVE: Due to bug in NVRTC
     return
 
     if platform.system() == "Darwin":
-        print("conjugateGradientMultiBlockCG is not supported on Mac OSX", file=sys.stderr)
-        sys.exit(1)
+        pytest.skip("conjugateGradientMultiBlockCG is not supported on Mac OSX")
 
     if platform.machine() == "armv7l":
-        print("conjugateGradientMultiBlockCG is not supported on ARMv7", file=sys.stderr)
-        sys.exit(1)
+        pytest.skip("conjugateGradientMultiBlockCG is not supported on ARMv7")
 
     if platform.machine() == "qnx":
-        print("conjugateGradientMultiBlockCG is not supported on QNX", file=sys.stderr)
-        sys.exit(1)
+        pytest.skip("conjugateGradientMultiBlockCG is not supported on QNX")
 
     # This will pick the best possible CUDA capable device
     devID = findCudaDevice()
     deviceProp = checkCudaErrors(cudart.cudaGetDeviceProperties(devID))
 
     if not deviceProp.managedMemory:
-        print("Unified Memory not supported on this device", file=sys.stderr)
-        sys.exit(1)
+        pytest.skip("Unified Memory not supported on this device")
 
     # This sample requires being run on a device that supports Cooperative Kernel
     # Launch
     if not deviceProp.cooperativeLaunch:
-        print(f"\nSelected GPU {devID} does not support Cooperative Kernel Launch, Waiving the run", file=sys.stderr)
-        sys.exit(1)
+        pytest.skip(f"Selected GPU {devID} does not support Cooperative Kernel Launch")
 
     # Statistics about the GPU device
     print(