add and update samples for CUDA 11.6

Samples/5_Domain_Specific/BlackScholes/.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
+}

Samples/5_Domain_Specific/BlackScholes/.vscode/extensions.json

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

Samples/5_Domain_Specific/BlackScholes/.vscode/launch.json

@@ -0,0 +1,10 @@
+{
+    "configurations": [
+        {
+            "name": "CUDA C++: Launch",
+            "type": "cuda-gdb",
+            "request": "launch",
+            "program": "${workspaceFolder}/BlackScholes"
+        }
+    ]
+}

Samples/5_Domain_Specific/BlackScholes/.vscode/tasks.json

@@ -0,0 +1,15 @@
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "sample",
+            "type": "shell",
+            "command": "make dbg=1",
+            "problemMatcher": ["$nvcc"],
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            }
+        }
+    ]
+}

Samples/5_Domain_Specific/BlackScholes/BlackScholes.cu

@@ -0,0 +1,243 @@
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * This sample evaluates fair call and put prices for a
+ * given set of European options by Black-Scholes formula.
+ * See supplied whitepaper for more explanations.
+ */
+
+#include <helper_functions.h>  // helper functions for string parsing
+#include <helper_cuda.h>  // helper functions CUDA error checking and initialization
+
+////////////////////////////////////////////////////////////////////////////////
+// Process an array of optN options on CPU
+////////////////////////////////////////////////////////////////////////////////
+extern "C" void BlackScholesCPU(float *h_CallResult, float *h_PutResult,
+                                float *h_StockPrice, float *h_OptionStrike,
+                                float *h_OptionYears, float Riskfree,
+                                float Volatility, int optN);
+
+////////////////////////////////////////////////////////////////////////////////
+// Process an array of OptN options on GPU
+////////////////////////////////////////////////////////////////////////////////
+#include "BlackScholes_kernel.cuh"
+
+////////////////////////////////////////////////////////////////////////////////
+// Helper function, returning uniformly distributed
+// random float in [low, high] range
+////////////////////////////////////////////////////////////////////////////////
+float RandFloat(float low, float high) {
+  float t = (float)rand() / (float)RAND_MAX;
+  return (1.0f - t) * low + t * high;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Data configuration
+////////////////////////////////////////////////////////////////////////////////
+const int OPT_N = 4000000;
+const int NUM_ITERATIONS = 512;
+
+const int OPT_SZ = OPT_N * sizeof(float);
+const float RISKFREE = 0.02f;
+const float VOLATILITY = 0.30f;
+
+#define DIV_UP(a, b) (((a) + (b)-1) / (b))
+
+////////////////////////////////////////////////////////////////////////////////
+// Main program
+////////////////////////////////////////////////////////////////////////////////
+int main(int argc, char **argv) {
+  // Start logs
+  printf("[%s] - Starting...\n", argv[0]);
+
+  //'h_' prefix - CPU (host) memory space
+  float
+      // Results calculated by CPU for reference
+      *h_CallResultCPU,
+      *h_PutResultCPU,
+      // CPU copy of GPU results
+      *h_CallResultGPU, *h_PutResultGPU,
+      // CPU instance of input data
+      *h_StockPrice, *h_OptionStrike, *h_OptionYears;
+
+  //'d_' prefix - GPU (device) memory space
+  float
+      // Results calculated by GPU
+      *d_CallResult,
+      *d_PutResult,
+      // GPU instance of input data
+      *d_StockPrice, *d_OptionStrike, *d_OptionYears;
+
+  double delta, ref, sum_delta, sum_ref, max_delta, L1norm, gpuTime;
+
+  StopWatchInterface *hTimer = NULL;
+  int i;
+
+  findCudaDevice(argc, (const char **)argv);
+
+  sdkCreateTimer(&hTimer);
+
+  printf("Initializing data...\n");
+  printf("...allocating CPU memory for options.\n");
+  h_CallResultCPU = (float *)malloc(OPT_SZ);
+  h_PutResultCPU = (float *)malloc(OPT_SZ);
+  h_CallResultGPU = (float *)malloc(OPT_SZ);
+  h_PutResultGPU = (float *)malloc(OPT_SZ);
+  h_StockPrice = (float *)malloc(OPT_SZ);
+  h_OptionStrike = (float *)malloc(OPT_SZ);
+  h_OptionYears = (float *)malloc(OPT_SZ);
+
+  printf("...allocating GPU memory for options.\n");
+  checkCudaErrors(cudaMalloc((void **)&d_CallResult, OPT_SZ));
+  checkCudaErrors(cudaMalloc((void **)&d_PutResult, OPT_SZ));
+  checkCudaErrors(cudaMalloc((void **)&d_StockPrice, OPT_SZ));
+  checkCudaErrors(cudaMalloc((void **)&d_OptionStrike, OPT_SZ));
+  checkCudaErrors(cudaMalloc((void **)&d_OptionYears, OPT_SZ));
+
+  printf("...generating input data in CPU mem.\n");
+  srand(5347);
+
+  // Generate options set
+  for (i = 0; i < OPT_N; i++) {
+    h_CallResultCPU[i] = 0.0f;
+    h_PutResultCPU[i] = -1.0f;
+    h_StockPrice[i] = RandFloat(5.0f, 30.0f);
+    h_OptionStrike[i] = RandFloat(1.0f, 100.0f);
+    h_OptionYears[i] = RandFloat(0.25f, 10.0f);
+  }
+
+  printf("...copying input data to GPU mem.\n");
+  // Copy options data to GPU memory for further processing
+  checkCudaErrors(
+      cudaMemcpy(d_StockPrice, h_StockPrice, OPT_SZ, cudaMemcpyHostToDevice));
+  checkCudaErrors(cudaMemcpy(d_OptionStrike, h_OptionStrike, OPT_SZ,
+                             cudaMemcpyHostToDevice));
+  checkCudaErrors(
+      cudaMemcpy(d_OptionYears, h_OptionYears, OPT_SZ, cudaMemcpyHostToDevice));
+  printf("Data init done.\n\n");
+
+  printf("Executing Black-Scholes GPU kernel (%i iterations)...\n",
+         NUM_ITERATIONS);
+  checkCudaErrors(cudaDeviceSynchronize());
+  sdkResetTimer(&hTimer);
+  sdkStartTimer(&hTimer);
+
+  for (i = 0; i < NUM_ITERATIONS; i++) {
+    BlackScholesGPU<<<DIV_UP((OPT_N / 2), 128), 128 /*480, 128*/>>>(
+        (float2 *)d_CallResult, (float2 *)d_PutResult, (float2 *)d_StockPrice,
+        (float2 *)d_OptionStrike, (float2 *)d_OptionYears, RISKFREE, VOLATILITY,
+        OPT_N);
+    getLastCudaError("BlackScholesGPU() execution failed\n");
+  }
+
+  checkCudaErrors(cudaDeviceSynchronize());
+  sdkStopTimer(&hTimer);
+  gpuTime = sdkGetTimerValue(&hTimer) / NUM_ITERATIONS;
+
+  // Both call and put is calculated
+  printf("Options count             : %i     \n", 2 * OPT_N);
+  printf("BlackScholesGPU() time    : %f msec\n", gpuTime);
+  printf("Effective memory bandwidth: %f GB/s\n",
+         ((double)(5 * OPT_N * sizeof(float)) * 1E-9) / (gpuTime * 1E-3));
+  printf("Gigaoptions per second    : %f     \n\n",
+         ((double)(2 * OPT_N) * 1E-9) / (gpuTime * 1E-3));
+
+  printf(
+      "BlackScholes, Throughput = %.4f GOptions/s, Time = %.5f s, Size = %u "
+      "options, NumDevsUsed = %u, Workgroup = %u\n",
+      (((double)(2.0 * OPT_N) * 1.0E-9) / (gpuTime * 1.0E-3)), gpuTime * 1e-3,
+      (2 * OPT_N), 1, 128);
+
+  printf("\nReading back GPU results...\n");
+  // Read back GPU results to compare them to CPU results
+  checkCudaErrors(cudaMemcpy(h_CallResultGPU, d_CallResult, OPT_SZ,
+                             cudaMemcpyDeviceToHost));
+  checkCudaErrors(
+      cudaMemcpy(h_PutResultGPU, d_PutResult, OPT_SZ, cudaMemcpyDeviceToHost));
+
+  printf("Checking the results...\n");
+  printf("...running CPU calculations.\n\n");
+  // Calculate options values on CPU
+  BlackScholesCPU(h_CallResultCPU, h_PutResultCPU, h_StockPrice, h_OptionStrike,
+                  h_OptionYears, RISKFREE, VOLATILITY, OPT_N);
+
+  printf("Comparing the results...\n");
+  // Calculate max absolute difference and L1 distance
+  // between CPU and GPU results
+  sum_delta = 0;
+  sum_ref = 0;
+  max_delta = 0;
+
+  for (i = 0; i < OPT_N; i++) {
+    ref = h_CallResultCPU[i];
+    delta = fabs(h_CallResultCPU[i] - h_CallResultGPU[i]);
+
+    if (delta > max_delta) {
+      max_delta = delta;
+    }
+
+    sum_delta += delta;
+    sum_ref += fabs(ref);
+  }
+
+  L1norm = sum_delta / sum_ref;
+  printf("L1 norm: %E\n", L1norm);
+  printf("Max absolute error: %E\n\n", max_delta);
+
+  printf("Shutting down...\n");
+  printf("...releasing GPU memory.\n");
+  checkCudaErrors(cudaFree(d_OptionYears));
+  checkCudaErrors(cudaFree(d_OptionStrike));
+  checkCudaErrors(cudaFree(d_StockPrice));
+  checkCudaErrors(cudaFree(d_PutResult));
+  checkCudaErrors(cudaFree(d_CallResult));
+
+  printf("...releasing CPU memory.\n");
+  free(h_OptionYears);
+  free(h_OptionStrike);
+  free(h_StockPrice);
+  free(h_PutResultGPU);
+  free(h_CallResultGPU);
+  free(h_PutResultCPU);
+  free(h_CallResultCPU);
+  sdkDeleteTimer(&hTimer);
+  printf("Shutdown done.\n");
+
+  printf("\n[BlackScholes] - Test Summary\n");
+
+  if (L1norm > 1e-6) {
+    printf("Test failed!\n");
+    exit(EXIT_FAILURE);
+  }
+
+  printf(
+      "\nNOTE: The CUDA Samples are not meant for performance measurements. "
+      "Results may vary when GPU Boost is enabled.\n\n");
+  printf("Test passed\n");
+  exit(EXIT_SUCCESS);
+}

Samples/5_Domain_Specific/BlackScholes/BlackScholes_gold.cpp

@@ -0,0 +1,86 @@
+/* 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 <math.h>
+
+////////////////////////////////////////////////////////////////////////////////
+// Polynomial approximation of cumulative normal distribution function
+////////////////////////////////////////////////////////////////////////////////
+static double CND(double d) {
+  const double A1 = 0.31938153;
+  const double A2 = -0.356563782;
+  const double A3 = 1.781477937;
+  const double A4 = -1.821255978;
+  const double A5 = 1.330274429;
+  const double RSQRT2PI = 0.39894228040143267793994605993438;
+
+  double K = 1.0 / (1.0 + 0.2316419 * fabs(d));
+
+  double cnd = RSQRT2PI * exp(-0.5 * d * d) *
+               (K * (A1 + K * (A2 + K * (A3 + K * (A4 + K * A5)))));
+
+  if (d > 0) cnd = 1.0 - cnd;
+
+  return cnd;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Black-Scholes formula for both call and put
+////////////////////////////////////////////////////////////////////////////////
+static void BlackScholesBodyCPU(float &callResult, float &putResult,
+                                float Sf,  // Stock price
+                                float Xf,  // Option strike
+                                float Tf,  // Option years
+                                float Rf,  // Riskless rate
+                                float Vf  // Volatility rate
+                                ) {
+  double S = Sf, X = Xf, T = Tf, R = Rf, V = Vf;
+
+  double sqrtT = sqrt(T);
+  double d1 = (log(S / X) + (R + 0.5 * V * V) * T) / (V * sqrtT);
+  double d2 = d1 - V * sqrtT;
+  double CNDD1 = CND(d1);
+  double CNDD2 = CND(d2);
+
+  // Calculate Call and Put simultaneously
+  double expRT = exp(-R * T);
+  callResult = (float)(S * CNDD1 - X * expRT * CNDD2);
+  putResult = (float)(X * expRT * (1.0 - CNDD2) - S * (1.0 - CNDD1));
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Process an array of optN options
+////////////////////////////////////////////////////////////////////////////////
+extern "C" void BlackScholesCPU(float *h_CallResult, float *h_PutResult,
+                                float *h_StockPrice, float *h_OptionStrike,
+                                float *h_OptionYears, float Riskfree,
+                                float Volatility, int optN) {
+  for (int opt = 0; opt < optN; opt++)
+    BlackScholesBodyCPU(h_CallResult[opt], h_PutResult[opt], h_StockPrice[opt],
+                        h_OptionStrike[opt], h_OptionYears[opt], Riskfree,
+                        Volatility);
+}

Samples/5_Domain_Specific/BlackScholes/BlackScholes_kernel.cuh

@@ -0,0 +1,106 @@
+/* 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.
+ */
+
+////////////////////////////////////////////////////////////////////////////////
+// Polynomial approximation of cumulative normal distribution function
+////////////////////////////////////////////////////////////////////////////////
+__device__ inline float cndGPU(float d) {
+  const float A1 = 0.31938153f;
+  const float A2 = -0.356563782f;
+  const float A3 = 1.781477937f;
+  const float A4 = -1.821255978f;
+  const float A5 = 1.330274429f;
+  const float RSQRT2PI = 0.39894228040143267793994605993438f;
+
+  float K = __fdividef(1.0f, (1.0f + 0.2316419f * fabsf(d)));
+
+  float cnd = RSQRT2PI * __expf(-0.5f * d * d) *
+              (K * (A1 + K * (A2 + K * (A3 + K * (A4 + K * A5)))));
+
+  if (d > 0) cnd = 1.0f - cnd;
+
+  return cnd;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Black-Scholes formula for both call and put
+////////////////////////////////////////////////////////////////////////////////
+__device__ inline void BlackScholesBodyGPU(float &CallResult, float &PutResult,
+                                           float S,  // Stock price
+                                           float X,  // Option strike
+                                           float T,  // Option years
+                                           float R,  // Riskless rate
+                                           float V  // Volatility rate
+                                           ) {
+  float sqrtT, expRT;
+  float d1, d2, CNDD1, CNDD2;
+
+  sqrtT = __fdividef(1.0F, rsqrtf(T));
+  d1 = __fdividef(__logf(S / X) + (R + 0.5f * V * V) * T, V * sqrtT);
+  d2 = d1 - V * sqrtT;
+
+  CNDD1 = cndGPU(d1);
+  CNDD2 = cndGPU(d2);
+
+  // Calculate Call and Put simultaneously
+  expRT = __expf(-R * T);
+  CallResult = S * CNDD1 - X * expRT * CNDD2;
+  PutResult = X * expRT * (1.0f - CNDD2) - S * (1.0f - CNDD1);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Process an array of optN options on GPU
+////////////////////////////////////////////////////////////////////////////////
+__launch_bounds__(128) __global__
+    void BlackScholesGPU(float2 *__restrict d_CallResult,
+                         float2 *__restrict d_PutResult,
+                         float2 *__restrict d_StockPrice,
+                         float2 *__restrict d_OptionStrike,
+                         float2 *__restrict d_OptionYears, float Riskfree,
+                         float Volatility, int optN) {
+  ////Thread index
+  // const int      tid = blockDim.x * blockIdx.x + threadIdx.x;
+  ////Total number of threads in execution grid
+  // const int THREAD_N = blockDim.x * gridDim.x;
+
+  const int opt = blockDim.x * blockIdx.x + threadIdx.x;
+
+  // Calculating 2 options per thread to increase ILP (instruction level
+  // parallelism)
+  if (opt < (optN / 2)) {
+    float callResult1, callResult2;
+    float putResult1, putResult2;
+    BlackScholesBodyGPU(callResult1, putResult1, d_StockPrice[opt].x,
+                        d_OptionStrike[opt].x, d_OptionYears[opt].x, Riskfree,
+                        Volatility);
+    BlackScholesBodyGPU(callResult2, putResult2, d_StockPrice[opt].y,
+                        d_OptionStrike[opt].y, d_OptionYears[opt].y, Riskfree,
+                        Volatility);
+    d_CallResult[opt] = make_float2(callResult1, callResult2);
+    d_PutResult[opt] = make_float2(putResult1, putResult2);
+  }
+}

Samples/5_Domain_Specific/BlackScholes/BlackScholes_vs2017.sln

@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2017
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "BlackScholes", "BlackScholes_vs2017.vcxproj", "{997E0757-EA74-4A4E-A0FC-47D8C8831A15}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Release|x64 = Release|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Debug|x64.ActiveCfg = Debug|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Debug|x64.Build.0 = Debug|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Release|x64.ActiveCfg = Release|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Release|x64.Build.0 = Release|x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

Samples/5_Domain_Specific/BlackScholes/BlackScholes_vs2017.vcxproj

@@ -0,0 +1,113 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <CUDAPropsPath Condition="'$(CUDAPropsPath)'==''">$(VCTargetsPath)\BuildCustomizations</CUDAPropsPath>
+  </PropertyGroup>
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{997E0757-EA74-4A4E-A0FC-47D8C8831A15}</ProjectGuid>
+    <RootNamespace>BlackScholes_vs2017</RootNamespace>
+    <ProjectName>BlackScholes</ProjectName>
+    <CudaToolkitCustomDir />
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(WindowsTargetPlatformVersion)'==''">
+    <LatestTargetPlatformVersion>$([Microsoft.Build.Utilities.ToolLocationHelper]::GetLatestSDKTargetPlatformVersion('Windows', '10.0'))</LatestTargetPlatformVersion>
+    <WindowsTargetPlatformVersion Condition="'$(WindowsTargetPlatformVersion)' == ''">$(LatestTargetPlatformVersion)</WindowsTargetPlatformVersion>
+    <TargetPlatformVersion>$(WindowsTargetPlatformVersion)</TargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup>
+    <ConfigurationType>Application</ConfigurationType>
+    <CharacterSet>MultiByte</CharacterSet>
+    <PlatformToolset>v141</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Debug'">
+    <UseDebugLibraries>true</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Release'">
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.6.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <IntDir>$(Platform)/$(Configuration)/</IntDir>
+    <IncludePath>$(IncludePath)</IncludePath>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules />
+    <CodeAnalysisRuleAssemblies />
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Platform)'=='x64'">
+    <OutDir>../../../bin/win64/$(Configuration)/</OutDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;_MBCS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>./;$(CudaToolkitDir)/include;../../../Common;</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <AdditionalDependencies>cudart_static.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>$(CudaToolkitLibDir);</AdditionalLibraryDirectories>
+      <OutputFile>$(OutDir)/BlackScholes.exe</OutputFile>
+    </Link>
+    <CudaCompile>
+      <CodeGeneration>compute_35,sm_35;compute_37,sm_37;compute_50,sm_50;compute_52,sm_52;compute_60,sm_60;compute_61,sm_61;compute_70,sm_70;compute_75,sm_75;compute_80,sm_80;compute_86,sm_86;</CodeGeneration>
+      <AdditionalOptions>-Xcompiler "/wd 4819"  --threads 0 </AdditionalOptions>
+      <Include>./;../../../Common</Include>
+      <Defines>WIN32</Defines>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Debug'">
+    <ClCompile>
+      <Optimization>Disabled</Optimization>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
+    </Link>
+    <CudaCompile>
+      <Runtime>MTd</Runtime>
+      <TargetMachinePlatform>64</TargetMachinePlatform>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Release'">
+    <ClCompile>
+      <Optimization>MaxSpeed</Optimization>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>false</GenerateDebugInformation>
+      <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
+    </Link>
+    <CudaCompile>
+      <Runtime>MT</Runtime>
+      <TargetMachinePlatform>64</TargetMachinePlatform>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <CudaCompile Include="BlackScholes.cu" />
+    <ClCompile Include="BlackScholes_gold.cpp" />
+    <None Include="BlackScholes_kernel.cuh" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.6.targets" />
+  </ImportGroup>
+</Project>

Samples/5_Domain_Specific/BlackScholes/BlackScholes_vs2019.sln

@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2019
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "BlackScholes", "BlackScholes_vs2019.vcxproj", "{997E0757-EA74-4A4E-A0FC-47D8C8831A15}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Release|x64 = Release|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Debug|x64.ActiveCfg = Debug|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Debug|x64.Build.0 = Debug|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Release|x64.ActiveCfg = Release|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Release|x64.Build.0 = Release|x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

Samples/5_Domain_Specific/BlackScholes/BlackScholes_vs2019.vcxproj

@@ -0,0 +1,109 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <CUDAPropsPath Condition="'$(CUDAPropsPath)'==''">$(VCTargetsPath)\BuildCustomizations</CUDAPropsPath>
+  </PropertyGroup>
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{997E0757-EA74-4A4E-A0FC-47D8C8831A15}</ProjectGuid>
+    <RootNamespace>BlackScholes_vs2019</RootNamespace>
+    <ProjectName>BlackScholes</ProjectName>
+    <CudaToolkitCustomDir />
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup>
+    <ConfigurationType>Application</ConfigurationType>
+    <CharacterSet>MultiByte</CharacterSet>
+    <PlatformToolset>v142</PlatformToolset>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Debug'">
+    <UseDebugLibraries>true</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Release'">
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.6.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <IntDir>$(Platform)/$(Configuration)/</IntDir>
+    <IncludePath>$(IncludePath)</IncludePath>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules />
+    <CodeAnalysisRuleAssemblies />
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Platform)'=='x64'">
+    <OutDir>../../../bin/win64/$(Configuration)/</OutDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;_MBCS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>./;$(CudaToolkitDir)/include;../../../Common;</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <AdditionalDependencies>cudart_static.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>$(CudaToolkitLibDir);</AdditionalLibraryDirectories>
+      <OutputFile>$(OutDir)/BlackScholes.exe</OutputFile>
+    </Link>
+    <CudaCompile>
+      <CodeGeneration>compute_35,sm_35;compute_37,sm_37;compute_50,sm_50;compute_52,sm_52;compute_60,sm_60;compute_61,sm_61;compute_70,sm_70;compute_75,sm_75;compute_80,sm_80;compute_86,sm_86;</CodeGeneration>
+      <AdditionalOptions>-Xcompiler "/wd 4819"  --threads 0 </AdditionalOptions>
+      <Include>./;../../../Common</Include>
+      <Defines>WIN32</Defines>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Debug'">
+    <ClCompile>
+      <Optimization>Disabled</Optimization>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
+    </Link>
+    <CudaCompile>
+      <Runtime>MTd</Runtime>
+      <TargetMachinePlatform>64</TargetMachinePlatform>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Release'">
+    <ClCompile>
+      <Optimization>MaxSpeed</Optimization>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>false</GenerateDebugInformation>
+      <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
+    </Link>
+    <CudaCompile>
+      <Runtime>MT</Runtime>
+      <TargetMachinePlatform>64</TargetMachinePlatform>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <CudaCompile Include="BlackScholes.cu" />
+    <ClCompile Include="BlackScholes_gold.cpp" />
+    <None Include="BlackScholes_kernel.cuh" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.6.targets" />
+  </ImportGroup>
+</Project>

Samples/5_Domain_Specific/BlackScholes/BlackScholes_vs2022.sln

@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2022
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "BlackScholes", "BlackScholes_vs2022.vcxproj", "{997E0757-EA74-4A4E-A0FC-47D8C8831A15}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Release|x64 = Release|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Debug|x64.ActiveCfg = Debug|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Debug|x64.Build.0 = Debug|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Release|x64.ActiveCfg = Release|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Release|x64.Build.0 = Release|x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

Samples/5_Domain_Specific/BlackScholes/BlackScholes_vs2022.vcxproj

@@ -0,0 +1,109 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <CUDAPropsPath Condition="'$(CUDAPropsPath)'==''">$(VCTargetsPath)\BuildCustomizations</CUDAPropsPath>
+  </PropertyGroup>
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{997E0757-EA74-4A4E-A0FC-47D8C8831A15}</ProjectGuid>
+    <RootNamespace>BlackScholes_vs2022</RootNamespace>
+    <ProjectName>BlackScholes</ProjectName>
+    <CudaToolkitCustomDir />
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup>
+    <ConfigurationType>Application</ConfigurationType>
+    <CharacterSet>MultiByte</CharacterSet>
+    <PlatformToolset>v143</PlatformToolset>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Debug'">
+    <UseDebugLibraries>true</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Release'">
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.6.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <IntDir>$(Platform)/$(Configuration)/</IntDir>
+    <IncludePath>$(IncludePath)</IncludePath>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules />
+    <CodeAnalysisRuleAssemblies />
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Platform)'=='x64'">
+    <OutDir>../../../bin/win64/$(Configuration)/</OutDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;_MBCS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>./;$(CudaToolkitDir)/include;../../../Common;</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <AdditionalDependencies>cudart_static.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>$(CudaToolkitLibDir);</AdditionalLibraryDirectories>
+      <OutputFile>$(OutDir)/BlackScholes.exe</OutputFile>
+    </Link>
+    <CudaCompile>
+      <CodeGeneration>compute_35,sm_35;compute_37,sm_37;compute_50,sm_50;compute_52,sm_52;compute_60,sm_60;compute_61,sm_61;compute_70,sm_70;compute_75,sm_75;compute_80,sm_80;compute_86,sm_86;</CodeGeneration>
+      <AdditionalOptions>-Xcompiler "/wd 4819"  --threads 0 </AdditionalOptions>
+      <Include>./;../../../Common</Include>
+      <Defines>WIN32</Defines>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Debug'">
+    <ClCompile>
+      <Optimization>Disabled</Optimization>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
+    </Link>
+    <CudaCompile>
+      <Runtime>MTd</Runtime>
+      <TargetMachinePlatform>64</TargetMachinePlatform>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Release'">
+    <ClCompile>
+      <Optimization>MaxSpeed</Optimization>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>false</GenerateDebugInformation>
+      <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
+    </Link>
+    <CudaCompile>
+      <Runtime>MT</Runtime>
+      <TargetMachinePlatform>64</TargetMachinePlatform>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <CudaCompile Include="BlackScholes.cu" />
+    <ClCompile Include="BlackScholes_gold.cpp" />
+    <None Include="BlackScholes_kernel.cuh" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.6.targets" />
+  </ImportGroup>
+</Project>

Samples/5_Domain_Specific/BlackScholes/Makefile

@@ -0,0 +1,343 @@
+################################################################################
+# 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.
+#
+################################################################################
+#
+# Makefile project only supported on Mac OS X and Linux Platforms)
+#
+################################################################################
+
+# Location of the CUDA Toolkit
+CUDA_PATH ?= /usr/local/cuda
+
+##############################
+# start deprecated interface #
+##############################
+ifeq ($(x86_64),1)
+    $(info WARNING - x86_64 variable has been deprecated)
+    $(info WARNING - please use TARGET_ARCH=x86_64 instead)
+    TARGET_ARCH ?= x86_64
+endif
+ifeq ($(ARMv7),1)
+    $(info WARNING - ARMv7 variable has been deprecated)
+    $(info WARNING - please use TARGET_ARCH=armv7l instead)
+    TARGET_ARCH ?= armv7l
+endif
+ifeq ($(aarch64),1)
+    $(info WARNING - aarch64 variable has been deprecated)
+    $(info WARNING - please use TARGET_ARCH=aarch64 instead)
+    TARGET_ARCH ?= aarch64
+endif
+ifeq ($(ppc64le),1)
+    $(info WARNING - ppc64le variable has been deprecated)
+    $(info WARNING - please use TARGET_ARCH=ppc64le instead)
+    TARGET_ARCH ?= ppc64le
+endif
+ifneq ($(GCC),)
+    $(info WARNING - GCC variable has been deprecated)
+    $(info WARNING - please use HOST_COMPILER=$(GCC) instead)
+    HOST_COMPILER ?= $(GCC)
+endif
+ifneq ($(abi),)
+    $(error ERROR - abi variable has been removed)
+endif
+############################
+# end deprecated interface #
+############################
+
+# architecture
+HOST_ARCH   := $(shell uname -m)
+TARGET_ARCH ?= $(HOST_ARCH)
+ifneq (,$(filter $(TARGET_ARCH),x86_64 aarch64 sbsa ppc64le armv7l))
+    ifneq ($(TARGET_ARCH),$(HOST_ARCH))
+        ifneq (,$(filter $(TARGET_ARCH),x86_64 aarch64 sbsa ppc64le))
+            TARGET_SIZE := 64
+        else ifneq (,$(filter $(TARGET_ARCH),armv7l))
+            TARGET_SIZE := 32
+        endif
+    else
+        TARGET_SIZE := $(shell getconf LONG_BIT)
+    endif
+else
+    $(error ERROR - unsupported value $(TARGET_ARCH) for TARGET_ARCH!)
+endif
+
+# sbsa and aarch64 systems look similar. Need to differentiate them at host level for now.
+ifeq ($(HOST_ARCH),aarch64)
+    ifeq ($(CUDA_PATH)/targets/sbsa-linux,$(shell ls -1d $(CUDA_PATH)/targets/sbsa-linux 2>/dev/null))
+        HOST_ARCH := sbsa
+        TARGET_ARCH := sbsa
+    endif
+endif
+
+ifneq ($(TARGET_ARCH),$(HOST_ARCH))
+    ifeq (,$(filter $(HOST_ARCH)-$(TARGET_ARCH),aarch64-armv7l x86_64-armv7l x86_64-aarch64 x86_64-sbsa x86_64-ppc64le))
+        $(error ERROR - cross compiling from $(HOST_ARCH) to $(TARGET_ARCH) is not supported!)
+    endif
+endif
+
+# When on native aarch64 system with userspace of 32-bit, change TARGET_ARCH to armv7l
+ifeq ($(HOST_ARCH)-$(TARGET_ARCH)-$(TARGET_SIZE),aarch64-aarch64-32)
+    TARGET_ARCH = armv7l
+endif
+
+# operating system
+HOST_OS   := $(shell uname -s 2>/dev/null | tr "[:upper:]" "[:lower:]")
+TARGET_OS ?= $(HOST_OS)
+ifeq (,$(filter $(TARGET_OS),linux darwin qnx android))
+    $(error ERROR - unsupported value $(TARGET_OS) for TARGET_OS!)
+endif
+
+# host compiler
+ifeq ($(TARGET_OS),darwin)
+    ifeq ($(shell expr `xcodebuild -version | grep -i xcode | awk '{print $$2}' | cut -d'.' -f1` \>= 5),1)
+        HOST_COMPILER ?= clang++
+    endif
+else ifneq ($(TARGET_ARCH),$(HOST_ARCH))
+    ifeq ($(HOST_ARCH)-$(TARGET_ARCH),x86_64-armv7l)
+        ifeq ($(TARGET_OS),linux)
+            HOST_COMPILER ?= arm-linux-gnueabihf-g++
+        else ifeq ($(TARGET_OS),qnx)
+            ifeq ($(QNX_HOST),)
+                $(error ERROR - QNX_HOST must be passed to the QNX host toolchain)
+            endif
+            ifeq ($(QNX_TARGET),)
+                $(error ERROR - QNX_TARGET must be passed to the QNX target toolchain)
+            endif
+            export QNX_HOST
+            export QNX_TARGET
+            HOST_COMPILER ?= $(QNX_HOST)/usr/bin/arm-unknown-nto-qnx6.6.0eabi-g++
+        else ifeq ($(TARGET_OS),android)
+            HOST_COMPILER ?= arm-linux-androideabi-g++
+        endif
+    else ifeq ($(TARGET_ARCH),aarch64)
+        ifeq ($(TARGET_OS), linux)
+            HOST_COMPILER ?= aarch64-linux-gnu-g++
+        else ifeq ($(TARGET_OS),qnx)
+            ifeq ($(QNX_HOST),)
+                $(error ERROR - QNX_HOST must be passed to the QNX host toolchain)
+            endif
+            ifeq ($(QNX_TARGET),)
+                $(error ERROR - QNX_TARGET must be passed to the QNX target toolchain)
+            endif
+            export QNX_HOST
+            export QNX_TARGET
+            HOST_COMPILER ?= $(QNX_HOST)/usr/bin/q++
+        else ifeq ($(TARGET_OS), android)
+            HOST_COMPILER ?= aarch64-linux-android-clang++
+        endif
+    else ifeq ($(TARGET_ARCH),sbsa)
+        HOST_COMPILER ?= aarch64-linux-gnu-g++
+    else ifeq ($(TARGET_ARCH),ppc64le)
+        HOST_COMPILER ?= powerpc64le-linux-gnu-g++
+    endif
+endif
+HOST_COMPILER ?= g++
+NVCC          := $(CUDA_PATH)/bin/nvcc -ccbin $(HOST_COMPILER)
+
+# internal flags
+NVCCFLAGS   := -m${TARGET_SIZE}
+CCFLAGS     :=
+LDFLAGS     :=
+
+# build flags
+ifeq ($(TARGET_OS),darwin)
+    LDFLAGS += -rpath $(CUDA_PATH)/lib
+    CCFLAGS += -arch $(HOST_ARCH)
+else ifeq ($(HOST_ARCH)-$(TARGET_ARCH)-$(TARGET_OS),x86_64-armv7l-linux)
+    LDFLAGS += --dynamic-linker=/lib/ld-linux-armhf.so.3
+    CCFLAGS += -mfloat-abi=hard
+else ifeq ($(TARGET_OS),android)
+    LDFLAGS += -pie
+    CCFLAGS += -fpie -fpic -fexceptions
+endif
+
+ifneq ($(TARGET_ARCH),$(HOST_ARCH))
+    ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-linux)
+        ifneq ($(TARGET_FS),)
+            GCCVERSIONLTEQ46 := $(shell expr `$(HOST_COMPILER) -dumpversion` \<= 4.6)
+            ifeq ($(GCCVERSIONLTEQ46),1)
+                CCFLAGS += --sysroot=$(TARGET_FS)
+            endif
+            LDFLAGS += --sysroot=$(TARGET_FS)
+            LDFLAGS += -rpath-link=$(TARGET_FS)/lib
+            LDFLAGS += -rpath-link=$(TARGET_FS)/usr/lib
+            LDFLAGS += -rpath-link=$(TARGET_FS)/usr/lib/arm-linux-gnueabihf
+        endif
+    endif
+    ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-linux)
+        ifneq ($(TARGET_FS),)
+            GCCVERSIONLTEQ46 := $(shell expr `$(HOST_COMPILER) -dumpversion` \<= 4.6)
+            ifeq ($(GCCVERSIONLTEQ46),1)
+                CCFLAGS += --sysroot=$(TARGET_FS)
+            endif
+            LDFLAGS += --sysroot=$(TARGET_FS)
+            LDFLAGS += -rpath-link=$(TARGET_FS)/lib -L$(TARGET_FS)/lib
+            LDFLAGS += -rpath-link=$(TARGET_FS)/lib/aarch64-linux-gnu -L$(TARGET_FS)/lib/aarch64-linux-gnu
+            LDFLAGS += -rpath-link=$(TARGET_FS)/usr/lib -L$(TARGET_FS)/usr/lib
+            LDFLAGS += -rpath-link=$(TARGET_FS)/usr/lib/aarch64-linux-gnu -L$(TARGET_FS)/usr/lib/aarch64-linux-gnu
+            LDFLAGS += --unresolved-symbols=ignore-in-shared-libs
+            CCFLAGS += -isystem=$(TARGET_FS)/usr/include -I$(TARGET_FS)/usr/include -I$(TARGET_FS)/usr/include/libdrm
+            CCFLAGS += -isystem=$(TARGET_FS)/usr/include/aarch64-linux-gnu -I$(TARGET_FS)/usr/include/aarch64-linux-gnu
+        endif
+    endif
+    ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-qnx)
+        NVCCFLAGS += -D_QNX_SOURCE
+        NVCCFLAGS += --qpp-config 8.3.0,gcc_ntoaarch64le
+        CCFLAGS += -DWIN_INTERFACE_CUSTOM -I/usr/include/aarch64-qnx-gnu
+        LDFLAGS += -lsocket
+        LDFLAGS += -L/usr/lib/aarch64-qnx-gnu
+        CCFLAGS += "-Wl\,-rpath-link\,/usr/lib/aarch64-qnx-gnu"
+        ifdef TARGET_OVERRIDE
+            LDFLAGS += -lslog2
+        endif
+
+        ifneq ($(TARGET_FS),)
+            LDFLAGS += -L$(TARGET_FS)/usr/lib
+            CCFLAGS += "-Wl\,-rpath-link\,$(TARGET_FS)/usr/lib"
+            LDFLAGS += -L$(TARGET_FS)/usr/libnvidia
+            CCFLAGS += "-Wl\,-rpath-link\,$(TARGET_FS)/usr/libnvidia"
+            CCFLAGS += -I$(TARGET_FS)/../include
+        endif
+    endif
+endif
+
+ifdef TARGET_OVERRIDE # cuda toolkit targets override
+    NVCCFLAGS += -target-dir $(TARGET_OVERRIDE)
+endif
+
+# Install directory of different arch
+CUDA_INSTALL_TARGET_DIR :=
+ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-linux)
+    CUDA_INSTALL_TARGET_DIR = targets/armv7-linux-gnueabihf/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-linux)
+    CUDA_INSTALL_TARGET_DIR = targets/aarch64-linux/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),sbsa-linux)
+    CUDA_INSTALL_TARGET_DIR = targets/sbsa-linux/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-android)
+    CUDA_INSTALL_TARGET_DIR = targets/armv7-linux-androideabi/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-android)
+    CUDA_INSTALL_TARGET_DIR = targets/aarch64-linux-androideabi/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-qnx)
+    CUDA_INSTALL_TARGET_DIR = targets/ARMv7-linux-QNX/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-qnx)
+    CUDA_INSTALL_TARGET_DIR = targets/aarch64-qnx/
+else ifeq ($(TARGET_ARCH),ppc64le)
+    CUDA_INSTALL_TARGET_DIR = targets/ppc64le-linux/
+endif
+
+# Debug build flags
+ifeq ($(dbg),1)
+      NVCCFLAGS += -g -G
+      BUILD_TYPE := debug
+else
+      BUILD_TYPE := release
+endif
+
+ALL_CCFLAGS :=
+ALL_CCFLAGS += $(NVCCFLAGS)
+ALL_CCFLAGS += $(EXTRA_NVCCFLAGS)
+ALL_CCFLAGS += $(addprefix -Xcompiler ,$(CCFLAGS))
+ALL_CCFLAGS += $(addprefix -Xcompiler ,$(EXTRA_CCFLAGS))
+
+SAMPLE_ENABLED := 1
+
+ALL_LDFLAGS :=
+ALL_LDFLAGS += $(ALL_CCFLAGS)
+ALL_LDFLAGS += $(addprefix -Xlinker ,$(LDFLAGS))
+ALL_LDFLAGS += $(addprefix -Xlinker ,$(EXTRA_LDFLAGS))
+
+# Common includes and paths for CUDA
+INCLUDES  := -I../../../Common
+LIBRARIES :=
+
+################################################################################
+
+# Gencode arguments
+ifeq ($(TARGET_ARCH),$(filter $(TARGET_ARCH),armv7l aarch64 sbsa))
+SMS ?= 53 61 70 72 75 80 86 87
+else
+SMS ?= 35 37 50 52 60 61 70 75 80 86
+endif
+
+ifeq ($(SMS),)
+$(info >>> WARNING - no SM architectures have been specified - waiving sample <<<)
+SAMPLE_ENABLED := 0
+endif
+
+ifeq ($(GENCODE_FLAGS),)
+# Generate SASS code for each SM architecture listed in $(SMS)
+$(foreach sm,$(SMS),$(eval GENCODE_FLAGS += -gencode arch=compute_$(sm),code=sm_$(sm)))
+
+# Generate PTX code from the highest SM architecture in $(SMS) to guarantee forward-compatibility
+HIGHEST_SM := $(lastword $(sort $(SMS)))
+ifneq ($(HIGHEST_SM),)
+GENCODE_FLAGS += -gencode arch=compute_$(HIGHEST_SM),code=compute_$(HIGHEST_SM)
+endif
+endif
+
+ALL_CCFLAGS += -maxrregcount=16 --threads 0 --std=c++11
+
+ifeq ($(SAMPLE_ENABLED),0)
+EXEC ?= @echo "[@]"
+endif
+
+################################################################################
+
+# Target rules
+all: build
+
+build: BlackScholes
+
+check.deps:
+ifeq ($(SAMPLE_ENABLED),0)
+	@echo "Sample will be waived due to the above missing dependencies"
+else
+	@echo "Sample is ready - all dependencies have been met"
+endif
+
+BlackScholes.o:BlackScholes.cu
+	$(EXEC) $(NVCC) $(INCLUDES) $(ALL_CCFLAGS) $(GENCODE_FLAGS) -o $@ -c $<
+
+BlackScholes_gold.o:BlackScholes_gold.cpp
+	$(EXEC) $(NVCC) $(INCLUDES) $(ALL_CCFLAGS) $(GENCODE_FLAGS) -o $@ -c $<
+
+BlackScholes: BlackScholes.o BlackScholes_gold.o
+	$(EXEC) $(NVCC) $(ALL_LDFLAGS) $(GENCODE_FLAGS) -o $@ $+ $(LIBRARIES)
+	$(EXEC) mkdir -p ../../../bin/$(TARGET_ARCH)/$(TARGET_OS)/$(BUILD_TYPE)
+	$(EXEC) cp $@ ../../../bin/$(TARGET_ARCH)/$(TARGET_OS)/$(BUILD_TYPE)
+
+run: build
+	$(EXEC) ./BlackScholes
+
+testrun: build
+
+clean:
+	rm -f BlackScholes BlackScholes.o BlackScholes_gold.o
+	rm -rf ../../../bin/$(TARGET_ARCH)/$(TARGET_OS)/$(BUILD_TYPE)/BlackScholes
+
+clobber: clean

Samples/5_Domain_Specific/BlackScholes/NsightEclipse.xml

@@ -0,0 +1,82 @@
+<?xml version="1.0" encoding="UTF-8"?> 
+<!DOCTYPE entry SYSTEM "SamplesInfo.dtd">
+<entry>
+  <name>BlackScholes</name>
+  <cflags>
+    <flag>-maxrregcount=16</flag>
+  </cflags>
+  <cuda_api_list>
+    <toolkit>cudaMalloc</toolkit>
+    <toolkit>cudaFree</toolkit>
+    <toolkit>cudaDeviceSynchronize</toolkit>
+    <toolkit>cudaMemcpy</toolkit>
+  </cuda_api_list>
+  <description><![CDATA[This sample evaluates fair call and put prices for a given set of European options by Black-Scholes formula.]]></description>
+  <devicecompilation>whole</devicecompilation>
+  <includepaths>
+    <path>./</path>
+    <path>../</path>
+    <path>../../../Common</path>
+  </includepaths>
+  <keyconcepts>
+    <concept level="basic">Computational Finance</concept>
+  </keyconcepts>
+  <keywords>
+    <keyword>CUDA</keyword>
+    <keyword>Computational Finance</keyword>
+    <keyword>option pricing</keyword>
+    <keyword>Black-Scholes</keyword>
+  </keywords>
+  <libraries>
+  </libraries>
+  <librarypaths>
+  </librarypaths>
+  <nsight_eclipse>true</nsight_eclipse>
+  <primary_file>BlackScholes.cu</primary_file>
+  <scopes>
+    <scope>1:CUDA Basic Topics</scope>
+    <scope>3:Computational Finance</scope>
+  </scopes>
+  <sm-arch>sm35</sm-arch>
+  <sm-arch>sm37</sm-arch>
+  <sm-arch>sm50</sm-arch>
+  <sm-arch>sm52</sm-arch>
+  <sm-arch>sm53</sm-arch>
+  <sm-arch>sm60</sm-arch>
+  <sm-arch>sm61</sm-arch>
+  <sm-arch>sm70</sm-arch>
+  <sm-arch>sm72</sm-arch>
+  <sm-arch>sm75</sm-arch>
+  <sm-arch>sm80</sm-arch>
+  <sm-arch>sm86</sm-arch>
+  <sm-arch>sm87</sm-arch>
+  <supported_envs>
+    <env>
+      <arch>x86_64</arch>
+      <platform>linux</platform>
+    </env>
+    <env>
+      <platform>windows7</platform>
+    </env>
+    <env>
+      <arch>x86_64</arch>
+      <platform>macosx</platform>
+    </env>
+    <env>
+      <arch>arm</arch>
+    </env>
+    <env>
+      <arch>sbsa</arch>
+    </env>
+    <env>
+      <arch>ppc64le</arch>
+      <platform>linux</platform>
+    </env>
+  </supported_envs>
+  <supported_sm_architectures>
+    <include>all</include>
+  </supported_sm_architectures>
+  <title>Black-Scholes Option Pricing</title>
+  <type>exe</type>
+  <whitepaper>doc\BlackScholes.pdf</whitepaper>
+</entry>

Samples/5_Domain_Specific/BlackScholes/README.md

@@ -0,0 +1,71 @@
+# BlackScholes - Black-Scholes Option Pricing
+
+## Description
+
+This sample evaluates fair call and put prices for a given set of European options by Black-Scholes formula.
+
+## Key Concepts
+
+Computational Finance
+
+## Supported SM Architectures
+
+[SM 3.5 ](https://developer.nvidia.com/cuda-gpus)  [SM 3.7 ](https://developer.nvidia.com/cuda-gpus)  [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)
+
+## Supported OSes
+
+Linux, Windows
+
+## Supported CPU Architecture
+
+x86_64, ppc64le, armv7l
+
+## CUDA APIs involved
+
+### [CUDA Runtime API](http://docs.nvidia.com/cuda/cuda-runtime-api/index.html)
+cudaMalloc, cudaFree, cudaDeviceSynchronize, cudaMemcpy
+
+## Prerequisites
+
+Download and install the [CUDA Toolkit 11.6](https://developer.nvidia.com/cuda-downloads) for your corresponding platform.
+
+## Build and Run
+
+### Windows
+The Windows samples are built using the Visual Studio IDE. Solution files (.sln) are provided for each supported version of Visual Studio, using the format:
+```
+*_vs<version>.sln - for Visual Studio <version>
+```
+Each individual sample has its own set of solution files in its directory:
+
+To build/examine all the samples at once, the complete solution files should be used. To build/examine a single sample, the individual sample solution files should be used.
+> **Note:** Some samples require that the Microsoft DirectX SDK (June 2010 or newer) be installed and that the VC++ directory paths are properly set up (**Tools > Options...**). Check DirectX Dependencies section for details."
+
+### Linux
+The Linux samples are built using makefiles. To use the makefiles, change the current directory to the sample directory you wish to build, and run make:
+```
+$ cd <sample_dir>
+$ make
+```
+The samples makefiles can take advantage of certain options:
+*  **TARGET_ARCH=<arch>** - cross-compile targeting a specific architecture. Allowed architectures are x86_64, ppc64le, armv7l.
+    By default, TARGET_ARCH is set to HOST_ARCH. On a x86_64 machine, not setting TARGET_ARCH is the equivalent of setting TARGET_ARCH=x86_64.<br/>
+`$ make TARGET_ARCH=x86_64` <br/> `$ make TARGET_ARCH=ppc64le` <br/> `$ make TARGET_ARCH=armv7l` <br/>
+    See [here](http://docs.nvidia.com/cuda/cuda-samples/index.html#cross-samples) for more details.
+*   **dbg=1** - build with debug symbols
+    ```
+    $ make dbg=1
+    ```
+*   **SMS="A B ..."** - override the SM architectures for which the sample will be built, where `"A B ..."` is a space-delimited list of SM architectures. For example, to generate SASS for SM 50 and SM 60, use `SMS="50 60"`.
+    ```
+    $ make SMS="50 60"
+    ```
+
+*  **HOST_COMPILER=<host_compiler>** - override the default g++ host compiler. See the [Linux Installation Guide](http://docs.nvidia.com/cuda/cuda-installation-guide-linux/index.html#system-requirements) for a list of supported host compilers.
+```
+    $ make HOST_COMPILER=g++
+```
+
+## References (for more details)
+
+[whitepaper](./doc/BlackScholes.pdf)

Samples/5_Domain_Specific/BlackScholes_nvrtc/.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
+}

Samples/5_Domain_Specific/BlackScholes_nvrtc/.vscode/extensions.json

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

Samples/5_Domain_Specific/BlackScholes_nvrtc/.vscode/launch.json

@@ -0,0 +1,10 @@
+{
+    "configurations": [
+        {
+            "name": "CUDA C++: Launch",
+            "type": "cuda-gdb",
+            "request": "launch",
+            "program": "${workspaceFolder}/BlackScholes_nvrtc"
+        }
+    ]
+}

Samples/5_Domain_Specific/BlackScholes_nvrtc/.vscode/tasks.json

@@ -0,0 +1,15 @@
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "sample",
+            "type": "shell",
+            "command": "make dbg=1",
+            "problemMatcher": ["$nvcc"],
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            }
+        }
+    ]
+}

Samples/5_Domain_Specific/BlackScholes_nvrtc/BlackScholes.cpp

@@ -0,0 +1,269 @@
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * This sample evaluates fair call and put prices for a
+ * given set of European options by Black-Scholes formula.
+ * See supplied whitepaper for more explanations.
+ */
+
+#include <cuda_runtime.h>
+#include <nvrtc_helper.h>
+
+#include <helper_functions.h>  // helper functions for string parsing
+
+////////////////////////////////////////////////////////////////////////////////
+// Process an array of optN options on CPU
+////////////////////////////////////////////////////////////////////////////////
+
+extern "C" void BlackScholesCPU(float *h_CallResult, float *h_PutResult,
+                                float *h_StockPrice, float *h_OptionStrike,
+                                float *h_OptionYears, float Riskfree,
+                                float Volatility, int optN);
+
+////////////////////////////////////////////////////////////////////////////////
+// Process an array of OptN options on GPU
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+// Helper function, returning uniformly distributed
+// random float in [low, high] range
+////////////////////////////////////////////////////////////////////////////////
+
+float RandFloat(float low, float high) {
+  float t = (float)rand() / (float)RAND_MAX;
+  return (1.0f - t) * low + t * high;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Data configuration
+////////////////////////////////////////////////////////////////////////////////
+
+const int OPT_N = 4000000;
+const int NUM_ITERATIONS = 512;
+const int OPT_SZ = OPT_N * sizeof(float);
+const float RISKFREE = 0.02f;
+const float VOLATILITY = 0.30f;
+
+#define DIV_UP(a, b) (((a) + (b)-1) / (b))
+
+////////////////////////////////////////////////////////////////////////////////
+// Main program
+////////////////////////////////////////////////////////////////////////////////
+
+int main(int argc, char **argv) {
+  // Start logs
+  printf("[%s] - Starting...\n", argv[0]);
+
+  //'h_' prefix - CPU (host) memory space
+  float
+      // Results calculated by CPU for reference
+      *h_CallResultCPU,
+      *h_PutResultCPU,
+      // CPU copy of GPU results
+      *h_CallResultGPU, *h_PutResultGPU,
+      // CPU instance of input data
+      *h_StockPrice, *h_OptionStrike, *h_OptionYears;
+
+  //'d_' prefix - GPU (device) memory space
+  CUdeviceptr
+      // Results calculated by GPU
+      d_CallResult,
+      d_PutResult,
+
+      // GPU instance of input data
+      d_StockPrice, d_OptionStrike, d_OptionYears;
+
+  double delta, ref, sum_delta, sum_ref, max_delta, L1norm, gpuTime;
+
+  StopWatchInterface *hTimer = NULL;
+  int i;
+
+  sdkCreateTimer(&hTimer);
+
+  printf("Initializing data...\n");
+  printf("...allocating CPU memory for options.\n");
+
+  h_CallResultCPU = (float *)malloc(OPT_SZ);
+  h_PutResultCPU = (float *)malloc(OPT_SZ);
+  h_CallResultGPU = (float *)malloc(OPT_SZ);
+  h_PutResultGPU = (float *)malloc(OPT_SZ);
+  h_StockPrice = (float *)malloc(OPT_SZ);
+  h_OptionStrike = (float *)malloc(OPT_SZ);
+  h_OptionYears = (float *)malloc(OPT_SZ);
+
+  char *cubin, *kernel_file;
+  size_t cubinSize;
+  kernel_file = sdkFindFilePath("BlackScholes_kernel.cuh", argv[0]);
+
+  // Compile the kernel BlackScholes_kernel.
+  compileFileToCUBIN(kernel_file, argc, argv, &cubin, &cubinSize, 0);
+  CUmodule module = loadCUBIN(cubin, argc, argv);
+
+  CUfunction kernel_addr;
+  checkCudaErrors(cuModuleGetFunction(&kernel_addr, module, "BlackScholesGPU"));
+
+  printf("...allocating GPU memory for options.\n");
+  checkCudaErrors(cuMemAlloc(&d_CallResult, OPT_SZ));
+  checkCudaErrors(cuMemAlloc(&d_PutResult, OPT_SZ));
+  checkCudaErrors(cuMemAlloc(&d_StockPrice, OPT_SZ));
+  checkCudaErrors(cuMemAlloc(&d_OptionStrike, OPT_SZ));
+  checkCudaErrors(cuMemAlloc(&d_OptionYears, OPT_SZ));
+
+  printf("...generating input data in CPU mem.\n");
+  srand(5347);
+
+  // Generate options set
+  for (i = 0; i < OPT_N; i++) {
+    h_CallResultCPU[i] = 0.0f;
+    h_PutResultCPU[i] = -1.0f;
+    h_StockPrice[i] = RandFloat(5.0f, 30.0f);
+    h_OptionStrike[i] = RandFloat(1.0f, 100.0f);
+    h_OptionYears[i] = RandFloat(0.25f, 10.0f);
+  }
+
+  printf("...copying input data to GPU mem.\n");
+  // Copy options data to GPU memory for further processing
+  checkCudaErrors(cuMemcpyHtoD(d_StockPrice, h_StockPrice, OPT_SZ));
+  checkCudaErrors(cuMemcpyHtoD(d_OptionStrike, h_OptionStrike, OPT_SZ));
+  checkCudaErrors(cuMemcpyHtoD(d_OptionYears, h_OptionYears, OPT_SZ));
+
+  printf("Data init done.\n\n");
+  printf("Executing Black-Scholes GPU kernel (%i iterations)...\n",
+         NUM_ITERATIONS);
+
+  sdkResetTimer(&hTimer);
+  sdkStartTimer(&hTimer);
+
+  dim3 cudaBlockSize(128, 1, 1);
+  dim3 cudaGridSize(DIV_UP(OPT_N / 2, 128), 1, 1);
+
+  float risk = RISKFREE;
+  float volatility = VOLATILITY;
+  int optval = OPT_N;
+
+  void *arr[] = {(void *)&d_CallResult,  (void *)&d_PutResult,
+                 (void *)&d_StockPrice,  (void *)&d_OptionStrike,
+                 (void *)&d_OptionYears, (void *)&risk,
+                 (void *)&volatility,    (void *)&optval};
+
+  for (i = 0; i < NUM_ITERATIONS; i++) {
+    checkCudaErrors(cuLaunchKernel(kernel_addr, cudaGridSize.x, cudaGridSize.y,
+                                   cudaGridSize.z, /* grid dim */
+                                   cudaBlockSize.x, cudaBlockSize.y,
+                                   cudaBlockSize.z, /* block dim */
+                                   0, 0,            /* shared mem, stream */
+                                   &arr[0],         /* arguments */
+                                   0));
+  }
+
+  checkCudaErrors(cuCtxSynchronize());
+
+  sdkStopTimer(&hTimer);
+  gpuTime = sdkGetTimerValue(&hTimer) / NUM_ITERATIONS;
+
+  // Both call and put is calculated
+  printf("Options count             : %i     \n", 2 * OPT_N);
+  printf("BlackScholesGPU() time    : %f msec\n", gpuTime);
+  printf("Effective memory bandwidth: %f GB/s\n",
+         ((double)(5 * OPT_N * sizeof(float)) * 1E-9) / (gpuTime * 1E-3));
+  printf("Gigaoptions per second    : %f     \n\n",
+         ((double)(2 * OPT_N) * 1E-9) / (gpuTime * 1E-3));
+  printf(
+      "BlackScholes, Throughput = %.4f GOptions/s, Time = %.5f s, Size = %u "
+      "options, NumDevsUsed = %u, Workgroup = %u\n",
+      (((double)(2.0 * OPT_N) * 1.0E-9) / (gpuTime * 1.0E-3)), gpuTime * 1e-3,
+      (2 * OPT_N), 1, 128);
+
+  printf("\nReading back GPU results...\n");
+
+  // Read back GPU results to compare them to CPU results
+  checkCudaErrors(cuMemcpyDtoH(h_CallResultGPU, d_CallResult, OPT_SZ));
+  checkCudaErrors(cuMemcpyDtoH(h_PutResultGPU, d_PutResult, OPT_SZ));
+
+  printf("Checking the results...\n");
+  printf("...running CPU calculations.\n\n");
+
+  // Calculate options values on CPU
+  BlackScholesCPU(h_CallResultCPU, h_PutResultCPU, h_StockPrice, h_OptionStrike,
+                  h_OptionYears, RISKFREE, VOLATILITY, OPT_N);
+
+  printf("Comparing the results...\n");
+  // Calculate max absolute difference and L1 distance
+  // between CPU and GPU results
+  sum_delta = 0;
+  sum_ref = 0;
+  max_delta = 0;
+
+  for (i = 0; i < OPT_N; i++) {
+    ref = h_CallResultCPU[i];
+    delta = fabs(h_CallResultCPU[i] - h_CallResultGPU[i]);
+
+    if (delta > max_delta) {
+      max_delta = delta;
+    }
+
+    sum_delta += delta;
+    sum_ref += fabs(ref);
+  }
+
+  L1norm = sum_delta / sum_ref;
+  printf("L1 norm: %E\n", L1norm);
+  printf("Max absolute error: %E\n\n", max_delta);
+
+  printf("Shutting down...\n");
+  printf("...releasing GPU memory.\n");
+
+  checkCudaErrors(cuMemFree(d_OptionYears));
+  checkCudaErrors(cuMemFree(d_OptionStrike));
+  checkCudaErrors(cuMemFree(d_StockPrice));
+  checkCudaErrors(cuMemFree(d_PutResult));
+  checkCudaErrors(cuMemFree(d_CallResult));
+
+  printf("...releasing CPU memory.\n");
+
+  free(h_OptionYears);
+  free(h_OptionStrike);
+  free(h_StockPrice);
+  free(h_PutResultGPU);
+  free(h_CallResultGPU);
+  free(h_PutResultCPU);
+  free(h_CallResultCPU);
+
+  sdkDeleteTimer(&hTimer);
+  printf("Shutdown done.\n");
+
+  printf("\n[%s] - Test Summary\n", argv[0]);
+
+  if (L1norm > 1e-6) {
+    printf("Test failed!\n");
+    exit(EXIT_FAILURE);
+  }
+
+  printf("Test passed\n");
+  exit(EXIT_SUCCESS);
+}

Samples/5_Domain_Specific/BlackScholes_nvrtc/BlackScholes_gold.cpp

@@ -0,0 +1,88 @@
+/* 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 <math.h>
+
+///////////////////////////////////////////////////////////////////////////////
+// Polynomial approximation of cumulative normal distribution function
+///////////////////////////////////////////////////////////////////////////////
+
+static double CND(double d) {
+  const double A1 = 0.31938153;
+  const double A2 = -0.356563782;
+  const double A3 = 1.781477937;
+  const double A4 = -1.821255978;
+  const double A5 = 1.330274429;
+  const double RSQRT2PI = 0.39894228040143267793994605993438;
+
+  double K = 1.0 / (1.0 + 0.2316419 * fabs(d));
+
+  double cnd = RSQRT2PI * exp(-0.5 * d * d) *
+               (K * (A1 + K * (A2 + K * (A3 + K * (A4 + K * A5)))));
+
+  if (d > 0) cnd = 1.0 - cnd;
+
+  return cnd;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Black-Scholes formula for both call and put
+///////////////////////////////////////////////////////////////////////////////
+static void BlackScholesBodyCPU(float &callResult, float &putResult,
+                                float Sf,  // Stock price
+                                float Xf,  // Option strike
+                                float Tf,  // Option years
+                                float Rf,  // Riskless rate
+                                float Vf  // Volatility rate
+                                ) {
+  double S = Sf, X = Xf, T = Tf, R = Rf, V = Vf;
+  double sqrtT = sqrt(T);
+  double d1 = (log(S / X) + (R + 0.5 * V * V) * T) / (V * sqrtT);
+  double d2 = d1 - V * sqrtT;
+  double CNDD1 = CND(d1);
+  double CNDD2 = CND(d2);
+
+  // Calculate Call and Put simultaneously
+  double expRT = exp(-R * T);
+
+  callResult = (float)(S * CNDD1 - X * expRT * CNDD2);
+  putResult = (float)(X * expRT * (1.0 - CNDD2) - S * (1.0 - CNDD1));
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Process an array of optN options
+////////////////////////////////////////////////////////////////////////////////
+
+extern "C" void BlackScholesCPU(float *h_CallResult, float *h_PutResult,
+                                float *h_StockPrice, float *h_OptionStrike,
+                                float *h_OptionYears, float Riskfree,
+                                float Volatility, int optN) {
+  for (int opt = 0; opt < optN; opt++)
+    BlackScholesBodyCPU(h_CallResult[opt], h_PutResult[opt], h_StockPrice[opt],
+                        h_OptionStrike[opt], h_OptionYears[opt], Riskfree,
+                        Volatility);
+}

Samples/5_Domain_Specific/BlackScholes_nvrtc/BlackScholes_kernel.cuh

@@ -0,0 +1,103 @@
+/* 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.
+ */
+
+///////////////////////////////////////////////////////////////////////////////
+// Polynomial approximation of cumulative normal distribution function
+///////////////////////////////////////////////////////////////////////////////
+
+__device__ inline float cndGPU(float d) {
+  const float A1 = 0.31938153f;
+  const float A2 = -0.356563782f;
+  const float A3 = 1.781477937f;
+  const float A4 = -1.821255978f;
+  const float A5 = 1.330274429f;
+  const float RSQRT2PI = 0.39894228040143267793994605993438f;
+
+  float K = __fdividef(1.0f, (1.0f + 0.2316419f * fabsf(d)));
+
+  float cnd = RSQRT2PI * __expf(-0.5f * d * d) *
+              (K * (A1 + K * (A2 + K * (A3 + K * (A4 + K * A5)))));
+
+  if (d > 0) cnd = 1.0f - cnd;
+
+  return cnd;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Black-Scholes formula for both call and put
+///////////////////////////////////////////////////////////////////////////////
+__device__ inline void BlackScholesBodyGPU(float &CallResult, float &PutResult,
+                                           float S,  // Stock price
+                                           float X,  // Option strike
+                                           float T,  // Option years
+                                           float R,  // Riskless rate
+                                           float V  // Volatility rate
+                                           ) {
+  float sqrtT, expRT;
+  float d1, d2, CNDD1, CNDD2;
+
+  sqrtT = __fdividef(1.0F, rsqrtf(T));
+  d1 = __fdividef(__logf(S / X) + (R + 0.5f * V * V) * T, V * sqrtT);
+  d2 = d1 - V * sqrtT;
+
+  CNDD1 = cndGPU(d1);
+  CNDD2 = cndGPU(d2);
+
+  // Calculate Call and Put simultaneously
+  expRT = __expf(-R * T);
+  CallResult = S * CNDD1 - X * expRT * CNDD2;
+  PutResult = X * expRT * (1.0f - CNDD2) - S * (1.0f - CNDD1);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Process an array of optN options on GPU
+////////////////////////////////////////////////////////////////////////////////
+extern "C" __launch_bounds__(128) __global__
+    void BlackScholesGPU(float2 *__restrict d_CallResult,
+                         float2 *__restrict d_PutResult,
+                         float2 *__restrict d_StockPrice,
+                         float2 *__restrict d_OptionStrike,
+                         float2 *__restrict d_OptionYears, float Riskfree,
+                         float Volatility, int optN) {
+  ////Thread index
+  const int opt = blockDim.x * blockIdx.x + threadIdx.x;
+
+  // Calculating 2 options per thread to increase ILP (instruction level
+  // parallelism)
+  if (opt < (optN / 2)) {
+    float callResult1, callResult2;
+    float putResult1, putResult2;
+    BlackScholesBodyGPU(callResult1, putResult1, d_StockPrice[opt].x,
+                        d_OptionStrike[opt].x, d_OptionYears[opt].x, Riskfree,
+                        Volatility);
+    BlackScholesBodyGPU(callResult2, putResult2, d_StockPrice[opt].y,
+                        d_OptionStrike[opt].y, d_OptionYears[opt].y, Riskfree,
+                        Volatility);
+    d_CallResult[opt] = make_float2(callResult1, callResult2);
+    d_PutResult[opt] = make_float2(putResult1, putResult2);
+  }
+}

Samples/5_Domain_Specific/BlackScholes_nvrtc/BlackScholes_nvrtc_vs2017.sln

@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2017
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "BlackScholes_nvrtc", "BlackScholes_nvrtc_vs2017.vcxproj", "{997E0757-EA74-4A4E-A0FC-47D8C8831A15}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Release|x64 = Release|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Debug|x64.ActiveCfg = Debug|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Debug|x64.Build.0 = Debug|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Release|x64.ActiveCfg = Release|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Release|x64.Build.0 = Release|x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

Samples/5_Domain_Specific/BlackScholes_nvrtc/BlackScholes_nvrtc_vs2017.vcxproj

@@ -0,0 +1,113 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <CUDAPropsPath Condition="'$(CUDAPropsPath)'==''">$(VCTargetsPath)\BuildCustomizations</CUDAPropsPath>
+  </PropertyGroup>
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{997E0757-EA74-4A4E-A0FC-47D8C8831A15}</ProjectGuid>
+    <RootNamespace>BlackScholes_nvrtc_vs2017</RootNamespace>
+    <ProjectName>BlackScholes_nvrtc</ProjectName>
+    <CudaToolkitCustomDir />
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(WindowsTargetPlatformVersion)'==''">
+    <LatestTargetPlatformVersion>$([Microsoft.Build.Utilities.ToolLocationHelper]::GetLatestSDKTargetPlatformVersion('Windows', '10.0'))</LatestTargetPlatformVersion>
+    <WindowsTargetPlatformVersion Condition="'$(WindowsTargetPlatformVersion)' == ''">$(LatestTargetPlatformVersion)</WindowsTargetPlatformVersion>
+    <TargetPlatformVersion>$(WindowsTargetPlatformVersion)</TargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup>
+    <ConfigurationType>Application</ConfigurationType>
+    <CharacterSet>MultiByte</CharacterSet>
+    <PlatformToolset>v141</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Debug'">
+    <UseDebugLibraries>true</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Release'">
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.6.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <IntDir>$(Platform)/$(Configuration)/</IntDir>
+    <IncludePath>$(IncludePath)</IncludePath>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules />
+    <CodeAnalysisRuleAssemblies />
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Platform)'=='x64'">
+    <OutDir>../../../bin/win64/$(Configuration)/</OutDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;_MBCS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>./;$(CudaToolkitDir)/include;../../../Common;$(CudaToolkitIncludeDir);$(CUDA_PATH)/include;</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <AdditionalDependencies>cuda.lib;nvrtc.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>$(CudaToolkitLibDir);</AdditionalLibraryDirectories>
+      <OutputFile>$(OutDir)/BlackScholes_nvrtc.exe</OutputFile>
+    </Link>
+    <CudaCompile>
+      <CodeGeneration></CodeGeneration>
+      <AdditionalOptions>-Xcompiler "/wd 4819"  --threads 0 </AdditionalOptions>
+      <Include>./;../../../Common</Include>
+      <Defines>WIN32</Defines>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Debug'">
+    <ClCompile>
+      <Optimization>Disabled</Optimization>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
+    </Link>
+    <CudaCompile>
+      <Runtime>MTd</Runtime>
+      <TargetMachinePlatform>64</TargetMachinePlatform>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Release'">
+    <ClCompile>
+      <Optimization>MaxSpeed</Optimization>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>false</GenerateDebugInformation>
+      <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
+    </Link>
+    <CudaCompile>
+      <Runtime>MT</Runtime>
+      <TargetMachinePlatform>64</TargetMachinePlatform>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="BlackScholes.cpp" />
+    <ClCompile Include="BlackScholes_gold.cpp" />
+    <None Include="BlackScholes_kernel.cuh" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.6.targets" />
+  </ImportGroup>
+</Project>

Samples/5_Domain_Specific/BlackScholes_nvrtc/BlackScholes_nvrtc_vs2019.sln

@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2019
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "BlackScholes_nvrtc", "BlackScholes_nvrtc_vs2019.vcxproj", "{997E0757-EA74-4A4E-A0FC-47D8C8831A15}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Release|x64 = Release|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Debug|x64.ActiveCfg = Debug|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Debug|x64.Build.0 = Debug|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Release|x64.ActiveCfg = Release|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Release|x64.Build.0 = Release|x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

Samples/5_Domain_Specific/BlackScholes_nvrtc/BlackScholes_nvrtc_vs2019.vcxproj

@@ -0,0 +1,109 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <CUDAPropsPath Condition="'$(CUDAPropsPath)'==''">$(VCTargetsPath)\BuildCustomizations</CUDAPropsPath>
+  </PropertyGroup>
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{997E0757-EA74-4A4E-A0FC-47D8C8831A15}</ProjectGuid>
+    <RootNamespace>BlackScholes_nvrtc_vs2019</RootNamespace>
+    <ProjectName>BlackScholes_nvrtc</ProjectName>
+    <CudaToolkitCustomDir />
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup>
+    <ConfigurationType>Application</ConfigurationType>
+    <CharacterSet>MultiByte</CharacterSet>
+    <PlatformToolset>v142</PlatformToolset>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Debug'">
+    <UseDebugLibraries>true</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Release'">
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.6.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <IntDir>$(Platform)/$(Configuration)/</IntDir>
+    <IncludePath>$(IncludePath)</IncludePath>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules />
+    <CodeAnalysisRuleAssemblies />
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Platform)'=='x64'">
+    <OutDir>../../../bin/win64/$(Configuration)/</OutDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;_MBCS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>./;$(CudaToolkitDir)/include;../../../Common;$(CudaToolkitIncludeDir);$(CUDA_PATH)/include;</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <AdditionalDependencies>cuda.lib;nvrtc.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>$(CudaToolkitLibDir);</AdditionalLibraryDirectories>
+      <OutputFile>$(OutDir)/BlackScholes_nvrtc.exe</OutputFile>
+    </Link>
+    <CudaCompile>
+      <CodeGeneration></CodeGeneration>
+      <AdditionalOptions>-Xcompiler "/wd 4819"  --threads 0 </AdditionalOptions>
+      <Include>./;../../../Common</Include>
+      <Defines>WIN32</Defines>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Debug'">
+    <ClCompile>
+      <Optimization>Disabled</Optimization>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
+    </Link>
+    <CudaCompile>
+      <Runtime>MTd</Runtime>
+      <TargetMachinePlatform>64</TargetMachinePlatform>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Release'">
+    <ClCompile>
+      <Optimization>MaxSpeed</Optimization>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>false</GenerateDebugInformation>
+      <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
+    </Link>
+    <CudaCompile>
+      <Runtime>MT</Runtime>
+      <TargetMachinePlatform>64</TargetMachinePlatform>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="BlackScholes.cpp" />
+    <ClCompile Include="BlackScholes_gold.cpp" />
+    <None Include="BlackScholes_kernel.cuh" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.6.targets" />
+  </ImportGroup>
+</Project>

Samples/5_Domain_Specific/BlackScholes_nvrtc/BlackScholes_nvrtc_vs2022.sln

@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2022
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "BlackScholes_nvrtc", "BlackScholes_nvrtc_vs2022.vcxproj", "{997E0757-EA74-4A4E-A0FC-47D8C8831A15}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Release|x64 = Release|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Debug|x64.ActiveCfg = Debug|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Debug|x64.Build.0 = Debug|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Release|x64.ActiveCfg = Release|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Release|x64.Build.0 = Release|x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

Samples/5_Domain_Specific/BlackScholes_nvrtc/BlackScholes_nvrtc_vs2022.vcxproj

@@ -0,0 +1,109 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <CUDAPropsPath Condition="'$(CUDAPropsPath)'==''">$(VCTargetsPath)\BuildCustomizations</CUDAPropsPath>
+  </PropertyGroup>
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{997E0757-EA74-4A4E-A0FC-47D8C8831A15}</ProjectGuid>
+    <RootNamespace>BlackScholes_nvrtc_vs2022</RootNamespace>
+    <ProjectName>BlackScholes_nvrtc</ProjectName>
+    <CudaToolkitCustomDir />
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup>
+    <ConfigurationType>Application</ConfigurationType>
+    <CharacterSet>MultiByte</CharacterSet>
+    <PlatformToolset>v143</PlatformToolset>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Debug'">
+    <UseDebugLibraries>true</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Release'">
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.6.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <IntDir>$(Platform)/$(Configuration)/</IntDir>
+    <IncludePath>$(IncludePath)</IncludePath>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules />
+    <CodeAnalysisRuleAssemblies />
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Platform)'=='x64'">
+    <OutDir>../../../bin/win64/$(Configuration)/</OutDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;_MBCS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>./;$(CudaToolkitDir)/include;../../../Common;$(CudaToolkitIncludeDir);$(CUDA_PATH)/include;</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <AdditionalDependencies>cuda.lib;nvrtc.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>$(CudaToolkitLibDir);</AdditionalLibraryDirectories>
+      <OutputFile>$(OutDir)/BlackScholes_nvrtc.exe</OutputFile>
+    </Link>
+    <CudaCompile>
+      <CodeGeneration></CodeGeneration>
+      <AdditionalOptions>-Xcompiler "/wd 4819"  --threads 0 </AdditionalOptions>
+      <Include>./;../../../Common</Include>
+      <Defines>WIN32</Defines>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Debug'">
+    <ClCompile>
+      <Optimization>Disabled</Optimization>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
+    </Link>
+    <CudaCompile>
+      <Runtime>MTd</Runtime>
+      <TargetMachinePlatform>64</TargetMachinePlatform>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Release'">
+    <ClCompile>
+      <Optimization>MaxSpeed</Optimization>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>false</GenerateDebugInformation>
+      <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
+    </Link>
+    <CudaCompile>
+      <Runtime>MT</Runtime>
+      <TargetMachinePlatform>64</TargetMachinePlatform>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="BlackScholes.cpp" />
+    <ClCompile Include="BlackScholes_gold.cpp" />
+    <None Include="BlackScholes_kernel.cuh" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.6.targets" />
+  </ImportGroup>
+</Project>

Samples/5_Domain_Specific/BlackScholes_nvrtc/Makefile

@@ -0,0 +1,395 @@
+################################################################################
+# 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.
+#
+################################################################################
+#
+# Makefile project only supported on Mac OS X and Linux Platforms)
+#
+################################################################################
+
+# Location of the CUDA Toolkit
+CUDA_PATH ?= /usr/local/cuda
+
+##############################
+# start deprecated interface #
+##############################
+ifeq ($(x86_64),1)
+    $(info WARNING - x86_64 variable has been deprecated)
+    $(info WARNING - please use TARGET_ARCH=x86_64 instead)
+    TARGET_ARCH ?= x86_64
+endif
+ifeq ($(ARMv7),1)
+    $(info WARNING - ARMv7 variable has been deprecated)
+    $(info WARNING - please use TARGET_ARCH=armv7l instead)
+    TARGET_ARCH ?= armv7l
+endif
+ifeq ($(aarch64),1)
+    $(info WARNING - aarch64 variable has been deprecated)
+    $(info WARNING - please use TARGET_ARCH=aarch64 instead)
+    TARGET_ARCH ?= aarch64
+endif
+ifeq ($(ppc64le),1)
+    $(info WARNING - ppc64le variable has been deprecated)
+    $(info WARNING - please use TARGET_ARCH=ppc64le instead)
+    TARGET_ARCH ?= ppc64le
+endif
+ifneq ($(GCC),)
+    $(info WARNING - GCC variable has been deprecated)
+    $(info WARNING - please use HOST_COMPILER=$(GCC) instead)
+    HOST_COMPILER ?= $(GCC)
+endif
+ifneq ($(abi),)
+    $(error ERROR - abi variable has been removed)
+endif
+############################
+# end deprecated interface #
+############################
+
+# architecture
+HOST_ARCH   := $(shell uname -m)
+TARGET_ARCH ?= $(HOST_ARCH)
+ifneq (,$(filter $(TARGET_ARCH),x86_64 aarch64 sbsa ppc64le armv7l))
+    ifneq ($(TARGET_ARCH),$(HOST_ARCH))
+        ifneq (,$(filter $(TARGET_ARCH),x86_64 aarch64 sbsa ppc64le))
+            TARGET_SIZE := 64
+        else ifneq (,$(filter $(TARGET_ARCH),armv7l))
+            TARGET_SIZE := 32
+        endif
+    else
+        TARGET_SIZE := $(shell getconf LONG_BIT)
+    endif
+else
+    $(error ERROR - unsupported value $(TARGET_ARCH) for TARGET_ARCH!)
+endif
+
+# sbsa and aarch64 systems look similar. Need to differentiate them at host level for now.
+ifeq ($(HOST_ARCH),aarch64)
+    ifeq ($(CUDA_PATH)/targets/sbsa-linux,$(shell ls -1d $(CUDA_PATH)/targets/sbsa-linux 2>/dev/null))
+        HOST_ARCH := sbsa
+        TARGET_ARCH := sbsa
+    endif
+endif
+
+ifneq ($(TARGET_ARCH),$(HOST_ARCH))
+    ifeq (,$(filter $(HOST_ARCH)-$(TARGET_ARCH),aarch64-armv7l x86_64-armv7l x86_64-aarch64 x86_64-sbsa x86_64-ppc64le))
+        $(error ERROR - cross compiling from $(HOST_ARCH) to $(TARGET_ARCH) is not supported!)
+    endif
+endif
+
+# When on native aarch64 system with userspace of 32-bit, change TARGET_ARCH to armv7l
+ifeq ($(HOST_ARCH)-$(TARGET_ARCH)-$(TARGET_SIZE),aarch64-aarch64-32)
+    TARGET_ARCH = armv7l
+endif
+
+# operating system
+HOST_OS   := $(shell uname -s 2>/dev/null | tr "[:upper:]" "[:lower:]")
+TARGET_OS ?= $(HOST_OS)
+ifeq (,$(filter $(TARGET_OS),linux darwin qnx android))
+    $(error ERROR - unsupported value $(TARGET_OS) for TARGET_OS!)
+endif
+
+# host compiler
+ifeq ($(TARGET_OS),darwin)
+    ifeq ($(shell expr `xcodebuild -version | grep -i xcode | awk '{print $$2}' | cut -d'.' -f1` \>= 5),1)
+        HOST_COMPILER ?= clang++
+    endif
+else ifneq ($(TARGET_ARCH),$(HOST_ARCH))
+    ifeq ($(HOST_ARCH)-$(TARGET_ARCH),x86_64-armv7l)
+        ifeq ($(TARGET_OS),linux)
+            HOST_COMPILER ?= arm-linux-gnueabihf-g++
+        else ifeq ($(TARGET_OS),qnx)
+            ifeq ($(QNX_HOST),)
+                $(error ERROR - QNX_HOST must be passed to the QNX host toolchain)
+            endif
+            ifeq ($(QNX_TARGET),)
+                $(error ERROR - QNX_TARGET must be passed to the QNX target toolchain)
+            endif
+            export QNX_HOST
+            export QNX_TARGET
+            HOST_COMPILER ?= $(QNX_HOST)/usr/bin/arm-unknown-nto-qnx6.6.0eabi-g++
+        else ifeq ($(TARGET_OS),android)
+            HOST_COMPILER ?= arm-linux-androideabi-g++
+        endif
+    else ifeq ($(TARGET_ARCH),aarch64)
+        ifeq ($(TARGET_OS), linux)
+            HOST_COMPILER ?= aarch64-linux-gnu-g++
+        else ifeq ($(TARGET_OS),qnx)
+            ifeq ($(QNX_HOST),)
+                $(error ERROR - QNX_HOST must be passed to the QNX host toolchain)
+            endif
+            ifeq ($(QNX_TARGET),)
+                $(error ERROR - QNX_TARGET must be passed to the QNX target toolchain)
+            endif
+            export QNX_HOST
+            export QNX_TARGET
+            HOST_COMPILER ?= $(QNX_HOST)/usr/bin/q++
+        else ifeq ($(TARGET_OS), android)
+            HOST_COMPILER ?= aarch64-linux-android-clang++
+        endif
+    else ifeq ($(TARGET_ARCH),sbsa)
+        HOST_COMPILER ?= aarch64-linux-gnu-g++
+    else ifeq ($(TARGET_ARCH),ppc64le)
+        HOST_COMPILER ?= powerpc64le-linux-gnu-g++
+    endif
+endif
+HOST_COMPILER ?= g++
+NVCC          := $(CUDA_PATH)/bin/nvcc -ccbin $(HOST_COMPILER)
+
+# internal flags
+NVCCFLAGS   := -m${TARGET_SIZE}
+CCFLAGS     :=
+LDFLAGS     :=
+
+# build flags
+ifeq ($(TARGET_OS),darwin)
+    LDFLAGS += -rpath $(CUDA_PATH)/lib
+    CCFLAGS += -arch $(HOST_ARCH)
+else ifeq ($(HOST_ARCH)-$(TARGET_ARCH)-$(TARGET_OS),x86_64-armv7l-linux)
+    LDFLAGS += --dynamic-linker=/lib/ld-linux-armhf.so.3
+    CCFLAGS += -mfloat-abi=hard
+else ifeq ($(TARGET_OS),android)
+    LDFLAGS += -pie
+    CCFLAGS += -fpie -fpic -fexceptions
+endif
+
+ifneq ($(TARGET_ARCH),$(HOST_ARCH))
+    ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-linux)
+        ifneq ($(TARGET_FS),)
+            GCCVERSIONLTEQ46 := $(shell expr `$(HOST_COMPILER) -dumpversion` \<= 4.6)
+            ifeq ($(GCCVERSIONLTEQ46),1)
+                CCFLAGS += --sysroot=$(TARGET_FS)
+            endif
+            LDFLAGS += --sysroot=$(TARGET_FS)
+            LDFLAGS += -rpath-link=$(TARGET_FS)/lib
+            LDFLAGS += -rpath-link=$(TARGET_FS)/usr/lib
+            LDFLAGS += -rpath-link=$(TARGET_FS)/usr/lib/arm-linux-gnueabihf
+        endif
+    endif
+    ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-linux)
+        ifneq ($(TARGET_FS),)
+            GCCVERSIONLTEQ46 := $(shell expr `$(HOST_COMPILER) -dumpversion` \<= 4.6)
+            ifeq ($(GCCVERSIONLTEQ46),1)
+                CCFLAGS += --sysroot=$(TARGET_FS)
+            endif
+            LDFLAGS += --sysroot=$(TARGET_FS)
+            LDFLAGS += -rpath-link=$(TARGET_FS)/lib -L$(TARGET_FS)/lib
+            LDFLAGS += -rpath-link=$(TARGET_FS)/lib/aarch64-linux-gnu -L$(TARGET_FS)/lib/aarch64-linux-gnu
+            LDFLAGS += -rpath-link=$(TARGET_FS)/usr/lib -L$(TARGET_FS)/usr/lib
+            LDFLAGS += -rpath-link=$(TARGET_FS)/usr/lib/aarch64-linux-gnu -L$(TARGET_FS)/usr/lib/aarch64-linux-gnu
+            LDFLAGS += --unresolved-symbols=ignore-in-shared-libs
+            CCFLAGS += -isystem=$(TARGET_FS)/usr/include -I$(TARGET_FS)/usr/include -I$(TARGET_FS)/usr/include/libdrm
+            CCFLAGS += -isystem=$(TARGET_FS)/usr/include/aarch64-linux-gnu -I$(TARGET_FS)/usr/include/aarch64-linux-gnu
+        endif
+    endif
+    ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-qnx)
+        NVCCFLAGS += -D_QNX_SOURCE
+        NVCCFLAGS += --qpp-config 8.3.0,gcc_ntoaarch64le
+        CCFLAGS += -DWIN_INTERFACE_CUSTOM -I/usr/include/aarch64-qnx-gnu
+        LDFLAGS += -lsocket
+        LDFLAGS += -L/usr/lib/aarch64-qnx-gnu
+        CCFLAGS += "-Wl\,-rpath-link\,/usr/lib/aarch64-qnx-gnu"
+        ifdef TARGET_OVERRIDE
+            LDFLAGS += -lslog2
+        endif
+
+        ifneq ($(TARGET_FS),)
+            LDFLAGS += -L$(TARGET_FS)/usr/lib
+            CCFLAGS += "-Wl\,-rpath-link\,$(TARGET_FS)/usr/lib"
+            LDFLAGS += -L$(TARGET_FS)/usr/libnvidia
+            CCFLAGS += "-Wl\,-rpath-link\,$(TARGET_FS)/usr/libnvidia"
+            CCFLAGS += -I$(TARGET_FS)/../include
+        endif
+    endif
+endif
+
+ifdef TARGET_OVERRIDE # cuda toolkit targets override
+    NVCCFLAGS += -target-dir $(TARGET_OVERRIDE)
+endif
+
+# Install directory of different arch
+CUDA_INSTALL_TARGET_DIR :=
+ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-linux)
+    CUDA_INSTALL_TARGET_DIR = targets/armv7-linux-gnueabihf/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-linux)
+    CUDA_INSTALL_TARGET_DIR = targets/aarch64-linux/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),sbsa-linux)
+    CUDA_INSTALL_TARGET_DIR = targets/sbsa-linux/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-android)
+    CUDA_INSTALL_TARGET_DIR = targets/armv7-linux-androideabi/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-android)
+    CUDA_INSTALL_TARGET_DIR = targets/aarch64-linux-androideabi/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-qnx)
+    CUDA_INSTALL_TARGET_DIR = targets/ARMv7-linux-QNX/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-qnx)
+    CUDA_INSTALL_TARGET_DIR = targets/aarch64-qnx/
+else ifeq ($(TARGET_ARCH),ppc64le)
+    CUDA_INSTALL_TARGET_DIR = targets/ppc64le-linux/
+endif
+
+# Debug build flags
+ifeq ($(dbg),1)
+      NVCCFLAGS += -g -G
+      BUILD_TYPE := debug
+else
+      BUILD_TYPE := release
+endif
+
+ALL_CCFLAGS :=
+ALL_CCFLAGS += $(NVCCFLAGS)
+ALL_CCFLAGS += $(EXTRA_NVCCFLAGS)
+ALL_CCFLAGS += $(addprefix -Xcompiler ,$(CCFLAGS))
+ALL_CCFLAGS += $(addprefix -Xcompiler ,$(EXTRA_CCFLAGS))
+
+UBUNTU = $(shell lsb_release -i -s 2>/dev/null | grep -i ubuntu)
+
+SAMPLE_ENABLED := 1
+
+# This sample is not supported on ARMv7
+ifeq ($(TARGET_ARCH),armv7l)
+  $(info >>> WARNING - BlackScholes_nvrtc is not supported on ARMv7 - waiving sample <<<)
+  SAMPLE_ENABLED := 0
+endif
+
+ALL_LDFLAGS :=
+ALL_LDFLAGS += $(ALL_CCFLAGS)
+ALL_LDFLAGS += $(addprefix -Xlinker ,$(LDFLAGS))
+ALL_LDFLAGS += $(addprefix -Xlinker ,$(EXTRA_LDFLAGS))
+
+# Common includes and paths for CUDA
+INCLUDES  := -I../../../Common
+LIBRARIES :=
+
+################################################################################
+
+# libNVRTC specific libraries
+ifeq ($(TARGET_OS),darwin)
+ LDFLAGS += -L$(CUDA_PATH)/lib -F/Library/Frameworks -framework CUDA
+endif
+
+ifeq ($(TARGET_OS),darwin)
+  ALL_LDFLAGS += -Xcompiler -F/Library/Frameworks -Xlinker -framework -Xlinker CUDA
+else
+  ifeq ($(TARGET_ARCH),x86_64)
+    CUDA_SEARCH_PATH ?= $(CUDA_PATH)/lib64/stubs
+    CUDA_SEARCH_PATH += $(CUDA_PATH)/lib/stubs
+    CUDA_SEARCH_PATH += $(CUDA_PATH)/targets/x86_64-linux/lib/stubs
+  endif
+
+  ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-linux)
+    CUDA_SEARCH_PATH ?= $(CUDA_PATH)/targets/armv7-linux-gnueabihf/lib/stubs
+  endif
+
+  ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-linux)
+    CUDA_SEARCH_PATH ?= $(CUDA_PATH)/targets/aarch64-linux/lib/stubs
+  endif
+
+  ifeq ($(TARGET_ARCH)-$(TARGET_OS),sbsa-linux)
+    CUDA_SEARCH_PATH ?= $(CUDA_PATH)/targets/sbsa-linux/lib/stubs
+  endif
+
+  ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-android)
+    CUDA_SEARCH_PATH ?= $(CUDA_PATH)/targets/armv7-linux-androideabi/lib/stubs
+  endif
+
+  ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-android)
+    CUDA_SEARCH_PATH ?= $(CUDA_PATH)/targets/aarch64-linux-androideabi/lib/stubs
+  endif
+
+  ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-qnx)
+    CUDA_SEARCH_PATH ?= $(CUDA_PATH)/targets/ARMv7-linux-QNX/lib/stubs
+  endif
+
+  ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-qnx)
+    CUDA_SEARCH_PATH ?= $(CUDA_PATH)/targets/aarch64-qnx/lib/stubs
+    ifdef TARGET_OVERRIDE
+        CUDA_SEARCH_PATH := $(CUDA_PATH)/targets/$(TARGET_OVERRIDE)/lib/stubs
+    endif
+  endif
+
+  ifeq ($(TARGET_ARCH),ppc64le)
+    CUDA_SEARCH_PATH ?= $(CUDA_PATH)/targets/ppc64le-linux/lib/stubs
+  endif
+
+  ifeq ($(HOST_ARCH),ppc64le)
+    CUDA_SEARCH_PATH += $(CUDA_PATH)/lib64/stubs
+  endif
+
+  CUDALIB ?= $(shell find -L $(CUDA_SEARCH_PATH) -maxdepth 1 -name libcuda.so 2> /dev/null)
+  ifeq ("$(CUDALIB)","")
+    $(info >>> WARNING - libcuda.so not found, CUDA Driver is not installed.  Please re-install the driver. <<<)
+    SAMPLE_ENABLED := 0
+  else
+    CUDALIB := $(shell echo $(CUDALIB) | sed "s/ .*//" | sed "s/\/libcuda.so//" )
+    LIBRARIES += -L$(CUDALIB) -lcuda
+  endif
+endif
+
+ALL_CCFLAGS += --threads 0 --std=c++11
+
+INCLUDES += -I$(CUDA_PATH)/include
+
+LIBRARIES += -lnvrtc
+
+ifeq ($(SAMPLE_ENABLED),0)
+EXEC ?= @echo "[@]"
+endif
+
+################################################################################
+
+# Target rules
+all: build
+
+build: BlackScholes_nvrtc
+
+check.deps:
+ifeq ($(SAMPLE_ENABLED),0)
+	@echo "Sample will be waived due to the above missing dependencies"
+else
+	@echo "Sample is ready - all dependencies have been met"
+endif
+
+BlackScholes.o:BlackScholes.cpp
+	$(EXEC) $(NVCC) $(INCLUDES) $(ALL_CCFLAGS) $(GENCODE_FLAGS) -o $@ -c $<
+
+BlackScholes_gold.o:BlackScholes_gold.cpp
+	$(EXEC) $(NVCC) $(INCLUDES) $(ALL_CCFLAGS) $(GENCODE_FLAGS) -o $@ -c $<
+
+BlackScholes_nvrtc: BlackScholes.o BlackScholes_gold.o
+	$(EXEC) $(NVCC) $(ALL_LDFLAGS) $(GENCODE_FLAGS) -o $@ $+ $(LIBRARIES)
+	$(EXEC) mkdir -p ../../../bin/$(TARGET_ARCH)/$(TARGET_OS)/$(BUILD_TYPE)
+	$(EXEC) cp $@ ../../../bin/$(TARGET_ARCH)/$(TARGET_OS)/$(BUILD_TYPE)
+
+run: build
+	$(EXEC) ./BlackScholes_nvrtc
+
+testrun: build
+
+clean:
+	rm -f BlackScholes_nvrtc BlackScholes.o BlackScholes_gold.o
+	rm -rf ../../../bin/$(TARGET_ARCH)/$(TARGET_OS)/$(BUILD_TYPE)/BlackScholes_nvrtc
+
+clobber: clean

Samples/5_Domain_Specific/BlackScholes_nvrtc/README.md

@@ -0,0 +1,77 @@
+# BlackScholes_nvrtc - Black-Scholes Option Pricing with libNVRTC
+
+## Description
+
+This sample evaluates fair call and put prices for a given set of European options by Black-Scholes formula, compiling the CUDA kernels involved at runtime using NVRTC.
+
+## Key Concepts
+
+Computational Finance, Runtime Compilation
+
+## Supported SM Architectures
+
+[SM 3.5 ](https://developer.nvidia.com/cuda-gpus)  [SM 3.7 ](https://developer.nvidia.com/cuda-gpus)  [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)
+
+## Supported OSes
+
+Linux, Windows, QNX
+
+## Supported CPU Architecture
+
+x86_64, ppc64le, aarch64
+
+## CUDA APIs involved
+
+### [CUDA Driver API](http://docs.nvidia.com/cuda/cuda-driver-api/index.html)
+cuModuleGetFunction, cuMemAlloc, cuLaunchKernel, cuCtxSynchronize, cuMemFree, cuMemcpyDtoH, cuMemcpyHtoD
+
+### [CUDA Runtime API](http://docs.nvidia.com/cuda/cuda-runtime-api/index.html)
+cudaBlockSize, cudaGridSize
+
+## Dependencies needed to build/run
+[NVRTC](../../README.md#nvrtc)
+
+## Prerequisites
+
+Download and install the [CUDA Toolkit 11.6](https://developer.nvidia.com/cuda-downloads) for your corresponding platform.
+Make sure the dependencies mentioned in [Dependencies]() section above are installed.
+
+## Build and Run
+
+### Windows
+The Windows samples are built using the Visual Studio IDE. Solution files (.sln) are provided for each supported version of Visual Studio, using the format:
+```
+*_vs<version>.sln - for Visual Studio <version>
+```
+Each individual sample has its own set of solution files in its directory:
+
+To build/examine all the samples at once, the complete solution files should be used. To build/examine a single sample, the individual sample solution files should be used.
+> **Note:** Some samples require that the Microsoft DirectX SDK (June 2010 or newer) be installed and that the VC++ directory paths are properly set up (**Tools > Options...**). Check DirectX Dependencies section for details."
+
+### Linux
+The Linux samples are built using makefiles. To use the makefiles, change the current directory to the sample directory you wish to build, and run make:
+```
+$ cd <sample_dir>
+$ make
+```
+The samples makefiles can take advantage of certain options:
+*  **TARGET_ARCH=<arch>** - cross-compile targeting a specific architecture. Allowed architectures are x86_64, ppc64le, aarch64.
+    By default, TARGET_ARCH is set to HOST_ARCH. On a x86_64 machine, not setting TARGET_ARCH is the equivalent of setting TARGET_ARCH=x86_64.<br/>
+`$ make TARGET_ARCH=x86_64` <br/> `$ make TARGET_ARCH=ppc64le` <br/> `$ make TARGET_ARCH=aarch64` <br/>
+    See [here](http://docs.nvidia.com/cuda/cuda-samples/index.html#cross-samples) for more details.
+*   **dbg=1** - build with debug symbols
+    ```
+    $ make dbg=1
+    ```
+*   **SMS="A B ..."** - override the SM architectures for which the sample will be built, where `"A B ..."` is a space-delimited list of SM architectures. For example, to generate SASS for SM 50 and SM 60, use `SMS="50 60"`.
+    ```
+    $ make SMS="50 60"
+    ```
+
+*  **HOST_COMPILER=<host_compiler>** - override the default g++ host compiler. See the [Linux Installation Guide](http://docs.nvidia.com/cuda/cuda-installation-guide-linux/index.html#system-requirements) for a list of supported host compilers.
+```
+    $ make HOST_COMPILER=g++
+```
+
+## References (for more details)
+

Samples/5_Domain_Specific/FDTD3d/.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
+}

Samples/5_Domain_Specific/FDTD3d/.vscode/extensions.json

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

Samples/5_Domain_Specific/FDTD3d/.vscode/launch.json

@@ -0,0 +1,10 @@
+{
+    "configurations": [
+        {
+            "name": "CUDA C++: Launch",
+            "type": "cuda-gdb",
+            "request": "launch",
+            "program": "${workspaceFolder}/FDTD3d"
+        }
+    ]
+}

Samples/5_Domain_Specific/FDTD3d/.vscode/tasks.json

@@ -0,0 +1,15 @@
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "sample",
+            "type": "shell",
+            "command": "make dbg=1",
+            "problemMatcher": ["$nvcc"],
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            }
+        }
+    ]
+}

Samples/5_Domain_Specific/FDTD3d/FDTD3d_vs2017.sln

@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2017
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "FDTD3d", "FDTD3d_vs2017.vcxproj", "{997E0757-EA74-4A4E-A0FC-47D8C8831A15}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Release|x64 = Release|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Debug|x64.ActiveCfg = Debug|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Debug|x64.Build.0 = Debug|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Release|x64.ActiveCfg = Release|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Release|x64.Build.0 = Release|x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

Samples/5_Domain_Specific/FDTD3d/FDTD3d_vs2017.vcxproj

@@ -0,0 +1,117 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <CUDAPropsPath Condition="'$(CUDAPropsPath)'==''">$(VCTargetsPath)\BuildCustomizations</CUDAPropsPath>
+  </PropertyGroup>
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{997E0757-EA74-4A4E-A0FC-47D8C8831A15}</ProjectGuid>
+    <RootNamespace>FDTD3d_vs2017</RootNamespace>
+    <ProjectName>FDTD3d</ProjectName>
+    <CudaToolkitCustomDir />
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(WindowsTargetPlatformVersion)'==''">
+    <LatestTargetPlatformVersion>$([Microsoft.Build.Utilities.ToolLocationHelper]::GetLatestSDKTargetPlatformVersion('Windows', '10.0'))</LatestTargetPlatformVersion>
+    <WindowsTargetPlatformVersion Condition="'$(WindowsTargetPlatformVersion)' == ''">$(LatestTargetPlatformVersion)</WindowsTargetPlatformVersion>
+    <TargetPlatformVersion>$(WindowsTargetPlatformVersion)</TargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup>
+    <ConfigurationType>Application</ConfigurationType>
+    <CharacterSet>MultiByte</CharacterSet>
+    <PlatformToolset>v141</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Debug'">
+    <UseDebugLibraries>true</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Release'">
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.6.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <IntDir>$(Platform)/$(Configuration)/</IntDir>
+    <IncludePath>$(IncludePath)</IncludePath>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules />
+    <CodeAnalysisRuleAssemblies />
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Platform)'=='x64'">
+    <OutDir>../../../bin/win64/$(Configuration)/</OutDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;_MBCS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>./;$(CudaToolkitDir)/include;../../../Common;inc;</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <AdditionalDependencies>cudart_static.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>$(CudaToolkitLibDir);</AdditionalLibraryDirectories>
+      <OutputFile>$(OutDir)/FDTD3d.exe</OutputFile>
+    </Link>
+    <CudaCompile>
+      <CodeGeneration>compute_35,sm_35;compute_37,sm_37;compute_50,sm_50;compute_52,sm_52;compute_60,sm_60;compute_61,sm_61;compute_70,sm_70;compute_75,sm_75;compute_80,sm_80;compute_86,sm_86;</CodeGeneration>
+      <AdditionalOptions>-Xcompiler "/wd 4819"  --threads 0 </AdditionalOptions>
+      <Include>./;../../../Common</Include>
+      <Defines>WIN32</Defines>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Debug'">
+    <ClCompile>
+      <Optimization>Disabled</Optimization>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
+    </Link>
+    <CudaCompile>
+      <Runtime>MTd</Runtime>
+      <TargetMachinePlatform>64</TargetMachinePlatform>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Release'">
+    <ClCompile>
+      <Optimization>MaxSpeed</Optimization>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>false</GenerateDebugInformation>
+      <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
+    </Link>
+    <CudaCompile>
+      <Runtime>MT</Runtime>
+      <TargetMachinePlatform>64</TargetMachinePlatform>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="src/FDTD3d.cpp" />
+    <CudaCompile Include="src/FDTD3dGPU.cu" />
+    <ClCompile Include="src/FDTD3dReference.cpp" />
+    <ClInclude Include="inc/FDTD3d.h" />
+    <ClInclude Include="inc/FDTD3dGPU.h" />
+    <ClInclude Include="inc/FDTD3dReference.h" />
+    <None Include="inc/FDTD3dGPUKernel.cuh" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.6.targets" />
+  </ImportGroup>
+</Project>

Samples/5_Domain_Specific/FDTD3d/FDTD3d_vs2019.sln

@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2019
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "FDTD3d", "FDTD3d_vs2019.vcxproj", "{997E0757-EA74-4A4E-A0FC-47D8C8831A15}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Release|x64 = Release|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Debug|x64.ActiveCfg = Debug|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Debug|x64.Build.0 = Debug|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Release|x64.ActiveCfg = Release|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Release|x64.Build.0 = Release|x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

Samples/5_Domain_Specific/FDTD3d/FDTD3d_vs2019.vcxproj

@@ -0,0 +1,113 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <CUDAPropsPath Condition="'$(CUDAPropsPath)'==''">$(VCTargetsPath)\BuildCustomizations</CUDAPropsPath>
+  </PropertyGroup>
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{997E0757-EA74-4A4E-A0FC-47D8C8831A15}</ProjectGuid>
+    <RootNamespace>FDTD3d_vs2019</RootNamespace>
+    <ProjectName>FDTD3d</ProjectName>
+    <CudaToolkitCustomDir />
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup>
+    <ConfigurationType>Application</ConfigurationType>
+    <CharacterSet>MultiByte</CharacterSet>
+    <PlatformToolset>v142</PlatformToolset>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Debug'">
+    <UseDebugLibraries>true</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Release'">
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.6.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <IntDir>$(Platform)/$(Configuration)/</IntDir>
+    <IncludePath>$(IncludePath)</IncludePath>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules />
+    <CodeAnalysisRuleAssemblies />
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Platform)'=='x64'">
+    <OutDir>../../../bin/win64/$(Configuration)/</OutDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;_MBCS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>./;$(CudaToolkitDir)/include;../../../Common;inc;</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <AdditionalDependencies>cudart_static.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>$(CudaToolkitLibDir);</AdditionalLibraryDirectories>
+      <OutputFile>$(OutDir)/FDTD3d.exe</OutputFile>
+    </Link>
+    <CudaCompile>
+      <CodeGeneration>compute_35,sm_35;compute_37,sm_37;compute_50,sm_50;compute_52,sm_52;compute_60,sm_60;compute_61,sm_61;compute_70,sm_70;compute_75,sm_75;compute_80,sm_80;compute_86,sm_86;</CodeGeneration>
+      <AdditionalOptions>-Xcompiler "/wd 4819"  --threads 0 </AdditionalOptions>
+      <Include>./;../../../Common</Include>
+      <Defines>WIN32</Defines>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Debug'">
+    <ClCompile>
+      <Optimization>Disabled</Optimization>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
+    </Link>
+    <CudaCompile>
+      <Runtime>MTd</Runtime>
+      <TargetMachinePlatform>64</TargetMachinePlatform>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Release'">
+    <ClCompile>
+      <Optimization>MaxSpeed</Optimization>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>false</GenerateDebugInformation>
+      <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
+    </Link>
+    <CudaCompile>
+      <Runtime>MT</Runtime>
+      <TargetMachinePlatform>64</TargetMachinePlatform>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="src/FDTD3d.cpp" />
+    <CudaCompile Include="src/FDTD3dGPU.cu" />
+    <ClCompile Include="src/FDTD3dReference.cpp" />
+    <ClInclude Include="inc/FDTD3d.h" />
+    <ClInclude Include="inc/FDTD3dGPU.h" />
+    <ClInclude Include="inc/FDTD3dReference.h" />
+    <None Include="inc/FDTD3dGPUKernel.cuh" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.6.targets" />
+  </ImportGroup>
+</Project>

Samples/5_Domain_Specific/FDTD3d/FDTD3d_vs2022.sln

@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2022
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "FDTD3d", "FDTD3d_vs2022.vcxproj", "{997E0757-EA74-4A4E-A0FC-47D8C8831A15}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Release|x64 = Release|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Debug|x64.ActiveCfg = Debug|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Debug|x64.Build.0 = Debug|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Release|x64.ActiveCfg = Release|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Release|x64.Build.0 = Release|x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

Samples/5_Domain_Specific/FDTD3d/FDTD3d_vs2022.vcxproj

@@ -0,0 +1,113 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <CUDAPropsPath Condition="'$(CUDAPropsPath)'==''">$(VCTargetsPath)\BuildCustomizations</CUDAPropsPath>
+  </PropertyGroup>
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{997E0757-EA74-4A4E-A0FC-47D8C8831A15}</ProjectGuid>
+    <RootNamespace>FDTD3d_vs2022</RootNamespace>
+    <ProjectName>FDTD3d</ProjectName>
+    <CudaToolkitCustomDir />
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup>
+    <ConfigurationType>Application</ConfigurationType>
+    <CharacterSet>MultiByte</CharacterSet>
+    <PlatformToolset>v143</PlatformToolset>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Debug'">
+    <UseDebugLibraries>true</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Release'">
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.6.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <IntDir>$(Platform)/$(Configuration)/</IntDir>
+    <IncludePath>$(IncludePath)</IncludePath>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules />
+    <CodeAnalysisRuleAssemblies />
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Platform)'=='x64'">
+    <OutDir>../../../bin/win64/$(Configuration)/</OutDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;_MBCS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>./;$(CudaToolkitDir)/include;../../../Common;inc;</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <AdditionalDependencies>cudart_static.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>$(CudaToolkitLibDir);</AdditionalLibraryDirectories>
+      <OutputFile>$(OutDir)/FDTD3d.exe</OutputFile>
+    </Link>
+    <CudaCompile>
+      <CodeGeneration>compute_35,sm_35;compute_37,sm_37;compute_50,sm_50;compute_52,sm_52;compute_60,sm_60;compute_61,sm_61;compute_70,sm_70;compute_75,sm_75;compute_80,sm_80;compute_86,sm_86;</CodeGeneration>
+      <AdditionalOptions>-Xcompiler "/wd 4819"  --threads 0 </AdditionalOptions>
+      <Include>./;../../../Common</Include>
+      <Defines>WIN32</Defines>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Debug'">
+    <ClCompile>
+      <Optimization>Disabled</Optimization>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
+    </Link>
+    <CudaCompile>
+      <Runtime>MTd</Runtime>
+      <TargetMachinePlatform>64</TargetMachinePlatform>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Release'">
+    <ClCompile>
+      <Optimization>MaxSpeed</Optimization>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>false</GenerateDebugInformation>
+      <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
+    </Link>
+    <CudaCompile>
+      <Runtime>MT</Runtime>
+      <TargetMachinePlatform>64</TargetMachinePlatform>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="src/FDTD3d.cpp" />
+    <CudaCompile Include="src/FDTD3dGPU.cu" />
+    <ClCompile Include="src/FDTD3dReference.cpp" />
+    <ClInclude Include="inc/FDTD3d.h" />
+    <ClInclude Include="inc/FDTD3dGPU.h" />
+    <ClInclude Include="inc/FDTD3dReference.h" />
+    <None Include="inc/FDTD3dGPUKernel.cuh" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.6.targets" />
+  </ImportGroup>
+</Project>

Samples/5_Domain_Specific/FDTD3d/Makefile

@@ -0,0 +1,348 @@
+################################################################################
+# 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.
+#
+################################################################################
+#
+# Makefile project only supported on Mac OS X and Linux Platforms)
+#
+################################################################################
+
+# Location of the CUDA Toolkit
+CUDA_PATH ?= /usr/local/cuda
+
+##############################
+# start deprecated interface #
+##############################
+ifeq ($(x86_64),1)
+    $(info WARNING - x86_64 variable has been deprecated)
+    $(info WARNING - please use TARGET_ARCH=x86_64 instead)
+    TARGET_ARCH ?= x86_64
+endif
+ifeq ($(ARMv7),1)
+    $(info WARNING - ARMv7 variable has been deprecated)
+    $(info WARNING - please use TARGET_ARCH=armv7l instead)
+    TARGET_ARCH ?= armv7l
+endif
+ifeq ($(aarch64),1)
+    $(info WARNING - aarch64 variable has been deprecated)
+    $(info WARNING - please use TARGET_ARCH=aarch64 instead)
+    TARGET_ARCH ?= aarch64
+endif
+ifeq ($(ppc64le),1)
+    $(info WARNING - ppc64le variable has been deprecated)
+    $(info WARNING - please use TARGET_ARCH=ppc64le instead)
+    TARGET_ARCH ?= ppc64le
+endif
+ifneq ($(GCC),)
+    $(info WARNING - GCC variable has been deprecated)
+    $(info WARNING - please use HOST_COMPILER=$(GCC) instead)
+    HOST_COMPILER ?= $(GCC)
+endif
+ifneq ($(abi),)
+    $(error ERROR - abi variable has been removed)
+endif
+############################
+# end deprecated interface #
+############################
+
+# architecture
+HOST_ARCH   := $(shell uname -m)
+TARGET_ARCH ?= $(HOST_ARCH)
+ifneq (,$(filter $(TARGET_ARCH),x86_64 aarch64 sbsa ppc64le armv7l))
+    ifneq ($(TARGET_ARCH),$(HOST_ARCH))
+        ifneq (,$(filter $(TARGET_ARCH),x86_64 aarch64 sbsa ppc64le))
+            TARGET_SIZE := 64
+        else ifneq (,$(filter $(TARGET_ARCH),armv7l))
+            TARGET_SIZE := 32
+        endif
+    else
+        TARGET_SIZE := $(shell getconf LONG_BIT)
+    endif
+else
+    $(error ERROR - unsupported value $(TARGET_ARCH) for TARGET_ARCH!)
+endif
+
+# sbsa and aarch64 systems look similar. Need to differentiate them at host level for now.
+ifeq ($(HOST_ARCH),aarch64)
+    ifeq ($(CUDA_PATH)/targets/sbsa-linux,$(shell ls -1d $(CUDA_PATH)/targets/sbsa-linux 2>/dev/null))
+        HOST_ARCH := sbsa
+        TARGET_ARCH := sbsa
+    endif
+endif
+
+ifneq ($(TARGET_ARCH),$(HOST_ARCH))
+    ifeq (,$(filter $(HOST_ARCH)-$(TARGET_ARCH),aarch64-armv7l x86_64-armv7l x86_64-aarch64 x86_64-sbsa x86_64-ppc64le))
+        $(error ERROR - cross compiling from $(HOST_ARCH) to $(TARGET_ARCH) is not supported!)
+    endif
+endif
+
+# When on native aarch64 system with userspace of 32-bit, change TARGET_ARCH to armv7l
+ifeq ($(HOST_ARCH)-$(TARGET_ARCH)-$(TARGET_SIZE),aarch64-aarch64-32)
+    TARGET_ARCH = armv7l
+endif
+
+# operating system
+HOST_OS   := $(shell uname -s 2>/dev/null | tr "[:upper:]" "[:lower:]")
+TARGET_OS ?= $(HOST_OS)
+ifeq (,$(filter $(TARGET_OS),linux darwin qnx android))
+    $(error ERROR - unsupported value $(TARGET_OS) for TARGET_OS!)
+endif
+
+# host compiler
+ifeq ($(TARGET_OS),darwin)
+    ifeq ($(shell expr `xcodebuild -version | grep -i xcode | awk '{print $$2}' | cut -d'.' -f1` \>= 5),1)
+        HOST_COMPILER ?= clang++
+    endif
+else ifneq ($(TARGET_ARCH),$(HOST_ARCH))
+    ifeq ($(HOST_ARCH)-$(TARGET_ARCH),x86_64-armv7l)
+        ifeq ($(TARGET_OS),linux)
+            HOST_COMPILER ?= arm-linux-gnueabihf-g++
+        else ifeq ($(TARGET_OS),qnx)
+            ifeq ($(QNX_HOST),)
+                $(error ERROR - QNX_HOST must be passed to the QNX host toolchain)
+            endif
+            ifeq ($(QNX_TARGET),)
+                $(error ERROR - QNX_TARGET must be passed to the QNX target toolchain)
+            endif
+            export QNX_HOST
+            export QNX_TARGET
+            HOST_COMPILER ?= $(QNX_HOST)/usr/bin/arm-unknown-nto-qnx6.6.0eabi-g++
+        else ifeq ($(TARGET_OS),android)
+            HOST_COMPILER ?= arm-linux-androideabi-g++
+        endif
+    else ifeq ($(TARGET_ARCH),aarch64)
+        ifeq ($(TARGET_OS), linux)
+            HOST_COMPILER ?= aarch64-linux-gnu-g++
+        else ifeq ($(TARGET_OS),qnx)
+            ifeq ($(QNX_HOST),)
+                $(error ERROR - QNX_HOST must be passed to the QNX host toolchain)
+            endif
+            ifeq ($(QNX_TARGET),)
+                $(error ERROR - QNX_TARGET must be passed to the QNX target toolchain)
+            endif
+            export QNX_HOST
+            export QNX_TARGET
+            HOST_COMPILER ?= $(QNX_HOST)/usr/bin/q++
+        else ifeq ($(TARGET_OS), android)
+            HOST_COMPILER ?= aarch64-linux-android-clang++
+        endif
+    else ifeq ($(TARGET_ARCH),sbsa)
+        HOST_COMPILER ?= aarch64-linux-gnu-g++
+    else ifeq ($(TARGET_ARCH),ppc64le)
+        HOST_COMPILER ?= powerpc64le-linux-gnu-g++
+    endif
+endif
+HOST_COMPILER ?= g++
+NVCC          := $(CUDA_PATH)/bin/nvcc -ccbin $(HOST_COMPILER)
+
+# internal flags
+NVCCFLAGS   := -m${TARGET_SIZE}
+CCFLAGS     :=
+LDFLAGS     :=
+
+# build flags
+ifeq ($(TARGET_OS),darwin)
+    LDFLAGS += -rpath $(CUDA_PATH)/lib
+    CCFLAGS += -arch $(HOST_ARCH)
+else ifeq ($(HOST_ARCH)-$(TARGET_ARCH)-$(TARGET_OS),x86_64-armv7l-linux)
+    LDFLAGS += --dynamic-linker=/lib/ld-linux-armhf.so.3
+    CCFLAGS += -mfloat-abi=hard
+else ifeq ($(TARGET_OS),android)
+    LDFLAGS += -pie
+    CCFLAGS += -fpie -fpic -fexceptions
+endif
+
+ifneq ($(TARGET_ARCH),$(HOST_ARCH))
+    ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-linux)
+        ifneq ($(TARGET_FS),)
+            GCCVERSIONLTEQ46 := $(shell expr `$(HOST_COMPILER) -dumpversion` \<= 4.6)
+            ifeq ($(GCCVERSIONLTEQ46),1)
+                CCFLAGS += --sysroot=$(TARGET_FS)
+            endif
+            LDFLAGS += --sysroot=$(TARGET_FS)
+            LDFLAGS += -rpath-link=$(TARGET_FS)/lib
+            LDFLAGS += -rpath-link=$(TARGET_FS)/usr/lib
+            LDFLAGS += -rpath-link=$(TARGET_FS)/usr/lib/arm-linux-gnueabihf
+        endif
+    endif
+    ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-linux)
+        ifneq ($(TARGET_FS),)
+            GCCVERSIONLTEQ46 := $(shell expr `$(HOST_COMPILER) -dumpversion` \<= 4.6)
+            ifeq ($(GCCVERSIONLTEQ46),1)
+                CCFLAGS += --sysroot=$(TARGET_FS)
+            endif
+            LDFLAGS += --sysroot=$(TARGET_FS)
+            LDFLAGS += -rpath-link=$(TARGET_FS)/lib -L$(TARGET_FS)/lib
+            LDFLAGS += -rpath-link=$(TARGET_FS)/lib/aarch64-linux-gnu -L$(TARGET_FS)/lib/aarch64-linux-gnu
+            LDFLAGS += -rpath-link=$(TARGET_FS)/usr/lib -L$(TARGET_FS)/usr/lib
+            LDFLAGS += -rpath-link=$(TARGET_FS)/usr/lib/aarch64-linux-gnu -L$(TARGET_FS)/usr/lib/aarch64-linux-gnu
+            LDFLAGS += --unresolved-symbols=ignore-in-shared-libs
+            CCFLAGS += -isystem=$(TARGET_FS)/usr/include -I$(TARGET_FS)/usr/include -I$(TARGET_FS)/usr/include/libdrm
+            CCFLAGS += -isystem=$(TARGET_FS)/usr/include/aarch64-linux-gnu -I$(TARGET_FS)/usr/include/aarch64-linux-gnu
+        endif
+    endif
+    ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-qnx)
+        NVCCFLAGS += -D_QNX_SOURCE
+        NVCCFLAGS += --qpp-config 8.3.0,gcc_ntoaarch64le
+        CCFLAGS += -DWIN_INTERFACE_CUSTOM -I/usr/include/aarch64-qnx-gnu
+        LDFLAGS += -lsocket
+        LDFLAGS += -L/usr/lib/aarch64-qnx-gnu
+        CCFLAGS += "-Wl\,-rpath-link\,/usr/lib/aarch64-qnx-gnu"
+        ifdef TARGET_OVERRIDE
+            LDFLAGS += -lslog2
+        endif
+
+        ifneq ($(TARGET_FS),)
+            LDFLAGS += -L$(TARGET_FS)/usr/lib
+            CCFLAGS += "-Wl\,-rpath-link\,$(TARGET_FS)/usr/lib"
+            LDFLAGS += -L$(TARGET_FS)/usr/libnvidia
+            CCFLAGS += "-Wl\,-rpath-link\,$(TARGET_FS)/usr/libnvidia"
+            CCFLAGS += -I$(TARGET_FS)/../include
+        endif
+    endif
+endif
+
+ifdef TARGET_OVERRIDE # cuda toolkit targets override
+    NVCCFLAGS += -target-dir $(TARGET_OVERRIDE)
+endif
+
+# Install directory of different arch
+CUDA_INSTALL_TARGET_DIR :=
+ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-linux)
+    CUDA_INSTALL_TARGET_DIR = targets/armv7-linux-gnueabihf/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-linux)
+    CUDA_INSTALL_TARGET_DIR = targets/aarch64-linux/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),sbsa-linux)
+    CUDA_INSTALL_TARGET_DIR = targets/sbsa-linux/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-android)
+    CUDA_INSTALL_TARGET_DIR = targets/armv7-linux-androideabi/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-android)
+    CUDA_INSTALL_TARGET_DIR = targets/aarch64-linux-androideabi/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-qnx)
+    CUDA_INSTALL_TARGET_DIR = targets/ARMv7-linux-QNX/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-qnx)
+    CUDA_INSTALL_TARGET_DIR = targets/aarch64-qnx/
+else ifeq ($(TARGET_ARCH),ppc64le)
+    CUDA_INSTALL_TARGET_DIR = targets/ppc64le-linux/
+endif
+
+# Debug build flags
+ifeq ($(dbg),1)
+      NVCCFLAGS += -g -G
+      BUILD_TYPE := debug
+else
+      BUILD_TYPE := release
+endif
+
+ALL_CCFLAGS :=
+ALL_CCFLAGS += $(NVCCFLAGS)
+ALL_CCFLAGS += $(EXTRA_NVCCFLAGS)
+ALL_CCFLAGS += $(addprefix -Xcompiler ,$(CCFLAGS))
+ALL_CCFLAGS += $(addprefix -Xcompiler ,$(EXTRA_CCFLAGS))
+
+SAMPLE_ENABLED := 1
+
+ALL_LDFLAGS :=
+ALL_LDFLAGS += $(ALL_CCFLAGS)
+ALL_LDFLAGS += $(addprefix -Xlinker ,$(LDFLAGS))
+ALL_LDFLAGS += $(addprefix -Xlinker ,$(EXTRA_LDFLAGS))
+
+# Common includes and paths for CUDA
+INCLUDES  := -I../../../Common
+LIBRARIES :=
+
+################################################################################
+
+# Gencode arguments
+ifeq ($(TARGET_ARCH),$(filter $(TARGET_ARCH),armv7l aarch64 sbsa))
+SMS ?= 53 61 70 72 75 80 86 87
+else
+SMS ?= 35 37 50 52 60 61 70 75 80 86
+endif
+
+ifeq ($(SMS),)
+$(info >>> WARNING - no SM architectures have been specified - waiving sample <<<)
+SAMPLE_ENABLED := 0
+endif
+
+ifeq ($(GENCODE_FLAGS),)
+# Generate SASS code for each SM architecture listed in $(SMS)
+$(foreach sm,$(SMS),$(eval GENCODE_FLAGS += -gencode arch=compute_$(sm),code=sm_$(sm)))
+
+# Generate PTX code from the highest SM architecture in $(SMS) to guarantee forward-compatibility
+HIGHEST_SM := $(lastword $(sort $(SMS)))
+ifneq ($(HIGHEST_SM),)
+GENCODE_FLAGS += -gencode arch=compute_$(HIGHEST_SM),code=compute_$(HIGHEST_SM)
+endif
+endif
+
+ALL_CCFLAGS += --threads 0 --std=c++11
+
+INCLUDES += -Iinc
+
+ifeq ($(SAMPLE_ENABLED),0)
+EXEC ?= @echo "[@]"
+endif
+
+################################################################################
+
+# Target rules
+all: build
+
+build: FDTD3d
+
+check.deps:
+ifeq ($(SAMPLE_ENABLED),0)
+	@echo "Sample will be waived due to the above missing dependencies"
+else
+	@echo "Sample is ready - all dependencies have been met"
+endif
+
+FDTD3d.o:src/FDTD3d.cpp
+	$(EXEC) $(NVCC) $(INCLUDES) $(ALL_CCFLAGS) $(GENCODE_FLAGS) -o $@ -c $<
+
+FDTD3dGPU.o:src/FDTD3dGPU.cu
+	$(EXEC) $(NVCC) $(INCLUDES) $(ALL_CCFLAGS) $(GENCODE_FLAGS) -o $@ -c $<
+
+FDTD3dReference.o:src/FDTD3dReference.cpp
+	$(EXEC) $(NVCC) $(INCLUDES) $(ALL_CCFLAGS) $(GENCODE_FLAGS) -o $@ -c $<
+
+FDTD3d: FDTD3d.o FDTD3dGPU.o FDTD3dReference.o
+	$(EXEC) $(NVCC) $(ALL_LDFLAGS) $(GENCODE_FLAGS) -o $@ $+ $(LIBRARIES)
+	$(EXEC) mkdir -p ../../../bin/$(TARGET_ARCH)/$(TARGET_OS)/$(BUILD_TYPE)
+	$(EXEC) cp $@ ../../../bin/$(TARGET_ARCH)/$(TARGET_OS)/$(BUILD_TYPE)
+
+run: build
+	$(EXEC) ./FDTD3d
+
+testrun: build
+
+clean:
+	rm -f FDTD3d FDTD3d.o FDTD3dGPU.o FDTD3dReference.o
+	rm -rf ../../../bin/$(TARGET_ARCH)/$(TARGET_OS)/$(BUILD_TYPE)/FDTD3d
+
+clobber: clean

Samples/5_Domain_Specific/FDTD3d/NsightEclipse.xml

@@ -0,0 +1,91 @@
+<?xml version="1.0" encoding="UTF-8"?> 
+<!DOCTYPE entry SYSTEM "SamplesInfo.dtd">
+<entry>
+  <name>FDTD3d</name>
+  <cuda_api_list>
+    <toolkit>cudaMemcpyToSymbol</toolkit>
+    <toolkit>cudaFree</toolkit>
+    <toolkit>cudaEventRecord</toolkit>
+    <toolkit>cudaEventCreate</toolkit>
+    <toolkit>cudaFuncGetAttributes</toolkit>
+    <toolkit>cudaGetDeviceCount</toolkit>
+    <toolkit>cudaEventElapsedTime</toolkit>
+    <toolkit>cudaDeviceSynchronize</toolkit>
+    <toolkit>cudaMalloc</toolkit>
+    <toolkit>cudaEventDestroy</toolkit>
+    <toolkit>cudaSetDevice</toolkit>
+    <toolkit>cudaMemcpy</toolkit>
+    <toolkit>cudaGetDeviceProperties</toolkit>
+  </cuda_api_list>
+  <description><![CDATA[This sample applies a finite differences time domain progression stencil on a 3D surface.]]></description>
+  <devicecompilation>whole</devicecompilation>
+  <includepaths>
+    <path>inc</path>
+    <path>./</path>
+    <path>../</path>
+    <path>../../../Common</path>
+  </includepaths>
+  <keyconcepts>
+    <concept level="advanced">Performance Strategies</concept>
+  </keyconcepts>
+  <keywords>
+    <keyword>GPGPU</keyword>
+    <keyword>CUDA</keyword>
+    <keyword>finite difference</keyword>
+    <keyword>fdtd</keyword>
+    <keyword>differential equation</keyword>
+    <keyword>pde</keyword>
+    <keyword>ode</keyword>
+  </keywords>
+  <libraries>
+  </libraries>
+  <librarypaths>
+  </librarypaths>
+  <nsight_eclipse>true</nsight_eclipse>
+  <primary_file>FDTD3d.cpp</primary_file>
+  <scopes>
+    <scope>1:CUDA Advanced Topics</scope>
+    <scope>1:Performance Strategies</scope>
+  </scopes>
+  <sm-arch>sm35</sm-arch>
+  <sm-arch>sm37</sm-arch>
+  <sm-arch>sm50</sm-arch>
+  <sm-arch>sm52</sm-arch>
+  <sm-arch>sm53</sm-arch>
+  <sm-arch>sm60</sm-arch>
+  <sm-arch>sm61</sm-arch>
+  <sm-arch>sm70</sm-arch>
+  <sm-arch>sm72</sm-arch>
+  <sm-arch>sm75</sm-arch>
+  <sm-arch>sm80</sm-arch>
+  <sm-arch>sm86</sm-arch>
+  <sm-arch>sm87</sm-arch>
+  <supported_envs>
+    <env>
+      <arch>x86_64</arch>
+      <platform>linux</platform>
+    </env>
+    <env>
+      <platform>windows7</platform>
+    </env>
+    <env>
+      <arch>x86_64</arch>
+      <platform>macosx</platform>
+    </env>
+    <env>
+      <arch>arm</arch>
+    </env>
+    <env>
+      <arch>sbsa</arch>
+    </env>
+    <env>
+      <arch>ppc64le</arch>
+      <platform>linux</platform>
+    </env>
+  </supported_envs>
+  <supported_sm_architectures>
+    <include>all</include>
+  </supported_sm_architectures>
+  <title>CUDA C 3D FDTD</title>
+  <type>exe</type>
+</entry>

Samples/5_Domain_Specific/FDTD3d/README.md

@@ -0,0 +1,70 @@
+# FDTD3d - CUDA C 3D FDTD
+
+## Description
+
+This sample applies a finite differences time domain progression stencil on a 3D surface.
+
+## Key Concepts
+
+Performance Strategies
+
+## Supported SM Architectures
+
+[SM 3.5 ](https://developer.nvidia.com/cuda-gpus)  [SM 3.7 ](https://developer.nvidia.com/cuda-gpus)  [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)
+
+## Supported OSes
+
+Linux, Windows
+
+## Supported CPU Architecture
+
+x86_64, ppc64le, armv7l
+
+## CUDA APIs involved
+
+### [CUDA Runtime API](http://docs.nvidia.com/cuda/cuda-runtime-api/index.html)
+cudaMemcpyToSymbol, cudaFree, cudaEventRecord, cudaEventCreate, cudaFuncGetAttributes, cudaGetDeviceCount, cudaEventElapsedTime, cudaDeviceSynchronize, cudaMalloc, cudaEventDestroy, cudaSetDevice, cudaMemcpy, cudaGetDeviceProperties
+
+## Prerequisites
+
+Download and install the [CUDA Toolkit 11.6](https://developer.nvidia.com/cuda-downloads) for your corresponding platform.
+
+## Build and Run
+
+### Windows
+The Windows samples are built using the Visual Studio IDE. Solution files (.sln) are provided for each supported version of Visual Studio, using the format:
+```
+*_vs<version>.sln - for Visual Studio <version>
+```
+Each individual sample has its own set of solution files in its directory:
+
+To build/examine all the samples at once, the complete solution files should be used. To build/examine a single sample, the individual sample solution files should be used.
+> **Note:** Some samples require that the Microsoft DirectX SDK (June 2010 or newer) be installed and that the VC++ directory paths are properly set up (**Tools > Options...**). Check DirectX Dependencies section for details."
+
+### Linux
+The Linux samples are built using makefiles. To use the makefiles, change the current directory to the sample directory you wish to build, and run make:
+```
+$ cd <sample_dir>
+$ make
+```
+The samples makefiles can take advantage of certain options:
+*  **TARGET_ARCH=<arch>** - cross-compile targeting a specific architecture. Allowed architectures are x86_64, ppc64le, armv7l.
+    By default, TARGET_ARCH is set to HOST_ARCH. On a x86_64 machine, not setting TARGET_ARCH is the equivalent of setting TARGET_ARCH=x86_64.<br/>
+`$ make TARGET_ARCH=x86_64` <br/> `$ make TARGET_ARCH=ppc64le` <br/> `$ make TARGET_ARCH=armv7l` <br/>
+    See [here](http://docs.nvidia.com/cuda/cuda-samples/index.html#cross-samples) for more details.
+*   **dbg=1** - build with debug symbols
+    ```
+    $ make dbg=1
+    ```
+*   **SMS="A B ..."** - override the SM architectures for which the sample will be built, where `"A B ..."` is a space-delimited list of SM architectures. For example, to generate SASS for SM 50 and SM 60, use `SMS="50 60"`.
+    ```
+    $ make SMS="50 60"
+    ```
+
+*  **HOST_COMPILER=<host_compiler>** - override the default g++ host compiler. See the [Linux Installation Guide](http://docs.nvidia.com/cuda/cuda-installation-guide-linux/index.html#system-requirements) for a list of supported host compilers.
+```
+    $ make HOST_COMPILER=g++
+```
+
+## References (for more details)
+

Samples/5_Domain_Specific/FDTD3d/inc/FDTD3d.h

@@ -0,0 +1,54 @@
+/* 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 _FDTD3D_H_
+#define _FDTD3D_H_
+
+// The values are set to give reasonable runtimes, they can
+// be changed but note that running very large dimensions can
+// take a very long time and you should avoid running on your
+// primary display in this case.
+#define k_dim_min 96
+#define k_dim_max 376
+#define k_dim_qa 248
+
+// Note that the radius is defined here as exactly 4 since the
+// kernel code uses a constant. If you want a different radius
+// you must change the kernel accordingly.
+#define k_radius_min 4
+#define k_radius_max 4
+#define k_radius_default 4
+
+// The values are set to give reasonable runtimes, they can
+// be changed but note that running a very large number of
+// timesteps can take a very long time and you should avoid
+// running on your primary display in this case.
+#define k_timesteps_min 1
+#define k_timesteps_max 10
+#define k_timesteps_default 5
+
+#endif

Samples/5_Domain_Specific/FDTD3d/inc/FDTD3dGPU.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 _FDTD3DGPU_H_
+#define _FDTD3DGPU_H_
+
+#include <cstddef>
+#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || \
+    defined(_WIN64) && defined(_MSC_VER)
+typedef unsigned __int64 memsize_t;
+#else
+#include <stdint.h>
+typedef uint64_t memsize_t;
+#endif
+
+#define k_blockDimX 32
+#define k_blockDimMaxY 16
+#define k_blockSizeMin 128
+#define k_blockSizeMax (k_blockDimX * k_blockDimMaxY)
+
+bool getTargetDeviceGlobalMemSize(memsize_t *result, const int argc,
+                                  const char **argv);
+bool fdtdGPU(float *output, const float *input, const float *coeff,
+             const int dimx, const int dimy, const int dimz, const int radius,
+             const int timesteps, const int argc, const char **argv);
+
+#endif

Samples/5_Domain_Specific/FDTD3d/inc/FDTD3dGPUKernel.cuh

@@ -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.
+ */
+
+#include "FDTD3dGPU.h"
+#include <cooperative_groups.h>
+
+namespace cg = cooperative_groups;
+
+// Note: If you change the RADIUS, you should also change the unrolling below
+#define RADIUS 4
+
+__constant__ float stencil[RADIUS + 1];
+
+__global__ void FiniteDifferencesKernel(float *output, const float *input,
+                                        const int dimx, const int dimy,
+                                        const int dimz) {
+  bool validr = true;
+  bool validw = true;
+  const int gtidx = blockIdx.x * blockDim.x + threadIdx.x;
+  const int gtidy = blockIdx.y * blockDim.y + threadIdx.y;
+  const int ltidx = threadIdx.x;
+  const int ltidy = threadIdx.y;
+  const int workx = blockDim.x;
+  const int worky = blockDim.y;
+  // Handle to thread block group
+  cg::thread_block cta = cg::this_thread_block();
+  __shared__ float tile[k_blockDimMaxY + 2 * RADIUS][k_blockDimX + 2 * RADIUS];
+
+  const int stride_y = dimx + 2 * RADIUS;
+  const int stride_z = stride_y * (dimy + 2 * RADIUS);
+
+  int inputIndex = 0;
+  int outputIndex = 0;
+
+  // Advance inputIndex to start of inner volume
+  inputIndex += RADIUS * stride_y + RADIUS;
+
+  // Advance inputIndex to target element
+  inputIndex += gtidy * stride_y + gtidx;
+
+  float infront[RADIUS];
+  float behind[RADIUS];
+  float current;
+
+  const int tx = ltidx + RADIUS;
+  const int ty = ltidy + RADIUS;
+
+  // Check in bounds
+  if ((gtidx >= dimx + RADIUS) || (gtidy >= dimy + RADIUS)) validr = false;
+
+  if ((gtidx >= dimx) || (gtidy >= dimy)) validw = false;
+
+  // Preload the "infront" and "behind" data
+  for (int i = RADIUS - 2; i >= 0; i--) {
+    if (validr) behind[i] = input[inputIndex];
+
+    inputIndex += stride_z;
+  }
+
+  if (validr) current = input[inputIndex];
+
+  outputIndex = inputIndex;
+  inputIndex += stride_z;
+
+  for (int i = 0; i < RADIUS; i++) {
+    if (validr) infront[i] = input[inputIndex];
+
+    inputIndex += stride_z;
+  }
+
+// Step through the xy-planes
+#pragma unroll 9
+
+  for (int iz = 0; iz < dimz; iz++) {
+    // Advance the slice (move the thread-front)
+    for (int i = RADIUS - 1; i > 0; i--) behind[i] = behind[i - 1];
+
+    behind[0] = current;
+    current = infront[0];
+#pragma unroll 4
+
+    for (int i = 0; i < RADIUS - 1; i++) infront[i] = infront[i + 1];
+
+    if (validr) infront[RADIUS - 1] = input[inputIndex];
+
+    inputIndex += stride_z;
+    outputIndex += stride_z;
+    cg::sync(cta);
+
+    // Note that for the work items on the boundary of the problem, the
+    // supplied index when reading the halo (below) may wrap to the
+    // previous/next row or even the previous/next xy-plane. This is
+    // acceptable since a) we disable the output write for these work
+    // items and b) there is at least one xy-plane before/after the
+    // current plane, so the access will be within bounds.
+
+    // Update the data slice in the local tile
+    // Halo above & below
+    if (ltidy < RADIUS) {
+      tile[ltidy][tx] = input[outputIndex - RADIUS * stride_y];
+      tile[ltidy + worky + RADIUS][tx] = input[outputIndex + worky * stride_y];
+    }
+
+    // Halo left & right
+    if (ltidx < RADIUS) {
+      tile[ty][ltidx] = input[outputIndex - RADIUS];
+      tile[ty][ltidx + workx + RADIUS] = input[outputIndex + workx];
+    }
+
+    tile[ty][tx] = current;
+    cg::sync(cta);
+
+    // Compute the output value
+    float value = stencil[0] * current;
+#pragma unroll 4
+
+    for (int i = 1; i <= RADIUS; i++) {
+      value +=
+          stencil[i] * (infront[i - 1] + behind[i - 1] + tile[ty - i][tx] +
+                        tile[ty + i][tx] + tile[ty][tx - i] + tile[ty][tx + i]);
+    }
+
+    // Store the output value
+    if (validw) output[outputIndex] = value;
+  }
+}

Samples/5_Domain_Specific/FDTD3d/inc/FDTD3dReference.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 _FDTD3DREFERENCE_H_
+#define _FDTD3DREFERENCE_H_
+
+void generateRandomData(float *data, const int dimx, const int dimy,
+                        const int dimz, const float lowerBound,
+                        const float upperBound);
+void generatePatternData(float *data, const int dimx, const int dimy,
+                         const int dimz, const float lowerBound,
+                         const float upperBound);
+bool fdtdReference(float *output, const float *input, const float *coeff,
+                   const int dimx, const int dimy, const int dimz,
+                   const int radius, const int timesteps);
+bool compareData(const float *output, const float *reference, const int dimx,
+                 const int dimy, const int dimz, const int radius,
+                 const float tolerance = 0.0001f);
+
+#endif

Samples/5_Domain_Specific/FDTD3d/src/FDTD3d.cpp

@@ -0,0 +1,235 @@
+/* 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 "FDTD3d.h"
+
+#include <iostream>
+#include <iomanip>
+
+#include "FDTD3dReference.h"
+#include "FDTD3dGPU.h"
+
+#include <helper_functions.h>
+
+#include <math.h>
+#include <assert.h>
+
+#ifndef CLAMP
+#define CLAMP(a, min, max) (MIN(max, MAX(a, min)))
+#endif
+
+//// Name of the log file
+// const char *printfFile = "FDTD3d.txt";
+
+// Forward declarations
+bool runTest(int argc, const char **argv);
+void showHelp(const int argc, const char **argv);
+
+int main(int argc, char **argv) {
+  bool bTestResult = false;
+  // Start the log
+  printf("%s Starting...\n\n", argv[0]);
+
+  // Check help flag
+  if (checkCmdLineFlag(argc, (const char **)argv, "help")) {
+    printf("Displaying help on console\n");
+    showHelp(argc, (const char **)argv);
+    bTestResult = true;
+  } else {
+    // Execute
+    bTestResult = runTest(argc, (const char **)argv);
+  }
+
+  // Finish
+  exit(bTestResult ? EXIT_SUCCESS : EXIT_FAILURE);
+}
+
+void showHelp(const int argc, const char **argv) {
+  if (argc > 0) std::cout << std::endl << argv[0] << std::endl;
+
+  std::cout << std::endl << "Syntax:" << std::endl;
+  std::cout << std::left;
+  std::cout << "    " << std::setw(20) << "--device=<device>"
+            << "Specify device to use for execution" << std::endl;
+  std::cout << "    " << std::setw(20) << "--dimx=<N>"
+            << "Specify number of elements in x direction (excluding halo)"
+            << std::endl;
+  std::cout << "    " << std::setw(20) << "--dimy=<N>"
+            << "Specify number of elements in y direction (excluding halo)"
+            << std::endl;
+  std::cout << "    " << std::setw(20) << "--dimz=<N>"
+            << "Specify number of elements in z direction (excluding halo)"
+            << std::endl;
+  std::cout << "    " << std::setw(20) << "--radius=<N>"
+            << "Specify radius of stencil" << std::endl;
+  std::cout << "    " << std::setw(20) << "--timesteps=<N>"
+            << "Specify number of timesteps" << std::endl;
+  std::cout << "    " << std::setw(20) << "--block-size=<N>"
+            << "Specify number of threads per block" << std::endl;
+  std::cout << std::endl;
+  std::cout << "    " << std::setw(20) << "--noprompt"
+            << "Skip prompt before exit" << std::endl;
+  std::cout << std::endl;
+}
+
+bool runTest(int argc, const char **argv) {
+  float *host_output;
+  float *device_output;
+  float *input;
+  float *coeff;
+
+  int defaultDim;
+  int dimx;
+  int dimy;
+  int dimz;
+  int outerDimx;
+  int outerDimy;
+  int outerDimz;
+  int radius;
+  int timesteps;
+  size_t volumeSize;
+  memsize_t memsize;
+
+  const float lowerBound = 0.0f;
+  const float upperBound = 1.0f;
+
+  // Determine default dimensions
+  printf("Set-up, based upon target device GMEM size...\n");
+  // Get the memory size of the target device
+  printf(" getTargetDeviceGlobalMemSize\n");
+  getTargetDeviceGlobalMemSize(&memsize, argc, argv);
+
+  // We can never use all the memory so to keep things simple we aim to
+  // use around half the total memory
+  memsize /= 2;
+
+  // Most of our memory use is taken up by the input and output buffers -
+  // two buffers of equal size - and for simplicity the volume is a cube:
+  //   dim = floor( (N/2)^(1/3) )
+  defaultDim = (int)floor(pow((memsize / (2.0 * sizeof(float))), 1.0 / 3.0));
+
+  // By default, make the volume edge size an integer multiple of 128B to
+  // improve performance by coalescing memory accesses, in a real
+  // application it would make sense to pad the lines accordingly
+  int roundTarget = 128 / sizeof(float);
+  defaultDim = defaultDim / roundTarget * roundTarget;
+  defaultDim -= k_radius_default * 2;
+
+  // Check dimension is valid
+  if (defaultDim < k_dim_min) {
+    printf(
+        "insufficient device memory (maximum volume on device is %d, must be "
+        "between %d and %d).\n",
+        defaultDim, k_dim_min, k_dim_max);
+    exit(EXIT_FAILURE);
+  } else if (defaultDim > k_dim_max) {
+    defaultDim = k_dim_max;
+  }
+
+  // For QA testing, override default volume size
+  if (checkCmdLineFlag(argc, argv, "qatest")) {
+    defaultDim = MIN(defaultDim, k_dim_qa);
+  }
+
+  // set default dim
+  dimx = defaultDim;
+  dimy = defaultDim;
+  dimz = defaultDim;
+  radius = k_radius_default;
+  timesteps = k_timesteps_default;
+
+  // Parse command line arguments
+  if (checkCmdLineFlag(argc, argv, "dimx")) {
+    dimx =
+        CLAMP(getCmdLineArgumentInt(argc, argv, "dimx"), k_dim_min, k_dim_max);
+  }
+
+  if (checkCmdLineFlag(argc, argv, "dimy")) {
+    dimy =
+        CLAMP(getCmdLineArgumentInt(argc, argv, "dimy"), k_dim_min, k_dim_max);
+  }
+
+  if (checkCmdLineFlag(argc, argv, "dimz")) {
+    dimz =
+        CLAMP(getCmdLineArgumentInt(argc, argv, "dimz"), k_dim_min, k_dim_max);
+  }
+
+  if (checkCmdLineFlag(argc, argv, "radius")) {
+    radius = CLAMP(getCmdLineArgumentInt(argc, argv, "radius"), k_radius_min,
+                   k_radius_max);
+  }
+
+  if (checkCmdLineFlag(argc, argv, "timesteps")) {
+    timesteps = CLAMP(getCmdLineArgumentInt(argc, argv, "timesteps"),
+                      k_timesteps_min, k_timesteps_max);
+  }
+
+  // Determine volume size
+  outerDimx = dimx + 2 * radius;
+  outerDimy = dimy + 2 * radius;
+  outerDimz = dimz + 2 * radius;
+  volumeSize = outerDimx * outerDimy * outerDimz;
+
+  // Allocate memory
+  host_output = (float *)calloc(volumeSize, sizeof(float));
+  input = (float *)malloc(volumeSize * sizeof(float));
+  coeff = (float *)malloc((radius + 1) * sizeof(float));
+
+  // Create coefficients
+  for (int i = 0; i <= radius; i++) {
+    coeff[i] = 0.1f;
+  }
+
+  // Generate data
+  printf(" generateRandomData\n\n");
+  generateRandomData(input, outerDimx, outerDimy, outerDimz, lowerBound,
+                     upperBound);
+  printf(
+      "FDTD on %d x %d x %d volume with symmetric filter radius %d for %d "
+      "timesteps...\n\n",
+      dimx, dimy, dimz, radius, timesteps);
+
+  // Execute on the host
+  printf("fdtdReference...\n");
+  fdtdReference(host_output, input, coeff, dimx, dimy, dimz, radius, timesteps);
+  printf("fdtdReference complete\n");
+
+  // Allocate memory
+  device_output = (float *)calloc(volumeSize, sizeof(float));
+
+  // Execute on the device
+  printf("fdtdGPU...\n");
+  fdtdGPU(device_output, input, coeff, dimx, dimy, dimz, radius, timesteps,
+          argc, argv);
+  printf("fdtdGPU complete\n");
+
+  // Compare the results
+  float tolerance = 0.0001f;
+  printf("\nCompareData (tolerance %f)...\n", tolerance);
+  return compareData(device_output, host_output, dimx, dimy, dimz, radius,
+                     tolerance);
+}

Samples/5_Domain_Specific/FDTD3d/src/FDTD3dGPU.cu

@@ -0,0 +1,263 @@
+/* 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 "FDTD3dGPU.h"
+
+#include <iostream>
+#include <algorithm>
+#include <helper_functions.h>
+#include <helper_cuda.h>
+
+#include "FDTD3dGPUKernel.cuh"
+
+bool getTargetDeviceGlobalMemSize(memsize_t *result, const int argc,
+                                  const char **argv) {
+  int deviceCount = 0;
+  int targetDevice = 0;
+  size_t memsize = 0;
+
+  // Get the number of CUDA enabled GPU devices
+  printf(" cudaGetDeviceCount\n");
+  checkCudaErrors(cudaGetDeviceCount(&deviceCount));
+
+  // Select target device (device 0 by default)
+  targetDevice = findCudaDevice(argc, (const char **)argv);
+
+  // Query target device for maximum memory allocation
+  printf(" cudaGetDeviceProperties\n");
+  struct cudaDeviceProp deviceProp;
+  checkCudaErrors(cudaGetDeviceProperties(&deviceProp, targetDevice));
+
+  memsize = deviceProp.totalGlobalMem;
+
+  // Save the result
+  *result = (memsize_t)memsize;
+  return true;
+}
+
+bool fdtdGPU(float *output, const float *input, const float *coeff,
+             const int dimx, const int dimy, const int dimz, const int radius,
+             const int timesteps, const int argc, const char **argv) {
+  const int outerDimx = dimx + 2 * radius;
+  const int outerDimy = dimy + 2 * radius;
+  const int outerDimz = dimz + 2 * radius;
+  const size_t volumeSize = outerDimx * outerDimy * outerDimz;
+  int deviceCount = 0;
+  int targetDevice = 0;
+  float *bufferOut = 0;
+  float *bufferIn = 0;
+  dim3 dimBlock;
+  dim3 dimGrid;
+
+  // Ensure that the inner data starts on a 128B boundary
+  const int padding = (128 / sizeof(float)) - radius;
+  const size_t paddedVolumeSize = volumeSize + padding;
+
+#ifdef GPU_PROFILING
+  cudaEvent_t profileStart = 0;
+  cudaEvent_t profileEnd = 0;
+  const int profileTimesteps = timesteps - 1;
+
+  if (profileTimesteps < 1) {
+    printf(
+        " cannot profile with fewer than two timesteps (timesteps=%d), "
+        "profiling is disabled.\n",
+        timesteps);
+  }
+
+#endif
+
+  // Check the radius is valid
+  if (radius != RADIUS) {
+    printf("radius is invalid, must be %d - see kernel for details.\n", RADIUS);
+    exit(EXIT_FAILURE);
+  }
+
+  // Get the number of CUDA enabled GPU devices
+  checkCudaErrors(cudaGetDeviceCount(&deviceCount));
+
+  // Select target device (device 0 by default)
+  targetDevice = findCudaDevice(argc, (const char **)argv);
+
+  checkCudaErrors(cudaSetDevice(targetDevice));
+
+  // Allocate memory buffers
+  checkCudaErrors(
+      cudaMalloc((void **)&bufferOut, paddedVolumeSize * sizeof(float)));
+  checkCudaErrors(
+      cudaMalloc((void **)&bufferIn, paddedVolumeSize * sizeof(float)));
+
+  // Check for a command-line specified block size
+  int userBlockSize;
+
+  if (checkCmdLineFlag(argc, (const char **)argv, "block-size")) {
+    userBlockSize = getCmdLineArgumentInt(argc, argv, "block-size");
+    // Constrain to a multiple of k_blockDimX
+    userBlockSize = (userBlockSize / k_blockDimX * k_blockDimX);
+
+    // Constrain within allowed bounds
+    userBlockSize = MIN(MAX(userBlockSize, k_blockSizeMin), k_blockSizeMax);
+  } else {
+    userBlockSize = k_blockSizeMax;
+  }
+
+  // Check the device limit on the number of threads
+  struct cudaFuncAttributes funcAttrib;
+  checkCudaErrors(cudaFuncGetAttributes(&funcAttrib, FiniteDifferencesKernel));
+
+  userBlockSize = MIN(userBlockSize, funcAttrib.maxThreadsPerBlock);
+
+  // Set the block size
+  dimBlock.x = k_blockDimX;
+  // Visual Studio 2005 does not like std::min
+  //    dimBlock.y = std::min<size_t>(userBlockSize / k_blockDimX,
+  //    (size_t)k_blockDimMaxY);
+  dimBlock.y = ((userBlockSize / k_blockDimX) < (size_t)k_blockDimMaxY)
+                   ? (userBlockSize / k_blockDimX)
+                   : (size_t)k_blockDimMaxY;
+  dimGrid.x = (unsigned int)ceil((float)dimx / dimBlock.x);
+  dimGrid.y = (unsigned int)ceil((float)dimy / dimBlock.y);
+  printf(" set block size to %dx%d\n", dimBlock.x, dimBlock.y);
+  printf(" set grid size to %dx%d\n", dimGrid.x, dimGrid.y);
+
+  // Check the block size is valid
+  if (dimBlock.x < RADIUS || dimBlock.y < RADIUS) {
+    printf("invalid block size, x (%d) and y (%d) must be >= radius (%d).\n",
+           dimBlock.x, dimBlock.y, RADIUS);
+    exit(EXIT_FAILURE);
+  }
+
+  // Copy the input to the device input buffer
+  checkCudaErrors(cudaMemcpy(bufferIn + padding, input,
+                             volumeSize * sizeof(float),
+                             cudaMemcpyHostToDevice));
+
+  // Copy the input to the device output buffer (actually only need the halo)
+  checkCudaErrors(cudaMemcpy(bufferOut + padding, input,
+                             volumeSize * sizeof(float),
+                             cudaMemcpyHostToDevice));
+
+  // Copy the coefficients to the device coefficient buffer
+  checkCudaErrors(
+      cudaMemcpyToSymbol(stencil, (void *)coeff, (radius + 1) * sizeof(float)));
+
+#ifdef GPU_PROFILING
+
+  // Create the events
+  checkCudaErrors(cudaEventCreate(&profileStart));
+  checkCudaErrors(cudaEventCreate(&profileEnd));
+
+#endif
+
+  // Execute the FDTD
+  float *bufferSrc = bufferIn + padding;
+  float *bufferDst = bufferOut + padding;
+  printf(" GPU FDTD loop\n");
+
+#ifdef GPU_PROFILING
+  // Enqueue start event
+  checkCudaErrors(cudaEventRecord(profileStart, 0));
+#endif
+
+  for (int it = 0; it < timesteps; it++) {
+    printf("\tt = %d ", it);
+
+    // Launch the kernel
+    printf("launch kernel\n");
+    FiniteDifferencesKernel<<<dimGrid, dimBlock>>>(bufferDst, bufferSrc, dimx,
+                                                   dimy, dimz);
+
+    // Toggle the buffers
+    // Visual Studio 2005 does not like std::swap
+    //    std::swap<float *>(bufferSrc, bufferDst);
+    float *tmp = bufferDst;
+    bufferDst = bufferSrc;
+    bufferSrc = tmp;
+  }
+
+  printf("\n");
+
+#ifdef GPU_PROFILING
+  // Enqueue end event
+  checkCudaErrors(cudaEventRecord(profileEnd, 0));
+#endif
+
+  // Wait for the kernel to complete
+  checkCudaErrors(cudaDeviceSynchronize());
+
+  // Read the result back, result is in bufferSrc (after final toggle)
+  checkCudaErrors(cudaMemcpy(output, bufferSrc, volumeSize * sizeof(float),
+                             cudaMemcpyDeviceToHost));
+
+// Report time
+#ifdef GPU_PROFILING
+  float elapsedTimeMS = 0;
+
+  if (profileTimesteps > 0) {
+    checkCudaErrors(
+        cudaEventElapsedTime(&elapsedTimeMS, profileStart, profileEnd));
+  }
+
+  if (profileTimesteps > 0) {
+    // Convert milliseconds to seconds
+    double elapsedTime = elapsedTimeMS * 1.0e-3;
+    double avgElapsedTime = elapsedTime / (double)profileTimesteps;
+    // Determine number of computations per timestep
+    size_t pointsComputed = dimx * dimy * dimz;
+    // Determine throughput
+    double throughputM = 1.0e-6 * (double)pointsComputed / avgElapsedTime;
+    printf(
+        "FDTD3d, Throughput = %.4f MPoints/s, Time = %.5f s, Size = %u Points, "
+        "NumDevsUsed = %u, Blocksize = %u\n",
+        throughputM, avgElapsedTime, pointsComputed, 1,
+        dimBlock.x * dimBlock.y);
+  }
+
+#endif
+
+  // Cleanup
+  if (bufferIn) {
+    checkCudaErrors(cudaFree(bufferIn));
+  }
+
+  if (bufferOut) {
+    checkCudaErrors(cudaFree(bufferOut));
+  }
+
+#ifdef GPU_PROFILING
+
+  if (profileStart) {
+    checkCudaErrors(cudaEventDestroy(profileStart));
+  }
+
+  if (profileEnd) {
+    checkCudaErrors(cudaEventDestroy(profileEnd));
+  }
+
+#endif
+  return true;
+}

Samples/5_Domain_Specific/FDTD3d/src/FDTD3dReference.cpp

@@ -0,0 +1,178 @@
+/* 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 "FDTD3dReference.h"
+
+#include <cstdlib>
+#include <cmath>
+#include <iostream>
+#include <iomanip>
+#include <stdio.h>
+
+void generateRandomData(float *data, const int dimx, const int dimy,
+                        const int dimz, const float lowerBound,
+                        const float upperBound) {
+  srand(0);
+
+  for (int iz = 0; iz < dimz; iz++) {
+    for (int iy = 0; iy < dimy; iy++) {
+      for (int ix = 0; ix < dimx; ix++) {
+        *data = (float)(lowerBound +
+                        ((float)rand() / (float)RAND_MAX) *
+                            (upperBound - lowerBound));
+        ++data;
+      }
+    }
+  }
+}
+
+void generatePatternData(float *data, const int dimx, const int dimy,
+                         const int dimz, const float lowerBound,
+                         const float upperBound) {
+  for (int iz = 0; iz < dimz; iz++) {
+    for (int iy = 0; iy < dimy; iy++) {
+      for (int ix = 0; ix < dimx; ix++) {
+        *data = (float)(lowerBound +
+                        ((float)iz / (float)dimz) * (upperBound - lowerBound));
+        ++data;
+      }
+    }
+  }
+}
+
+bool fdtdReference(float *output, const float *input, const float *coeff,
+                   const int dimx, const int dimy, const int dimz,
+                   const int radius, const int timesteps) {
+  const int outerDimx = dimx + 2 * radius;
+  const int outerDimy = dimy + 2 * radius;
+  const int outerDimz = dimz + 2 * radius;
+  const size_t volumeSize = outerDimx * outerDimy * outerDimz;
+  const int stride_y = outerDimx;
+  const int stride_z = stride_y * outerDimy;
+  float *intermediate = 0;
+  const float *bufsrc = 0;
+  float *bufdst = 0;
+  float *bufdstnext = 0;
+
+  // Allocate temporary buffer
+  printf(" calloc intermediate\n");
+  intermediate = (float *)calloc(volumeSize, sizeof(float));
+
+  // Decide which buffer to use first (result should end up in output)
+  if ((timesteps % 2) == 0) {
+    bufsrc = input;
+    bufdst = intermediate;
+    bufdstnext = output;
+  } else {
+    bufsrc = input;
+    bufdst = output;
+    bufdstnext = intermediate;
+  }
+
+  // Run the FDTD (naive method)
+  printf(" Host FDTD loop\n");
+
+  for (int it = 0; it < timesteps; it++) {
+    printf("\tt = %d\n", it);
+    const float *src = bufsrc;
+    float *dst = bufdst;
+
+    for (int iz = -radius; iz < dimz + radius; iz++) {
+      for (int iy = -radius; iy < dimy + radius; iy++) {
+        for (int ix = -radius; ix < dimx + radius; ix++) {
+          if (ix >= 0 && ix < dimx && iy >= 0 && iy < dimy && iz >= 0 &&
+              iz < dimz) {
+            float value = (*src) * coeff[0];
+
+            for (int ir = 1; ir <= radius; ir++) {
+              value += coeff[ir] * (*(src + ir) + *(src - ir));  // horizontal
+              value += coeff[ir] * (*(src + ir * stride_y) +
+                                    *(src - ir * stride_y));  // vertical
+              value +=
+                  coeff[ir] * (*(src + ir * stride_z) +
+                               *(src - ir * stride_z));  // in front & behind
+            }
+
+            *dst = value;
+          } else {
+            *dst = *src;
+          }
+
+          ++dst;
+          ++src;
+        }
+      }
+    }
+
+    // Rotate buffers
+    float *tmp = bufdst;
+    bufdst = bufdstnext;
+    bufdstnext = tmp;
+    bufsrc = (const float *)tmp;
+  }
+
+  printf("\n");
+
+  if (intermediate) free(intermediate);
+
+  return true;
+}
+
+bool compareData(const float *output, const float *reference, const int dimx,
+                 const int dimy, const int dimz, const int radius,
+                 const float tolerance) {
+  for (int iz = -radius; iz < dimz + radius; iz++) {
+    for (int iy = -radius; iy < dimy + radius; iy++) {
+      for (int ix = -radius; ix < dimx + radius; ix++) {
+        if (ix >= 0 && ix < dimx && iy >= 0 && iy < dimy && iz >= 0 &&
+            iz < dimz) {
+          // Determine the absolute difference
+          float difference = fabs(*reference - *output);
+          float error;
+
+          // Determine the relative error
+          if (*reference != 0)
+            error = difference / *reference;
+          else
+            error = difference;
+
+          // Check the error is within the tolerance
+          if (error > tolerance) {
+            printf("Data error at point (%d,%d,%d)\t%f instead of %f\n", ix, iy,
+                   iz, *output, *reference);
+            return false;
+          }
+        }
+
+        ++output;
+        ++reference;
+      }
+    }
+  }
+
+  return true;
+}

Samples/5_Domain_Specific/HSOpticalFlow/.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
+}

Samples/5_Domain_Specific/HSOpticalFlow/.vscode/extensions.json

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

Samples/5_Domain_Specific/HSOpticalFlow/.vscode/launch.json

@@ -0,0 +1,10 @@
+{
+    "configurations": [
+        {
+            "name": "CUDA C++: Launch",
+            "type": "cuda-gdb",
+            "request": "launch",
+            "program": "${workspaceFolder}/HSOpticalFlow"
+        }
+    ]
+}

Samples/5_Domain_Specific/HSOpticalFlow/.vscode/tasks.json

@@ -0,0 +1,15 @@
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "sample",
+            "type": "shell",
+            "command": "make dbg=1",
+            "problemMatcher": ["$nvcc"],
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            }
+        }
+    ]
+}

Samples/5_Domain_Specific/HSOpticalFlow/HSOpticalFlow_vs2017.sln

@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2017
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "HSOpticalFlow", "HSOpticalFlow_vs2017.vcxproj", "{997E0757-EA74-4A4E-A0FC-47D8C8831A15}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Release|x64 = Release|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Debug|x64.ActiveCfg = Debug|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Debug|x64.Build.0 = Debug|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Release|x64.ActiveCfg = Release|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Release|x64.Build.0 = Release|x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

Samples/5_Domain_Specific/HSOpticalFlow/HSOpticalFlow_vs2017.vcxproj

@@ -0,0 +1,122 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <CUDAPropsPath Condition="'$(CUDAPropsPath)'==''">$(VCTargetsPath)\BuildCustomizations</CUDAPropsPath>
+  </PropertyGroup>
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{997E0757-EA74-4A4E-A0FC-47D8C8831A15}</ProjectGuid>
+    <RootNamespace>HSOpticalFlow_vs2017</RootNamespace>
+    <ProjectName>HSOpticalFlow</ProjectName>
+    <CudaToolkitCustomDir />
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(WindowsTargetPlatformVersion)'==''">
+    <LatestTargetPlatformVersion>$([Microsoft.Build.Utilities.ToolLocationHelper]::GetLatestSDKTargetPlatformVersion('Windows', '10.0'))</LatestTargetPlatformVersion>
+    <WindowsTargetPlatformVersion Condition="'$(WindowsTargetPlatformVersion)' == ''">$(LatestTargetPlatformVersion)</WindowsTargetPlatformVersion>
+    <TargetPlatformVersion>$(WindowsTargetPlatformVersion)</TargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup>
+    <ConfigurationType>Application</ConfigurationType>
+    <CharacterSet>MultiByte</CharacterSet>
+    <PlatformToolset>v141</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Debug'">
+    <UseDebugLibraries>true</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Release'">
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.6.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <IntDir>$(Platform)/$(Configuration)/</IntDir>
+    <IncludePath>$(IncludePath)</IncludePath>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules />
+    <CodeAnalysisRuleAssemblies />
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Platform)'=='x64'">
+    <OutDir>../../../bin/win64/$(Configuration)/</OutDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;_MBCS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>./;$(CudaToolkitDir)/include;../../../Common;</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <AdditionalDependencies>cudart_static.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>$(CudaToolkitLibDir);</AdditionalLibraryDirectories>
+      <OutputFile>$(OutDir)/HSOpticalFlow.exe</OutputFile>
+    </Link>
+    <CudaCompile>
+      <CodeGeneration>compute_35,sm_35;compute_37,sm_37;compute_50,sm_50;compute_52,sm_52;compute_60,sm_60;compute_61,sm_61;compute_70,sm_70;compute_75,sm_75;compute_80,sm_80;compute_86,sm_86;</CodeGeneration>
+      <AdditionalOptions>-Xcompiler "/wd 4819"  --threads 0 </AdditionalOptions>
+      <Include>./;../../../Common</Include>
+      <Defines>WIN32</Defines>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Debug'">
+    <ClCompile>
+      <Optimization>Disabled</Optimization>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
+    </Link>
+    <CudaCompile>
+      <Runtime>MTd</Runtime>
+      <TargetMachinePlatform>64</TargetMachinePlatform>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Release'">
+    <ClCompile>
+      <Optimization>MaxSpeed</Optimization>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>false</GenerateDebugInformation>
+      <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
+    </Link>
+    <CudaCompile>
+      <Runtime>MT</Runtime>
+      <TargetMachinePlatform>64</TargetMachinePlatform>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <CudaCompile Include="flowCUDA.cu" />
+    <ClCompile Include="flowGold.cpp" />
+    <ClCompile Include="main.cpp" />
+    <ClInclude Include="common.h" />
+    <ClInclude Include="flowCUDA.h" />
+    <ClInclude Include="flowGold.h" />
+    <None Include="addKernel.cuh" />
+    <None Include="derivativesKernel.cuh" />
+    <None Include="downscaleKernel.cuh" />
+    <None Include="solverKernel.cuh" />
+    <None Include="upscaleKernel.cuh" />
+    <None Include="warpingKernel.cuh" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.6.targets" />
+  </ImportGroup>
+</Project>

Samples/5_Domain_Specific/HSOpticalFlow/HSOpticalFlow_vs2019.sln

@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2019
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "HSOpticalFlow", "HSOpticalFlow_vs2019.vcxproj", "{997E0757-EA74-4A4E-A0FC-47D8C8831A15}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Release|x64 = Release|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Debug|x64.ActiveCfg = Debug|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Debug|x64.Build.0 = Debug|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Release|x64.ActiveCfg = Release|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Release|x64.Build.0 = Release|x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

Samples/5_Domain_Specific/HSOpticalFlow/HSOpticalFlow_vs2019.vcxproj

@@ -0,0 +1,118 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <CUDAPropsPath Condition="'$(CUDAPropsPath)'==''">$(VCTargetsPath)\BuildCustomizations</CUDAPropsPath>
+  </PropertyGroup>
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{997E0757-EA74-4A4E-A0FC-47D8C8831A15}</ProjectGuid>
+    <RootNamespace>HSOpticalFlow_vs2019</RootNamespace>
+    <ProjectName>HSOpticalFlow</ProjectName>
+    <CudaToolkitCustomDir />
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup>
+    <ConfigurationType>Application</ConfigurationType>
+    <CharacterSet>MultiByte</CharacterSet>
+    <PlatformToolset>v142</PlatformToolset>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Debug'">
+    <UseDebugLibraries>true</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Release'">
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.6.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <IntDir>$(Platform)/$(Configuration)/</IntDir>
+    <IncludePath>$(IncludePath)</IncludePath>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules />
+    <CodeAnalysisRuleAssemblies />
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Platform)'=='x64'">
+    <OutDir>../../../bin/win64/$(Configuration)/</OutDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;_MBCS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>./;$(CudaToolkitDir)/include;../../../Common;</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <AdditionalDependencies>cudart_static.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>$(CudaToolkitLibDir);</AdditionalLibraryDirectories>
+      <OutputFile>$(OutDir)/HSOpticalFlow.exe</OutputFile>
+    </Link>
+    <CudaCompile>
+      <CodeGeneration>compute_35,sm_35;compute_37,sm_37;compute_50,sm_50;compute_52,sm_52;compute_60,sm_60;compute_61,sm_61;compute_70,sm_70;compute_75,sm_75;compute_80,sm_80;compute_86,sm_86;</CodeGeneration>
+      <AdditionalOptions>-Xcompiler "/wd 4819"  --threads 0 </AdditionalOptions>
+      <Include>./;../../../Common</Include>
+      <Defines>WIN32</Defines>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Debug'">
+    <ClCompile>
+      <Optimization>Disabled</Optimization>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
+    </Link>
+    <CudaCompile>
+      <Runtime>MTd</Runtime>
+      <TargetMachinePlatform>64</TargetMachinePlatform>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Release'">
+    <ClCompile>
+      <Optimization>MaxSpeed</Optimization>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>false</GenerateDebugInformation>
+      <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
+    </Link>
+    <CudaCompile>
+      <Runtime>MT</Runtime>
+      <TargetMachinePlatform>64</TargetMachinePlatform>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <CudaCompile Include="flowCUDA.cu" />
+    <ClCompile Include="flowGold.cpp" />
+    <ClCompile Include="main.cpp" />
+    <ClInclude Include="common.h" />
+    <ClInclude Include="flowCUDA.h" />
+    <ClInclude Include="flowGold.h" />
+    <None Include="addKernel.cuh" />
+    <None Include="derivativesKernel.cuh" />
+    <None Include="downscaleKernel.cuh" />
+    <None Include="solverKernel.cuh" />
+    <None Include="upscaleKernel.cuh" />
+    <None Include="warpingKernel.cuh" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.6.targets" />
+  </ImportGroup>
+</Project>

Samples/5_Domain_Specific/HSOpticalFlow/HSOpticalFlow_vs2022.sln

@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2022
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "HSOpticalFlow", "HSOpticalFlow_vs2022.vcxproj", "{997E0757-EA74-4A4E-A0FC-47D8C8831A15}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Release|x64 = Release|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Debug|x64.ActiveCfg = Debug|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Debug|x64.Build.0 = Debug|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Release|x64.ActiveCfg = Release|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Release|x64.Build.0 = Release|x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

Samples/5_Domain_Specific/HSOpticalFlow/HSOpticalFlow_vs2022.vcxproj

@@ -0,0 +1,118 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <CUDAPropsPath Condition="'$(CUDAPropsPath)'==''">$(VCTargetsPath)\BuildCustomizations</CUDAPropsPath>
+  </PropertyGroup>
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{997E0757-EA74-4A4E-A0FC-47D8C8831A15}</ProjectGuid>
+    <RootNamespace>HSOpticalFlow_vs2022</RootNamespace>
+    <ProjectName>HSOpticalFlow</ProjectName>
+    <CudaToolkitCustomDir />
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup>
+    <ConfigurationType>Application</ConfigurationType>
+    <CharacterSet>MultiByte</CharacterSet>
+    <PlatformToolset>v143</PlatformToolset>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Debug'">
+    <UseDebugLibraries>true</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Release'">
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.6.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <IntDir>$(Platform)/$(Configuration)/</IntDir>
+    <IncludePath>$(IncludePath)</IncludePath>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules />
+    <CodeAnalysisRuleAssemblies />
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Platform)'=='x64'">
+    <OutDir>../../../bin/win64/$(Configuration)/</OutDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;_MBCS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>./;$(CudaToolkitDir)/include;../../../Common;</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <AdditionalDependencies>cudart_static.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>$(CudaToolkitLibDir);</AdditionalLibraryDirectories>
+      <OutputFile>$(OutDir)/HSOpticalFlow.exe</OutputFile>
+    </Link>
+    <CudaCompile>
+      <CodeGeneration>compute_35,sm_35;compute_37,sm_37;compute_50,sm_50;compute_52,sm_52;compute_60,sm_60;compute_61,sm_61;compute_70,sm_70;compute_75,sm_75;compute_80,sm_80;compute_86,sm_86;</CodeGeneration>
+      <AdditionalOptions>-Xcompiler "/wd 4819"  --threads 0 </AdditionalOptions>
+      <Include>./;../../../Common</Include>
+      <Defines>WIN32</Defines>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Debug'">
+    <ClCompile>
+      <Optimization>Disabled</Optimization>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
+    </Link>
+    <CudaCompile>
+      <Runtime>MTd</Runtime>
+      <TargetMachinePlatform>64</TargetMachinePlatform>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Release'">
+    <ClCompile>
+      <Optimization>MaxSpeed</Optimization>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>false</GenerateDebugInformation>
+      <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
+    </Link>
+    <CudaCompile>
+      <Runtime>MT</Runtime>
+      <TargetMachinePlatform>64</TargetMachinePlatform>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <CudaCompile Include="flowCUDA.cu" />
+    <ClCompile Include="flowGold.cpp" />
+    <ClCompile Include="main.cpp" />
+    <ClInclude Include="common.h" />
+    <ClInclude Include="flowCUDA.h" />
+    <ClInclude Include="flowGold.h" />
+    <None Include="addKernel.cuh" />
+    <None Include="derivativesKernel.cuh" />
+    <None Include="downscaleKernel.cuh" />
+    <None Include="solverKernel.cuh" />
+    <None Include="upscaleKernel.cuh" />
+    <None Include="warpingKernel.cuh" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.6.targets" />
+  </ImportGroup>
+</Project>

Samples/5_Domain_Specific/HSOpticalFlow/Makefile

@@ -0,0 +1,346 @@
+################################################################################
+# 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.
+#
+################################################################################
+#
+# Makefile project only supported on Mac OS X and Linux Platforms)
+#
+################################################################################
+
+# Location of the CUDA Toolkit
+CUDA_PATH ?= /usr/local/cuda
+
+##############################
+# start deprecated interface #
+##############################
+ifeq ($(x86_64),1)
+    $(info WARNING - x86_64 variable has been deprecated)
+    $(info WARNING - please use TARGET_ARCH=x86_64 instead)
+    TARGET_ARCH ?= x86_64
+endif
+ifeq ($(ARMv7),1)
+    $(info WARNING - ARMv7 variable has been deprecated)
+    $(info WARNING - please use TARGET_ARCH=armv7l instead)
+    TARGET_ARCH ?= armv7l
+endif
+ifeq ($(aarch64),1)
+    $(info WARNING - aarch64 variable has been deprecated)
+    $(info WARNING - please use TARGET_ARCH=aarch64 instead)
+    TARGET_ARCH ?= aarch64
+endif
+ifeq ($(ppc64le),1)
+    $(info WARNING - ppc64le variable has been deprecated)
+    $(info WARNING - please use TARGET_ARCH=ppc64le instead)
+    TARGET_ARCH ?= ppc64le
+endif
+ifneq ($(GCC),)
+    $(info WARNING - GCC variable has been deprecated)
+    $(info WARNING - please use HOST_COMPILER=$(GCC) instead)
+    HOST_COMPILER ?= $(GCC)
+endif
+ifneq ($(abi),)
+    $(error ERROR - abi variable has been removed)
+endif
+############################
+# end deprecated interface #
+############################
+
+# architecture
+HOST_ARCH   := $(shell uname -m)
+TARGET_ARCH ?= $(HOST_ARCH)
+ifneq (,$(filter $(TARGET_ARCH),x86_64 aarch64 sbsa ppc64le armv7l))
+    ifneq ($(TARGET_ARCH),$(HOST_ARCH))
+        ifneq (,$(filter $(TARGET_ARCH),x86_64 aarch64 sbsa ppc64le))
+            TARGET_SIZE := 64
+        else ifneq (,$(filter $(TARGET_ARCH),armv7l))
+            TARGET_SIZE := 32
+        endif
+    else
+        TARGET_SIZE := $(shell getconf LONG_BIT)
+    endif
+else
+    $(error ERROR - unsupported value $(TARGET_ARCH) for TARGET_ARCH!)
+endif
+
+# sbsa and aarch64 systems look similar. Need to differentiate them at host level for now.
+ifeq ($(HOST_ARCH),aarch64)
+    ifeq ($(CUDA_PATH)/targets/sbsa-linux,$(shell ls -1d $(CUDA_PATH)/targets/sbsa-linux 2>/dev/null))
+        HOST_ARCH := sbsa
+        TARGET_ARCH := sbsa
+    endif
+endif
+
+ifneq ($(TARGET_ARCH),$(HOST_ARCH))
+    ifeq (,$(filter $(HOST_ARCH)-$(TARGET_ARCH),aarch64-armv7l x86_64-armv7l x86_64-aarch64 x86_64-sbsa x86_64-ppc64le))
+        $(error ERROR - cross compiling from $(HOST_ARCH) to $(TARGET_ARCH) is not supported!)
+    endif
+endif
+
+# When on native aarch64 system with userspace of 32-bit, change TARGET_ARCH to armv7l
+ifeq ($(HOST_ARCH)-$(TARGET_ARCH)-$(TARGET_SIZE),aarch64-aarch64-32)
+    TARGET_ARCH = armv7l
+endif
+
+# operating system
+HOST_OS   := $(shell uname -s 2>/dev/null | tr "[:upper:]" "[:lower:]")
+TARGET_OS ?= $(HOST_OS)
+ifeq (,$(filter $(TARGET_OS),linux darwin qnx android))
+    $(error ERROR - unsupported value $(TARGET_OS) for TARGET_OS!)
+endif
+
+# host compiler
+ifeq ($(TARGET_OS),darwin)
+    ifeq ($(shell expr `xcodebuild -version | grep -i xcode | awk '{print $$2}' | cut -d'.' -f1` \>= 5),1)
+        HOST_COMPILER ?= clang++
+    endif
+else ifneq ($(TARGET_ARCH),$(HOST_ARCH))
+    ifeq ($(HOST_ARCH)-$(TARGET_ARCH),x86_64-armv7l)
+        ifeq ($(TARGET_OS),linux)
+            HOST_COMPILER ?= arm-linux-gnueabihf-g++
+        else ifeq ($(TARGET_OS),qnx)
+            ifeq ($(QNX_HOST),)
+                $(error ERROR - QNX_HOST must be passed to the QNX host toolchain)
+            endif
+            ifeq ($(QNX_TARGET),)
+                $(error ERROR - QNX_TARGET must be passed to the QNX target toolchain)
+            endif
+            export QNX_HOST
+            export QNX_TARGET
+            HOST_COMPILER ?= $(QNX_HOST)/usr/bin/arm-unknown-nto-qnx6.6.0eabi-g++
+        else ifeq ($(TARGET_OS),android)
+            HOST_COMPILER ?= arm-linux-androideabi-g++
+        endif
+    else ifeq ($(TARGET_ARCH),aarch64)
+        ifeq ($(TARGET_OS), linux)
+            HOST_COMPILER ?= aarch64-linux-gnu-g++
+        else ifeq ($(TARGET_OS),qnx)
+            ifeq ($(QNX_HOST),)
+                $(error ERROR - QNX_HOST must be passed to the QNX host toolchain)
+            endif
+            ifeq ($(QNX_TARGET),)
+                $(error ERROR - QNX_TARGET must be passed to the QNX target toolchain)
+            endif
+            export QNX_HOST
+            export QNX_TARGET
+            HOST_COMPILER ?= $(QNX_HOST)/usr/bin/q++
+        else ifeq ($(TARGET_OS), android)
+            HOST_COMPILER ?= aarch64-linux-android-clang++
+        endif
+    else ifeq ($(TARGET_ARCH),sbsa)
+        HOST_COMPILER ?= aarch64-linux-gnu-g++
+    else ifeq ($(TARGET_ARCH),ppc64le)
+        HOST_COMPILER ?= powerpc64le-linux-gnu-g++
+    endif
+endif
+HOST_COMPILER ?= g++
+NVCC          := $(CUDA_PATH)/bin/nvcc -ccbin $(HOST_COMPILER)
+
+# internal flags
+NVCCFLAGS   := -m${TARGET_SIZE}
+CCFLAGS     :=
+LDFLAGS     :=
+
+# build flags
+ifeq ($(TARGET_OS),darwin)
+    LDFLAGS += -rpath $(CUDA_PATH)/lib
+    CCFLAGS += -arch $(HOST_ARCH)
+else ifeq ($(HOST_ARCH)-$(TARGET_ARCH)-$(TARGET_OS),x86_64-armv7l-linux)
+    LDFLAGS += --dynamic-linker=/lib/ld-linux-armhf.so.3
+    CCFLAGS += -mfloat-abi=hard
+else ifeq ($(TARGET_OS),android)
+    LDFLAGS += -pie
+    CCFLAGS += -fpie -fpic -fexceptions
+endif
+
+ifneq ($(TARGET_ARCH),$(HOST_ARCH))
+    ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-linux)
+        ifneq ($(TARGET_FS),)
+            GCCVERSIONLTEQ46 := $(shell expr `$(HOST_COMPILER) -dumpversion` \<= 4.6)
+            ifeq ($(GCCVERSIONLTEQ46),1)
+                CCFLAGS += --sysroot=$(TARGET_FS)
+            endif
+            LDFLAGS += --sysroot=$(TARGET_FS)
+            LDFLAGS += -rpath-link=$(TARGET_FS)/lib
+            LDFLAGS += -rpath-link=$(TARGET_FS)/usr/lib
+            LDFLAGS += -rpath-link=$(TARGET_FS)/usr/lib/arm-linux-gnueabihf
+        endif
+    endif
+    ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-linux)
+        ifneq ($(TARGET_FS),)
+            GCCVERSIONLTEQ46 := $(shell expr `$(HOST_COMPILER) -dumpversion` \<= 4.6)
+            ifeq ($(GCCVERSIONLTEQ46),1)
+                CCFLAGS += --sysroot=$(TARGET_FS)
+            endif
+            LDFLAGS += --sysroot=$(TARGET_FS)
+            LDFLAGS += -rpath-link=$(TARGET_FS)/lib -L$(TARGET_FS)/lib
+            LDFLAGS += -rpath-link=$(TARGET_FS)/lib/aarch64-linux-gnu -L$(TARGET_FS)/lib/aarch64-linux-gnu
+            LDFLAGS += -rpath-link=$(TARGET_FS)/usr/lib -L$(TARGET_FS)/usr/lib
+            LDFLAGS += -rpath-link=$(TARGET_FS)/usr/lib/aarch64-linux-gnu -L$(TARGET_FS)/usr/lib/aarch64-linux-gnu
+            LDFLAGS += --unresolved-symbols=ignore-in-shared-libs
+            CCFLAGS += -isystem=$(TARGET_FS)/usr/include -I$(TARGET_FS)/usr/include -I$(TARGET_FS)/usr/include/libdrm
+            CCFLAGS += -isystem=$(TARGET_FS)/usr/include/aarch64-linux-gnu -I$(TARGET_FS)/usr/include/aarch64-linux-gnu
+        endif
+    endif
+    ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-qnx)
+        NVCCFLAGS += -D_QNX_SOURCE
+        NVCCFLAGS += --qpp-config 8.3.0,gcc_ntoaarch64le
+        CCFLAGS += -DWIN_INTERFACE_CUSTOM -I/usr/include/aarch64-qnx-gnu
+        LDFLAGS += -lsocket
+        LDFLAGS += -L/usr/lib/aarch64-qnx-gnu
+        CCFLAGS += "-Wl\,-rpath-link\,/usr/lib/aarch64-qnx-gnu"
+        ifdef TARGET_OVERRIDE
+            LDFLAGS += -lslog2
+        endif
+
+        ifneq ($(TARGET_FS),)
+            LDFLAGS += -L$(TARGET_FS)/usr/lib
+            CCFLAGS += "-Wl\,-rpath-link\,$(TARGET_FS)/usr/lib"
+            LDFLAGS += -L$(TARGET_FS)/usr/libnvidia
+            CCFLAGS += "-Wl\,-rpath-link\,$(TARGET_FS)/usr/libnvidia"
+            CCFLAGS += -I$(TARGET_FS)/../include
+        endif
+    endif
+endif
+
+ifdef TARGET_OVERRIDE # cuda toolkit targets override
+    NVCCFLAGS += -target-dir $(TARGET_OVERRIDE)
+endif
+
+# Install directory of different arch
+CUDA_INSTALL_TARGET_DIR :=
+ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-linux)
+    CUDA_INSTALL_TARGET_DIR = targets/armv7-linux-gnueabihf/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-linux)
+    CUDA_INSTALL_TARGET_DIR = targets/aarch64-linux/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),sbsa-linux)
+    CUDA_INSTALL_TARGET_DIR = targets/sbsa-linux/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-android)
+    CUDA_INSTALL_TARGET_DIR = targets/armv7-linux-androideabi/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-android)
+    CUDA_INSTALL_TARGET_DIR = targets/aarch64-linux-androideabi/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-qnx)
+    CUDA_INSTALL_TARGET_DIR = targets/ARMv7-linux-QNX/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-qnx)
+    CUDA_INSTALL_TARGET_DIR = targets/aarch64-qnx/
+else ifeq ($(TARGET_ARCH),ppc64le)
+    CUDA_INSTALL_TARGET_DIR = targets/ppc64le-linux/
+endif
+
+# Debug build flags
+ifeq ($(dbg),1)
+      NVCCFLAGS += -g -G
+      BUILD_TYPE := debug
+else
+      BUILD_TYPE := release
+endif
+
+ALL_CCFLAGS :=
+ALL_CCFLAGS += $(NVCCFLAGS)
+ALL_CCFLAGS += $(EXTRA_NVCCFLAGS)
+ALL_CCFLAGS += $(addprefix -Xcompiler ,$(CCFLAGS))
+ALL_CCFLAGS += $(addprefix -Xcompiler ,$(EXTRA_CCFLAGS))
+
+SAMPLE_ENABLED := 1
+
+ALL_LDFLAGS :=
+ALL_LDFLAGS += $(ALL_CCFLAGS)
+ALL_LDFLAGS += $(addprefix -Xlinker ,$(LDFLAGS))
+ALL_LDFLAGS += $(addprefix -Xlinker ,$(EXTRA_LDFLAGS))
+
+# Common includes and paths for CUDA
+INCLUDES  := -I../../../Common
+LIBRARIES :=
+
+################################################################################
+
+# Gencode arguments
+ifeq ($(TARGET_ARCH),$(filter $(TARGET_ARCH),armv7l aarch64 sbsa))
+SMS ?= 53 61 70 72 75 80 86 87
+else
+SMS ?= 35 37 50 52 60 61 70 75 80 86
+endif
+
+ifeq ($(SMS),)
+$(info >>> WARNING - no SM architectures have been specified - waiving sample <<<)
+SAMPLE_ENABLED := 0
+endif
+
+ifeq ($(GENCODE_FLAGS),)
+# Generate SASS code for each SM architecture listed in $(SMS)
+$(foreach sm,$(SMS),$(eval GENCODE_FLAGS += -gencode arch=compute_$(sm),code=sm_$(sm)))
+
+# Generate PTX code from the highest SM architecture in $(SMS) to guarantee forward-compatibility
+HIGHEST_SM := $(lastword $(sort $(SMS)))
+ifneq ($(HIGHEST_SM),)
+GENCODE_FLAGS += -gencode arch=compute_$(HIGHEST_SM),code=compute_$(HIGHEST_SM)
+endif
+endif
+
+ALL_CCFLAGS += --threads 0 --std=c++11
+
+ifeq ($(SAMPLE_ENABLED),0)
+EXEC ?= @echo "[@]"
+endif
+
+################################################################################
+
+# Target rules
+all: build
+
+build: HSOpticalFlow
+
+check.deps:
+ifeq ($(SAMPLE_ENABLED),0)
+	@echo "Sample will be waived due to the above missing dependencies"
+else
+	@echo "Sample is ready - all dependencies have been met"
+endif
+
+flowCUDA.o:flowCUDA.cu
+	$(EXEC) $(NVCC) $(INCLUDES) $(ALL_CCFLAGS) $(GENCODE_FLAGS) -o $@ -c $<
+
+flowGold.o:flowGold.cpp
+	$(EXEC) $(NVCC) $(INCLUDES) $(ALL_CCFLAGS) $(GENCODE_FLAGS) -o $@ -c $<
+
+main.o:main.cpp
+	$(EXEC) $(NVCC) $(INCLUDES) $(ALL_CCFLAGS) $(GENCODE_FLAGS) -o $@ -c $<
+
+HSOpticalFlow: flowCUDA.o flowGold.o main.o
+	$(EXEC) $(NVCC) $(ALL_LDFLAGS) $(GENCODE_FLAGS) -o $@ $+ $(LIBRARIES)
+	$(EXEC) mkdir -p ../../../bin/$(TARGET_ARCH)/$(TARGET_OS)/$(BUILD_TYPE)
+	$(EXEC) cp $@ ../../../bin/$(TARGET_ARCH)/$(TARGET_OS)/$(BUILD_TYPE)
+
+run: build
+	$(EXEC) ./HSOpticalFlow
+
+testrun: build
+
+clean:
+	rm -f HSOpticalFlow flowCUDA.o flowGold.o main.o
+	rm -rf ../../../bin/$(TARGET_ARCH)/$(TARGET_OS)/$(BUILD_TYPE)/HSOpticalFlow
+
+clobber: clean

Samples/5_Domain_Specific/HSOpticalFlow/NsightEclipse.xml

@@ -0,0 +1,84 @@
+<?xml version="1.0" encoding="UTF-8"?> 
+<!DOCTYPE entry SYSTEM "SamplesInfo.dtd">
+<entry>
+  <name>HSOpticalFlow</name>
+  <cuda_api_list>
+    <toolkit>cudaMalloc</toolkit>
+    <toolkit>cudaMemset</toolkit>
+    <toolkit>cudaFree</toolkit>
+    <toolkit>cudaMemcpy</toolkit>
+  </cuda_api_list>
+  <description><![CDATA[Variational optical flow estimation example.  Uses textures for image operations. Shows how simple PDE solver can be accelerated with CUDA.]]></description>
+  <devicecompilation>whole</devicecompilation>
+  <files>
+    <file>data\frame10.ppm</file>
+    <file>data\frame11.ppm</file>
+  </files>
+  <includepaths>
+    <path>./</path>
+    <path>../</path>
+    <path>../../../Common</path>
+  </includepaths>
+  <keyconcepts>
+    <concept level="advanced">Image Processing</concept>
+    <concept level="advanced">Data Parallel Algorithms</concept>
+  </keyconcepts>
+  <keywords>
+    <keyword>optical flow</keyword>
+    <keyword>motion estimation</keyword>
+    <keyword>texture</keyword>
+    <keyword>shared memory</keyword>
+  </keywords>
+  <libraries>
+  </libraries>
+  <librarypaths>
+  </librarypaths>
+  <nsight_eclipse>true</nsight_eclipse>
+  <primary_file>main.cpp</primary_file>
+  <scopes>
+    <scope>1:CUDA Advanced Topics</scope>
+    <scope>2:Image Processing</scope>
+  </scopes>
+  <sm-arch>sm35</sm-arch>
+  <sm-arch>sm37</sm-arch>
+  <sm-arch>sm50</sm-arch>
+  <sm-arch>sm52</sm-arch>
+  <sm-arch>sm53</sm-arch>
+  <sm-arch>sm60</sm-arch>
+  <sm-arch>sm61</sm-arch>
+  <sm-arch>sm70</sm-arch>
+  <sm-arch>sm72</sm-arch>
+  <sm-arch>sm75</sm-arch>
+  <sm-arch>sm80</sm-arch>
+  <sm-arch>sm86</sm-arch>
+  <sm-arch>sm87</sm-arch>
+  <supported_envs>
+    <env>
+      <arch>x86_64</arch>
+      <platform>linux</platform>
+    </env>
+    <env>
+      <platform>windows7</platform>
+    </env>
+    <env>
+      <arch>x86_64</arch>
+      <platform>macosx</platform>
+    </env>
+    <env>
+      <arch>arm</arch>
+    </env>
+    <env>
+      <arch>sbsa</arch>
+    </env>
+    <env>
+      <arch>ppc64le</arch>
+      <platform>linux</platform>
+    </env>
+  </supported_envs>
+  <supported_sm_architectures>
+    <include>all</include>
+  </supported_sm_architectures>
+  <title>Optical Flow</title>
+  <type>exe</type>
+  <whitepaper>doc\OpticalFlow.pdf</whitepaper>
+</entry>

Samples/5_Domain_Specific/HSOpticalFlow/README.md

@@ -0,0 +1,71 @@
+# HSOpticalFlow - Optical Flow
+
+## Description
+
+Variational optical flow estimation example.  Uses textures for image operations. Shows how simple PDE solver can be accelerated with CUDA.
+
+## Key Concepts
+
+Image Processing, Data Parallel Algorithms
+
+## Supported SM Architectures
+
+[SM 3.5 ](https://developer.nvidia.com/cuda-gpus)  [SM 3.7 ](https://developer.nvidia.com/cuda-gpus)  [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)
+
+## Supported OSes
+
+Linux, Windows
+
+## Supported CPU Architecture
+
+x86_64, ppc64le, armv7l
+
+## CUDA APIs involved
+
+### [CUDA Runtime API](http://docs.nvidia.com/cuda/cuda-runtime-api/index.html)
+cudaMalloc, cudaMemset, cudaFree, cudaMemcpy
+
+## Prerequisites
+
+Download and install the [CUDA Toolkit 11.6](https://developer.nvidia.com/cuda-downloads) for your corresponding platform.
+
+## Build and Run
+
+### Windows
+The Windows samples are built using the Visual Studio IDE. Solution files (.sln) are provided for each supported version of Visual Studio, using the format:
+```
+*_vs<version>.sln - for Visual Studio <version>
+```
+Each individual sample has its own set of solution files in its directory:
+
+To build/examine all the samples at once, the complete solution files should be used. To build/examine a single sample, the individual sample solution files should be used.
+> **Note:** Some samples require that the Microsoft DirectX SDK (June 2010 or newer) be installed and that the VC++ directory paths are properly set up (**Tools > Options...**). Check DirectX Dependencies section for details."
+
+### Linux
+The Linux samples are built using makefiles. To use the makefiles, change the current directory to the sample directory you wish to build, and run make:
+```
+$ cd <sample_dir>
+$ make
+```
+The samples makefiles can take advantage of certain options:
+*  **TARGET_ARCH=<arch>** - cross-compile targeting a specific architecture. Allowed architectures are x86_64, ppc64le, armv7l.
+    By default, TARGET_ARCH is set to HOST_ARCH. On a x86_64 machine, not setting TARGET_ARCH is the equivalent of setting TARGET_ARCH=x86_64.<br/>
+`$ make TARGET_ARCH=x86_64` <br/> `$ make TARGET_ARCH=ppc64le` <br/> `$ make TARGET_ARCH=armv7l` <br/>
+    See [here](http://docs.nvidia.com/cuda/cuda-samples/index.html#cross-samples) for more details.
+*   **dbg=1** - build with debug symbols
+    ```
+    $ make dbg=1
+    ```
+*   **SMS="A B ..."** - override the SM architectures for which the sample will be built, where `"A B ..."` is a space-delimited list of SM architectures. For example, to generate SASS for SM 50 and SM 60, use `SMS="50 60"`.
+    ```
+    $ make SMS="50 60"
+    ```
+
+*  **HOST_COMPILER=<host_compiler>** - override the default g++ host compiler. See the [Linux Installation Guide](http://docs.nvidia.com/cuda/cuda-installation-guide-linux/index.html#system-requirements) for a list of supported host compilers.
+```
+    $ make HOST_COMPILER=g++
+```
+
+## References (for more details)
+
+[whitepaper](./doc/OpticalFlow.pdf)

Samples/5_Domain_Specific/HSOpticalFlow/addKernel.cuh

@@ -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.
+ */
+
+#include "common.h"
+
+///////////////////////////////////////////////////////////////////////////////
+/// \brief add two vectors of size _count_
+///
+/// CUDA kernel
+/// \param[in]  op1   term one
+/// \param[in]  op2   term two
+/// \param[in]  count vector size
+/// \param[out] sum   result
+///////////////////////////////////////////////////////////////////////////////
+__global__ void AddKernel(const float *op1, const float *op2, int count,
+                          float *sum) {
+  const int pos = threadIdx.x + blockIdx.x * blockDim.x;
+
+  if (pos >= count) return;
+
+  sum[pos] = op1[pos] + op2[pos];
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// \brief add two vectors of size _count_
+/// \param[in]  op1   term one
+/// \param[in]  op2   term two
+/// \param[in]  count vector size
+/// \param[out] sum   result
+///////////////////////////////////////////////////////////////////////////////
+static void Add(const float *op1, const float *op2, int count, float *sum) {
+  dim3 threads(256);
+  dim3 blocks(iDivUp(count, threads.x));
+
+  AddKernel<<<blocks, threads>>>(op1, op2, count, sum);
+}

Samples/5_Domain_Specific/HSOpticalFlow/common.h

@@ -0,0 +1,76 @@
+/* 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.
+ */
+
+///////////////////////////////////////////////////////////////////////////////
+// Header for common includes and utility functions
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef COMMON_H
+#define COMMON_H
+
+///////////////////////////////////////////////////////////////////////////////
+// Common includes
+///////////////////////////////////////////////////////////////////////////////
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <time.h>
+#include <memory.h>
+#include <math.h>
+
+#include <helper_cuda.h>
+
+///////////////////////////////////////////////////////////////////////////////
+// Common constants
+///////////////////////////////////////////////////////////////////////////////
+const int StrideAlignment = 32;
+
+///////////////////////////////////////////////////////////////////////////////
+// Common functions
+///////////////////////////////////////////////////////////////////////////////
+
+// Align up n to the nearest multiple of m
+inline int iAlignUp(int n, int m = StrideAlignment) {
+  int mod = n % m;
+
+  if (mod)
+    return n + m - mod;
+  else
+    return n;
+}
+
+// round up n/m
+inline int iDivUp(int n, int m) { return (n + m - 1) / m; }
+
+// swap two values
+template <typename T>
+inline void Swap(T &a, T &b) {
+  T t = a;
+  a = b;
+  b = t;
+}
+#endif

Samples/5_Domain_Specific/HSOpticalFlow/derivativesKernel.cuh

@@ -0,0 +1,144 @@
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "common.h"
+
+///////////////////////////////////////////////////////////////////////////////
+/// \brief compute image derivatives
+///
+/// CUDA kernel, relies heavily on texture unit
+/// \param[in]  width   image width
+/// \param[in]  height  image height
+/// \param[in]  stride  image stride
+/// \param[out] Ix      x derivative
+/// \param[out] Iy      y derivative
+/// \param[out] Iz      temporal derivative
+///////////////////////////////////////////////////////////////////////////////
+__global__ void ComputeDerivativesKernel(int width, int height, int stride,
+                                         float *Ix, float *Iy, float *Iz,
+                                         cudaTextureObject_t texSource,
+                                         cudaTextureObject_t texTarget) {
+  const int ix = threadIdx.x + blockIdx.x * blockDim.x;
+  const int iy = threadIdx.y + blockIdx.y * blockDim.y;
+
+  const int pos = ix + iy * stride;
+
+  if (ix >= width || iy >= height) return;
+
+  float dx = 1.0f / (float)width;
+  float dy = 1.0f / (float)height;
+
+  float x = ((float)ix + 0.5f) * dx;
+  float y = ((float)iy + 0.5f) * dy;
+
+  float t0, t1;
+  // x derivative
+  t0 = tex2D<float>(texSource, x - 2.0f * dx, y);
+  t0 -= tex2D<float>(texSource, x - 1.0f * dx, y) * 8.0f;
+  t0 += tex2D<float>(texSource, x + 1.0f * dx, y) * 8.0f;
+  t0 -= tex2D<float>(texSource, x + 2.0f * dx, y);
+  t0 /= 12.0f;
+
+  t1 = tex2D<float>(texTarget, x - 2.0f * dx, y);
+  t1 -= tex2D<float>(texTarget, x - 1.0f * dx, y) * 8.0f;
+  t1 += tex2D<float>(texTarget, x + 1.0f * dx, y) * 8.0f;
+  t1 -= tex2D<float>(texTarget, x + 2.0f * dx, y);
+  t1 /= 12.0f;
+
+  Ix[pos] = (t0 + t1) * 0.5f;
+
+  // t derivative
+  Iz[pos] = tex2D<float>(texTarget, x, y) - tex2D<float>(texSource, x, y);
+
+  // y derivative
+  t0 = tex2D<float>(texSource, x, y - 2.0f * dy);
+  t0 -= tex2D<float>(texSource, x, y - 1.0f * dy) * 8.0f;
+  t0 += tex2D<float>(texSource, x, y + 1.0f * dy) * 8.0f;
+  t0 -= tex2D<float>(texSource, x, y + 2.0f * dy);
+  t0 /= 12.0f;
+
+  t1 = tex2D<float>(texTarget, x, y - 2.0f * dy);
+  t1 -= tex2D<float>(texTarget, x, y - 1.0f * dy) * 8.0f;
+  t1 += tex2D<float>(texTarget, x, y + 1.0f * dy) * 8.0f;
+  t1 -= tex2D<float>(texTarget, x, y + 2.0f * dy);
+  t1 /= 12.0f;
+
+  Iy[pos] = (t0 + t1) * 0.5f;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// \brief compute image derivatives
+///
+/// \param[in]  I0  source image
+/// \param[in]  I1  tracked image
+/// \param[in]  w   image width
+/// \param[in]  h   image height
+/// \param[in]  s   image stride
+/// \param[out] Ix  x derivative
+/// \param[out] Iy  y derivative
+/// \param[out] Iz  temporal derivative
+///////////////////////////////////////////////////////////////////////////////
+static void ComputeDerivatives(const float *I0, const float *I1, int w, int h,
+                               int s, float *Ix, float *Iy, float *Iz) {
+  dim3 threads(32, 6);
+  dim3 blocks(iDivUp(w, threads.x), iDivUp(h, threads.y));
+
+  cudaTextureObject_t texSource, texTarget;
+  cudaResourceDesc texRes;
+  memset(&texRes, 0, sizeof(cudaResourceDesc));
+
+  texRes.resType = cudaResourceTypePitch2D;
+  texRes.res.pitch2D.devPtr = (void *)I0;
+  texRes.res.pitch2D.desc = cudaCreateChannelDesc<float>();
+  texRes.res.pitch2D.width = w;
+  texRes.res.pitch2D.height = h;
+  texRes.res.pitch2D.pitchInBytes = s * sizeof(float);
+
+  cudaTextureDesc texDescr;
+  memset(&texDescr, 0, sizeof(cudaTextureDesc));
+
+  texDescr.normalizedCoords = true;
+  texDescr.filterMode = cudaFilterModeLinear;
+  texDescr.addressMode[0] = cudaAddressModeMirror;
+  texDescr.addressMode[1] = cudaAddressModeMirror;
+  texDescr.readMode = cudaReadModeElementType;
+
+  checkCudaErrors(
+      cudaCreateTextureObject(&texSource, &texRes, &texDescr, NULL));
+  memset(&texRes, 0, sizeof(cudaResourceDesc));
+  texRes.resType = cudaResourceTypePitch2D;
+  texRes.res.pitch2D.devPtr = (void *)I1;
+  texRes.res.pitch2D.desc = cudaCreateChannelDesc<float>();
+  texRes.res.pitch2D.width = w;
+  texRes.res.pitch2D.height = h;
+  texRes.res.pitch2D.pitchInBytes = s * sizeof(float);
+  checkCudaErrors(
+      cudaCreateTextureObject(&texTarget, &texRes, &texDescr, NULL));
+
+  ComputeDerivativesKernel<<<blocks, threads>>>(w, h, s, Ix, Iy, Iz, texSource,
+                                                texTarget);
+}

Samples/5_Domain_Specific/HSOpticalFlow/downscaleKernel.cuh

@@ -0,0 +1,98 @@
+/* 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 "common.h"
+
+///////////////////////////////////////////////////////////////////////////////
+/// \brief downscale image
+///
+/// CUDA kernel, relies heavily on texture unit
+/// \param[in]  width   image width
+/// \param[in]  height  image height
+/// \param[in]  stride  image stride
+/// \param[out] out     result
+///////////////////////////////////////////////////////////////////////////////
+__global__ void DownscaleKernel(int width, int height, int stride, float *out,
+                                cudaTextureObject_t texFine) {
+  const int ix = threadIdx.x + blockIdx.x * blockDim.x;
+  const int iy = threadIdx.y + blockIdx.y * blockDim.y;
+
+  if (ix >= width || iy >= height) {
+    return;
+  }
+
+  float dx = 1.0f / (float)width;
+  float dy = 1.0f / (float)height;
+
+  float x = ((float)ix + 0.5f) * dx;
+  float y = ((float)iy + 0.5f) * dy;
+
+  out[ix + iy * stride] = 0.25f * (tex2D<float>(texFine, x - dx * 0.25f, y) +
+                                   tex2D<float>(texFine, x + dx * 0.25f, y) +
+                                   tex2D<float>(texFine, x, y - dy * 0.25f) +
+                                   tex2D<float>(texFine, x, y + dy * 0.25f));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// \brief downscale image
+///
+/// \param[in]  src     image to downscale
+/// \param[in]  width   image width
+/// \param[in]  height  image height
+/// \param[in]  stride  image stride
+/// \param[out] out     result
+///////////////////////////////////////////////////////////////////////////////
+static void Downscale(const float *src, int width, int height, int stride,
+                      int newWidth, int newHeight, int newStride, float *out) {
+  dim3 threads(32, 8);
+  dim3 blocks(iDivUp(newWidth, threads.x), iDivUp(newHeight, threads.y));
+
+  cudaTextureObject_t texFine;
+  cudaResourceDesc texRes;
+  memset(&texRes, 0, sizeof(cudaResourceDesc));
+
+  texRes.resType = cudaResourceTypePitch2D;
+  texRes.res.pitch2D.devPtr = (void *)src;
+  texRes.res.pitch2D.desc = cudaCreateChannelDesc<float>();
+  texRes.res.pitch2D.width = width;
+  texRes.res.pitch2D.height = height;
+  texRes.res.pitch2D.pitchInBytes = stride * sizeof(float);
+
+  cudaTextureDesc texDescr;
+  memset(&texDescr, 0, sizeof(cudaTextureDesc));
+
+  texDescr.normalizedCoords = true;
+  texDescr.filterMode = cudaFilterModeLinear;
+  texDescr.addressMode[0] = cudaAddressModeMirror;
+  texDescr.addressMode[1] = cudaAddressModeMirror;
+  texDescr.readMode = cudaReadModeElementType;
+
+  checkCudaErrors(cudaCreateTextureObject(&texFine, &texRes, &texDescr, NULL));
+
+  DownscaleKernel<<<blocks, threads>>>(newWidth, newHeight, newStride, out,
+                                       texFine);
+}

Samples/5_Domain_Specific/HSOpticalFlow/flowCUDA.cu

@@ -0,0 +1,216 @@
+/* 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 "common.h"
+
+// include kernels
+#include "downscaleKernel.cuh"
+#include "upscaleKernel.cuh"
+#include "warpingKernel.cuh"
+#include "derivativesKernel.cuh"
+#include "solverKernel.cuh"
+#include "addKernel.cuh"
+
+///////////////////////////////////////////////////////////////////////////////
+/// \brief method logic
+///
+/// handles memory allocations, control flow
+/// \param[in]  I0           source image
+/// \param[in]  I1           tracked image
+/// \param[in]  width        images width
+/// \param[in]  height       images height
+/// \param[in]  stride       images stride
+/// \param[in]  alpha        degree of displacement field smoothness
+/// \param[in]  nLevels      number of levels in a pyramid
+/// \param[in]  nWarpIters   number of warping iterations per pyramid level
+/// \param[in]  nSolverIters number of solver iterations (Jacobi iterations)
+/// \param[out] u            horizontal displacement
+/// \param[out] v            vertical displacement
+///////////////////////////////////////////////////////////////////////////////
+void ComputeFlowCUDA(const float *I0, const float *I1, int width, int height,
+                     int stride, float alpha, int nLevels, int nWarpIters,
+                     int nSolverIters, float *u, float *v) {
+  printf("Computing optical flow on GPU...\n");
+
+  // pI0 and pI1 will hold device pointers
+  const float **pI0 = new const float *[nLevels];
+  const float **pI1 = new const float *[nLevels];
+
+  int *pW = new int[nLevels];
+  int *pH = new int[nLevels];
+  int *pS = new int[nLevels];
+
+  // device memory pointers
+  float *d_tmp;
+  float *d_du0;
+  float *d_dv0;
+  float *d_du1;
+  float *d_dv1;
+
+  float *d_Ix;
+  float *d_Iy;
+  float *d_Iz;
+
+  float *d_u;
+  float *d_v;
+  float *d_nu;
+  float *d_nv;
+
+  const int dataSize = stride * height * sizeof(float);
+
+  checkCudaErrors(cudaMalloc(&d_tmp, dataSize));
+  checkCudaErrors(cudaMalloc(&d_du0, dataSize));
+  checkCudaErrors(cudaMalloc(&d_dv0, dataSize));
+  checkCudaErrors(cudaMalloc(&d_du1, dataSize));
+  checkCudaErrors(cudaMalloc(&d_dv1, dataSize));
+
+  checkCudaErrors(cudaMalloc(&d_Ix, dataSize));
+  checkCudaErrors(cudaMalloc(&d_Iy, dataSize));
+  checkCudaErrors(cudaMalloc(&d_Iz, dataSize));
+
+  checkCudaErrors(cudaMalloc(&d_u, dataSize));
+  checkCudaErrors(cudaMalloc(&d_v, dataSize));
+  checkCudaErrors(cudaMalloc(&d_nu, dataSize));
+  checkCudaErrors(cudaMalloc(&d_nv, dataSize));
+
+  // prepare pyramid
+
+  int currentLevel = nLevels - 1;
+  // allocate GPU memory for input images
+  checkCudaErrors(cudaMalloc(pI0 + currentLevel, dataSize));
+  checkCudaErrors(cudaMalloc(pI1 + currentLevel, dataSize));
+
+  checkCudaErrors(cudaMemcpy((void *)pI0[currentLevel], I0, dataSize,
+                             cudaMemcpyHostToDevice));
+  checkCudaErrors(cudaMemcpy((void *)pI1[currentLevel], I1, dataSize,
+                             cudaMemcpyHostToDevice));
+
+  pW[currentLevel] = width;
+  pH[currentLevel] = height;
+  pS[currentLevel] = stride;
+
+  for (; currentLevel > 0; --currentLevel) {
+    int nw = pW[currentLevel] / 2;
+    int nh = pH[currentLevel] / 2;
+    int ns = iAlignUp(nw);
+
+    checkCudaErrors(
+        cudaMalloc(pI0 + currentLevel - 1, ns * nh * sizeof(float)));
+    checkCudaErrors(
+        cudaMalloc(pI1 + currentLevel - 1, ns * nh * sizeof(float)));
+
+    Downscale(pI0[currentLevel], pW[currentLevel], pH[currentLevel],
+              pS[currentLevel], nw, nh, ns, (float *)pI0[currentLevel - 1]);
+
+    Downscale(pI1[currentLevel], pW[currentLevel], pH[currentLevel],
+              pS[currentLevel], nw, nh, ns, (float *)pI1[currentLevel - 1]);
+
+    pW[currentLevel - 1] = nw;
+    pH[currentLevel - 1] = nh;
+    pS[currentLevel - 1] = ns;
+  }
+
+  checkCudaErrors(cudaMemset(d_u, 0, stride * height * sizeof(float)));
+  checkCudaErrors(cudaMemset(d_v, 0, stride * height * sizeof(float)));
+
+  // compute flow
+  for (; currentLevel < nLevels; ++currentLevel) {
+    for (int warpIter = 0; warpIter < nWarpIters; ++warpIter) {
+      checkCudaErrors(cudaMemset(d_du0, 0, dataSize));
+      checkCudaErrors(cudaMemset(d_dv0, 0, dataSize));
+
+      checkCudaErrors(cudaMemset(d_du1, 0, dataSize));
+      checkCudaErrors(cudaMemset(d_dv1, 0, dataSize));
+
+      // on current level we compute optical flow
+      // between frame 0 and warped frame 1
+      WarpImage(pI1[currentLevel], pW[currentLevel], pH[currentLevel],
+                pS[currentLevel], d_u, d_v, d_tmp);
+
+      ComputeDerivatives(pI0[currentLevel], d_tmp, pW[currentLevel],
+                         pH[currentLevel], pS[currentLevel], d_Ix, d_Iy, d_Iz);
+
+      for (int iter = 0; iter < nSolverIters; ++iter) {
+        SolveForUpdate(d_du0, d_dv0, d_Ix, d_Iy, d_Iz, pW[currentLevel],
+                       pH[currentLevel], pS[currentLevel], alpha, d_du1, d_dv1);
+
+        Swap(d_du0, d_du1);
+        Swap(d_dv0, d_dv1);
+      }
+
+      // update u, v
+      Add(d_u, d_du0, pH[currentLevel] * pS[currentLevel], d_u);
+      Add(d_v, d_dv0, pH[currentLevel] * pS[currentLevel], d_v);
+    }
+
+    if (currentLevel != nLevels - 1) {
+      // prolongate solution
+      float scaleX = (float)pW[currentLevel + 1] / (float)pW[currentLevel];
+
+      Upscale(d_u, pW[currentLevel], pH[currentLevel], pS[currentLevel],
+              pW[currentLevel + 1], pH[currentLevel + 1], pS[currentLevel + 1],
+              scaleX, d_nu);
+
+      float scaleY = (float)pH[currentLevel + 1] / (float)pH[currentLevel];
+
+      Upscale(d_v, pW[currentLevel], pH[currentLevel], pS[currentLevel],
+              pW[currentLevel + 1], pH[currentLevel + 1], pS[currentLevel + 1],
+              scaleY, d_nv);
+
+      Swap(d_u, d_nu);
+      Swap(d_v, d_nv);
+    }
+  }
+
+  checkCudaErrors(cudaMemcpy(u, d_u, dataSize, cudaMemcpyDeviceToHost));
+  checkCudaErrors(cudaMemcpy(v, d_v, dataSize, cudaMemcpyDeviceToHost));
+
+  // cleanup
+  for (int i = 0; i < nLevels; ++i) {
+    checkCudaErrors(cudaFree((void *)pI0[i]));
+    checkCudaErrors(cudaFree((void *)pI1[i]));
+  }
+
+  delete[] pI0;
+  delete[] pI1;
+  delete[] pW;
+  delete[] pH;
+  delete[] pS;
+
+  checkCudaErrors(cudaFree(d_tmp));
+  checkCudaErrors(cudaFree(d_du0));
+  checkCudaErrors(cudaFree(d_dv0));
+  checkCudaErrors(cudaFree(d_du1));
+  checkCudaErrors(cudaFree(d_dv1));
+  checkCudaErrors(cudaFree(d_Ix));
+  checkCudaErrors(cudaFree(d_Iy));
+  checkCudaErrors(cudaFree(d_Iz));
+  checkCudaErrors(cudaFree(d_nu));
+  checkCudaErrors(cudaFree(d_nv));
+  checkCudaErrors(cudaFree(d_u));
+  checkCudaErrors(cudaFree(d_v));
+}

Samples/5_Domain_Specific/HSOpticalFlow/flowCUDA.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 FLOW_CUDA_H
+#define FLOW_CUDA_H
+
+void ComputeFlowCUDA(
+    const float *I0,   // source frame
+    const float *I1,   // tracked frame
+    int width,         // frame width
+    int height,        // frame height
+    int stride,        // row access stride
+    float alpha,       // smoothness coefficient
+    int nLevels,       // number of levels in pyramid
+    int nWarpIters,    // number of warping iterations per pyramid level
+    int nSolverIters,  // number of solver iterations (for linear system)
+    float *u,          // output horizontal flow
+    float *v);         // output vertical flow
+#endif

Samples/5_Domain_Specific/HSOpticalFlow/flowGold.cpp

@@ -0,0 +1,462 @@
+/* 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 "common.h"
+#include "flowGold.h"
+
+///////////////////////////////////////////////////////////////////////////////
+/// \brief host texture fetch
+///
+/// read from arbitrary position within image using bilinear interpolation
+/// out of range coords are mirrored
+/// \param[in]  t   texture raw data
+/// \param[in]  w   texture width
+/// \param[in]  h   texture height
+/// \param[in]  s   texture stride
+/// \param[in]  x   x coord of the point to fetch value at
+/// \param[in]  y   y coord of the point to fetch value at
+/// \return fetched value
+///////////////////////////////////////////////////////////////////////////////
+inline float Tex2D(const float *t, int w, int h, int s, float x, float y) {
+  // integer parts in floating point format
+  float intPartX, intPartY;
+
+  // get fractional parts of coordinates
+  float dx = fabsf(modff(x, &intPartX));
+  float dy = fabsf(modff(y, &intPartY));
+
+  // assume pixels are squares
+  // one of the corners
+  int ix0 = (int)intPartX;
+  int iy0 = (int)intPartY;
+
+  // mirror out-of-range position
+  if (ix0 < 0) ix0 = abs(ix0 + 1);
+
+  if (iy0 < 0) iy0 = abs(iy0 + 1);
+
+  if (ix0 >= w) ix0 = w * 2 - ix0 - 1;
+
+  if (iy0 >= h) iy0 = h * 2 - iy0 - 1;
+
+  // corner which is opposite to (ix0, iy0)
+  int ix1 = ix0 + 1;
+  int iy1 = iy0 + 1;
+
+  if (ix1 >= w) ix1 = w * 2 - ix1 - 1;
+
+  if (iy1 >= h) iy1 = h * 2 - iy1 - 1;
+
+  float res = t[ix0 + iy0 * s] * (1.0f - dx) * (1.0f - dy);
+  res += t[ix1 + iy0 * s] * dx * (1.0f - dy);
+  res += t[ix0 + iy1 * s] * (1.0f - dx) * dy;
+  res += t[ix1 + iy1 * s] * dx * dy;
+
+  return res;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// \brief host texture fetch
+///
+/// read specific texel value
+/// out of range coords are mirrored
+/// \param[in]  t   texture raw data
+/// \param[in]  w   texture width
+/// \param[in]  h   texture height
+/// \param[in]  s   texture stride
+/// \param[in]  x   x coord of the point to fetch value at
+/// \param[in]  y   y coord of the point to fetch value at
+/// \return fetched value
+///////////////////////////////////////////////////////////////////////////////
+inline float Tex2Di(const float *src, int w, int h, int s, int x, int y) {
+  if (x < 0) x = abs(x + 1);
+
+  if (y < 0) y = abs(y + 1);
+
+  if (x >= w) x = w * 2 - x - 1;
+
+  if (y >= h) y = h * 2 - y - 1;
+
+  return src[x + y * s];
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// \brief resize image
+/// \param[in]  src         image to downscale
+/// \param[in]  width       image width
+/// \param[in]  height      image height
+/// \param[in]  stride      image stride
+/// \param[in]  newWidth    image new width
+/// \param[in]  newHeight   image new height
+/// \param[in]  newStride   image new stride
+/// \param[out] out         downscaled image data
+///////////////////////////////////////////////////////////////////////////////
+static void Downscale(const float *src, int width, int height, int stride,
+                      int newWidth, int newHeight, int newStride, float *out) {
+  for (int i = 0; i < newHeight; ++i) {
+    for (int j = 0; j < newWidth; ++j) {
+      const int srcX = j * 2;
+      const int srcY = i * 2;
+      // average 4 neighbouring pixels
+      float sum;
+      sum = Tex2Di(src, width, height, stride, srcX + 0, srcY + 0);
+      sum += Tex2Di(src, width, height, stride, srcX + 0, srcY + 1);
+      sum += Tex2Di(src, width, height, stride, srcX + 1, srcY + 0);
+      sum += Tex2Di(src, width, height, stride, srcX + 1, srcY + 1);
+      // normalize
+      sum *= 0.25f;
+      out[j + i * newStride] = sum;
+    }
+  }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// \brief upscale one component of a displacement field
+/// \param[in]  src         field component to upscale
+/// \param[in]  width       field current width
+/// \param[in]  height      field current height
+/// \param[in]  stride      field current stride
+/// \param[in]  newWidth    field new width
+/// \param[in]  newHeight   field new height
+/// \param[in]  newStride   field new stride
+/// \param[in]  scale       value scale factor (multiplier)
+/// \param[out] out         upscaled field component
+///////////////////////////////////////////////////////////////////////////////
+static void Upscale(const float *src, int width, int height, int stride,
+                    int newWidth, int newHeight, int newStride, float scale,
+                    float *out) {
+  for (int i = 0; i < newHeight; ++i) {
+    for (int j = 0; j < newWidth; ++j) {
+      // position within smaller image
+      float x = ((float)j - 0.5f) * 0.5f;
+      float y = ((float)i - 0.5f) * 0.5f;
+
+      out[j + i * newStride] = Tex2D(src, width, height, stride, x, y) * scale;
+    }
+  }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// \brief warp image with provided vector field
+///
+/// For each output pixel there is a vector which tells which pixel
+/// from a source image should be mapped to this particular output
+/// pixel.
+/// It is assumed that images and the vector field have the same stride and
+/// resolution.
+/// \param[in]  src source image
+/// \param[in]  w   width
+/// \param[in]  h   height
+/// \param[in]  s   stride
+/// \param[in]  u   horizontal displacement
+/// \param[in]  v   vertical displacement
+/// \param[out] out warped image
+///////////////////////////////////////////////////////////////////////////////
+static void WarpImage(const float *src, int w, int h, int s, const float *u,
+                      const float *v, float *out) {
+  for (int i = 0; i < h; ++i) {
+    for (int j = 0; j < w; ++j) {
+      const int pos = j + i * s;
+      // warped coords
+      float x = (float)j + u[pos];
+      float y = (float)i + v[pos];
+
+      out[pos] = Tex2D(src, w, h, s, x, y);
+    }
+  }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// \brief computes image derivatives for a pair of images
+/// \param[in]  I0  source image
+/// \param[in]  I1  tracked image
+/// \param[in]  w   images width
+/// \param[in]  h   images height
+/// \param[in]  s   images stride
+/// \param[out] Ix  x derivative
+/// \param[out] Iy  y derivative
+/// \param[out] Iz  temporal derivative
+///////////////////////////////////////////////////////////////////////////////
+static void ComputeDerivatives(const float *I0, const float *I1, int w, int h,
+                               int s, float *Ix, float *Iy, float *Iz) {
+  for (int i = 0; i < h; ++i) {
+    for (int j = 0; j < w; ++j) {
+      const int pos = j + i * s;
+      float t0, t1;
+      // derivative filter is (1, -8, 0, 8, -1)/12
+      // x derivative
+      t0 = Tex2Di(I0, w, h, s, j - 2, i);
+      t0 -= Tex2Di(I0, w, h, s, j - 1, i) * 8.0f;
+      t0 += Tex2Di(I0, w, h, s, j + 1, i) * 8.0f;
+      t0 -= Tex2Di(I0, w, h, s, j + 2, i);
+      t0 /= 12.0f;
+
+      t1 = Tex2Di(I1, w, h, s, j - 2, i);
+      t1 -= Tex2Di(I1, w, h, s, j - 1, i) * 8.0f;
+      t1 += Tex2Di(I1, w, h, s, j + 1, i) * 8.0f;
+      t1 -= Tex2Di(I1, w, h, s, j + 2, i);
+      t1 /= 12.0f;
+
+      // spatial derivatives are averaged
+      Ix[pos] = (t0 + t1) * 0.5f;
+
+      // t derivative
+      Iz[pos] = I1[pos] - I0[pos];
+
+      // y derivative
+      t0 = Tex2Di(I0, w, h, s, j, i - 2);
+      t0 -= Tex2Di(I0, w, h, s, j, i - 1) * 8.0f;
+      t0 += Tex2Di(I0, w, h, s, j, i + 1) * 8.0f;
+      t0 -= Tex2Di(I0, w, h, s, j, i + 2);
+      t0 /= 12.0f;
+
+      t1 = Tex2Di(I1, w, h, s, j, i - 2);
+      t1 -= Tex2Di(I1, w, h, s, j, i - 1) * 8.0f;
+      t1 += Tex2Di(I1, w, h, s, j, i + 1) * 8.0f;
+      t1 -= Tex2Di(I1, w, h, s, j, i + 2);
+      t1 /= 12.0f;
+
+      Iy[pos] = (t0 + t1) * 0.5f;
+    }
+  }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// \brief one iteration of classical Horn-Schunck method
+///
+/// It is one iteration of Jacobi method for a corresponding linear system
+/// \param[in]  du0     current horizontal displacement approximation
+/// \param[in]  dv0     current vertical displacement approximation
+/// \param[in]  Ix      image x derivative
+/// \param[in]  Iy      image y derivative
+/// \param[in]  Iz      temporal derivative
+/// \param[in]  w       width
+/// \param[in]  h       height
+/// \param[in]  s       stride
+/// \param[in]  alpha   degree of smoothness
+/// \param[out] du1     new horizontal displacement approximation
+/// \param[out] dv1     new vertical displacement approximation
+///////////////////////////////////////////////////////////////////////////////
+static void SolveForUpdate(const float *du0, const float *dv0, const float *Ix,
+                           const float *Iy, const float *Iz, int w, int h,
+                           int s, float alpha, float *du1, float *dv1) {
+  for (int i = 0; i < h; ++i) {
+    for (int j = 0; j < w; ++j) {
+      const int pos = j + i * s;
+      int left, right, up, down;
+
+      // handle borders
+      if (j != 0)
+        left = pos - 1;
+      else
+        left = pos;
+
+      if (j != w - 1)
+        right = pos + 1;
+      else
+        right = pos;
+
+      if (i != 0)
+        down = pos - s;
+      else
+        down = pos;
+
+      if (i != h - 1)
+        up = pos + s;
+      else
+        up = pos;
+
+      float sumU = (du0[left] + du0[right] + du0[up] + du0[down]) * 0.25f;
+      float sumV = (dv0[left] + dv0[right] + dv0[up] + dv0[down]) * 0.25f;
+
+      float frac = (Ix[pos] * sumU + Iy[pos] * sumV + Iz[pos]) /
+                   (Ix[pos] * Ix[pos] + Iy[pos] * Iy[pos] + alpha);
+
+      du1[pos] = sumU - Ix[pos] * frac;
+      dv1[pos] = sumV - Iy[pos] * frac;
+    }
+  }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// \brief method logic
+///
+/// handles memory allocation and control flow
+/// \param[in]  I0           source image
+/// \param[in]  I1           tracked image
+/// \param[in]  width        images width
+/// \param[in]  height       images height
+/// \param[in]  stride       images stride
+/// \param[in]  alpha        degree of displacement field smoothness
+/// \param[in]  nLevels      number of levels in a pyramid
+/// \param[in]  nWarpIters   number of warping iterations per pyramid level
+/// \param[in]  nSolverIters number of solver iterations (Jacobi iterations)
+/// \param[out] u            horizontal displacement
+/// \param[out] v            vertical displacement
+///////////////////////////////////////////////////////////////////////////////
+void ComputeFlowGold(const float *I0, const float *I1, int width, int height,
+                     int stride, float alpha, int nLevels, int nWarpIters,
+                     int nSolverIters, float *u, float *v) {
+  printf("Computing optical flow on CPU...\n");
+
+  float *u0 = u;
+  float *v0 = v;
+
+  const float **pI0 = new const float *[nLevels];
+  const float **pI1 = new const float *[nLevels];
+
+  int *pW = new int[nLevels];
+  int *pH = new int[nLevels];
+  int *pS = new int[nLevels];
+
+  const int pixelCountAligned = height * stride;
+
+  float *tmp = new float[pixelCountAligned];
+  float *du0 = new float[pixelCountAligned];
+  float *dv0 = new float[pixelCountAligned];
+  float *du1 = new float[pixelCountAligned];
+  float *dv1 = new float[pixelCountAligned];
+  float *Ix = new float[pixelCountAligned];
+  float *Iy = new float[pixelCountAligned];
+  float *Iz = new float[pixelCountAligned];
+  float *nu = new float[pixelCountAligned];
+  float *nv = new float[pixelCountAligned];
+
+  // prepare pyramid
+  int currentLevel = nLevels - 1;
+  pI0[currentLevel] = I0;
+  pI1[currentLevel] = I1;
+
+  pW[currentLevel] = width;
+  pH[currentLevel] = height;
+  pS[currentLevel] = stride;
+
+  for (; currentLevel > 0; --currentLevel) {
+    int nw = pW[currentLevel] / 2;
+    int nh = pH[currentLevel] / 2;
+    int ns = iAlignUp(nw);
+    pI0[currentLevel - 1] = new float[ns * nh];
+    pI1[currentLevel - 1] = new float[ns * nh];
+
+    Downscale(pI0[currentLevel], pW[currentLevel], pH[currentLevel],
+              pS[currentLevel], nw, nh, ns, (float *)pI0[currentLevel - 1]);
+
+    Downscale(pI1[currentLevel], pW[currentLevel], pH[currentLevel],
+              pS[currentLevel], nw, nh, ns, (float *)pI1[currentLevel - 1]);
+
+    pW[currentLevel - 1] = nw;
+    pH[currentLevel - 1] = nh;
+    pS[currentLevel - 1] = ns;
+  }
+
+  // initial approximation
+  memset(u, 0, stride * height * sizeof(float));
+  memset(v, 0, stride * height * sizeof(float));
+
+  // compute flow
+  for (; currentLevel < nLevels; ++currentLevel) {
+    for (int warpIter = 0; warpIter < nWarpIters; ++warpIter) {
+      memset(du0, 0, pixelCountAligned * sizeof(float));
+      memset(dv0, 0, pixelCountAligned * sizeof(float));
+
+      memset(du1, 0, pixelCountAligned * sizeof(float));
+      memset(dv1, 0, pixelCountAligned * sizeof(float));
+
+      WarpImage(pI1[currentLevel], pW[currentLevel], pH[currentLevel],
+                pS[currentLevel], u, v, tmp);
+
+      // on current level we compute optical flow
+      // between frame 0 and warped frame 1
+      ComputeDerivatives(pI0[currentLevel], tmp, pW[currentLevel],
+                         pH[currentLevel], pS[currentLevel], Ix, Iy, Iz);
+
+      for (int iter = 0; iter < nSolverIters; ++iter) {
+        SolveForUpdate(du0, dv0, Ix, Iy, Iz, pW[currentLevel], pH[currentLevel],
+                       pS[currentLevel], alpha, du1, dv1);
+        Swap(du0, du1);
+        Swap(dv0, dv1);
+      }
+
+      // update u, v
+      for (int i = 0; i < pH[currentLevel] * pS[currentLevel]; ++i) {
+        u[i] += du0[i];
+        v[i] += dv0[i];
+      }
+    }  // end for (int warpIter = 0; warpIter < nWarpIters; ++warpIter)
+
+    if (currentLevel != nLevels - 1) {
+      // prolongate solution
+      float scaleX = (float)pW[currentLevel + 1] / (float)pW[currentLevel];
+
+      Upscale(u, pW[currentLevel], pH[currentLevel], pS[currentLevel],
+              pW[currentLevel + 1], pH[currentLevel + 1], pS[currentLevel + 1],
+              scaleX, nu);
+
+      float scaleY = (float)pH[currentLevel + 1] / (float)pH[currentLevel];
+
+      Upscale(v, pW[currentLevel], pH[currentLevel], pS[currentLevel],
+              pW[currentLevel + 1], pH[currentLevel + 1], pS[currentLevel + 1],
+              scaleY, nv);
+
+      Swap(u, nu);
+      Swap(v, nv);
+    }
+  }  // end for (; currentLevel < nLevels; ++currentLevel)
+
+  if (u != u0) {
+    // solution is not in the specified array
+    // copy
+    memcpy(u0, u, pixelCountAligned * sizeof(float));
+    memcpy(v0, v, pixelCountAligned * sizeof(float));
+    Swap(u, nu);
+    Swap(v, nv);
+  }
+
+  // cleanup
+  // last level is not being freed here
+  // because it refers to input images
+  for (int i = 0; i < nLevels - 1; ++i) {
+    delete[] pI0[i];
+    delete[] pI1[i];
+  }
+
+  delete[] pI0;
+  delete[] pI1;
+  delete[] pW;
+  delete[] pH;
+  delete[] pS;
+  delete[] tmp;
+  delete[] du0;
+  delete[] dv0;
+  delete[] du1;
+  delete[] dv1;
+  delete[] Ix;
+  delete[] Iy;
+  delete[] Iz;
+  delete[] nu;
+  delete[] nv;
+}

Samples/5_Domain_Specific/HSOpticalFlow/flowGold.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 FLOW_GOLD_H
+#define FLOW_GOLD_H
+
+void ComputeFlowGold(
+    const float *I0,  // source frame
+    const float *I1,  // tracked frame
+    int width,        // frame width
+    int height,       // frame height
+    int stride,       // row access stride
+    float alpha,      // smoothness coefficient
+    int nLevels,      // number of levels in pyramid
+    int nWarpIters,   // number of warping iterations per pyramid level
+    int nIters,       // number of solver iterations (for linear system)
+    float *u,         // output horizontal flow
+    float *v);        // output vertical flow
+
+#endif

Samples/5_Domain_Specific/HSOpticalFlow/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.
+ */
+
+const static char *const sSDKsample = "HSOpticalFlow";
+
+// CPU-GPU discrepancy threshold for self-test
+const float THRESHOLD = 0.05f;
+
+#include <cuda_runtime.h>
+
+#include "common.h"
+#include "flowGold.h"
+#include "flowCUDA.h"
+
+#include <helper_functions.h>
+
+///////////////////////////////////////////////////////////////////////////////
+/// \brief save optical flow in format described on vision.middlebury.edu/flow
+/// \param[in] name output file name
+/// \param[in] w    optical flow field width
+/// \param[in] h    optical flow field height
+/// \param[in] s    optical flow field row stride
+/// \param[in] u    horizontal displacement
+/// \param[in] v    vertical displacement
+///////////////////////////////////////////////////////////////////////////////
+void WriteFloFile(const char *name, int w, int h, int s, const float *u,
+                  const float *v) {
+  FILE *stream;
+  stream = fopen(name, "wb");
+
+  if (stream == 0) {
+    printf("Could not save flow to \"%s\"\n", name);
+    return;
+  }
+
+  float data = 202021.25f;
+  fwrite(&data, sizeof(float), 1, stream);
+  fwrite(&w, sizeof(w), 1, stream);
+  fwrite(&h, sizeof(h), 1, stream);
+
+  for (int i = 0; i < h; ++i) {
+    for (int j = 0; j < w; ++j) {
+      const int pos = j + i * s;
+      fwrite(u + pos, sizeof(float), 1, stream);
+      fwrite(v + pos, sizeof(float), 1, stream);
+    }
+  }
+
+  fclose(stream);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// \brief
+/// load 4-channel unsigned byte image
+/// and convert it to single channel FP32 image
+/// \param[out] img_data pointer to raw image data
+/// \param[out] img_w    image width
+/// \param[out] img_h    image height
+/// \param[out] img_s    image row stride
+/// \param[in]  name     image file name
+/// \param[in]  exePath  executable file path
+/// \return true if image is successfully loaded or false otherwise
+///////////////////////////////////////////////////////////////////////////////
+bool LoadImageAsFP32(float *&img_data, int &img_w, int &img_h, int &img_s,
+                     const char *name, const char *exePath) {
+  printf("Loading \"%s\" ...\n", name);
+  char *name_ = sdkFindFilePath(name, exePath);
+
+  if (!name_) {
+    printf("File not found\n");
+    return false;
+  }
+
+  unsigned char *data = 0;
+  unsigned int w = 0, h = 0;
+  bool result = sdkLoadPPM4ub(name_, &data, &w, &h);
+
+  if (result == false) {
+    printf("Invalid file format\n");
+    return false;
+  }
+
+  img_w = w;
+  img_h = h;
+  img_s = iAlignUp(img_w);
+
+  img_data = new float[img_s * h];
+
+  // source is 4 channel image
+  const int widthStep = 4 * img_w;
+
+  for (int i = 0; i < img_h; ++i) {
+    for (int j = 0; j < img_w; ++j) {
+      img_data[j + i * img_s] = ((float)data[j * 4 + i * widthStep]) / 255.0f;
+    }
+  }
+
+  return true;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// \brief compare given flow field with gold (L1 norm)
+/// \param[in] width    optical flow field width
+/// \param[in] height   optical flow field height
+/// \param[in] stride   optical flow field row stride
+/// \param[in] h_uGold  horizontal displacement, gold
+/// \param[in] h_vGold  vertical displacement, gold
+/// \param[in] h_u      horizontal displacement
+/// \param[in] h_v      vertical displacement
+/// \return true if discrepancy is lower than a given threshold
+///////////////////////////////////////////////////////////////////////////////
+bool CompareWithGold(int width, int height, int stride, const float *h_uGold,
+                     const float *h_vGold, const float *h_u, const float *h_v) {
+  float error = 0.0f;
+
+  for (int i = 0; i < height; ++i) {
+    for (int j = 0; j < width; ++j) {
+      const int pos = j + i * stride;
+      error += fabsf(h_u[pos] - h_uGold[pos]) + fabsf(h_v[pos] - h_vGold[pos]);
+    }
+  }
+
+  error /= (float)(width * height);
+
+  printf("L1 error : %.6f\n", error);
+
+  return (error < THRESHOLD);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// application entry point
+///////////////////////////////////////////////////////////////////////////////
+int main(int argc, char **argv) {
+  // welcome message
+  printf("%s Starting...\n\n", sSDKsample);
+
+  // pick GPU
+  findCudaDevice(argc, (const char **)argv);
+
+  // find images
+  const char *const sourceFrameName = "frame10.ppm";
+  const char *const targetFrameName = "frame11.ppm";
+
+  // image dimensions
+  int width;
+  int height;
+  // row access stride
+  int stride;
+
+  // flow is computed from source image to target image
+  float *h_source;  // source image, host memory
+  float *h_target;  // target image, host memory
+
+  // load image from file
+  if (!LoadImageAsFP32(h_source, width, height, stride, sourceFrameName,
+                       argv[0])) {
+    exit(EXIT_FAILURE);
+  }
+
+  if (!LoadImageAsFP32(h_target, width, height, stride, targetFrameName,
+                       argv[0])) {
+    exit(EXIT_FAILURE);
+  }
+
+  // allocate host memory for CPU results
+  float *h_uGold = new float[stride * height];
+  float *h_vGold = new float[stride * height];
+
+  // allocate host memory for GPU results
+  float *h_u = new float[stride * height];
+  float *h_v = new float[stride * height];
+
+  // smoothness
+  // if image brightness is not within [0,1]
+  // this paramter should be scaled appropriately
+  const float alpha = 0.2f;
+
+  // number of pyramid levels
+  const int nLevels = 5;
+
+  // number of solver iterations on each level
+  const int nSolverIters = 500;
+
+  // number of warping iterations
+  const int nWarpIters = 3;
+
+  ComputeFlowGold(h_source, h_target, width, height, stride, alpha, nLevels,
+                  nWarpIters, nSolverIters, h_uGold, h_vGold);
+
+  ComputeFlowCUDA(h_source, h_target, width, height, stride, alpha, nLevels,
+                  nWarpIters, nSolverIters, h_u, h_v);
+
+  // compare results (L1 norm)
+  bool status =
+      CompareWithGold(width, height, stride, h_uGold, h_vGold, h_u, h_v);
+
+  WriteFloFile("FlowGPU.flo", width, height, stride, h_u, h_v);
+
+  WriteFloFile("FlowCPU.flo", width, height, stride, h_uGold, h_vGold);
+
+  // free resources
+  delete[] h_uGold;
+  delete[] h_vGold;
+
+  delete[] h_u;
+  delete[] h_v;
+
+  delete[] h_source;
+  delete[] h_target;
+
+  // report self-test status
+  exit(status ? EXIT_SUCCESS : EXIT_FAILURE);
+}

Samples/5_Domain_Specific/HSOpticalFlow/solverKernel.cuh

@@ -0,0 +1,181 @@
+/* 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 "common.h"
+#include <cooperative_groups.h>
+
+namespace cg = cooperative_groups;
+
+///////////////////////////////////////////////////////////////////////////////
+/// \brief one iteration of classical Horn-Schunck method, CUDA kernel.
+///
+/// It is one iteration of Jacobi method for a corresponding linear system.
+/// Template parameters are describe CTA size
+/// \param[in]  du0     current horizontal displacement approximation
+/// \param[in]  dv0     current vertical displacement approximation
+/// \param[in]  Ix      image x derivative
+/// \param[in]  Iy      image y derivative
+/// \param[in]  Iz      temporal derivative
+/// \param[in]  w       width
+/// \param[in]  h       height
+/// \param[in]  s       stride
+/// \param[in]  alpha   degree of smoothness
+/// \param[out] du1     new horizontal displacement approximation
+/// \param[out] dv1     new vertical displacement approximation
+///////////////////////////////////////////////////////////////////////////////
+template <int bx, int by>
+__global__ void JacobiIteration(const float *du0, const float *dv0,
+                                const float *Ix, const float *Iy,
+                                const float *Iz, int w, int h, int s,
+                                float alpha, float *du1, float *dv1) {
+  // Handle to thread block group
+  cg::thread_block cta = cg::this_thread_block();
+
+  volatile __shared__ float du[(bx + 2) * (by + 2)];
+  volatile __shared__ float dv[(bx + 2) * (by + 2)];
+
+  const int ix = threadIdx.x + blockIdx.x * blockDim.x;
+  const int iy = threadIdx.y + blockIdx.y * blockDim.y;
+
+  // position within global memory array
+  const int pos = min(ix, w - 1) + min(iy, h - 1) * s;
+
+  // position within shared memory array
+  const int shMemPos = threadIdx.x + 1 + (threadIdx.y + 1) * (bx + 2);
+
+  // Load data to shared memory.
+  // load tile being processed
+  du[shMemPos] = du0[pos];
+  dv[shMemPos] = dv0[pos];
+
+  // load necessary neighbouring elements
+  // We clamp out-of-range coordinates.
+  // It is equivalent to mirroring
+  // because we access data only one step away from borders.
+  if (threadIdx.y == 0) {
+    // beginning of the tile
+    const int bsx = blockIdx.x * blockDim.x;
+    const int bsy = blockIdx.y * blockDim.y;
+    // element position within matrix
+    int x, y;
+    // element position within linear array
+    // gm - global memory
+    // sm - shared memory
+    int gmPos, smPos;
+
+    x = min(bsx + threadIdx.x, w - 1);
+    // row just below the tile
+    y = max(bsy - 1, 0);
+    gmPos = y * s + x;
+    smPos = threadIdx.x + 1;
+    du[smPos] = du0[gmPos];
+    dv[smPos] = dv0[gmPos];
+
+    // row above the tile
+    y = min(bsy + by, h - 1);
+    smPos += (by + 1) * (bx + 2);
+    gmPos = y * s + x;
+    du[smPos] = du0[gmPos];
+    dv[smPos] = dv0[gmPos];
+  } else if (threadIdx.y == 1) {
+    // beginning of the tile
+    const int bsx = blockIdx.x * blockDim.x;
+    const int bsy = blockIdx.y * blockDim.y;
+    // element position within matrix
+    int x, y;
+    // element position within linear array
+    // gm - global memory
+    // sm - shared memory
+    int gmPos, smPos;
+
+    y = min(bsy + threadIdx.x, h - 1);
+    // column to the left
+    x = max(bsx - 1, 0);
+    smPos = bx + 2 + threadIdx.x * (bx + 2);
+    gmPos = x + y * s;
+
+    // check if we are within tile
+    if (threadIdx.x < by) {
+      du[smPos] = du0[gmPos];
+      dv[smPos] = dv0[gmPos];
+      // column to the right
+      x = min(bsx + bx, w - 1);
+      gmPos = y * s + x;
+      smPos += bx + 1;
+      du[smPos] = du0[gmPos];
+      dv[smPos] = dv0[gmPos];
+    }
+  }
+
+  cg::sync(cta);
+
+  if (ix >= w || iy >= h) return;
+
+  // now all necessary data are loaded to shared memory
+  int left, right, up, down;
+  left = shMemPos - 1;
+  right = shMemPos + 1;
+  up = shMemPos + bx + 2;
+  down = shMemPos - bx - 2;
+
+  float sumU = (du[left] + du[right] + du[up] + du[down]) * 0.25f;
+  float sumV = (dv[left] + dv[right] + dv[up] + dv[down]) * 0.25f;
+
+  float frac = (Ix[pos] * sumU + Iy[pos] * sumV + Iz[pos]) /
+               (Ix[pos] * Ix[pos] + Iy[pos] * Iy[pos] + alpha);
+
+  du1[pos] = sumU - Ix[pos] * frac;
+  dv1[pos] = sumV - Iy[pos] * frac;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// \brief one iteration of classical Horn-Schunck method, CUDA kernel wrapper.
+///
+/// It is one iteration of Jacobi method for a corresponding linear system.
+/// \param[in]  du0     current horizontal displacement approximation
+/// \param[in]  dv0     current vertical displacement approximation
+/// \param[in]  Ix      image x derivative
+/// \param[in]  Iy      image y derivative
+/// \param[in]  Iz      temporal derivative
+/// \param[in]  w       width
+/// \param[in]  h       height
+/// \param[in]  s       stride
+/// \param[in]  alpha   degree of smoothness
+/// \param[out] du1     new horizontal displacement approximation
+/// \param[out] dv1     new vertical displacement approximation
+///////////////////////////////////////////////////////////////////////////////
+static void SolveForUpdate(const float *du0, const float *dv0, const float *Ix,
+                           const float *Iy, const float *Iz, int w, int h,
+                           int s, float alpha, float *du1, float *dv1) {
+  // CTA size
+  dim3 threads(32, 6);
+  // grid size
+  dim3 blocks(iDivUp(w, threads.x), iDivUp(h, threads.y));
+
+  JacobiIteration<32, 6><<<blocks, threads>>>(du0, dv0, Ix, Iy, Iz, w, h, s,
+                                              alpha, du1, dv1);
+}

Samples/5_Domain_Specific/HSOpticalFlow/upscaleKernel.cuh

@@ -0,0 +1,96 @@
+/* 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 "common.h"
+
+///////////////////////////////////////////////////////////////////////////////
+/// \brief upscale one component of a displacement field, CUDA kernel
+/// \param[in]  width   field width
+/// \param[in]  height  field height
+/// \param[in]  stride  field stride
+/// \param[in]  scale   scale factor (multiplier)
+/// \param[out] out     result
+///////////////////////////////////////////////////////////////////////////////
+__global__ void UpscaleKernel(int width, int height, int stride, float scale,
+                              float *out, cudaTextureObject_t texCoarse) {
+  const int ix = threadIdx.x + blockIdx.x * blockDim.x;
+  const int iy = threadIdx.y + blockIdx.y * blockDim.y;
+
+  if (ix >= width || iy >= height) return;
+
+  float x = ((float)ix + 0.5f) / (float)width;
+  float y = ((float)iy + 0.5f) / (float)height;
+
+  // exploit hardware interpolation
+  // and scale interpolated vector to match next pyramid level resolution
+  out[ix + iy * stride] = tex2D<float>(texCoarse, x, y) * scale;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// \brief upscale one component of a displacement field, kernel wrapper
+/// \param[in]  src         field component to upscale
+/// \param[in]  width       field current width
+/// \param[in]  height      field current height
+/// \param[in]  stride      field current stride
+/// \param[in]  newWidth    field new width
+/// \param[in]  newHeight   field new height
+/// \param[in]  newStride   field new stride
+/// \param[in]  scale       value scale factor (multiplier)
+/// \param[out] out         upscaled field component
+///////////////////////////////////////////////////////////////////////////////
+static void Upscale(const float *src, int width, int height, int stride,
+                    int newWidth, int newHeight, int newStride, float scale,
+                    float *out) {
+  dim3 threads(32, 8);
+  dim3 blocks(iDivUp(newWidth, threads.x), iDivUp(newHeight, threads.y));
+
+  cudaTextureObject_t texCoarse;
+  cudaResourceDesc texRes;
+  memset(&texRes, 0, sizeof(cudaResourceDesc));
+
+  texRes.resType = cudaResourceTypePitch2D;
+  texRes.res.pitch2D.devPtr = (void *)src;
+  texRes.res.pitch2D.desc = cudaCreateChannelDesc<float>();
+  texRes.res.pitch2D.width = width;
+  texRes.res.pitch2D.height = height;
+  texRes.res.pitch2D.pitchInBytes = stride * sizeof(float);
+
+  cudaTextureDesc texDescr;
+  memset(&texDescr, 0, sizeof(cudaTextureDesc));
+
+  texDescr.normalizedCoords = true;
+  texDescr.filterMode = cudaFilterModeLinear;
+  texDescr.addressMode[0] = cudaAddressModeMirror;
+  texDescr.addressMode[1] = cudaAddressModeMirror;
+  texDescr.readMode = cudaReadModeElementType;
+
+  checkCudaErrors(
+      cudaCreateTextureObject(&texCoarse, &texRes, &texDescr, NULL));
+
+  UpscaleKernel<<<blocks, threads>>>(newWidth, newHeight, newStride, scale, out,
+                                     texCoarse);
+}

Samples/5_Domain_Specific/HSOpticalFlow/warpingKernel.cuh

@@ -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.
+ */
+
+#include "common.h"
+
+///////////////////////////////////////////////////////////////////////////////
+/// \brief warp image with a given displacement field, CUDA kernel.
+/// \param[in]  width   image width
+/// \param[in]  height  image height
+/// \param[in]  stride  image stride
+/// \param[in]  u       horizontal displacement
+/// \param[in]  v       vertical displacement
+/// \param[out] out     result
+///////////////////////////////////////////////////////////////////////////////
+__global__ void WarpingKernel(int width, int height, int stride, const float *u,
+                              const float *v, float *out,
+                              cudaTextureObject_t texToWarp) {
+  const int ix = threadIdx.x + blockIdx.x * blockDim.x;
+  const int iy = threadIdx.y + blockIdx.y * blockDim.y;
+
+  const int pos = ix + iy * stride;
+
+  if (ix >= width || iy >= height) return;
+
+  float x = ((float)ix + u[pos] + 0.5f) / (float)width;
+  float y = ((float)iy + v[pos] + 0.5f) / (float)height;
+
+  out[pos] = tex2D<float>(texToWarp, x, y);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// \brief warp image with provided vector field, CUDA kernel wrapper.
+///
+/// For each output pixel there is a vector which tells which pixel
+/// from a source image should be mapped to this particular output
+/// pixel.
+/// It is assumed that images and the vector field have the same stride and
+/// resolution.
+/// \param[in]  src source image
+/// \param[in]  w   width
+/// \param[in]  h   height
+/// \param[in]  s   stride
+/// \param[in]  u   horizontal displacement
+/// \param[in]  v   vertical displacement
+/// \param[out] out warped image
+///////////////////////////////////////////////////////////////////////////////
+static void WarpImage(const float *src, int w, int h, int s, const float *u,
+                      const float *v, float *out) {
+  dim3 threads(32, 6);
+  dim3 blocks(iDivUp(w, threads.x), iDivUp(h, threads.y));
+
+  cudaTextureObject_t texToWarp;
+  cudaResourceDesc texRes;
+  memset(&texRes, 0, sizeof(cudaResourceDesc));
+
+  texRes.resType = cudaResourceTypePitch2D;
+  texRes.res.pitch2D.devPtr = (void *)src;
+  texRes.res.pitch2D.desc = cudaCreateChannelDesc<float>();
+  texRes.res.pitch2D.width = w;
+  texRes.res.pitch2D.height = h;
+  texRes.res.pitch2D.pitchInBytes = s * sizeof(float);
+
+  cudaTextureDesc texDescr;
+  memset(&texDescr, 0, sizeof(cudaTextureDesc));
+
+  texDescr.normalizedCoords = true;
+  texDescr.filterMode = cudaFilterModeLinear;
+  texDescr.addressMode[0] = cudaAddressModeMirror;
+  texDescr.addressMode[1] = cudaAddressModeMirror;
+  texDescr.readMode = cudaReadModeElementType;
+
+  checkCudaErrors(
+      cudaCreateTextureObject(&texToWarp, &texRes, &texDescr, NULL));
+
+  WarpingKernel<<<blocks, threads>>>(w, h, s, u, v, out, texToWarp);
+}

Samples/5_Domain_Specific/Mandelbrot/.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
+}

Samples/5_Domain_Specific/Mandelbrot/.vscode/extensions.json

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

Samples/5_Domain_Specific/Mandelbrot/.vscode/launch.json

@@ -0,0 +1,10 @@
+{
+    "configurations": [
+        {
+            "name": "CUDA C++: Launch",
+            "type": "cuda-gdb",
+            "request": "launch",
+            "program": "${workspaceFolder}/Mandelbrot"
+        }
+    ]
+}

Samples/5_Domain_Specific/Mandelbrot/.vscode/tasks.json

@@ -0,0 +1,15 @@
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "sample",
+            "type": "shell",
+            "command": "make dbg=1",
+            "problemMatcher": ["$nvcc"],
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            }
+        }
+    ]
+}

Samples/5_Domain_Specific/Mandelbrot/Makefile

@@ -0,0 +1,368 @@
+################################################################################
+# 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.
+#
+################################################################################
+#
+# Makefile project only supported on Mac OS X and Linux Platforms)
+#
+################################################################################
+
+# Location of the CUDA Toolkit
+CUDA_PATH ?= /usr/local/cuda
+
+##############################
+# start deprecated interface #
+##############################
+ifeq ($(x86_64),1)
+    $(info WARNING - x86_64 variable has been deprecated)
+    $(info WARNING - please use TARGET_ARCH=x86_64 instead)
+    TARGET_ARCH ?= x86_64
+endif
+ifeq ($(ARMv7),1)
+    $(info WARNING - ARMv7 variable has been deprecated)
+    $(info WARNING - please use TARGET_ARCH=armv7l instead)
+    TARGET_ARCH ?= armv7l
+endif
+ifeq ($(aarch64),1)
+    $(info WARNING - aarch64 variable has been deprecated)
+    $(info WARNING - please use TARGET_ARCH=aarch64 instead)
+    TARGET_ARCH ?= aarch64
+endif
+ifeq ($(ppc64le),1)
+    $(info WARNING - ppc64le variable has been deprecated)
+    $(info WARNING - please use TARGET_ARCH=ppc64le instead)
+    TARGET_ARCH ?= ppc64le
+endif
+ifneq ($(GCC),)
+    $(info WARNING - GCC variable has been deprecated)
+    $(info WARNING - please use HOST_COMPILER=$(GCC) instead)
+    HOST_COMPILER ?= $(GCC)
+endif
+ifneq ($(abi),)
+    $(error ERROR - abi variable has been removed)
+endif
+############################
+# end deprecated interface #
+############################
+
+# architecture
+HOST_ARCH   := $(shell uname -m)
+TARGET_ARCH ?= $(HOST_ARCH)
+ifneq (,$(filter $(TARGET_ARCH),x86_64 aarch64 sbsa ppc64le armv7l))
+    ifneq ($(TARGET_ARCH),$(HOST_ARCH))
+        ifneq (,$(filter $(TARGET_ARCH),x86_64 aarch64 sbsa ppc64le))
+            TARGET_SIZE := 64
+        else ifneq (,$(filter $(TARGET_ARCH),armv7l))
+            TARGET_SIZE := 32
+        endif
+    else
+        TARGET_SIZE := $(shell getconf LONG_BIT)
+    endif
+else
+    $(error ERROR - unsupported value $(TARGET_ARCH) for TARGET_ARCH!)
+endif
+
+# sbsa and aarch64 systems look similar. Need to differentiate them at host level for now.
+ifeq ($(HOST_ARCH),aarch64)
+    ifeq ($(CUDA_PATH)/targets/sbsa-linux,$(shell ls -1d $(CUDA_PATH)/targets/sbsa-linux 2>/dev/null))
+        HOST_ARCH := sbsa
+        TARGET_ARCH := sbsa
+    endif
+endif
+
+ifneq ($(TARGET_ARCH),$(HOST_ARCH))
+    ifeq (,$(filter $(HOST_ARCH)-$(TARGET_ARCH),aarch64-armv7l x86_64-armv7l x86_64-aarch64 x86_64-sbsa x86_64-ppc64le))
+        $(error ERROR - cross compiling from $(HOST_ARCH) to $(TARGET_ARCH) is not supported!)
+    endif
+endif
+
+# When on native aarch64 system with userspace of 32-bit, change TARGET_ARCH to armv7l
+ifeq ($(HOST_ARCH)-$(TARGET_ARCH)-$(TARGET_SIZE),aarch64-aarch64-32)
+    TARGET_ARCH = armv7l
+endif
+
+# operating system
+HOST_OS   := $(shell uname -s 2>/dev/null | tr "[:upper:]" "[:lower:]")
+TARGET_OS ?= $(HOST_OS)
+ifeq (,$(filter $(TARGET_OS),linux darwin qnx android))
+    $(error ERROR - unsupported value $(TARGET_OS) for TARGET_OS!)
+endif
+
+# host compiler
+ifeq ($(TARGET_OS),darwin)
+    ifeq ($(shell expr `xcodebuild -version | grep -i xcode | awk '{print $$2}' | cut -d'.' -f1` \>= 5),1)
+        HOST_COMPILER ?= clang++
+    endif
+else ifneq ($(TARGET_ARCH),$(HOST_ARCH))
+    ifeq ($(HOST_ARCH)-$(TARGET_ARCH),x86_64-armv7l)
+        ifeq ($(TARGET_OS),linux)
+            HOST_COMPILER ?= arm-linux-gnueabihf-g++
+        else ifeq ($(TARGET_OS),qnx)
+            ifeq ($(QNX_HOST),)
+                $(error ERROR - QNX_HOST must be passed to the QNX host toolchain)
+            endif
+            ifeq ($(QNX_TARGET),)
+                $(error ERROR - QNX_TARGET must be passed to the QNX target toolchain)
+            endif
+            export QNX_HOST
+            export QNX_TARGET
+            HOST_COMPILER ?= $(QNX_HOST)/usr/bin/arm-unknown-nto-qnx6.6.0eabi-g++
+        else ifeq ($(TARGET_OS),android)
+            HOST_COMPILER ?= arm-linux-androideabi-g++
+        endif
+    else ifeq ($(TARGET_ARCH),aarch64)
+        ifeq ($(TARGET_OS), linux)
+            HOST_COMPILER ?= aarch64-linux-gnu-g++
+        else ifeq ($(TARGET_OS),qnx)
+            ifeq ($(QNX_HOST),)
+                $(error ERROR - QNX_HOST must be passed to the QNX host toolchain)
+            endif
+            ifeq ($(QNX_TARGET),)
+                $(error ERROR - QNX_TARGET must be passed to the QNX target toolchain)
+            endif
+            export QNX_HOST
+            export QNX_TARGET
+            HOST_COMPILER ?= $(QNX_HOST)/usr/bin/q++
+        else ifeq ($(TARGET_OS), android)
+            HOST_COMPILER ?= aarch64-linux-android-clang++
+        endif
+    else ifeq ($(TARGET_ARCH),sbsa)
+        HOST_COMPILER ?= aarch64-linux-gnu-g++
+    else ifeq ($(TARGET_ARCH),ppc64le)
+        HOST_COMPILER ?= powerpc64le-linux-gnu-g++
+    endif
+endif
+HOST_COMPILER ?= g++
+NVCC          := $(CUDA_PATH)/bin/nvcc -ccbin $(HOST_COMPILER)
+
+# internal flags
+NVCCFLAGS   := -m${TARGET_SIZE}
+CCFLAGS     :=
+LDFLAGS     :=
+
+# build flags
+ifeq ($(TARGET_OS),darwin)
+    LDFLAGS += -rpath $(CUDA_PATH)/lib
+    CCFLAGS += -arch $(HOST_ARCH)
+else ifeq ($(HOST_ARCH)-$(TARGET_ARCH)-$(TARGET_OS),x86_64-armv7l-linux)
+    LDFLAGS += --dynamic-linker=/lib/ld-linux-armhf.so.3
+    CCFLAGS += -mfloat-abi=hard
+else ifeq ($(TARGET_OS),android)
+    LDFLAGS += -pie
+    CCFLAGS += -fpie -fpic -fexceptions
+endif
+
+ifneq ($(TARGET_ARCH),$(HOST_ARCH))
+    ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-linux)
+        ifneq ($(TARGET_FS),)
+            GCCVERSIONLTEQ46 := $(shell expr `$(HOST_COMPILER) -dumpversion` \<= 4.6)
+            ifeq ($(GCCVERSIONLTEQ46),1)
+                CCFLAGS += --sysroot=$(TARGET_FS)
+            endif
+            LDFLAGS += --sysroot=$(TARGET_FS)
+            LDFLAGS += -rpath-link=$(TARGET_FS)/lib
+            LDFLAGS += -rpath-link=$(TARGET_FS)/usr/lib
+            LDFLAGS += -rpath-link=$(TARGET_FS)/usr/lib/arm-linux-gnueabihf
+        endif
+    endif
+    ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-linux)
+        ifneq ($(TARGET_FS),)
+            GCCVERSIONLTEQ46 := $(shell expr `$(HOST_COMPILER) -dumpversion` \<= 4.6)
+            ifeq ($(GCCVERSIONLTEQ46),1)
+                CCFLAGS += --sysroot=$(TARGET_FS)
+            endif
+            LDFLAGS += --sysroot=$(TARGET_FS)
+            LDFLAGS += -rpath-link=$(TARGET_FS)/lib -L$(TARGET_FS)/lib
+            LDFLAGS += -rpath-link=$(TARGET_FS)/lib/aarch64-linux-gnu -L$(TARGET_FS)/lib/aarch64-linux-gnu
+            LDFLAGS += -rpath-link=$(TARGET_FS)/usr/lib -L$(TARGET_FS)/usr/lib
+            LDFLAGS += -rpath-link=$(TARGET_FS)/usr/lib/aarch64-linux-gnu -L$(TARGET_FS)/usr/lib/aarch64-linux-gnu
+            LDFLAGS += --unresolved-symbols=ignore-in-shared-libs
+            CCFLAGS += -isystem=$(TARGET_FS)/usr/include -I$(TARGET_FS)/usr/include -I$(TARGET_FS)/usr/include/libdrm
+            CCFLAGS += -isystem=$(TARGET_FS)/usr/include/aarch64-linux-gnu -I$(TARGET_FS)/usr/include/aarch64-linux-gnu
+        endif
+    endif
+    ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-qnx)
+        NVCCFLAGS += -D_QNX_SOURCE
+        NVCCFLAGS += --qpp-config 8.3.0,gcc_ntoaarch64le
+        CCFLAGS += -DWIN_INTERFACE_CUSTOM -I/usr/include/aarch64-qnx-gnu
+        LDFLAGS += -lsocket
+        LDFLAGS += -L/usr/lib/aarch64-qnx-gnu
+        CCFLAGS += "-Wl\,-rpath-link\,/usr/lib/aarch64-qnx-gnu"
+        ifdef TARGET_OVERRIDE
+            LDFLAGS += -lslog2
+        endif
+
+        ifneq ($(TARGET_FS),)
+            LDFLAGS += -L$(TARGET_FS)/usr/lib
+            CCFLAGS += "-Wl\,-rpath-link\,$(TARGET_FS)/usr/lib"
+            LDFLAGS += -L$(TARGET_FS)/usr/libnvidia
+            CCFLAGS += "-Wl\,-rpath-link\,$(TARGET_FS)/usr/libnvidia"
+            CCFLAGS += -I$(TARGET_FS)/../include
+        endif
+    endif
+endif
+
+ifdef TARGET_OVERRIDE # cuda toolkit targets override
+    NVCCFLAGS += -target-dir $(TARGET_OVERRIDE)
+endif
+
+# Install directory of different arch
+CUDA_INSTALL_TARGET_DIR :=
+ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-linux)
+    CUDA_INSTALL_TARGET_DIR = targets/armv7-linux-gnueabihf/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-linux)
+    CUDA_INSTALL_TARGET_DIR = targets/aarch64-linux/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),sbsa-linux)
+    CUDA_INSTALL_TARGET_DIR = targets/sbsa-linux/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-android)
+    CUDA_INSTALL_TARGET_DIR = targets/armv7-linux-androideabi/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-android)
+    CUDA_INSTALL_TARGET_DIR = targets/aarch64-linux-androideabi/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-qnx)
+    CUDA_INSTALL_TARGET_DIR = targets/ARMv7-linux-QNX/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-qnx)
+    CUDA_INSTALL_TARGET_DIR = targets/aarch64-qnx/
+else ifeq ($(TARGET_ARCH),ppc64le)
+    CUDA_INSTALL_TARGET_DIR = targets/ppc64le-linux/
+endif
+
+# Debug build flags
+ifeq ($(dbg),1)
+      NVCCFLAGS += -g -G
+      BUILD_TYPE := debug
+else
+      BUILD_TYPE := release
+endif
+
+ALL_CCFLAGS :=
+ALL_CCFLAGS += $(NVCCFLAGS)
+ALL_CCFLAGS += $(EXTRA_NVCCFLAGS)
+ALL_CCFLAGS += $(addprefix -Xcompiler ,$(CCFLAGS))
+ALL_CCFLAGS += $(addprefix -Xcompiler ,$(EXTRA_CCFLAGS))
+
+SAMPLE_ENABLED := 1
+
+# This sample is not supported on QNX
+ifeq ($(TARGET_OS),qnx)
+  $(info >>> WARNING - Mandelbrot is not supported on QNX - waiving sample <<<)
+  SAMPLE_ENABLED := 0
+endif
+
+ALL_LDFLAGS :=
+ALL_LDFLAGS += $(ALL_CCFLAGS)
+ALL_LDFLAGS += $(addprefix -Xlinker ,$(LDFLAGS))
+ALL_LDFLAGS += $(addprefix -Xlinker ,$(EXTRA_LDFLAGS))
+
+# Common includes and paths for CUDA
+INCLUDES  := -I../../../Common
+LIBRARIES :=
+
+################################################################################
+
+# Makefile include to help find GL Libraries
+include ./findgllib.mk
+
+# OpenGL specific libraries
+ifeq ($(TARGET_OS),darwin)
+ # Mac OSX specific libraries and paths to include
+ LIBRARIES += -L/System/Library/Frameworks/OpenGL.framework/Libraries
+ LIBRARIES += -lGL -lGLU
+ ALL_LDFLAGS += -Xlinker -framework -Xlinker GLUT
+else
+ LIBRARIES += $(GLLINK)
+ LIBRARIES += -lGL -lGLU -lglut
+endif
+
+# Gencode arguments
+ifeq ($(TARGET_ARCH),$(filter $(TARGET_ARCH),armv7l aarch64 sbsa))
+SMS ?= 53 61 70 72 75 80 86 87
+else
+SMS ?= 35 37 50 52 60 61 70 75 80 86
+endif
+
+ifeq ($(SMS),)
+$(info >>> WARNING - no SM architectures have been specified - waiving sample <<<)
+SAMPLE_ENABLED := 0
+endif
+
+ifeq ($(GENCODE_FLAGS),)
+# Generate SASS code for each SM architecture listed in $(SMS)
+$(foreach sm,$(SMS),$(eval GENCODE_FLAGS += -gencode arch=compute_$(sm),code=sm_$(sm)))
+
+# Generate PTX code from the highest SM architecture in $(SMS) to guarantee forward-compatibility
+HIGHEST_SM := $(lastword $(sort $(SMS)))
+ifneq ($(HIGHEST_SM),)
+GENCODE_FLAGS += -gencode arch=compute_$(HIGHEST_SM),code=compute_$(HIGHEST_SM)
+endif
+endif
+
+ALL_CCFLAGS += --threads 0 --std=c++11
+
+ifeq ($(SAMPLE_ENABLED),0)
+EXEC ?= @echo "[@]"
+endif
+
+################################################################################
+
+# Target rules
+all: build
+
+build: Mandelbrot
+
+check.deps:
+ifeq ($(SAMPLE_ENABLED),0)
+	@echo "Sample will be waived due to the above missing dependencies"
+else
+	@echo "Sample is ready - all dependencies have been met"
+endif
+
+Mandelbrot.o:Mandelbrot.cpp
+	$(EXEC) $(NVCC) $(INCLUDES) $(ALL_CCFLAGS) $(GENCODE_FLAGS) -o $@ -c $<
+
+Mandelbrot_cuda.o:Mandelbrot_cuda.cu
+	$(EXEC) $(NVCC) $(INCLUDES) $(ALL_CCFLAGS) $(GENCODE_FLAGS) -o $@ -c $<
+
+Mandelbrot_gold.o:Mandelbrot_gold.cpp
+	$(EXEC) $(NVCC) $(INCLUDES) $(ALL_CCFLAGS) $(GENCODE_FLAGS) -o $@ -c $<
+
+Mandelbrot: Mandelbrot.o Mandelbrot_cuda.o Mandelbrot_gold.o
+	$(EXEC) $(NVCC) $(ALL_LDFLAGS) $(GENCODE_FLAGS) -o $@ $+ $(LIBRARIES)
+	$(EXEC) mkdir -p ../../../bin/$(TARGET_ARCH)/$(TARGET_OS)/$(BUILD_TYPE)
+	$(EXEC) cp $@ ../../../bin/$(TARGET_ARCH)/$(TARGET_OS)/$(BUILD_TYPE)
+
+run: build
+	$(EXEC) ./Mandelbrot
+
+testrun: build
+	$(EXEC) ./Mandelbrot -mode=0 -file=Mandelbrot_fp32.ppm
+		$(EXEC) ./Mandelbrot -mode=1 -file=referenceJulia_fp32.ppm
+
+clean:
+	rm -f Mandelbrot Mandelbrot.o Mandelbrot_cuda.o Mandelbrot_gold.o
+	rm -rf ../../../bin/$(TARGET_ARCH)/$(TARGET_OS)/$(BUILD_TYPE)/Mandelbrot
+
+clobber: clean

Samples/5_Domain_Specific/Mandelbrot/Mandelbrot_cuda.cu

@@ -0,0 +1,394 @@
+/* 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 <stdio.h>
+#include "helper_cuda.h"
+#include "Mandelbrot_kernel.h"
+#include "Mandelbrot_kernel.cuh"
+
+// The Mandelbrot CUDA GPU thread function
+
+template <class T>
+__global__ void Mandelbrot0(uchar4 *dst, const int imageW, const int imageH,
+                            const int crunch, const T xOff, const T yOff,
+                            const T xJP, const T yJP, const T scale,
+                            const uchar4 colors, const int frame,
+                            const int animationFrame, const int gridWidth,
+                            const int numBlocks, const bool isJ) {
+  // loop until all blocks completed
+  for (unsigned int blockIndex = blockIdx.x; blockIndex < numBlocks;
+       blockIndex += gridDim.x) {
+    unsigned int blockX = blockIndex % gridWidth;
+    unsigned int blockY = blockIndex / gridWidth;
+
+    // process this block
+    const int ix = blockDim.x * blockX + threadIdx.x;
+    const int iy = blockDim.y * blockY + threadIdx.y;
+
+    if ((ix < imageW) && (iy < imageH)) {
+      // Calculate the location
+      const T xPos = (T)ix * scale + xOff;
+      const T yPos = (T)iy * scale + yOff;
+
+      // Calculate the Mandelbrot index for the current location
+      int m = CalcMandelbrot<T>(xPos, yPos, xJP, yJP, crunch, isJ);
+      //            int m = blockIdx.x;         // uncomment to see scheduling
+      //            order
+      m = m > 0 ? crunch - m : 0;
+
+      // Convert the Mandelbrot index into a color
+      uchar4 color;
+
+      if (m) {
+        m += animationFrame;
+        color.x = m * colors.x;
+        color.y = m * colors.y;
+        color.z = m * colors.z;
+      } else {
+        color.x = 0;
+        color.y = 0;
+        color.z = 0;
+      }
+
+      // Output the pixel
+      int pixel = imageW * iy + ix;
+
+      if (frame == 0) {
+        color.w = 0;
+        dst[pixel] = color;
+      } else {
+        int frame1 = frame + 1;
+        int frame2 = frame1 / 2;
+        dst[pixel].x = (dst[pixel].x * frame + color.x + frame2) / frame1;
+        dst[pixel].y = (dst[pixel].y * frame + color.y + frame2) / frame1;
+        dst[pixel].z = (dst[pixel].z * frame + color.z + frame2) / frame1;
+      }
+    }
+  }
+
+}  // Mandelbrot0
+
+// The Mandelbrot CUDA GPU thread function (double single version)
+__global__ void MandelbrotDS0(uchar4 *dst, const int imageW, const int imageH,
+                              const int crunch, const float xOff0,
+                              const float xOff1, const float yOff0,
+                              const float yOff1, const float xJP,
+                              const float yJP, const float scale,
+                              const uchar4 colors, const int frame,
+                              const int animationFrame, const int gridWidth,
+                              const int numBlocks, const bool isJ) {
+  // loop until all blocks completed
+  for (unsigned int blockIndex = blockIdx.x; blockIndex < numBlocks;
+       blockIndex += gridDim.x) {
+    unsigned int blockX = blockIndex % gridWidth;
+    unsigned int blockY = blockIndex / gridWidth;
+
+    // process this block
+    const int ix = blockDim.x * blockX + threadIdx.x;
+    const int iy = blockDim.y * blockY + threadIdx.y;
+
+    if ((ix < imageW) && (iy < imageH)) {
+      // Calculate the location
+      float xPos0 = (float)ix * scale;
+      float xPos1 = 0.0f;
+      float yPos0 = (float)iy * scale;
+      float yPos1 = 0.0f;
+      dsadd(xPos0, xPos1, xPos0, xPos1, xOff0, xOff1);
+      dsadd(yPos0, yPos1, yPos0, yPos1, yOff0, yOff1);
+
+      // Calculate the Mandelbrot index for the current location
+      int m =
+          CalcMandelbrotDS(xPos0, xPos1, yPos0, yPos1, xJP, yJP, crunch, isJ);
+      m = m > 0 ? crunch - m : 0;
+
+      // Convert the Mandelbrot index into a color
+      uchar4 color;
+
+      if (m) {
+        m += animationFrame;
+        color.x = m * colors.x;
+        color.y = m * colors.y;
+        color.z = m * colors.z;
+      } else {
+        color.x = 0;
+        color.y = 0;
+        color.z = 0;
+      }
+
+      // Output the pixel
+      int pixel = imageW * iy + ix;
+
+      if (frame == 0) {
+        color.w = 0;
+        dst[pixel] = color;
+      } else {
+        int frame1 = frame + 1;
+        int frame2 = frame1 / 2;
+        dst[pixel].x = (dst[pixel].x * frame + color.x + frame2) / frame1;
+        dst[pixel].y = (dst[pixel].y * frame + color.y + frame2) / frame1;
+        dst[pixel].z = (dst[pixel].z * frame + color.z + frame2) / frame1;
+      }
+    }
+  }
+}  // MandelbrotDS0
+
+// The Mandelbrot secondary AA pass CUDA GPU thread function
+template <class T>
+__global__ void Mandelbrot1(uchar4 *dst, const int imageW, const int imageH,
+                            const int crunch, const T xOff, const T yOff,
+                            const T xJP, const T yJP, const T scale,
+                            const uchar4 colors, const int frame,
+                            const int animationFrame, const int gridWidth,
+                            const int numBlocks, const bool isJ) {
+  // loop until all blocks completed
+  for (unsigned int blockIndex = blockIdx.x; blockIndex < numBlocks;
+       blockIndex += gridDim.x) {
+    unsigned int blockX = blockIndex % gridWidth;
+    unsigned int blockY = blockIndex / gridWidth;
+
+    // process this block
+    const int ix = blockDim.x * blockX + threadIdx.x;
+    const int iy = blockDim.y * blockY + threadIdx.y;
+
+    if ((ix < imageW) && (iy < imageH)) {
+      // Get the current pixel color
+      int pixel = imageW * iy + ix;
+      uchar4 pixelColor = dst[pixel];
+      int count = 0;
+
+      // Search for pixels out of tolerance surrounding the current pixel
+      if (ix > 0) {
+        count += CheckColors(pixelColor, dst[pixel - 1]);
+      }
+
+      if (ix + 1 < imageW) {
+        count += CheckColors(pixelColor, dst[pixel + 1]);
+      }
+
+      if (iy > 0) {
+        count += CheckColors(pixelColor, dst[pixel - imageW]);
+      }
+
+      if (iy + 1 < imageH) {
+        count += CheckColors(pixelColor, dst[pixel + imageW]);
+      }
+
+      if (count) {
+        // Calculate the location
+        const T xPos = (T)ix * scale + xOff;
+        const T yPos = (T)iy * scale + yOff;
+
+        // Calculate the Mandelbrot index for the current location
+        int m = CalcMandelbrot(xPos, yPos, xJP, yJP, crunch, isJ);
+        m = m > 0 ? crunch - m : 0;
+
+        // Convert the Mandelbrot index into a color
+        uchar4 color;
+
+        if (m) {
+          m += animationFrame;
+          color.x = m * colors.x;
+          color.y = m * colors.y;
+          color.z = m * colors.z;
+        } else {
+          color.x = 0;
+          color.y = 0;
+          color.z = 0;
+        }
+
+        // Output the pixel
+        int frame1 = frame + 1;
+        int frame2 = frame1 / 2;
+        dst[pixel].x = (pixelColor.x * frame + color.x + frame2) / frame1;
+        dst[pixel].y = (pixelColor.y * frame + color.y + frame2) / frame1;
+        dst[pixel].z = (pixelColor.z * frame + color.z + frame2) / frame1;
+      }
+    }
+  }
+
+}  // Mandelbrot1
+
+// The Mandelbrot secondary AA pass CUDA GPU thread function (double single
+// version)
+__global__ void MandelbrotDS1(uchar4 *dst, const int imageW, const int imageH,
+                              const int crunch, const float xOff0,
+                              const float xOff1, const float yOff0,
+                              const float yOff1, const float xJP,
+                              const float yJP, const float scale,
+                              const uchar4 colors, const int frame,
+                              const int animationFrame, const int gridWidth,
+                              const int numBlocks, const bool isJ) {
+  // loop until all blocks completed
+  for (unsigned int blockIndex = blockIdx.x; blockIndex < numBlocks;
+       blockIndex += gridDim.x) {
+    unsigned int blockX = blockIndex % gridWidth;
+    unsigned int blockY = blockIndex / gridWidth;
+
+    // process this block
+    const int ix = blockDim.x * blockX + threadIdx.x;
+    const int iy = blockDim.y * blockY + threadIdx.y;
+
+    if ((ix < imageW) && (iy < imageH)) {
+      // Get the current pixel color
+      int pixel = imageW * iy + ix;
+      uchar4 pixelColor = dst[pixel];
+      int count = 0;
+
+      // Search for pixels out of tolerance surrounding the current pixel
+      if (ix > 0) {
+        count += CheckColors(pixelColor, dst[pixel - 1]);
+      }
+
+      if (ix + 1 < imageW) {
+        count += CheckColors(pixelColor, dst[pixel + 1]);
+      }
+
+      if (iy > 0) {
+        count += CheckColors(pixelColor, dst[pixel - imageW]);
+      }
+
+      if (iy + 1 < imageH) {
+        count += CheckColors(pixelColor, dst[pixel + imageW]);
+      }
+
+      if (count) {
+        // Calculate the location
+        float xPos0 = (float)ix * scale;
+        float xPos1 = 0.0f;
+        float yPos0 = (float)iy * scale;
+        float yPos1 = 0.0f;
+        dsadd(xPos0, xPos1, xPos0, xPos1, xOff0, xOff1);
+        dsadd(yPos0, yPos1, yPos0, yPos1, yOff0, yOff1);
+
+        // Calculate the Mandelbrot index for the current location
+        int m =
+            CalcMandelbrotDS(xPos0, xPos1, yPos0, yPos1, xJP, yJP, crunch, isJ);
+        m = m > 0 ? crunch - m : 0;
+
+        // Convert the Mandelbrot index into a color
+        uchar4 color;
+
+        if (m) {
+          m += animationFrame;
+          color.x = m * colors.x;
+          color.y = m * colors.y;
+          color.z = m * colors.z;
+        } else {
+          color.x = 0;
+          color.y = 0;
+          color.z = 0;
+        }
+
+        // Output the pixel
+        int frame1 = frame + 1;
+        int frame2 = frame1 / 2;
+        dst[pixel].x = (pixelColor.x * frame + color.x + frame2) / frame1;
+        dst[pixel].y = (pixelColor.y * frame + color.y + frame2) / frame1;
+        dst[pixel].z = (pixelColor.z * frame + color.z + frame2) / frame1;
+      }
+    }
+  }
+
+}  // MandelbrotDS1
+
+// The host CPU Mandelbrot thread spawner
+void RunMandelbrot0(uchar4 *dst, const int imageW, const int imageH,
+                    const int crunch, const double xOff, const double yOff,
+                    const double xjp, const double yjp, const double scale,
+                    const uchar4 colors, const int frame,
+                    const int animationFrame, const int mode, const int numSMs,
+                    const bool isJ, int version) {
+  dim3 threads(BLOCKDIM_X, BLOCKDIM_Y);
+  dim3 grid(iDivUp(imageW, BLOCKDIM_X), iDivUp(imageH, BLOCKDIM_Y));
+
+  int numWorkerBlocks = numSMs;
+
+  switch (mode) {
+    default:
+    case 0:
+      Mandelbrot0<float><<<numWorkerBlocks, threads>>>(
+          dst, imageW, imageH, crunch, (float)xOff, (float)yOff, (float)xjp,
+          (float)yjp, (float)scale, colors, frame, animationFrame, grid.x,
+          grid.x * grid.y, isJ);
+      break;
+    case 1:
+      float x0, x1, y0, y1;
+      dsdeq(x0, x1, xOff);
+      dsdeq(y0, y1, yOff);
+      MandelbrotDS0<<<numWorkerBlocks, threads>>>(
+          dst, imageW, imageH, crunch, x0, x1, y0, y1, (float)xjp, (float)yjp,
+          (float)scale, colors, frame, animationFrame, grid.x, grid.x * grid.y,
+          isJ);
+      break;
+    case 2:
+      Mandelbrot0<double><<<numWorkerBlocks, threads>>>(
+          dst, imageW, imageH, crunch, xOff, yOff, xjp, yjp, scale, colors,
+          frame, animationFrame, grid.x, grid.x * grid.y, isJ);
+      break;
+  }
+
+  getLastCudaError("Mandelbrot0 kernel execution failed.\n");
+}  // RunMandelbrot0
+
+// The host CPU Mandelbrot thread spawner
+void RunMandelbrot1(uchar4 *dst, const int imageW, const int imageH,
+                    const int crunch, const double xOff, const double yOff,
+                    const double xjp, const double yjp, const double scale,
+                    const uchar4 colors, const int frame,
+                    const int animationFrame, const int mode, const int numSMs,
+                    const bool isJ, int version) {
+  dim3 threads(BLOCKDIM_X, BLOCKDIM_Y);
+  dim3 grid(iDivUp(imageW, BLOCKDIM_X), iDivUp(imageH, BLOCKDIM_Y));
+
+  int numWorkerBlocks = numSMs;
+
+  switch (mode) {
+    default:
+    case 0:
+      Mandelbrot1<float><<<numWorkerBlocks, threads>>>(
+          dst, imageW, imageH, crunch, (float)xOff, (float)yOff, (float)xjp,
+          (float)yjp, (float)scale, colors, frame, animationFrame, grid.x,
+          grid.x * grid.y, isJ);
+      break;
+    case 1:
+      float x0, x1, y0, y1;
+      dsdeq(x0, x1, xOff);
+      dsdeq(y0, y1, yOff);
+      MandelbrotDS1<<<numWorkerBlocks, threads>>>(
+          dst, imageW, imageH, crunch, x0, x1, y0, y1, (float)xjp, (float)yjp,
+          (float)scale, colors, frame, animationFrame, grid.x, grid.x * grid.y,
+          isJ);
+      break;
+    case 2:
+      Mandelbrot1<double><<<numWorkerBlocks, threads>>>(
+          dst, imageW, imageH, crunch, xOff, yOff, xjp, yjp, scale, colors,
+          frame, animationFrame, grid.x, grid.x * grid.y, isJ);
+      break;
+  }
+
+  getLastCudaError("Mandelbrot1 kernel execution failed.\n");
+}  // RunMandelbrot1

Samples/5_Domain_Specific/Mandelbrot/Mandelbrot_gold.cpp

@@ -0,0 +1,282 @@
+/* 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 "Mandelbrot_gold.h"
+
+#define ABS(n) ((n) < 0 ? -(n) : (n))
+
+/* dfloat class declaration */
+class dfloat {
+ private:
+  float val[2];
+
+ public:
+  dfloat() { val[0] = val[1] = 0; }
+  dfloat(float a, float b) {
+    val[0] = a;
+    val[1] = b;
+  }
+  dfloat(double b);
+  inline float operator[](unsigned idx) const { return val[idx]; }
+};
+inline dfloat operator+(const dfloat &dsa, const dfloat &dsb);
+inline dfloat operator-(const dfloat &dsa, const dfloat &dsb);
+inline dfloat operator*(const dfloat &dsa, const dfloat &dsb);
+inline int operator<(const dfloat &a, float b) { return a[0] < b; }
+
+// The core Mandelbrot calculation function template
+template <class T>
+inline int CalcMandelbrot(const T xPos, const T yPos, const T xJParam,
+                          const T yJParam, const int crunch,
+                          const bool isJulia) {
+  T x, y, xx, yy, xC, yC;
+  int i = crunch;
+
+  if (isJulia) {
+    xC = xJParam;
+    yC = yJParam;
+    y = yPos;
+    x = xPos;
+    yy = y * y;
+    xx = x * x;
+  } else {
+    xC = xPos;
+    yC = yPos;
+    x = y = 0;
+    xx = yy = 0;
+  }
+
+  while (--i && (xx + yy < 4.0f)) {
+    y = x * y + x * y + yC;
+    x = xx - yy + xC;
+    yy = y * y;
+    xx = x * x;
+  }
+
+  return i;
+}  // CalcMandelbrot
+
+inline void updatePixel(uchar4 &dst, const uchar4 &color, int frame) {
+  int frame1 = frame + 1;
+  int frame2 = frame1 / 2;
+  dst.x = (dst.x * frame + color.x + frame2) / frame1;
+  dst.y = (dst.y * frame + color.y + frame2) / frame1;
+  dst.z = (dst.z * frame + color.z + frame2) / frame1;
+}
+
+inline void setColor(uchar4 &dst, const uchar4 &colors, int &m,
+                     const int animationFrame) {
+  if (m == 0) {
+    dst.x = 0;
+    dst.y = 0;
+    dst.z = 0;
+    return;
+  }
+
+  m += animationFrame;
+  dst.x = m * colors.x;
+  dst.y = m * colors.y;
+  dst.z = m * colors.z;
+}
+
+template <class T, class T_>
+void runMandelbrotGold0(uchar4 *dst, const int imageW, const int imageH,
+                        const int crunch, const T xOff, const T yOff,
+                        const T xJParam, const T yJParam, const T scale,
+                        const uchar4 colors, const int frame,
+                        const int animationFrame, const bool isJulia) {
+  for (int iy = 0; iy < imageH; iy++)
+    for (int ix = 0; ix < imageW; ix++) {
+      // Calculate the location
+      const T_ xPos = (T)ix * scale + xOff;
+      const T_ yPos = (T)iy * scale + yOff;
+
+      // Calculate the Mandelbrot index for the current location
+      int m = CalcMandelbrot<T_>(xPos, yPos, xJParam, yJParam, crunch, isJulia);
+      m = m > 0 ? crunch - m : 0;
+
+      // Convert the Mandelbrot index into a color
+      uchar4 color;
+
+      setColor(color, colors, m, animationFrame);
+
+      // Output the pixel
+      int pixel = imageW * iy + ix;
+
+      if (frame == 0) {
+        color.w = 0;
+        dst[pixel] = color;
+      } else
+        updatePixel(dst[pixel], color, frame);
+    }
+
+}  // runMandelbrotGold0_
+
+// Determine if two pixel colors are within tolerance
+inline int CheckColors(const uchar4 &color0, const uchar4 &color1) {
+  int x = color1.x - color0.x;
+  int y = color1.y - color0.y;
+  int z = color1.z - color0.z;
+  return (ABS(x) > 10) || (ABS(y) > 10) || (ABS(z) > 10);
+}  // CheckColors
+
+template <class T, class T_>
+void runMandelbrotGold1(uchar4 *dst, const int imageW, const int imageH,
+                        const int crunch, const T xOff, const T yOff,
+                        const T xJParam, const T yJParam, const T scale,
+                        const uchar4 colors, const int frame,
+                        const int animationFrame, const bool isJulia) {
+  for (int iy = 0; iy < imageH; iy++)
+    for (int ix = 0; ix < imageW; ix++) {
+      // Get the current pixel color
+      int pixel = imageW * iy + ix;
+      uchar4 pixelColor = dst[pixel];
+      int count = 0;
+
+      // Search for pixels out of tolerance surrounding the current pixel
+      if (ix > 0) count += CheckColors(pixelColor, dst[pixel - 1]);
+
+      if (ix + 1 < imageW) count += CheckColors(pixelColor, dst[pixel + 1]);
+
+      if (iy > 0) count += CheckColors(pixelColor, dst[pixel - imageW]);
+
+      if (iy + 1 < imageH)
+        count += CheckColors(pixelColor, dst[pixel + imageW]);
+
+      if (count) {
+        // Calculate the location
+        const T_ xPos = (T)ix * scale + xOff;
+        const T_ yPos = (T)iy * scale + yOff;
+
+        // Calculate the Mandelbrot index for the current location
+        int m =
+            CalcMandelbrot<T_>(xPos, yPos, xJParam, yJParam, crunch, isJulia);
+        m = m > 0 ? crunch - m : 0;
+
+        // Convert the Mandelbrot index into a color
+        uchar4 color;
+
+        setColor(color, colors, m, animationFrame);
+
+        // Output the pixel
+        updatePixel(dst[pixel], color, frame);
+      }
+    }
+}  // RunMandelbrotGold1_
+
+/* Implementation of exported functions */
+void RunMandelbrotGold1(uchar4 *dst, const int imageW, const int imageH,
+                        const int crunch, const float xOff, const float yOff,
+                        const float xJParam, const float yJParam,
+                        const float scale, const uchar4 colors, const int frame,
+                        const int animationFrame, const bool isJulia) {
+  runMandelbrotGold1<float, float>(dst, imageW, imageH, crunch, xOff, yOff,
+                                   xJParam, yJParam, scale, colors, frame,
+                                   animationFrame, isJulia);
+
+}  // RunMandelbrotGold1
+
+void RunMandelbrotDSGold1(uchar4 *dst, const int imageW, const int imageH,
+                          const int crunch, const double xOff,
+                          const double yOff, const double xJParam,
+                          const double yJParam, const double scale,
+                          const uchar4 colors, const int frame,
+                          const int animationFrame, const bool isJulia) {
+  runMandelbrotGold1<double, dfloat>(dst, imageW, imageH, crunch, xOff, yOff,
+                                     xJParam, yJParam, scale, colors, frame,
+                                     animationFrame, isJulia);
+
+}  // RunMandelbrotDSGold1
+
+void RunMandelbrotGold0(uchar4 *dst, const int imageW, const int imageH,
+                        const int crunch, const float xOff, const float yOff,
+                        const float xJParam, const float yJParam,
+                        const float scale, const uchar4 colors, const int frame,
+                        const int animationFrame, const bool isJulia) {
+  runMandelbrotGold0<float, float>(dst, imageW, imageH, crunch, xOff, yOff,
+                                   xJParam, yJParam, scale, colors, frame,
+                                   animationFrame, isJulia);
+}  // RunMandelbrotGold0
+
+void RunMandelbrotDSGold0(uchar4 *dst, const int imageW, const int imageH,
+                          const int crunch, const double xOff,
+                          const double yOff, const double xJParam,
+                          const double yJParam, const double scale,
+                          const uchar4 colors, const int frame,
+                          const int animationFrame, const bool isJulia) {
+  runMandelbrotGold0<double, dfloat>(dst, imageW, imageH, crunch, xOff, yOff,
+                                     xJParam, yJParam, scale, colors, frame,
+                                     animationFrame, isJulia);
+}  // RunMandelbrotDSGold0
+
+/*dfloat operations implementation */
+
+/* Construct a DS number equal to a double precision floating point number b*/
+dfloat::dfloat(double b) {
+  val[0] = (float)b;
+  val[1] = (float)(b - val[0]);
+}
+
+inline dfloat operator+(const dfloat &dsa, const dfloat &dsb) {
+  // Compute dsa + dsb using Knuth's trick.
+  float t1 = dsa[0] + dsb[0];
+  float e = t1 - dsa[0];
+  float t2 = ((dsb[0] - e) + (dsa[0] - (t1 - e))) + dsa[1] + dsb[1];
+
+  // The result is t1 + t2, after normalization.
+  e = t1 + t2;
+  return dfloat(e, t2 - (e - t1));
+}
+
+inline dfloat operator-(const dfloat &dsa, const dfloat &dsb) {
+  // Compute dsa - dsb using Knuth's trick.
+  float t1 = dsa[0] - dsb[0];
+  float e = t1 - dsa[0];
+  float t2 = ((-dsb[0] - e) + (dsa[0] - (t1 - e))) + dsa[1] - dsb[1];
+
+  // The result is t1 + t2, after normalization.
+  e = t1 + t2;
+  return dfloat(e, t2 - (e - t1));
+}
+
+inline dfloat operator*(const dfloat &dsa, const dfloat &dsb) {
+  // This splits dsa(1) and dsb(1) into high-order and low-order words.
+  float c11 = dsa[0] * dsb[0];
+  float c21 = dsa[0] * dsb[0] - c11;
+
+  // Compute dsa[0] * dsb[1] + dsa[1] * dsb[0] (only high-order word is needed).
+  float c2 = dsa[0] * dsb[1] + dsa[1] * dsb[0];
+
+  // Compute (c11, c21) + c2 using Knuth's trick, also adding low-order product.
+  float t1 = c11 + c2;
+  float e = t1 - c11;
+  float t2 = ((c2 - e) + (c11 - (t1 - e))) + c21 + dsa[1] * dsb[1];
+
+  // The result is t1 + t2, after normalization.
+  e = t1 + t2;
+  return dfloat(e, t2 - (e - t1));
+}

Samples/5_Domain_Specific/Mandelbrot/Mandelbrot_gold.h

@@ -0,0 +1,62 @@
+/* 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 _MANDELBROT_GOLD_h_
+#define _MANDELBROT_GOLD_h_
+
+#include <vector_types.h>
+
+extern "C" void RunMandelbrotGold0(uchar4 *dst, const int imageW,
+                                   const int imageH, const int crunch,
+                                   const float xOff, const float yOff,
+                                   const float xJParam, const float yJParam,
+                                   const float scale, const uchar4 colors,
+                                   const int frame, const int animationFrame,
+                                   const bool isJulia);
+extern "C" void RunMandelbrotDSGold0(uchar4 *dst, const int imageW,
+                                     const int imageH, const int crunch,
+                                     const double xOff, const double yOff,
+                                     const double xJParam, const double yJParam,
+                                     const double scale, const uchar4 colors,
+                                     const int frame, const int animationFrame,
+                                     const bool isJulia);
+extern "C" void RunMandelbrotGold1(uchar4 *dst, const int imageW,
+                                   const int imageH, const int crunch,
+                                   const float xOff, const float yOff,
+                                   const float xJParam, const float yJParam,
+                                   const float scale, const uchar4 colors,
+                                   const int frame, const int animationFrame,
+                                   const bool isJulia);
+extern "C" void RunMandelbrotDSGold1(uchar4 *dst, const int imageW,
+                                     const int imageH, const int crunch,
+                                     const double xOff, const double yOff,
+                                     const double xJParam, const double yJParam,
+                                     const double scale, const uchar4 colors,
+                                     const int frame, const int animationFrame,
+                                     const bool isJulia);
+
+#endif

Samples/5_Domain_Specific/Mandelbrot/Mandelbrot_kernel.cuh

@@ -0,0 +1,456 @@
+/* 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 <stdio.h>
+#include "helper_cuda.h"
+#include "Mandelbrot_kernel.h"
+
+// The dimensions of the thread block
+#define BLOCKDIM_X 16
+#define BLOCKDIM_Y 16
+
+#define ABS(n) ((n) < 0 ? -(n) : (n))
+
+// Double single functions based on DSFUN90 package:
+// http://crd.lbl.gov/~dhbailey/mpdist/index.html
+
+// This function sets the DS number A equal to the double precision floating
+// point number B.
+inline void dsdeq(float &a0, float &a1, double b) {
+  a0 = (float)b;
+  a1 = (float)(b - a0);
+}  // dsdcp
+
+// This function sets the DS number A equal to the single precision floating
+// point number B.
+__device__ inline void dsfeq(float &a0, float &a1, float b) {
+  a0 = b;
+  a1 = 0.0f;
+}  // dsfeq
+
+// This function computes c = a + b.
+__device__ inline void dsadd(float &c0, float &c1, const float a0,
+                             const float a1, const float b0, const float b1) {
+  // Compute dsa + dsb using Knuth's trick.
+  float t1 = a0 + b0;
+  float e = t1 - a0;
+  float t2 = ((b0 - e) + (a0 - (t1 - e))) + a1 + b1;
+
+  // The result is t1 + t2, after normalization.
+  c0 = e = t1 + t2;
+  c1 = t2 - (e - t1);
+}  // dsadd
+
+// This function computes c = a - b.
+__device__ inline void dssub(float &c0, float &c1, const float a0,
+                             const float a1, const float b0, const float b1) {
+  // Compute dsa - dsb using Knuth's trick.
+  float t1 = a0 - b0;
+  float e = t1 - a0;
+  float t2 = ((-b0 - e) + (a0 - (t1 - e))) + a1 - b1;
+
+  // The result is t1 + t2, after normalization.
+  c0 = e = t1 + t2;
+  c1 = t2 - (e - t1);
+}  // dssub
+
+#if 1
+
+// This function multiplies DS numbers A and B to yield the DS product C.
+__device__ inline void dsmul(float &c0, float &c1, const float a0,
+                             const float a1, const float b0, const float b1) {
+  // This splits dsa(1) and dsb(1) into high-order and low-order words.
+  float cona = a0 * 8193.0f;
+  float conb = b0 * 8193.0f;
+  float sa1 = cona - (cona - a0);
+  float sb1 = conb - (conb - b0);
+  float sa2 = a0 - sa1;
+  float sb2 = b0 - sb1;
+
+  // Multilply a0 * b0 using Dekker's method.
+  float c11 = a0 * b0;
+  float c21 = (((sa1 * sb1 - c11) + sa1 * sb2) + sa2 * sb1) + sa2 * sb2;
+
+  // Compute a0 * b1 + a1 * b0 (only high-order word is needed).
+  float c2 = a0 * b1 + a1 * b0;
+
+  // Compute (c11, c21) + c2 using Knuth's trick, also adding low-order product.
+  float t1 = c11 + c2;
+  float e = t1 - c11;
+  float t2 = ((c2 - e) + (c11 - (t1 - e))) + c21 + a1 * b1;
+
+  // The result is t1 + t2, after normalization.
+  c0 = e = t1 + t2;
+  c1 = t2 - (e - t1);
+}  // dsmul
+
+#else
+
+// Modified double-single mul function by Norbert Juffa, NVIDIA
+// uses __fmul_rn() and __fadd_rn() intrinsics which prevent FMAD merging
+
+/* Based on: Guillaume Da Gra<72>a, David Defour. Implementation of Float-Float
+ * Operators on Graphics Hardware. RNC'7 pp. 23-32, 2006.
+ */
+
+// This function multiplies DS numbers A and B to yield the DS product C.
+__device__ inline void dsmul(float &c0, float &c1, const float a0,
+                             const float a1, const float b0, const float b1) {
+  // This splits dsa(1) and dsb(1) into high-order and low-order words.
+  float cona = a0 * 8193.0f;
+  float conb = b0 * 8193.0f;
+  float sa1 = cona - (cona - a0);
+  float sb1 = conb - (conb - b0);
+  float sa2 = a0 - sa1;
+  float sb2 = b0 - sb1;
+
+  // Multilply a0 * b0 using Dekker's method.
+  float c11 = __fmul_rn(a0, b0);
+  float c21 = (((sa1 * sb1 - c11) + sa1 * sb2) + sa2 * sb1) + sa2 * sb2;
+
+  // Compute a0 * b1 + a1 * b0 (only high-order word is needed).
+  float c2 = __fmul_rn(a0, b1) + __fmul_rn(a1, b0);
+
+  // Compute (c11, c21) + c2 using Knuth's trick, also adding low-order product.
+  float t1 = c11 + c2;
+  float e = t1 - c11;
+  float t2 = ((c2 - e) + (c11 - (t1 - e))) + c21 + __fmul_rn(a1, b1);
+
+  // The result is t1 + t2, after normalization.
+  c0 = e = t1 + t2;
+  c1 = t2 - (e - t1);
+}  // dsmul
+
+#endif
+
+// The core Mandelbrot CUDA GPU calculation function
+#if 1
+// Unrolled version
+template <class T>
+__device__ inline int CalcMandelbrot(const T xPos, const T yPos,
+                                     const T xJParam, const T yJParam,
+                                     const int crunch, const bool isJulia) {
+  T x, y, xx, yy;
+  int i = crunch;
+
+  T xC, yC;
+
+  if (isJulia) {
+    xC = xJParam;
+    yC = yJParam;
+    y = yPos;
+    x = xPos;
+    yy = y * y;
+    xx = x * x;
+
+  } else {
+    xC = xPos;
+    yC = yPos;
+    y = 0;
+    x = 0;
+    yy = 0;
+    xx = 0;
+  }
+
+  do {
+    // Iteration 1
+    if (xx + yy > T(4.0)) return i - 1;
+
+    y = x * y * T(2.0) + yC;
+    x = xx - yy + xC;
+    yy = y * y;
+    xx = x * x;
+
+    // Iteration 2
+    if (xx + yy > T(4.0)) return i - 2;
+
+    y = x * y * T(2.0) + yC;
+    x = xx - yy + xC;
+    yy = y * y;
+    xx = x * x;
+
+    // Iteration 3
+    if (xx + yy > T(4.0)) return i - 3;
+
+    y = x * y * T(2.0) + yC;
+    x = xx - yy + xC;
+    yy = y * y;
+    xx = x * x;
+
+    // Iteration 4
+    if (xx + yy > T(4.0)) return i - 4;
+
+    y = x * y * T(2.0) + yC;
+    x = xx - yy + xC;
+    yy = y * y;
+    xx = x * x;
+
+    // Iteration 5
+    if (xx + yy > T(4.0)) return i - 5;
+
+    y = x * y * T(2.0) + yC;
+    x = xx - yy + xC;
+    yy = y * y;
+    xx = x * x;
+
+    // Iteration 6
+    if (xx + yy > T(4.0)) return i - 6;
+
+    y = x * y * T(2.0) + yC;
+    x = xx - yy + xC;
+    yy = y * y;
+    xx = x * x;
+
+    // Iteration 7
+    if (xx + yy > T(4.0)) return i - 7;
+
+    y = x * y * T(2.0) + yC;
+    x = xx - yy + xC;
+    yy = y * y;
+    xx = x * x;
+
+    // Iteration 8
+    if (xx + yy > T(4.0)) return i - 8;
+
+    y = x * y * T(2.0) + yC;
+    x = xx - yy + xC;
+    yy = y * y;
+    xx = x * x;
+
+    // Iteration 9
+    if (xx + yy > T(4.0)) return i - 9;
+
+    y = x * y * T(2.0) + yC;
+    x = xx - yy + xC;
+    yy = y * y;
+    xx = x * x;
+
+    // Iteration 10
+    if (xx + yy > T(4.0)) return i - 10;
+
+    y = x * y * T(2.0) + yC;
+    x = xx - yy + xC;
+    yy = y * y;
+    xx = x * x;
+
+    // Iteration 11
+    if (xx + yy > T(4.0)) return i - 11;
+
+    y = x * y * T(2.0) + yC;
+    x = xx - yy + xC;
+    yy = y * y;
+    xx = x * x;
+
+    // Iteration 12
+    if (xx + yy > T(4.0)) return i - 12;
+
+    y = x * y * T(2.0) + yC;
+    x = xx - yy + xC;
+    yy = y * y;
+    xx = x * x;
+
+    // Iteration 13
+    if (xx + yy > T(4.0)) return i - 13;
+
+    y = x * y * T(2.0) + yC;
+    x = xx - yy + xC;
+    yy = y * y;
+    xx = x * x;
+
+    // Iteration 14
+    if (xx + yy > T(4.0)) return i - 14;
+
+    y = x * y * T(2.0) + yC;
+    x = xx - yy + xC;
+    yy = y * y;
+    xx = x * x;
+
+    // Iteration 15
+    if (xx + yy > T(4.0)) return i - 15;
+
+    y = x * y * T(2.0) + yC;
+    x = xx - yy + xC;
+    yy = y * y;
+    xx = x * x;
+
+    // Iteration 16
+    if (xx + yy > T(4.0)) return i - 16;
+
+    y = x * y * T(2.0) + yC;
+    x = xx - yy + xC;
+    yy = y * y;
+    xx = x * x;
+
+    // Iteration 17
+    if (xx + yy > T(4.0)) return i - 17;
+
+    y = x * y * T(2.0) + yC;
+    x = xx - yy + xC;
+    yy = y * y;
+    xx = x * x;
+
+    // Iteration 18
+    if (xx + yy > T(4.0)) return i - 18;
+
+    y = x * y * T(2.0) + yC;
+    x = xx - yy + xC;
+    yy = y * y;
+    xx = x * x;
+
+    // Iteration 19
+    if (xx + yy > T(4.0)) return i - 19;
+
+    y = x * y * T(2.0) + yC;
+    x = xx - yy + xC;
+    yy = y * y;
+    xx = x * x;
+
+    // Iteration 20
+    i -= 20;
+
+    if ((i <= 0) || (xx + yy > T(4.0))) return i;
+
+    y = x * y * T(2.0) + yC;
+    x = xx - yy + xC;
+    yy = y * y;
+    xx = x * x;
+  } while (1);
+}  // CalcMandelbrot
+
+#else
+
+template <class T>
+__device__ inline int CalcMandelbrot(const T xPos, const T yPos,
+                                     const T xJParam, const T yJParam,
+                                     const int crunch, const isJulia) {
+  T x, y, xx, yy, xC, yC;
+
+  if (isJulia) {
+    xC = xJParam;
+    yC = yJParam;
+    y = yPos;
+    x = xPos;
+    yy = y * y;
+    xx = x * x;
+
+  } else {
+    xC = xPos;
+    yC = yPos;
+    y = 0;
+    x = 0;
+    yy = 0;
+    xx = 0;
+  }
+
+  int i = crunch;
+
+  while (--i && (xx + yy < T(4.0))) {
+    y = x * y * T(2.0) + yC;
+    x = xx - yy + xC;
+    yy = y * y;
+    xx = x * x;
+  }
+
+  return i;  // i > 0 ? crunch - i : 0;
+}  // CalcMandelbrot
+
+#endif
+
+// The core Mandelbrot calculation function in double-single precision
+__device__ inline int CalcMandelbrotDS(const float xPos0, const float xPos1,
+                                       const float yPos0, const float yPos1,
+                                       const float xJParam, const float yJParam,
+                                       const int crunch, const bool isJulia) {
+  float xx0, xx1;
+  float yy0, yy1;
+  float sum0, sum1;
+  int i = crunch;
+
+  float x0, x1, y0, y1;
+  float xC0, xC1, yC0, yC1;
+
+  if (isJulia) {
+    xC0 = xJParam;
+    xC1 = 0;
+    yC0 = yJParam;
+    yC1 = 0;
+    y0 = yPos0;  // y = yPos;
+    y1 = yPos1;
+    x0 = xPos0;  // x = xPos;
+    x1 = xPos1;
+    dsmul(yy0, yy1, y0, y1, y0, y1);  // yy = y * y;
+    dsmul(xx0, xx1, x0, x1, x0, x1);  // xx = x * x;
+  } else {
+    xC0 = xPos0;
+    xC1 = xPos1;
+    yC0 = yPos0;
+    yC1 = yPos1;
+    y0 = 0;  // y = 0 ;
+    y1 = 0;
+    x0 = 0;  // x = 0 ;
+    x1 = 0;
+    yy0 = 0;  // yy = 0 ;
+    yy1 = 0;
+    xx0 = 0;  // xx = 0 ;
+    xx1 = 0;
+  }
+
+  dsadd(sum0, sum1, xx0, xx1, yy0, yy1);  // sum = xx + yy;
+
+  while (--i && (sum0 + sum1 < 4.0f)) {
+    dsmul(y0, y1, x0, x1, y0, y1);  // y = x * y * 2.0f + yC;  // yC is yPos for
+                                    // Mandelbrot and it is yJParam for Julia
+    dsadd(y0, y1, y0, y1, y0, y1);
+    dsadd(y0, y1, y0, y1, yC0, yC1);
+
+    dssub(x0, x1, xx0, xx1, yy0, yy1);  //  x = xx - yy + xC;  // xC is xPos for
+                                        //  Mandelbrot and it is xJParam for
+                                        //  Julia
+    dsadd(x0, x1, x0, x1, xC0, xC1);
+
+    dsmul(yy0, yy1, y0, y1, y0, y1);        // yy = y * y;
+    dsmul(xx0, xx1, x0, x1, x0, x1);        // xx = x * x;
+    dsadd(sum0, sum1, xx0, xx1, yy0, yy1);  // sum = xx + yy;
+  }
+
+  return i;
+}  // CalcMandelbrotDS
+
+// Determine if two pixel colors are within tolerance
+__device__ inline int CheckColors(const uchar4 &color0, const uchar4 &color1) {
+  int x = color1.x - color0.x;
+  int y = color1.y - color0.y;
+  int z = color1.z - color0.z;
+  return (ABS(x) > 10) || (ABS(y) > 10) || (ABS(z) > 10);
+}  // CheckColors
+
+// Increase the grid size by 1 if the image width or height does not divide
+// evenly
+// by the thread block dimensions
+inline int iDivUp(int a, int b) {
+  return ((a % b) != 0) ? (a / b + 1) : (a / b);
+}  // iDivUp

Samples/5_Domain_Specific/Mandelbrot/Mandelbrot_kernel.h

@@ -0,0 +1,50 @@
+/* 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 _MANDELBROT_KERNEL_h_
+#define _MANDELBROT_KERNEL_h_
+
+#include <vector_types.h>
+
+extern "C" void RunMandelbrot0(uchar4 *dst, const int imageW, const int imageH,
+                               const int crunch, const double xOff,
+                               const double yOff, const double xjp,
+                               const double yjp, const double scale,
+                               const uchar4 colors, const int frame,
+                               const int animationFrame, const int mode,
+                               const int numSMs, const bool isJ,
+                               int version = 13);
+extern "C" void RunMandelbrot1(uchar4 *dst, const int imageW, const int imageH,
+                               const int crunch, const double xOff,
+                               const double yOff, const double xjp,
+                               const double yjp, const double scale,
+                               const uchar4 colors, const int frame,
+                               const int animationFrame, const int mode,
+                               const int numSMs, const bool isJ,
+                               int version = 13);
+
+#endif

Samples/5_Domain_Specific/Mandelbrot/Mandelbrot_vs2017.sln

@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2017
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Mandelbrot", "Mandelbrot_vs2017.vcxproj", "{997E0757-EA74-4A4E-A0FC-47D8C8831A15}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Release|x64 = Release|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Debug|x64.ActiveCfg = Debug|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Debug|x64.Build.0 = Debug|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Release|x64.ActiveCfg = Release|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Release|x64.Build.0 = Release|x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

Samples/5_Domain_Specific/Mandelbrot/Mandelbrot_vs2017.vcxproj

@@ -0,0 +1,126 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <CUDAPropsPath Condition="'$(CUDAPropsPath)'==''">$(VCTargetsPath)\BuildCustomizations</CUDAPropsPath>
+  </PropertyGroup>
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{997E0757-EA74-4A4E-A0FC-47D8C8831A15}</ProjectGuid>
+    <RootNamespace>Mandelbrot_vs2017</RootNamespace>
+    <ProjectName>Mandelbrot</ProjectName>
+    <CudaToolkitCustomDir />
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(WindowsTargetPlatformVersion)'==''">
+    <LatestTargetPlatformVersion>$([Microsoft.Build.Utilities.ToolLocationHelper]::GetLatestSDKTargetPlatformVersion('Windows', '10.0'))</LatestTargetPlatformVersion>
+    <WindowsTargetPlatformVersion Condition="'$(WindowsTargetPlatformVersion)' == ''">$(LatestTargetPlatformVersion)</WindowsTargetPlatformVersion>
+    <TargetPlatformVersion>$(WindowsTargetPlatformVersion)</TargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup>
+    <ConfigurationType>Application</ConfigurationType>
+    <CharacterSet>MultiByte</CharacterSet>
+    <PlatformToolset>v141</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Debug'">
+    <UseDebugLibraries>true</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Release'">
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.6.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <IntDir>$(Platform)/$(Configuration)/</IntDir>
+    <IncludePath>$(IncludePath)</IncludePath>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules />
+    <CodeAnalysisRuleAssemblies />
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Platform)'=='x64'">
+    <OutDir>../../../bin/win64/$(Configuration)/</OutDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;_MBCS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>./;$(CudaToolkitDir)/include;../../../Common;</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <AdditionalDependencies>cudart_static.lib;freeglut.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>$(CudaToolkitLibDir);../../../Common/lib/$(PlatformName);</AdditionalLibraryDirectories>
+      <OutputFile>$(OutDir)/Mandelbrot.exe</OutputFile>
+    </Link>
+    <CudaCompile>
+      <CodeGeneration>compute_35,sm_35;compute_37,sm_37;compute_50,sm_50;compute_52,sm_52;compute_60,sm_60;compute_61,sm_61;compute_70,sm_70;compute_75,sm_75;compute_80,sm_80;compute_86,sm_86;</CodeGeneration>
+      <AdditionalOptions>-Xcompiler "/wd 4819"  --threads 0 </AdditionalOptions>
+      <Include>./;../../../Common</Include>
+      <Defines>WIN32</Defines>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Debug'">
+    <ClCompile>
+      <Optimization>Disabled</Optimization>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
+    </Link>
+    <CudaCompile>
+      <Runtime>MTd</Runtime>
+      <TargetMachinePlatform>64</TargetMachinePlatform>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Release'">
+    <ClCompile>
+      <Optimization>MaxSpeed</Optimization>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>false</GenerateDebugInformation>
+      <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
+    </Link>
+    <CudaCompile>
+      <Runtime>MT</Runtime>
+      <TargetMachinePlatform>64</TargetMachinePlatform>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Platform)'=='Win32'">
+    <Link>
+      
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Platform)'=='x64'">
+    <Link>
+      <AdditionalDependencies>glew64.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="Mandelbrot.cpp" />
+    <CudaCompile Include="Mandelbrot_cuda.cu" />
+    <ClCompile Include="Mandelbrot_gold.cpp" />
+    <ClInclude Include="Mandelbrot_gold.h" />
+    <ClInclude Include="Mandelbrot_kernel.h" />
+    <None Include="Mandelbrot_kernel.cuh" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.6.targets" />
+  </ImportGroup>
+</Project>

Samples/5_Domain_Specific/Mandelbrot/Mandelbrot_vs2019.sln

@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2019
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Mandelbrot", "Mandelbrot_vs2019.vcxproj", "{997E0757-EA74-4A4E-A0FC-47D8C8831A15}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Release|x64 = Release|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Debug|x64.ActiveCfg = Debug|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Debug|x64.Build.0 = Debug|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Release|x64.ActiveCfg = Release|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Release|x64.Build.0 = Release|x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

Samples/5_Domain_Specific/Mandelbrot/Mandelbrot_vs2019.vcxproj

@@ -0,0 +1,122 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <CUDAPropsPath Condition="'$(CUDAPropsPath)'==''">$(VCTargetsPath)\BuildCustomizations</CUDAPropsPath>
+  </PropertyGroup>
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{997E0757-EA74-4A4E-A0FC-47D8C8831A15}</ProjectGuid>
+    <RootNamespace>Mandelbrot_vs2019</RootNamespace>
+    <ProjectName>Mandelbrot</ProjectName>
+    <CudaToolkitCustomDir />
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup>
+    <ConfigurationType>Application</ConfigurationType>
+    <CharacterSet>MultiByte</CharacterSet>
+    <PlatformToolset>v142</PlatformToolset>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Debug'">
+    <UseDebugLibraries>true</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Release'">
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.6.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <IntDir>$(Platform)/$(Configuration)/</IntDir>
+    <IncludePath>$(IncludePath)</IncludePath>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules />
+    <CodeAnalysisRuleAssemblies />
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Platform)'=='x64'">
+    <OutDir>../../../bin/win64/$(Configuration)/</OutDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;_MBCS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>./;$(CudaToolkitDir)/include;../../../Common;</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <AdditionalDependencies>cudart_static.lib;freeglut.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>$(CudaToolkitLibDir);../../../Common/lib/$(PlatformName);</AdditionalLibraryDirectories>
+      <OutputFile>$(OutDir)/Mandelbrot.exe</OutputFile>
+    </Link>
+    <CudaCompile>
+      <CodeGeneration>compute_35,sm_35;compute_37,sm_37;compute_50,sm_50;compute_52,sm_52;compute_60,sm_60;compute_61,sm_61;compute_70,sm_70;compute_75,sm_75;compute_80,sm_80;compute_86,sm_86;</CodeGeneration>
+      <AdditionalOptions>-Xcompiler "/wd 4819"  --threads 0 </AdditionalOptions>
+      <Include>./;../../../Common</Include>
+      <Defines>WIN32</Defines>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Debug'">
+    <ClCompile>
+      <Optimization>Disabled</Optimization>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
+    </Link>
+    <CudaCompile>
+      <Runtime>MTd</Runtime>
+      <TargetMachinePlatform>64</TargetMachinePlatform>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Release'">
+    <ClCompile>
+      <Optimization>MaxSpeed</Optimization>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>false</GenerateDebugInformation>
+      <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
+    </Link>
+    <CudaCompile>
+      <Runtime>MT</Runtime>
+      <TargetMachinePlatform>64</TargetMachinePlatform>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Platform)'=='Win32'">
+    <Link>
+      
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Platform)'=='x64'">
+    <Link>
+      <AdditionalDependencies>glew64.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="Mandelbrot.cpp" />
+    <CudaCompile Include="Mandelbrot_cuda.cu" />
+    <ClCompile Include="Mandelbrot_gold.cpp" />
+    <ClInclude Include="Mandelbrot_gold.h" />
+    <ClInclude Include="Mandelbrot_kernel.h" />
+    <None Include="Mandelbrot_kernel.cuh" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.6.targets" />
+  </ImportGroup>
+</Project>

Samples/5_Domain_Specific/Mandelbrot/Mandelbrot_vs2022.sln

@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2022
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Mandelbrot", "Mandelbrot_vs2022.vcxproj", "{997E0757-EA74-4A4E-A0FC-47D8C8831A15}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Release|x64 = Release|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Debug|x64.ActiveCfg = Debug|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Debug|x64.Build.0 = Debug|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Release|x64.ActiveCfg = Release|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Release|x64.Build.0 = Release|x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

Samples/5_Domain_Specific/Mandelbrot/Mandelbrot_vs2022.vcxproj

@@ -0,0 +1,122 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <CUDAPropsPath Condition="'$(CUDAPropsPath)'==''">$(VCTargetsPath)\BuildCustomizations</CUDAPropsPath>
+  </PropertyGroup>
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{997E0757-EA74-4A4E-A0FC-47D8C8831A15}</ProjectGuid>
+    <RootNamespace>Mandelbrot_vs2022</RootNamespace>
+    <ProjectName>Mandelbrot</ProjectName>
+    <CudaToolkitCustomDir />
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup>
+    <ConfigurationType>Application</ConfigurationType>
+    <CharacterSet>MultiByte</CharacterSet>
+    <PlatformToolset>v143</PlatformToolset>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Debug'">
+    <UseDebugLibraries>true</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Release'">
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.6.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <IntDir>$(Platform)/$(Configuration)/</IntDir>
+    <IncludePath>$(IncludePath)</IncludePath>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules />
+    <CodeAnalysisRuleAssemblies />
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Platform)'=='x64'">
+    <OutDir>../../../bin/win64/$(Configuration)/</OutDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;_MBCS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>./;$(CudaToolkitDir)/include;../../../Common;</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <AdditionalDependencies>cudart_static.lib;freeglut.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>$(CudaToolkitLibDir);../../../Common/lib/$(PlatformName);</AdditionalLibraryDirectories>
+      <OutputFile>$(OutDir)/Mandelbrot.exe</OutputFile>
+    </Link>
+    <CudaCompile>
+      <CodeGeneration>compute_35,sm_35;compute_37,sm_37;compute_50,sm_50;compute_52,sm_52;compute_60,sm_60;compute_61,sm_61;compute_70,sm_70;compute_75,sm_75;compute_80,sm_80;compute_86,sm_86;</CodeGeneration>
+      <AdditionalOptions>-Xcompiler "/wd 4819"  --threads 0 </AdditionalOptions>
+      <Include>./;../../../Common</Include>
+      <Defines>WIN32</Defines>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Debug'">
+    <ClCompile>
+      <Optimization>Disabled</Optimization>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
+    </Link>
+    <CudaCompile>
+      <Runtime>MTd</Runtime>
+      <TargetMachinePlatform>64</TargetMachinePlatform>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Release'">
+    <ClCompile>
+      <Optimization>MaxSpeed</Optimization>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>false</GenerateDebugInformation>
+      <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
+    </Link>
+    <CudaCompile>
+      <Runtime>MT</Runtime>
+      <TargetMachinePlatform>64</TargetMachinePlatform>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Platform)'=='Win32'">
+    <Link>
+      
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Platform)'=='x64'">
+    <Link>
+      <AdditionalDependencies>glew64.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="Mandelbrot.cpp" />
+    <CudaCompile Include="Mandelbrot_cuda.cu" />
+    <ClCompile Include="Mandelbrot_gold.cpp" />
+    <ClInclude Include="Mandelbrot_gold.h" />
+    <ClInclude Include="Mandelbrot_kernel.h" />
+    <None Include="Mandelbrot_kernel.cuh" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.6.targets" />
+  </ImportGroup>
+</Project>

Samples/5_Domain_Specific/Mandelbrot/NsightEclipse.xml

@@ -0,0 +1,106 @@
+<?xml version="1.0" encoding="UTF-8"?> 
+<!DOCTYPE entry SYSTEM "SamplesInfo.dtd">
+<entry>
+  <name>Mandelbrot</name>
+  <cuda_api_list>
+    <toolkit>cudaFree</toolkit>
+    <toolkit>cudaGraphicsMapResources</toolkit>
+    <toolkit>cudaGraphicsUnregisterResource</toolkit>
+    <toolkit>cudaGraphicsGLRegisterBuffer</toolkit>
+    <toolkit>cudaGLUnregisterBufferObject</toolkit>
+    <toolkit>cudaGraphicsResourceGetMappedPointer</toolkit>
+    <toolkit>cudaGLUnmapBufferObject</toolkit>
+    <toolkit>cudaDeviceSynchronize</toolkit>
+    <toolkit>cudaGLMapBufferObject</toolkit>
+    <toolkit>cudaMalloc</toolkit>
+    <toolkit>cudaGLRegisterBufferObject</toolkit>
+    <toolkit>cudaGraphicsUnmapResources</toolkit>
+    <toolkit>cudaMemcpy</toolkit>
+    <toolkit>cudaGetDeviceProperties</toolkit>
+  </cuda_api_list>
+  <description><![CDATA[This sample uses CUDA to compute and display the Mandelbrot or Julia sets interactively. It also illustrates the use of "double single" arithmetic to improve precision when zooming a long way into the pattern. This sample uses double precision.  Thanks to Mark Granger of NewTek who submitted this code sample.!]]></description>
+  <devicecompilation>whole</devicecompilation>
+  <files>
+    <file>data\Mandelbrot_fp32.ppm</file>
+    <file>data\Mandelbrot_fp64.ppm</file>
+    <file>data\referenceJulia_fp32.ppm</file>
+    <file>data\referenceJulia_fp64.ppm</file>
+  </files>
+  <includepaths>
+    <path>./</path>
+    <path>../</path>
+    <path>../../../Common</path>
+  </includepaths>
+  <keyconcepts>
+    <concept level="advanced">Graphics Interop</concept>
+    <concept level="advanced">Data Parallel Algorithms</concept>
+  </keyconcepts>
+  <keywords>
+    <keyword>GPGPU</keyword>
+    <keyword>openGL</keyword>
+  </keywords>
+  <libraries>
+    <library>GLU</library>
+    <library>GL</library>
+    <library framework="true" os="macosx">GLUT</library>
+    <library os="linux">GLEW</library>
+    <library os="linux">glut</library>
+    <library os="linux">X11</library>
+  </libraries>
+  <librarypaths>
+    <path arch="x86_64" os="linux">../../../common/lib/linux/x86_64</path>
+    <path arch="armv7l" os="linux">../../../common/lib/linux/armv7l</path>
+    <path os="macosx">../../../common/lib/darwin</path>
+  </librarypaths>
+  <nsight_eclipse>true</nsight_eclipse>
+  <primary_file>Mandelbrot.cpp</primary_file>
+  <qatests>
+    <qatest>-mode=0 -file=Mandelbrot_fp32.ppm</qatest>
+    <qatest>-mode=1 -file=referenceJulia_fp32.ppm</qatest>
+  </qatests>
+  <required_dependencies>
+    <dependency>X11</dependency>
+    <dependency>GL</dependency>
+  </required_dependencies>
+  <scopes>
+    <scope>2:Graphics Interop</scope>
+    <scope>1:Data-Parallel Algorithms</scope>
+  </scopes>
+  <sm-arch>sm35</sm-arch>
+  <sm-arch>sm37</sm-arch>
+  <sm-arch>sm50</sm-arch>
+  <sm-arch>sm52</sm-arch>
+  <sm-arch>sm53</sm-arch>
+  <sm-arch>sm60</sm-arch>
+  <sm-arch>sm61</sm-arch>
+  <sm-arch>sm70</sm-arch>
+  <sm-arch>sm72</sm-arch>
+  <sm-arch>sm75</sm-arch>
+  <sm-arch>sm80</sm-arch>
+  <sm-arch>sm86</sm-arch>
+  <sm-arch>sm87</sm-arch>
+  <supported_envs>
+    <env>
+      <arch>x86_64</arch>
+      <platform>linux</platform>
+    </env>
+    <env>
+      <platform>windows7</platform>
+    </env>
+    <env>
+      <arch>x86_64</arch>
+      <platform>macosx</platform>
+    </env>
+    <env>
+      <arch>arm</arch>
+    </env>
+    <env>
+      <arch>sbsa</arch>
+    </env>
+  </supported_envs>
+  <supported_sm_architectures>
+    <include>all</include>
+  </supported_sm_architectures>
+  <title>Mandelbrot</title>
+  <type>exe</type>
+</entry>