CUDA 13.2 samples update (#432)

- Added Python samples for CUDA Python 1.0 release
- Renamed top-level `Samples` directory to `cpp` to accommodate Python samples.

cpp/0_Introduction/simpleOccupancy/.vscode/c_cpp_properties.json

@@ -0,0 +1,18 @@
+{
+    "configurations": [
+        {
+            "name": "Linux",
+            "includePath": [
+                "${workspaceFolder}/**",
+                "${workspaceFolder}/../../../Common"
+            ],
+            "defines": [],
+            "compilerPath": "/usr/local/cuda/bin/nvcc",
+            "cStandard": "gnu17",
+            "cppStandard": "gnu++14",
+            "intelliSenseMode": "linux-gcc-x64",
+            "configurationProvider": "ms-vscode.makefile-tools"
+        }
+    ],
+    "version": 4
+}

cpp/0_Introduction/simpleOccupancy/.vscode/extensions.json

@@ -0,0 +1,7 @@
+{
+    "recommendations": [
+        "nvidia.nsight-vscode-edition",
+        "ms-vscode.cpptools",
+        "ms-vscode.makefile-tools"
+    ]
+}

cpp/0_Introduction/simpleOccupancy/CMakeLists.txt

@@ -0,0 +1,34 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../../cmake/Modules")
+
+project(simpleOccupancy LANGUAGES C CXX CUDA)
+
+find_package(CUDAToolkit REQUIRED)
+
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+set(CMAKE_CUDA_ARCHITECTURES 75 80 86 87 89 90 100 110 120)
+set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -Wno-deprecated-gpu-targets")
+if(ENABLE_CUDA_DEBUG)
+    set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")        # enable cuda-gdb (may significantly affect performance on some targets)
+else()
+    set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -lineinfo") # add line information to all builds for debug tools (exclusive to -G option)
+endif()
+
+# Include directories and libraries
+include_directories(../../../Common)
+
+# Source file
+# Add target for simpleOccupancy
+add_executable(simpleOccupancy simpleOccupancy.cu)
+
+target_compile_options(simpleOccupancy PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(simpleOccupancy PRIVATE cxx_std_17 cuda_std_17)
+
+set_target_properties(simpleOccupancy PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
+
+# Include installation configuration
+include(${CMAKE_CURRENT_SOURCE_DIR}/../../../cmake/InstallSamples.cmake)
+setup_samples_install()

cpp/0_Introduction/simpleOccupancy/README.md

@@ -0,0 +1,32 @@
+# simpleOccupancy - simpleOccupancy
+
+## Description
+
+This sample demonstrates the basic usage of the CUDA occupancy calculator and occupancy-based launch configurator APIs by launching a kernel with the launch configurator, and measures the utilization difference against a manually configured launch.
+
+## Key Concepts
+
+Occupancy Calculator
+
+## Supported SM Architectures
+
+[SM 5.0 ](https://developer.nvidia.com/cuda-gpus)  [SM 5.2 ](https://developer.nvidia.com/cuda-gpus)  [SM 5.3 ](https://developer.nvidia.com/cuda-gpus)  [SM 6.0 ](https://developer.nvidia.com/cuda-gpus)  [SM 6.1 ](https://developer.nvidia.com/cuda-gpus)  [SM 7.0 ](https://developer.nvidia.com/cuda-gpus)  [SM 7.2 ](https://developer.nvidia.com/cuda-gpus)  [SM 7.5 ](https://developer.nvidia.com/cuda-gpus)  [SM 8.0 ](https://developer.nvidia.com/cuda-gpus)  [SM 8.6 ](https://developer.nvidia.com/cuda-gpus)  [SM 8.7 ](https://developer.nvidia.com/cuda-gpus)  [SM 8.9 ](https://developer.nvidia.com/cuda-gpus)  [SM 9.0 ](https://developer.nvidia.com/cuda-gpus)
+
+## Supported OSes
+
+Linux, Windows
+
+## Supported CPU Architecture
+
+x86_64, armv7l
+
+## CUDA APIs involved
+
+### [CUDA Runtime API](http://docs.nvidia.com/cuda/cuda-runtime-api/index.html)
+cudaMemcpy, cudaFree, cudaDeviceSynchronize, cudaEventRecord, cudaGetDevice, cudaMalloc, cudaEventElapsedTime, cudaOccupancyMaxActiveBlocksPerMultiprocessor, cudaGetDeviceProperties, cudaOccupancyMaxPotentialBlockSize, cudaEventCreate
+
+## Prerequisites
+
+Download and install the [CUDA Toolkit](https://developer.nvidia.com/cuda-downloads) for your corresponding platform.
+
+## References (for more details)

cpp/0_Introduction/simpleOccupancy/simpleOccupancy.cu

@@ -0,0 +1,240 @@
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <cstdint>
+#include <helper_cuda.h> // helper functions for CUDA error check
+#include <iostream>
+
+const int manualBlockSize = 32;
+
+////////////////////////////////////////////////////////////////////////////////
+// Test kernel
+//
+// This kernel squares each array element. Each thread addresses
+// himself with threadIdx and blockIdx, so that it can handle any
+// execution configuration, including anything the launch configurator
+// API suggests.
+////////////////////////////////////////////////////////////////////////////////
+__global__ void square(uint32_t *array, int arrayCount)
+{
+    extern __shared__ int dynamicSmem[];
+    int                   idx = threadIdx.x + blockIdx.x * blockDim.x;
+
+    if (idx < arrayCount) {
+        array[idx] *= array[idx];
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Potential occupancy calculator
+//
+// The potential occupancy is calculated according to the kernel and
+// execution configuration the user desires. Occupancy is defined in
+// terms of active blocks per multiprocessor, and the user can convert
+// it to other metrics.
+//
+// This wrapper routine computes the occupancy of kernel, and reports
+// it in terms of active warps / maximum warps per SM.
+////////////////////////////////////////////////////////////////////////////////
+static double reportPotentialOccupancy(void *kernel, int blockSize, size_t dynamicSMem)
+{
+    int            device;
+    cudaDeviceProp prop;
+
+    int numBlocks;
+    int activeWarps;
+    int maxWarps;
+
+    double occupancy;
+
+    checkCudaErrors(cudaGetDevice(&device));
+    checkCudaErrors(cudaGetDeviceProperties(&prop, device));
+
+    checkCudaErrors(cudaOccupancyMaxActiveBlocksPerMultiprocessor(&numBlocks, kernel, blockSize, dynamicSMem));
+
+    activeWarps = numBlocks * blockSize / prop.warpSize;
+    maxWarps    = prop.maxThreadsPerMultiProcessor / prop.warpSize;
+
+    occupancy = (double)activeWarps / maxWarps;
+
+    return occupancy;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Occupancy-based launch configurator
+//
+// The launch configurator, cudaOccupancyMaxPotentialBlockSize and
+// cudaOccupancyMaxPotentialBlockSizeVariableSMem, suggests a block
+// size that achieves the best theoretical occupancy. It also returns
+// the minimum number of blocks needed to achieve the occupancy on the
+// whole device.
+//
+// This launch configurator is purely occupancy-based. It doesn't
+// translate directly to performance, but the suggestion should
+// nevertheless be a good starting point for further optimizations.
+//
+// This function configures the launch based on the "automatic"
+// argument, records the runtime, and reports occupancy and runtime.
+////////////////////////////////////////////////////////////////////////////////
+static int launchConfig(uint32_t *array, int arrayCount, bool automatic)
+{
+    int    blockSize;
+    int    minGridSize;
+    int    gridSize;
+    size_t dynamicSMemUsage = 0;
+
+    cudaEvent_t start;
+    cudaEvent_t end;
+
+    float elapsedTime;
+
+    double potentialOccupancy;
+
+    checkCudaErrors(cudaEventCreate(&start));
+    checkCudaErrors(cudaEventCreate(&end));
+
+    if (automatic) {
+        checkCudaErrors(
+            cudaOccupancyMaxPotentialBlockSize(&minGridSize, &blockSize, (void *)square, dynamicSMemUsage, arrayCount));
+
+        std::cout << "Suggested block size: " << blockSize << std::endl
+                  << "Minimum grid size for maximum occupancy: " << minGridSize << std::endl;
+    }
+    else {
+        // This block size is too small. Given limited number of
+        // active blocks per multiprocessor, the number of active
+        // threads will be limited, and thus unable to achieve maximum
+        // occupancy.
+        //
+        blockSize = manualBlockSize;
+    }
+
+    // Round up
+    //
+    gridSize = (arrayCount + blockSize - 1) / blockSize;
+
+    // Launch and profile
+    //
+    checkCudaErrors(cudaEventRecord(start));
+    square<<<gridSize, blockSize, dynamicSMemUsage>>>(array, arrayCount);
+    checkCudaErrors(cudaEventRecord(end));
+
+    checkCudaErrors(cudaDeviceSynchronize());
+
+    // Calculate occupancy
+    //
+    potentialOccupancy = reportPotentialOccupancy((void *)square, blockSize, dynamicSMemUsage);
+
+    std::cout << "Potential occupancy: " << potentialOccupancy * 100 << "%" << std::endl;
+
+    // Report elapsed time
+    //
+    checkCudaErrors(cudaEventElapsedTime(&elapsedTime, start, end));
+    std::cout << "Elapsed time: " << elapsedTime << "ms" << std::endl;
+
+    return 0;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// The test
+//
+// The test generates an array and squares it with a CUDA kernel, then
+// verifies the result.
+////////////////////////////////////////////////////////////////////////////////
+static int test(bool automaticLaunchConfig, const int count = 1000000)
+{
+    uint32_t *array;
+    uint32_t *dArray;
+    int       size = count * sizeof(uint32_t);
+
+    array = new uint32_t[count];
+
+    for (uint32_t i = 0; i < count; i += 1) {
+        array[i] = i;
+    }
+
+    checkCudaErrors(cudaMalloc(&dArray, size));
+    checkCudaErrors(cudaMemcpy(dArray, array, size, cudaMemcpyHostToDevice));
+
+    for (uint32_t i = 0; i < count; i += 1) {
+        array[i] = 0;
+    }
+
+    launchConfig(dArray, count, automaticLaunchConfig);
+
+    checkCudaErrors(cudaMemcpy(array, dArray, size, cudaMemcpyDeviceToHost));
+    checkCudaErrors(cudaFree(dArray));
+
+    // Verify the return data
+    // Both GPU and CPU use uint32_t * uint32_t, which has well-defined overflow behavior (modulo 2^32)
+    //
+    for (uint32_t i = 0; i < count; i += 1) {
+        if (array[i] != i * i) {
+            std::cout << "element " << i << " expected " << i * i << " actual " << array[i] << std::endl;
+            return 1;
+        }
+    }
+    delete[] array;
+
+    return 0;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Sample Main
+//
+// The sample runs the test with manually configured launch and
+// automatically configured launch, and reports the occupancy and
+// performance.
+////////////////////////////////////////////////////////////////////////////////
+int main()
+{
+    int status;
+
+    std::cout << "starting Simple Occupancy" << std::endl << std::endl;
+
+    std::cout << "[ Manual configuration with " << manualBlockSize << " threads per block ]" << std::endl;
+
+    status = test(false);
+    if (status) {
+        std::cerr << "Test failed\n" << std::endl;
+        return -1;
+    }
+
+    std::cout << std::endl;
+
+    std::cout << "[ Automatic, occupancy-based configuration ]" << std::endl;
+    status = test(true);
+    if (status) {
+        std::cerr << "Test failed\n" << std::endl;
+        return -1;
+    }
+
+    std::cout << std::endl;
+    std::cout << "Test PASSED\n" << std::endl;
+
+    return 0;
+}