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/2_Concepts_and_Techniques/CMakeLists.txt

@@ -0,0 +1,32 @@
+add_subdirectory(EGLStream_CUDA_CrossGPU)
+add_subdirectory(EGLStream_CUDA_Interop)
+add_subdirectory(FunctionPointers)
+add_subdirectory(MC_EstimatePiInlineP)
+add_subdirectory(MC_EstimatePiInlineQ)
+add_subdirectory(MC_EstimatePiP)
+add_subdirectory(MC_EstimatePiQ)
+add_subdirectory(MC_SingleAsianOptionP)
+add_subdirectory(boxFilter)
+add_subdirectory(convolutionSeparable)
+add_subdirectory(convolutionTexture)
+add_subdirectory(dct8x8)
+add_subdirectory(eigenvalues)
+add_subdirectory(histogram)
+add_subdirectory(imageDenoising)
+add_subdirectory(inlinePTX)
+add_subdirectory(inlinePTX_nvrtc)
+add_subdirectory(interval)
+add_subdirectory(particles)
+add_subdirectory(radixSortThrust)
+add_subdirectory(reduction)
+add_subdirectory(reductionMultiBlockCG)
+add_subdirectory(scalarProd)
+add_subdirectory(scan)
+add_subdirectory(segmentationTreeThrust)
+add_subdirectory(shfl_scan)
+add_subdirectory(sortingNetworks)
+add_subdirectory(streamOrderedAllocation)
+add_subdirectory(streamOrderedAllocationIPC)
+add_subdirectory(streamOrderedAllocationP2P)
+add_subdirectory(threadFenceReduction)
+add_subdirectory(threadMigration)

cpp/2_Concepts_and_Techniques/EGLStream_CUDA_CrossGPU/.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/2_Concepts_and_Techniques/EGLStream_CUDA_CrossGPU/.vscode/extensions.json

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

cpp/2_Concepts_and_Techniques/EGLStream_CUDA_CrossGPU/CMakeLists.txt

@@ -0,0 +1,54 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../../cmake/Modules")
+
+project(EGLStream_CUDA_CrossGPU 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)
+
+find_package(EGL)
+
+if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+    # Source file
+    if(${EGL_FOUND})
+            # Add target for EGLStream_CUDA_CrossGPU
+            add_executable(EGLStream_CUDA_CrossGPU cuda_consumer.cpp cuda_producer.cpp eglstrm_common.cpp kernel.cu main.cpp)
+
+            target_compile_options(EGLStream_CUDA_CrossGPU PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+            target_compile_features(EGLStream_CUDA_CrossGPU PRIVATE cxx_std_17 cuda_std_17)
+
+            set_target_properties(EGLStream_CUDA_CrossGPU PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
+
+            target_include_directories(EGLStream_CUDA_CrossGPU PUBLIC
+                ${EGL_INCLUDE_DIR}
+                ${CUDAToolkit_INCLUDE_DIRS}
+            )
+
+            target_link_libraries(EGLStream_CUDA_CrossGPU
+                ${EGL_LIBRARY}
+                CUDA::cuda_driver
+            )
+    else()
+        message(STATUS "EGL not found - will not build sample 'EGLStream_CUDA_CrossGPU'")
+    endif()
+else()
+    message(STATUS "Will not build sample EGLStream_CUDA_CrossGPU - requires Linux OS")
+endif()
+
+# Include installation configuration
+include(${CMAKE_CURRENT_SOURCE_DIR}/../../../cmake/InstallSamples.cmake)
+setup_samples_install()

cpp/2_Concepts_and_Techniques/EGLStream_CUDA_CrossGPU/README.md

@@ -0,0 +1,39 @@
+# EGLStream_CUDA_CrossGPU - EGLStream_CUDA_CrossGPU
+
+## Description
+
+Demonstrates CUDA and EGL Streams interop, where consumer's EGL Stream is on one GPU and producer's on other and both consumer-producer are different processes.
+
+## Key Concepts
+
+EGLStreams Interop
+
+## 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
+
+## Supported CPU Architecture
+
+x86_64, armv7l
+
+## CUDA APIs involved
+
+### [CUDA Driver API](http://docs.nvidia.com/cuda/cuda-driver-api/index.html)
+cuDeviceGetName, cuEGLStreamConsumerReleaseFrame, cuEGLStreamConsumerConnect, cuEGLStreamConsumerDisconnect, cuCtxPushCurrent, cuEGLStreamProducerReturnFrame, cuStreamCreate, cuEGLStreamProducerPresentFrame, cuMemFree, cuGraphicsResourceGetMappedEglFrame, cuInit, cuMemcpyHtoD, cuDeviceGet, cuEGLStreamConsumerAcquireFrame, cuEGLStreamProducerDisconnect, cuEGLStreamProducerConnect, cuDeviceGetAttribute, cuCtxSynchronize, cuMemAlloc, cuCtxPopCurrent, cuCtxCreate
+
+### [CUDA Runtime API](http://docs.nvidia.com/cuda/cuda-runtime-api/index.html)
+cudaMemcpy, cudaMalloc, cudaProducerPresentFrame, cudaFree, cudaGetErrorString, cudaConsumerReleaseFrame, cudaProducerReturnFrame, cudaDeviceSynchronize, cudaDeviceCreateProducer, cudaProducerDeinit, cudaProducerPrepareFrame, cudaGetValueMismatch, cudaConsumerAcquireFrame, cudaProducerInit, cudaDeviceCreateConsumer
+
+## Dependencies needed to build/run
+[EGL](../../../README.md#egl)
+
+## 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/2_Concepts_and_Techniques/EGLStream_CUDA_CrossGPU/cuda_consumer.cpp

@@ -0,0 +1,265 @@
+/* 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.
+ */
+
+//
+// DESCRIPTION:   Simple CUDA consumer rendering sample app
+//
+
+#include "cuda_consumer.h"
+
+#include <cuda_runtime.h>
+#include <math.h>
+#include <unistd.h>
+
+#include "eglstrm_common.h"
+
+#if defined(EXTENSION_LIST)
+EXTENSION_LIST(EXTLST_EXTERN)
+#endif
+CUgraphicsResource cudaResource;
+
+static int    count_acq           = 0;
+static double acquire_time[25000] = {0}, total_time_acq = 0;
+
+static int    count_rel       = 0;
+static double rel_time[25000] = {0}, total_time_rel = 0;
+
+void acquireApiStat(void);
+void acquireApiStat(void)
+{
+    int    i   = 0;
+    double min = 10000000, max = 0;
+    double average_launch_time = 0, standard_deviation = 0;
+    if (count_acq == 0)
+        return;
+    // lets compute the standard deviation
+    min = max           = acquire_time[1];
+    average_launch_time = (total_time_acq - acquire_time[0]) / count_acq;
+    for (i = 1; i < count_acq; i++) {
+        standard_deviation += (acquire_time[i] - average_launch_time) * (acquire_time[i] - average_launch_time);
+        if (acquire_time[i] < min)
+            min = acquire_time[i];
+        if (acquire_time[i] > max)
+            max = acquire_time[i];
+    }
+    standard_deviation = sqrt(standard_deviation / count_acq);
+    printf("acquire Avg: %lf\n", average_launch_time);
+    printf("acquire  SD: %lf\n", standard_deviation);
+    printf("acquire min: %lf\n", min);
+    printf("acquire max: %lf\n", max);
+
+    min = max           = rel_time[1];
+    average_launch_time = (total_time_rel - rel_time[0]) / count_rel;
+    for (i = 1; i < count_rel; i++) {
+        standard_deviation += (rel_time[i] - average_launch_time) * (rel_time[i] - average_launch_time);
+        if (rel_time[i] < min)
+            min = rel_time[i];
+        if (rel_time[i] > max)
+            max = rel_time[i];
+    }
+    standard_deviation = sqrt(standard_deviation / count_rel);
+    printf("release Avg: %lf\n", average_launch_time);
+    printf("release  SD: %lf\n", standard_deviation);
+    printf("release min: %lf\n", min);
+    printf("release max: %lf\n", max);
+}
+CUresult cudaConsumerAcquireFrame(test_cuda_consumer_s *cudaConsumer, int frameNumber)
+{
+    CUresult        cuStatus = CUDA_SUCCESS;
+    CUeglFrame      cudaEgl;
+    struct timespec start, end;
+    EGLint          streamState = 0;
+    double          curTime;
+
+    if (!cudaConsumer) {
+        printf("%s: Bad parameter\n", __func__);
+        goto done;
+    }
+
+    while (1) {
+        if (!eglQueryStreamKHR(cudaConsumer->eglDisplay, cudaConsumer->eglStream, EGL_STREAM_STATE_KHR, &streamState)) {
+            printf("Cuda Consumer: eglQueryStreamKHR EGL_STREAM_STATE_KHR failed\n");
+            cuStatus = CUDA_ERROR_UNKNOWN;
+            goto done;
+        }
+        if (streamState == EGL_STREAM_STATE_DISCONNECTED_KHR) {
+            printf("Cuda Consumer: EGL_STREAM_STATE_DISCONNECTED_KHR received\n");
+            cuStatus = CUDA_ERROR_UNKNOWN;
+            goto done;
+        }
+
+        if (streamState == EGL_STREAM_STATE_NEW_FRAME_AVAILABLE_KHR) {
+            break;
+        }
+    }
+    if (cudaConsumer->profileAPI) {
+        getTime(&start);
+    }
+    cuStatus =
+        cuEGLStreamConsumerAcquireFrame(&(cudaConsumer->cudaConn), &cudaResource, &cudaConsumer->consCudaStream, 16000);
+    if (cudaConsumer->profileAPI) {
+        getTime(&end);
+        curTime                   = TIME_DIFF(end, start);
+        acquire_time[count_acq++] = curTime;
+        if (count_acq == 25000)
+            count_acq = 0;
+        total_time_acq += curTime;
+    }
+    if (cuStatus == CUDA_SUCCESS) {
+        CUdeviceptr pDevPtr = 0;
+        cudaError_t err;
+
+        cuStatus = cuGraphicsResourceGetMappedEglFrame(&cudaEgl, cudaResource, 0, 0);
+        if (cuStatus != CUDA_SUCCESS) {
+            printf("Cuda get resource failed with %d\n", cuStatus);
+            goto done;
+        }
+        pDevPtr = (CUdeviceptr)cudaEgl.frame.pPitch[0];
+
+        err = cudaConsumer_filter(cudaConsumer->consCudaStream,
+                                  (char *)pDevPtr,
+                                  WIDTH * 4,
+                                  HEIGHT,
+                                  PROD_DATA + frameNumber,
+                                  CONS_DATA + frameNumber,
+                                  frameNumber);
+        if (err != cudaSuccess) {
+            printf("Cuda Consumer: kernel failed with: %s\n", cudaGetErrorString(err));
+            goto done;
+        }
+    }
+
+done:
+    return cuStatus;
+}
+
+CUresult cudaConsumerReleaseFrame(test_cuda_consumer_s *cudaConsumer, int frameNumber)
+{
+    CUresult        cuStatus = CUDA_SUCCESS;
+    struct timespec start, end;
+    double          curTime;
+
+    if (!cudaConsumer) {
+        printf("%s: Bad parameter\n", __func__);
+        goto done;
+    }
+    if (cudaConsumer->profileAPI) {
+        getTime(&start);
+    }
+    cuStatus = cuEGLStreamConsumerReleaseFrame(&cudaConsumer->cudaConn, cudaResource, &cudaConsumer->consCudaStream);
+    if (cudaConsumer->profileAPI) {
+        getTime(&end);
+        curTime               = TIME_DIFF(end, start);
+        rel_time[count_rel++] = curTime;
+        if (count_rel == 25000)
+            count_rel = 0;
+        total_time_rel += curTime;
+    }
+    if (cuStatus != CUDA_SUCCESS) {
+        printf("cuEGLStreamConsumerReleaseFrame failed, status:%d\n", cuStatus);
+        goto done;
+    }
+
+done:
+    return cuStatus;
+}
+
+CUresult cudaDeviceCreateConsumer(test_cuda_consumer_s *cudaConsumer)
+{
+    CUdevice          device;
+    CUresult          status          = CUDA_SUCCESS;
+    CUctxCreateParams ctxCreateParams = {};
+
+    if (CUDA_SUCCESS != (status = cuInit(0))) {
+        printf("Failed to initialize CUDA\n");
+        return status;
+    }
+
+    if (CUDA_SUCCESS != (status = cuDeviceGet(&device, cudaConsumer->cudaDevId))) {
+        printf("failed to get CUDA device\n");
+        return status;
+    }
+
+    if (CUDA_SUCCESS != (status = cuCtxCreate(&cudaConsumer->context, &ctxCreateParams, 0, device))) {
+        printf("failed to create CUDA context\n");
+        return status;
+    }
+
+    int  major = 0, minor = 0;
+    char deviceName[256];
+    cuDeviceGetAttribute(&major, CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR, device);
+    cuDeviceGetAttribute(&minor, CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR, device);
+    cuDeviceGetName(deviceName, 256, device);
+    printf("CUDA Consumer on GPU Device %d: \"%s\" with compute capability "
+           "%d.%d\n\n",
+           device,
+           deviceName,
+           major,
+           minor);
+
+    cuCtxPopCurrent(&cudaConsumer->context);
+    if (major < 6) {
+        printf("EGLStream_CUDA_CrossGPU requires SM 6.0 or higher arch GPU.  "
+               "Exiting...\n");
+        exit(2); // EXIT_WAIVED
+    }
+
+    return status;
+}
+
+CUresult cuda_consumer_init(test_cuda_consumer_s *cudaConsumer, TestArgs *args)
+{
+    CUresult status = CUDA_SUCCESS;
+    int      bufferSize;
+
+    cudaConsumer->charCnt = args->charCnt;
+    bufferSize            = args->charCnt;
+
+    cudaConsumer->pCudaCopyMem = (unsigned char *)malloc(bufferSize);
+    if (cudaConsumer->pCudaCopyMem == NULL) {
+        printf("Cuda Consumer: malloc failed\n");
+        goto done;
+    }
+
+    status = cuStreamCreate(&cudaConsumer->consCudaStream, 0);
+    if (status != CUDA_SUCCESS) {
+        printf("Cuda Consumer: cuStreamCreate failed, status:%d\n", status);
+        goto done;
+    }
+
+    atexit(acquireApiStat);
+done:
+    return status;
+}
+
+CUresult cuda_consumer_Deinit(test_cuda_consumer_s *cudaConsumer)
+{
+    if (cudaConsumer->pCudaCopyMem) {
+        free(cudaConsumer->pCudaCopyMem);
+    }
+    return cuEGLStreamConsumerDisconnect(&cudaConsumer->cudaConn);
+}

cpp/2_Concepts_and_Techniques/EGLStream_CUDA_CrossGPU/cuda_consumer.h

@@ -0,0 +1,72 @@
+/* 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.
+ */
+
+//
+// DESCRIPTION:   CUDA consumer header file
+//
+
+#ifndef _CUDA_CONSUMER_H_
+#define _CUDA_CONSUMER_H_
+
+#include <cuda.h>
+#include <cuda_runtime.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "cudaEGL.h"
+#include "eglstrm_common.h"
+
+typedef struct _test_cuda_consumer_s
+{
+    CUcontext             context;
+    CUeglStreamConnection cudaConn;
+    int                   cudaDevId;
+    EGLDisplay            eglDisplay;
+    EGLStreamKHR          eglStream;
+    unsigned int          charCnt;
+    char                 *cudaBuf;
+    bool                  profileAPI;
+    unsigned char        *pCudaCopyMem;
+    CUstream              consCudaStream;
+} test_cuda_consumer_s;
+
+CUresult    cuda_consumer_init(test_cuda_consumer_s *cudaConsumer, TestArgs *args);
+CUresult    cuda_consumer_Deinit(test_cuda_consumer_s *cudaConsumer);
+CUresult    cudaConsumerAcquireFrame(test_cuda_consumer_s *data, int frameNumber);
+CUresult    cudaConsumerReleaseFrame(test_cuda_consumer_s *data, int frameNumber);
+CUresult    cudaDeviceCreateConsumer(test_cuda_consumer_s *cudaConsumer);
+cudaError_t cudaConsumer_filter(CUstream cStream,
+                                char    *pSrc,
+                                int      width,
+                                int      height,
+                                char     expectedVal,
+                                char     newVal,
+                                int      frameNumber);
+cudaError_t cudaGetValueMismatch(void);
+
+#endif

cpp/2_Concepts_and_Techniques/EGLStream_CUDA_CrossGPU/cuda_producer.cpp

@@ -0,0 +1,294 @@
+/* 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.
+ */
+
+//
+// DESCRIPTION:   Simple cuda EGL stream producer app
+//
+
+#include "cuda_producer.h"
+
+#include <cuda_runtime.h>
+
+#include "cudaEGL.h"
+#include "eglstrm_common.h"
+#if defined(EXTENSION_LIST)
+EXTENSION_LIST(EXTLST_EXTERN)
+#endif
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "cuda_runtime.h"
+#include "math.h"
+
+int         cudaPresentReturnData = INIT_DATA;
+int         fakePresent           = 0;
+CUeglFrame  fakeFrame;
+CUdeviceptr cudaPtrFake;
+extern bool isCrossDevice;
+
+void cudaProducerPrepareFrame(CUeglFrame *cudaEgl, CUdeviceptr cudaPtr, int bufferSize)
+{
+    cudaEgl->frame.pPitch[0] = (void *)cudaPtr;
+    cudaEgl->width           = WIDTH;
+    cudaEgl->depth           = 0;
+    cudaEgl->height          = HEIGHT;
+    cudaEgl->pitch           = WIDTH * 4;
+    cudaEgl->frameType       = CU_EGL_FRAME_TYPE_PITCH;
+    cudaEgl->planeCount      = 1;
+    cudaEgl->numChannels     = 4;
+    cudaEgl->eglColorFormat  = CU_EGL_COLOR_FORMAT_ARGB;
+    cudaEgl->cuFormat        = CU_AD_FORMAT_UNSIGNED_INT8;
+}
+
+static int    count_present = 0, count_return = 0;
+static double present_time[25000] = {0}, total_time_present = 0;
+static double return_time[25000] = {0}, total_time_return = 0;
+
+void presentApiStat(void);
+void presentApiStat(void)
+{
+    int    i   = 0;
+    double min = 10000000, max = 0;
+    double average_launch_time = 0, standard_deviation = 0;
+    if (count_present == 0)
+        return;
+    // lets compute the standard deviation
+    min = max           = present_time[1];
+    average_launch_time = (total_time_present) / count_present;
+    for (i = 1; i < count_present; i++) {
+        standard_deviation += (present_time[i] - average_launch_time) * (present_time[i] - average_launch_time);
+        if (present_time[i] < min)
+            min = present_time[i];
+        if (present_time[i] > max)
+            max = present_time[i];
+    }
+    standard_deviation = sqrt(standard_deviation / count_present);
+    printf("present Avg: %lf\n", average_launch_time);
+    printf("present  SD: %lf\n", standard_deviation);
+    printf("present min: %lf\n", min);
+    printf("present max: %lf\n", max);
+
+    min = max           = return_time[1];
+    average_launch_time = (total_time_return - return_time[0]) / count_return;
+    for (i = 1; i < count_return; i++) {
+        standard_deviation += (return_time[i] - average_launch_time) * (return_time[i] - average_launch_time);
+        if (return_time[i] < min)
+            min = return_time[i];
+        if (return_time[i] > max)
+            max = return_time[i];
+    }
+    standard_deviation = sqrt(standard_deviation / count_return);
+    printf("return  Avg: %lf\n", average_launch_time);
+    printf("return   SD: %lf\n", standard_deviation);
+    printf("return  min: %lf\n", min);
+    printf("return  max: %lf\n", max);
+}
+CUresult cudaProducerPresentFrame(test_cuda_producer_s *cudaProducer, CUeglFrame cudaEgl, int t)
+{
+    static int      flag   = 0;
+    CUresult        status = CUDA_SUCCESS;
+    struct timespec start, end;
+    double          curTime;
+    CUdeviceptr     pDevPtr = (CUdeviceptr)cudaEgl.frame.pPitch[0];
+    cudaProducer_filter(
+        cudaProducer->prodCudaStream, (char *)pDevPtr, WIDTH * 4, HEIGHT, cudaPresentReturnData, PROD_DATA + t, t);
+    if (cudaProducer->profileAPI) {
+        getTime(&start);
+    }
+    status = cuEGLStreamProducerPresentFrame(&cudaProducer->cudaConn, cudaEgl, &cudaProducer->prodCudaStream);
+    if (status != CUDA_SUCCESS) {
+        printf("Cuda Producer: Present frame failed, status:%d\n", status);
+        goto done;
+    }
+    flag++;
+    if (cudaProducer->profileAPI && flag > 10) {
+        getTime(&end);
+        curTime                       = TIME_DIFF(end, start);
+        present_time[count_present++] = curTime;
+        if (count_present == 25000)
+            count_present = 0;
+        total_time_present += curTime;
+    }
+done:
+    return status;
+}
+
+int      flag = 0;
+CUresult cudaProducerReturnFrame(test_cuda_producer_s *cudaProducer, CUeglFrame cudaEgl, int t)
+{
+    CUresult        status = CUDA_SUCCESS;
+    struct timespec start, end;
+    double          curTime;
+    CUdeviceptr     pDevPtr = 0;
+
+    pDevPtr = (CUdeviceptr)cudaEgl.frame.pPitch[0];
+    if (cudaProducer->profileAPI) {
+        getTime(&start);
+    }
+
+    while (1) {
+        status = cuEGLStreamProducerReturnFrame(&cudaProducer->cudaConn, &cudaEgl, &cudaProducer->prodCudaStream);
+        if (status == CUDA_ERROR_LAUNCH_TIMEOUT) {
+            continue;
+        }
+        else if (status != CUDA_SUCCESS) {
+            printf("Cuda Producer: Return frame failed, status:%d\n", status);
+            goto done;
+        }
+        break;
+    }
+    if (cudaProducer->profileAPI) {
+        getTime(&end);
+        curTime                     = TIME_DIFF(end, start);
+        return_time[count_return++] = curTime;
+        if (count_return == 25000)
+            count_return = 0;
+        total_time_return += curTime;
+    }
+    if (flag % 2 == 0) {
+        cudaPresentReturnData++;
+    }
+    cudaProducer_filter(
+        cudaProducer->prodCudaStream, (char *)pDevPtr, WIDTH * 4, HEIGHT, CONS_DATA + t, cudaPresentReturnData, t);
+    flag++;
+done:
+    return status;
+}
+
+CUresult cudaDeviceCreateProducer(test_cuda_producer_s *cudaProducer)
+{
+    CUdevice          device;
+    CUresult          status          = CUDA_SUCCESS;
+    CUctxCreateParams ctxCreateParams = {};
+
+    if (CUDA_SUCCESS != (status = cuInit(0))) {
+        printf("Failed to initialize CUDA\n");
+        return status;
+    }
+
+    if (CUDA_SUCCESS != (status = cuDeviceGet(&device, cudaProducer->cudaDevId))) {
+        printf("failed to get CUDA device\n");
+        return status;
+    }
+
+    if (CUDA_SUCCESS != (status = cuCtxCreate(&cudaProducer->context, &ctxCreateParams, 0, device))) {
+        printf("failed to create CUDA context\n");
+        return status;
+    }
+
+    int  major = 0, minor = 0;
+    char deviceName[256];
+    cuDeviceGetAttribute(&major, CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR, device);
+    cuDeviceGetAttribute(&minor, CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR, device);
+    cuDeviceGetName(deviceName, 256, device);
+    printf("CUDA Producer on GPU Device %d: \"%s\" with compute capability "
+           "%d.%d\n\n",
+           device,
+           deviceName,
+           major,
+           minor);
+
+    cuCtxPopCurrent(&cudaProducer->context);
+
+    if (major < 6) {
+        printf("EGLStream_CUDA_CrossGPU requires SM 6.0 or higher arch GPU.  "
+               "Exiting...\n");
+        exit(2); // EXIT_WAIVED
+    }
+
+    return status;
+}
+
+CUresult cudaProducerInit(test_cuda_producer_s *cudaProducer, TestArgs *args)
+{
+    CUresult status = CUDA_SUCCESS;
+    int      bufferSize;
+
+    cudaProducer->charCnt = args->charCnt;
+    bufferSize            = cudaProducer->charCnt;
+
+    cudaProducer->tempBuff = (char *)malloc(bufferSize);
+    if (!cudaProducer->tempBuff) {
+        printf("Cuda Producer: Failed to allocate image buffer\n");
+        status = CUDA_ERROR_UNKNOWN;
+        goto done;
+    }
+    memset((void *)cudaProducer->tempBuff, INIT_DATA, cudaProducer->charCnt);
+
+    // Fill this init data
+    status = cuMemAlloc(&cudaProducer->cudaPtr, bufferSize);
+    if (status != CUDA_SUCCESS) {
+        printf("Cuda Producer: cuda Malloc failed, status:%d\n", status);
+        goto done;
+    }
+    status = cuMemcpyHtoD(cudaProducer->cudaPtr, (void *)(cudaProducer->tempBuff), bufferSize);
+    if (status != CUDA_SUCCESS) {
+        printf("Cuda Producer: cuMemCpy failed, status:%d\n", status);
+        goto done;
+    }
+
+    // Fill this init data
+    status = cuMemAlloc(&cudaProducer->cudaPtr1, bufferSize);
+    if (status != CUDA_SUCCESS) {
+        printf("Cuda Producer: cuda Malloc failed, status:%d\n", status);
+        goto done;
+    }
+    status = cuMemcpyHtoD(cudaProducer->cudaPtr1, (void *)(cudaProducer->tempBuff), bufferSize);
+    if (status != CUDA_SUCCESS) {
+        printf("Cuda Producer: cuMemCpy failed, status:%d\n", status);
+        goto done;
+    }
+
+    status = cuStreamCreate(&cudaProducer->prodCudaStream, 0);
+    if (status != CUDA_SUCCESS) {
+        printf("Cuda Producer: cuStreamCreate failed, status:%d\n", status);
+        goto done;
+    }
+
+    // Fill this init data
+    status = cuMemAlloc(&cudaPtrFake, 100);
+    if (status != CUDA_SUCCESS) {
+        printf("Cuda Producer: cuda Malloc failed, status:%d\n", status);
+        goto done;
+    }
+
+    atexit(presentApiStat);
+done:
+    return status;
+}
+
+CUresult cudaProducerDeinit(test_cuda_producer_s *cudaProducer)
+{
+    if (cudaProducer->tempBuff) {
+        free(cudaProducer->tempBuff);
+    }
+    if (cudaProducer->cudaPtr) {
+        cuMemFree(cudaProducer->cudaPtr);
+    }
+    return cuEGLStreamProducerDisconnect(&cudaProducer->cudaConn);
+}

cpp/2_Concepts_and_Techniques/EGLStream_CUDA_CrossGPU/cuda_producer.h

@@ -0,0 +1,71 @@
+/* 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.
+ */
+
+//
+// DESCRIPTION:   Simple cuda producer header file
+//
+
+#ifndef _CUDA_PRODUCER_H_
+#define _CUDA_PRODUCER_H_
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+#include <cuda.h>
+#include <cuda_runtime.h>
+
+#include "cudaEGL.h"
+#include "eglstrm_common.h"
+
+typedef struct _test_cuda_producer_s
+{
+    //  Stream params
+    CUcontext             context;
+    CUeglStreamConnection cudaConn;
+    int                   cudaDevId;
+    EGLStreamKHR          eglStream;
+    EGLDisplay            eglDisplay;
+    unsigned int          charCnt;
+    bool                  profileAPI;
+    char                 *tempBuff;
+    CUdeviceptr           cudaPtr;
+    CUdeviceptr           cudaPtr1;
+    CUstream              prodCudaStream;
+} test_cuda_producer_s;
+
+CUresult    cudaProducerInit(test_cuda_producer_s *cudaProducer, TestArgs *args);
+CUresult    cudaProducerPresentFrame(test_cuda_producer_s *parserArg, CUeglFrame cudaEgl, int t);
+CUresult    cudaProducerReturnFrame(test_cuda_producer_s *parserArg, CUeglFrame cudaEgl, int t);
+CUresult    cudaProducerDeinit(test_cuda_producer_s *cudaProducer);
+CUresult    cudaDeviceCreateProducer(test_cuda_producer_s *cudaProducer);
+cudaError_t cudaProducer_filter(CUstream cStream,
+                                char    *pSrc,
+                                int      width,
+                                int      height,
+                                char     expectedVal,
+                                char     newVal,
+                                int      frameNumber);
+void        cudaProducerPrepareFrame(CUeglFrame *cudaEgl, CUdeviceptr cudaPtr, int bufferSize);
+#endif

cpp/2_Concepts_and_Techniques/EGLStream_CUDA_CrossGPU/eglstrm_common.cpp

@@ -0,0 +1,424 @@
+/* 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.
+ */
+
+//
+// DESCRIPTION:   Common egl stream functions
+//
+
+#include "eglstrm_common.h"
+
+EGLStreamKHR g_producerEglStream  = EGL_NO_STREAM_KHR;
+EGLStreamKHR g_consumerEglStream  = EGL_NO_STREAM_KHR;
+EGLDisplay   g_producerEglDisplay = EGL_NO_DISPLAY;
+EGLDisplay   g_consumerEglDisplay = EGL_NO_DISPLAY;
+int          cudaDevIndexProd     = -1;
+int          cudaDevIndexCons     = -1;
+
+#if defined(EXTENSION_LIST)
+EXTENSION_LIST(EXTLST_DECL)
+typedef void (*extlst_fnptr_t)(void);
+static struct
+{
+    extlst_fnptr_t *fnptr;
+    char const     *name;
+    bool            is_dgpu; // This function is need only for dgpu case
+} extensionList[] = {EXTENSION_LIST(EXTLST_ENTRY)};
+
+int eglSetupExtensions(bool isCrossDevice)
+{
+    unsigned int i;
+
+    for (i = 0; i < (sizeof(extensionList) / sizeof(*extensionList)); i++) {
+        // load the dgpu function only if we are running cross device test
+        if ((!extensionList[i].is_dgpu) || (extensionList[i].is_dgpu == isCrossDevice)) {
+            *extensionList[i].fnptr = eglGetProcAddress(extensionList[i].name);
+            if (*extensionList[i].fnptr == NULL) {
+                printf("Couldn't get address of %s()\n", extensionList[i].name);
+                return 0;
+            }
+        }
+    }
+
+    return 1;
+}
+
+int EGLStreamInit(bool isCrossDevice, int isConsumer, EGLNativeFileDescriptorKHR fileDesc)
+{
+    static const EGLint streamAttrFIFOMode[] = {
+        EGL_STREAM_FIFO_LENGTH_KHR, 5, EGL_SUPPORT_REUSE_NV, EGL_FALSE, EGL_NONE};
+    EGLDisplay   eglDisplay[2] = {0};
+    EGLStreamKHR eglStream[2]  = {0};
+    EGLBoolean   eglStatus;
+
+#define MAX_EGL_DEVICES 4
+
+    EGLDeviceEXT devices[MAX_EGL_DEVICES];
+    EGLint       numDevices = 0;
+
+    eglStatus = eglQueryDevicesEXT(MAX_EGL_DEVICES, devices, &numDevices);
+    if (eglStatus != EGL_TRUE) {
+        printf("Error querying EGL devices\n");
+        goto Done;
+    }
+
+    if (numDevices == 0) {
+        printf("No EGL devices found\n");
+        eglStatus = EGL_FALSE;
+        goto Done;
+    }
+
+    // If cross device, create discrete GPU stream first and then create the
+    // integrated GPU stream to connect to it via fd. The other way round fails
+    // in producer connect.
+    //
+    // TODO: Find out if this EGL behavior is by design.
+    if (isConsumer) {
+        int egl_device_id = 0;
+        for (egl_device_id = 0; egl_device_id < numDevices; egl_device_id++) {
+            EGLAttrib cuda_device;
+            eglStatus = eglQueryDeviceAttribEXT(devices[egl_device_id], EGL_CUDA_DEVICE_NV, &cuda_device);
+            if (eglStatus == EGL_TRUE) {
+                cudaDevIndexCons = cuda_device; // We select first EGL-CUDA Capable
+                                                // device for consumer.
+                printf("Found EGL-CUDA Capable device with CUDA Device id = %d out of "
+                       "egl_device_id = %d\n",
+                       (int)cudaDevIndexCons,
+                       egl_device_id);
+                break;
+            }
+        }
+
+        if (egl_device_id >= numDevices) {
+            printf("No CUDA Capable EGL Device found.. Waiving execution\n");
+            goto Done;
+        }
+
+        g_consumerEglDisplay = eglGetPlatformDisplayEXT(EGL_PLATFORM_DEVICE_EXT, (void *)devices[egl_device_id], NULL);
+        if (g_consumerEglDisplay == EGL_NO_DISPLAY) {
+            printf("Could not get EGL display from device. \n");
+            eglStatus = EGL_FALSE;
+            goto Done;
+        }
+
+        eglStatus = eglInitialize(g_consumerEglDisplay, 0, 0);
+        if (!eglStatus) {
+            printf("EGL failed to initialize. \n");
+            eglStatus = EGL_FALSE;
+            goto Done;
+        }
+
+        g_consumerEglStream = eglCreateStreamKHR(g_consumerEglDisplay, streamAttrFIFOMode);
+        if (g_consumerEglStream == EGL_NO_STREAM_KHR) {
+            printf("Could not create EGL stream.\n");
+            eglStatus = EGL_FALSE;
+            goto Done;
+        }
+
+        eglStatus = eglStreamAttribKHR(g_consumerEglDisplay, g_consumerEglStream, EGL_CONSUMER_LATENCY_USEC_KHR, 16000);
+        if (eglStatus != EGL_TRUE) {
+            printf("eglStreamAttribKHR EGL_CONSUMER_LATENCY_USEC_KHR failed\n");
+            goto Done;
+        }
+
+        eglStatus =
+            eglStreamAttribKHR(g_consumerEglDisplay, g_consumerEglStream, EGL_CONSUMER_ACQUIRE_TIMEOUT_USEC_KHR, 16000);
+        if (eglStatus != EGL_TRUE) {
+            printf("eglStreamAttribKHR EGL_CONSUMER_ACQUIRE_TIMEOUT_USEC_KHR failed\n");
+            goto Done;
+        }
+    }
+
+    if (!isConsumer) { // Producer
+
+        if (fileDesc == EGL_NO_FILE_DESCRIPTOR_KHR) {
+            printf("Cuda Producer received bad file descriptor\n");
+            eglStatus = EGL_FALSE;
+            goto Done;
+        }
+
+        int egl_device_id    = 0;
+        int egl_cuda_devices = 0;
+        for (egl_device_id = 0; egl_device_id < numDevices; egl_device_id++) {
+            EGLAttrib cuda_device = -1;
+            eglStatus             = eglQueryDeviceAttribEXT(devices[egl_device_id], EGL_CUDA_DEVICE_NV, &cuda_device);
+            if (eglStatus == EGL_TRUE) {
+                egl_cuda_devices++;
+                if (isCrossDevice && (egl_cuda_devices > 1)) {
+                    // We select second EGL-CUDA Capable device for producer.
+                    cudaDevIndexProd = (int)cuda_device;
+                    printf("Found EGL-CUDA Capable device with CUDA Device id = %d "
+                           "egl_device_id = %d \n",
+                           (int)cudaDevIndexProd,
+                           egl_device_id);
+                    break;
+                }
+                if (!isCrossDevice) {
+                    // We select first EGL-CUDA Capable device for producer same as
+                    // consumer.
+                    cudaDevIndexProd = (int)cuda_device;
+                    printf("Found EGL-CUDA Capable device with CUDA Device id = %d "
+                           "egl_device_id = %d \n",
+                           (int)cudaDevIndexProd,
+                           egl_device_id);
+                    break;
+                }
+            }
+        }
+
+        if (egl_device_id >= numDevices) {
+            printf("No CUDA Capable EGL Device found.. Waiving execution\n");
+            goto Done;
+        }
+
+        g_producerEglDisplay = eglGetPlatformDisplayEXT(EGL_PLATFORM_DEVICE_EXT, (void *)devices[egl_device_id], NULL);
+        if (g_producerEglDisplay == EGL_NO_DISPLAY) {
+            printf("Could not get EGL display from device. \n");
+            eglStatus = EGL_FALSE;
+            goto Done;
+        }
+
+        eglStatus = eglInitialize(g_producerEglDisplay, 0, 0);
+        if (!eglStatus) {
+            printf("EGL failed to initialize. \n");
+            eglStatus = EGL_FALSE;
+            goto Done;
+        }
+
+        g_producerEglStream = eglCreateStreamFromFileDescriptorKHR(g_producerEglDisplay, fileDesc);
+        close(fileDesc);
+
+        if (g_producerEglStream == EGL_NO_STREAM_KHR) {
+            printf("CUDA Producer Could not create EGL stream.\n");
+            eglStatus = EGL_FALSE;
+            goto Done;
+        }
+        else {
+            printf("Producer created EGLStream for the GPU.\n");
+        }
+    }
+
+Done:
+    return eglStatus == EGL_TRUE ? 1 : 0;
+}
+
+void EGLStreamFini(void)
+{
+    if (g_producerEglStream != EGL_NO_STREAM_KHR) {
+        eglDestroyStreamKHR(g_producerEglDisplay, g_producerEglStream);
+    }
+    if (g_consumerEglStream != g_producerEglStream) {
+        if (g_consumerEglStream != EGL_NO_STREAM_KHR) {
+            eglDestroyStreamKHR(g_consumerEglDisplay, g_consumerEglStream);
+        }
+    }
+}
+
+int UnixSocketConnect(const char *socket_name)
+{
+    int                sock_fd = -1;
+    struct sockaddr_un sock_addr;
+    int                wait_loop = 0;
+
+    sock_fd = socket(PF_UNIX, SOCK_STREAM, 0);
+    if (sock_fd < 0) {
+        printf("%s: socket create failed.\n", __func__);
+        return -1;
+    }
+
+    if (verbose)
+        printf("%s: send_fd: sock_fd: %d\n", __func__, sock_fd);
+
+    memset(&sock_addr, 0, sizeof(struct sockaddr_un));
+    sock_addr.sun_family = AF_UNIX;
+    strncpy(sock_addr.sun_path, socket_name, sizeof(sock_addr.sun_path) - 1);
+
+    while (connect(sock_fd, (const struct sockaddr *)&sock_addr, sizeof(struct sockaddr_un))) {
+        if (wait_loop < 60) {
+            if (!wait_loop)
+                printf("Waiting for EGL stream producer ");
+            else
+                printf(".");
+            fflush(stdout);
+            sleep(1);
+            wait_loop++;
+        }
+        else {
+            printf("\n%s: Waiting timed out\n", __func__);
+            return -1;
+        }
+    }
+    if (wait_loop)
+        printf("\n");
+
+    if (verbose)
+        printf("%s: Wait is done\n", __func__);
+
+    return sock_fd;
+}
+
+/* Send <fd_to_send> (a file descriptor) to another process */
+/* over a unix domain socket named <socket_name>.           */
+/* <socket_name> can be any nonexistant filename.           */
+int EGLStreamSendfd(int send_fd, int fd_to_send)
+{
+    struct msghdr   msg;
+    struct iovec    iov[1];
+    char            ctrl_buf[CMSG_SPACE(sizeof(int))];
+    struct cmsghdr *cmsg = NULL;
+    void           *data;
+    int             res;
+    memset(&msg, 0, sizeof(msg));
+
+    iov[0].iov_len  = 1;           // must send at least 1 byte
+    iov[0].iov_base = (void *)"x"; // any byte value (value ignored)
+    msg.msg_iov     = iov;
+    msg.msg_iovlen  = 1;
+
+    memset(ctrl_buf, 0, sizeof(ctrl_buf));
+    msg.msg_control    = ctrl_buf;
+    msg.msg_controllen = sizeof(ctrl_buf);
+
+    cmsg             = CMSG_FIRSTHDR(&msg);
+    cmsg->cmsg_level = SOL_SOCKET;
+    cmsg->cmsg_type  = SCM_RIGHTS;
+    cmsg->cmsg_len   = CMSG_LEN(sizeof(int));
+    data             = CMSG_DATA(cmsg);
+    *(int *)data     = fd_to_send;
+
+    msg.msg_controllen = cmsg->cmsg_len;
+
+    res = sendmsg(send_fd, &msg, 0);
+    if (res <= 0) {
+        printf("%s: sendmsg failed", __func__);
+        return -1;
+    }
+
+    return 0;
+}
+
+/* Listen on a unix domain socket named <socket_name>.     */
+/* Connect to it and return connect_fd                     */
+int UnixSocketCreate(const char *socket_name)
+{
+    int                listen_fd;
+    struct sockaddr_un sock_addr;
+    int                connect_fd;
+    struct sockaddr_un connect_addr;
+    socklen_t          connect_addr_len = 0;
+
+    listen_fd = socket(PF_UNIX, SOCK_STREAM, 0);
+    if (listen_fd < 0) {
+        printf("%s: socket create failed", __func__);
+        return -1;
+    }
+
+    if (verbose)
+        printf("%s: listen_fd: %d\n", __func__, listen_fd);
+
+    unlink(socket_name);
+
+    memset(&sock_addr, 0, sizeof(struct sockaddr_un));
+    sock_addr.sun_family = AF_UNIX;
+    strncpy(sock_addr.sun_path, socket_name, sizeof(sock_addr.sun_path) - 1);
+
+    if (bind(listen_fd, (const struct sockaddr *)&sock_addr, sizeof(struct sockaddr_un))) {
+        printf("i%s: bind error", __func__);
+        return -1;
+    }
+
+    if (listen(listen_fd, 1)) {
+        printf("%s: listen error", __func__);
+        return -1;
+    }
+
+    connect_fd = accept(listen_fd, (struct sockaddr *)&connect_addr, &connect_addr_len);
+
+    if (verbose)
+        printf("%s: connect_fd: %d\n", __func__, connect_fd);
+
+    close(listen_fd);
+    unlink(socket_name);
+    if (connect_fd < 0) {
+        printf("%s: accept failed\n", __func__);
+        return -1;
+    }
+
+    return connect_fd;
+}
+
+/* receive a file descriptor from another process.         */
+/* Returns the file descriptor.  Note: the integer value   */
+/* of the file descriptor may be different from the        */
+/* integer value in the other process, but the file        */
+/* descriptors in each process will refer to the same file */
+/* object in the kernel.                                   */
+int EGLStreamReceivefd(int connect_fd)
+{
+    struct msghdr   msg;
+    struct iovec    iov[1];
+    char            msg_buf[1];
+    char            ctrl_buf[CMSG_SPACE(sizeof(int))];
+    struct cmsghdr *cmsg;
+    void           *data;
+    int             recvfd;
+
+    memset(&msg, 0, sizeof(msg));
+
+    iov[0].iov_base = msg_buf;
+    iov[0].iov_len  = sizeof(msg_buf);
+    msg.msg_iov     = iov;
+    msg.msg_iovlen  = 1;
+
+    msg.msg_control    = ctrl_buf;
+    msg.msg_controllen = sizeof(ctrl_buf);
+
+    if (recvmsg(connect_fd, &msg, 0) <= 0) {
+        printf("%s: recvmsg failed", __func__);
+        return -1;
+    }
+
+    cmsg = CMSG_FIRSTHDR(&msg);
+    if (!cmsg) {
+        printf("%s: NULL message header\n", __func__);
+        return -1;
+    }
+    if (cmsg->cmsg_level != SOL_SOCKET) {
+        printf("%s: Message level is not SOL_SOCKET\n", __func__);
+        return -1;
+    }
+    if (cmsg->cmsg_type != SCM_RIGHTS) {
+        printf("%s: Message type is not SCM_RIGHTS\n", __func__);
+        return -1;
+    }
+
+    data   = CMSG_DATA(cmsg);
+    recvfd = *(int *)data;
+
+    return recvfd;
+}
+
+#endif

cpp/2_Concepts_and_Techniques/EGLStream_CUDA_CrossGPU/eglstrm_common.h

@@ -0,0 +1,109 @@
+/* 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.
+ */
+
+//
+// DESCRIPTION:   Common EGL stream functions header file
+//
+
+#ifndef _EGLSTRM_COMMON_H_
+#define _EGLSTRM_COMMON_H_
+
+#include <signal.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/un.h>
+#include <time.h>
+#include <unistd.h>
+
+#include "cuda.h"
+#include "cudaEGL.h"
+#define TIME_DIFF(end, start) (getMicrosecond(end) - getMicrosecond(start))
+
+extern EGLStreamKHR g_producerEglStream;
+extern EGLStreamKHR g_consumerEglStream;
+extern EGLDisplay   g_producerEglDisplay;
+extern EGLDisplay   g_consumerEglDisplay;
+extern int          cudaDevIndexCons;
+extern int          cudaDevIndexProd;
+extern bool         verbose;
+
+#define EXTENSION_LIST(T)                                                                  \
+    T(PFNEGLCREATESTREAMKHRPROC, eglCreateStreamKHR)                                       \
+    T(PFNEGLDESTROYSTREAMKHRPROC, eglDestroyStreamKHR)                                     \
+    T(PFNEGLQUERYSTREAMKHRPROC, eglQueryStreamKHR)                                         \
+    T(PFNEGLQUERYSTREAMU64KHRPROC, eglQueryStreamu64KHR)                                   \
+    T(PFNEGLQUERYSTREAMTIMEKHRPROC, eglQueryStreamTimeKHR)                                 \
+    T(PFNEGLSTREAMATTRIBKHRPROC, eglStreamAttribKHR)                                       \
+    T(PFNEGLSTREAMCONSUMERACQUIREKHRPROC, eglStreamConsumerAcquireKHR)                     \
+    T(PFNEGLSTREAMCONSUMERRELEASEKHRPROC, eglStreamConsumerReleaseKHR)                     \
+    T(PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALKHRPROC, eglStreamConsumerGLTextureExternalKHR) \
+    T(PFNEGLQUERYDEVICESEXTPROC, eglQueryDevicesEXT)                                       \
+    T(PFNEGLGETPLATFORMDISPLAYEXTPROC, eglGetPlatformDisplayEXT)                           \
+    T(PFNEGLGETSTREAMFILEDESCRIPTORKHRPROC, eglGetStreamFileDescriptorKHR)                 \
+    T(PFNEGLQUERYDEVICEATTRIBEXTPROC, eglQueryDeviceAttribEXT)                             \
+    T(PFNEGLCREATESTREAMFROMFILEDESCRIPTORKHRPROC, eglCreateStreamFromFileDescriptorKHR)
+
+#define EXTLST_DECL(tx, x)   tx x = NULL;
+#define EXTLST_EXTERN(tx, x) extern tx x;
+#define EXTLST_ENTRY(tx, x)  {(extlst_fnptr_t *)&x, #x},
+
+#define MAX_STRING_SIZE 256
+#define INIT_DATA       0x01
+#define PROD_DATA       0x07
+#define CONS_DATA       0x04
+
+#define SOCK_PATH "/tmp/tegra_sw_egl_socket"
+
+typedef struct _TestArgs
+{
+    unsigned int charCnt;
+    bool         isProducer;
+} TestArgs;
+
+extern int WIDTH, HEIGHT;
+
+int  eglSetupExtensions(bool is_dgpu);
+int  EGLStreamInit(bool isCrossDevice, int isConsumer, EGLNativeFileDescriptorKHR fileDesc);
+void EGLStreamFini(void);
+
+int EGLStreamSetAttr(EGLDisplay display, EGLStreamKHR eglStream);
+int UnixSocketConnect(const char *socket_name);
+int EGLStreamSendfd(int send_fd, int fd_to_send);
+int UnixSocketCreate(const char *socket_name);
+int EGLStreamReceivefd(int connect_fd);
+
+static clockid_t clock_id = CLOCK_MONOTONIC; // CLOCK_PROCESS_CPUTIME_ID;
+static double    getMicrosecond(struct timespec t) { return ((t.tv_sec) * 1000000.0 + (t.tv_nsec) / 1.0e3); }
+
+static inline void getTime(struct timespec *t) { clock_gettime(clock_id, t); }
+#endif

cpp/2_Concepts_and_Techniques/EGLStream_CUDA_CrossGPU/helper.h

@@ -0,0 +1,228 @@
+/* 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 "eglstrm_common.h"
+#if defined(EXTENSION_LIST)
+EXTENSION_LIST(EXTLST_EXTERN)
+#endif
+#include <cuda.h>
+
+int  parseCmdLine(int argc, char *argv[], TestArgs *args);
+void printUsage(void);
+int  NUMTRIALS   = 10;
+int  profileAPIs = 0;
+
+bool verbose       = 0;
+bool isCrossDevice = 0;
+
+// Parse the command line options. Returns FAILURE on a parse error, SUCCESS
+// otherwise.
+int parseCmdLine(int argc, char *argv[], TestArgs *args)
+{
+    int i;
+
+    for (i = 1; i < argc; i++) {
+        if (strcmp(argv[i], "-h") == 0) {
+            printUsage();
+            exit(0);
+        }
+        else if (strcmp(argv[i], "-n") == 0) {
+            ++i;
+            if (sscanf(argv[i], "%d", &NUMTRIALS) != 1 || NUMTRIALS <= 0) {
+                printf("Invalid trial count: %s should be > 0\n", argv[i]);
+                return -1;
+            }
+        }
+        else if (strcmp(argv[i], "-profile") == 0) {
+            profileAPIs = 1;
+        }
+        else if (strcmp(argv[i], "-crossdev") == 0) {
+            isCrossDevice = 1;
+        }
+        else if (strcmp(argv[i], "-width") == 0) {
+            ++i;
+            if (sscanf(argv[i], "%d", &WIDTH) != 1 || (WIDTH <= 0)) {
+                printf("Width should be greater than 0\n");
+                return -1;
+            }
+        }
+        else if (strcmp(argv[i], "-height") == 0) {
+            ++i;
+            if (sscanf(argv[i], "%d", &HEIGHT) != 1 || (HEIGHT <= 0)) {
+                printf("Width should be greater than 0\n");
+                return -1;
+            }
+        }
+        else if (0 == strcmp(&argv[i][1], "proctype")) {
+            ++i;
+            if (!strcasecmp(argv[i], "prod")) {
+                args->isProducer = 1;
+            }
+            else if (!strcasecmp(argv[i], "cons")) {
+                args->isProducer = 0;
+            }
+            else {
+                printf("%s: Bad Process Type: %s\n", __func__, argv[i]);
+                return 1;
+            }
+        }
+        else if (strcmp(argv[i], "-v") == 0) {
+            verbose = 1;
+        }
+        else {
+            printf("Unknown option: %s\n", argv[i]);
+            return -1;
+        }
+    }
+
+    if (isCrossDevice) {
+        int deviceCount = 0;
+
+        CUresult error_id = cuInit(0);
+        if (error_id != CUDA_SUCCESS) {
+            printf("cuInit(0) returned %d\n", error_id);
+            printf("Result = FAIL\n");
+            exit(EXIT_FAILURE);
+        }
+
+        error_id = cuDeviceGetCount(&deviceCount);
+        if (error_id != CUDA_SUCCESS) {
+            printf("cuDeviceGetCount returned %d\n", (int)error_id);
+            printf("Result = FAIL\n");
+            exit(EXIT_FAILURE);
+        }
+
+        int      iGPUexists = 0;
+        CUdevice dev;
+        for (dev = 0; dev < deviceCount; ++dev) {
+            int      integrated   = 0;
+            CUresult error_result = cuDeviceGetAttribute(&integrated, CU_DEVICE_ATTRIBUTE_INTEGRATED, dev);
+
+            if (error_result != CUDA_SUCCESS) {
+                printf("cuDeviceGetAttribute returned error : %d\n", (int)error_result);
+                exit(EXIT_FAILURE);
+            }
+
+            if (integrated) {
+                iGPUexists = 1;
+            }
+        }
+
+        if (!iGPUexists) {
+            printf("No Integrated GPU found in the system.\n");
+            printf("-crossdev option is only supported on systems with an Integrated "
+                   "GPU and a Discrete GPU\n");
+            printf("Waiving the execution\n");
+            exit(EXIT_SUCCESS);
+        }
+    }
+
+    if (!eglSetupExtensions(isCrossDevice)) {
+        printf("SetupExtentions failed \n");
+        exit(EXIT_FAILURE);
+    }
+#define MAX_EGL_DEVICES 4
+    EGLDeviceEXT devices[MAX_EGL_DEVICES];
+    EGLint       numDevices = 0;
+    EGLBoolean   eglStatus  = eglQueryDevicesEXT(MAX_EGL_DEVICES, devices, &numDevices);
+    if (eglStatus != EGL_TRUE) {
+        printf("Error querying EGL devices\n");
+        exit(EXIT_FAILURE);
+    }
+
+    if (numDevices == 0) {
+        printf("No EGL devices found\n");
+        eglStatus = EGL_FALSE;
+        exit(2); // EXIT_WAIVED
+    }
+
+    int egl_device_id = 0;
+    for (egl_device_id = 0; egl_device_id < numDevices; egl_device_id++) {
+        EGLAttrib cuda_device;
+        eglStatus = eglQueryDeviceAttribEXT(devices[egl_device_id], EGL_CUDA_DEVICE_NV, &cuda_device);
+        if (eglStatus == EGL_TRUE) {
+            break;
+        }
+    }
+
+    if (egl_device_id >= numDevices) {
+        printf("No CUDA Capable EGL Device found.. Waiving execution\n");
+        exit(2); // EXIT_WAIVED
+    }
+
+    if (isCrossDevice) {
+        if (numDevices == 1) {
+            printf("Found only one EGL device, cannot setup cross GPU streams. "
+                   "Waiving\n");
+            eglStatus = EGL_FALSE;
+            exit(2); // EXIT_WAIVED
+        }
+    }
+
+    return 0;
+}
+
+void launchProducer(TestArgs *args)
+{
+    /* Cross-process creation of producer */
+    char argsProducer[1024];
+    char str[256];
+
+    strcpy(argsProducer, "./EGLStream_CUDA_CrossGPU -proctype prod ");
+
+    if (isCrossDevice) {
+        sprintf(str, "-crossdev ");
+        strcat(argsProducer, str);
+    }
+
+    if (verbose) {
+        sprintf(str, "-v ");
+        strcat(argsProducer, str);
+    }
+
+    /*Make the process run in bg*/
+    strcat(argsProducer, "& ");
+
+    printf("\n%s: Crossproc Producer command: %s \n", __func__, argsProducer);
+
+    /*Create crossproc Producer*/
+    system(argsProducer);
+
+    /*Enable crossproc Consumer in the same process */
+    args->isProducer = 0;
+}
+
+void printUsage(void)
+{
+    printf("Usage:\n");
+    printf("  -h           Print this help message\n");
+    printf("  -n n         Exit after running n trials. Set to 10 by default\n");
+    printf("  -profile     Profile time taken by ReleaseAPI. Not set by default\n");
+    printf("  -crossdev    Run with producer on idgpu and consumer on dgpu\n");
+    printf("  -dgpu        (same as -crossdev, deprecated)\n");
+    printf("  -v           verbose output\n");
+}

cpp/2_Concepts_and_Techniques/EGLStream_CUDA_CrossGPU/kernel.cu

@@ -0,0 +1,150 @@
+/* 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.
+ */
+
+//
+// DESCRIPTION:   Simple CUDA consumer rendering sample app
+//
+
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+#include <cuda.h>
+#include <cuda_runtime.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "eglstrm_common.h"
+
+extern bool isCrossDevice;
+
+__device__ static unsigned int numErrors = 0, errorFound = 0;
+__device__ void                checkProducerDataGPU(char *data, int size, char expectedVal, int frameNumber)
+{
+    if ((data[blockDim.x * blockIdx.x + threadIdx.x] != expectedVal) && (!errorFound)) {
+        printf("Producer FOUND:%d expected: %d at %d for trial %d %d\n",
+               data[blockDim.x * blockIdx.x + threadIdx.x],
+               expectedVal,
+               (blockDim.x * blockIdx.x + threadIdx.x),
+               frameNumber,
+               numErrors);
+        numErrors++;
+        errorFound = 1;
+        return;
+    }
+}
+
+__device__ void checkConsumerDataGPU(char *data, int size, char expectedVal, int frameNumber)
+{
+    if ((data[blockDim.x * blockIdx.x + threadIdx.x] != expectedVal) && (!errorFound)) {
+        printf("Consumer FOUND:%d expected: %d at %d for trial %d %d\n",
+               data[blockDim.x * blockIdx.x + threadIdx.x],
+               expectedVal,
+               (blockDim.x * blockIdx.x + threadIdx.x),
+               frameNumber,
+               numErrors);
+        numErrors++;
+        errorFound = 1;
+        return;
+    }
+}
+
+__global__ void writeDataToBuffer(char *pSrc, char newVal) { pSrc[blockDim.x * blockIdx.x + threadIdx.x] = newVal; }
+
+__global__ void testKernelConsumer(char *pSrc, char size, char expectedVal, char newVal, int frameNumber)
+{
+    checkConsumerDataGPU(pSrc, size, expectedVal, frameNumber);
+}
+
+__global__ void testKernelProducer(char *pSrc, char size, char expectedVal, char newVal, int frameNumber)
+{
+    checkProducerDataGPU(pSrc, size, expectedVal, frameNumber);
+}
+__global__ void getNumErrors(int *numErr) { *numErr = numErrors; }
+
+cudaError_t cudaProducer_filter(cudaStream_t pStream,
+                                char        *pSrc,
+                                int          width,
+                                int          height,
+                                char         expectedVal,
+                                char         newVal,
+                                int          frameNumber)
+{
+    // in case where consumer is on dgpu and producer is on igpu when return is
+    // called the frame is not copied back to igpu. So the consumer changes is not
+    // visible to producer
+    if (isCrossDevice == 0) {
+        testKernelProducer<<<(width * height) / 1024, 1024, 1, pStream>>>(
+            pSrc, width * height, expectedVal, newVal, frameNumber);
+    }
+    writeDataToBuffer<<<(width * height) / 1024, 1024, 1, pStream>>>(pSrc, newVal);
+    return cudaSuccess;
+};
+
+cudaError_t cudaConsumer_filter(cudaStream_t cStream,
+                                char        *pSrc,
+                                int          width,
+                                int          height,
+                                char         expectedVal,
+                                char         newVal,
+                                int          frameNumber)
+{
+    testKernelConsumer<<<(width * height) / 1024, 1024, 1, cStream>>>(
+        pSrc, width * height, expectedVal, newVal, frameNumber);
+    writeDataToBuffer<<<(width * height) / 1024, 1024, 1, cStream>>>(pSrc, newVal);
+    return cudaSuccess;
+};
+
+cudaError_t cudaGetValueMismatch()
+{
+    int         numErr_h;
+    int        *numErr_d = NULL;
+    cudaError_t err      = cudaSuccess;
+    err                  = cudaMalloc(&numErr_d, sizeof(int));
+    if (err != cudaSuccess) {
+        printf("Cuda Main: cudaMalloc failed with %s\n", cudaGetErrorString(err));
+        return err;
+    }
+    getNumErrors<<<1, 1>>>(numErr_d);
+    err = cudaDeviceSynchronize();
+    if (err != cudaSuccess) {
+        printf("Cuda Main: cudaDeviceSynchronize failed with %s\n", cudaGetErrorString(err));
+    }
+    err = cudaMemcpy(&numErr_h, numErr_d, sizeof(int), cudaMemcpyDeviceToHost);
+    if (err != cudaSuccess) {
+        printf("Cuda Main: cudaMemcpy failed with %s\n", cudaGetErrorString(err));
+        cudaFree(numErr_d);
+        return err;
+    }
+    err = cudaFree(numErr_d);
+    if (err != cudaSuccess) {
+        printf("Cuda Main: cudaFree failed with %s\n", cudaGetErrorString(err));
+        return err;
+    }
+    if (numErr_h > 0) {
+        return cudaErrorUnknown;
+    }
+    return cudaSuccess;
+}

cpp/2_Concepts_and_Techniques/EGLStream_CUDA_CrossGPU/main.cpp

@@ -0,0 +1,378 @@
+/* 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 "cudaEGL.h"
+#include "cuda_consumer.h"
+#include "cuda_producer.h"
+#include "eglstrm_common.h"
+#include "helper.h"
+#if defined(EXTENSION_LIST)
+EXTENSION_LIST(EXTLST_EXTERN)
+#endif
+
+bool        signal_stop = 0;
+extern bool verbose;
+
+static void sig_handler(int sig)
+{
+    signal_stop = 1;
+    printf("Signal: %d\n", sig);
+}
+
+void DoneCons(int consumerStatus, int send_fd)
+{
+    EGLStreamFini();
+    // get the final status from producer, combine and print
+    int producerStatus = -1;
+    if (-1 == recv(send_fd, (void *)&producerStatus, sizeof(int), 0)) {
+        printf("%s: Cuda Consumer could not receive status from producer.\n", __func__);
+    }
+    close(send_fd);
+
+    if (producerStatus == 0 && consumerStatus == 0) {
+        printf("&&&& EGLStream_CUDA_CrossGPU PASSED\n");
+        exit(EXIT_SUCCESS);
+    }
+    else {
+        printf("&&&& EGLStream_CUDA_CrossGPU FAILED\n");
+        exit(EXIT_FAILURE);
+    }
+}
+
+void DoneProd(int producerStatus, int connect_fd)
+{
+    EGLStreamFini();
+    if (-1 == send(connect_fd, (void *)&producerStatus, sizeof(int), 0)) {
+        printf("%s: Cuda Producer could not send status to consumer.\n", __func__);
+    }
+    close(connect_fd);
+    if (producerStatus == 0) {
+        exit(EXIT_SUCCESS);
+    }
+    else {
+        exit(EXIT_FAILURE);
+    }
+}
+
+int WIDTH = 8192, HEIGHT = 8192;
+int main(int argc, char **argv)
+{
+    TestArgs                   args           = {0, false};
+    CUresult                   curesult       = CUDA_SUCCESS;
+    unsigned int               j              = 0;
+    cudaError_t                err            = cudaSuccess;
+    EGLNativeFileDescriptorKHR fileDescriptor = EGL_NO_FILE_DESCRIPTOR_KHR;
+    struct timespec            start, end;
+    CUeglFrame                 cudaEgl1, cudaEgl2;
+    int                        consumerStatus = 0;
+    int                        send_fd        = -1;
+
+    if (parseCmdLine(argc, argv, &args) < 0) {
+        printUsage();
+        curesult = CUDA_ERROR_UNKNOWN;
+        DoneCons(consumerStatus, send_fd);
+    }
+
+    printf("Width : %u, height: %u and iterations: %u\n", WIDTH, HEIGHT, NUMTRIALS);
+
+    if (!args.isProducer) // Consumer code
+    {
+        test_cuda_consumer_s cudaConsumer;
+        memset(&cudaConsumer, 0, sizeof(test_cuda_consumer_s));
+        cudaConsumer.profileAPI = profileAPIs;
+
+        // Hook up Ctrl-C handler
+        signal(SIGINT, sig_handler);
+
+        if (!EGLStreamInit(isCrossDevice, !args.isProducer, EGL_NO_FILE_DESCRIPTOR_KHR)) {
+            printf("EGLStream Init failed.\n");
+            curesult       = CUDA_ERROR_UNKNOWN;
+            consumerStatus = -1;
+            DoneCons(consumerStatus, send_fd);
+        }
+
+        cudaConsumer.cudaDevId = cudaDevIndexCons;
+        curesult               = cudaDeviceCreateConsumer(&cudaConsumer);
+        if (curesult != CUDA_SUCCESS) {
+            consumerStatus = -1;
+            DoneCons(consumerStatus, send_fd);
+        }
+
+        cuCtxPushCurrent(cudaConsumer.context);
+
+        launchProducer(&args);
+
+        args.charCnt = WIDTH * HEIGHT * 4;
+
+        curesult = cuda_consumer_init(&cudaConsumer, &args);
+        if (curesult != CUDA_SUCCESS) {
+            printf("Cuda Consumer: Init failed, status: %d\n", curesult);
+            consumerStatus = -1;
+            DoneCons(consumerStatus, send_fd);
+        }
+
+        cuCtxPopCurrent(&cudaConsumer.context);
+
+        send_fd = UnixSocketConnect(SOCK_PATH);
+        if (-1 == send_fd) {
+            printf("%s: Cuda Consumer cannot create socket %s\n", __func__, SOCK_PATH);
+            consumerStatus = -1;
+            DoneCons(consumerStatus, send_fd);
+        }
+
+        cuCtxPushCurrent(cudaConsumer.context);
+        cudaConsumer.eglStream  = g_consumerEglStream;
+        cudaConsumer.eglDisplay = g_consumerEglDisplay;
+
+        // Send the EGL stream FD to producer
+        fileDescriptor = eglGetStreamFileDescriptorKHR(cudaConsumer.eglDisplay, cudaConsumer.eglStream);
+        if (EGL_NO_FILE_DESCRIPTOR_KHR == fileDescriptor) {
+            printf("%s: Cuda Consumer could not get EGL file descriptor.\n", __func__);
+            eglDestroyStreamKHR(cudaConsumer.eglDisplay, cudaConsumer.eglStream);
+            consumerStatus = -1;
+            DoneCons(consumerStatus, send_fd);
+        }
+
+        if (verbose)
+            printf("%s: Cuda Consumer EGL stream FD obtained : %d.\n", __func__, fileDescriptor);
+
+        int res = -1;
+        res     = EGLStreamSendfd(send_fd, fileDescriptor);
+        if (-1 == res) {
+            printf("%s: Cuda Consumer could not send EGL file descriptor.\n", __func__);
+            consumerStatus = -1;
+            close(fileDescriptor);
+        }
+
+        if (CUDA_SUCCESS != (curesult = cuEGLStreamConsumerConnect(&(cudaConsumer.cudaConn), cudaConsumer.eglStream))) {
+            printf("FAILED Connect CUDA consumer with error %d\n", curesult);
+            consumerStatus = -1;
+            DoneCons(consumerStatus, send_fd);
+        }
+
+        j = 0;
+        for (j = 0; j < NUMTRIALS; j++) {
+            curesult = cudaConsumerAcquireFrame(&cudaConsumer, j);
+            if (curesult != CUDA_SUCCESS) {
+                printf("Cuda Consumer Test failed for frame = %d\n", j + 1);
+                consumerStatus = -1;
+                DoneCons(consumerStatus, send_fd);
+            }
+            curesult = cudaConsumerReleaseFrame(&cudaConsumer, j);
+            if (curesult != CUDA_SUCCESS) {
+                printf("Cuda Consumer Test failed for frame = %d\n", j + 1);
+                consumerStatus = -1;
+                DoneCons(consumerStatus, send_fd);
+            }
+
+            curesult = cudaConsumerAcquireFrame(&cudaConsumer, j);
+            if (curesult != CUDA_SUCCESS) {
+                printf("Cuda Consumer Test failed for frame = %d\n", j + 1);
+                consumerStatus = -1;
+                DoneCons(consumerStatus, send_fd);
+            }
+            curesult = cudaConsumerReleaseFrame(&cudaConsumer, j);
+            if (curesult != CUDA_SUCCESS) {
+                printf("Cuda Consumer Test failed for frame = %d\n", j + 1);
+                consumerStatus = -1;
+                DoneCons(consumerStatus, send_fd);
+            }
+        }
+        cuCtxSynchronize();
+        close(fileDescriptor);
+        err = cudaGetValueMismatch();
+        if (err != cudaSuccess) {
+            printf("Consumer: App failed with value mismatch\n");
+            curesult       = CUDA_ERROR_UNKNOWN;
+            consumerStatus = -1;
+            DoneCons(consumerStatus, send_fd);
+        }
+
+        EGLint streamState = 0;
+        if (!eglQueryStreamKHR(cudaConsumer.eglDisplay, cudaConsumer.eglStream, EGL_STREAM_STATE_KHR, &streamState)) {
+            printf("Main, eglQueryStreamKHR EGL_STREAM_STATE_KHR failed\n");
+            curesult       = CUDA_ERROR_UNKNOWN;
+            consumerStatus = -1;
+            DoneCons(consumerStatus, send_fd);
+        }
+
+        if (streamState != EGL_STREAM_STATE_DISCONNECTED_KHR) {
+            if (CUDA_SUCCESS != (curesult = cuda_consumer_Deinit(&cudaConsumer))) {
+                printf("Consumer Disconnect FAILED.\n");
+                consumerStatus = -1;
+                DoneCons(consumerStatus, send_fd);
+            }
+        }
+    }
+    else // Producer
+    {
+        test_cuda_producer_s cudaProducer;
+        memset(&cudaProducer, 0, sizeof(test_cuda_producer_s));
+        cudaProducer.profileAPI = profileAPIs;
+        int producerStatus      = 0;
+
+        setenv("CUDA_EGL_PRODUCER_RETURN_WAIT_TIMEOUT", "1600", 0);
+
+        int connect_fd = -1;
+        // Hook up Ctrl-C handler
+        signal(SIGINT, sig_handler);
+
+        // Create connection to Consumer
+        connect_fd = UnixSocketCreate(SOCK_PATH);
+        if (-1 == connect_fd) {
+            printf("%s: Cuda Producer could not create socket: %s.\n", __func__, SOCK_PATH);
+            producerStatus = -1;
+            DoneProd(producerStatus, connect_fd);
+        }
+
+        // Get the file descriptor of the stream from the consumer process
+        // and re-create the EGL stream from it
+        fileDescriptor = EGLStreamReceivefd(connect_fd);
+        if (-1 == fileDescriptor) {
+            printf("%s: Cuda Producer could not receive EGL file descriptor \n", __func__);
+            producerStatus = -1;
+            DoneProd(producerStatus, connect_fd);
+        }
+
+        if (!EGLStreamInit(isCrossDevice, 0, fileDescriptor)) {
+            printf("EGLStream Init failed.\n");
+            producerStatus = -1;
+            curesult       = CUDA_ERROR_UNKNOWN;
+            DoneProd(producerStatus, connect_fd);
+        }
+
+        cudaProducer.eglDisplay = g_producerEglDisplay;
+        cudaProducer.eglStream  = g_producerEglStream;
+        cudaProducer.cudaDevId  = cudaDevIndexProd;
+
+        curesult = cudaDeviceCreateProducer(&cudaProducer);
+        if (curesult != CUDA_SUCCESS) {
+            producerStatus = -1;
+            DoneProd(producerStatus, connect_fd);
+        }
+
+        args.charCnt = WIDTH * HEIGHT * 4;
+        cuCtxPushCurrent(cudaProducer.context);
+        curesult = cudaProducerInit(&cudaProducer, &args);
+        if (curesult != CUDA_SUCCESS) {
+            printf("Cuda Producer: Init failed, status: %d\n", curesult);
+            producerStatus = -1;
+            DoneProd(producerStatus, connect_fd);
+        }
+
+        // wait for consumer to connect first
+        int    err         = 0;
+        int    wait_loop   = 0;
+        EGLint streamState = 0;
+        do {
+            err =
+                eglQueryStreamKHR(cudaProducer.eglDisplay, cudaProducer.eglStream, EGL_STREAM_STATE_KHR, &streamState);
+            if ((0 != err) && (EGL_STREAM_STATE_CONNECTING_KHR != streamState)) {
+                sleep(1);
+                wait_loop++;
+            }
+        } while ((wait_loop < 10) && (0 != err) && (streamState != EGL_STREAM_STATE_CONNECTING_KHR));
+
+        if ((0 == err) || (wait_loop >= 10)) {
+            printf("%s: Cuda Producer eglQueryStreamKHR EGL_STREAM_STATE_KHR failed.\n", __func__);
+            producerStatus = -1;
+            DoneProd(producerStatus, connect_fd);
+        }
+
+        if (CUDA_SUCCESS
+            != (curesult =
+                    cuEGLStreamProducerConnect(&(cudaProducer.cudaConn), cudaProducer.eglStream, WIDTH, HEIGHT))) {
+            printf("Connect CUDA producer FAILED with error %d\n", curesult);
+            producerStatus = -1;
+            DoneProd(producerStatus, connect_fd);
+        }
+
+        printf("main - Cuda Producer and Consumer Initialized.\n");
+
+        cudaProducerPrepareFrame(&cudaEgl1, cudaProducer.cudaPtr, args.charCnt);
+        cudaProducerPrepareFrame(&cudaEgl2, cudaProducer.cudaPtr1, args.charCnt);
+
+        j = 0;
+        for (j = 0; j < NUMTRIALS; j++) {
+            curesult = cudaProducerPresentFrame(&cudaProducer, cudaEgl1, j);
+            if (curesult != CUDA_SUCCESS) {
+                printf("Cuda Producer Test failed for frame = %d with cuda error:%d\n", j + 1, curesult);
+                producerStatus = -1;
+                DoneProd(producerStatus, connect_fd);
+            }
+
+            curesult = cudaProducerPresentFrame(&cudaProducer, cudaEgl2, j);
+            if (curesult != CUDA_SUCCESS) {
+                printf("Cuda Producer Test failed for frame = %d with cuda error:%d\n", j + 1, curesult);
+                producerStatus = -1;
+                DoneProd(producerStatus, connect_fd);
+            }
+
+            curesult = cudaProducerReturnFrame(&cudaProducer, cudaEgl1, j);
+            if (curesult != CUDA_SUCCESS) {
+                printf("Cuda Producer Test failed for frame = %d with cuda error:%d\n", j + 1, curesult);
+                producerStatus = -1;
+                DoneProd(producerStatus, connect_fd);
+            }
+
+            curesult = cudaProducerReturnFrame(&cudaProducer, cudaEgl2, j);
+            if (curesult != CUDA_SUCCESS) {
+                printf("Cuda Producer Test failed for frame = %d with cuda error:%d\n", j + 1, curesult);
+                producerStatus = -1;
+                DoneProd(producerStatus, connect_fd);
+            }
+        }
+
+        cuCtxSynchronize();
+        err = cudaGetValueMismatch();
+        if (err != cudaSuccess) {
+            printf("Prod: App failed with value mismatch\n");
+            curesult       = CUDA_ERROR_UNKNOWN;
+            producerStatus = -1;
+            DoneProd(producerStatus, connect_fd);
+        }
+
+        printf("Tear Down Start.....\n");
+        if (!eglQueryStreamKHR(cudaProducer.eglDisplay, cudaProducer.eglStream, EGL_STREAM_STATE_KHR, &streamState)) {
+            printf("Main, eglQueryStreamKHR EGL_STREAM_STATE_KHR failed\n");
+            curesult       = CUDA_ERROR_UNKNOWN;
+            producerStatus = -1;
+            DoneProd(producerStatus, connect_fd);
+        }
+
+        if (streamState != EGL_STREAM_STATE_DISCONNECTED_KHR) {
+            if (CUDA_SUCCESS != (curesult = cudaProducerDeinit(&cudaProducer))) {
+                printf("Producer Disconnect FAILED with %d\n", curesult);
+                producerStatus = -1;
+                DoneProd(producerStatus, connect_fd);
+            }
+        }
+        unsetenv("CUDA_EGL_PRODUCER_RETURN_WAIT_TIMEOUT");
+    }
+
+    return 0;
+}

cpp/2_Concepts_and_Techniques/EGLStream_CUDA_Interop/.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/2_Concepts_and_Techniques/EGLStream_CUDA_Interop/.vscode/extensions.json

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

cpp/2_Concepts_and_Techniques/EGLStream_CUDA_Interop/CMakeLists.txt

@@ -0,0 +1,55 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../../cmake/Modules")
+
+project(EGLStream_CUDA_Interop 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)
+
+find_package(EGL)
+
+if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+    # Source file
+    if(${EGL_FOUND})
+        # Add target for EGLStream_CUDA_Interop
+        add_executable(EGLStream_CUDA_Interop cuda_consumer.cpp cuda_producer.cpp eglstrm_common.cpp main.cpp)
+
+        target_compile_options(EGLStream_CUDA_Interop PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+        target_compile_features(EGLStream_CUDA_Interop PRIVATE cxx_std_17 cuda_std_17)
+
+        set_target_properties(EGLStream_CUDA_Interop PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
+
+        target_include_directories(EGLStream_CUDA_Interop PUBLIC
+            ${EGL_INCLUDE_DIR}
+            ${CUDAToolkit_INCLUDE_DIRS}
+        )
+
+        target_link_libraries(EGLStream_CUDA_Interop
+            ${EGL_LIBRARY}
+            CUDA::cuda_driver
+        )
+
+    else()
+        message(STATUS "EGL not found - will not build sample 'EGLStream_CUDA_Interop'")
+    endif()
+else()
+    message(STATUS "Will not build sample EGLStream_CUDA_Interop - requires Linux OS")
+endif()
+
+# Include installation configuration
+include(${CMAKE_CURRENT_SOURCE_DIR}/../../../cmake/InstallSamples.cmake)
+setup_samples_install()

cpp/2_Concepts_and_Techniques/EGLStream_CUDA_Interop/README.md

@@ -0,0 +1,39 @@
+# EGLStream_CUDA_Interop - EGLStream CUDA Interop
+
+## Description
+
+Demonstrates data exchange between CUDA and EGL Streams.
+
+## Key Concepts
+
+EGLStreams Interop
+
+## 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
+
+## Supported CPU Architecture
+
+x86_64, aarch64
+
+## CUDA APIs involved
+
+### [CUDA Driver API](http://docs.nvidia.com/cuda/cuda-driver-api/index.html)
+cuMemcpyDtoH, cuDeviceGetName, cuEGLStreamConsumerReleaseFrame, cuEGLStreamConsumerConnect, cuEGLStreamConsumerDisconnect, cuCtxPushCurrent, cuArrayDestroy, cuEGLStreamProducerReturnFrame, cuEGLStreamProducerPresentFrame, cuMemFree, cuGraphicsResourceGetMappedEglFrame, cuInit, cuEGLStreamConsumerAcquireFrame, cuEGLStreamProducerDisconnect, cuDeviceGetCount, cuEGLStreamProducerConnect, cuDeviceGetAttribute, cuCtxSynchronize, cuMemAlloc, cuCtxPopCurrent, cuCtxCreate, cuMemcpy
+
+### [CUDA Runtime API](http://docs.nvidia.com/cuda/cuda-runtime-api/index.html)
+cudaProducerReadYUVFrame, cudaProducerTest, cudaProducerDeinit, cudaDeviceCreateProducer, cudaProducerReadARGBFrame, cudaDeviceCreateConsumer, cudaConsumerTest, cudaProducerInit
+
+## Dependencies needed to build/run
+[EGL](../../../README.md#egl)
+
+## 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/2_Concepts_and_Techniques/EGLStream_CUDA_Interop/cuda_consumer.cpp

@@ -0,0 +1,329 @@
+/* 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.
+ */
+
+//
+// DESCRIPTION:   Simple CUDA consumer rendering sample app
+//
+
+#include "cuda_consumer.h"
+
+#include <helper_cuda_drvapi.h>
+
+#include "eglstrm_common.h"
+
+#if defined(EXTENSION_LIST)
+EXTENSION_LIST(EXTLST_EXTERN)
+#endif
+
+int checkbuf(FILE *fp1, FILE *fp2);
+
+CUresult cudaConsumerTest(test_cuda_consumer_s *data, const char *fileName)
+{
+    CUresult           cuStatus = CUDA_SUCCESS;
+    CUarray            cudaArr  = NULL;
+    CUeglFrame         cudaEgl;
+    CUgraphicsResource cudaResource;
+    unsigned int       i;
+    int                check_result;
+    FILE              *pInFile1 = NULL, *pInFile2 = NULL, *file_p = NULL;
+    EGLint             streamState = 0;
+
+    if (!data) {
+        printf("%s: Bad parameter\n", __func__);
+        goto done;
+    }
+
+    if (!eglQueryStreamKHR(g_display, eglStream, EGL_STREAM_STATE_KHR, &streamState)) {
+        printf("Cuda consumer, eglQueryStreamKHR EGL_STREAM_STATE_KHR failed\n");
+    }
+    if (streamState == EGL_STREAM_STATE_DISCONNECTED_KHR) {
+        printf("CUDA Consumer: - EGL_STREAM_STATE_DISCONNECTED_KHR received\n");
+    }
+
+    if (streamState == EGL_STREAM_STATE_NEW_FRAME_AVAILABLE_KHR) {
+        cuStatus = cuEGLStreamConsumerAcquireFrame(&(data->cudaConn), &cudaResource, NULL, 16000);
+
+        if (cuStatus == CUDA_SUCCESS) {
+            CUdeviceptr    pDevPtr = 0;
+            int            bufferSize;
+            unsigned char *pCudaCopyMem     = NULL;
+            unsigned int   copyWidthInBytes = 0, copyHeight = 0;
+
+            file_p = fopen(fileName, "wb+");
+            if (!file_p) {
+                printf("WriteFrame: file open failed %s\n", fileName);
+                cuStatus = CUDA_ERROR_UNKNOWN;
+                goto done;
+            }
+            cuStatus = cuGraphicsResourceGetMappedEglFrame(&cudaEgl, cudaResource, 0, 0);
+            if (cuStatus != CUDA_SUCCESS) {
+                printf("Cuda get resource failed with %d\n", cuStatus);
+                goto done;
+            }
+            cuStatus = cuCtxSynchronize();
+            if (cuStatus != CUDA_SUCCESS) {
+                printf("cuCtxSynchronize failed \n");
+                goto done;
+            }
+            if (!(cudaEgl.planeCount >= 1 && cudaEgl.planeCount <= 3)) {
+                printf("Plane count is invalid\nExiting\n");
+                goto done;
+            }
+
+            for (i = 0; i < cudaEgl.planeCount; i++) {
+                if (cudaEgl.frameType == CU_EGL_FRAME_TYPE_PITCH) {
+                    pDevPtr = (CUdeviceptr)cudaEgl.frame.pPitch[i];
+                    if (cudaEgl.planeCount == 1) {
+                        bufferSize       = cudaEgl.pitch * cudaEgl.height;
+                        copyWidthInBytes = cudaEgl.pitch;
+                        copyHeight       = data->height;
+                    }
+                    else if (i == 1 && cudaEgl.planeCount == 2) { // YUV 420
+                                                                  // semi-planar
+                        bufferSize       = cudaEgl.pitch * cudaEgl.height / 2;
+                        copyWidthInBytes = cudaEgl.pitch;
+                        copyHeight       = data->height / 2;
+                    }
+                    else {
+                        bufferSize       = data->width * data->height;
+                        copyWidthInBytes = data->width;
+                        copyHeight       = data->height;
+                        if (i > 0) {
+                            bufferSize >>= 2;
+                            copyWidthInBytes >>= 1;
+                            copyHeight >>= 1;
+                        }
+                    }
+                }
+                else {
+                    cudaArr = cudaEgl.frame.pArray[i];
+                    if (cudaEgl.planeCount == 1) {
+                        bufferSize       = data->width * data->height * 4;
+                        copyWidthInBytes = data->width * 4;
+                        copyHeight       = data->height;
+                    }
+                    else if (i == 1 && cudaEgl.planeCount == 2) { // YUV 420
+                                                                  // semi-planar
+                        bufferSize       = data->width * data->height / 2;
+                        copyWidthInBytes = data->width;
+                        copyHeight       = data->height / 2;
+                    }
+                    else {
+                        bufferSize       = data->width * data->height;
+                        copyWidthInBytes = data->width;
+                        copyHeight       = data->height;
+                        if (i > 0) {
+                            bufferSize >>= 2;
+                            copyWidthInBytes >>= 1;
+                            copyHeight >>= 1;
+                        }
+                    }
+                }
+                if (i == 0) {
+                    pCudaCopyMem = (unsigned char *)malloc(bufferSize);
+                    if (pCudaCopyMem == NULL) {
+                        printf("pCudaCopyMem malloc failed\n");
+                        goto done;
+                    }
+                }
+                memset(pCudaCopyMem, 0, bufferSize);
+                if (data->pitchLinearOutput) {
+                    cuStatus = cuMemcpyDtoH(pCudaCopyMem, pDevPtr, bufferSize);
+                    if (cuStatus != CUDA_SUCCESS) {
+                        printf("cuda_consumer: pitch linear Memcpy failed, bufferSize =%d\n", bufferSize);
+                        goto done;
+                    }
+                    cuStatus = cuCtxSynchronize();
+                    if (cuStatus != CUDA_SUCCESS) {
+                        printf("cuda_consumer: cuCtxSynchronize failed after memcpy \n");
+                        goto done;
+                    }
+                }
+                else {
+                    CUDA_MEMCPY3D cpdesc;
+                    memset(&cpdesc, 0, sizeof(cpdesc));
+                    cpdesc.srcXInBytes = cpdesc.srcY = cpdesc.srcZ = cpdesc.srcLOD = 0;
+                    cpdesc.srcMemoryType                                           = CU_MEMORYTYPE_ARRAY;
+                    cpdesc.srcArray                                                = cudaArr;
+                    cpdesc.dstXInBytes = cpdesc.dstY = cpdesc.dstZ = cpdesc.dstLOD = 0;
+                    cpdesc.dstMemoryType                                           = CU_MEMORYTYPE_HOST;
+                    cpdesc.dstHost                                                 = (void *)pCudaCopyMem;
+                    cpdesc.WidthInBytes = copyWidthInBytes; // data->width * 4;
+                    cpdesc.Height       = copyHeight;       // data->height;
+                    cpdesc.Depth        = 1;
+
+                    cuStatus = cuMemcpy3D(&cpdesc);
+                    if (cuStatus != CUDA_SUCCESS) {
+                        printf("Cuda consumer: cuMemCpy3D failed,  copyWidthInBytes=%d, "
+                               "copyHight=%d\n",
+                               copyWidthInBytes,
+                               copyHeight);
+                    }
+                    cuStatus = cuCtxSynchronize();
+                    if (cuStatus != CUDA_SUCCESS) {
+                        printf("cuCtxSynchronize failed after memcpy \n");
+                    }
+                }
+                if (cuStatus == CUDA_SUCCESS) {
+                    if (fwrite(pCudaCopyMem, bufferSize, 1, file_p) != 1) {
+                        printf("Cuda consumer: output file write failed\n");
+                        cuStatus = CUDA_ERROR_UNKNOWN;
+                        goto done;
+                    }
+                }
+            }
+            pInFile1 = fopen(data->fileName1, "rb");
+            if (!pInFile1) {
+                printf("Failed to open file :%s\n", data->fileName1);
+                goto done;
+            }
+            pInFile2 = fopen(data->fileName2, "rb");
+            if (!pInFile2) {
+                printf("Failed to open file :%s\n", data->fileName2);
+                goto done;
+            }
+            rewind(file_p);
+            check_result = checkbuf(file_p, pInFile1);
+            if (check_result == -1) {
+                rewind(file_p);
+                check_result = checkbuf(file_p, pInFile2);
+                if (check_result == -1) {
+                    printf("Frame received does not match any valid image: FAILED\n");
+                }
+                else {
+                    printf("Frame check Passed\n");
+                }
+            }
+            else {
+                printf("Frame check Passed\n");
+            }
+            if (pCudaCopyMem) {
+                free(pCudaCopyMem);
+                pCudaCopyMem = NULL;
+            }
+            cuStatus = cuEGLStreamConsumerReleaseFrame(&data->cudaConn, cudaResource, NULL);
+            if (cuStatus != CUDA_SUCCESS) {
+                printf("cuEGLStreamConsumerReleaseFrame failed with cuStatus = %d\n", cuStatus);
+                goto done;
+            }
+        }
+        else {
+            printf("cuda AcquireFrame FAILED with  cuStatus=%d\n", cuStatus);
+            goto done;
+        }
+    }
+
+done:
+    if (file_p) {
+        fclose(file_p);
+        file_p = NULL;
+    }
+    if (pInFile1) {
+        fclose(pInFile1);
+        pInFile1 = NULL;
+    }
+    if (pInFile1) {
+        fclose(pInFile2);
+        pInFile2 = NULL;
+    }
+    return cuStatus;
+}
+
+int checkbuf(FILE *fp1, FILE *fp2)
+{
+    int match = 0;
+    int ch1, ch2;
+    if (fp1 == NULL) {
+        printf("Invalid file pointer for first file\n");
+        return -1;
+    }
+    else if (fp2 == NULL) {
+        printf("Invalid file pointer for second file\n");
+        return -1;
+    }
+    else {
+        ch1 = getc(fp1);
+        ch2 = getc(fp2);
+        while ((ch1 != EOF) && (ch2 != EOF) && (ch1 == ch2)) {
+            ch1 = getc(fp1);
+            ch2 = getc(fp2);
+        }
+        if (ch1 == ch2) {
+            match = 1;
+        }
+        else if (ch1 != ch2) {
+            match = -1;
+        }
+    }
+    return match;
+}
+
+CUresult cudaDeviceCreateConsumer(test_cuda_consumer_s *cudaConsumer, CUdevice device)
+{
+    CUresult status = CUDA_SUCCESS;
+    if (CUDA_SUCCESS != (status = cuInit(0))) {
+        printf("Failed to initialize CUDA\n");
+        return status;
+    }
+
+    int  major = 0, minor = 0;
+    char deviceName[256];
+    checkCudaErrors(cuDeviceGetAttribute(&major, CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR, device));
+    checkCudaErrors(cuDeviceGetAttribute(&minor, CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR, device));
+    checkCudaErrors(cuDeviceGetName(deviceName, 256, device));
+    printf("CUDA Consumer on GPU Device %d: \"%s\" with compute capability "
+           "%d.%d\n\n",
+           device,
+           deviceName,
+           major,
+           minor);
+
+    CUctxCreateParams ctxCreateParams = {};
+    if (CUDA_SUCCESS != (status = cuCtxCreate(&cudaConsumer->context, &ctxCreateParams, 0, device))) {
+        printf("failed to create CUDA context\n");
+        return status;
+    }
+    checkCudaErrors(cuCtxPopCurrent(&cudaConsumer->context));
+    return status;
+}
+
+void cuda_consumer_init(test_cuda_consumer_s *cudaConsumer, TestArgs *args)
+{
+    cudaConsumer->pitchLinearOutput = args->pitchLinearOutput;
+    cudaConsumer->width             = args->inputWidth;
+    cudaConsumer->height            = args->inputHeight;
+    cudaConsumer->fileName1         = args->infile1;
+    cudaConsumer->fileName2         = args->infile2;
+
+    cudaConsumer->outFile1 = const_cast<char *>("cuda_out1.yuv");
+    cudaConsumer->outFile2 = const_cast<char *>("cuda_out2.yuv");
+}
+
+CUresult cuda_consumer_deinit(test_cuda_consumer_s *cudaConsumer)
+{
+    return cuEGLStreamConsumerDisconnect(&cudaConsumer->cudaConn);
+}

cpp/2_Concepts_and_Techniques/EGLStream_CUDA_Interop/cuda_consumer.h

@@ -0,0 +1,63 @@
+/* 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.
+ */
+
+//
+// DESCRIPTION:   CUDA consumer header file
+//
+
+#ifndef _CUDA_CONSUMER_H_
+#define _CUDA_CONSUMER_H_
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "cudaEGL.h"
+#include "eglstrm_common.h"
+
+extern EGLStreamKHR eglStream;
+extern EGLDisplay   g_display;
+
+typedef struct _test_cuda_consumer_s
+{
+    CUcontext             context;
+    CUeglStreamConnection cudaConn;
+    bool                  pitchLinearOutput;
+    unsigned int          width;
+    unsigned int          height;
+    const char           *fileName1;
+    const char           *fileName2;
+    const char           *outFile1;
+    const char           *outFile2;
+    unsigned int          frameCount;
+} test_cuda_consumer_s;
+
+void     cuda_consumer_init(test_cuda_consumer_s *cudaConsumer, TestArgs *args);
+CUresult cuda_consumer_deinit(test_cuda_consumer_s *cudaConsumer);
+CUresult cudaConsumerTest(test_cuda_consumer_s *data, const char *outFile);
+CUresult cudaDeviceCreateConsumer(test_cuda_consumer_s *cudaConsumer, CUdevice device);
+#endif

cpp/2_Concepts_and_Techniques/EGLStream_CUDA_Interop/cuda_producer.cpp

@@ -0,0 +1,419 @@
+/* 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.
+ */
+
+//
+// DESCRIPTION:   Simple cuda EGL stream producer app
+//
+
+#include "cuda_producer.h"
+
+#include <helper_cuda_drvapi.h>
+
+#include "cudaEGL.h"
+#include "eglstrm_common.h"
+
+#if defined(EXTENSION_LIST)
+EXTENSION_LIST(EXTLST_EXTERN)
+#endif
+
+static CUresult cudaProducerReadYUVFrame(FILE          *file,
+                                         unsigned int   frameNum,
+                                         unsigned int   width,
+                                         unsigned int   height,
+                                         unsigned char *pBuff)
+{
+    int            bOrderUV = 0;
+    unsigned char *pYBuff, *pUBuff, *pVBuff, *pChroma;
+    unsigned int   frameSize = (width * height * 3) / 2;
+    CUresult       ret       = CUDA_SUCCESS;
+    unsigned int   i;
+
+    if (!pBuff || !file)
+        return CUDA_ERROR_FILE_NOT_FOUND;
+
+    pYBuff = pBuff;
+
+    // YVU order in the buffer
+    pVBuff = pYBuff + width * height;
+    pUBuff = pVBuff + width * height / 4;
+
+    if (fseek(file, frameNum * frameSize, SEEK_SET)) {
+        printf("ReadYUVFrame: Error seeking file: %p\n", file);
+        ret = CUDA_ERROR_NOT_PERMITTED;
+        goto done;
+    }
+    // read Y U V separately
+    for (i = 0; i < height; i++) {
+        if (fread(pYBuff, width, 1, file) != 1) {
+            printf("ReadYUVFrame: Error reading file: %p\n", file);
+            ret = CUDA_ERROR_NOT_PERMITTED;
+            goto done;
+        }
+        pYBuff += width;
+    }
+
+    pChroma = bOrderUV ? pUBuff : pVBuff;
+    for (i = 0; i < height / 2; i++) {
+        if (fread(pChroma, width / 2, 1, file) != 1) {
+            printf("ReadYUVFrame: Error reading file: %p\n", file);
+            ret = CUDA_ERROR_NOT_PERMITTED;
+            goto done;
+        }
+        pChroma += width / 2;
+    }
+
+    pChroma = bOrderUV ? pVBuff : pUBuff;
+    for (i = 0; i < height / 2; i++) {
+        if (fread(pChroma, width / 2, 1, file) != 1) {
+            printf("ReadYUVFrame: Error reading file: %p\n", file);
+            ret = CUDA_ERROR_NOT_PERMITTED;
+            goto done;
+        }
+        pChroma += width / 2;
+    }
+done:
+    return ret;
+}
+
+static CUresult cudaProducerReadARGBFrame(FILE          *file,
+                                          unsigned int   frameNum,
+                                          unsigned int   width,
+                                          unsigned int   height,
+                                          unsigned char *pBuff)
+{
+    unsigned int frameSize = width * height * 4;
+    CUresult     ret       = CUDA_SUCCESS;
+
+    if (!pBuff || !file)
+        return CUDA_ERROR_FILE_NOT_FOUND;
+
+    if (fseek(file, frameNum * frameSize, SEEK_SET)) {
+        printf("ReadYUVFrame: Error seeking file: %p\n", file);
+        ret = CUDA_ERROR_NOT_PERMITTED;
+        goto done;
+    }
+
+    // read ARGB data
+    if (fread(pBuff, frameSize, 1, file) != 1) {
+        if (feof(file))
+            printf("ReadARGBFrame: file read to the end\n");
+        else
+            printf("ReadARGBFrame: Error reading file: %p\n", file);
+        ret = CUDA_ERROR_NOT_PERMITTED;
+        goto done;
+    }
+done:
+    return ret;
+}
+
+CUresult cudaProducerTest(test_cuda_producer_s *cudaProducer, char *file)
+{
+    int              framenum   = 0;
+    CUarray          cudaArr[3] = {0};
+    CUdeviceptr      cudaPtr[3] = {0, 0, 0};
+    unsigned int     bufferSize;
+    CUresult         cuStatus = CUDA_SUCCESS;
+    unsigned int     i, surfNum, uvOffset[3] = {0};
+    unsigned int     copyWidthInBytes[3] = {0, 0, 0}, copyHeight[3] = {0, 0, 0};
+    CUeglColorFormat eglColorFormat;
+    FILE            *file_p;
+    CUeglFrame       cudaEgl;
+    CUcontext        oldContext;
+
+    file_p = fopen(file, "rb");
+    if (!file_p) {
+        printf("CudaProducer: Error opening file: %s\n", file);
+        goto done;
+    }
+
+    if (cudaProducer->pitchLinearOutput) {
+        if (cudaProducer->isARGB) {
+            cudaPtr[0] = cudaProducer->cudaPtrARGB[0];
+        }
+        else { // YUV case
+            for (i = 0; i < 3; i++) {
+                if (i == 0) {
+                    bufferSize = cudaProducer->width * cudaProducer->height;
+                }
+                else {
+                    bufferSize = cudaProducer->width * cudaProducer->height / 4;
+                }
+
+                cudaPtr[i] = cudaProducer->cudaPtrYUV[i];
+            }
+        }
+    }
+    else {
+        if (cudaProducer->isARGB) {
+            cudaArr[0] = cudaProducer->cudaArrARGB[0];
+        }
+        else {
+            for (i = 0; i < 3; i++) {
+                cudaArr[i] = cudaProducer->cudaArrYUV[i];
+            }
+        }
+    }
+    uvOffset[0] = 0;
+    if (cudaProducer->isARGB) {
+        if (CUDA_SUCCESS
+            != cudaProducerReadARGBFrame(
+                file_p, framenum, cudaProducer->width, cudaProducer->height, cudaProducer->pBuff)) {
+            printf("cuda producer, read ARGB frame failed\n");
+            goto done;
+        }
+        copyWidthInBytes[0] = cudaProducer->width * 4;
+        copyHeight[0]       = cudaProducer->height;
+        surfNum             = 1;
+        eglColorFormat      = CU_EGL_COLOR_FORMAT_ARGB;
+    }
+    else {
+        if (CUDA_SUCCESS
+            != cudaProducerReadYUVFrame(
+                file_p, framenum, cudaProducer->width, cudaProducer->height, cudaProducer->pBuff)) {
+            printf("cuda producer, reading YUV frame failed\n");
+            goto done;
+        }
+        surfNum             = 3;
+        eglColorFormat      = CU_EGL_COLOR_FORMAT_YUV420_PLANAR;
+        copyWidthInBytes[0] = cudaProducer->width;
+        copyHeight[0]       = cudaProducer->height;
+        copyWidthInBytes[1] = cudaProducer->width / 2;
+        copyHeight[1]       = cudaProducer->height / 2;
+        copyWidthInBytes[2] = cudaProducer->width / 2;
+        copyHeight[2]       = cudaProducer->height / 2;
+        uvOffset[1]         = cudaProducer->width * cudaProducer->height;
+        uvOffset[2]         = uvOffset[1] + cudaProducer->width / 2 * cudaProducer->height / 2;
+    }
+    if (cudaProducer->pitchLinearOutput) {
+        for (i = 0; i < surfNum; i++) {
+            cuStatus = cuMemcpy(
+                cudaPtr[i], (CUdeviceptr)(cudaProducer->pBuff + uvOffset[i]), copyWidthInBytes[i] * copyHeight[i]);
+
+            if (cuStatus != CUDA_SUCCESS) {
+                printf("Cuda producer: cuMemCpy pitchlinear failed, cuStatus =%d\n", cuStatus);
+                goto done;
+            }
+        }
+    }
+    else {
+        // copy cudaProducer->pBuff to cudaArray
+        CUDA_MEMCPY3D cpdesc;
+        for (i = 0; i < surfNum; i++) {
+            memset(&cpdesc, 0, sizeof(cpdesc));
+            cpdesc.srcXInBytes = cpdesc.srcY = cpdesc.srcZ = cpdesc.srcLOD = 0;
+            cpdesc.srcMemoryType                                           = CU_MEMORYTYPE_HOST;
+            cpdesc.srcHost     = (void *)(cudaProducer->pBuff + uvOffset[i]);
+            cpdesc.dstXInBytes = cpdesc.dstY = cpdesc.dstZ = cpdesc.dstLOD = 0;
+            cpdesc.dstMemoryType                                           = CU_MEMORYTYPE_ARRAY;
+            cpdesc.dstArray                                                = cudaArr[i];
+            cpdesc.WidthInBytes                                            = copyWidthInBytes[i];
+            cpdesc.Height                                                  = copyHeight[i];
+            cpdesc.Depth                                                   = 1;
+            cuStatus                                                       = cuMemcpy3D(&cpdesc);
+            if (cuStatus != CUDA_SUCCESS) {
+                printf("Cuda producer: cuMemCpy failed, cuStatus =%d\n", cuStatus);
+                goto done;
+            }
+        }
+    }
+    for (i = 0; i < surfNum; i++) {
+        if (cudaProducer->pitchLinearOutput)
+            cudaEgl.frame.pPitch[i] = (void *)cudaPtr[i];
+        else
+            cudaEgl.frame.pArray[i] = cudaArr[i];
+    }
+    cudaEgl.width          = copyWidthInBytes[0];
+    cudaEgl.depth          = 1;
+    cudaEgl.height         = copyHeight[0];
+    cudaEgl.pitch          = cudaProducer->pitchLinearOutput ? cudaEgl.width : 0;
+    cudaEgl.frameType      = cudaProducer->pitchLinearOutput ? CU_EGL_FRAME_TYPE_PITCH : CU_EGL_FRAME_TYPE_ARRAY;
+    cudaEgl.planeCount     = surfNum;
+    cudaEgl.numChannels    = (eglColorFormat == CU_EGL_COLOR_FORMAT_ARGB) ? 4 : 1;
+    cudaEgl.eglColorFormat = eglColorFormat;
+    cudaEgl.cuFormat       = CU_AD_FORMAT_UNSIGNED_INT8;
+
+    static int numFramesPresented = 0;
+    // If there is a frame presented before we check if consumer
+    // is done with it using cuEGLStreamProducerReturnFrame.
+    while (numFramesPresented) {
+        CUeglFrame returnedCudaEgl;
+        cuStatus = cuEGLStreamProducerReturnFrame(&cudaProducer->cudaConn, &returnedCudaEgl, NULL);
+        if (cuStatus == CUDA_ERROR_LAUNCH_TIMEOUT) {
+            continue;
+        }
+        else if (cuStatus != CUDA_SUCCESS) {
+            printf("cuda Producer return frame FAILED with custatus= %d\n", cuStatus);
+            return cuStatus;
+        }
+        else {
+            numFramesPresented--;
+        }
+    }
+
+    cuStatus = cuEGLStreamProducerPresentFrame(&cudaProducer->cudaConn, cudaEgl, NULL);
+    if (cuStatus != CUDA_SUCCESS) {
+        printf("cuda Producer present frame FAILED with custatus= %d\n", cuStatus);
+        goto done;
+    }
+    numFramesPresented++;
+
+done:
+    if (file_p) {
+        fclose(file_p);
+        file_p = NULL;
+    }
+
+    return cuStatus;
+}
+
+CUresult cudaDeviceCreateProducer(test_cuda_producer_s *cudaProducer, CUdevice device)
+{
+    CUresult status = CUDA_SUCCESS;
+    if (CUDA_SUCCESS != (status = cuInit(0))) {
+        printf("Failed to initialize CUDA\n");
+        return status;
+    }
+
+    int  major = 0, minor = 0;
+    char deviceName[256];
+    checkCudaErrors(cuDeviceGetAttribute(&major, CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR, device));
+    checkCudaErrors(cuDeviceGetAttribute(&minor, CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR, device));
+    checkCudaErrors(cuDeviceGetName(deviceName, 256, device));
+    printf("CUDA Producer on GPU Device %d: \"%s\" with compute capability "
+           "%d.%d\n\n",
+           device,
+           deviceName,
+           major,
+           minor);
+
+    if (major < 6) {
+        printf("EGLStream_CUDA_Interop requires SM 6.0 or higher arch GPU.  "
+               "Exiting...\n");
+        exit(2); // EXIT_WAIVED
+    }
+
+    CUctxCreateParams ctxCreateParams = {};
+    if (CUDA_SUCCESS != (status = cuCtxCreate(&cudaProducer->context, &ctxCreateParams, 0, device))) {
+        printf("failed to create CUDA context\n");
+        return status;
+    }
+
+    status = cuMemAlloc(&cudaProducer->cudaPtrARGB[0], (WIDTH * HEIGHT * 4));
+    if (status != CUDA_SUCCESS) {
+        printf("Create CUDA pointer failed, cuStatus=%d\n", status);
+        return status;
+    }
+
+    status = cuMemAlloc(&cudaProducer->cudaPtrYUV[0], (WIDTH * HEIGHT));
+    if (status != CUDA_SUCCESS) {
+        printf("Create CUDA pointer failed, cuStatus=%d\n", status);
+        return status;
+    }
+    status = cuMemAlloc(&cudaProducer->cudaPtrYUV[1], (WIDTH * HEIGHT) / 4);
+    if (status != CUDA_SUCCESS) {
+        printf("Create CUDA pointer failed, cuStatus=%d\n", status);
+        return status;
+    }
+    status = cuMemAlloc(&cudaProducer->cudaPtrYUV[2], (WIDTH * HEIGHT) / 4);
+    if (status != CUDA_SUCCESS) {
+        printf("Create CUDA pointer failed, cuStatus=%d\n", status);
+        return status;
+    }
+
+    CUDA_ARRAY3D_DESCRIPTOR desc = {0};
+
+    desc.Format      = CU_AD_FORMAT_UNSIGNED_INT8;
+    desc.Depth       = 1;
+    desc.Flags       = CUDA_ARRAY3D_SURFACE_LDST;
+    desc.NumChannels = 4;
+    desc.Width       = WIDTH * 4;
+    desc.Height      = HEIGHT;
+    status           = cuArray3DCreate(&cudaProducer->cudaArrARGB[0], &desc);
+    if (status != CUDA_SUCCESS) {
+        printf("Create CUDA array failed, cuStatus=%d\n", status);
+        return status;
+    }
+
+    for (int i = 0; i < 3; i++) {
+        if (i == 0) {
+            desc.NumChannels = 1;
+            desc.Width       = WIDTH;
+            desc.Height      = HEIGHT;
+        }
+        else { // U/V surface as planar
+            desc.NumChannels = 1;
+            desc.Width       = WIDTH / 2;
+            desc.Height      = HEIGHT / 2;
+        }
+        status = cuArray3DCreate(&cudaProducer->cudaArrYUV[i], &desc);
+        if (status != CUDA_SUCCESS) {
+            printf("Create CUDA array failed, cuStatus=%d\n", status);
+            return status;
+        }
+    }
+
+    cudaProducer->pBuff = (unsigned char *)malloc((WIDTH * HEIGHT * 4));
+    if (!cudaProducer->pBuff) {
+        printf("CudaProducer: Failed to allocate image buffer\n");
+    }
+
+    checkCudaErrors(cuCtxPopCurrent(&cudaProducer->context));
+    return status;
+}
+
+void cudaProducerInit(test_cuda_producer_s *cudaProducer, EGLDisplay eglDisplay, EGLStreamKHR eglStream, TestArgs *args)
+{
+    cudaProducer->fileName1 = args->infile1;
+    cudaProducer->fileName2 = args->infile2;
+
+    cudaProducer->frameCount        = 2;
+    cudaProducer->width             = args->inputWidth;
+    cudaProducer->height            = args->inputHeight;
+    cudaProducer->isARGB            = args->isARGB;
+    cudaProducer->pitchLinearOutput = args->pitchLinearOutput;
+
+    // Set cudaProducer default parameters
+    cudaProducer->eglDisplay = eglDisplay;
+    cudaProducer->eglStream  = eglStream;
+}
+
+CUresult cudaProducerDeinit(test_cuda_producer_s *cudaProducer)
+{
+    if (cudaProducer->pBuff)
+        free(cudaProducer->pBuff);
+
+    checkCudaErrors(cuMemFree(cudaProducer->cudaPtrARGB[0]));
+    checkCudaErrors(cuMemFree(cudaProducer->cudaPtrYUV[0]));
+    checkCudaErrors(cuMemFree(cudaProducer->cudaPtrYUV[1]));
+    checkCudaErrors(cuMemFree(cudaProducer->cudaPtrYUV[2]));
+    checkCudaErrors(cuArrayDestroy(cudaProducer->cudaArrARGB[0]));
+    checkCudaErrors(cuArrayDestroy(cudaProducer->cudaArrYUV[0]));
+    checkCudaErrors(cuArrayDestroy(cudaProducer->cudaArrYUV[1]));
+    checkCudaErrors(cuArrayDestroy(cudaProducer->cudaArrYUV[2]));
+
+    return cuEGLStreamProducerDisconnect(&cudaProducer->cudaConn);
+}

cpp/2_Concepts_and_Techniques/EGLStream_CUDA_Interop/cuda_producer.h

@@ -0,0 +1,71 @@
+/* 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.
+ */
+
+//
+// DESCRIPTION:   Simple cuda producer header file
+//
+
+#ifndef _CUDA_PRODUCER_H_
+#define _CUDA_PRODUCER_H_
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+
+#include "cudaEGL.h"
+#include "eglstrm_common.h"
+
+extern EGLStreamKHR eglStream;
+extern EGLDisplay   g_display;
+
+typedef struct _test_cuda_producer_s
+{
+    //  Stream params
+    char                 *fileName1;
+    char                 *fileName2;
+    unsigned char        *pBuff;
+    int                   frameCount;
+    bool                  isARGB;
+    bool                  pitchLinearOutput;
+    unsigned int          width;
+    unsigned int          height;
+    CUcontext             context;
+    CUeglStreamConnection cudaConn;
+    CUdeviceptr           cudaPtrARGB[1];
+    CUdeviceptr           cudaPtrYUV[3];
+    CUarray               cudaArrARGB[1];
+    CUarray               cudaArrYUV[3];
+    EGLStreamKHR          eglStream;
+    EGLDisplay            eglDisplay;
+} test_cuda_producer_s;
+
+void     cudaProducerInit(test_cuda_producer_s *cudaProducer,
+                          EGLDisplay            eglDisplay,
+                          EGLStreamKHR          eglStream,
+                          TestArgs             *args);
+CUresult cudaProducerTest(test_cuda_producer_s *parserArg, char *file);
+CUresult cudaProducerDeinit(test_cuda_producer_s *cudaProducer);
+CUresult cudaDeviceCreateProducer(test_cuda_producer_s *cudaProducer, CUdevice device);
+#endif

cpp/2_Concepts_and_Techniques/EGLStream_CUDA_Interop/eglstrm_common.cpp

@@ -0,0 +1,134 @@
+/* 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.
+ */
+
+//
+// DESCRIPTION:   Common egl stream functions
+//
+
+#include "eglstrm_common.h"
+
+EGLStreamKHR eglStream;
+EGLDisplay   g_display;
+EGLAttrib    cudaIndex;
+
+#if defined(EXTENSION_LIST)
+EXTENSION_LIST(EXTLST_DECL)
+typedef void (*extlst_fnptr_t)(void);
+static struct
+{
+    extlst_fnptr_t *fnptr;
+    char const     *name;
+} extensionList[] = {EXTENSION_LIST(EXTLST_ENTRY)};
+
+int eglSetupExtensions(void)
+{
+    unsigned int i;
+
+    for (i = 0; i < (sizeof(extensionList) / sizeof(*extensionList)); i++) {
+        *extensionList[i].fnptr = eglGetProcAddress(extensionList[i].name);
+        if (*extensionList[i].fnptr == NULL) {
+            printf("Couldn't get address of %s()\n", extensionList[i].name);
+            return 0;
+        }
+    }
+
+    return 1;
+}
+
+int EGLStreamInit(int *cuda_device)
+{
+    static const EGLint streamAttrMailboxMode[] = {EGL_SUPPORT_REUSE_NV, EGL_FALSE, EGL_NONE};
+    EGLBoolean          eglStatus;
+#define MAX_EGL_DEVICES 4
+    EGLint       numDevices = 0;
+    EGLDeviceEXT devices[MAX_EGL_DEVICES];
+    eglStatus = eglQueryDevicesEXT(MAX_EGL_DEVICES, devices, &numDevices);
+    if (eglStatus != EGL_TRUE) {
+        printf("Error querying EGL devices\n");
+        exit(EXIT_FAILURE);
+    }
+
+    if (numDevices == 0) {
+        printf("No EGL devices found.. Waiving\n");
+        eglStatus = EGL_FALSE;
+        exit(EXIT_WAIVED);
+    }
+
+    int egl_device_id = 0;
+    for (egl_device_id = 0; egl_device_id < numDevices; egl_device_id++) {
+        eglStatus = eglQueryDeviceAttribEXT(devices[egl_device_id], EGL_CUDA_DEVICE_NV, &cudaIndex);
+        if (eglStatus == EGL_TRUE) {
+            *cuda_device = cudaIndex; // We select first EGL-CUDA Capable device.
+            printf("Found EGL-CUDA Capable device with CUDA Device id = %d\n", (int)cudaIndex);
+            break;
+        }
+    }
+
+    if (egl_device_id >= numDevices) {
+        printf("No CUDA Capable EGL Device found.. Waiving execution\n");
+        exit(EXIT_WAIVED);
+    }
+
+    g_display = eglGetPlatformDisplayEXT(EGL_PLATFORM_DEVICE_EXT, (void *)devices[egl_device_id], NULL);
+    if (g_display == EGL_NO_DISPLAY) {
+        printf("Could not get EGL display from device. \n");
+        eglStatus = EGL_FALSE;
+        exit(EXIT_FAILURE);
+    }
+
+    eglStatus = eglInitialize(g_display, 0, 0);
+    if (!eglStatus) {
+        printf("EGL failed to initialize. \n");
+        eglStatus = EGL_FALSE;
+        exit(EXIT_FAILURE);
+    }
+
+    eglStream = eglCreateStreamKHR(g_display, streamAttrMailboxMode);
+    if (eglStream == EGL_NO_STREAM_KHR) {
+        printf("Could not create EGL stream.\n");
+        eglStatus = EGL_FALSE;
+        exit(EXIT_FAILURE);
+    }
+
+    printf("Created EGLStream %p\n", eglStream);
+
+    // Set stream attribute
+    if (!eglStreamAttribKHR(g_display, eglStream, EGL_CONSUMER_LATENCY_USEC_KHR, 16000)) {
+        printf("Consumer: eglStreamAttribKHR EGL_CONSUMER_LATENCY_USEC_KHR failed\n");
+        return 0;
+    }
+    if (!eglStreamAttribKHR(g_display, eglStream, EGL_CONSUMER_ACQUIRE_TIMEOUT_USEC_KHR, 16000)) {
+        printf("Consumer: eglStreamAttribKHR EGL_CONSUMER_ACQUIRE_TIMEOUT_USEC_KHR "
+               "failed\n");
+        return 0;
+    }
+    printf("EGLStream initialized\n");
+    return 1;
+}
+
+void EGLStreamFini(void) { eglDestroyStreamKHR(g_display, eglStream); }
+#endif

cpp/2_Concepts_and_Techniques/EGLStream_CUDA_Interop/eglstrm_common.h

@@ -0,0 +1,100 @@
+/* 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.
+ */
+
+//
+// DESCRIPTION:   Common EGL stream functions header file
+//
+
+#ifndef _EGLSTRM_COMMON_H_
+#define _EGLSTRM_COMMON_H_
+
+#include <signal.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <unistd.h>
+
+#include "cuda.h"
+#include "cudaEGL.h"
+#include "helper_cuda_drvapi.h"
+
+#define EXTENSION_LIST(T)                                                                  \
+    T(PFNEGLCREATESTREAMKHRPROC, eglCreateStreamKHR)                                       \
+    T(PFNEGLDESTROYSTREAMKHRPROC, eglDestroyStreamKHR)                                     \
+    T(PFNEGLQUERYSTREAMKHRPROC, eglQueryStreamKHR)                                         \
+    T(PFNEGLQUERYSTREAMU64KHRPROC, eglQueryStreamu64KHR)                                   \
+    T(PFNEGLQUERYSTREAMTIMEKHRPROC, eglQueryStreamTimeKHR)                                 \
+    T(PFNEGLSTREAMATTRIBKHRPROC, eglStreamAttribKHR)                                       \
+    T(PFNEGLSTREAMCONSUMERACQUIREKHRPROC, eglStreamConsumerAcquireKHR)                     \
+    T(PFNEGLSTREAMCONSUMERRELEASEKHRPROC, eglStreamConsumerReleaseKHR)                     \
+    T(PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALKHRPROC, eglStreamConsumerGLTextureExternalKHR) \
+    T(PFNEGLGETSTREAMFILEDESCRIPTORKHRPROC, eglGetStreamFileDescriptorKHR)                 \
+    T(PFNEGLQUERYDEVICESEXTPROC, eglQueryDevicesEXT)                                       \
+    T(PFNEGLGETPLATFORMDISPLAYEXTPROC, eglGetPlatformDisplayEXT)                           \
+    T(PFNEGLQUERYDEVICEATTRIBEXTPROC, eglQueryDeviceAttribEXT)                             \
+    T(PFNEGLCREATESTREAMFROMFILEDESCRIPTORKHRPROC, eglCreateStreamFromFileDescriptorKHR)
+
+#define eglCreateStreamKHR                    my_eglCreateStreamKHR
+#define eglDestroyStreamKHR                   my_eglDestroyStreamKHR
+#define eglQueryStreamKHR                     my_eglQueryStreamKHR
+#define eglQueryStreamu64KHR                  my_eglQueryStreamu64KHR
+#define eglQueryStreamTimeKHR                 my_eglQueryStreamTimeKHR
+#define eglStreamAttribKHR                    my_eglStreamAttribKHR
+#define eglStreamConsumerAcquireKHR           my_eglStreamConsumerAcquireKHR
+#define eglStreamConsumerReleaseKHR           my_eglStreamConsumerReleaseKHR
+#define eglStreamConsumerGLTextureExternalKHR my_eglStreamConsumerGLTextureExternalKHR
+#define eglGetStreamFileDescriptorKHR         my_eglGetStreamFileDescriptorKHR
+#define eglCreateStreamFromFileDescriptorKHR  my_eglCreateStreamFromFileDescriptorKHR
+#define eglQueryDevicesEXT                    my_eglQueryDevicesEXT
+#define eglGetPlatformDisplayEXT              my_eglGetPlatformDisplayEXT
+#define eglQueryDeviceAttribEXT               my_eglQueryDeviceAttribEXT
+
+#define EXTLST_DECL(tx, x)   tx my_##x = NULL;
+#define EXTLST_EXTERN(tx, x) extern tx my_##x;
+#define EXTLST_ENTRY(tx, x)  {(extlst_fnptr_t *)&my_##x, #x},
+
+#define MAX_STRING_SIZE 256
+#define WIDTH           720
+#define HEIGHT          480
+
+typedef struct _TestArgs
+{
+    char        *infile1;
+    char        *infile2;
+    bool         isARGB;
+    unsigned int inputWidth;
+    unsigned int inputHeight;
+    bool         pitchLinearOutput;
+} TestArgs;
+
+int  eglSetupExtensions(void);
+int  EGLStreamInit(int *dev);
+void EGLStreamFini(void);
+#endif

cpp/2_Concepts_and_Techniques/EGLStream_CUDA_Interop/main.cpp

@@ -0,0 +1,232 @@
+/* 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.
+ */
+//
+// DESCRIPTION:   Simple EGL stream sample app
+//
+//
+
+// #define EGL_EGLEXT_PROTOTYPES
+
+#include "cudaEGL.h"
+#include "cuda_consumer.h"
+#include "cuda_producer.h"
+#include "eglstrm_common.h"
+
+/* ------  globals ---------*/
+
+#if defined(EXTENSION_LIST)
+EXTENSION_LIST(EXTLST_EXTERN)
+#endif
+
+#define NUM_TRAILS 4
+
+bool signal_stop = 0;
+
+static void sig_handler(int sig)
+{
+    signal_stop = 1;
+    printf("Signal: %d\n", sig);
+}
+
+int main(int argc, char **argv)
+{
+    TestArgs     args;
+    CUresult     curesult = CUDA_SUCCESS;
+    unsigned int i, j;
+    EGLint       streamState = 0;
+
+    test_cuda_consumer_s cudaConsumer;
+    test_cuda_producer_s cudaProducer;
+
+    memset(&cudaProducer, 0, sizeof(test_cuda_producer_s));
+    memset(&cudaConsumer, 0, sizeof(test_cuda_consumer_s));
+
+    // Hook up Ctrl-C handler
+    signal(SIGINT, sig_handler);
+    if (!eglSetupExtensions()) {
+        printf("SetupExtentions failed \n");
+        curesult = CUDA_ERROR_UNKNOWN;
+        goto done;
+    }
+
+    checkCudaErrors(cuInit(0));
+
+    int count;
+
+    checkCudaErrors(cuDeviceGetCount(&count));
+    printf("Found %d cuda devices\n", count);
+
+    CUdevice devId;
+
+    if (!EGLStreamInit(&devId)) {
+        printf("EGLStream Init failed.\n");
+        curesult = CUDA_ERROR_UNKNOWN;
+        goto done;
+    }
+    curesult = cudaDeviceCreateProducer(&cudaProducer, devId);
+    if (curesult != CUDA_SUCCESS) {
+        goto done;
+    }
+    curesult = cudaDeviceCreateConsumer(&cudaConsumer, devId);
+    if (curesult != CUDA_SUCCESS) {
+        goto done;
+    }
+    checkCudaErrors(cuCtxPushCurrent(cudaConsumer.context));
+    if (CUDA_SUCCESS != (curesult = cuEGLStreamConsumerConnect(&(cudaConsumer.cudaConn), eglStream))) {
+        printf("FAILED Connect CUDA consumer  with error %d\n", curesult);
+        goto done;
+    }
+    else {
+        printf("Connected CUDA consumer, CudaConsumer %p\n", cudaConsumer.cudaConn);
+    }
+    checkCudaErrors(cuCtxPopCurrent(&cudaConsumer.context));
+
+    checkCudaErrors(cuCtxPushCurrent(cudaProducer.context));
+    if (CUDA_SUCCESS == (curesult = cuEGLStreamProducerConnect(&(cudaProducer.cudaConn), eglStream, WIDTH, HEIGHT))) {
+        printf("Connect CUDA producer Done, CudaProducer %p\n", cudaProducer.cudaConn);
+    }
+    else {
+        printf("Connect CUDA producer FAILED with error %d\n", curesult);
+        goto done;
+    }
+    checkCudaErrors(cuCtxPopCurrent(&cudaProducer.context));
+
+    // Initialize producer
+    for (i = 0; i < NUM_TRAILS; i++) {
+        if (streamState != EGL_STREAM_STATE_CONNECTING_KHR) {
+            if (!eglQueryStreamKHR(g_display, eglStream, EGL_STREAM_STATE_KHR, &streamState)) {
+                printf("main: eglQueryStreamKHR EGL_STREAM_STATE_KHR failed\n");
+                curesult = CUDA_ERROR_UNKNOWN;
+                goto done;
+            }
+        }
+        args.inputWidth  = WIDTH;
+        args.inputHeight = HEIGHT;
+        if (i % 2 != 0) {
+            args.isARGB  = 1;
+            args.infile1 = sdkFindFilePath("cuda_f_1.yuv", argv[0]);
+            args.infile2 = sdkFindFilePath("cuda_f_2.yuv", argv[0]);
+        }
+        else {
+            args.isARGB  = 0;
+            args.infile1 = sdkFindFilePath("cuda_yuv_f_1.yuv", argv[0]);
+            args.infile2 = sdkFindFilePath("cuda_yuv_f_2.yuv", argv[0]);
+        }
+        if ((i % 4) < 2) {
+            args.pitchLinearOutput = 1;
+        }
+        else {
+            args.pitchLinearOutput = 0;
+        }
+
+        checkCudaErrors(cuCtxPushCurrent(cudaProducer.context));
+        cudaProducerInit(&cudaProducer, g_display, eglStream, &args);
+        checkCudaErrors(cuCtxPopCurrent(&cudaProducer.context));
+
+        checkCudaErrors(cuCtxPushCurrent(cudaConsumer.context));
+        cuda_consumer_init(&cudaConsumer, &args);
+        checkCudaErrors(cuCtxPopCurrent(&cudaConsumer.context));
+
+        printf("main - Cuda Producer and Consumer Initialized.\n");
+
+        for (j = 0; j < 2; j++) {
+            printf("Running for %s frame and %s input\n",
+                   args.isARGB ? "ARGB" : "YUV",
+                   args.pitchLinearOutput ? "Pitchlinear" : "BlockLinear");
+            if (j == 0) {
+                checkCudaErrors(cuCtxPushCurrent(cudaProducer.context));
+                curesult = cudaProducerTest(&cudaProducer, cudaProducer.fileName1);
+                if (curesult != CUDA_SUCCESS) {
+                    printf("Cuda Producer Test failed for frame = %d\n", j + 1);
+                    goto done;
+                }
+                checkCudaErrors(cuCtxPopCurrent(&cudaProducer.context));
+                checkCudaErrors(cuCtxPushCurrent(cudaConsumer.context));
+                curesult = cudaConsumerTest(&cudaConsumer, cudaConsumer.outFile1);
+                if (curesult != CUDA_SUCCESS) {
+                    printf("Cuda Consumer Test failed for frame = %d\n", j + 1);
+                    goto done;
+                }
+                checkCudaErrors(cuCtxPopCurrent(&cudaConsumer.context));
+            }
+            else {
+                checkCudaErrors(cuCtxPushCurrent(cudaProducer.context));
+                curesult = cudaProducerTest(&cudaProducer, cudaProducer.fileName2);
+                if (curesult != CUDA_SUCCESS) {
+                    printf("Cuda Producer Test failed for frame = %d\n", j + 1);
+                    goto done;
+                }
+
+                checkCudaErrors(cuCtxPopCurrent(&cudaProducer.context));
+                checkCudaErrors(cuCtxPushCurrent(cudaConsumer.context));
+                curesult = cudaConsumerTest(&cudaConsumer, cudaConsumer.outFile2);
+                if (curesult != CUDA_SUCCESS) {
+                    printf("Cuda Consumer Test failed for frame = %d\n", j + 1);
+                    goto done;
+                }
+                checkCudaErrors(cuCtxPopCurrent(&cudaConsumer.context));
+            }
+        }
+    }
+
+    checkCudaErrors(cuCtxPushCurrent(cudaProducer.context));
+    if (CUDA_SUCCESS != (curesult = cudaProducerDeinit(&cudaProducer))) {
+        printf("Producer Disconnect FAILED. \n");
+        goto done;
+    }
+    checkCudaErrors(cuCtxPopCurrent(&cudaProducer.context));
+
+    if (!eglQueryStreamKHR(g_display, eglStream, EGL_STREAM_STATE_KHR, &streamState)) {
+        printf("Cuda consumer, eglQueryStreamKHR EGL_STREAM_STATE_KHR failed\n");
+        curesult = CUDA_ERROR_UNKNOWN;
+        goto done;
+    }
+    if (streamState != EGL_STREAM_STATE_DISCONNECTED_KHR) {
+        if (CUDA_SUCCESS != (curesult = cuda_consumer_deinit(&cudaConsumer))) {
+            printf("Consumer Disconnect FAILED.\n");
+            goto done;
+        }
+    }
+    printf("Producer and Consumer Disconnected \n");
+
+done:
+    if (!eglQueryStreamKHR(g_display, eglStream, EGL_STREAM_STATE_KHR, &streamState)) {
+        printf("Cuda consumer, eglQueryStreamKHR EGL_STREAM_STATE_KHR failed\n");
+        curesult = CUDA_ERROR_UNKNOWN;
+    }
+    if (streamState != EGL_STREAM_STATE_DISCONNECTED_KHR) {
+        EGLStreamFini();
+    }
+
+    if (curesult == CUDA_SUCCESS) {
+        printf("&&&& EGLStream interop test PASSED\n");
+    }
+    else {
+        printf("&&&& EGLStream interop test FAILED\n");
+    }
+    return 0;
+}

cpp/2_Concepts_and_Techniques/FunctionPointers/.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/2_Concepts_and_Techniques/FunctionPointers/.vscode/extensions.json

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

cpp/2_Concepts_and_Techniques/FunctionPointers/CMakeLists.txt

@@ -0,0 +1,96 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../../cmake/Modules")
+
+project(FunctionPointers 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)
+
+if(WIN32)
+    set(PC_GLUT_INCLUDE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/../../../Common")
+    set(PC_GLUT_LIBRARY_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/../../../Common/lib/x64")
+    # The GLEW library built on Windows on Arm system is named as glew32.lib/glew32.dll by default.
+    if(EXISTS "${PC_GLUT_LIBRARY_DIRS}/glew32.lib")
+        set(GLEW_LIB_NAME "glew32")
+    else()
+        set(GLEW_LIB_NAME "glew64")
+    endif()
+endif()
+
+find_package(OpenGL)
+find_package(GLUT)
+
+# Source file
+if(${OpenGL_FOUND})
+    if (${GLUT_FOUND})
+        # Add target for FunctionPointers
+        add_executable(FunctionPointers FunctionPointers.cpp FunctionPointers_kernels.cu)
+
+        target_compile_options(FunctionPointers PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+        target_compile_features(FunctionPointers PRIVATE cxx_std_17 cuda_std_17)
+
+        set_target_properties(FunctionPointers PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
+
+        target_include_directories(FunctionPointers PUBLIC
+            ${OPENGL_INCLUDE_DIR}
+            ${CUDAToolkit_INCLUDE_DIRS}
+            ${GLUT_INCLUDE_DIRS}
+        )
+
+        target_link_libraries(FunctionPointers
+            ${OPENGL_LIBRARIES}
+            ${GLUT_LIBRARIES}
+        )
+
+        # Copy data files to output directory
+        add_custom_command(TARGET FunctionPointers POST_BUILD
+            COMMAND ${CMAKE_COMMAND} -E copy_directory
+            ${CMAKE_CURRENT_SOURCE_DIR}/data
+            ${CMAKE_CURRENT_BINARY_DIR}/data
+        )
+
+        if(WIN32)
+            target_link_libraries(FunctionPointers
+                ${PC_GLUT_LIBRARY_DIRS}/freeglut.lib
+                ${PC_GLUT_LIBRARY_DIRS}/${GLEW_LIB_NAME}.lib
+            )
+
+            add_custom_command(TARGET FunctionPointers
+                POST_BUILD
+                COMMAND ${CMAKE_COMMAND} -E copy
+                ${CMAKE_CURRENT_SOURCE_DIR}/../../../bin/win64/$<CONFIGURATION>/freeglut.dll
+                ${CMAKE_CURRENT_BINARY_DIR}/$<CONFIGURATION>
+            )
+
+            add_custom_command(TARGET FunctionPointers
+                POST_BUILD
+                COMMAND ${CMAKE_COMMAND} -E copy
+                ${CMAKE_CURRENT_SOURCE_DIR}/../../../bin/win64/$<CONFIGURATION>/${GLEW_LIB_NAME}.dll
+                ${CMAKE_CURRENT_BINARY_DIR}/$<CONFIGURATION>
+            )
+        endif()
+
+    else()
+        message(STATUS "GLUT not found - will not build sample 'FunctionPointers'")
+    endif()
+else()
+    message(STATUS "OpenGL not found - will not build sample 'FunctionPointers'")
+endif()
+
+# Include installation configuration
+include(${CMAKE_CURRENT_SOURCE_DIR}/../../../cmake/InstallSamples.cmake)
+setup_samples_install()

cpp/2_Concepts_and_Techniques/FunctionPointers/FunctionPointers.cpp

@@ -0,0 +1,506 @@
+/* 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.
+ */
+
+// OpenGL Graphics includes
+#include <helper_gl.h>
+#if defined(__APPLE__) || defined(MACOSX)
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#include <GLUT/glut.h>
+#ifndef glutCloseFunc
+#define glutCloseFunc glutWMCloseFunc
+#endif
+#else
+#include <GL/freeglut.h>
+#endif
+
+// Includes
+#include <cuda_gl_interop.h>  // CUDA OpenGL interop
+#include <cuda_runtime.h>     // CUDA Runtime
+#include <helper_cuda.h>      // includes for CUDA initialization and error checking
+#include <helper_functions.h> // helper functions for timing, string parsing
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "FunctionPointers_kernels.h"
+
+#define EXIT_WAIVED 2
+
+//
+// Cuda example code that implements the Sobel edge detection
+// filter. This code works for 8-bit monochrome images.
+//
+// Use the '-' and '=' keys to change the scale factor.
+//
+// Other keys:
+// I: display image
+// T: display Sobel Edge Detection (computed solely with texture)
+// S: display Sobel Edge Detection (computed with texture and shared memory)
+
+void cleanup(void);
+void initializeData(char *file);
+
+#define MAX_EPSILON_ERROR 5.0f
+
+static const char *sSDKsample = "CUDA Function Pointers (SobelFilter)";
+
+const char *filterMode[] = {"No Filtering", "Sobel Texture", "Sobel SMEM+Texture", NULL};
+
+static int wWidth   = 512; // Window width
+static int wHeight  = 512; // Window height
+static int imWidth  = 0;   // Image width
+static int imHeight = 0;   // Image height
+static int blockOp  = 0;
+static int pointOp  = 1;
+
+// Code to handle Auto verification
+const int           frameCheckNumber = 4;
+int                 fpsCount         = 0; // FPS count for averaging
+int                 fpsLimit         = 8; // FPS limit for sampling
+unsigned int        frameCount       = 0;
+StopWatchInterface *timer            = NULL;
+unsigned int        g_Bpp;
+
+int g_TotalErrors = 0;
+
+int   *pArgc = NULL;
+char **pArgv = NULL;
+
+bool g_bQAReadback = false;
+
+// Display Data
+static GLuint                pbo_buffer = 0;    // Front and back CA buffers
+struct cudaGraphicsResource *cuda_pbo_resource; // CUDA Graphics Resource (to transfer PBO)
+
+static GLuint         texid      = 0;    // Texture for display
+unsigned char        *pixels     = NULL; // Image pixel data on the host
+float                 imageScale = 1.f;  // Image exposure
+enum SobelDisplayMode g_SobelDisplayMode;
+
+#define OFFSET(i)     ((char *)NULL + (i))
+#define MAX(a, b)     ((a > b) ? a : b)
+#define REFRESH_DELAY 10 // ms
+
+void computeFPS()
+{
+    frameCount++;
+    fpsCount++;
+
+    if (fpsCount == fpsLimit) {
+        char  fps[256];
+        float ifps = 1.f / (sdkGetAverageTimerValue(&timer) / 1000.f);
+        sprintf(fps, "FunctionPointers [CUDA Edge Detection] (%s): %3.1f fps", filterMode[g_SobelDisplayMode], ifps);
+
+        glutSetWindowTitle(fps);
+        fpsCount = 0;
+
+        fpsLimit = (int)MAX(ifps, 1.f);
+        sdkResetTimer(&timer);
+    }
+}
+
+// This is the normal display path
+void display(void)
+{
+    sdkStartTimer(&timer);
+
+    // Sobel operation
+    Pixel *data = NULL;
+
+    // map PBO to get CUDA device pointer
+    checkCudaErrors(cudaGraphicsMapResources(1, &cuda_pbo_resource, 0));
+    size_t num_bytes;
+    checkCudaErrors(cudaGraphicsResourceGetMappedPointer((void **)&data, &num_bytes, cuda_pbo_resource));
+    // printf("CUDA mapped PBO: May access %ld bytes\n", num_bytes);
+
+    sobelFilter(data, imWidth, imHeight, g_SobelDisplayMode, imageScale, blockOp, pointOp);
+    checkCudaErrors(cudaGraphicsUnmapResources(1, &cuda_pbo_resource, 0));
+
+    glClear(GL_COLOR_BUFFER_BIT);
+
+    glBindTexture(GL_TEXTURE_2D, texid);
+    glBindBuffer(GL_PIXEL_UNPACK_BUFFER, pbo_buffer);
+    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, imWidth, imHeight, GL_LUMINANCE, GL_UNSIGNED_BYTE, OFFSET(0));
+    glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
+
+    glDisable(GL_DEPTH_TEST);
+    glEnable(GL_TEXTURE_2D);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+
+    glBegin(GL_QUADS);
+    glVertex2f(0, 0);
+    glTexCoord2f(0, 0);
+    glVertex2f(0, 1);
+    glTexCoord2f(1, 0);
+    glVertex2f(1, 1);
+    glTexCoord2f(1, 1);
+    glVertex2f(1, 0);
+    glTexCoord2f(0, 1);
+    glEnd();
+    glBindTexture(GL_TEXTURE_2D, 0);
+
+    glutSwapBuffers();
+
+    sdkStopTimer(&timer);
+    computeFPS();
+}
+
+void timerEvent(int value)
+{
+    if (glutGetWindow()) {
+        glutPostRedisplay();
+        glutTimerFunc(REFRESH_DELAY, timerEvent, 0);
+    }
+}
+
+void keyboard(unsigned char key, int /*x*/, int /*y*/)
+{
+    char temp[256];
+
+    switch (key) {
+    case 27:
+#if defined(__APPLE__) || defined(MACOSX)
+        exit(EXIT_SUCCESS);
+#else
+        glutDestroyWindow(glutGetWindow());
+        return;
+#endif
+        break;
+
+    case '-':
+        imageScale -= 0.1f;
+        printf("brightness = %4.2f\n", imageScale);
+        break;
+
+    case '=':
+        imageScale += 0.1f;
+        printf("brightness = %4.2f\n", imageScale);
+        break;
+
+    case 'i':
+    case 'I':
+        g_SobelDisplayMode = SOBELDISPLAY_IMAGE;
+        sprintf(temp, "Function Pointers [CUDA Edge Detection] (%s)", filterMode[g_SobelDisplayMode]);
+        glutSetWindowTitle(temp);
+        break;
+
+    case 's':
+    case 'S':
+        g_SobelDisplayMode = SOBELDISPLAY_SOBELSHARED;
+        sprintf(temp, "Function Pointers [CUDA Edge Detection] (%s)", filterMode[g_SobelDisplayMode]);
+        glutSetWindowTitle(temp);
+        break;
+
+    case 't':
+    case 'T':
+        g_SobelDisplayMode = SOBELDISPLAY_SOBELTEX;
+        sprintf(temp, "Function Pointers [CUDA Edge Detection] (%s)", filterMode[g_SobelDisplayMode]);
+        glutSetWindowTitle(temp);
+        break;
+
+    case 'b':
+    case 'B':
+        blockOp = (blockOp + 1) % LAST_BLOCK_FILTER;
+        break;
+
+    case 'p':
+    case 'P':
+        pointOp = (pointOp + 1) % LAST_POINT_FILTER;
+        break;
+
+    default:
+        break;
+    }
+}
+
+void reshape(int x, int y)
+{
+    glViewport(0, 0, x, y);
+    glMatrixMode(GL_PROJECTION);
+    glLoadIdentity();
+    glOrtho(0, 1, 0, 1, 0, 1);
+    glMatrixMode(GL_MODELVIEW);
+    glLoadIdentity();
+}
+
+void cleanup(void)
+{
+    cudaGraphicsUnregisterResource(cuda_pbo_resource);
+
+    glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
+    glDeleteBuffers(1, &pbo_buffer);
+    glDeleteTextures(1, &texid);
+    deleteTexture();
+
+    sdkDeleteTimer(&timer);
+}
+
+void initializeData(char *file)
+{
+    GLint        bsize;
+    unsigned int w, h;
+    size_t       file_length = strlen(file);
+
+    if (!strcmp(&file[file_length - 3], "pgm")) {
+        if (sdkLoadPGM<unsigned char>(file, &pixels, &w, &h) != true) {
+            printf("Failed to load PGM image file: %s\n", file);
+            exit(EXIT_FAILURE);
+        }
+
+        g_Bpp = 1;
+    }
+    else if (!strcmp(&file[file_length - 3], "ppm")) {
+        if (sdkLoadPPM4(file, &pixels, &w, &h) != true) {
+            printf("Failed to load PPM image file: %s\n", file);
+            exit(EXIT_FAILURE);
+        }
+
+        g_Bpp = 4;
+    }
+    else {
+        exit(EXIT_FAILURE);
+    }
+
+    imWidth  = (int)w;
+    imHeight = (int)h;
+    setupTexture(imWidth, imHeight, pixels, g_Bpp);
+
+    // copy function pointer tables to host side for later use
+    setupFunctionTables();
+
+    memset(pixels, 0x0, g_Bpp * sizeof(Pixel) * imWidth * imHeight);
+
+    if (!g_bQAReadback) {
+        // use OpenGL Path
+        glGenBuffers(1, &pbo_buffer);
+        glBindBuffer(GL_PIXEL_UNPACK_BUFFER, pbo_buffer);
+        glBufferData(GL_PIXEL_UNPACK_BUFFER, g_Bpp * sizeof(Pixel) * imWidth * imHeight, pixels, GL_STREAM_DRAW);
+
+        glGetBufferParameteriv(GL_PIXEL_UNPACK_BUFFER, GL_BUFFER_SIZE, &bsize);
+
+        if ((GLuint)bsize != (g_Bpp * sizeof(Pixel) * imWidth * imHeight)) {
+            printf("Buffer object (%d) has incorrect size (%d).\n", (unsigned)pbo_buffer, (unsigned)bsize);
+            exit(EXIT_FAILURE);
+        }
+
+        glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
+
+        // register this buffer object with CUDA
+        checkCudaErrors(cudaGraphicsGLRegisterBuffer(&cuda_pbo_resource, pbo_buffer, cudaGraphicsMapFlagsWriteDiscard));
+
+        glGenTextures(1, &texid);
+        glBindTexture(GL_TEXTURE_2D, texid);
+        glTexImage2D(GL_TEXTURE_2D,
+                     0,
+                     ((g_Bpp == 1) ? GL_LUMINANCE : GL_BGRA),
+                     imWidth,
+                     imHeight,
+                     0,
+                     GL_LUMINANCE,
+                     GL_UNSIGNED_BYTE,
+                     NULL);
+        glBindTexture(GL_TEXTURE_2D, 0);
+
+        glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+        glPixelStorei(GL_PACK_ALIGNMENT, 1);
+    }
+}
+
+void loadDefaultImage(char *loc_exec)
+{
+    printf("Reading image: teapot512.pgm\n");
+    const char *image_filename = "teapot512.pgm";
+    char       *image_path     = sdkFindFilePath(image_filename, loc_exec);
+
+    if (image_path == NULL) {
+        printf("Failed to read image file: <%s>\n", image_filename);
+        exit(EXIT_FAILURE);
+    }
+
+    initializeData(image_path);
+    free(image_path);
+}
+
+void initGL(int *argc, char **argv)
+{
+    glutInit(argc, argv);
+    glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
+    glutInitWindowSize(wWidth, wHeight);
+    glutCreateWindow("Function Pointers [CUDA Edge Detection]n");
+
+    if (!isGLVersionSupported(1, 5)
+        || !areGLExtensionsSupported("GL_ARB_vertex_buffer_object GL_ARB_pixel_buffer_object")) {
+        fprintf(stderr, "Error: failed to get minimal extensions for demo\n");
+        fprintf(stderr, "This sample requires:\n");
+        fprintf(stderr, "  OpenGL version 1.5\n");
+        fprintf(stderr, "  GL_ARB_vertex_buffer_object\n");
+        fprintf(stderr, "  GL_ARB_pixel_buffer_object\n");
+
+        exit(EXIT_WAIVED);
+    }
+}
+
+void runAutoTest(int argc, char *argv[])
+{
+    printf("[%s] (automated testing w/ readback)\n", sSDKsample);
+    int devID = findCudaDevice(argc, (const char **)argv);
+
+    loadDefaultImage(argv[0]);
+
+    Pixel *d_result;
+    checkCudaErrors(cudaMalloc((void **)&d_result, imWidth * imHeight * sizeof(Pixel)));
+
+    char *ref_file = NULL;
+    char  dump_file[256];
+
+    int mode = 0;
+    mode     = getCmdLineArgumentInt(argc, (const char **)argv, "mode");
+    getCmdLineArgumentString(argc, (const char **)argv, "file", &ref_file);
+
+    switch (mode) {
+    case 0:
+        g_SobelDisplayMode = SOBELDISPLAY_IMAGE;
+        sprintf(dump_file, "teapot512_orig.pgm");
+        break;
+
+    case 1:
+        g_SobelDisplayMode = SOBELDISPLAY_SOBELTEX;
+        sprintf(dump_file, "teapot512_tex.pgm");
+        break;
+
+    case 2:
+        g_SobelDisplayMode = SOBELDISPLAY_SOBELSHARED;
+        sprintf(dump_file, "teapot512_shared.pgm");
+        break;
+
+    default:
+        printf("Invalid Filter Mode File\n");
+        exit(EXIT_FAILURE);
+        break;
+    }
+
+    printf("AutoTest: %s <%s>\n", sSDKsample, filterMode[g_SobelDisplayMode]);
+    sobelFilter(d_result, imWidth, imHeight, g_SobelDisplayMode, imageScale, blockOp, pointOp);
+    checkCudaErrors(cudaDeviceSynchronize());
+
+    unsigned char *h_result = (unsigned char *)malloc(imWidth * imHeight * sizeof(Pixel));
+    checkCudaErrors(cudaMemcpy(h_result, d_result, imWidth * imHeight * sizeof(Pixel), cudaMemcpyDeviceToHost));
+    sdkSavePGM(dump_file, h_result, imWidth, imHeight);
+
+    if (!sdkComparePGM(dump_file, sdkFindFilePath(ref_file, argv[0]), MAX_EPSILON_ERROR, 0.15f, false)) {
+        g_TotalErrors++;
+    }
+
+    checkCudaErrors(cudaFree(d_result));
+    free(h_result);
+
+    if (g_TotalErrors != 0) {
+        printf("Test failed!\n");
+        exit(EXIT_FAILURE);
+    }
+
+    printf("Test passed!\n");
+    exit(EXIT_SUCCESS);
+}
+
+int main(int argc, char **argv)
+{
+    pArgc = &argc;
+    pArgv = argv;
+
+#if defined(__linux__)
+    setenv("DISPLAY", ":0", 0);
+#endif
+
+    printf("%s Starting...\n\n", argv[0]);
+
+    if (checkCmdLineFlag(argc, (const char **)argv, "help")) {
+        printf("\nUsage: FunctionPointers (SobelFilter) <options>\n");
+        printf("\t\t-mode=n (0=original, 1=texture, 2=smem + texture)\n");
+        printf("\t\t-file=ref_orig.pgm (ref_tex.pgm, ref_shared.pgm)\n\n");
+
+        exit(EXIT_WAIVED);
+    }
+
+    if (checkCmdLineFlag(argc, (const char **)argv, "file")) {
+        g_bQAReadback = true;
+        runAutoTest(argc, argv);
+    }
+
+    // use command-line specified CUDA device, otherwise use device with highest
+    // Gflops/s
+    if (checkCmdLineFlag(argc, (const char **)argv, "device")) {
+        printf("   This SDK does not explicitly support -device=n when running with "
+               "OpenGL.\n");
+        printf("   When specifying -device=n (n=0,1,2,....) the sample must not use "
+               "OpenGL.\n");
+        printf("   See details below to run without OpenGL:\n\n");
+        printf(" > %s -device=n\n\n", argv[0]);
+        printf("exiting...\n");
+
+        exit(EXIT_WAIVED);
+    }
+
+    if (!g_bQAReadback) {
+        // First initialize OpenGL context, so we can properly set the GL for CUDA.
+        // This is necessary in order to achieve optimal performance with
+        // OpenGL/CUDA interop.
+        initGL(&argc, argv);
+
+        int dev = findCudaDevice(argc, (const char **)argv);
+
+        sdkCreateTimer(&timer);
+        sdkResetTimer(&timer);
+
+        glutDisplayFunc(display);
+        glutKeyboardFunc(keyboard);
+        glutReshapeFunc(reshape);
+
+        loadDefaultImage(argv[0]);
+
+        // If code is not printing the USage, then we execute this path.
+        printf("I: display Image (no filtering)\n");
+        printf("T: display Sobel Edge Detection (Using Texture)\n");
+        printf("S: display Sobel Edge Detection (Using SMEM+Texture)\n");
+        printf("Use the '-' and '=' keys to change the brightness.\n");
+        printf("b: switch block filter operation (Mean/Sobel)\n");
+        printf("p: switch point filter operation (Threshold ON/OFF)\n");
+        fflush(stdout);
+
+#if defined(__APPLE__) || defined(MACOSX)
+        atexit(cleanup);
+#else
+        glutCloseFunc(cleanup);
+#endif
+
+        glutTimerFunc(REFRESH_DELAY, timerEvent, 0);
+        glutMainLoop();
+    }
+}

cpp/2_Concepts_and_Techniques/FunctionPointers/FunctionPointers_kernels.cu

@@ -0,0 +1,414 @@
+/* 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 <cooperative_groups.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+namespace cg = cooperative_groups;
+
+#include <helper_cuda.h>
+
+#include "FunctionPointers_kernels.h"
+
+// Texture object for reading image
+cudaTextureObject_t             tex;
+extern __shared__ unsigned char LocalBlock[];
+static cudaArray               *array = NULL;
+
+#define RADIUS 1
+
+// pixel value used for thresholding function,
+// works well with sample image 'teapot512'
+#define THRESHOLD 150.0f
+
+#ifdef FIXED_BLOCKWIDTH
+#define BlockWidth  80
+#define SharedPitch 384
+#endif
+
+// A function pointer can be declared explicitly like this line:
+//__device__ unsigned char (*pointFunction)(unsigned char, float ) = NULL;
+// or by using typedef's like below:
+
+typedef unsigned char (*blockFunction_t)(unsigned char,
+                                         unsigned char,
+                                         unsigned char,
+                                         unsigned char,
+                                         unsigned char,
+                                         unsigned char,
+                                         unsigned char,
+                                         unsigned char,
+                                         unsigned char,
+                                         float);
+
+typedef unsigned char (*pointFunction_t)(unsigned char, float);
+
+__device__ blockFunction_t blockFunction;
+
+__device__ unsigned char ComputeSobel(unsigned char ul, // upper left
+                                      unsigned char um, // upper middle
+                                      unsigned char ur, // upper right
+                                      unsigned char ml, // middle left
+                                      unsigned char mm, // middle (unused)
+                                      unsigned char mr, // middle right
+                                      unsigned char ll, // lower left
+                                      unsigned char lm, // lower middle
+                                      unsigned char lr, // lower right
+                                      float         fScale)
+{
+    short Horz = ur + 2 * mr + lr - ul - 2 * ml - ll;
+    short Vert = ul + 2 * um + ur - ll - 2 * lm - lr;
+    short Sum  = (short)(fScale * (abs((int)Horz) + abs((int)Vert)));
+    return (unsigned char)((Sum < 0) ? 0 : ((Sum > 255) ? 255 : Sum));
+}
+
+// define a function pointer and initialize to NULL
+__device__ unsigned char (*varFunction)(unsigned char,
+                                        unsigned char,
+                                        unsigned char,
+                                        unsigned char,
+                                        unsigned char,
+                                        unsigned char,
+                                        unsigned char,
+                                        unsigned char,
+                                        unsigned char,
+                                        float x) = NULL;
+
+__device__ unsigned char ComputeBox(unsigned char ul, // upper left
+                                    unsigned char um, // upper middle
+                                    unsigned char ur, // upper right
+                                    unsigned char ml, // middle left
+                                    unsigned char mm, // middle...middle
+                                    unsigned char mr, // middle right
+                                    unsigned char ll, // lower left
+                                    unsigned char lm, // lower middle
+                                    unsigned char lr, // lower right
+                                    float         fscale)
+{
+    short Sum = (short)(ul + um + ur + ml + mm + mr + ll + lm + lr) / 9;
+    Sum *= fscale;
+    return (unsigned char)((Sum < 0) ? 0 : ((Sum > 255) ? 255 : Sum));
+}
+__device__ unsigned char Threshold(unsigned char in, float thresh)
+{
+    if (in > thresh) {
+        return 0xFF;
+    }
+    else {
+        return 0;
+    }
+}
+
+// Declare function tables, one for the point function chosen, one for the
+// block function chosen.  The number of entries is determined by the
+// enum in FunctionPointers_kernels.h
+__device__ blockFunction_t blockFunction_table[LAST_BLOCK_FILTER];
+__device__ pointFunction_t pointFunction_table[LAST_POINT_FILTER];
+
+// Declare device side function pointers.  We retrieve them later with
+// cudaMemcpyFromSymbol to set our function tables above in some
+// particular order specified at runtime.
+__device__ blockFunction_t pComputeSobel     = ComputeSobel;
+__device__ blockFunction_t pComputeBox       = ComputeBox;
+__device__ pointFunction_t pComputeThreshold = Threshold;
+
+// Allocate host side tables to mirror the device side, and later, we
+// fill these tables with the function pointers.  This lets us send
+// the pointers to the kernel on invocation, as a method of choosing
+// which function to run.
+blockFunction_t h_blockFunction_table[2];
+pointFunction_t h_pointFunction_table[2];
+
+// Perform a filter operation on the data, using shared memory
+// The actual operation performed is
+// determined by the function pointer "blockFunction" and selected
+// by the integer argument "blockOperation" and has access
+// to an apron around the current pixel being processed.
+// Following the block operation, a per-pixel operation,
+// pointed to by pPointFunction is performed before the final
+// pixel is produced.
+__global__ void SobelShared(uchar4        *pSobelOriginal,
+                            unsigned short SobelPitch,
+#ifndef FIXED_BLOCKWIDTH
+                            short BlockWidth,
+                            short SharedPitch,
+#endif
+                            short               w,
+                            short               h,
+                            float               fScale,
+                            int                 blockOperation,
+                            pointFunction_t     pPointFunction,
+                            cudaTextureObject_t tex)
+{
+    // Handle to thread block group
+    cg::thread_block cta = cg::this_thread_block();
+    short            u   = 4 * blockIdx.x * BlockWidth;
+    short            v   = blockIdx.y * blockDim.y + threadIdx.y;
+    short            ib;
+
+    int SharedIdx = threadIdx.y * SharedPitch;
+
+    for (ib = threadIdx.x; ib < BlockWidth + 2 * RADIUS; ib += blockDim.x) {
+        LocalBlock[SharedIdx + 4 * ib + 0] =
+            tex2D<unsigned char>(tex, (float)(u + 4 * ib - RADIUS + 0), (float)(v - RADIUS));
+        LocalBlock[SharedIdx + 4 * ib + 1] =
+            tex2D<unsigned char>(tex, (float)(u + 4 * ib - RADIUS + 1), (float)(v - RADIUS));
+        LocalBlock[SharedIdx + 4 * ib + 2] =
+            tex2D<unsigned char>(tex, (float)(u + 4 * ib - RADIUS + 2), (float)(v - RADIUS));
+        LocalBlock[SharedIdx + 4 * ib + 3] =
+            tex2D<unsigned char>(tex, (float)(u + 4 * ib - RADIUS + 3), (float)(v - RADIUS));
+    }
+
+    if (threadIdx.y < RADIUS * 2) {
+        //
+        // copy trailing RADIUS*2 rows of pixels into shared
+        //
+        SharedIdx = (blockDim.y + threadIdx.y) * SharedPitch;
+
+        for (ib = threadIdx.x; ib < BlockWidth + 2 * RADIUS; ib += blockDim.x) {
+            LocalBlock[SharedIdx + 4 * ib + 0] =
+                tex2D<unsigned char>(tex, (float)(u + 4 * ib - RADIUS + 0), (float)(v + blockDim.y - RADIUS));
+            LocalBlock[SharedIdx + 4 * ib + 1] =
+                tex2D<unsigned char>(tex, (float)(u + 4 * ib - RADIUS + 1), (float)(v + blockDim.y - RADIUS));
+            LocalBlock[SharedIdx + 4 * ib + 2] =
+                tex2D<unsigned char>(tex, (float)(u + 4 * ib - RADIUS + 2), (float)(v + blockDim.y - RADIUS));
+            LocalBlock[SharedIdx + 4 * ib + 3] =
+                tex2D<unsigned char>(tex, (float)(u + 4 * ib - RADIUS + 3), (float)(v + blockDim.y - RADIUS));
+        }
+    }
+
+    cg::sync(cta);
+
+    u >>= 2; // index as uchar4 from here
+    uchar4 *pSobel = (uchar4 *)(((char *)pSobelOriginal) + v * SobelPitch);
+    SharedIdx      = threadIdx.y * SharedPitch;
+
+    blockFunction = blockFunction_table[blockOperation];
+
+    for (ib = threadIdx.x; ib < BlockWidth; ib += blockDim.x) {
+        uchar4 out;
+
+        unsigned char pix00 = LocalBlock[SharedIdx + 4 * ib + 0 * SharedPitch + 0];
+        unsigned char pix01 = LocalBlock[SharedIdx + 4 * ib + 0 * SharedPitch + 1];
+        unsigned char pix02 = LocalBlock[SharedIdx + 4 * ib + 0 * SharedPitch + 2];
+        unsigned char pix10 = LocalBlock[SharedIdx + 4 * ib + 1 * SharedPitch + 0];
+        unsigned char pix11 = LocalBlock[SharedIdx + 4 * ib + 1 * SharedPitch + 1];
+        unsigned char pix12 = LocalBlock[SharedIdx + 4 * ib + 1 * SharedPitch + 2];
+        unsigned char pix20 = LocalBlock[SharedIdx + 4 * ib + 2 * SharedPitch + 0];
+        unsigned char pix21 = LocalBlock[SharedIdx + 4 * ib + 2 * SharedPitch + 1];
+        unsigned char pix22 = LocalBlock[SharedIdx + 4 * ib + 2 * SharedPitch + 2];
+
+        out.x = (*blockFunction)(pix00, pix01, pix02, pix10, pix11, pix12, pix20, pix21, pix22, fScale);
+
+        pix00 = LocalBlock[SharedIdx + 4 * ib + 0 * SharedPitch + 3];
+        pix10 = LocalBlock[SharedIdx + 4 * ib + 1 * SharedPitch + 3];
+        pix20 = LocalBlock[SharedIdx + 4 * ib + 2 * SharedPitch + 3];
+        out.y = (*blockFunction)(pix01, pix02, pix00, pix11, pix12, pix10, pix21, pix22, pix20, fScale);
+
+        pix01 = LocalBlock[SharedIdx + 4 * ib + 0 * SharedPitch + 4];
+        pix11 = LocalBlock[SharedIdx + 4 * ib + 1 * SharedPitch + 4];
+        pix21 = LocalBlock[SharedIdx + 4 * ib + 2 * SharedPitch + 4];
+        out.z = (*blockFunction)(pix02, pix00, pix01, pix12, pix10, pix11, pix22, pix20, pix21, fScale);
+
+        pix02 = LocalBlock[SharedIdx + 4 * ib + 0 * SharedPitch + 5];
+        pix12 = LocalBlock[SharedIdx + 4 * ib + 1 * SharedPitch + 5];
+        pix22 = LocalBlock[SharedIdx + 4 * ib + 2 * SharedPitch + 5];
+        out.w = (*blockFunction)(pix00, pix01, pix02, pix10, pix11, pix12, pix20, pix21, pix22, fScale);
+
+        if (pPointFunction != NULL) {
+            out.x = (*pPointFunction)(out.x, THRESHOLD);
+            out.y = (*pPointFunction)(out.y, THRESHOLD);
+            out.z = (*pPointFunction)(out.z, THRESHOLD);
+            out.w = (*pPointFunction)(out.w, THRESHOLD);
+        }
+
+        if (u + ib < w / 4 && v < h) {
+            pSobel[u + ib] = out;
+        }
+    }
+
+    cg::sync(cta);
+}
+
+__global__ void
+SobelCopyImage(Pixel *pSobelOriginal, unsigned int Pitch, int w, int h, float fscale, cudaTextureObject_t tex)
+{
+    unsigned char *pSobel = (unsigned char *)(((char *)pSobelOriginal) + blockIdx.x * Pitch);
+
+    for (int i = threadIdx.x; i < w; i += blockDim.x) {
+        pSobel[i] = min(max((tex2D<unsigned char>(tex, (float)i, (float)blockIdx.x) * fscale), 0.f), 255.f);
+    }
+}
+
+// Perform block and pointer filtering using texture lookups.
+// The block and point operations are determined by the
+// input argument (see comment above for "SobelShared" function)
+__global__ void SobelTex(Pixel              *pSobelOriginal,
+                         unsigned int        Pitch,
+                         int                 w,
+                         int                 h,
+                         float               fScale,
+                         int                 blockOperation,
+                         pointFunction_t     pPointOperation,
+                         cudaTextureObject_t tex)
+{
+    unsigned char *pSobel = (unsigned char *)(((char *)pSobelOriginal) + blockIdx.x * Pitch);
+    unsigned char  tmp    = 0;
+
+    for (int i = threadIdx.x; i < w; i += blockDim.x) {
+        unsigned char pix00 = tex2D<unsigned char>(tex, (float)i - 1, (float)blockIdx.x - 1);
+        unsigned char pix01 = tex2D<unsigned char>(tex, (float)i + 0, (float)blockIdx.x - 1);
+        unsigned char pix02 = tex2D<unsigned char>(tex, (float)i + 1, (float)blockIdx.x - 1);
+        unsigned char pix10 = tex2D<unsigned char>(tex, (float)i - 1, (float)blockIdx.x + 0);
+        unsigned char pix11 = tex2D<unsigned char>(tex, (float)i + 0, (float)blockIdx.x + 0);
+        unsigned char pix12 = tex2D<unsigned char>(tex, (float)i + 1, (float)blockIdx.x + 0);
+        unsigned char pix20 = tex2D<unsigned char>(tex, (float)i - 1, (float)blockIdx.x + 1);
+        unsigned char pix21 = tex2D<unsigned char>(tex, (float)i + 0, (float)blockIdx.x + 1);
+        unsigned char pix22 = tex2D<unsigned char>(tex, (float)i + 1, (float)blockIdx.x + 1);
+        tmp                 = (*(blockFunction_table[blockOperation]))(
+            pix00, pix01, pix02, pix10, pix11, pix12, pix20, pix21, pix22, fScale);
+
+        if (pPointOperation != NULL) {
+            tmp = (*pPointOperation)(tmp, 150.0);
+        }
+
+        pSobel[i] = tmp;
+    }
+}
+
+extern "C" void setupTexture(int iw, int ih, Pixel *data, int Bpp)
+{
+    cudaChannelFormatDesc desc;
+
+    if (Bpp == 1) {
+        desc = cudaCreateChannelDesc<unsigned char>();
+    }
+    else {
+        desc = cudaCreateChannelDesc<uchar4>();
+    }
+
+    checkCudaErrors(cudaMallocArray(&array, &desc, iw, ih));
+    checkCudaErrors(cudaMemcpy2DToArray(
+        array, 0, 0, data, iw * Bpp * sizeof(Pixel), iw * Bpp * sizeof(Pixel), ih, cudaMemcpyHostToDevice));
+
+    cudaResourceDesc texRes;
+    memset(&texRes, 0, sizeof(cudaResourceDesc));
+
+    texRes.resType         = cudaResourceTypeArray;
+    texRes.res.array.array = array;
+
+    cudaTextureDesc texDescr;
+    memset(&texDescr, 0, sizeof(cudaTextureDesc));
+
+    checkCudaErrors(cudaCreateTextureObject(&tex, &texRes, &texDescr, NULL));
+}
+
+extern "C" void deleteTexture(void)
+{
+    checkCudaErrors(cudaFreeArray(array));
+    checkCudaErrors(cudaDestroyTextureObject(tex));
+}
+
+// Copy the pointers from the function tables to the host side
+void setupFunctionTables()
+{
+    // Dynamically assign the function table.
+    // Copy the function pointers to their appropriate locations according to the
+    // enum
+    checkCudaErrors(cudaMemcpyFromSymbol(&h_blockFunction_table[SOBEL_FILTER], pComputeSobel, sizeof(blockFunction_t)));
+    checkCudaErrors(cudaMemcpyFromSymbol(&h_blockFunction_table[BOX_FILTER], pComputeBox, sizeof(blockFunction_t)));
+
+    // do the same for the point function, where the 2nd function is NULL ("no-op"
+    // filter, skipped in kernel code)
+    checkCudaErrors(
+        cudaMemcpyFromSymbol(&h_pointFunction_table[THRESHOLD_FILTER], pComputeThreshold, sizeof(pointFunction_t)));
+    h_pointFunction_table[NULL_FILTER] = NULL;
+
+    // now copy the function tables back to the device, so if we wish we can use
+    // an index into the table to choose them
+    // We have now set the order in the function table according to our enum.
+    checkCudaErrors(
+        cudaMemcpyToSymbol(blockFunction_table, h_blockFunction_table, sizeof(blockFunction_t) * LAST_BLOCK_FILTER));
+    checkCudaErrors(
+        cudaMemcpyToSymbol(pointFunction_table, h_pointFunction_table, sizeof(pointFunction_t) * LAST_POINT_FILTER));
+}
+
+// Wrapper for the __global__ call that sets up the texture and threads
+// Below two methods for selecting the image processing function to run are
+// shown.
+// BlockOperation is an integer kernel argument used as an index into the
+// blockFunction_table on the device side
+// pPointOp is itself a function pointer passed as a kernel argument, retrieved
+// from a host side copy of the function table
+extern "C" void sobelFilter(Pixel                *odata,
+                            int                   iw,
+                            int                   ih,
+                            enum SobelDisplayMode mode,
+                            float                 fScale,
+                            int                   blockOperation,
+                            int                   pointOperation)
+{
+    pointFunction_t pPointOp = h_pointFunction_table[pointOperation];
+
+    switch (mode) {
+    case SOBELDISPLAY_IMAGE:
+        SobelCopyImage<<<ih, 384>>>(odata, iw, iw, ih, fScale, tex);
+        break;
+
+    case SOBELDISPLAY_SOBELTEX:
+        SobelTex<<<ih, 384>>>(odata, iw, iw, ih, fScale, blockOperation, pPointOp, tex);
+        break;
+
+    case SOBELDISPLAY_SOBELSHARED: {
+        dim3 threads(16, 4);
+#ifndef FIXED_BLOCKWIDTH
+        int BlockWidth = 80; // must be divisible by 16 for coalescing
+#endif
+        dim3 blocks =
+            dim3(iw / (4 * BlockWidth) + (0 != iw % (4 * BlockWidth)), ih / threads.y + (0 != ih % threads.y));
+        int SharedPitch = ~0x3f & (4 * (BlockWidth + 2 * RADIUS) + 0x3f);
+        int sharedMem   = SharedPitch * (threads.y + 2 * RADIUS);
+
+        // for the shared kernel, width must be divisible by 4
+        iw &= ~3;
+
+        SobelShared<<<blocks, threads, sharedMem>>>((uchar4 *)odata,
+                                                    iw,
+#ifndef FIXED_BLOCKWIDTH
+                                                    BlockWidth,
+                                                    SharedPitch,
+#endif
+                                                    iw,
+                                                    ih,
+                                                    fScale,
+                                                    blockOperation,
+                                                    pPointOp,
+                                                    tex);
+    } break;
+    }
+}

cpp/2_Concepts_and_Techniques/FunctionPointers/FunctionPointers_kernels.h

@@ -0,0 +1,58 @@
+/* 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.
+ */
+
+#ifndef __SOBELFILTER_KERNELS_H_
+#define __SOBELFILTER_KERNELS_H_
+
+typedef unsigned char Pixel;
+
+// global determines which filter to invoke
+enum SobelDisplayMode { SOBELDISPLAY_IMAGE = 0, SOBELDISPLAY_SOBELTEX, SOBELDISPLAY_SOBELSHARED };
+
+// Enums to set up the function table
+// note: if you change these be sure to recompile those files
+// that include this header or ensure the .h is in the
+// dependencies for the related object files
+enum POINT_ENUM { SOBEL_FILTER = 0, BOX_FILTER, LAST_POINT_FILTER };
+
+enum BLOCK_ENUM { THRESHOLD_FILTER = 0, NULL_FILTER, LAST_BLOCK_FILTER };
+
+extern enum SobelDisplayMode g_SobelDisplayMode;
+
+extern "C" void sobelFilter(Pixel                *odata,
+                            int                   iw,
+                            int                   ih,
+                            enum SobelDisplayMode mode,
+                            float                 fScale,
+                            int                   blockOperation,
+                            int                   pointOperation);
+extern "C" void setupTexture(int iw, int ih, Pixel *data, int Bpp);
+extern "C" void deleteTexture(void);
+extern "C" void initFilter(void);
+void            setupFunctionTables();
+
+#endif

cpp/2_Concepts_and_Techniques/FunctionPointers/README.md

@@ -0,0 +1,36 @@
+# FunctionPointers - Function Pointers
+
+## Description
+
+This sample illustrates how to use function pointers and implements the Sobel Edge Detection filter for 8-bit monochrome images.
+
+## Key Concepts
+
+Graphics Interop, Image Processing
+
+## 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)
+cudaGraphicsUnmapResources, cudaMemcpy, cudaMallocArray, cudaFreeArray, cudaFree, cudaMemcpyFromSymbol, cudaGraphicsResourceGetMappedPointer, cudaGraphicsMapResources, cudaDestroyTextureObject, cudaDeviceSynchronize, cudaCreateTextureObject, cudaMemcpyToSymbol, cudaGraphicsUnregisterResource, cudaMalloc, cudaGraphicsGLRegisterBuffer
+
+## Dependencies needed to build/run
+[X11](../../../README.md#x11), [OpenGL](../../../README.md#opengl), [Freeglut](../../../README.md#freeglut), [GLEW](../../../README.md#glew)
+
+## 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/2_Concepts_and_Techniques/MC_EstimatePiInlineP/.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/2_Concepts_and_Techniques/MC_EstimatePiInlineP/.vscode/extensions.json

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

cpp/2_Concepts_and_Techniques/MC_EstimatePiInlineP/CMakeLists.txt

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

cpp/2_Concepts_and_Techniques/MC_EstimatePiInlineP/README.md

@@ -0,0 +1,36 @@
+# MC_EstimatePiInlineP - Monte Carlo Estimation of Pi (inline PRNG)
+
+## Description
+
+This sample uses Monte Carlo simulation for Estimation of Pi (using inline PRNG).  This sample also uses the NVIDIA CURAND library.
+
+## Key Concepts
+
+Random Number Generator, Computational Finance, CURAND Library
+
+## 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, cudaGetErrorString, cudaFree, cudaSetDevice, cudaGetDeviceCount, cudaMalloc, cudaFuncGetAttributes, cudaGetDeviceProperties
+
+## Dependencies needed to build/run
+[CURAND](../../../README.md#curand)
+
+## 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/2_Concepts_and_Techniques/MC_EstimatePiInlineP/inc/cudasharedmem.h

@@ -0,0 +1,102 @@
+/* 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.
+ */
+
+#ifndef CUDASHAREDMEM_H
+#define CUDASHAREDMEM_H
+
+//****************************************************************************
+// Because dynamically sized shared memory arrays are declared "extern",
+// we can't templatize them directly.  To get around this, we declare a
+// simple wrapper struct that will declare the extern array with a different
+// name depending on the type.  This avoids compiler errors about duplicate
+// definitions.
+//
+// To use dynamically allocated shared memory in a templatized __global__ or
+// __device__ function, just replace code like this:
+//      template<class T>
+//      __global__ void
+//      foo( T* g_idata, T* g_odata)
+//      {
+//          // Shared mem size is determined by the host app at run time
+//          extern __shared__  T sdata[];
+//          ...
+//          x = sdata[i];
+//          sdata[i] = x;
+//          ...
+//      }
+//
+// With this:
+//      template<class T>
+//      __global__ void
+//      foo( T* g_idata, T* g_odata)
+//      {
+//          // Shared mem size is determined by the host app at run time
+//          SharedMemory<T> sdata;
+//          ...
+//          x = sdata[i];
+//          sdata[i] = x;
+//          ...
+//      }
+//****************************************************************************
+
+// This is the un-specialized struct.  Note that we prevent instantiation of
+// this struct by making it abstract (i.e. with pure virtual methods).
+template <typename T> struct SharedMemory
+{
+    // Ensure that we won't compile any un-specialized types
+    virtual __device__ T &operator*()       = 0;
+    virtual __device__ T &operator[](int i) = 0;
+};
+
+#define BUILD_SHAREDMEMORY_TYPE(t, n)   \
+    template <> struct SharedMemory<t>  \
+    {                                   \
+        __device__ t &operator*()       \
+        {                               \
+            extern __shared__ t n[];    \
+            return *n;                  \
+        }                               \
+        __device__ t &operator[](int i) \
+        {                               \
+            extern __shared__ t n[];    \
+            return n[i];                \
+        }                               \
+    }
+
+BUILD_SHAREDMEMORY_TYPE(int, s_int);
+BUILD_SHAREDMEMORY_TYPE(unsigned int, s_uint);
+BUILD_SHAREDMEMORY_TYPE(char, s_char);
+BUILD_SHAREDMEMORY_TYPE(unsigned char, s_uchar);
+BUILD_SHAREDMEMORY_TYPE(short, s_short);
+BUILD_SHAREDMEMORY_TYPE(unsigned short, s_ushort);
+BUILD_SHAREDMEMORY_TYPE(long, s_long);
+BUILD_SHAREDMEMORY_TYPE(unsigned long, s_ulong);
+BUILD_SHAREDMEMORY_TYPE(bool, s_bool);
+BUILD_SHAREDMEMORY_TYPE(float, s_float);
+BUILD_SHAREDMEMORY_TYPE(double, s_double);
+
+#endif

cpp/2_Concepts_and_Techniques/MC_EstimatePiInlineP/inc/piestimator.h

@@ -0,0 +1,44 @@
+/* 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.
+ */
+
+#ifndef PIESTIMATOR_H
+#define PIESTIMATOR_H
+
+template <typename Real> class PiEstimator
+{
+public:
+    PiEstimator(unsigned int numSims, unsigned int device, unsigned int threadBlockSize, unsigned int seed);
+    Real operator()();
+
+private:
+    unsigned int m_seed;
+    unsigned int m_numSims;
+    unsigned int m_device;
+    unsigned int m_threadBlockSize;
+};
+
+#endif

cpp/2_Concepts_and_Techniques/MC_EstimatePiInlineP/inc/test.h

@@ -0,0 +1,60 @@
+/* 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.
+ */
+
+#ifndef TEST_H
+#define TEST_H
+
+template <typename Real> struct Test
+{
+    Test()
+        : pass(false) {};
+
+    int          device;
+    unsigned int numSims;
+    unsigned int threadBlockSize;
+    unsigned int seed;
+
+    bool   pass;
+    double elapsedTime;
+
+    bool operator()();
+};
+
+// Defaults are arbitrary to give sensible runtime
+#define k_sims_min  100000
+#define k_sims_max  10000000
+#define k_sims_def  100000
+#define k_sims_qa   100000
+#define k_bsize_min 32
+#define k_bsize_def 128
+#define k_bsize_qa  128
+#define k_seed_def  1234
+
+// Target value
+#define PI 3.14159265359
+
+#endif

cpp/2_Concepts_and_Techniques/MC_EstimatePiInlineP/src/main.cpp

@@ -0,0 +1,257 @@
+/* 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.
+ */
+
+///////////////////////////////////////////////////////////////////////////////
+// Monte Carlo: Estimate Pi
+// ========================
+//
+// This sample demonstrates a very simple Monte Carlo estimation for Pi.
+//
+// This file, main.cpp, contains the setup information to run the test, for
+// example parsing the command line and integrating this sample with the
+// samples framework. As such it is perhaps less interesting than the guts of
+// the sample. Readers wishing to skip the clutter are advised to skip straight
+// to Test.operator() in test.cpp.
+///////////////////////////////////////////////////////////////////////////////
+
+#include <cuda_runtime.h>
+#include <helper_cuda.h>
+#include <iomanip>
+#include <iostream>
+#include <stdexcept>
+
+#include "../inc/test.h"
+
+// SDK information
+static const char *printfFile = "MonteCarloEstimatePiInlineP.txt";
+
+// Forward declarations
+void                          showHelp(const int argc, const char **argv);
+template <typename Real> void runTest(int argc, const char **argv);
+
+int main(int argc, char **argv)
+{
+    using std::invalid_argument;
+    using std::string;
+
+    // Open the log file
+    printf("Monte Carlo Estimate Pi (with inline PRNG)\n");
+    printf("==========================================\n\n");
+
+    // If help flag is set, display help and exit immediately
+    if (checkCmdLineFlag(argc, (const char **)argv, "help")) {
+        printf("Displaying help on console\n");
+        showHelp(argc, (const char **)argv);
+        exit(EXIT_SUCCESS);
+    }
+
+    // Check the precision (checked against the device capability later)
+    try {
+        char *value;
+
+        if (getCmdLineArgumentString(argc, (const char **)argv, "precision", &value)) {
+            // Check requested precision is valid
+            string prec(value);
+
+            if (prec.compare("single") == 0 || prec.compare("\"single\"") == 0) {
+                runTest<float>(argc, (const char **)argv);
+            }
+            else if (prec.compare("double") == 0 || prec.compare("\"double\"") == 0) {
+                runTest<double>(argc, (const char **)argv);
+            }
+            else {
+                printf("specified precision (%s) is invalid, must be \"single\" or "
+                       "\"double\".\n",
+                       value);
+                throw invalid_argument("precision");
+            }
+        }
+        else {
+            runTest<float>(argc, (const char **)argv);
+        }
+    }
+    catch (invalid_argument &e) {
+        printf("invalid command line argument (%s)\n", e.what());
+        exit(EXIT_FAILURE);
+    }
+
+    // Finish
+    exit(EXIT_SUCCESS);
+}
+
+template <typename Real> void runTest(int argc, const char **argv)
+{
+    using std::invalid_argument;
+    using std::runtime_error;
+
+    try {
+        Test<Real>  test;
+        int         deviceCount = 0;
+        cudaError_t cudaResult  = cudaSuccess;
+
+        // by default specify GPU Device == 0
+        test.device = 0;
+
+        // Get number of available devices
+        cudaResult = cudaGetDeviceCount(&deviceCount);
+
+        if (cudaResult != cudaSuccess) {
+            printf("could not get device count (%s).\n", cudaGetErrorString(cudaResult));
+            throw runtime_error("cudaGetDeviceCount");
+        }
+
+        // (default parameters)
+        test.numSims         = k_sims_qa;
+        test.threadBlockSize = k_bsize_qa;
+        test.seed            = k_seed_def;
+
+        {
+            char *value = 0;
+
+            if (getCmdLineArgumentString(argc, argv, "device", &value)) {
+                test.device = (int)atoi(value);
+
+                if (test.device >= deviceCount) {
+                    printf("invalid target device specified on command line (device %d does "
+                           "not exist).\n",
+                           test.device);
+                    throw invalid_argument("device");
+                }
+            }
+            else {
+                test.device = gpuGetMaxGflopsDeviceId();
+            }
+
+            if (getCmdLineArgumentString(argc, argv, "sims", &value)) {
+                test.numSims = (unsigned int)atoi(value);
+                printf("number of simulations = %d\n", test.numSims);
+
+                if (test.numSims < k_sims_min || test.numSims > k_sims_max) {
+                    printf("specified number of simulations (%d) is invalid, must be "
+                           "between %d and %d.\n",
+                           test.numSims,
+                           k_sims_min,
+                           k_sims_max);
+                    throw invalid_argument("sims");
+                }
+            }
+            else {
+                test.numSims = k_sims_def;
+            }
+
+            if (getCmdLineArgumentString(argc, argv, "block-size", &value)) {
+                // Determine max threads per block
+                cudaDeviceProp deviceProperties;
+                cudaResult = cudaGetDeviceProperties(&deviceProperties, test.device);
+
+                if (cudaResult != cudaSuccess) {
+                    printf("unable to get device properties for device %d.\n", test.device);
+                    throw runtime_error("cudaGetDeviceProperties");
+                }
+
+                // Check requested size is valid
+                test.threadBlockSize = (unsigned int)atoi(value);
+                printf("block size = %d\n", test.threadBlockSize);
+
+                if (test.threadBlockSize < k_bsize_min
+                    || test.threadBlockSize > static_cast<unsigned int>(deviceProperties.maxThreadsPerBlock)) {
+                    printf("specified block size (%d) is invalid, must be between %d and %d "
+                           "for device %d.\n",
+                           test.threadBlockSize,
+                           k_bsize_min,
+                           deviceProperties.maxThreadsPerBlock,
+                           test.device);
+                    throw invalid_argument("block-size");
+                }
+
+                if (test.threadBlockSize & test.threadBlockSize - 1) {
+                    printf("specified block size (%d) is invalid, must be a power of two "
+                           "(see reduction function).\n",
+                           test.threadBlockSize);
+                    throw invalid_argument("block-size");
+                }
+            }
+            else {
+                test.threadBlockSize = k_bsize_def;
+            }
+
+            if (getCmdLineArgumentString(argc, argv, "seed", &value)) {
+                // Check requested seed is valid
+                test.seed = (unsigned int)atoi(value);
+                printf("seed = %d\n", test.seed);
+
+                if (test.seed == 0) {
+                    printf("specified seed (%d) is invalid, must be non-zero.\n", test.seed);
+                    throw invalid_argument("seed");
+                }
+            }
+            else {
+                test.seed = k_seed_def;
+            }
+        }
+
+        // Execute
+        test();
+    }
+    catch (invalid_argument &e) {
+        printf("invalid command line argument (%s)\n", e.what());
+        exit(EXIT_FAILURE);
+    }
+    catch (runtime_error &e) {
+        printf("runtime error (%s)\n", e.what());
+        exit(EXIT_FAILURE);
+    }
+}
+
+void showHelp(int argc, const char **argv)
+{
+    using std::cout;
+    using std::endl;
+    using std::left;
+    using std::setw;
+
+    if (argc > 0) {
+        cout << endl << argv[0] << endl;
+    }
+
+    cout << endl << "Syntax:" << endl;
+    cout << left;
+    cout << "    " << setw(20) << "--device=<device>"
+         << "Specify device to use for execution" << endl;
+    cout << "    " << setw(20) << "--sims=<N>"
+         << "Specify number of Monte Carlo simulations" << endl;
+    cout << "    " << setw(20) << "--block-size=<N>"
+         << "Specify number of threads per block" << endl;
+    cout << "    " << setw(20) << "--seed=<N>"
+         << "Specify the seed to use for the random number generator" << endl;
+    cout << "    " << setw(20) << "--precision=<P>"
+         << "Specify the precision (\"single\" or \"double\")" << endl;
+    cout << endl;
+    cout << "    " << setw(20) << "--noprompt"
+         << "Skip prompt before exit" << endl;
+    cout << endl;
+}

cpp/2_Concepts_and_Techniques/MC_EstimatePiInlineP/src/piestimator.cu

@@ -0,0 +1,283 @@
+/* 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 <cooperative_groups.h>
+#include <cuda_runtime.h>
+#include <numeric>
+#include <stdexcept>
+#include <string>
+#include <typeinfo>
+#include <vector>
+
+#include "../inc/piestimator.h"
+
+namespace cg = cooperative_groups;
+#include <curand_kernel.h>
+
+using std::string;
+using std::vector;
+
+// RNG init kernel
+__global__ void initRNG(curandState *const rngStates, const unsigned int seed)
+{
+    // Determine thread ID
+    unsigned int tid = blockIdx.x * blockDim.x + threadIdx.x;
+
+    // Initialise the RNG
+    curand_init(seed, tid, 0, &rngStates[tid]);
+}
+
+__device__ unsigned int reduce_sum(unsigned int in, cg::thread_block cta)
+{
+    extern __shared__ unsigned int sdata[];
+
+    // Perform first level of reduction:
+    // - Write to shared memory
+    unsigned int ltid = threadIdx.x;
+
+    sdata[ltid] = in;
+    cg::sync(cta);
+
+    // Do reduction in shared mem
+    for (unsigned int s = blockDim.x / 2; s > 0; s >>= 1) {
+        if (ltid < s) {
+            sdata[ltid] += sdata[ltid + s];
+        }
+
+        cg::sync(cta);
+    }
+
+    return sdata[0];
+}
+
+__device__ inline void getPoint(float &x, float &y, curandState &state)
+{
+    x = curand_uniform(&state);
+    y = curand_uniform(&state);
+}
+__device__ inline void getPoint(double &x, double &y, curandState &state)
+{
+    x = curand_uniform_double(&state);
+    y = curand_uniform_double(&state);
+}
+
+// Estimator kernel
+template <typename Real>
+__global__ void computeValue(unsigned int *const results, curandState *const rngStates, const unsigned int numSims)
+{
+    // Handle to thread block group
+    cg::thread_block cta = cg::this_thread_block();
+    // Determine thread ID
+    unsigned int bid  = blockIdx.x;
+    unsigned int tid  = blockIdx.x * blockDim.x + threadIdx.x;
+    unsigned int step = gridDim.x * blockDim.x;
+
+    // Initialise the RNG
+    curandState localState = rngStates[tid];
+
+    // Count the number of points which lie inside the unit quarter-circle
+    unsigned int pointsInside = 0;
+
+    for (unsigned int i = tid; i < numSims; i += step) {
+        Real x;
+        Real y;
+        getPoint(x, y, localState);
+        Real l2norm2 = x * x + y * y;
+
+        if (l2norm2 < static_cast<Real>(1)) {
+            pointsInside++;
+        }
+    }
+
+    // Reduce within the block
+    pointsInside = reduce_sum(pointsInside, cta);
+
+    // Store the result
+    if (threadIdx.x == 0) {
+        results[bid] = pointsInside;
+    }
+}
+
+template <typename Real>
+PiEstimator<Real>::PiEstimator(unsigned int numSims,
+                               unsigned int device,
+                               unsigned int threadBlockSize,
+                               unsigned int seed)
+    : m_numSims(numSims)
+    , m_device(device)
+    , m_threadBlockSize(threadBlockSize)
+    , m_seed(seed)
+{
+}
+
+template <typename Real> Real PiEstimator<Real>::operator()()
+{
+    cudaError_t               cudaResult = cudaSuccess;
+    struct cudaDeviceProp     deviceProperties;
+    struct cudaFuncAttributes funcAttributes;
+
+    // Get device properties
+    cudaResult = cudaGetDeviceProperties(&deviceProperties, m_device);
+
+    if (cudaResult != cudaSuccess) {
+        string msg("Could not get device properties: ");
+        msg += cudaGetErrorString(cudaResult);
+        throw std::runtime_error(msg);
+    }
+
+    // Check precision is valid
+    if (typeid(Real) == typeid(double)
+        && (deviceProperties.major < 1 || (deviceProperties.major == 1 && deviceProperties.minor < 3))) {
+        throw std::runtime_error("Device does not have double precision support");
+    }
+
+    // Attach to GPU
+    cudaResult = cudaSetDevice(m_device);
+
+    if (cudaResult != cudaSuccess) {
+        string msg("Could not set CUDA device: ");
+        msg += cudaGetErrorString(cudaResult);
+        throw std::runtime_error(msg);
+    }
+
+    // Determine how to divide the work between cores
+    dim3 block;
+    dim3 grid;
+    block.x = m_threadBlockSize;
+    grid.x  = (m_numSims + m_threadBlockSize - 1) / m_threadBlockSize;
+
+    // Aim to launch around ten or more times as many blocks as there
+    // are multiprocessors on the target device.
+    unsigned int blocksPerSM = 10;
+    unsigned int numSMs      = deviceProperties.multiProcessorCount;
+
+    while (grid.x > 2 * blocksPerSM * numSMs) {
+        grid.x >>= 1;
+    }
+
+    // Get initRNG function properties and check the maximum block size
+    cudaResult = cudaFuncGetAttributes(&funcAttributes, initRNG);
+
+    if (cudaResult != cudaSuccess) {
+        string msg("Could not get function attributes: ");
+        msg += cudaGetErrorString(cudaResult);
+        throw std::runtime_error(msg);
+    }
+
+    if (block.x > (unsigned int)funcAttributes.maxThreadsPerBlock) {
+        throw std::runtime_error("Block X dimension is too large for initRNG kernel");
+    }
+
+    // Get computeValue function properties and check the maximum block size
+    cudaResult = cudaFuncGetAttributes(&funcAttributes, computeValue<Real>);
+
+    if (cudaResult != cudaSuccess) {
+        string msg("Could not get function attributes: ");
+        msg += cudaGetErrorString(cudaResult);
+        throw std::runtime_error(msg);
+    }
+
+    if (block.x > (unsigned int)funcAttributes.maxThreadsPerBlock) {
+        throw std::runtime_error("Block X dimension is too large for computeValue kernel");
+    }
+
+    // Check the dimensions are valid
+    if (block.x > (unsigned int)deviceProperties.maxThreadsDim[0]) {
+        throw std::runtime_error("Block X dimension is too large for device");
+    }
+
+    if (grid.x > (unsigned int)deviceProperties.maxGridSize[0]) {
+        throw std::runtime_error("Grid X dimension is too large for device");
+    }
+
+    // Allocate memory for RNG states
+    curandState *d_rngStates = 0;
+    cudaResult               = cudaMalloc((void **)&d_rngStates, grid.x * block.x * sizeof(curandState));
+
+    if (cudaResult != cudaSuccess) {
+        string msg("Could not allocate memory on device for RNG states: ");
+        msg += cudaGetErrorString(cudaResult);
+        throw std::runtime_error(msg);
+    }
+
+    // Allocate memory for result
+    // Each thread block will produce one result
+    unsigned int *d_results = 0;
+    cudaResult              = cudaMalloc((void **)&d_results, grid.x * sizeof(unsigned int));
+
+    if (cudaResult != cudaSuccess) {
+        string msg("Could not allocate memory on device for partial results: ");
+        msg += cudaGetErrorString(cudaResult);
+        throw std::runtime_error(msg);
+    }
+
+    // Initialise RNG
+    initRNG<<<grid, block>>>(d_rngStates, m_seed);
+
+    // Count the points inside unit quarter-circle
+    computeValue<Real><<<grid, block, block.x * sizeof(unsigned int)>>>(d_results, d_rngStates, m_numSims);
+
+    // Copy partial results back
+    vector<unsigned int> results(grid.x);
+    cudaResult = cudaMemcpy(&results[0], d_results, grid.x * sizeof(unsigned int), cudaMemcpyDeviceToHost);
+
+    if (cudaResult != cudaSuccess) {
+        string msg("Could not copy partial results to host: ");
+        msg += cudaGetErrorString(cudaResult);
+        throw std::runtime_error(msg);
+    }
+
+    // Complete sum-reduction on host
+    Real value = static_cast<Real>(std::accumulate(results.begin(), results.end(), 0));
+
+    // Determine the proportion of points inside the quarter-circle,
+    // i.e. the area of the unit quarter-circle
+    value /= m_numSims;
+
+    // Value is currently an estimate of the area of a unit quarter-circle, so we
+    // can scale to a full circle by multiplying by four. Now since the area of a
+    // circle is pi * r^2, and r is one, the value will be an estimate for the
+    // value of pi.
+    value *= 4;
+
+    // Cleanup
+    if (d_rngStates) {
+        cudaFree(d_rngStates);
+        d_rngStates = 0;
+    }
+
+    if (d_results) {
+        cudaFree(d_results);
+        d_results = 0;
+    }
+
+    return value;
+}
+
+// Explicit template instantiation
+template class PiEstimator<float>;
+template class PiEstimator<double>;

cpp/2_Concepts_and_Techniques/MC_EstimatePiInlineP/src/test.cpp

@@ -0,0 +1,113 @@
+/* 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 "../inc/test.h"
+
+#include <cassert>
+#include <cuda_runtime.h>
+#include <helper_timer.h>
+#include <iomanip>
+#include <iostream>
+#include <math.h>
+#include <memory>
+#include <sstream>
+#include <stdexcept>
+#include <stdio.h>
+#include <typeinfo>
+
+#include "../inc/piestimator.h"
+
+template <typename Real> bool Test<Real>::operator()()
+{
+    using std::endl;
+    using std::setw;
+    using std::stringstream;
+
+    StopWatchInterface *timer = NULL;
+    sdkCreateTimer(&timer);
+
+    // Get device properties
+    struct cudaDeviceProp deviceProperties;
+    cudaError_t           cudaResult = cudaGetDeviceProperties(&deviceProperties, device);
+
+    if (cudaResult != cudaSuccess) {
+        std::string msg("Could not get device properties: ");
+        msg += cudaGetErrorString(cudaResult);
+        throw std::runtime_error(msg);
+    }
+
+    // Evaluate on GPU
+    printf("Estimating Pi on GPU (%s)\n\n", deviceProperties.name);
+    PiEstimator<Real> estimator(numSims, device, threadBlockSize, seed);
+    sdkStartTimer(&timer);
+    Real result = estimator();
+    sdkStopTimer(&timer);
+    elapsedTime = sdkGetAverageTimerValue(&timer) / 1000.0f;
+
+    // Tolerance to compare result with expected
+    // This is just to check that nothing has gone very wrong with the
+    // test, the actual accuracy of the result depends on the number of
+    // Monte Carlo trials
+    const Real tolerance = static_cast<Real>(0.01);
+
+    // Display results
+    Real abserror = fabs(result - static_cast<Real>(PI));
+    Real relerror = abserror / static_cast<float>(PI);
+    printf("Precision:      %s\n", (typeid(Real) == typeid(double)) ? "double" : "single");
+    printf("Number of sims: %d\n", numSims);
+    printf("Tolerance:      %e\n", tolerance);
+    printf("GPU result:     %e\n", result);
+    printf("Expected:       %e\n", PI);
+    printf("Absolute error: %e\n", abserror);
+    printf("Relative error: %e\n\n", relerror);
+
+    // Check result
+    if (relerror > tolerance) {
+        printf("computed result (%e) does not match expected result (%e).\n", result, PI);
+        pass = false;
+    }
+    else {
+        pass = true;
+    }
+
+    // Print results
+    printf("MonteCarloEstimatePiInlineP, Performance = %.2f sims/s, Time = "
+           "%.2f(ms), NumDevsUsed = %u, Blocksize = %u\n",
+           numSims / elapsedTime,
+           elapsedTime * 1000.0f,
+           1,
+           threadBlockSize);
+
+    sdkDeleteTimer(&timer);
+
+    return pass;
+}
+
+// Explicit template instantiation
+template struct Test<float>;
+template struct Test<double>;

cpp/2_Concepts_and_Techniques/MC_EstimatePiInlineQ/.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/2_Concepts_and_Techniques/MC_EstimatePiInlineQ/.vscode/extensions.json

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

cpp/2_Concepts_and_Techniques/MC_EstimatePiInlineQ/CMakeLists.txt

@@ -0,0 +1,43 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../../cmake/Modules")
+
+project(MC_EstimatePiInlineQ 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 MC_EstimatePiInlineQ
+add_executable(MC_EstimatePiInlineQ src/main.cpp src/piestimator.cu src/test.cpp)
+
+target_compile_options(MC_EstimatePiInlineQ PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(MC_EstimatePiInlineQ PRIVATE cxx_std_17 cuda_std_17)
+
+set_target_properties(MC_EstimatePiInlineQ PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
+
+target_include_directories(MC_EstimatePiInlineQ PUBLIC
+    ${CMAKE_CURRENT_SOURCE_DIR}/inc
+    ${CUDAToolkit_INCLUDE_DIRS}
+)
+
+target_link_libraries(MC_EstimatePiInlineQ PUBLIC
+    CUDA::curand
+)
+
+# Include installation configuration
+include(${CMAKE_CURRENT_SOURCE_DIR}/../../../cmake/InstallSamples.cmake)
+setup_samples_install()

cpp/2_Concepts_and_Techniques/MC_EstimatePiInlineQ/README.md

@@ -0,0 +1,36 @@
+# MC_EstimatePiInlineQ - Monte Carlo Estimation of Pi (inline QRNG)
+
+## Description
+
+This sample uses Monte Carlo simulation for Estimation of Pi (using inline QRNG).  This sample also uses the NVIDIA CURAND library.
+
+## Key Concepts
+
+Random Number Generator, Computational Finance, CURAND Library
+
+## 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, cudaGetErrorString, cudaFree, cudaSetDevice, cudaGetDeviceCount, cudaMalloc, cudaFuncGetAttributes, cudaGetDeviceProperties
+
+## Dependencies needed to build/run
+[CURAND](../../../README.md#curand)
+
+## 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/2_Concepts_and_Techniques/MC_EstimatePiInlineQ/inc/cudasharedmem.h

@@ -0,0 +1,102 @@
+/* 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.
+ */
+
+#ifndef CUDASHAREDMEM_H
+#define CUDASHAREDMEM_H
+
+//****************************************************************************
+// Because dynamically sized shared memory arrays are declared "extern",
+// we can't templatize them directly.  To get around this, we declare a
+// simple wrapper struct that will declare the extern array with a different
+// name depending on the type.  This avoids compiler errors about duplicate
+// definitions.
+//
+// To use dynamically allocated shared memory in a templatized __global__ or
+// __device__ function, just replace code like this:
+//      template<class T>
+//      __global__ void
+//      foo( T* g_idata, T* g_odata)
+//      {
+//          // Shared mem size is determined by the host app at run time
+//          extern __shared__  T sdata[];
+//          ...
+//          x = sdata[i];
+//          sdata[i] = x;
+//          ...
+//      }
+//
+// With this:
+//      template<class T>
+//      __global__ void
+//      foo( T* g_idata, T* g_odata)
+//      {
+//          // Shared mem size is determined by the host app at run time
+//          SharedMemory<T> sdata;
+//          ...
+//          x = sdata[i];
+//          sdata[i] = x;
+//          ...
+//      }
+//****************************************************************************
+
+// This is the un-specialized struct.  Note that we prevent instantiation of
+// this struct by making it abstract (i.e. with pure virtual methods).
+template <typename T> struct SharedMemory
+{
+    // Ensure that we won't compile any un-specialized types
+    virtual __device__ T &operator*()       = 0;
+    virtual __device__ T &operator[](int i) = 0;
+};
+
+#define BUILD_SHAREDMEMORY_TYPE(t, n)   \
+    template <> struct SharedMemory<t>  \
+    {                                   \
+        __device__ t &operator*()       \
+        {                               \
+            extern __shared__ t n[];    \
+            return *n;                  \
+        }                               \
+        __device__ t &operator[](int i) \
+        {                               \
+            extern __shared__ t n[];    \
+            return n[i];                \
+        }                               \
+    }
+
+BUILD_SHAREDMEMORY_TYPE(int, s_int);
+BUILD_SHAREDMEMORY_TYPE(unsigned int, s_uint);
+BUILD_SHAREDMEMORY_TYPE(char, s_char);
+BUILD_SHAREDMEMORY_TYPE(unsigned char, s_uchar);
+BUILD_SHAREDMEMORY_TYPE(short, s_short);
+BUILD_SHAREDMEMORY_TYPE(unsigned short, s_ushort);
+BUILD_SHAREDMEMORY_TYPE(long, s_long);
+BUILD_SHAREDMEMORY_TYPE(unsigned long, s_ulong);
+BUILD_SHAREDMEMORY_TYPE(bool, s_bool);
+BUILD_SHAREDMEMORY_TYPE(float, s_float);
+BUILD_SHAREDMEMORY_TYPE(double, s_double);
+
+#endif

cpp/2_Concepts_and_Techniques/MC_EstimatePiInlineQ/inc/piestimator.h

@@ -0,0 +1,43 @@
+/* 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.
+ */
+
+#ifndef PIESTIMATOR_H
+#define PIESTIMATOR_H
+
+template <typename Real> class PiEstimator
+{
+public:
+    PiEstimator(unsigned int numSims, unsigned int device, unsigned int threadBlockSize);
+    Real operator()();
+
+private:
+    unsigned int m_numSims;
+    unsigned int m_device;
+    unsigned int m_threadBlockSize;
+};
+
+#endif

cpp/2_Concepts_and_Techniques/MC_EstimatePiInlineQ/inc/test.h

@@ -0,0 +1,58 @@
+/* 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.
+ */
+
+#ifndef TEST_H
+#define TEST_H
+
+template <typename Real> struct Test
+{
+    Test()
+        : pass(false) {};
+
+    int          device;
+    unsigned int numSims;
+    unsigned int threadBlockSize;
+
+    bool   pass;
+    double elapsedTime;
+
+    bool operator()();
+};
+
+// Defaults are arbitrary to give sensible runtime
+#define k_sims_min  100000
+#define k_sims_max  10000000
+#define k_sims_def  100000
+#define k_sims_qa   100000
+#define k_bsize_min 32
+#define k_bsize_def 128
+#define k_bsize_qa  128
+
+// Target value
+#define PI 3.14159265359
+
+#endif

cpp/2_Concepts_and_Techniques/MC_EstimatePiInlineQ/src/main.cpp

@@ -0,0 +1,239 @@
+/* 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.
+ */
+
+///////////////////////////////////////////////////////////////////////////////
+// Monte Carlo: Estimate Pi
+// ========================
+//
+// This sample demonstrates a very simple Monte Carlo estimation for Pi.
+//
+// This file, main.cpp, contains the setup information to run the test, for
+// example parsing the command line and integrating this sample with the
+// samples framework. As such it is perhaps less interesting than the guts of
+// the sample. Readers wishing to skip the clutter are advised to skip straight
+// to Test.operator() in test.cpp.
+///////////////////////////////////////////////////////////////////////////////
+
+
+#include <cuda_runtime.h>
+#include <helper_cuda.h>
+#include <helper_timer.h>
+#include <iomanip>
+#include <iostream>
+#include <math.h>
+#include <stdexcept>
+
+#include "../inc/test.h"
+
+// Forward declarations
+void                          showHelp(const int argc, const char **argv);
+template <typename Real> void runTest(int argc, const char **argv);
+
+int main(int argc, char **argv)
+{
+    using std::invalid_argument;
+    using std::string;
+
+    // Open the log file
+    printf("Monte Carlo Estimate Pi (with inline QRNG)\n");
+    printf("==========================================\n\n");
+
+    // If help flag is set, display help and exit immediately
+    if (checkCmdLineFlag(argc, (const char **)argv, "help")) {
+        printf("Displaying help on console\n");
+        showHelp(argc, (const char **)argv);
+        exit(EXIT_SUCCESS);
+    }
+
+    // Check the precision (checked against the device capability later)
+    try {
+        char *value;
+
+        if (getCmdLineArgumentString(argc, (const char **)argv, "precision", &value)) {
+            // Check requested precision is valid
+            string prec(value);
+
+            if (prec.compare("single") == 0 || prec.compare("\"single\"") == 0) {
+                runTest<float>(argc, (const char **)argv);
+            }
+            else if (prec.compare("double") == 0 || prec.compare("\"double\"") == 0) {
+                runTest<double>(argc, (const char **)argv);
+            }
+            else {
+                printf("specified precision (%s) is invalid, must be \"single\" or "
+                       "\"double\".\n",
+                       value);
+                throw invalid_argument("precision");
+            }
+        }
+        else {
+            runTest<float>(argc, (const char **)argv);
+        }
+    }
+    catch (invalid_argument &e) {
+        printf("invalid command line argument (%s)\n", e.what());
+        exit(EXIT_FAILURE);
+    }
+
+    // Finish
+    exit(EXIT_SUCCESS);
+}
+
+template <typename Real> void runTest(int argc, const char **argv)
+{
+    using std::invalid_argument;
+    using std::runtime_error;
+
+    StopWatchInterface *timer = NULL;
+
+    try {
+        Test<Real>  test;
+        int         deviceCount = 0;
+        cudaError_t cudaResult  = cudaSuccess;
+
+        // by default specify GPU Device == 0
+        test.device = 0;
+
+        // Get number of available devices
+        cudaResult = cudaGetDeviceCount(&deviceCount);
+
+        if (cudaResult != cudaSuccess) {
+            printf("could not get device count.\n");
+            throw runtime_error("cudaGetDeviceCount");
+        }
+
+        // (default parameters)
+        test.numSims         = k_sims_qa;
+        test.threadBlockSize = k_bsize_qa;
+
+        {
+            char *value = 0;
+
+            if (getCmdLineArgumentString(argc, argv, "device", &value)) {
+                test.device = (int)atoi(value);
+
+                if (test.device >= deviceCount) {
+                    printf("invalid target device specified on command line (device %d does "
+                           "not exist).\n",
+                           test.device);
+                    throw invalid_argument("device");
+                }
+            }
+            else {
+                test.device = gpuGetMaxGflopsDeviceId();
+            }
+
+            if (getCmdLineArgumentString(argc, argv, "sims", &value)) {
+                test.numSims = (unsigned int)atoi(value);
+
+                if (test.numSims < k_sims_min || test.numSims > k_sims_max) {
+                    printf("specified number of simulations (%d) is invalid, must be "
+                           "between %d and %d.\n",
+                           test.numSims,
+                           k_sims_min,
+                           k_sims_max);
+                    throw invalid_argument("sims");
+                }
+            }
+            else {
+                test.numSims = k_sims_def;
+            }
+
+            if (getCmdLineArgumentString(argc, argv, "block-size", &value)) {
+                // Determine max threads per block
+                cudaDeviceProp deviceProperties;
+                cudaResult = cudaGetDeviceProperties(&deviceProperties, test.device);
+
+                if (cudaResult != cudaSuccess) {
+                    printf("cound not get device properties for device %d.\n", test.device);
+                    throw runtime_error("cudaGetDeviceProperties");
+                }
+
+                // Check requested size is valid
+                test.threadBlockSize = (unsigned int)atoi(value);
+
+                if (test.threadBlockSize < k_bsize_min
+                    || test.threadBlockSize > static_cast<unsigned int>(deviceProperties.maxThreadsPerBlock)) {
+                    printf("specified block size (%d) is invalid, must be between %d and %d "
+                           "for device %d.\n",
+                           test.threadBlockSize,
+                           k_bsize_min,
+                           deviceProperties.maxThreadsPerBlock,
+                           test.device);
+                    throw invalid_argument("block-size");
+                }
+
+                if (test.threadBlockSize & test.threadBlockSize - 1) {
+                    printf("specified block size (%d) is invalid, must be a power of two "
+                           "(see reduction function).\n",
+                           test.threadBlockSize);
+                    throw invalid_argument("block-size");
+                }
+            }
+            else {
+                test.threadBlockSize = k_bsize_def;
+            }
+        }
+        // Execute
+        test();
+    }
+    catch (invalid_argument &e) {
+        printf("invalid command line argument (%s)\n", e.what());
+        exit(EXIT_FAILURE);
+    }
+    catch (runtime_error &e) {
+        printf("runtime error (%s)\n", e.what());
+        exit(EXIT_FAILURE);
+    }
+}
+
+void showHelp(int argc, const char **argv)
+{
+    using std::cout;
+    using std::endl;
+    using std::left;
+    using std::setw;
+
+    if (argc > 0) {
+        cout << endl << argv[0] << endl;
+    }
+
+    cout << endl << "Syntax:" << endl;
+    cout << left;
+    cout << "    " << setw(20) << "--device=<device>"
+         << "Specify device to use for execution" << endl;
+    cout << "    " << setw(20) << "--sims=<N>"
+         << "Specify number of Monte Carlo simulations" << endl;
+    cout << "    " << setw(20) << "--block-size=<N>"
+         << "Specify number of threads per block" << endl;
+    cout << "    " << setw(20) << "--precision=<P>"
+         << "Specify the precision (\"single\" or \"double\")" << endl;
+    cout << endl;
+    cout << "    " << setw(20) << "--noprompt"
+         << "Skip prompt before exit" << endl;
+    cout << endl;
+}

cpp/2_Concepts_and_Techniques/MC_EstimatePiInlineQ/src/piestimator.cu

@@ -0,0 +1,376 @@
+/* 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 <cooperative_groups.h>
+#include <cuda_runtime.h>
+#include <numeric>
+#include <stdexcept>
+#include <string>
+#include <typeinfo>
+#include <vector>
+
+#include "../inc/piestimator.h"
+
+namespace cg = cooperative_groups;
+#include <curand.h>
+#include <curand_kernel.h>
+
+#include "../inc/cudasharedmem.h"
+
+using std::string;
+using std::vector;
+
+// Helper templates to support float and double in same code
+template <typename L, typename R> struct TYPE_IS
+{
+    static const bool test = false;
+};
+template <typename L> struct TYPE_IS<L, L>
+{
+    static const bool test = true;
+};
+template <bool, class L, class R> struct IF
+{
+    typedef R type;
+};
+template <class L, class R> struct IF<true, L, R>
+{
+    typedef L type;
+};
+
+// RNG init kernel
+template <typename rngState_t, typename rngDirectionVectors_t>
+__global__ void
+initRNG(rngState_t *const rngStates, rngDirectionVectors_t *const rngDirections, unsigned int numDrawsPerDirection)
+{
+    // Determine thread ID
+    unsigned int tid  = blockIdx.x * blockDim.x + threadIdx.x;
+    unsigned int step = gridDim.x * blockDim.x;
+
+    // Determine offset to avoid overlapping sub-sequences
+    unsigned int offset = tid * ((numDrawsPerDirection + step - 1) / step);
+
+    // Initialise the RNG
+    curand_init(rngDirections[0], offset, &rngStates[tid]);
+    curand_init(rngDirections[1], offset, &rngStates[tid + step]);
+}
+
+__device__ unsigned int reduce_sum(unsigned int in, cg::thread_block cta)
+{
+    extern __shared__ unsigned int sdata[];
+
+    // Perform first level of reduction:
+    // - Write to shared memory
+    unsigned int ltid = threadIdx.x;
+
+    sdata[ltid] = in;
+    cg::sync(cta);
+
+    // Do reduction in shared mem
+    for (unsigned int s = blockDim.x / 2; s > 0; s >>= 1) {
+        if (ltid < s) {
+            sdata[ltid] += sdata[ltid + s];
+        }
+
+        cg::sync(cta);
+    }
+
+    return sdata[0];
+}
+
+__device__ inline void getPoint(float &x, float &y, curandStateSobol32 &state1, curandStateSobol32 &state2)
+{
+    x = curand_uniform(&state1);
+    y = curand_uniform(&state2);
+}
+__device__ inline void getPoint(double &x, double &y, curandStateSobol64 &state1, curandStateSobol64 &state2)
+{
+    x = curand_uniform_double(&state1);
+    y = curand_uniform_double(&state2);
+}
+
+// Estimator kernel
+template <typename Real, typename rngState_t>
+__global__ void computeValue(unsigned int *const results, rngState_t *const rngStates, const unsigned int numSims)
+{
+    // Handle to thread block group
+    cg::thread_block cta = cg::this_thread_block();
+    // Determine thread ID
+    unsigned int bid  = blockIdx.x;
+    unsigned int tid  = blockIdx.x * blockDim.x + threadIdx.x;
+    unsigned int step = gridDim.x * blockDim.x;
+
+    // Initialise the RNG
+    rngState_t localState1 = rngStates[tid];
+    rngState_t localState2 = rngStates[tid + step];
+
+    // Count the number of points which lie inside the unit quarter-circle
+    unsigned int pointsInside = 0;
+
+    for (unsigned int i = tid; i < numSims; i += step) {
+        Real x;
+        Real y;
+        getPoint(x, y, localState1, localState2);
+        Real l2norm2 = x * x + y * y;
+
+        if (l2norm2 < static_cast<Real>(1)) {
+            pointsInside++;
+        }
+    }
+
+    // Reduce within the block
+    pointsInside = reduce_sum(pointsInside, cta);
+
+    // Store the result
+    if (threadIdx.x == 0) {
+        results[bid] = pointsInside;
+    }
+}
+
+template <typename Real>
+PiEstimator<Real>::PiEstimator(unsigned int numSims, unsigned int device, unsigned int threadBlockSize)
+    : m_numSims(numSims)
+    , m_device(device)
+    , m_threadBlockSize(threadBlockSize)
+{
+}
+
+template <typename Real> Real PiEstimator<Real>::operator()()
+{
+    cudaError_t               cudaResult = cudaSuccess;
+    struct cudaDeviceProp     deviceProperties;
+    struct cudaFuncAttributes funcAttributes;
+
+    // Determine type of generator to use (32- or 64-bit)
+    typedef
+        typename IF<TYPE_IS<Real, double>::test, curandStateSobol64_t, curandStateSobol32_t>::type curandStateSobol_sz;
+    typedef typename IF<TYPE_IS<Real, double>::test, curandDirectionVectors64_t, curandDirectionVectors32_t>::type
+        curandDirectionVectors_sz;
+
+    // Get device properties
+    cudaResult = cudaGetDeviceProperties(&deviceProperties, m_device);
+
+    if (cudaResult != cudaSuccess) {
+        string msg("Could not get device properties: ");
+        msg += cudaGetErrorString(cudaResult);
+        throw std::runtime_error(msg);
+    }
+
+    // Check precision is valid
+    if (typeid(Real) == typeid(double)
+        && (deviceProperties.major < 1 || (deviceProperties.major == 1 && deviceProperties.minor < 3))) {
+        throw std::runtime_error("Device does not have double precision support");
+    }
+
+    // Attach to GPU
+    cudaResult = cudaSetDevice(m_device);
+
+    if (cudaResult != cudaSuccess) {
+        string msg("Could not set CUDA device: ");
+        msg += cudaGetErrorString(cudaResult);
+        throw std::runtime_error(msg);
+    }
+
+    // Determine how to divide the work between cores
+    dim3 block;
+    dim3 grid;
+    block.x = m_threadBlockSize;
+    grid.x  = (m_numSims + m_threadBlockSize - 1) / m_threadBlockSize;
+
+    // Aim to launch around ten or more times as many blocks as there
+    // are multiprocessors on the target device.
+    unsigned int blocksPerSM = 10;
+    unsigned int numSMs      = deviceProperties.multiProcessorCount;
+
+    while (grid.x > 2 * blocksPerSM * numSMs) {
+        grid.x >>= 1;
+    }
+
+    // Get initRNG function properties and check the maximum block size
+    cudaResult = cudaFuncGetAttributes(&funcAttributes, initRNG<curandStateSobol_sz, curandDirectionVectors_sz>);
+
+    if (cudaResult != cudaSuccess) {
+        string msg("Could not get function attributes: ");
+        msg += cudaGetErrorString(cudaResult);
+        throw std::runtime_error(msg);
+    }
+
+    if (block.x > (unsigned int)funcAttributes.maxThreadsPerBlock) {
+        throw std::runtime_error("Block X dimension is too large for initRNG kernel");
+    }
+
+    // Get computeValue function properties and check the maximum block size
+    cudaResult = cudaFuncGetAttributes(&funcAttributes, computeValue<Real, curandStateSobol_sz>);
+
+    if (cudaResult != cudaSuccess) {
+        string msg("Could not get function attributes: ");
+        msg += cudaGetErrorString(cudaResult);
+        throw std::runtime_error(msg);
+    }
+
+    if (block.x > (unsigned int)funcAttributes.maxThreadsPerBlock) {
+        throw std::runtime_error("Block X dimension is too large for computeValue kernel");
+    }
+
+    // Check the dimensions are valid
+    if (block.x > (unsigned int)deviceProperties.maxThreadsDim[0]) {
+        throw std::runtime_error("Block X dimension is too large for device");
+    }
+
+    if (grid.x > (unsigned int)deviceProperties.maxGridSize[0]) {
+        throw std::runtime_error("Grid X dimension is too large for device");
+    }
+
+    // Allocate memory for RNG states and direction vectors
+    curandStateSobol_sz       *d_rngStates     = 0;
+    curandDirectionVectors_sz *d_rngDirections = 0;
+    cudaResult = cudaMalloc((void **)&d_rngStates, 2 * grid.x * block.x * sizeof(curandStateSobol_sz));
+
+    if (cudaResult != cudaSuccess) {
+        string msg("Could not allocate memory on device for RNG states: ");
+        msg += cudaGetErrorString(cudaResult);
+        throw std::runtime_error(msg);
+    }
+
+    cudaResult = cudaMalloc((void **)&d_rngDirections, 2 * sizeof(curandDirectionVectors_sz));
+
+    if (cudaResult != cudaSuccess) {
+        string msg("Could not allocate memory on device for RNG direction vectors: ");
+        msg += cudaGetErrorString(cudaResult);
+        throw std::runtime_error(msg);
+    }
+
+    // Allocate memory for result
+    // Each thread block will produce one result
+    unsigned int *d_results = 0;
+    cudaResult              = cudaMalloc((void **)&d_results, grid.x * sizeof(unsigned int));
+
+    if (cudaResult != cudaSuccess) {
+        string msg("Could not allocate memory on device for partial results: ");
+        msg += cudaGetErrorString(cudaResult);
+        throw std::runtime_error(msg);
+    }
+
+    // Generate direction vectors on the host and copy to the device
+    if (typeid(Real) == typeid(float)) {
+        curandDirectionVectors32_t *rngDirections;
+        curandStatus_t curandResult = curandGetDirectionVectors32(&rngDirections, CURAND_DIRECTION_VECTORS_32_JOEKUO6);
+
+        if (curandResult != CURAND_STATUS_SUCCESS) {
+            string msg("Could not get direction vectors for quasi-random number "
+                       "generator: ");
+            msg += curandResult;
+            throw std::runtime_error(msg);
+        }
+
+        cudaResult =
+            cudaMemcpy(d_rngDirections, rngDirections, 2 * sizeof(curandDirectionVectors32_t), cudaMemcpyHostToDevice);
+
+        if (cudaResult != cudaSuccess) {
+            string msg("Could not copy direction vectors to device: ");
+            msg += cudaGetErrorString(cudaResult);
+            throw std::runtime_error(msg);
+        }
+    }
+    else if (typeid(Real) == typeid(double)) {
+        curandDirectionVectors64_t *rngDirections;
+        curandStatus_t curandResult = curandGetDirectionVectors64(&rngDirections, CURAND_DIRECTION_VECTORS_64_JOEKUO6);
+
+        if (curandResult != CURAND_STATUS_SUCCESS) {
+            string msg("Could not get direction vectors for quasi-random number "
+                       "generator: ");
+            msg += curandResult;
+            throw std::runtime_error(msg);
+        }
+
+        cudaResult =
+            cudaMemcpy(d_rngDirections, rngDirections, 2 * sizeof(curandDirectionVectors64_t), cudaMemcpyHostToDevice);
+
+        if (cudaResult != cudaSuccess) {
+            string msg("Could not copy direction vectors to device: ");
+            msg += cudaGetErrorString(cudaResult);
+            throw std::runtime_error(msg);
+        }
+    }
+    else {
+        string msg("Could not get direction vectors for random number generator of "
+                   "specified type");
+        throw std::runtime_error(msg);
+    }
+
+    // Initialise RNG
+    initRNG<<<grid, block>>>(d_rngStates, d_rngDirections, m_numSims);
+
+    // Count the points inside unit quarter-circle
+    computeValue<Real><<<grid, block, block.x * sizeof(unsigned int)>>>(d_results, d_rngStates, m_numSims);
+
+    // Copy partial results back
+    vector<unsigned int> results(grid.x);
+    cudaResult = cudaMemcpy(&results[0], d_results, grid.x * sizeof(unsigned int), cudaMemcpyDeviceToHost);
+
+    if (cudaResult != cudaSuccess) {
+        string msg("Could not copy partial results to host: ");
+        msg += cudaGetErrorString(cudaResult);
+        throw std::runtime_error(msg);
+    }
+
+    // Complete sum-reduction on host
+    Real value = static_cast<Real>(std::accumulate(results.begin(), results.end(), 0));
+
+    // Determine the proportion of points inside the quarter-circle,
+    // i.e. the area of the unit quarter-circle
+    value /= m_numSims;
+
+    // Value is currently an estimate of the area of a unit quarter-circle, so we
+    // can scale to a full circle by multiplying by four. Now since the area of a
+    // circle is pi * r^2, and r is one, the value will be an estimate for the
+    // value of pi.
+    value *= 4;
+
+    // Cleanup
+    if (d_rngStates) {
+        cudaFree(d_rngStates);
+        d_rngStates = 0;
+    }
+
+    if (d_rngDirections) {
+        cudaFree(d_rngDirections);
+        d_rngDirections = 0;
+    }
+
+    if (d_results) {
+        cudaFree(d_results);
+        d_results = 0;
+    }
+
+    return value;
+}
+
+// Explicit template instantiation
+template class PiEstimator<float>;
+template class PiEstimator<double>;

cpp/2_Concepts_and_Techniques/MC_EstimatePiInlineQ/src/test.cpp

@@ -0,0 +1,113 @@
+/* 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 "../inc/test.h"
+
+#include <cassert>
+#include <cuda_runtime.h>
+#include <helper_timer.h>
+#include <iomanip>
+#include <iostream>
+#include <math.h>
+#include <memory>
+#include <sstream>
+#include <stdexcept>
+#include <stdio.h>
+#include <typeinfo>
+
+#include "../inc/piestimator.h"
+
+template <typename Real> bool Test<Real>::operator()()
+{
+    using std::endl;
+    using std::setw;
+    using std::stringstream;
+
+    StopWatchInterface *timer = NULL;
+    sdkCreateTimer(&timer);
+
+    // Get device properties
+    struct cudaDeviceProp deviceProperties;
+    cudaError_t           cudaResult = cudaGetDeviceProperties(&deviceProperties, device);
+
+    if (cudaResult != cudaSuccess) {
+        std::string msg("Could not get device properties: ");
+        msg += cudaGetErrorString(cudaResult);
+        throw std::runtime_error(msg);
+    }
+
+    // Evaluate on GPU
+    printf("Estimating Pi on GPU (%s)\n\n", deviceProperties.name);
+    PiEstimator<Real> estimator(numSims, device, threadBlockSize);
+    sdkStartTimer(&timer);
+    Real result = estimator();
+    sdkStopTimer(&timer);
+    elapsedTime = sdkGetAverageTimerValue(&timer) / 1000.0f;
+
+    // Tolerance to compare result with expected
+    // This is just to check that nothing has gone very wrong with the
+    // test, the actual accuracy of the result depends on the number of
+    // Monte Carlo trials
+    const Real tolerance = static_cast<Real>(0.01);
+
+    // Display results
+    Real abserror = fabs(result - static_cast<Real>(PI));
+    Real relerror = abserror / static_cast<Real>(PI);
+    printf("Precision:      %s\n", (typeid(Real) == typeid(double)) ? "double" : "single");
+    printf("Number of sims: %d\n", numSims);
+    printf("Tolerance:      %e\n", tolerance);
+    printf("GPU result:     %e\n", result);
+    printf("Expected:       %e\n", PI);
+    printf("Absolute error: %e\n", abserror);
+    printf("Relative error: %e\n\n", relerror);
+
+    // Check result
+    if (relerror > tolerance) {
+        printf("computed result (%e) does not match expected result (%e).\n", result, PI);
+        pass = false;
+    }
+    else {
+        pass = true;
+    }
+
+    // Print results
+    printf("MonteCarloEstimatePiInlineQ, Performance = %.2f sims/s, Time = "
+           "%.2f(ms), NumDevsUsed = %u, Blocksize = %u\n",
+           numSims / elapsedTime,
+           elapsedTime * 1000.0f,
+           1,
+           threadBlockSize);
+
+    sdkDeleteTimer(&timer);
+
+    return pass;
+}
+
+// Explicit template instantiation
+template struct Test<float>;
+template struct Test<double>;

cpp/2_Concepts_and_Techniques/MC_EstimatePiP/.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/2_Concepts_and_Techniques/MC_EstimatePiP/.vscode/extensions.json

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

cpp/2_Concepts_and_Techniques/MC_EstimatePiP/CMakeLists.txt

@@ -0,0 +1,43 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../../cmake/Modules")
+
+project(MC_EstimatePiP 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 MC_EstimatePiP
+add_executable(MC_EstimatePiP src/main.cpp src/piestimator.cu src/test.cpp)
+
+target_compile_options(MC_EstimatePiP PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(MC_EstimatePiP PRIVATE cxx_std_17 cuda_std_17)
+
+set_target_properties(MC_EstimatePiP PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
+
+target_include_directories(MC_EstimatePiP PUBLIC
+    ${CMAKE_CURRENT_SOURCE_DIR}/inc
+    ${CUDAToolkit_INCLUDE_DIRS}
+)
+
+target_link_libraries(MC_EstimatePiP PUBLIC
+    CUDA::curand
+)
+
+# Include installation configuration
+include(${CMAKE_CURRENT_SOURCE_DIR}/../../../cmake/InstallSamples.cmake)
+setup_samples_install()

cpp/2_Concepts_and_Techniques/MC_EstimatePiP/README.md

@@ -0,0 +1,36 @@
+# MC_EstimatePiP - Monte Carlo Estimation of Pi (batch PRNG)
+
+## Description
+
+This sample uses Monte Carlo simulation for Estimation of Pi (using batch PRNG).  This sample also uses the NVIDIA CURAND library.
+
+## Key Concepts
+
+Random Number Generator, Computational Finance, CURAND Library
+
+## 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, cudaGetErrorString, cudaFree, cudaSetDevice, cudaGetDeviceCount, cudaMalloc, cudaFuncGetAttributes, cudaGetDeviceProperties
+
+## Dependencies needed to build/run
+[CURAND](../../../README.md#curand)
+
+## 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/2_Concepts_and_Techniques/MC_EstimatePiP/inc/cudasharedmem.h

@@ -0,0 +1,102 @@
+/* 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.
+ */
+
+#ifndef CUDASHAREDMEM_H
+#define CUDASHAREDMEM_H
+
+//****************************************************************************
+// Because dynamically sized shared memory arrays are declared "extern",
+// we can't templatize them directly.  To get around this, we declare a
+// simple wrapper struct that will declare the extern array with a different
+// name depending on the type.  This avoids compiler errors about duplicate
+// definitions.
+//
+// To use dynamically allocated shared memory in a templatized __global__ or
+// __device__ function, just replace code like this:
+//      template<class T>
+//      __global__ void
+//      foo( T* g_idata, T* g_odata)
+//      {
+//          // Shared mem size is determined by the host app at run time
+//          extern __shared__  T sdata[];
+//          ...
+//          x = sdata[i];
+//          sdata[i] = x;
+//          ...
+//      }
+//
+// With this:
+//      template<class T>
+//      __global__ void
+//      foo( T* g_idata, T* g_odata)
+//      {
+//          // Shared mem size is determined by the host app at run time
+//          SharedMemory<T> sdata;
+//          ...
+//          x = sdata[i];
+//          sdata[i] = x;
+//          ...
+//      }
+//****************************************************************************
+
+// This is the un-specialized struct.  Note that we prevent instantiation of
+// this struct by making it abstract (i.e. with pure virtual methods).
+template <typename T> struct SharedMemory
+{
+    // Ensure that we won't compile any un-specialized types
+    virtual __device__ T &operator*()       = 0;
+    virtual __device__ T &operator[](int i) = 0;
+};
+
+#define BUILD_SHAREDMEMORY_TYPE(t, n)   \
+    template <> struct SharedMemory<t>  \
+    {                                   \
+        __device__ t &operator*()       \
+        {                               \
+            extern __shared__ t n[];    \
+            return *n;                  \
+        }                               \
+        __device__ t &operator[](int i) \
+        {                               \
+            extern __shared__ t n[];    \
+            return n[i];                \
+        }                               \
+    }
+
+BUILD_SHAREDMEMORY_TYPE(int, s_int);
+BUILD_SHAREDMEMORY_TYPE(unsigned int, s_uint);
+BUILD_SHAREDMEMORY_TYPE(char, s_char);
+BUILD_SHAREDMEMORY_TYPE(unsigned char, s_uchar);
+BUILD_SHAREDMEMORY_TYPE(short, s_short);
+BUILD_SHAREDMEMORY_TYPE(unsigned short, s_ushort);
+BUILD_SHAREDMEMORY_TYPE(long, s_long);
+BUILD_SHAREDMEMORY_TYPE(unsigned long, s_ulong);
+BUILD_SHAREDMEMORY_TYPE(bool, s_bool);
+BUILD_SHAREDMEMORY_TYPE(float, s_float);
+BUILD_SHAREDMEMORY_TYPE(double, s_double);
+
+#endif

cpp/2_Concepts_and_Techniques/MC_EstimatePiP/inc/piestimator.h

@@ -0,0 +1,44 @@
+/* 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.
+ */
+
+#ifndef PIESTIMATOR_H
+#define PIESTIMATOR_H
+
+template <typename Real> class PiEstimator
+{
+public:
+    PiEstimator(unsigned int numSims, unsigned int device, unsigned int threadBlockSize, unsigned int seed);
+    Real operator()();
+
+private:
+    unsigned int m_seed;
+    unsigned int m_numSims;
+    unsigned int m_device;
+    unsigned int m_threadBlockSize;
+};
+
+#endif

cpp/2_Concepts_and_Techniques/MC_EstimatePiP/inc/test.h

@@ -0,0 +1,60 @@
+/* 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.
+ */
+
+#ifndef TEST_H
+#define TEST_H
+
+template <typename Real> struct Test
+{
+    Test()
+        : pass(false) {};
+
+    int          device;
+    unsigned int numSims;
+    unsigned int threadBlockSize;
+    unsigned int seed;
+
+    bool   pass;
+    double elapsedTime;
+
+    bool operator()();
+};
+
+// Defaults are arbitrary to give sensible runtime
+#define k_sims_min  100000
+#define k_sims_max  10000000
+#define k_sims_def  100000
+#define k_sims_qa   100000
+#define k_bsize_min 32
+#define k_bsize_def 128
+#define k_bsize_qa  128
+#define k_seed_def  1234
+
+// Target value
+#define PI 3.14159265359
+
+#endif

cpp/2_Concepts_and_Techniques/MC_EstimatePiP/src/main.cpp

@@ -0,0 +1,255 @@
+/* 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.
+ */
+
+///////////////////////////////////////////////////////////////////////////////
+// Monte Carlo: Estimate Pi
+// ========================
+//
+// This sample demonstrates a very simple Monte Carlo estimation for Pi.
+//
+// This file, main.cpp, contains the setup information to run the test, for
+// example parsing the command line and integrating this sample with the
+// samples framework. As such it is perhaps less interesting than the guts of
+// the sample. Readers wishing to skip the clutter are advised to skip straight
+// to Test.operator() in test.cpp.
+///////////////////////////////////////////////////////////////////////////////
+
+
+#include <cuda_runtime.h>
+#include <helper_cuda.h>
+#include <helper_timer.h>
+#include <iomanip>
+#include <iostream>
+#include <math.h>
+#include <stdexcept>
+
+#include "../inc/test.h"
+
+// SDK information
+static const char *printfFile = "MonteCarloEstimatePiP.txt";
+
+// Forward declarations
+void                          showHelp(const int argc, const char **argv);
+template <typename Real> void runTest(int argc, const char **argv);
+
+int main(int argc, char **argv)
+{
+    using std::invalid_argument;
+    using std::string;
+
+    // Open the log file
+    printf("Monte Carlo Estimate Pi (with batch PRNG)\n");
+    printf("=========================================\n\n");
+
+    // If help flag is set, display help and exit immediately
+    if (checkCmdLineFlag(argc, (const char **)argv, "help")) {
+        printf("Displaying help on console\n");
+        showHelp(argc, (const char **)argv);
+        exit(EXIT_SUCCESS);
+    }
+
+    // Check the precision (checked against the device capability later)
+    try {
+        char *value;
+
+        if (getCmdLineArgumentString(argc, (const char **)argv, "precision", &value)) {
+            // Check requested precision is valid
+            string prec(value);
+
+            if (prec.compare("single") == 0 || prec.compare("\"single\"") == 0) {
+                runTest<float>(argc, (const char **)argv);
+            }
+            else if (prec.compare("double") == 0 || prec.compare("\"double\"") == 0) {
+                runTest<double>(argc, (const char **)argv);
+            }
+            else {
+                printf("specified precision (%s) is invalid, must be \"single\".\n", value);
+                throw invalid_argument("precision");
+            }
+        }
+        else {
+            runTest<float>(argc, (const char **)argv);
+        }
+    }
+    catch (invalid_argument &e) {
+        printf("invalid command line argument (%s)\n", e.what());
+        exit(EXIT_FAILURE);
+    }
+
+    // Finish
+    exit(EXIT_SUCCESS);
+}
+
+template <typename Real> void runTest(int argc, const char **argv)
+{
+    using std::invalid_argument;
+    using std::runtime_error;
+
+    try {
+        Test<Real>  test;
+        int         deviceCount = 0;
+        cudaError_t cudaResult  = cudaSuccess;
+
+        // by default specify GPU Device == 0
+        test.device = 0;
+
+        // Get number of available devices
+        cudaResult = cudaGetDeviceCount(&deviceCount);
+
+        if (cudaResult != cudaSuccess) {
+            printf("could not get device count.\n");
+            throw runtime_error("cudaGetDeviceCount");
+        }
+
+        // (default parameters)
+        test.numSims         = k_sims_qa;
+        test.threadBlockSize = k_bsize_qa;
+        test.seed            = k_seed_def;
+
+        {
+            char *value = 0;
+
+            if (getCmdLineArgumentString(argc, argv, "device", &value)) {
+                test.device = (int)atoi(value);
+
+                if (test.device >= deviceCount) {
+                    printf("invalid target device specified on command line (device %d does "
+                           "not exist).\n",
+                           test.device);
+                    throw invalid_argument("device");
+                }
+            }
+            else {
+                test.device = gpuGetMaxGflopsDeviceId();
+            }
+
+            if (getCmdLineArgumentString(argc, argv, "sims", &value)) {
+                test.numSims = (unsigned int)atoi(value);
+
+                if (test.numSims < k_sims_min || test.numSims > k_sims_max) {
+                    printf("specified number of simulations (%d) is invalid, must be "
+                           "between %d and %d.\n",
+                           test.numSims,
+                           k_sims_min,
+                           k_sims_max);
+                    throw invalid_argument("sims");
+                }
+            }
+            else {
+                test.numSims = k_sims_def;
+            }
+
+            if (getCmdLineArgumentString(argc, argv, "block-size", &value)) {
+                // Determine max threads per block
+                cudaDeviceProp deviceProperties;
+                cudaResult = cudaGetDeviceProperties(&deviceProperties, test.device);
+
+                if (cudaResult != cudaSuccess) {
+                    printf("cound not get device properties for device %d.\n", test.device);
+                    throw runtime_error("cudaGetDeviceProperties");
+                }
+
+                // Check requested size is valid
+                test.threadBlockSize = (unsigned int)atoi(value);
+
+                if (test.threadBlockSize < k_bsize_min
+                    || test.threadBlockSize > static_cast<unsigned int>(deviceProperties.maxThreadsPerBlock)) {
+                    printf("specified block size (%d) is invalid, must be between %d and %d "
+                           "for device %d.\n",
+                           test.threadBlockSize,
+                           k_bsize_min,
+                           deviceProperties.maxThreadsPerBlock,
+                           test.device);
+                    throw invalid_argument("block-size");
+                }
+
+                if (test.threadBlockSize & test.threadBlockSize - 1) {
+                    printf("specified block size (%d) is invalid, must be a power of two "
+                           "(see reduction function).\n",
+                           test.threadBlockSize);
+                    throw invalid_argument("block-size");
+                }
+            }
+            else {
+                test.threadBlockSize = k_bsize_def;
+            }
+
+            if (getCmdLineArgumentString(argc, argv, "seed", &value)) {
+                // Check requested seed is valid
+                test.seed = (unsigned int)atoi(value);
+
+                if (test.seed == 0) {
+                    printf("specified seed (%d) is invalid, must be non-zero.\n", test.seed);
+                    throw invalid_argument("seed");
+                }
+            }
+            else {
+                test.seed = k_seed_def;
+            }
+        }
+
+        // Execute
+        test();
+    }
+    catch (invalid_argument &e) {
+        printf("invalid command line argument (%s)\n", e.what());
+        exit(EXIT_FAILURE);
+    }
+    catch (runtime_error &e) {
+        printf("runtime error (%s)\n", e.what());
+        exit(EXIT_FAILURE);
+    }
+}
+
+void showHelp(int argc, const char **argv)
+{
+    using std::cout;
+    using std::endl;
+    using std::left;
+    using std::setw;
+
+    if (argc > 0) {
+        cout << endl << argv[0] << endl;
+    }
+
+    cout << endl << "Syntax:" << endl;
+    cout << left;
+    cout << "    " << setw(20) << "--device=<device>"
+         << "Specify device to use for execution" << endl;
+    cout << "    " << setw(20) << "--sims=<N>"
+         << "Specify number of Monte Carlo simulations" << endl;
+    cout << "    " << setw(20) << "--block-size=<N>"
+         << "Specify number of threads per block" << endl;
+    cout << "    " << setw(20) << "--seed=<N>"
+         << "Specify the seed to use for the random number generator" << endl;
+    cout << "    " << setw(20) << "--precision=<P>"
+         << "Specify the precision (\"single\" or \"double\")" << endl;
+    cout << endl;
+    cout << "    " << setw(20) << "--noprompt"
+         << "Skip prompt before exit" << endl;
+    cout << endl;
+}

cpp/2_Concepts_and_Techniques/MC_EstimatePiP/src/piestimator.cu

@@ -0,0 +1,291 @@
+/* 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 <cooperative_groups.h>
+#include <cuda_runtime.h>
+#include <numeric>
+#include <stdexcept>
+#include <string>
+#include <typeinfo>
+#include <vector>
+
+#include "../inc/piestimator.h"
+
+namespace cg = cooperative_groups;
+#include <curand.h>
+
+using std::string;
+using std::vector;
+
+__device__ unsigned int reduce_sum(unsigned int in, cg::thread_block cta)
+{
+    extern __shared__ unsigned int sdata[];
+
+    // Perform first level of reduction:
+    // - Write to shared memory
+    unsigned int ltid = threadIdx.x;
+
+    sdata[ltid] = in;
+    cg::sync(cta);
+
+    // Do reduction in shared mem
+    for (unsigned int s = blockDim.x / 2; s > 0; s >>= 1) {
+        if (ltid < s) {
+            sdata[ltid] += sdata[ltid + s];
+        }
+
+        cg::sync(cta);
+    }
+
+    return sdata[0];
+}
+
+// Estimator kernel
+template <typename Real>
+__global__ void computeValue(unsigned int *const results, const Real *const points, const unsigned int numSims)
+{
+    // Handle to thread block group
+    cg::thread_block cta = cg::this_thread_block();
+    // Determine thread ID
+    unsigned int bid  = blockIdx.x;
+    unsigned int tid  = blockIdx.x * blockDim.x + threadIdx.x;
+    unsigned int step = gridDim.x * blockDim.x;
+
+    // Shift the input/output pointers
+    const Real *pointx = points + tid;
+    const Real *pointy = pointx + numSims;
+
+    // Count the number of points which lie inside the unit quarter-circle
+    unsigned int pointsInside = 0;
+
+    for (unsigned int i = tid; i < numSims; i += step, pointx += step, pointy += step) {
+        Real x       = *pointx;
+        Real y       = *pointy;
+        Real l2norm2 = x * x + y * y;
+
+        if (l2norm2 < static_cast<Real>(1)) {
+            pointsInside++;
+        }
+    }
+
+    // Reduce within the block
+    pointsInside = reduce_sum(pointsInside, cta);
+
+    // Store the result
+    if (threadIdx.x == 0) {
+        results[bid] = pointsInside;
+    }
+}
+
+template <typename Real>
+PiEstimator<Real>::PiEstimator(unsigned int numSims,
+                               unsigned int device,
+                               unsigned int threadBlockSize,
+                               unsigned int seed)
+    : m_numSims(numSims)
+    , m_device(device)
+    , m_threadBlockSize(threadBlockSize)
+    , m_seed(seed)
+{
+}
+
+template <typename Real> Real PiEstimator<Real>::operator()()
+{
+    cudaError_t               cudaResult = cudaSuccess;
+    struct cudaDeviceProp     deviceProperties;
+    struct cudaFuncAttributes funcAttributes;
+
+    // Get device properties
+    cudaResult = cudaGetDeviceProperties(&deviceProperties, m_device);
+
+    if (cudaResult != cudaSuccess) {
+        string msg("Could not get device properties: ");
+        msg += cudaGetErrorString(cudaResult);
+        throw std::runtime_error(msg);
+    }
+
+    // Check precision is valid
+    if (typeid(Real) == typeid(double)
+        && (deviceProperties.major < 1 || (deviceProperties.major == 1 && deviceProperties.minor < 3))) {
+        throw std::runtime_error("Device does not have double precision support");
+    }
+
+    // Attach to GPU
+    cudaResult = cudaSetDevice(m_device);
+
+    if (cudaResult != cudaSuccess) {
+        string msg("Could not set CUDA device: ");
+        msg += cudaGetErrorString(cudaResult);
+        throw std::runtime_error(msg);
+    }
+
+    // Determine how to divide the work between cores
+    dim3 block;
+    dim3 grid;
+    block.x = m_threadBlockSize;
+    grid.x  = (m_numSims + m_threadBlockSize - 1) / m_threadBlockSize;
+
+    // Aim to launch around ten or more times as many blocks as there
+    // are multiprocessors on the target device.
+    unsigned int blocksPerSM = 10;
+    unsigned int numSMs      = deviceProperties.multiProcessorCount;
+
+    while (grid.x > 2 * blocksPerSM * numSMs) {
+        grid.x >>= 1;
+    }
+
+    // Get computeValue function properties and check the maximum block size
+    cudaResult = cudaFuncGetAttributes(&funcAttributes, computeValue<Real>);
+
+    if (cudaResult != cudaSuccess) {
+        string msg("Could not get function attributes: ");
+        msg += cudaGetErrorString(cudaResult);
+        throw std::runtime_error(msg);
+    }
+
+    if (block.x > (unsigned int)funcAttributes.maxThreadsPerBlock) {
+        throw std::runtime_error("Block X dimension is too large for computeValue kernel");
+    }
+
+    // Check the dimensions are valid
+    if (block.x > (unsigned int)deviceProperties.maxThreadsDim[0]) {
+        throw std::runtime_error("Block X dimension is too large for device");
+    }
+
+    if (grid.x > (unsigned int)deviceProperties.maxGridSize[0]) {
+        throw std::runtime_error("Grid X dimension is too large for device");
+    }
+
+    // Allocate memory for points
+    // Each simulation has two random numbers to give X and Y coordinate
+    Real *d_points = 0;
+    cudaResult     = cudaMalloc((void **)&d_points, 2 * m_numSims * sizeof(Real));
+
+    if (cudaResult != cudaSuccess) {
+        string msg("Could not allocate memory on device for random numbers: ");
+        msg += cudaGetErrorString(cudaResult);
+        throw std::runtime_error(msg);
+    }
+
+    // Allocate memory for result
+    // Each thread block will produce one result
+    unsigned int *d_results = 0;
+    cudaResult              = cudaMalloc((void **)&d_results, grid.x * sizeof(unsigned int));
+
+    if (cudaResult != cudaSuccess) {
+        string msg("Could not allocate memory on device for partial results: ");
+        msg += cudaGetErrorString(cudaResult);
+        throw std::runtime_error(msg);
+    }
+
+    // Generate random points in unit square
+    curandStatus_t    curandResult;
+    curandGenerator_t prng;
+    curandResult = curandCreateGenerator(&prng, CURAND_RNG_PSEUDO_DEFAULT);
+
+    if (curandResult != CURAND_STATUS_SUCCESS) {
+        string msg("Could not create pseudo-random number generator: ");
+        msg += curandResult;
+        throw std::runtime_error(msg);
+    }
+
+    curandResult = curandSetPseudoRandomGeneratorSeed(prng, m_seed);
+
+    if (curandResult != CURAND_STATUS_SUCCESS) {
+        string msg("Could not set seed for pseudo-random number generator: ");
+        msg += curandResult;
+        throw std::runtime_error(msg);
+    }
+
+    if (typeid(Real) == typeid(float)) {
+        curandResult = curandGenerateUniform(prng, (float *)d_points, 2 * m_numSims);
+    }
+    else if (typeid(Real) == typeid(double)) {
+        curandResult = curandGenerateUniformDouble(prng, (double *)d_points, 2 * m_numSims);
+    }
+    else {
+        string msg("Could not generate random numbers of specified type");
+        throw std::runtime_error(msg);
+    }
+
+    if (curandResult != CURAND_STATUS_SUCCESS) {
+        string msg("Could not generate pseudo-random numbers: ");
+        msg += curandResult;
+        throw std::runtime_error(msg);
+    }
+
+    curandResult = curandDestroyGenerator(prng);
+
+    if (curandResult != CURAND_STATUS_SUCCESS) {
+        string msg("Could not destroy pseudo-random number generator: ");
+        msg += curandResult;
+        throw std::runtime_error(msg);
+    }
+
+    // Count the points inside unit quarter-circle
+    computeValue<Real><<<grid, block, block.x * sizeof(unsigned int)>>>(d_results, d_points, m_numSims);
+
+    // Copy partial results back
+    vector<unsigned int> results(grid.x);
+    cudaResult = cudaMemcpy(&results[0], d_results, grid.x * sizeof(unsigned int), cudaMemcpyDeviceToHost);
+
+    if (cudaResult != cudaSuccess) {
+        string msg("Could not copy partial results to host: ");
+        msg += cudaGetErrorString(cudaResult);
+        throw std::runtime_error(msg);
+    }
+
+    // Complete sum-reduction on host
+    Real value = static_cast<Real>(std::accumulate(results.begin(), results.end(), 0));
+
+    // Determine the proportion of points inside the quarter-circle,
+    // i.e. the area of the unit quarter-circle
+    value /= m_numSims;
+
+    // Value is currently an estimate of the area of a unit quarter-circle, so we
+    // can scale to a full circle by multiplying by four. Now since the area of a
+    // circle is pi * r^2, and r is one, the value will be an estimate for the
+    // value of pi.
+    value *= 4;
+
+    // Cleanup
+    if (d_points) {
+        cudaFree(d_points);
+        d_points = 0;
+    }
+
+    if (d_results) {
+        cudaFree(d_results);
+        d_results = 0;
+    }
+
+    return value;
+}
+
+// Explicit template instantiation
+template class PiEstimator<float>;
+template class PiEstimator<double>;

cpp/2_Concepts_and_Techniques/MC_EstimatePiP/src/test.cpp

@@ -0,0 +1,110 @@
+/* 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 "../inc/test.h"
+
+#include <cassert>
+#include <cuda_runtime.h>
+#include <helper_timer.h>
+#include <iomanip>
+#include <iostream>
+#include <math.h>
+#include <memory>
+#include <sstream>
+#include <stdexcept>
+#include <stdio.h>
+#include <typeinfo>
+
+#include "../inc/piestimator.h"
+
+template <typename Real> bool Test<Real>::operator()()
+{
+    using std::endl;
+    using std::setw;
+    using std::stringstream;
+
+    StopWatchInterface *timer = NULL;
+    sdkCreateTimer(&timer);
+
+    // Get device properties
+    struct cudaDeviceProp deviceProperties;
+    cudaError_t           cudaResult = cudaGetDeviceProperties(&deviceProperties, device);
+
+    if (cudaResult != cudaSuccess) {
+        std::string msg("Could not get device properties: ");
+        msg += cudaGetErrorString(cudaResult);
+        throw std::runtime_error(msg);
+    }
+
+    // Evaluate on GPU
+    printf("Estimating Pi on GPU (%s)\n\n", deviceProperties.name);
+    PiEstimator<Real> estimator(numSims, device, threadBlockSize, seed);
+    sdkStartTimer(&timer);
+    Real result = estimator();
+    sdkStopTimer(&timer);
+    elapsedTime = sdkGetAverageTimerValue(&timer) / 1000.0f;
+
+    // Tolerance to compare result with expected
+    // This is just to check that nothing has gone very wrong with the
+    // test, the actual accuracy of the result depends on the number of
+    // Monte Carlo trials
+    const Real tolerance = static_cast<Real>(0.01);
+
+    // Display results
+    Real abserror = fabs(result - static_cast<float>(PI));
+    Real relerror = abserror / static_cast<float>(PI);
+    printf("Precision:      %s\n", (typeid(Real) == typeid(double)) ? "double" : "single");
+    printf("Number of sims: %d\n", numSims);
+    printf("Tolerance:      %e\n", tolerance);
+    printf("GPU result:     %e\n", result);
+    printf("Expected:       %e\n", PI);
+    printf("Absolute error: %e\n", abserror);
+    printf("Relative error: %e\n\n", relerror);
+
+    // Check result
+    if (relerror > tolerance) {
+        printf("computed result (%e) does not match expected result (%e).\n", result, PI);
+        pass = false;
+    }
+    else {
+        pass = true;
+    }
+
+    // Print results
+    printf("MonteCarloEstimatePiP, Performance = %.2f sims/s, Time = %.2f(ms), "
+           "NumDevsUsed = %u, Blocksize = %u\n",
+           numSims / elapsedTime,
+           elapsedTime * 1000.0f,
+           1,
+           threadBlockSize);
+
+    return pass;
+}
+
+// Explicit template instantiation
+template struct Test<float>;
+template struct Test<double>;

cpp/2_Concepts_and_Techniques/MC_EstimatePiQ/.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/2_Concepts_and_Techniques/MC_EstimatePiQ/.vscode/extensions.json

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

cpp/2_Concepts_and_Techniques/MC_EstimatePiQ/CMakeLists.txt

@@ -0,0 +1,43 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../../cmake/Modules")
+
+project(MC_EstimatePiQ 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 MC_EstimatePiQ
+add_executable(MC_EstimatePiQ src/main.cpp src/piestimator.cu src/test.cpp)
+
+target_compile_options(MC_EstimatePiQ PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(MC_EstimatePiQ PRIVATE cxx_std_17 cuda_std_17)
+
+set_target_properties(MC_EstimatePiQ PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
+
+target_include_directories(MC_EstimatePiQ PUBLIC
+    ${CMAKE_CURRENT_SOURCE_DIR}/inc
+    ${CUDAToolkit_INCLUDE_DIRS}
+)
+
+target_link_libraries(MC_EstimatePiQ PUBLIC
+    CUDA::curand
+)
+
+# Include installation configuration
+include(${CMAKE_CURRENT_SOURCE_DIR}/../../../cmake/InstallSamples.cmake)
+setup_samples_install()

cpp/2_Concepts_and_Techniques/MC_EstimatePiQ/README.md

@@ -0,0 +1,36 @@
+# MC_EstimatePiQ - Monte Carlo Estimation of Pi (batch QRNG)
+
+## Description
+
+This sample uses Monte Carlo simulation for Estimation of Pi (using batch QRNG).  This sample also uses the NVIDIA CURAND library.
+
+## Key Concepts
+
+Random Number Generator, Computational Finance, CURAND Library
+
+## 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, cudaGetErrorString, cudaFree, cudaSetDevice, cudaGetDeviceCount, cudaMalloc, cudaFuncGetAttributes, cudaGetDeviceProperties
+
+## Dependencies needed to build/run
+[CURAND](../../../README.md#curand)
+
+## 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/2_Concepts_and_Techniques/MC_EstimatePiQ/inc/cudasharedmem.h

@@ -0,0 +1,102 @@
+/* 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.
+ */
+
+#ifndef CUDASHAREDMEM_H
+#define CUDASHAREDMEM_H
+
+//****************************************************************************
+// Because dynamically sized shared memory arrays are declared "extern",
+// we can't templatize them directly.  To get around this, we declare a
+// simple wrapper struct that will declare the extern array with a different
+// name depending on the type.  This avoids compiler errors about duplicate
+// definitions.
+//
+// To use dynamically allocated shared memory in a templatized __global__ or
+// __device__ function, just replace code like this:
+//      template<class T>
+//      __global__ void
+//      foo( T* g_idata, T* g_odata)
+//      {
+//          // Shared mem size is determined by the host app at run time
+//          extern __shared__  T sdata[];
+//          ...
+//          x = sdata[i];
+//          sdata[i] = x;
+//          ...
+//      }
+//
+// With this:
+//      template<class T>
+//      __global__ void
+//      foo( T* g_idata, T* g_odata)
+//      {
+//          // Shared mem size is determined by the host app at run time
+//          SharedMemory<T> sdata;
+//          ...
+//          x = sdata[i];
+//          sdata[i] = x;
+//          ...
+//      }
+//****************************************************************************
+
+// This is the un-specialized struct.  Note that we prevent instantiation of
+// this struct by making it abstract (i.e. with pure virtual methods).
+template <typename T> struct SharedMemory
+{
+    // Ensure that we won't compile any un-specialized types
+    virtual __device__ T &operator*()       = 0;
+    virtual __device__ T &operator[](int i) = 0;
+};
+
+#define BUILD_SHAREDMEMORY_TYPE(t, n)   \
+    template <> struct SharedMemory<t>  \
+    {                                   \
+        __device__ t &operator*()       \
+        {                               \
+            extern __shared__ t n[];    \
+            return *n;                  \
+        }                               \
+        __device__ t &operator[](int i) \
+        {                               \
+            extern __shared__ t n[];    \
+            return n[i];                \
+        }                               \
+    }
+
+BUILD_SHAREDMEMORY_TYPE(int, s_int);
+BUILD_SHAREDMEMORY_TYPE(unsigned int, s_uint);
+BUILD_SHAREDMEMORY_TYPE(char, s_char);
+BUILD_SHAREDMEMORY_TYPE(unsigned char, s_uchar);
+BUILD_SHAREDMEMORY_TYPE(short, s_short);
+BUILD_SHAREDMEMORY_TYPE(unsigned short, s_ushort);
+BUILD_SHAREDMEMORY_TYPE(long, s_long);
+BUILD_SHAREDMEMORY_TYPE(unsigned long, s_ulong);
+BUILD_SHAREDMEMORY_TYPE(bool, s_bool);
+BUILD_SHAREDMEMORY_TYPE(float, s_float);
+BUILD_SHAREDMEMORY_TYPE(double, s_double);
+
+#endif

cpp/2_Concepts_and_Techniques/MC_EstimatePiQ/inc/piestimator.h

@@ -0,0 +1,42 @@
+/* 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.
+ */
+#ifndef PIESTIMATOR_H
+#define PIESTIMATOR_H
+
+template <typename Real> class PiEstimator
+{
+public:
+    PiEstimator(unsigned int numSims, unsigned int device, unsigned int threadBlockSize);
+    Real operator()();
+
+private:
+    unsigned int m_numSims;
+    unsigned int m_device;
+    unsigned int m_threadBlockSize;
+};
+
+#endif

cpp/2_Concepts_and_Techniques/MC_EstimatePiQ/inc/test.h

@@ -0,0 +1,58 @@
+/* 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.
+ */
+
+#ifndef TEST_H
+#define TEST_H
+
+template <typename Real> struct Test
+{
+    Test()
+        : pass(false) {};
+
+    int          device;
+    unsigned int numSims;
+    unsigned int threadBlockSize;
+
+    bool   pass;
+    double elapsedTime;
+
+    bool operator()();
+};
+
+// Defaults are arbitrary to give sensible runtime
+#define k_sims_min  100000
+#define k_sims_max  10000000
+#define k_sims_def  100000
+#define k_sims_qa   100000
+#define k_bsize_min 32
+#define k_bsize_def 128
+#define k_bsize_qa  128
+
+// Target value
+#define PI 3.14159265359
+
+#endif

cpp/2_Concepts_and_Techniques/MC_EstimatePiQ/src/main.cpp

@@ -0,0 +1,237 @@
+/* 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.
+ */
+
+///////////////////////////////////////////////////////////////////////////////
+// Monte Carlo: Estimate Pi
+// ========================
+//
+// This sample demonstrates a very simple Monte Carlo estimation for Pi.
+//
+// This file, main.cpp, contains the setup information to run the test, for
+// example parsing the command line and integrating this sample with the
+// samples framework. As such it is perhaps less interesting than the guts of
+// the sample. Readers wishing to skip the clutter are advised to skip straight
+// to Test.operator() in test.cpp.
+///////////////////////////////////////////////////////////////////////////////
+
+
+#include <cuda_runtime.h>
+#include <helper_cuda.h>
+#include <helper_timer.h>
+#include <iomanip>
+#include <iostream>
+#include <stdexcept>
+
+#include "../inc/test.h"
+
+// SDK information
+static const char *printfFile = "MonteCarloEstimatePiQ.txt";
+
+// Forward declarations
+void                          showHelp(const int argc, const char **argv);
+template <typename Real> void runTest(int argc, const char **argv);
+
+int main(int argc, char **argv)
+{
+    using std::invalid_argument;
+    using std::string;
+
+    // Open the log file
+    printf("Monte Carlo Estimate Pi (with batch QRNG)\n");
+    printf("=========================================\n\n");
+
+    // If help flag is set, display help and exit immediately
+    if (checkCmdLineFlag(argc, (const char **)argv, "help")) {
+        printf("Displaying help on console\n");
+        showHelp(argc, (const char **)argv);
+        exit(EXIT_SUCCESS);
+    }
+
+    // Check the precision (checked against the device capability later)
+    try {
+        char *value;
+
+        if (getCmdLineArgumentString(argc, (const char **)argv, "precision", &value)) {
+            // Check requested precision is valid
+            string prec(value);
+
+            if (prec.compare("single") == 0 || prec.compare("\"single\"") == 0) {
+                runTest<float>(argc, (const char **)argv);
+            }
+            else if (prec.compare("double") == 0 || prec.compare("\"double\"") == 0) {
+                runTest<double>(argc, (const char **)argv);
+            }
+            else {
+                printf("specified precision (%s) is invalid, must be \"single\".\n", value);
+                throw invalid_argument("precision");
+            }
+        }
+        else {
+            runTest<float>(argc, (const char **)argv);
+        }
+    }
+    catch (invalid_argument &e) {
+        printf("invalid command line argument (%s)\n", e.what());
+        exit(EXIT_FAILURE);
+    }
+
+    // Finish
+    exit(EXIT_SUCCESS);
+}
+
+template <typename Real> void runTest(int argc, const char **argv)
+{
+    using std::invalid_argument;
+    using std::runtime_error;
+
+    try {
+        Test<Real>  test;
+        int         deviceCount = 0;
+        cudaError_t cudaResult  = cudaSuccess;
+
+        // by default specify GPU Device == 0
+        test.device = 0;
+
+        // Get number of available devices
+        cudaResult = cudaGetDeviceCount(&deviceCount);
+
+        if (cudaResult != cudaSuccess) {
+            printf("could not get device count.\n");
+            throw runtime_error("cudaGetDeviceCount");
+        }
+
+        // (default parameters)
+        test.numSims         = k_sims_qa;
+        test.threadBlockSize = k_bsize_qa;
+
+        {
+            char *value = 0;
+
+            if (getCmdLineArgumentString(argc, argv, "device", &value)) {
+                test.device = (int)atoi(value);
+
+                if (test.device >= deviceCount) {
+                    printf("invalid target device specified on command line (device %d does "
+                           "not exist).\n",
+                           test.device);
+                    throw invalid_argument("device");
+                }
+            }
+            else {
+                test.device = gpuGetMaxGflopsDeviceId();
+            }
+
+            if (getCmdLineArgumentString(argc, argv, "sims", &value)) {
+                test.numSims = (unsigned int)atoi(value);
+
+                if (test.numSims < k_sims_min || test.numSims > k_sims_max) {
+                    printf("specified number of simulations (%d) is invalid, must be "
+                           "between %d and %d.\n",
+                           test.numSims,
+                           k_sims_min,
+                           k_sims_max);
+                    throw invalid_argument("sims");
+                }
+            }
+            else {
+                test.numSims = k_sims_def;
+            }
+
+            if (getCmdLineArgumentString(argc, argv, "block-size", &value)) {
+                // Determine max threads per block
+                cudaDeviceProp deviceProperties;
+                cudaResult = cudaGetDeviceProperties(&deviceProperties, test.device);
+
+                if (cudaResult != cudaSuccess) {
+                    printf("cound not get device properties for device %d.\n", test.device);
+                    throw runtime_error("cudaGetDeviceProperties");
+                }
+
+                // Check requested size is valid
+                test.threadBlockSize = (unsigned int)atoi(value);
+
+                if (test.threadBlockSize < k_bsize_min
+                    || test.threadBlockSize > static_cast<unsigned int>(deviceProperties.maxThreadsPerBlock)) {
+                    printf("specified block size (%d) is invalid, must be between %d and %d "
+                           "for device %d.\n",
+                           test.threadBlockSize,
+                           k_bsize_min,
+                           deviceProperties.maxThreadsPerBlock,
+                           test.device);
+                    throw invalid_argument("block-size");
+                }
+
+                if (test.threadBlockSize & test.threadBlockSize - 1) {
+                    printf("specified block size (%d) is invalid, must be a power of two "
+                           "(see reduction function).\n",
+                           test.threadBlockSize);
+                    throw invalid_argument("block-size");
+                }
+            }
+            else {
+                test.threadBlockSize = k_bsize_def;
+            }
+        }
+        // Execute
+        test();
+    }
+    catch (invalid_argument &e) {
+        printf("invalid command line argument (%s)\n", e.what());
+        exit(EXIT_FAILURE);
+    }
+    catch (runtime_error &e) {
+        printf("runtime error (%s)\n", e.what());
+        exit(EXIT_FAILURE);
+    }
+}
+
+void showHelp(int argc, const char **argv)
+{
+    using std::cout;
+    using std::endl;
+    using std::left;
+    using std::setw;
+
+    if (argc > 0) {
+        cout << endl << argv[0] << endl;
+    }
+
+    cout << endl << "Syntax:" << endl;
+    cout << left;
+    cout << "    " << setw(20) << "--device=<device>"
+         << "Specify device to use for execution" << endl;
+    cout << "    " << setw(20) << "--sims=<N>"
+         << "Specify number of Monte Carlo simulations" << endl;
+    cout << "    " << setw(20) << "--block-size=<N>"
+         << "Specify number of threads per block" << endl;
+    cout << "    " << setw(20) << "--precision=<P>"
+         << "Specify the precision (\"single\" or \"double\")" << endl;
+    cout << endl;
+    cout << "    " << setw(20) << "--noprompt"
+         << "Skip prompt before exit" << endl;
+    cout << endl;
+}

cpp/2_Concepts_and_Techniques/MC_EstimatePiQ/src/piestimator.cu

@@ -0,0 +1,306 @@
+/* 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 <cooperative_groups.h>
+#include <cuda_runtime.h>
+#include <numeric>
+#include <stdexcept>
+#include <string>
+#include <typeinfo>
+#include <vector>
+
+#include "../inc/piestimator.h"
+
+namespace cg = cooperative_groups;
+#include <curand.h>
+
+using std::string;
+using std::vector;
+
+__device__ unsigned int reduce_sum(unsigned int in, cg::thread_block cta)
+{
+    extern __shared__ unsigned int sdata[];
+
+    // Perform first level of reduction:
+    // - Write to shared memory
+    unsigned int ltid = threadIdx.x;
+
+    sdata[ltid] = in;
+    cg::sync(cta);
+
+    // Do reduction in shared mem
+    for (unsigned int s = blockDim.x / 2; s > 0; s >>= 1) {
+        if (ltid < s) {
+            sdata[ltid] += sdata[ltid + s];
+        }
+
+        cg::sync(cta);
+    }
+
+    return sdata[0];
+}
+
+// Estimator kernel
+template <typename Real>
+__global__ void computeValue(unsigned int *const results, const Real *const points, const unsigned int numSims)
+{
+    // Handle to thread block group
+    cg::thread_block cta = cg::this_thread_block();
+    // Determine thread ID
+    unsigned int bid  = blockIdx.x;
+    unsigned int tid  = blockIdx.x * blockDim.x + threadIdx.x;
+    unsigned int step = gridDim.x * blockDim.x;
+
+    // Shift the input/output pointers
+    const Real *pointx = points + tid;
+    const Real *pointy = pointx + numSims;
+
+    // Count the number of points which lie inside the unit quarter-circle
+    unsigned int pointsInside = 0;
+
+    for (unsigned int i = tid; i < numSims; i += step, pointx += step, pointy += step) {
+        Real x       = *pointx;
+        Real y       = *pointy;
+        Real l2norm2 = x * x + y * y;
+
+        if (l2norm2 < static_cast<Real>(1)) {
+            pointsInside++;
+        }
+    }
+
+    // Reduce within the block
+    pointsInside = reduce_sum(pointsInside, cta);
+
+    // Store the result
+    if (threadIdx.x == 0) {
+        results[bid] = pointsInside;
+    }
+}
+
+template <typename Real>
+PiEstimator<Real>::PiEstimator(unsigned int numSims, unsigned int device, unsigned int threadBlockSize)
+    : m_numSims(numSims)
+    , m_device(device)
+    , m_threadBlockSize(threadBlockSize)
+{
+}
+
+template <typename Real> Real PiEstimator<Real>::operator()()
+{
+    cudaError_t               cudaResult = cudaSuccess;
+    struct cudaDeviceProp     deviceProperties;
+    struct cudaFuncAttributes funcAttributes;
+
+    // Get device properties
+    cudaResult = cudaGetDeviceProperties(&deviceProperties, m_device);
+
+    if (cudaResult != cudaSuccess) {
+        string msg("Could not get device properties: ");
+        msg += cudaGetErrorString(cudaResult);
+        throw std::runtime_error(msg);
+    }
+
+    // Check precision is valid
+    if (typeid(Real) == typeid(double)
+        && (deviceProperties.major < 1 || (deviceProperties.major == 1 && deviceProperties.minor < 3))) {
+        throw std::runtime_error("Device does not have double precision support");
+    }
+
+    // Attach to GPU
+    cudaResult = cudaSetDevice(m_device);
+
+    if (cudaResult != cudaSuccess) {
+        string msg("Could not set CUDA device: ");
+        msg += cudaGetErrorString(cudaResult);
+        throw std::runtime_error(msg);
+    }
+
+    // Determine how to divide the work between cores
+    dim3 block;
+    dim3 grid;
+    block.x = m_threadBlockSize;
+    grid.x  = (m_numSims + m_threadBlockSize - 1) / m_threadBlockSize;
+
+    // Aim to launch around ten or more times as many blocks as there
+    // are multiprocessors on the target device.
+    unsigned int blocksPerSM = 10;
+    unsigned int numSMs      = deviceProperties.multiProcessorCount;
+
+    while (grid.x > 2 * blocksPerSM * numSMs) {
+        grid.x >>= 1;
+    }
+
+    // Get computeValue function properties and check the maximum block size
+    cudaResult = cudaFuncGetAttributes(&funcAttributes, computeValue<Real>);
+
+    if (cudaResult != cudaSuccess) {
+        string msg("Could not get function attributes: ");
+        msg += cudaGetErrorString(cudaResult);
+        throw std::runtime_error(msg);
+    }
+
+    if (block.x > (unsigned int)funcAttributes.maxThreadsPerBlock) {
+        throw std::runtime_error("Block X dimension is too large for computeValue kernel");
+    }
+
+    // Check the dimensions are valid
+    if (block.x > (unsigned int)deviceProperties.maxThreadsDim[0]) {
+        throw std::runtime_error("Block X dimension is too large for device");
+    }
+
+    if (grid.x > (unsigned int)deviceProperties.maxGridSize[0]) {
+        throw std::runtime_error("Grid X dimension is too large for device");
+    }
+
+    // Allocate memory for points
+    // Each simulation has two random numbers to give X and Y coordinate
+    Real *d_points = 0;
+    cudaResult     = cudaMalloc((void **)&d_points, 2 * m_numSims * sizeof(Real));
+
+    if (cudaResult != cudaSuccess) {
+        string msg("Could not allocate memory on device for random numbers: ");
+        msg += cudaGetErrorString(cudaResult);
+        throw std::runtime_error(msg);
+    }
+
+    // Allocate memory for result
+    // Each thread block will produce one result
+    unsigned int *d_results = 0;
+    cudaResult              = cudaMalloc((void **)&d_results, grid.x * sizeof(unsigned int));
+
+    if (cudaResult != cudaSuccess) {
+        string msg("Could not allocate memory on device for partial results: ");
+        msg += cudaGetErrorString(cudaResult);
+        throw std::runtime_error(msg);
+    }
+
+    // Generate random points in unit square
+    curandStatus_t    curandResult;
+    curandGenerator_t qrng;
+
+    if (typeid(Real) == typeid(float)) {
+        curandResult = curandCreateGenerator(&qrng, CURAND_RNG_QUASI_SOBOL32);
+    }
+    else if (typeid(Real) == typeid(double)) {
+        curandResult = curandCreateGenerator(&qrng, CURAND_RNG_QUASI_SOBOL64);
+    }
+    else {
+        string msg("Could not create random number generator of specified type");
+        throw std::runtime_error(msg);
+    }
+
+    if (curandResult != CURAND_STATUS_SUCCESS) {
+        string msg("Could not create quasi-random number generator: ");
+        msg += curandResult;
+        throw std::runtime_error(msg);
+    }
+
+    curandResult = curandSetQuasiRandomGeneratorDimensions(qrng, 2);
+
+    if (curandResult != CURAND_STATUS_SUCCESS) {
+        string msg("Could not set number of dimensions for quasi-random number "
+                   "generator: ");
+        msg += curandResult;
+        throw std::runtime_error(msg);
+    }
+
+    curandResult = curandSetGeneratorOrdering(qrng, CURAND_ORDERING_QUASI_DEFAULT);
+
+    if (curandResult != CURAND_STATUS_SUCCESS) {
+        string msg("Could not set order for quasi-random number generator: ");
+        msg += curandResult;
+        throw std::runtime_error(msg);
+    }
+
+    if (typeid(Real) == typeid(float)) {
+        curandResult = curandGenerateUniform(qrng, (float *)d_points, 2 * m_numSims);
+    }
+    else if (typeid(Real) == typeid(double)) {
+        curandResult = curandGenerateUniformDouble(qrng, (double *)d_points, 2 * m_numSims);
+    }
+    else {
+        string msg("Could not generate random numbers of specified type");
+        throw std::runtime_error(msg);
+    }
+
+    if (curandResult != CURAND_STATUS_SUCCESS) {
+        string msg("Could not generate quasi-random numbers: ");
+        msg += curandResult;
+        throw std::runtime_error(msg);
+    }
+
+    curandResult = curandDestroyGenerator(qrng);
+
+    if (curandResult != CURAND_STATUS_SUCCESS) {
+        string msg("Could not destroy quasi-random number generator: ");
+        msg += curandResult;
+        throw std::runtime_error(msg);
+    }
+
+    // Count the points inside unit quarter-circle
+    computeValue<Real><<<grid, block, block.x * sizeof(unsigned int)>>>(d_results, d_points, m_numSims);
+
+    // Copy partial results back
+    vector<unsigned int> results(grid.x);
+    cudaResult = cudaMemcpy(&results[0], d_results, grid.x * sizeof(unsigned int), cudaMemcpyDeviceToHost);
+
+    if (cudaResult != cudaSuccess) {
+        string msg("Could not copy partial results to host: ");
+        msg += cudaGetErrorString(cudaResult);
+        throw std::runtime_error(msg);
+    }
+
+    // Complete sum-reduction on host
+    Real value = static_cast<Real>(std::accumulate(results.begin(), results.end(), 0));
+
+    // Determine the proportion of points inside the quarter-circle,
+    // i.e. the area of the unit quarter-circle
+    value /= m_numSims;
+
+    // Value is currently an estimate of the area of a unit quarter-circle, so we
+    // can scale to a full circle by multiplying by four. Now since the area of a
+    // circle is pi * r^2, and r is one, the value will be an estimate for the
+    // value of pi.
+    value *= 4;
+
+    // Cleanup
+    if (d_points) {
+        cudaFree(d_points);
+        d_points = 0;
+    }
+
+    if (d_results) {
+        cudaFree(d_results);
+        d_results = 0;
+    }
+
+    return value;
+}
+
+// Explicit template instantiation
+template class PiEstimator<float>;
+template class PiEstimator<double>;

cpp/2_Concepts_and_Techniques/MC_EstimatePiQ/src/test.cpp

@@ -0,0 +1,112 @@
+/* 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 "../inc/test.h"
+
+#include <cassert>
+#include <cuda_runtime.h>
+#include <helper_timer.h>
+#include <iomanip>
+#include <iostream>
+#include <math.h>
+#include <memory>
+#include <sstream>
+#include <stdexcept>
+#include <stdio.h>
+#include <typeinfo>
+
+#include "../inc/piestimator.h"
+
+template <typename Real> bool Test<Real>::operator()()
+{
+    using std::endl;
+    using std::setw;
+    using std::stringstream;
+
+    StopWatchInterface *timer = NULL;
+    sdkCreateTimer(&timer);
+
+    // Get device properties
+    struct cudaDeviceProp deviceProperties;
+    cudaError_t           cudaResult = cudaGetDeviceProperties(&deviceProperties, device);
+
+    if (cudaResult != cudaSuccess) {
+        std::string msg("Could not get device properties: ");
+        msg += cudaGetErrorString(cudaResult);
+        throw std::runtime_error(msg);
+    }
+
+    // Evaluate on GPU
+    printf("Estimating Pi on GPU (%s)\n\n", deviceProperties.name);
+    PiEstimator<Real> estimator(numSims, device, threadBlockSize);
+    sdkStartTimer(&timer);
+    Real result = estimator();
+    sdkStopTimer(&timer);
+    elapsedTime = sdkGetAverageTimerValue(&timer) / 1000.0f;
+
+    // Tolerance to compare result with expected
+    // This is just to check that nothing has gone very wrong with the
+    // test, the actual accuracy of the result depends on the number of
+    // Monte Carlo trials
+    const Real tolerance = static_cast<Real>(0.01);
+
+    // Display results
+    Real abserror = fabs(result - static_cast<Real>(PI));
+    Real relerror = abserror / static_cast<Real>(PI);
+    printf("Precision:      %s\n", (typeid(Real) == typeid(double)) ? "double" : "single");
+    printf("Number of sims: %d\n", numSims);
+    printf("Tolerance:      %e\n", tolerance);
+    printf("GPU result:     %e\n", result);
+    printf("Expected:       %e\n", PI);
+    printf("Absolute error: %e\n", abserror);
+    printf("Relative error: %e\n\n", relerror);
+
+    // Check result
+    if (relerror > tolerance) {
+        printf("computed result (%e) does not match expected result (%e).\n", result, PI);
+        pass = false;
+    }
+    else {
+        pass = true;
+    }
+
+    // Print results
+    printf("MonteCarloEstimatePiQ, Performance = %.2f sims/s, Time = %.2f(ms), "
+           "NumDevsUsed = %u, Blocksize = %u\n",
+           numSims / elapsedTime,
+           elapsedTime * 1000.0f,
+           1,
+           threadBlockSize);
+
+    sdkDeleteTimer(&timer);
+
+    return pass;
+}
+
+// Explicit template instantiation
+template struct Test<float>;
+template struct Test<double>;

cpp/2_Concepts_and_Techniques/MC_SingleAsianOptionP/.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/2_Concepts_and_Techniques/MC_SingleAsianOptionP/.vscode/extensions.json

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

cpp/2_Concepts_and_Techniques/MC_SingleAsianOptionP/CMakeLists.txt

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

cpp/2_Concepts_and_Techniques/MC_SingleAsianOptionP/README.md

@@ -0,0 +1,36 @@
+# MC_SingleAsianOptionP - Monte Carlo Single Asian Option
+
+## Description
+
+This sample uses Monte Carlo to simulate Single Asian Options using the NVIDIA CURAND library.
+
+## Key Concepts
+
+Random Number Generator, Computational Finance, CURAND Library
+
+## 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, cudaGetErrorString, cudaFree, cudaSetDevice, cudaGetDeviceCount, cudaMalloc, cudaFuncGetAttributes, cudaGetDeviceProperties
+
+## Dependencies needed to build/run
+[CURAND](../../../README.md#curand)
+
+## 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/2_Concepts_and_Techniques/MC_SingleAsianOptionP/inc/asianoption.h

@@ -0,0 +1,51 @@
+/* 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.
+ */
+
+#ifndef ASIANOPTION_H
+#define ASIANOPTION_H
+
+template <typename Real> struct AsianOption
+{
+    enum CallPut { Call, Put };
+
+    // Parameters
+    Real spot;
+    Real strike;
+    Real r;
+    Real sigma;
+    Real tenor;
+    Real dt;
+
+    // Value
+    Real golden;
+    Real value;
+
+    // Option type
+    CallPut type;
+};
+
+#endif

cpp/2_Concepts_and_Techniques/MC_SingleAsianOptionP/inc/cudasharedmem.h

@@ -0,0 +1,102 @@
+/* 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.
+ */
+
+#ifndef CUDASHAREDMEM_H
+#define CUDASHAREDMEM_H
+
+//****************************************************************************
+// Because dynamically sized shared memory arrays are declared "extern",
+// we can't templatize them directly.  To get around this, we declare a
+// simple wrapper struct that will declare the extern array with a different
+// name depending on the type.  This avoids compiler errors about duplicate
+// definitions.
+//
+// To use dynamically allocated shared memory in a templatized __global__ or
+// __device__ function, just replace code like this:
+//      template<class T>
+//      __global__ void
+//      foo( T* g_idata, T* g_odata)
+//      {
+//          // Shared mem size is determined by the host app at run time
+//          extern __shared__  T sdata[];
+//          ...
+//          x = sdata[i];
+//          sdata[i] = x;
+//          ...
+//      }
+//
+// With this:
+//      template<class T>
+//      __global__ void
+//      foo( T* g_idata, T* g_odata)
+//      {
+//          // Shared mem size is determined by the host app at run time
+//          SharedMemory<T> sdata;
+//          ...
+//          x = sdata[i];
+//          sdata[i] = x;
+//          ...
+//      }
+//****************************************************************************
+
+// This is the un-specialized struct.  Note that we prevent instantiation of
+// this struct by making it abstract (i.e. with pure virtual methods).
+template <typename T> struct SharedMemory
+{
+    // Ensure that we won't compile any un-specialized types
+    virtual __device__ T &operator*()       = 0;
+    virtual __device__ T &operator[](int i) = 0;
+};
+
+#define BUILD_SHAREDMEMORY_TYPE(t, n)   \
+    template <> struct SharedMemory<t>  \
+    {                                   \
+        __device__ t &operator*()       \
+        {                               \
+            extern __shared__ t n[];    \
+            return *n;                  \
+        }                               \
+        __device__ t &operator[](int i) \
+        {                               \
+            extern __shared__ t n[];    \
+            return n[i];                \
+        }                               \
+    }
+
+BUILD_SHAREDMEMORY_TYPE(int, s_int);
+BUILD_SHAREDMEMORY_TYPE(unsigned int, s_uint);
+BUILD_SHAREDMEMORY_TYPE(char, s_char);
+BUILD_SHAREDMEMORY_TYPE(unsigned char, s_uchar);
+BUILD_SHAREDMEMORY_TYPE(short, s_short);
+BUILD_SHAREDMEMORY_TYPE(unsigned short, s_ushort);
+BUILD_SHAREDMEMORY_TYPE(long, s_long);
+BUILD_SHAREDMEMORY_TYPE(unsigned long, s_ulong);
+BUILD_SHAREDMEMORY_TYPE(bool, s_bool);
+BUILD_SHAREDMEMORY_TYPE(float, s_float);
+BUILD_SHAREDMEMORY_TYPE(double, s_double);
+
+#endif

cpp/2_Concepts_and_Techniques/MC_SingleAsianOptionP/inc/pricingengine.h

@@ -0,0 +1,46 @@
+/* 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.
+ */
+
+#ifndef PRICINGENGINE_H
+#define PRICINGENGINE_H
+
+#include "asianoption.h"
+
+template <typename Real> class PricingEngine
+{
+public:
+    PricingEngine(unsigned int numSims, unsigned int device, unsigned int threadBlockSize, unsigned int seed);
+    void operator()(AsianOption<Real> &option);
+
+private:
+    unsigned int m_seed;
+    unsigned int m_numSims;
+    unsigned int m_device;
+    unsigned int m_threadBlockSize;
+};
+
+#endif

cpp/2_Concepts_and_Techniques/MC_SingleAsianOptionP/inc/test.h

@@ -0,0 +1,58 @@
+/* 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.
+ */
+
+#ifndef TEST_H
+#define TEST_H
+
+template <typename Real> struct Test
+{
+    Test()
+        : pass(false) {};
+
+    int          device;
+    unsigned int numSims;
+    unsigned int threadBlockSize;
+    unsigned int seed;
+
+    bool   pass;
+    double elapsedTime;
+
+    bool operator()();
+};
+
+// Defaults are arbitrary to give sensible runtime
+#define k_sims_min  100000
+#define k_sims_max  1000000
+#define k_sims_def  100000
+#define k_sims_qa   100000
+#define k_bsize_min 32
+#define k_bsize_def 128
+#define k_bsize_qa  128
+#define k_seed_def  1234
+#define k_seed_qa   1234
+
+#endif

cpp/2_Concepts_and_Techniques/MC_SingleAsianOptionP/src/main.cpp

@@ -0,0 +1,254 @@
+/* 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.
+ */
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Monte Carlo: Single Asian Option
+// ================================
+//
+// This sample demonstrates pricing a single European-exercise average-price
+// Asian option (arithmetic discrete average).
+//
+// This file, main.cpp, contains the setup information to run the test, for
+// example parsing the command line and integrating this sample with the
+// samples framework. As such it is perhaps less interesting than the guts of
+// the sample. Readers wishing to skip the clutter are advised to skip straight
+// to Test.operator() in test.cpp.
+///////////////////////////////////////////////////////////////////////////////
+
+
+#include <cuda_runtime.h>
+#include <helper_cuda.h>
+#include <helper_timer.h>
+#include <iomanip>
+#include <iostream>
+#include <stdexcept>
+
+#include "../inc/test.h"
+
+// Forward declarations
+void                          showHelp(const int argc, const char **argv);
+template <typename Real> void runTest(int argc, const char **argv);
+
+int main(int argc, char **argv)
+{
+    using std::invalid_argument;
+    using std::string;
+
+    // Open the log file
+    printf("Monte Carlo Single Asian Option (with PRNG)\n");
+    printf("===========================================\n\n");
+
+    // If help flag is set, display help and exit immediately
+    if (checkCmdLineFlag(argc, (const char **)argv, "help")) {
+        printf("Displaying help on console\n");
+        showHelp(argc, (const char **)argv);
+        exit(EXIT_SUCCESS);
+    }
+
+    // Check the precision (checked against the device capability later)
+    try {
+        char *value;
+
+        if (getCmdLineArgumentString(argc, (const char **)argv, "precision", &value)) {
+            // Check requested precision is valid
+            string prec(value);
+
+            if (prec.compare("single") == 0 || prec.compare("\"single\"") == 0) {
+                runTest<float>(argc, (const char **)argv);
+            }
+            else if (prec.compare("double") == 0 || prec.compare("\"double\"") == 0) {
+                runTest<double>(argc, (const char **)argv);
+            }
+            else {
+                printf("specified precision (%s) is invalid, must be \"single\" or "
+                       "\"double\".\n",
+                       value);
+                throw invalid_argument("precision");
+            }
+        }
+        else {
+            runTest<float>(argc, (const char **)argv);
+        }
+    }
+    catch (invalid_argument &e) {
+        printf("invalid command line argument (%s)\n", e.what());
+        exit(EXIT_FAILURE);
+    }
+
+    // Finish
+    exit(EXIT_SUCCESS);
+}
+
+template <typename Real> void runTest(int argc, const char **argv)
+{
+    using std::invalid_argument;
+    using std::runtime_error;
+
+    try {
+        Test<Real>  test;
+        int         deviceCount = 0;
+        cudaError_t cudaResult  = cudaSuccess;
+
+        // by default specify GPU Device == 0
+        test.device = 0;
+
+        // Get number of available devices
+        cudaResult = cudaGetDeviceCount(&deviceCount);
+
+        if (cudaResult != cudaSuccess) {
+            printf("could not get device count.\n");
+            throw runtime_error("cudaGetDeviceCount");
+        }
+
+        // (default parameters)
+        test.numSims         = k_sims_qa;
+        test.threadBlockSize = k_bsize_qa;
+        test.seed            = k_seed_qa;
+
+        {
+            char *value = 0;
+
+            if (getCmdLineArgumentString(argc, argv, "device", &value)) {
+                test.device = (int)atoi(value);
+
+                if (test.device >= deviceCount) {
+                    printf("invalid target device specified on command line (device %d does "
+                           "not exist).\n",
+                           test.device);
+                    throw invalid_argument("device");
+                }
+            }
+            else {
+                test.device = gpuGetMaxGflopsDeviceId();
+            }
+
+            if (getCmdLineArgumentString(argc, argv, "sims", &value)) {
+                test.numSims = (unsigned int)atoi(value);
+
+                if (test.numSims < k_sims_min || test.numSims > k_sims_max) {
+                    printf("specified number of simulations (%d) is invalid, must be "
+                           "between %d and %d.\n",
+                           test.numSims,
+                           k_sims_min,
+                           k_sims_max);
+                    throw invalid_argument("sims");
+                }
+            }
+            else {
+                test.numSims = k_sims_def;
+            }
+
+            if (getCmdLineArgumentString(argc, argv, "block-size", &value)) {
+                // Determine max threads per block
+                cudaDeviceProp deviceProperties;
+                cudaResult = cudaGetDeviceProperties(&deviceProperties, test.device);
+
+                if (cudaResult != cudaSuccess) {
+                    printf("cound not get device properties for device %d.\n", test.device);
+                    throw runtime_error("cudaGetDeviceProperties");
+                }
+
+                // Check requested size is valid
+                test.threadBlockSize = (unsigned int)atoi(value);
+
+                if (test.threadBlockSize < k_bsize_min
+                    || test.threadBlockSize > static_cast<unsigned int>(deviceProperties.maxThreadsPerBlock)) {
+                    printf("specified block size (%d) is invalid, must be between %d and %d "
+                           "for device %d.\n",
+                           test.threadBlockSize,
+                           k_bsize_min,
+                           deviceProperties.maxThreadsPerBlock,
+                           test.device);
+                    throw invalid_argument("block-size");
+                }
+
+                if (test.threadBlockSize & test.threadBlockSize - 1) {
+                    printf("specified block size (%d) is invalid, must be a power of two "
+                           "(see reduction function).\n",
+                           test.threadBlockSize);
+                    throw invalid_argument("block-size");
+                }
+            }
+            else {
+                test.threadBlockSize = k_bsize_def;
+            }
+
+            if (getCmdLineArgumentString(argc, argv, "seed", &value)) {
+                // Check requested seed is valid
+                test.seed = (unsigned int)atoi(value);
+
+                if (test.seed == 0) {
+                    printf("specified seed (%d) is invalid, must be non-zero.\n", test.seed);
+                    throw invalid_argument("seed");
+                }
+            }
+            else {
+                test.seed = k_seed_def;
+            }
+        }
+        // Execute
+        test();
+    }
+    catch (invalid_argument &e) {
+        printf("invalid command line argument (%s)\n", e.what());
+        exit(EXIT_FAILURE);
+    }
+    catch (runtime_error &e) {
+        printf("runtime error (%s)\n", e.what());
+        exit(EXIT_FAILURE);
+    }
+}
+
+void showHelp(int argc, const char **argv)
+{
+    using std::cout;
+    using std::endl;
+    using std::left;
+    using std::setw;
+
+    if (argc > 0) {
+        cout << endl << argv[0] << endl;
+    }
+
+    cout << endl << "Syntax:" << endl;
+    cout << left;
+    cout << "    " << setw(20) << "--device=<device>"
+         << "Specify device to use for execution" << endl;
+    cout << "    " << setw(20) << "--sims=<N>"
+         << "Specify number of Monte Carlo simulations" << endl;
+    cout << "    " << setw(20) << "--block-size=<N>"
+         << "Specify number of threads per block" << endl;
+    cout << "    " << setw(20) << "--seed=<N>"
+         << "Specify the seed to use for the random number generator" << endl;
+    cout << "    " << setw(20) << "--precision=<P>"
+         << "Specify the precision (\"single\" or \"double\")" << endl;
+    cout << endl;
+    cout << "    " << setw(20) << "--noprompt"
+         << "Skip prompt before exit" << endl;
+    cout << endl;
+}

cpp/2_Concepts_and_Techniques/MC_SingleAsianOptionP/src/pricingengine.cu

@@ -0,0 +1,369 @@
+/* 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 <cooperative_groups.h>
+#include <cuda_runtime.h>
+#include <numeric>
+#include <stdexcept>
+#include <string>
+#include <typeinfo>
+#include <vector>
+
+#include "../inc/pricingengine.h"
+
+namespace cg = cooperative_groups;
+#include <curand_kernel.h>
+
+#include "../inc/asianoption.h"
+#include "../inc/cudasharedmem.h"
+
+using std::string;
+using std::vector;
+
+// RNG init kernel
+__global__ void initRNG(curandState *const rngStates, const unsigned int seed)
+{
+    // Determine thread ID
+    unsigned int tid = blockIdx.x * blockDim.x + threadIdx.x;
+
+    // Initialise the RNG
+    curand_init(seed, tid, 0, &rngStates[tid]);
+}
+
+__device__ inline float getPathStep(float &drift, float &diffusion, curandState &state)
+{
+    return expf(drift + diffusion * curand_normal(&state));
+}
+__device__ inline double getPathStep(double &drift, double &diffusion, curandState &state)
+{
+    return exp(drift + diffusion * curand_normal_double(&state));
+}
+
+// Path generation kernel
+template <typename Real>
+__global__ void generatePaths(Real *const                    paths,
+                              curandState *const             rngStates,
+                              const AsianOption<Real> *const option,
+                              const unsigned int             numSims,
+                              const unsigned int             numTimesteps)
+{
+    // Determine thread ID
+    unsigned int tid  = blockIdx.x * blockDim.x + threadIdx.x;
+    unsigned int step = gridDim.x * blockDim.x;
+
+    // Compute parameters
+    Real drift     = (option->r - static_cast<Real>(0.5) * option->sigma * option->sigma) * option->dt;
+    Real diffusion = option->sigma * sqrt(option->dt);
+
+    // Initialise the RNG
+    curandState localState = rngStates[tid];
+
+    for (unsigned int i = tid; i < numSims; i += step) {
+        // Shift the output pointer
+        Real *output = paths + i;
+
+        // Simulate the path
+        Real s = static_cast<Real>(1);
+
+        for (unsigned int t = 0; t < numTimesteps; t++, output += numSims) {
+            s *= getPathStep(drift, diffusion, localState);
+            *output = s;
+        }
+    }
+}
+
+template <typename Real> __device__ Real reduce_sum(Real in, cg::thread_block cta)
+{
+    SharedMemory<Real> sdata;
+
+    // Perform first level of reduction:
+    // - Write to shared memory
+    unsigned int ltid = threadIdx.x;
+
+    sdata[ltid] = in;
+    cg::sync(cta);
+
+    // Do reduction in shared mem
+    for (unsigned int s = blockDim.x / 2; s > 0; s >>= 1) {
+        if (ltid < s) {
+            sdata[ltid] += sdata[ltid + s];
+        }
+
+        cg::sync(cta);
+    }
+
+    return sdata[0];
+}
+
+// Valuation kernel
+template <typename Real>
+__global__ void computeValue(Real *const                    values,
+                             const Real *const              paths,
+                             const AsianOption<Real> *const option,
+                             const unsigned int             numSims,
+                             const unsigned int             numTimesteps)
+{
+    // Handle to thread block group
+    cg::thread_block cta = cg::this_thread_block();
+    // Determine thread ID
+    unsigned int bid  = blockIdx.x;
+    unsigned int tid  = blockIdx.x * blockDim.x + threadIdx.x;
+    unsigned int step = gridDim.x * blockDim.x;
+
+    Real sumPayoffs = static_cast<Real>(0);
+
+    for (unsigned int i = tid; i < numSims; i += step) {
+        // Shift the input pointer
+        const Real *path = paths + i;
+        // Compute the arithmetic average
+        Real avg = static_cast<Real>(0);
+
+        for (unsigned int t = 0; t < numTimesteps; t++, path += numSims) {
+            avg += *path;
+        }
+
+        avg = avg * option->spot / numTimesteps;
+        // Compute the payoff
+        Real payoff = avg - option->strike;
+
+        if (option->type == AsianOption<Real>::Put) {
+            payoff = -payoff;
+        }
+
+        payoff = max(static_cast<Real>(0), payoff);
+        // Accumulate payoff locally
+        sumPayoffs += payoff;
+    }
+
+    // Reduce within the block
+    sumPayoffs = reduce_sum<Real>(sumPayoffs, cta);
+
+    // Store the result
+    if (threadIdx.x == 0) {
+        values[bid] = sumPayoffs;
+    }
+}
+
+template <typename Real>
+PricingEngine<Real>::PricingEngine(unsigned int numSims,
+                                   unsigned int device,
+                                   unsigned int threadBlockSize,
+                                   unsigned int seed)
+    : m_numSims(numSims)
+    , m_device(device)
+    , m_threadBlockSize(threadBlockSize)
+    , m_seed(seed)
+{
+}
+
+template <typename Real> void PricingEngine<Real>::operator()(AsianOption<Real> &option)
+{
+    cudaError_t               cudaResult = cudaSuccess;
+    struct cudaDeviceProp     deviceProperties;
+    struct cudaFuncAttributes funcAttributes;
+
+    // Get device properties
+    cudaResult = cudaGetDeviceProperties(&deviceProperties, m_device);
+
+    if (cudaResult != cudaSuccess) {
+        string msg("Could not get device properties: ");
+        msg += cudaGetErrorString(cudaResult);
+        throw std::runtime_error(msg);
+    }
+
+    // Check precision is valid
+    unsigned int deviceVersion = deviceProperties.major * 10 + deviceProperties.minor;
+
+    if (typeid(Real) == typeid(double) && deviceVersion < 13) {
+        throw std::runtime_error("Device does not have double precision support");
+    }
+
+    // Attach to GPU
+    cudaResult = cudaSetDevice(m_device);
+
+    if (cudaResult != cudaSuccess) {
+        string msg("Could not set CUDA device: ");
+        msg += cudaGetErrorString(cudaResult);
+        throw std::runtime_error(msg);
+    }
+
+    // Determine how to divide the work between cores
+    dim3 block;
+    dim3 grid;
+    block.x = m_threadBlockSize;
+    grid.x  = (m_numSims + m_threadBlockSize - 1) / m_threadBlockSize;
+
+    // Aim to launch around ten or more times as many blocks as there
+    // are multiprocessors on the target device.
+    unsigned int blocksPerSM = 10;
+    unsigned int numSMs      = deviceProperties.multiProcessorCount;
+
+    while (grid.x > 2 * blocksPerSM * numSMs) {
+        grid.x >>= 1;
+    }
+
+    // Get initRNG function properties and check the maximum block size
+    cudaResult = cudaFuncGetAttributes(&funcAttributes, initRNG);
+
+    if (cudaResult != cudaSuccess) {
+        string msg("Could not get function attributes: ");
+        msg += cudaGetErrorString(cudaResult);
+        throw std::runtime_error(msg);
+    }
+
+    if (block.x > (unsigned int)funcAttributes.maxThreadsPerBlock) {
+        throw std::runtime_error("Block X dimension is too large for initRNG kernel");
+    }
+
+    // Get generatePaths function properties and check the maximum block size
+    cudaResult = cudaFuncGetAttributes(&funcAttributes, generatePaths<Real>);
+
+    if (cudaResult != cudaSuccess) {
+        string msg("Could not get function attributes: ");
+        msg += cudaGetErrorString(cudaResult);
+        throw std::runtime_error(msg);
+    }
+
+    if (block.x > (unsigned int)funcAttributes.maxThreadsPerBlock) {
+        throw std::runtime_error("Block X dimension is too large for generatePaths kernel");
+    }
+
+    // Get computeValue function properties and check the maximum block size
+    cudaResult = cudaFuncGetAttributes(&funcAttributes, computeValue<Real>);
+
+    if (cudaResult != cudaSuccess) {
+        string msg("Could not get function attributes: ");
+        msg += cudaGetErrorString(cudaResult);
+        throw std::runtime_error(msg);
+    }
+
+    if (block.x > (unsigned int)funcAttributes.maxThreadsPerBlock) {
+        throw std::runtime_error("Block X dimension is too large for computeValue kernel");
+    }
+
+    // Setup problem on GPU
+    AsianOption<Real> *d_option = 0;
+    cudaResult                  = cudaMalloc((void **)&d_option, sizeof(AsianOption<Real>));
+
+    if (cudaResult != cudaSuccess) {
+        string msg("Could not allocate memory on device for option data: ");
+        msg += cudaGetErrorString(cudaResult);
+        throw std::runtime_error(msg);
+    }
+
+    cudaResult = cudaMemcpy(d_option, &option, sizeof(AsianOption<Real>), cudaMemcpyHostToDevice);
+
+    if (cudaResult != cudaSuccess) {
+        string msg("Could not copy data to device: ");
+        msg += cudaGetErrorString(cudaResult);
+        throw std::runtime_error(msg);
+    }
+
+    // Allocate memory for paths
+    Real *d_paths      = 0;
+    int   numTimesteps = static_cast<int>(option.tenor / option.dt);
+    cudaResult         = cudaMalloc((void **)&d_paths, m_numSims * numTimesteps * sizeof(Real));
+
+    if (cudaResult != cudaSuccess) {
+        string msg("Could not allocate memory on device for paths: ");
+        msg += cudaGetErrorString(cudaResult);
+        throw std::runtime_error(msg);
+    }
+
+    // Allocate memory for RNG states
+    curandState *d_rngStates = 0;
+    cudaResult               = cudaMalloc((void **)&d_rngStates, grid.x * block.x * sizeof(curandState));
+
+    if (cudaResult != cudaSuccess) {
+        string msg("Could not allocate memory on device for RNG state: ");
+        msg += cudaGetErrorString(cudaResult);
+        throw std::runtime_error(msg);
+    }
+
+    // Allocate memory for result
+    Real *d_values = 0;
+    cudaResult     = cudaMalloc((void **)&d_values, grid.x * sizeof(Real));
+
+    if (cudaResult != cudaSuccess) {
+        string msg("Could not allocate memory on device for partial results: ");
+        msg += cudaGetErrorString(cudaResult);
+        throw std::runtime_error(msg);
+    }
+
+    // Initialise RNG
+    initRNG<<<grid, block>>>(d_rngStates, m_seed);
+
+    // Generate paths
+    generatePaths<Real><<<grid, block>>>(d_paths, d_rngStates, d_option, m_numSims, numTimesteps);
+
+    // Compute value
+    computeValue<<<grid, block, block.x * sizeof(Real)>>>(d_values, d_paths, d_option, m_numSims, numTimesteps);
+
+    // Copy partial results back
+    vector<Real> values(grid.x);
+    cudaResult = cudaMemcpy(&values[0], d_values, grid.x * sizeof(Real), cudaMemcpyDeviceToHost);
+
+    if (cudaResult != cudaSuccess) {
+        string msg("Could not copy partial results to host: ");
+        msg += cudaGetErrorString(cudaResult);
+        throw std::runtime_error(msg);
+    }
+
+    // Complete sum-reduction on host
+    option.value = std::accumulate(values.begin(), values.end(), static_cast<Real>(0));
+
+    // Compute the mean
+    option.value /= m_numSims;
+
+    // Discount to present value
+    option.value *= exp(-option.r * option.tenor);
+
+    // Cleanup
+    if (d_option) {
+        cudaFree(d_option);
+        d_option = 0;
+    }
+
+    if (d_paths) {
+        cudaFree(d_paths);
+        d_paths = 0;
+    }
+
+    if (d_rngStates) {
+        cudaFree(d_rngStates);
+        d_rngStates = 0;
+    }
+
+    if (d_values) {
+        cudaFree(d_values);
+        d_values = 0;
+    }
+}
+
+// Explicit template instantiation
+template class PricingEngine<float>;
+template class PricingEngine<double>;

cpp/2_Concepts_and_Techniques/MC_SingleAsianOptionP/src/test.cpp

@@ -0,0 +1,138 @@
+/* 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 "../inc/test.h"
+
+#include <cassert>
+#include <cuda_runtime.h>
+#include <helper_timer.h>
+#include <iomanip>
+#include <iostream>
+#include <math.h>
+#include <memory>
+#include <sstream>
+#include <stdexcept>
+#include <stdio.h>
+#include <typeinfo>
+
+#include "../inc/asianoption.h"
+#include "../inc/pricingengine.h"
+
+template <typename Real> bool Test<Real>::operator()()
+{
+    using std::endl;
+    using std::setw;
+    using std::stringstream;
+
+    StopWatchInterface *timer = NULL;
+    sdkCreateTimer(&timer);
+
+    // Get device properties
+    struct cudaDeviceProp deviceProperties;
+    cudaError_t           cudaResult = cudaGetDeviceProperties(&deviceProperties, device);
+
+    if (cudaResult != cudaSuccess) {
+        std::string msg("Could not get device properties: ");
+        msg += cudaGetErrorString(cudaResult);
+        throw std::runtime_error(msg);
+    }
+
+    // This test prices a single Asian call option with European
+    // exercise, with the priced averaged arithmetically on discrete
+    // trading days (weekdays).
+    AsianOption<Real> option;
+    option.spot   = static_cast<Real>(40);
+    option.strike = static_cast<Real>(35);
+    option.r      = static_cast<Real>(0.03);
+    option.sigma  = static_cast<Real>(0.20);
+    option.tenor  = static_cast<Real>(1.0 / 3.0);
+    option.dt     = static_cast<Real>(1.0 / 261);
+    option.type   = AsianOption<Real>::Call;
+    option.value  = static_cast<Real>(0.0);
+    option.golden = static_cast<Real>(5.162534);
+
+    // Evaluate on GPU
+    printf("Pricing option on GPU (%s)\n\n", deviceProperties.name);
+    PricingEngine<Real> pricer(numSims, device, threadBlockSize, seed);
+    sdkStartTimer(&timer);
+    pricer(option);
+    sdkStopTimer(&timer);
+    elapsedTime = sdkGetAverageTimerValue(&timer) / 1000.0f;
+
+    // Tolerance to compare result with expected
+    // This is just to check that nothing has gone very wrong with the
+    // test, the actual accuracy of the result depends on the number of
+    // Monte Carlo trials
+    const Real tolerance = static_cast<Real>(0.1);
+
+    // Display results
+    stringstream output;
+    output << "Precision:      " << ((typeid(Real) == typeid(double)) ? "double" : "single") << endl;
+    output << "Number of sims: " << numSims << endl;
+    output << endl;
+    output << "   Spot    |   Strike   |     r      |   sigma    |   tenor    |  "
+              "Call/Put  |   Value    |  Expected  |"
+           << endl;
+    output << "-----------|------------|------------|------------|------------|--"
+              "----------|------------|------------|"
+           << endl;
+    output << setw(10) << option.spot << " | ";
+    output << setw(10) << option.strike << " | ";
+    output << setw(10) << option.r << " | ";
+    output << setw(10) << option.sigma << " | ";
+    output << setw(10) << option.tenor << " | ";
+    output << setw(10) << (option.type == AsianOption<Real>::Call ? "Call" : "Put") << " | ";
+    output << setw(10) << option.value << " | ";
+    output << setw(10) << option.golden << " |";
+
+    printf("%s\n\n", output.str().c_str());
+
+    // Check result
+    if (fabs(option.value - option.golden) > tolerance) {
+        printf("computed result (%e) does not match expected result (%e).\n", option.value, option.golden);
+        pass = false;
+    }
+    else {
+        pass = true;
+    }
+
+    // Print results
+    printf("MonteCarloSingleAsianOptionP, Performance = %.2f sims/s, Time = "
+           "%.2f(ms), NumDevsUsed = %u, Blocksize = %u\n",
+           numSims / elapsedTime,
+           elapsedTime * 1000.0f,
+           1,
+           threadBlockSize);
+
+    sdkDeleteTimer(&timer);
+
+    return pass;
+}
+
+// Explicit template instantiation
+template struct Test<float>;
+template struct Test<double>;

cpp/2_Concepts_and_Techniques/README.md

@@ -0,0 +1,98 @@
+# 2. Concepts and Techniques
+
+
+### [boxFilter](./boxFilter)
+Fast image box filter using CUDA with OpenGL rendering.
+
+### [convolutionSeparable](./convolutionSeparable)
+This sample implements a separable convolution filter of a 2D signal with a gaussian kernel.
+
+### [convolutionTexture](./convolutionTexture)
+Texture-based implementation of a separable 2D convolution with a gaussian kernel. Used for performance comparison against convolutionSeparable.
+
+### [dct8x8](./dct8x8)
+This sample demonstrates how Discrete Cosine Transform (DCT) for blocks of 8 by 8 pixels can be performed using CUDA: a naive implementation by definition and a more traditional approach used in many libraries. As opposed to implementing DCT in a fragment shader, CUDA allows for an easier and more efficient implementation.
+
+### [EGLStream_CUDA_CrossGPU](./EGLStream_CUDA_CrossGPU)
+Demonstrates CUDA and EGL Streams interop, where consumer's EGL Stream is on one GPU and producer's on other and both consumer-producer are different processes.
+
+### [EGLStream_CUDA_Interop](./EGLStream_CUDA_Interop)
+Demonstrates data exchange between CUDA and EGL Streams.
+
+### [eigenvalues](./eigenvalues)
+The computation of all or a subset of all eigenvalues is an important problem in Linear Algebra, statistics, physics, and many other fields. This sample demonstrates a parallel implementation of a bisection algorithm for the computation of all eigenvalues of a tridiagonal symmetric matrix of arbitrary size with CUDA.
+
+### [FunctionPointers](./FunctionPointers)
+This sample illustrates how to use function pointers and implements the Sobel Edge Detection filter for 8-bit monochrome images.
+
+### [histogram](./histogram)
+This sample demonstrates efficient implementation of 64-bin and 256-bin histogram.
+
+### [imageDenoising](./imageDenoising)
+This sample demonstrates two adaptive image denoising techniques: KNN and NLM, based on computation of both geometric and color distance between texels. While both techniques are implemented in the DirectX SDK using shaders, massively speeded up variation of the latter technique, taking advantage of shared memory, is implemented in addition to DirectX counterparts.
+
+### [inlinePTX](./inlinePTX)
+A simple test application that demonstrates a new CUDA 4.0 ability to embed PTX in a CUDA kernel.
+
+### [inlinePTX_nvrtc](./inlinePTX_nvrtc)
+A simple test application that demonstrates a new CUDA 4.0 ability to embed PTX in a CUDA kernel.
+
+### [interval](./interval)
+Interval arithmetic operators example.  Uses various C++ features (templates and recursion).  The recursive mode requires Compute SM 2.0 capabilities.
+
+### [MC_EstimatePiInlineP](./MC_EstimatePiInlineP)
+This sample uses Monte Carlo simulation for Estimation of Pi (using inline PRNG).  This sample also uses the NVIDIA CURAND library.
+
+### [MC_EstimatePiInlineQ](./MC_EstimatePiInlineQ)
+This sample uses Monte Carlo simulation for Estimation of Pi (using inline QRNG).  This sample also uses the NVIDIA CURAND library.
+
+### [MC_EstimatePiP](./MC_EstimatePiP)
+This sample uses Monte Carlo simulation for Estimation of Pi (using batch PRNG).  This sample also uses the NVIDIA CURAND library.
+
+### [MC_EstimatePiQ](./MC_EstimatePiQ)
+This sample uses Monte Carlo simulation for Estimation of Pi (using batch QRNG).  This sample also uses the NVIDIA CURAND library.
+
+### [MC_SingleAsianOptionP](./MC_SingleAsianOptionP)
+This sample uses Monte Carlo to simulate Single Asian Options using the NVIDIA CURAND library.
+
+### [particles](./particles)
+This sample uses CUDA to simulate and visualize a large set of particles and their physical interaction.  Adding "-particles=<N>" to the command line will allow users to set # of particles for simulation.  This example implements a uniform grid data structure using either atomic operations or a fast radix sort from the Thrust library
+
+### [radixSortThrust](./radixSortThrust)
+This sample demonstrates a very fast and efficient parallel radix sort uses Thrust library. The included RadixSort class can sort either key-value pairs (with float or unsigned integer keys) or keys only.
+
+### [reduction](./reduction)
+A parallel sum reduction that computes the sum of a large arrays of values. This sample demonstrates several important optimization strategies for Data-Parallel Algorithms like reduction using shared memory, __shfl_down_sync, __reduce_add_sync and cooperative_groups reduce.
+
+### [reductionMultiBlockCG](./reductionMultiBlockCG)
+This sample demonstrates single pass reduction using Multi Block Cooperative Groups.  This sample requires devices with compute capability 6.0 or higher having compute preemption.
+
+### [scalarProd](./scalarProd)
+This sample calculates scalar products of a given set of input vector pairs.
+
+### [scan](./scan)
+This example demonstrates an efficient CUDA implementation of parallel prefix sum, also known as "scan".  Given an array of numbers, scan computes a new array in which each element is the sum of all the elements before it in the input array.
+
+### [segmentationTreeThrust](./segmentationTreeThrust)
+This sample demonstrates an approach to the image segmentation trees construction.  This method is based on Boruvka's MST algorithm.
+
+### [shfl_scan](./shfl_scan)
+This example demonstrates how to use the shuffle intrinsic __shfl_up_sync to perform a scan operation across a thread block.
+
+### [sortingNetworks](./sortingNetworks)
+This sample implements bitonic sort and odd-even merge sort (also known as Batcher's sort), algorithms belonging to the class of sorting networks. While generally subefficient, for large sequences compared to algorithms with better asymptotic algorithmic complexity (i.e. merge sort or radix sort), this may be the preferred algorithms of choice for sorting batches of short-sized to mid-sized (key, value) array pairs. Refer to an excellent tutorial by H. W. Lang http://www.iti.fh-flensburg.de/lang/algorithmen/sortieren/networks/indexen.htm
+
+### [streamOrderedAllocation](./streamOrderedAllocation)
+This sample demonstrates stream ordered memory allocation on a GPU using cudaMallocAsync and cudaMemPool family of APIs.
+
+### [streamOrderedAllocationIPC](./streamOrderedAllocationIPC)
+This sample demonstrates IPC pools of stream ordered memory allocated using cudaMallocAsync and cudaMemPool family of APIs.
+
+### [streamOrderedAllocationP2P](./streamOrderedAllocationP2P)
+This sample demonstrates peer-to-peer access of stream ordered memory allocated using cudaMallocAsync and cudaMemPool family of APIs.
+
+### [threadFenceReduction](./threadFenceReduction)
+This sample shows how to perform a reduction operation on an array of values using the thread Fence intrinsic to produce a single value in a single kernel (as opposed to two or more kernel calls as shown in the "reduction" CUDA Sample).  Single-pass reduction requires global atomic instructions (Compute Capability 2.0 or later) and the _threadfence() intrinsic (CUDA 2.2 or later).
+
+### [threadMigration](./threadMigration)
+Simple program illustrating how to the CUDA Context Management API and uses the new CUDA 4.0 parameter passing and CUDA launch API.  CUDA contexts can be created separately and attached independently to different threads.

cpp/2_Concepts_and_Techniques/boxFilter/.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/2_Concepts_and_Techniques/boxFilter/.vscode/extensions.json

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

cpp/2_Concepts_and_Techniques/boxFilter/CMakeLists.txt

@@ -0,0 +1,96 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../../cmake/Modules")
+
+project(boxFilter 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)
+
+if(WIN32)
+    set(PC_GLUT_INCLUDE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/../../../Common")
+    set(PC_GLUT_LIBRARY_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/../../../Common/lib/x64")
+    # The GLEW library built on Windows on Arm system is named as glew32.lib/glew32.dll by default.
+    if(EXISTS "${PC_GLUT_LIBRARY_DIRS}/glew32.lib")
+        set(GLEW_LIB_NAME "glew32")
+    else()
+        set(GLEW_LIB_NAME "glew64")
+    endif()
+endif()
+
+find_package(OpenGL)
+find_package(GLUT)
+
+# Source file
+if(${OpenGL_FOUND})
+    if (${GLUT_FOUND})
+        # Add target for boxFilter
+        add_executable(boxFilter boxFilter.cpp boxFilter_cpu.cpp boxFilter_kernel.cu)
+
+        target_compile_options(boxFilter PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+        target_compile_features(boxFilter PRIVATE cxx_std_17 cuda_std_17)
+
+        set_target_properties(boxFilter PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
+
+        target_include_directories(boxFilter PUBLIC
+            ${OPENGL_INCLUDE_DIR}
+            ${CUDAToolkit_INCLUDE_DIRS}
+            ${GLUT_INCLUDE_DIRS}
+        )
+
+        target_link_libraries(boxFilter
+            ${OPENGL_LIBRARIES}
+            ${GLUT_LIBRARIES}
+        )
+
+        # Copy data files to output directory
+        add_custom_command(TARGET boxFilter POST_BUILD
+            COMMAND ${CMAKE_COMMAND} -E copy_directory
+            ${CMAKE_CURRENT_SOURCE_DIR}/data
+            ${CMAKE_CURRENT_BINARY_DIR}/data
+        )
+
+        if(WIN32)
+            target_link_libraries(boxFilter
+                ${PC_GLUT_LIBRARY_DIRS}/freeglut.lib
+                ${PC_GLUT_LIBRARY_DIRS}/${GLEW_LIB_NAME}.lib
+            )
+
+            add_custom_command(TARGET boxFilter
+                POST_BUILD
+                COMMAND ${CMAKE_COMMAND} -E copy
+                ${CMAKE_CURRENT_SOURCE_DIR}/../../../bin/win64/$<CONFIGURATION>/freeglut.dll
+                ${CMAKE_CURRENT_BINARY_DIR}/$<CONFIGURATION>
+            )
+
+            add_custom_command(TARGET boxFilter
+                POST_BUILD
+                COMMAND ${CMAKE_COMMAND} -E copy
+                ${CMAKE_CURRENT_SOURCE_DIR}/../../../bin/win64/$<CONFIGURATION>/${GLEW_LIB_NAME}.dll
+                ${CMAKE_CURRENT_BINARY_DIR}/$<CONFIGURATION>
+            )
+        endif()
+
+    else()
+        message(STATUS "GLUT not found - will not build sample 'boxFilter'")
+    endif()
+else()
+    message(STATUS "OpenGL not found - will not build sample 'boxFilter'")
+endif()
+
+# Include installation configuration
+include(${CMAKE_CURRENT_SOURCE_DIR}/../../../cmake/InstallSamples.cmake)
+setup_samples_install()

cpp/2_Concepts_and_Techniques/boxFilter/README.md

@@ -0,0 +1,36 @@
+# boxFilter - Box Filter
+
+## Description
+
+Fast image box filter using CUDA with OpenGL rendering.
+
+## Key Concepts
+
+Graphics Interop, Image Processing
+
+## 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)
+cudaGraphicsUnmapResources, cudaCreateChannelDesc, cudaMallocArray, cudaFreeArray, cudaFree, cudaGetErrorString, cudaMemcpy, cudaGraphicsResourceGetMappedPointer, cudaGraphicsMapResources, cudaDestroyTextureObject, cudaDeviceSynchronize, cudaCreateTextureObject, cudaGraphicsUnregisterResource, cudaMalloc, cudaGraphicsGLRegisterBuffer
+
+## Dependencies needed to build/run
+[X11](../../../README.md#x11), [OpenGL](../../../README.md#opengl), [Freeglut](../../../README.md#freeglut), [GLEW](../../../README.md#glew)
+
+## 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/2_Concepts_and_Techniques/boxFilter/boxFilter.cpp

@@ -0,0 +1,629 @@
+/* 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.
+ */
+
+/*
+  Image box filtering example
+
+  This sample uses CUDA to perform a simple box filter on an image
+  and uses OpenGL to display the results.
+
+  It processes rows and columns of the image in parallel.
+
+  The box filter is implemented such that it has a constant cost,
+  regardless of the filter width.
+
+  Press '=' to increment the filter radius, '-' to decrease it
+
+  Version 1.1 - modified to process 8-bit RGBA images
+*/
+
+// OpenGL Graphics includes
+#include <helper_gl.h>
+#if defined(__APPLE__) || defined(__MACOSX)
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#include <GLUT/glut.h>
+#ifndef glutCloseFunc
+#define glutCloseFunc glutWMCloseFunc
+#endif
+#else
+#include <GL/freeglut.h>
+#endif
+
+// CUDA utilities and system includes
+#include <cuda_gl_interop.h>
+#include <cuda_runtime.h>
+
+// Helper functions
+#include <helper_cuda.h>      // CUDA device initialization helper functions
+#include <helper_functions.h> // CUDA SDK Helper functions
+
+#define MAX_EPSILON_ERROR 5.0f
+#define REFRESH_DELAY     10 // ms
+
+const static char *sSDKsample = "CUDA Iterative Box Filter";
+
+// Define the files that are to be save and the reference images for validation
+const char *sOriginal[] = {"teapot1024_14.ppm", "teapot1024_22.ppm", NULL};
+
+const char *sReference[] = {"ref_14.ppm", "ref_22.ppm", NULL};
+
+const char   *image_filename = "teapot1024.ppm";
+int           iterations     = 1;
+int           filter_radius  = 14;
+int           nthreads       = 64;
+unsigned int  width, height;
+unsigned int *h_img  = NULL;
+unsigned int *d_temp = NULL;
+
+GLuint                       pbo;               // OpenGL pixel buffer object
+struct cudaGraphicsResource *cuda_pbo_resource; // handles OpenGL-CUDA exchange
+GLuint                       texid;             // Texture
+GLuint                       shader;
+
+StopWatchInterface *timer = NULL, *kernel_timer = NULL;
+
+// Auto-Verification Code
+int          fpsCount       = 0; // FPS count for averaging
+int          fpsLimit       = 8; // FPS limit for sampling
+int          g_Index        = 0;
+int          g_nFilterSign  = 1;
+float        avgFPS         = 0.0f;
+unsigned int frameCount     = 0;
+unsigned int g_TotalErrors  = 0;
+bool         g_bInteractive = false;
+
+int   *pArgc = NULL;
+char **pArgv = NULL;
+
+extern "C" int  runSingleTest(char *ref_file, char *exec_path);
+extern "C" int  runBenchmark();
+extern "C" void loadImageData(int argc, char **argv);
+extern "C" void computeGold(float *id, float *od, int w, int h, int n);
+
+// These are CUDA functions to handle allocation and launching the kernels
+extern "C" void   initTexture(int width, int height, void *pImage, bool useRGBA);
+extern "C" void   freeTextures();
+extern "C" double boxFilter(float              *d_temp,
+                            float              *d_dest,
+                            int                 width,
+                            int                 height,
+                            int                 radius,
+                            int                 iterations,
+                            int                 nthreads,
+                            StopWatchInterface *timer);
+
+extern "C" double boxFilterRGBA(unsigned int       *d_temp,
+                                unsigned int       *d_dest,
+                                int                 width,
+                                int                 height,
+                                int                 radius,
+                                int                 iterations,
+                                int                 nthreads,
+                                StopWatchInterface *timer);
+
+// This varies the filter radius, so we can see automatic animation
+void varySigma()
+{
+    filter_radius += g_nFilterSign;
+
+    if (filter_radius > 64) {
+        filter_radius = 64; // clamp to 64 and then negate sign
+        g_nFilterSign = -1;
+    }
+    else if (filter_radius < 0) {
+        filter_radius = 0;
+        g_nFilterSign = 1;
+    }
+}
+
+// Calculate the Frames per second and print in the title bar
+void computeFPS()
+{
+    frameCount++;
+    fpsCount++;
+
+    if (fpsCount == fpsLimit) {
+        avgFPS   = 1.0f / (sdkGetAverageTimerValue(&timer) / 1000.0f);
+        fpsCount = 0;
+        fpsLimit = (int)MAX(avgFPS, 1.0f);
+        sdkResetTimer(&timer);
+    }
+
+    char fps[256];
+    sprintf(fps,
+            "CUDA Rolling Box Filter <Animation=%s> (radius=%d, passes=%d): "
+            "%3.1f fps",
+            (!g_bInteractive ? "ON" : "OFF"),
+            filter_radius,
+            iterations,
+            avgFPS);
+    glutSetWindowTitle(fps);
+
+    if (!g_bInteractive) {
+        varySigma();
+    }
+}
+
+// display results using OpenGL
+void display()
+{
+    sdkStartTimer(&timer);
+
+    // execute filter, writing results to pbo
+    unsigned int *d_result;
+
+    checkCudaErrors(cudaGraphicsMapResources(1, &cuda_pbo_resource, 0));
+    size_t num_bytes;
+    checkCudaErrors(cudaGraphicsResourceGetMappedPointer((void **)&d_result, &num_bytes, cuda_pbo_resource));
+    boxFilterRGBA(d_temp, d_result, width, height, filter_radius, iterations, nthreads, kernel_timer);
+
+    checkCudaErrors(cudaGraphicsUnmapResources(1, &cuda_pbo_resource, 0));
+
+    // OpenGL display code path
+    {
+        glClear(GL_COLOR_BUFFER_BIT);
+
+        // load texture from pbo
+        glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, pbo);
+        glBindTexture(GL_TEXTURE_2D, texid);
+        glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, 0);
+        glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
+
+        // fragment program is required to display floating point texture
+        glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, shader);
+        glEnable(GL_FRAGMENT_PROGRAM_ARB);
+        glDisable(GL_DEPTH_TEST);
+
+        glBegin(GL_QUADS);
+        {
+            glTexCoord2f(0.0f, 0.0f);
+            glVertex2f(0.0f, 0.0f);
+            glTexCoord2f(1.0f, 0.0f);
+            glVertex2f(1.0f, 0.0f);
+            glTexCoord2f(1.0f, 1.0f);
+            glVertex2f(1.0f, 1.0f);
+            glTexCoord2f(0.0f, 1.0f);
+            glVertex2f(0.0f, 1.0f);
+        }
+        glEnd();
+        glBindTexture(GL_TEXTURE_2D, 0);
+        glDisable(GL_FRAGMENT_PROGRAM_ARB);
+    }
+
+    glutSwapBuffers();
+    glutReportErrors();
+
+    sdkStopTimer(&timer);
+
+    computeFPS();
+}
+
+// Keyboard callback function for OpenGL (GLUT)
+void keyboard(unsigned char key, int /*x*/, int /*y*/)
+{
+    switch (key) {
+    case 27:
+#if defined(__APPLE__) || defined(MACOSX)
+        exit(EXIT_SUCCESS);
+#else
+        glutDestroyWindow(glutGetWindow());
+        return;
+#endif
+        break;
+
+    case 'a':
+    case 'A':
+        g_bInteractive = !g_bInteractive;
+        printf("> Animation is %s\n", !g_bInteractive ? "ON" : "OFF");
+        break;
+
+    case '=':
+    case '+':
+        if (filter_radius < (int)width - 1 && filter_radius < (int)height - 1) {
+            filter_radius++;
+        }
+
+        break;
+
+    case '-':
+        if (filter_radius > 1) {
+            filter_radius--;
+        }
+
+        break;
+
+    case ']':
+        iterations++;
+        break;
+
+    case '[':
+        if (iterations > 1) {
+            iterations--;
+        }
+
+        break;
+
+    default:
+        break;
+    }
+
+    printf("radius = %d, iterations = %d\n", filter_radius, iterations);
+}
+
+// Timer Event so we can refresh the display
+void timerEvent(int value)
+{
+    if (glutGetWindow()) {
+        glutPostRedisplay();
+        glutTimerFunc(REFRESH_DELAY, timerEvent, 0);
+    }
+}
+
+// Resizing the window
+void reshape(int x, int y)
+{
+    glViewport(0, 0, x, y);
+
+    glMatrixMode(GL_MODELVIEW);
+    glLoadIdentity();
+
+    glMatrixMode(GL_PROJECTION);
+    glLoadIdentity();
+    glOrtho(0.0, 1.0, 0.0, 1.0, 0.0, 1.0);
+}
+
+void initCuda(bool useRGBA)
+{
+    checkCudaErrors(cudaMalloc((void **)&d_temp, (width * height * sizeof(unsigned int))));
+
+    // Refer to boxFilter_kernel.cu for implementation
+    initTexture(width, height, h_img, useRGBA);
+
+    sdkCreateTimer(&timer);
+    sdkCreateTimer(&kernel_timer);
+}
+
+void cleanup()
+{
+    sdkDeleteTimer(&timer);
+    sdkDeleteTimer(&kernel_timer);
+
+    if (h_img) {
+        free(h_img);
+        h_img = NULL;
+    }
+
+    if (d_temp) {
+        cudaFree(d_temp);
+        d_temp = NULL;
+    }
+
+    // Refer to boxFilter_kernel.cu for implementation
+    freeTextures();
+
+    cudaGraphicsUnregisterResource(cuda_pbo_resource);
+
+    glDeleteBuffers(1, &pbo);
+    glDeleteTextures(1, &texid);
+    glDeleteProgramsARB(1, &shader);
+}
+
+// shader for displaying floating-point texture
+static const char *shader_code = "!!ARBfp1.0\n"
+                                 "TEX result.color, fragment.texcoord, texture[0], 2D; \n"
+                                 "END";
+
+GLuint compileASMShader(GLenum program_type, const char *code)
+{
+    GLuint program_id;
+    glGenProgramsARB(1, &program_id);
+    glBindProgramARB(program_type, program_id);
+    glProgramStringARB(program_type, GL_PROGRAM_FORMAT_ASCII_ARB, (GLsizei)strlen(code), (GLubyte *)code);
+
+    GLint error_pos;
+    glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &error_pos);
+
+    if (error_pos != -1) {
+        const GLubyte *error_string;
+        error_string = glGetString(GL_PROGRAM_ERROR_STRING_ARB);
+        printf("Program error at position: %d\n%s\n", (int)error_pos, error_string);
+        return 0;
+    }
+
+    return program_id;
+}
+
+// This is where we create the OpenGL PBOs, FBOs, and texture resources
+void initGLResources()
+{
+    // create pixel buffer object
+    glGenBuffers(1, &pbo);
+    glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, pbo);
+    glBufferData(GL_PIXEL_UNPACK_BUFFER_ARB, width * height * sizeof(GLubyte) * 4, h_img, GL_STREAM_DRAW_ARB);
+
+    glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
+
+    checkCudaErrors(cudaGraphicsGLRegisterBuffer(&cuda_pbo_resource, pbo, cudaGraphicsMapFlagsWriteDiscard));
+
+    // create texture for display
+    glGenTextures(1, &texid);
+    glBindTexture(GL_TEXTURE_2D, texid);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    glBindTexture(GL_TEXTURE_2D, 0);
+
+    // load shader program
+    shader = compileASMShader(GL_FRAGMENT_PROGRAM_ARB, shader_code);
+}
+
+void initGL(int *argc, char **argv)
+{
+    // initialize GLUT
+    glutInit(argc, argv);
+    glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
+    glutInitWindowSize(768, 768);
+    glutCreateWindow("CUDA Rolling Box Filter");
+    glutDisplayFunc(display);
+
+    glutKeyboardFunc(keyboard);
+    glutReshapeFunc(reshape);
+    glutTimerFunc(REFRESH_DELAY, timerEvent, 0);
+
+    if (!isGLVersionSupported(2, 0)
+        || !areGLExtensionsSupported("GL_ARB_vertex_buffer_object GL_ARB_pixel_buffer_object")) {
+        printf("Error: failed to get minimal extensions for demo\n");
+        printf("This sample requires:\n");
+        printf("  OpenGL version 2.0\n");
+        printf("  GL_ARB_vertex_buffer_object\n");
+        printf("  GL_ARB_pixel_buffer_object\n");
+        exit(EXIT_FAILURE);
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//! Run a simple benchmark test for CUDA
+////////////////////////////////////////////////////////////////////////////////
+int runBenchmark()
+{
+    printf("[runBenchmark]: [%s]\n", sSDKsample);
+
+    initCuda(true);
+
+    unsigned int *d_result;
+    checkCudaErrors(cudaMalloc((void **)&d_result, width * height * sizeof(unsigned int)));
+
+    // warm-up
+    boxFilterRGBA(d_temp, d_temp, width, height, filter_radius, iterations, nthreads, kernel_timer);
+    checkCudaErrors(cudaDeviceSynchronize());
+
+    sdkStartTimer(&kernel_timer);
+    // Start round-trip timer and process iCycles loops on the GPU
+    iterations                = 1; // standard 1-pass filtering
+    const int iCycles         = 150;
+    double    dProcessingTime = 0.0;
+    printf("\nRunning BoxFilterGPU for %d cycles...\n\n", iCycles);
+
+    for (int i = 0; i < iCycles; i++) {
+        dProcessingTime +=
+            boxFilterRGBA(d_temp, d_temp, width, height, filter_radius, iterations, nthreads, kernel_timer);
+    }
+
+    // check if kernel execution generated an error and sync host
+    getLastCudaError("Error: boxFilterRGBA Kernel execution FAILED");
+    checkCudaErrors(cudaDeviceSynchronize());
+    sdkStopTimer(&kernel_timer);
+
+    // Get average computation time
+    dProcessingTime /= (double)iCycles;
+
+    // log testname, throughput, timing and config info to sample and master logs
+    printf("boxFilter-texture, Throughput = %.4f M RGBA Pixels/s, Time = %.5f s, "
+           "Size = %u RGBA Pixels, NumDevsUsed = %u, Workgroup = %u\n",
+           (1.0e-6 * width * height) / dProcessingTime,
+           dProcessingTime,
+           (width * height),
+           1,
+           nthreads);
+    printf("\n");
+
+    return 0;
+}
+
+// This test specifies a single test (where you specify radius and/or
+// iterations)
+int runSingleTest(char *ref_file, char *exec_path)
+{
+    int  nTotalErrors = 0;
+    char dump_file[256];
+
+    printf("[runSingleTest]: [%s]\n", sSDKsample);
+
+    initCuda(true);
+
+    unsigned int *d_result;
+    unsigned int *h_result = (unsigned int *)malloc(width * height * sizeof(unsigned int));
+    checkCudaErrors(cudaMalloc((void **)&d_result, width * height * sizeof(unsigned int)));
+
+    // run the sample radius
+    {
+        printf("%s (radius=%d) (passes=%d) ", sSDKsample, filter_radius, iterations);
+        boxFilterRGBA(d_temp, d_result, width, height, filter_radius, iterations, nthreads, kernel_timer);
+
+        // check if kernel execution generated an error
+        getLastCudaError("Error: boxFilterRGBA Kernel execution FAILED");
+        checkCudaErrors(cudaDeviceSynchronize());
+
+        // readback the results to system memory
+        cudaMemcpy((unsigned char *)h_result,
+                   (unsigned char *)d_result,
+                   width * height * sizeof(unsigned int),
+                   cudaMemcpyDeviceToHost);
+
+        sprintf(dump_file, "teapot1024_%02d.ppm", filter_radius);
+
+        sdkSavePPM4ub((const char *)dump_file, (unsigned char *)h_result, width, height);
+
+        if (!sdkComparePPM(dump_file, sdkFindFilePath(ref_file, exec_path), MAX_EPSILON_ERROR, 0.15f, false)) {
+            printf("Image is Different ");
+            nTotalErrors++;
+        }
+        else {
+            printf("Image is Matching ");
+        }
+
+        printf(" <%s>\n", ref_file);
+    }
+    printf("\n");
+
+    free(h_result);
+    checkCudaErrors(cudaFree(d_result));
+
+    return nTotalErrors;
+}
+
+void loadImageData(int argc, char **argv)
+{
+    // load image (needed so we can get the width and height before we create the
+    // window
+    char *image_path = NULL;
+
+    if (argc >= 1) {
+        image_path = sdkFindFilePath(image_filename, argv[0]);
+    }
+
+    if (image_path == 0) {
+        printf("Error finding image file '%s'\n", image_filename);
+        exit(EXIT_FAILURE);
+    }
+
+    sdkLoadPPM4(image_path, (unsigned char **)&h_img, &width, &height);
+
+    if (!h_img) {
+        printf("Error opening file '%s'\n", image_path);
+        exit(EXIT_FAILURE);
+    }
+
+    printf("Loaded '%s', %d x %d pixels\n", image_path, width, height);
+}
+
+void printHelp()
+{
+    printf("boxFilter usage\n");
+    printf("    -threads=n (specify the # of of threads to use)\n");
+    printf("    -radius=n  (specify the filter radius n to use)\n");
+    printf("    -passes=n  (specify the number of passes n to use)\n");
+    printf("    -file=name (specify reference file for comparison)\n");
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Program main
+////////////////////////////////////////////////////////////////////////////////
+int main(int argc, char **argv)
+{
+    int   devID    = 0;
+    char *ref_file = NULL;
+
+#if defined(__linux__)
+    setenv("DISPLAY", ":0", 0);
+#endif
+
+    pArgc = &argc;
+    pArgv = argv;
+
+    // start logs
+    printf("%s Starting...\n\n", argv[0]);
+
+    if (checkCmdLineFlag(argc, (const char **)argv, "help")) {
+        printHelp();
+        exit(EXIT_SUCCESS);
+    }
+
+    // use command-line specified CUDA device, otherwise use device with highest
+    // Gflops/s
+    if (argc > 1) {
+        if (checkCmdLineFlag(argc, (const char **)argv, "threads")) {
+            nthreads = getCmdLineArgumentInt(argc, (const char **)argv, "threads");
+        }
+
+        if (checkCmdLineFlag(argc, (const char **)argv, "radius")) {
+            filter_radius = getCmdLineArgumentInt(argc, (const char **)argv, "radius");
+        }
+
+        if (checkCmdLineFlag(argc, (const char **)argv, "passes")) {
+            iterations = getCmdLineArgumentInt(argc, (const char **)argv, "passes");
+        }
+
+        if (checkCmdLineFlag(argc, (const char **)argv, "file")) {
+            getCmdLineArgumentString(argc, (const char **)argv, "file", (char **)&ref_file);
+        }
+    }
+
+    // load image to process
+    loadImageData(argc, argv);
+    devID = findCudaDevice(argc, (const char **)argv);
+
+    if (checkCmdLineFlag(argc, (const char **)argv, "benchmark")) {
+        // This is a separate mode of the sample, where we are benchmark the kernels
+        // for performance
+        // Running CUDA kernels (boxfilter) in Benchmarking mode
+        g_TotalErrors += runBenchmark();
+        exit(g_TotalErrors == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
+    }
+    else if (checkCmdLineFlag(argc, (const char **)argv, "radius")
+             || checkCmdLineFlag(argc, (const char **)argv, "passes")) {
+        // This overrides the default mode.  Users can specify the radius used by
+        // the filter kernel
+        g_TotalErrors += runSingleTest(ref_file, argv[0]);
+        exit(g_TotalErrors == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
+    }
+    else {
+        // Default mode running with OpenGL visualization and in automatic mode
+        // the output automatically changes animation
+        printf("\n");
+
+        initGL(&argc, argv);
+
+        initCuda(true);
+        initGLResources();
+
+// sets the callback function so it will call cleanup upon exit
+#if defined(__APPLE__) || defined(MACOSX)
+        atexit(cleanup);
+#else
+        glutCloseFunc(cleanup);
+#endif
+
+        printf("Running Standard Demonstration with GLUT loop...\n\n");
+        printf("Press '+' and '-' to change filter width\n"
+               "Press ']' and '[' to change number of iterations\n"
+               "Press 'a' or  'A' to change animation ON/OFF\n\n");
+
+        // Main OpenGL loop that will run visualization for every vsync
+        glutMainLoop();
+    }
+}

cpp/2_Concepts_and_Techniques/boxFilter/boxFilter_cpu.cpp

@@ -0,0 +1,126 @@
+/* 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.
+ */
+
+////////////////////////////////////////////////////////////////////////////////
+// export C interface
+extern "C" void computeGold(float *id, float *od, int w, int h, int r);
+
+// CPU implementation
+void hboxfilter_x(float *id, float *od, int w, int h, int r)
+{
+    float scale = 1.0f / (2 * r + 1);
+
+    for (int y = 0; y < h; y++) {
+        float t;
+        // do left edge
+        t = id[y * w] * r;
+
+        for (int x = 0; x < r + 1; x++) {
+            t += id[y * w + x];
+        }
+
+        od[y * w] = t * scale;
+
+        for (int x = 1; x < r + 1; x++) {
+            int c = y * w + x;
+            t += id[c + r];
+            t -= id[y * w];
+            od[c] = t * scale;
+        }
+
+        // main loop
+        for (int x = r + 1; x < w - r; x++) {
+            int c = y * w + x;
+            t += id[c + r];
+            t -= id[c - r - 1];
+            od[c] = t * scale;
+        }
+
+        // do right edge
+        for (int x = w - r; x < w; x++) {
+            int c = y * w + x;
+            t += id[(y * w) + w - 1];
+            t -= id[c - r - 1];
+            od[c] = t * scale;
+        }
+    }
+}
+
+void hboxfilter_y(float *id, float *od, int w, int h, int r)
+{
+    float scale = 1.0f / (2 * r + 1);
+
+    for (int x = 0; x < w; x++) {
+        float t;
+        // do left edge
+        t = id[x] * r;
+
+        for (int y = 0; y < r + 1; y++) {
+            t += id[y * w + x];
+        }
+
+        od[x] = t * scale;
+
+        for (int y = 1; y < r + 1; y++) {
+            int c = y * w + x;
+            t += id[c + r * w];
+            t -= id[x];
+            od[c] = t * scale;
+        }
+
+        // main loop
+        for (int y = r + 1; y < h - r; y++) {
+            int c = y * w + x;
+            t += id[c + r * w];
+            t -= id[c - (r * w) - w];
+            od[c] = t * scale;
+        }
+
+        // do right edge
+        for (int y = h - r; y < h; y++) {
+            int c = y * w + x;
+            t += id[(h - 1) * w + x];
+            t -= id[c - (r * w) - w];
+            od[c] = t * scale;
+        }
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//! Compute reference data set
+//! @param image      pointer to input data
+//! @param temp       pointer to temporary store
+//! @param w          width of image
+//! @param h          height of image
+//! @param r          radius of filter
+////////////////////////////////////////////////////////////////////////////////
+
+void computeGold(float *image, float *temp, int w, int h, int r)
+{
+    hboxfilter_x(image, temp, w, h, r);
+    hboxfilter_y(temp, image, w, h, r);
+}

cpp/2_Concepts_and_Techniques/boxFilter/boxFilter_kernel.cu

@@ -0,0 +1,506 @@
+/* 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.
+ */
+
+#ifndef _BOXFILTER_KERNEL_CH_
+#define _BOXFILTER_KERNEL_CH_
+
+#include <helper_functions.h>
+#include <helper_math.h>
+
+cudaTextureObject_t tex;
+cudaTextureObject_t texTempArray;
+cudaTextureObject_t rgbaTex;
+cudaTextureObject_t rgbaTexTempArray;
+cudaArray          *d_array, *d_tempArray;
+
+////////////////////////////////////////////////////////////////////////////////
+// These are CUDA Helper functions
+
+// This will output the proper CUDA error strings in the event that a CUDA host
+// call returns an error
+#define checkCudaErrors(err) __checkCudaErrors(err, __FILE__, __LINE__)
+
+inline void __checkCudaErrors(cudaError err, const char *file, const int line)
+{
+    if (cudaSuccess != err) {
+        fprintf(stderr, "%s(%i) : CUDA Runtime API error %d: %s.\n", file, line, (int)err, cudaGetErrorString(err));
+        exit(EXIT_FAILURE);
+    }
+}
+
+/*
+  Perform a fast box filter using the sliding window method.
+
+  As the kernel moves from left to right, we add in the contribution of the
+  new sample on the right, and subtract the value of the exiting sample on the
+  left. This only requires 2 adds and a mul per output value, independent of the
+  filter radius. The box filter is separable, so to perform a 2D box filter we
+  perform the filter in the x direction, followed by the same filter in the y
+  direction. Applying multiple iterations of the box filter converges towards a
+  Gaussian blur. Using CUDA, rows or columns of the image are processed in
+  parallel. This version duplicates edge pixels.
+
+  Note that the x (row) pass suffers from uncoalesced global memory reads,
+  since each thread is reading from a different row. For this reason it is
+  better to use texture lookups for the x pass.
+  The y (column) pass is perfectly coalesced.
+
+  Parameters
+  id - pointer to input data in global memory
+  od - pointer to output data in global memory
+  w  - image width
+  h  - image height
+  r  - filter radius
+
+  e.g. for r = 2, w = 8:
+
+  0 1 2 3 4 5 6 7
+  x - -
+  - x - -
+  - - x - -
+    - - x - -
+      - - x - -
+        - - x - -
+          - - x -
+            - - x
+*/
+
+// process row
+__device__ void d_boxfilter_x(float *id, float *od, int w, int h, int r)
+{
+    float scale = 1.0f / (float)((r << 1) + 1);
+
+    float t;
+    // do left edge
+    t = id[0] * r;
+
+    for (int x = 0; x < (r + 1); x++) {
+        t += id[x];
+    }
+
+    od[0] = t * scale;
+
+    for (int x = 1; x < (r + 1); x++) {
+        t += id[x + r];
+        t -= id[0];
+        od[x] = t * scale;
+    }
+
+    // main loop
+    for (int x = (r + 1); x < w - r; x++) {
+        t += id[x + r];
+        t -= id[x - r - 1];
+        od[x] = t * scale;
+    }
+
+    // do right edge
+    for (int x = w - r; x < w; x++) {
+        t += id[w - 1];
+        t -= id[x - r - 1];
+        od[x] = t * scale;
+    }
+}
+
+// process column
+__device__ void d_boxfilter_y(float *id, float *od, int w, int h, int r)
+{
+    float scale = 1.0f / (float)((r << 1) + 1);
+
+    float t;
+    // do left edge
+    t = id[0] * r;
+
+    for (int y = 0; y < (r + 1); y++) {
+        t += id[y * w];
+    }
+
+    od[0] = t * scale;
+
+    for (int y = 1; y < (r + 1); y++) {
+        t += id[(y + r) * w];
+        t -= id[0];
+        od[y * w] = t * scale;
+    }
+
+    // main loop
+    for (int y = (r + 1); y < (h - r); y++) {
+        t += id[(y + r) * w];
+        t -= id[((y - r) * w) - w];
+        od[y * w] = t * scale;
+    }
+
+    // do right edge
+    for (int y = h - r; y < h; y++) {
+        t += id[(h - 1) * w];
+        t -= id[((y - r) * w) - w];
+        od[y * w] = t * scale;
+    }
+}
+
+__global__ void d_boxfilter_x_global(float *id, float *od, int w, int h, int r)
+{
+    unsigned int y = blockIdx.x * blockDim.x + threadIdx.x;
+    d_boxfilter_x(&id[y * w], &od[y * w], w, h, r);
+}
+
+__global__ void d_boxfilter_y_global(float *id, float *od, int w, int h, int r)
+{
+    unsigned int x = blockIdx.x * blockDim.x + threadIdx.x;
+    d_boxfilter_y(&id[x], &od[x], w, h, r);
+}
+
+// texture version
+// texture fetches automatically clamp to edge of image
+__global__ void d_boxfilter_x_tex(float *od, int w, int h, int r, cudaTextureObject_t tex)
+{
+    float        scale = 1.0f / (float)((r << 1) + 1);
+    unsigned int y     = blockIdx.x * blockDim.x + threadIdx.x;
+
+    float t = 0.0f;
+
+    for (int x = -r; x <= r; x++) {
+        t += tex2D<float>(tex, x, y);
+    }
+
+    od[y * w] = t * scale;
+
+    for (int x = 1; x < w; x++) {
+        t += tex2D<float>(tex, x + r, y);
+        t -= tex2D<float>(tex, x - r - 1, y);
+        od[y * w + x] = t * scale;
+    }
+}
+
+__global__ void d_boxfilter_y_tex(float *od, int w, int h, int r, cudaTextureObject_t tex)
+{
+    float        scale = 1.0f / (float)((r << 1) + 1);
+    unsigned int x     = blockIdx.x * blockDim.x + threadIdx.x;
+
+    float t = 0.0f;
+
+    for (int y = -r; y <= r; y++) {
+        t += tex2D<float>(tex, x, y);
+    }
+
+    od[x] = t * scale;
+
+    for (int y = 1; y < h; y++) {
+        t += tex2D<float>(tex, x, y + r);
+        t -= tex2D<float>(tex, x, y - r - 1);
+        od[y * w + x] = t * scale;
+    }
+}
+
+// RGBA version
+// reads from 32-bit unsigned int array holding 8-bit RGBA
+
+// convert floating point rgba color to 32-bit integer
+__device__ unsigned int rgbaFloatToInt(float4 rgba)
+{
+    rgba.x = __saturatef(rgba.x); // clamp to [0.0, 1.0]
+    rgba.y = __saturatef(rgba.y);
+    rgba.z = __saturatef(rgba.z);
+    rgba.w = __saturatef(rgba.w);
+    return ((unsigned int)(rgba.w * 255.0f) << 24) | ((unsigned int)(rgba.z * 255.0f) << 16)
+         | ((unsigned int)(rgba.y * 255.0f) << 8) | ((unsigned int)(rgba.x * 255.0f));
+}
+
+__device__ float4 rgbaIntToFloat(unsigned int c)
+{
+    float4 rgba;
+    rgba.x = (c & 0xff) * 0.003921568627f;         //  /255.0f;
+    rgba.y = ((c >> 8) & 0xff) * 0.003921568627f;  //  /255.0f;
+    rgba.z = ((c >> 16) & 0xff) * 0.003921568627f; //  /255.0f;
+    rgba.w = ((c >> 24) & 0xff) * 0.003921568627f; //  /255.0f;
+    return rgba;
+}
+
+// row pass using texture lookups
+__global__ void d_boxfilter_rgba_x(unsigned int *od, int w, int h, int r, cudaTextureObject_t rgbaTex)
+{
+    float        scale = 1.0f / (float)((r << 1) + 1);
+    unsigned int y     = blockIdx.x * blockDim.x + threadIdx.x;
+
+    // as long as address is always less than height, we do work
+    if (y < h) {
+        float4 t = make_float4(0.0f);
+
+        for (int x = -r; x <= r; x++) {
+            t += tex2D<float4>(rgbaTex, x, y);
+        }
+
+        od[y * w] = rgbaFloatToInt(t * scale);
+
+        for (int x = 1; x < w; x++) {
+            t += tex2D<float4>(rgbaTex, x + r, y);
+            t -= tex2D<float4>(rgbaTex, x - r - 1, y);
+            od[y * w + x] = rgbaFloatToInt(t * scale);
+        }
+    }
+}
+
+// column pass using coalesced global memory reads
+__global__ void d_boxfilter_rgba_y(unsigned int *id, unsigned int *od, int w, int h, int r)
+{
+    unsigned int x = blockIdx.x * blockDim.x + threadIdx.x;
+    id             = &id[x];
+    od             = &od[x];
+
+    float scale = 1.0f / (float)((r << 1) + 1);
+
+    float4 t;
+    // do left edge
+    t = rgbaIntToFloat(id[0]) * r;
+
+    for (int y = 0; y < (r + 1); y++) {
+        t += rgbaIntToFloat(id[y * w]);
+    }
+
+    od[0] = rgbaFloatToInt(t * scale);
+
+    for (int y = 1; y < (r + 1); y++) {
+        t += rgbaIntToFloat(id[(y + r) * w]);
+        t -= rgbaIntToFloat(id[0]);
+        od[y * w] = rgbaFloatToInt(t * scale);
+    }
+
+    // main loop
+    for (int y = (r + 1); y < (h - r); y++) {
+        t += rgbaIntToFloat(id[(y + r) * w]);
+        t -= rgbaIntToFloat(id[((y - r) * w) - w]);
+        od[y * w] = rgbaFloatToInt(t * scale);
+    }
+
+    // do right edge
+    for (int y = h - r; y < h; y++) {
+        t += rgbaIntToFloat(id[(h - 1) * w]);
+        t -= rgbaIntToFloat(id[((y - r) * w) - w]);
+        od[y * w] = rgbaFloatToInt(t * scale);
+    }
+}
+
+extern "C" void initTexture(int width, int height, void *pImage, bool useRGBA)
+{
+    // copy image data to array
+    cudaChannelFormatDesc channelDesc;
+    if (useRGBA) {
+        channelDesc = cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsigned);
+    }
+    else {
+        channelDesc = cudaCreateChannelDesc(32, 0, 0, 0, cudaChannelFormatKindFloat);
+    }
+    checkCudaErrors(cudaMallocArray(&d_array, &channelDesc, width, height));
+
+    size_t bytesPerElem = (useRGBA ? sizeof(uchar4) : sizeof(float));
+    checkCudaErrors(cudaMemcpy2DToArray(
+        d_array, 0, 0, pImage, width * bytesPerElem, width * bytesPerElem, height, cudaMemcpyHostToDevice));
+
+    checkCudaErrors(cudaMallocArray(&d_tempArray, &channelDesc, width, height));
+
+    // set texture parameters
+    cudaResourceDesc texRes;
+    memset(&texRes, 0, sizeof(cudaResourceDesc));
+
+    texRes.resType         = cudaResourceTypeArray;
+    texRes.res.array.array = d_array;
+
+    cudaTextureDesc texDescr;
+    memset(&texDescr, 0, sizeof(cudaTextureDesc));
+
+    texDescr.normalizedCoords = false;
+    texDescr.filterMode       = cudaFilterModeLinear;
+    texDescr.addressMode[0]   = cudaAddressModeWrap;
+    texDescr.addressMode[1]   = cudaAddressModeWrap;
+    texDescr.readMode         = cudaReadModeNormalizedFloat;
+
+    checkCudaErrors(cudaCreateTextureObject(&rgbaTex, &texRes, &texDescr, NULL));
+
+    memset(&texRes, 0, sizeof(cudaResourceDesc));
+
+    texRes.resType         = cudaResourceTypeArray;
+    texRes.res.array.array = d_tempArray;
+
+    memset(&texDescr, 0, sizeof(cudaTextureDesc));
+
+    texDescr.normalizedCoords = false;
+    texDescr.filterMode       = cudaFilterModeLinear;
+    texDescr.addressMode[0]   = cudaAddressModeClamp;
+    texDescr.addressMode[1]   = cudaAddressModeClamp;
+    texDescr.readMode         = cudaReadModeNormalizedFloat;
+
+    checkCudaErrors(cudaCreateTextureObject(&rgbaTexTempArray, &texRes, &texDescr, NULL));
+
+    memset(&texRes, 0, sizeof(cudaResourceDesc));
+
+    texRes.resType         = cudaResourceTypeArray;
+    texRes.res.array.array = d_array;
+
+    memset(&texDescr, 0, sizeof(cudaTextureDesc));
+
+    texDescr.normalizedCoords = true;
+    texDescr.filterMode       = cudaFilterModePoint;
+    texDescr.addressMode[0]   = cudaAddressModeWrap;
+    texDescr.addressMode[1]   = cudaAddressModeWrap;
+    texDescr.readMode         = cudaReadModeElementType;
+
+    checkCudaErrors(cudaCreateTextureObject(&tex, &texRes, &texDescr, NULL));
+
+    memset(&texRes, 0, sizeof(cudaResourceDesc));
+
+    texRes.resType         = cudaResourceTypeArray;
+    texRes.res.array.array = d_tempArray;
+
+    memset(&texDescr, 0, sizeof(cudaTextureDesc));
+
+    texDescr.normalizedCoords = true;
+    texDescr.filterMode       = cudaFilterModePoint;
+    texDescr.addressMode[0]   = cudaAddressModeWrap;
+    texDescr.addressMode[1]   = cudaAddressModeWrap;
+    texDescr.readMode         = cudaReadModeElementType;
+
+    checkCudaErrors(cudaCreateTextureObject(&texTempArray, &texRes, &texDescr, NULL));
+}
+
+extern "C" void freeTextures()
+{
+    checkCudaErrors(cudaDestroyTextureObject(tex));
+    checkCudaErrors(cudaDestroyTextureObject(texTempArray));
+    checkCudaErrors(cudaDestroyTextureObject(rgbaTex));
+    checkCudaErrors(cudaDestroyTextureObject(rgbaTexTempArray));
+    checkCudaErrors(cudaFreeArray(d_array));
+    checkCudaErrors(cudaFreeArray(d_tempArray));
+}
+
+/*
+    Perform 2D box filter on image using CUDA
+
+    Parameters:
+    d_temp - pointer to temporary storage in device memory
+    d_dest - pointer to destination image in device memory
+    width  - image width
+    height - image height
+    radius - filter radius
+    iterations - number of iterations
+
+*/
+extern "C" double boxFilter(float              *d_temp,
+                            float              *d_dest,
+                            int                 width,
+                            int                 height,
+                            int                 radius,
+                            int                 iterations,
+                            int                 nthreads,
+                            StopWatchInterface *timer)
+{
+    // var for kernel timing
+    double dKernelTime = 0.0;
+
+    // sync host and start computation timer_kernel
+    checkCudaErrors(cudaDeviceSynchronize());
+
+    for (int i = 0; i < iterations; i++) {
+        sdkResetTimer(&timer);
+        // use texture for horizontal pass
+        if (iterations > 1) {
+            d_boxfilter_x_tex<<<height / nthreads, nthreads, 0>>>(d_temp, width, height, radius, texTempArray);
+        }
+        else {
+            d_boxfilter_x_tex<<<height / nthreads, nthreads, 0>>>(d_temp, width, height, radius, tex);
+        }
+
+        d_boxfilter_y_global<<<width / nthreads, nthreads, 0>>>(d_temp, d_dest, width, height, radius);
+
+        // sync host and stop computation timer_kernel
+        checkCudaErrors(cudaDeviceSynchronize());
+        dKernelTime += sdkGetTimerValue(&timer);
+
+        if (iterations > 1) {
+            // copy result back from global memory to array
+            checkCudaErrors(cudaMemcpy2DToArray(d_tempArray,
+                                                0,
+                                                0,
+                                                d_dest,
+                                                width * sizeof(float),
+                                                width * sizeof(float),
+                                                height,
+                                                cudaMemcpyDeviceToDevice));
+        }
+    }
+
+    return ((dKernelTime / 1000.) / (double)iterations);
+}
+
+// RGBA version
+extern "C" double boxFilterRGBA(unsigned int       *d_temp,
+                                unsigned int       *d_dest,
+                                int                 width,
+                                int                 height,
+                                int                 radius,
+                                int                 iterations,
+                                int                 nthreads,
+                                StopWatchInterface *timer)
+{
+    // var for kernel computation timing
+    double dKernelTime;
+
+    for (int i = 0; i < iterations; i++) {
+        // sync host and start kernel computation timer_kernel
+        dKernelTime = 0.0;
+        checkCudaErrors(cudaDeviceSynchronize());
+        sdkResetTimer(&timer);
+
+        // use texture for horizontal pass
+        if (iterations > 1) {
+            d_boxfilter_rgba_x<<<height / nthreads, nthreads, 0>>>(d_temp, width, height, radius, rgbaTexTempArray);
+        }
+        else {
+            d_boxfilter_rgba_x<<<height / nthreads, nthreads, 0>>>(d_temp, width, height, radius, rgbaTex);
+        }
+
+        d_boxfilter_rgba_y<<<width / nthreads, nthreads, 0>>>(d_temp, d_dest, width, height, radius);
+
+        // sync host and stop computation timer_kernel
+        checkCudaErrors(cudaDeviceSynchronize());
+        dKernelTime += sdkGetTimerValue(&timer);
+
+        if (iterations > 1) {
+            // copy result back from global memory to array
+            checkCudaErrors(cudaMemcpy2DToArray(d_tempArray,
+                                                0,
+                                                0,
+                                                d_dest,
+                                                width * sizeof(unsigned int),
+                                                width * sizeof(unsigned int),
+                                                height,
+                                                cudaMemcpyDeviceToDevice));
+        }
+    }
+
+    return ((dKernelTime / 1000.) / (double)iterations);
+}
+
+#endif // #ifndef _BOXFILTER_KERNEL_H_