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/3_CUDA_Features/cdpSimpleQuicksort/.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/3_CUDA_Features/cdpSimpleQuicksort/.vscode/extensions.json

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

cpp/3_CUDA_Features/cdpSimpleQuicksort/CMakeLists.txt

@@ -0,0 +1,43 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../../cmake/Modules")
+
+project(cdpSimpleQuicksort LANGUAGES C CXX CUDA)
+
+find_package(CUDAToolkit REQUIRED)
+
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+# The aarch64/sbsa_aarch64 CUDA toolkit are support on Tegra since 13.0, so need to check which version of the toolkit is installed
+string(FIND "${CUDAToolkit_INCLUDE_DIRS}" "aarch64-linux" _aarch64_linux_ctk)
+string(FIND "${CUDAToolkit_INCLUDE_DIRS}" "aarch64-qnx" _aarch64_qnx_ctk)
+if(CMAKE_SYSTEM_PROCESSOR STREQUAL "aarch64" AND (NOT _aarch64_linux_ctk EQUAL -1 OR NOT _aarch64_qnx_ctk EQUAL -1))
+    set(CMAKE_CUDA_ARCHITECTURES 87 110)
+else()
+    set(CMAKE_CUDA_ARCHITECTURES 75 80 86 89 90 100 110 120)
+endif()
+
+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 cdpSimpleQuicksort
+add_executable(cdpSimpleQuicksort cdpSimpleQuicksort.cu)
+
+target_compile_options(cdpSimpleQuicksort PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(cdpSimpleQuicksort PRIVATE cxx_std_17 cuda_std_17)
+
+set_target_properties(cdpSimpleQuicksort PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
+
+# Include installation configuration
+include(${CMAKE_CURRENT_SOURCE_DIR}/../../../cmake/InstallSamples.cmake)
+setup_samples_install()

cpp/3_CUDA_Features/cdpSimpleQuicksort/README.md

@@ -0,0 +1,34 @@
+# cdpSimpleQuicksort - Simple Quicksort (CUDA Dynamic Parallelism)
+
+## Description
+
+This sample demonstrates simple quicksort implemented using CUDA Dynamic Parallelism.  This sample requires devices with compute capability 3.5 or higher.
+
+## Key Concepts
+
+CUDA Dynamic Parallelism
+
+## Supported SM Architectures
+
+## 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)
+cudaStreamCreateWithFlags, cudaMemcpy, cudaStreamDestroy, cudaFree, cudaDeviceSynchronize, cudaDeviceSetLimit, cudaMalloc, cudaGetDeviceProperties
+
+## Dependencies needed to build/run
+[CDP](../../../README.md#cuda-dynamic-parallellism)
+
+## Prerequisites
+
+Download and install the [CUDA Toolkit](https://developer.nvidia.com/cuda-downloads) for your corresponding platform.
+Make sure the dependencies mentioned in [Dependencies]() section above are installed.
+
+## References (for more details)

cpp/3_CUDA_Features/cdpSimpleQuicksort/cdpSimpleQuicksort.cu

@@ -0,0 +1,245 @@
+/* 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 <cstdio>
+#include <helper_cuda.h>
+#include <helper_string.h>
+#include <iostream>
+
+#define MAX_DEPTH      16
+#define INSERTION_SORT 32
+
+////////////////////////////////////////////////////////////////////////////////
+// Selection sort used when depth gets too big or the number of elements drops
+// below a threshold.
+////////////////////////////////////////////////////////////////////////////////
+__device__ void selection_sort(unsigned int *data, int left, int right)
+{
+    for (int i = left; i <= right; ++i) {
+        unsigned min_val = data[i];
+        int      min_idx = i;
+
+        // Find the smallest value in the range [left, right].
+        for (int j = i + 1; j <= right; ++j) {
+            unsigned val_j = data[j];
+
+            if (val_j < min_val) {
+                min_idx = j;
+                min_val = val_j;
+            }
+        }
+
+        // Swap the values.
+        if (i != min_idx) {
+            data[min_idx] = data[i];
+            data[i]       = min_val;
+        }
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Very basic quicksort algorithm, recursively launching the next level.
+////////////////////////////////////////////////////////////////////////////////
+__global__ void cdp_simple_quicksort(unsigned int *data, int left, int right, int depth)
+{
+    // If we're too deep or there are few elements left, we use an insertion
+    // sort...
+    if (depth >= MAX_DEPTH || right - left <= INSERTION_SORT) {
+        selection_sort(data, left, right);
+        return;
+    }
+
+    unsigned int *lptr  = data + left;
+    unsigned int *rptr  = data + right;
+    unsigned int  pivot = data[(left + right) / 2];
+
+    // Do the partitioning.
+    while (lptr <= rptr) {
+        // Find the next left- and right-hand values to swap
+        unsigned int lval = *lptr;
+        unsigned int rval = *rptr;
+
+        // Move the left pointer as long as the pointed element is smaller than the
+        // pivot.
+        while (lval < pivot) {
+            lptr++;
+            lval = *lptr;
+        }
+
+        // Move the right pointer as long as the pointed element is larger than the
+        // pivot.
+        while (rval > pivot) {
+            rptr--;
+            rval = *rptr;
+        }
+
+        // If the swap points are valid, do the swap!
+        if (lptr <= rptr) {
+            *lptr++ = rval;
+            *rptr-- = lval;
+        }
+    }
+
+    // Now the recursive part
+    int nright = rptr - data;
+    int nleft  = lptr - data;
+
+    // Launch a new block to sort the left part.
+    if (left < (rptr - data)) {
+        cudaStream_t s;
+        cudaStreamCreateWithFlags(&s, cudaStreamNonBlocking);
+        cdp_simple_quicksort<<<1, 1, 0, s>>>(data, left, nright, depth + 1);
+        cudaStreamDestroy(s);
+    }
+
+    // Launch a new block to sort the right part.
+    if ((lptr - data) < right) {
+        cudaStream_t s1;
+        cudaStreamCreateWithFlags(&s1, cudaStreamNonBlocking);
+        cdp_simple_quicksort<<<1, 1, 0, s1>>>(data, nleft, right, depth + 1);
+        cudaStreamDestroy(s1);
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Call the quicksort kernel from the host.
+////////////////////////////////////////////////////////////////////////////////
+void run_qsort(unsigned int *data, unsigned int nitems)
+{
+    // Prepare CDP for the max depth 'MAX_DEPTH'.
+
+    // Launch on device
+    int left  = 0;
+    int right = nitems - 1;
+    std::cout << "Launching kernel on the GPU" << std::endl;
+    cdp_simple_quicksort<<<1, 1>>>(data, left, right, 0);
+    checkCudaErrors(cudaDeviceSynchronize());
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Initialize data on the host.
+////////////////////////////////////////////////////////////////////////////////
+void initialize_data(unsigned int *dst, unsigned int nitems)
+{
+    // Fixed seed for illustration
+    srand(2047);
+
+    // Fill dst with random values
+    for (unsigned i = 0; i < nitems; i++)
+        dst[i] = rand() % nitems;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Verify the results.
+////////////////////////////////////////////////////////////////////////////////
+void check_results(int n, unsigned int *results_d)
+{
+    unsigned int *results_h = new unsigned[n];
+    checkCudaErrors(cudaMemcpy(results_h, results_d, n * sizeof(unsigned), cudaMemcpyDeviceToHost));
+
+    for (int i = 1; i < n; ++i)
+        if (results_h[i - 1] > results_h[i]) {
+            std::cout << "Invalid item[" << i - 1 << "]: " << results_h[i - 1] << " greater than " << results_h[i]
+                      << std::endl;
+            exit(EXIT_FAILURE);
+        }
+
+    std::cout << "OK" << std::endl;
+    delete[] results_h;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Main entry point.
+////////////////////////////////////////////////////////////////////////////////
+int main(int argc, char **argv)
+{
+    int  num_items = 128;
+    bool verbose   = false;
+
+    if (checkCmdLineFlag(argc, (const char **)argv, "help") || checkCmdLineFlag(argc, (const char **)argv, "h")) {
+        std::cerr << "Usage: " << argv[0]
+                  << " num_items=<num_items>\twhere num_items is the number of "
+                     "items to sort"
+                  << std::endl;
+        exit(EXIT_SUCCESS);
+    }
+
+    if (checkCmdLineFlag(argc, (const char **)argv, "v")) {
+        verbose = true;
+    }
+
+    if (checkCmdLineFlag(argc, (const char **)argv, "num_items")) {
+        num_items = getCmdLineArgumentInt(argc, (const char **)argv, "num_items");
+
+        if (num_items < 1) {
+            std::cerr << "ERROR: num_items has to be greater than 1" << std::endl;
+            exit(EXIT_FAILURE);
+        }
+    }
+
+    // Find/set device and get device properties
+    int            device = -1;
+    cudaDeviceProp deviceProp;
+    device = findCudaDevice(argc, (const char **)argv);
+    checkCudaErrors(cudaGetDeviceProperties(&deviceProp, device));
+
+    if (!(deviceProp.major > 3 || (deviceProp.major == 3 && deviceProp.minor >= 5))) {
+        printf("GPU %d - %s  does not support CUDA Dynamic Parallelism\n Exiting.", device, deviceProp.name);
+        exit(EXIT_WAIVED);
+    }
+
+    // Create input data
+    unsigned int *h_data = 0;
+    unsigned int *d_data = 0;
+
+    // Allocate CPU memory and initialize data.
+    std::cout << "Initializing data:" << std::endl;
+    h_data = (unsigned int *)malloc(num_items * sizeof(unsigned int));
+    initialize_data(h_data, num_items);
+
+    if (verbose) {
+        for (int i = 0; i < num_items; i++)
+            std::cout << "Data [" << i << "]: " << h_data[i] << std::endl;
+    }
+
+    // Allocate GPU memory.
+    checkCudaErrors(cudaMalloc((void **)&d_data, num_items * sizeof(unsigned int)));
+    checkCudaErrors(cudaMemcpy(d_data, h_data, num_items * sizeof(unsigned int), cudaMemcpyHostToDevice));
+
+    // Execute
+    std::cout << "Running quicksort on " << num_items << " elements" << std::endl;
+    run_qsort(d_data, num_items);
+
+    // Check result
+    std::cout << "Validating results: ";
+    check_results(num_items, d_data);
+
+    free(h_data);
+    checkCudaErrors(cudaFree(d_data));
+
+    exit(EXIT_SUCCESS);
+}