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/asyncAPI/.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/asyncAPI/.vscode/extensions.json

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

cpp/0_Introduction/asyncAPI/CMakeLists.txt

@@ -0,0 +1,34 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../../cmake/Modules")
+
+project(asyncAPI 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 asyncAPI
+add_executable(asyncAPI asyncAPI.cu)
+
+target_compile_options(asyncAPI PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(asyncAPI PRIVATE cxx_std_17 cuda_std_17)
+
+set_target_properties(asyncAPI PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
+
+# Include installation configuration
+include(${CMAKE_CURRENT_SOURCE_DIR}/../../../cmake/InstallSamples.cmake)
+setup_samples_install()

cpp/0_Introduction/asyncAPI/README.md

@@ -0,0 +1,32 @@
+# asyncAPI - asyncAPI
+
+## Description
+
+This sample illustrates the usage of CUDA events for both GPU timing and overlapping CPU and GPU execution. Events are inserted into a stream of CUDA calls. Since CUDA stream calls are asynchronous, the CPU can perform computations while GPU is executing (including DMA memcopies between the host and device). CPU can query CUDA events to determine whether GPU has completed tasks.
+
+## Key Concepts
+
+Asynchronous Data Transfers, CUDA Streams and Events
+
+## 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)
+cudaProfilerStop, cudaMalloc, cudaMemcpyAsync, cudaFree, cudaMallocHost, cudaProfilerStart, cudaDeviceSynchronize, cudaEventRecord, cudaFreeHost, cudaMemset, cudaEventDestroy, cudaEventQuery, cudaEventElapsedTime, cudaGetDeviceProperties, 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/asyncAPI/asyncAPI.cu

@@ -0,0 +1,144 @@
+/* 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.
+ */
+
+/*
+ * This sample illustrates the usage of CUDA events for both GPU timing and
+ * overlapping CPU and GPU execution.  Events are inserted into a stream
+ * of CUDA calls.  Since CUDA stream calls are asynchronous, the CPU can
+ * perform computations while GPU is executing (including DMA memcopies
+ * between the host and device).  CPU can query CUDA events to determine
+ * whether GPU has completed tasks.
+ */
+
+// includes, system
+#include <stdio.h>
+
+// includes CUDA Runtime
+#include <cuda_profiler_api.h>
+#include <cuda_runtime.h>
+
+// includes, project
+#include <helper_cuda.h>
+#include <helper_functions.h> // helper utility functions
+
+__global__ void increment_kernel(int *g_data, int inc_value)
+{
+    int idx     = blockIdx.x * blockDim.x + threadIdx.x;
+    g_data[idx] = g_data[idx] + inc_value;
+}
+
+bool correct_output(int *data, const int n, const int x)
+{
+    for (int i = 0; i < n; i++)
+        if (data[i] != x) {
+            printf("Error! data[%d] = %d, ref = %d\n", i, data[i], x);
+            return false;
+        }
+
+    return true;
+}
+
+int main(int argc, char *argv[])
+{
+    int            devID;
+    cudaDeviceProp deviceProps;
+
+    printf("[%s] - Starting...\n", argv[0]);
+
+    // This will pick the best possible CUDA capable device
+    devID = findCudaDevice(argc, (const char **)argv);
+
+    // get device name
+    checkCudaErrors(cudaGetDeviceProperties(&deviceProps, devID));
+    printf("CUDA device [%s]\n", deviceProps.name);
+
+    int n      = 16 * 1024 * 1024;
+    int nbytes = n * sizeof(int);
+    int value  = 26;
+
+    // allocate host memory
+    int *a = 0;
+    checkCudaErrors(cudaMallocHost((void **)&a, nbytes));
+    memset(a, 0, nbytes);
+
+    // allocate device memory
+    int *d_a = 0;
+    checkCudaErrors(cudaMalloc((void **)&d_a, nbytes));
+    checkCudaErrors(cudaMemset(d_a, 255, nbytes));
+
+    // set kernel launch configuration
+    dim3 threads = dim3(512, 1);
+    dim3 blocks  = dim3(n / threads.x, 1);
+
+    // create cuda event handles
+    cudaEvent_t start, stop;
+    checkCudaErrors(cudaEventCreate(&start));
+    checkCudaErrors(cudaEventCreate(&stop));
+
+    StopWatchInterface *timer = NULL;
+    sdkCreateTimer(&timer);
+    sdkResetTimer(&timer);
+
+    checkCudaErrors(cudaDeviceSynchronize());
+    float gpu_time = 0.0f;
+
+    // asynchronously issue work to the GPU (all to stream 0)
+    checkCudaErrors(cudaProfilerStart());
+    sdkStartTimer(&timer);
+    cudaEventRecord(start, 0);
+    cudaMemcpyAsync(d_a, a, nbytes, cudaMemcpyHostToDevice, 0);
+    increment_kernel<<<blocks, threads, 0, 0>>>(d_a, value);
+    cudaMemcpyAsync(a, d_a, nbytes, cudaMemcpyDeviceToHost, 0);
+    cudaEventRecord(stop, 0);
+    sdkStopTimer(&timer);
+    checkCudaErrors(cudaProfilerStop());
+
+    // have CPU do some work while waiting for stage 1 to finish
+    unsigned long int counter = 0;
+
+    while (cudaEventQuery(stop) == cudaErrorNotReady) {
+        counter++;
+    }
+
+    checkCudaErrors(cudaEventElapsedTime(&gpu_time, start, stop));
+
+    // print the cpu and gpu times
+    printf("time spent executing by the GPU: %.2f\n", gpu_time);
+    printf("time spent by CPU in CUDA calls: %.2f\n", sdkGetTimerValue(&timer));
+    printf("CPU executed %lu iterations while waiting for GPU to finish\n", counter);
+
+    // check the output for correctness
+    bool bFinalResults = correct_output(a, n, value);
+
+    // release resources
+    checkCudaErrors(cudaEventDestroy(start));
+    checkCudaErrors(cudaEventDestroy(stop));
+    checkCudaErrors(cudaFreeHost(a));
+    checkCudaErrors(cudaFree(d_a));
+
+    exit(bFinalResults ? EXIT_SUCCESS : EXIT_FAILURE);
+}