add and update samples for CUDA 11.6

Samples/5_Domain_Specific/simpleVulkanMMAP/.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/simpleVulkanMMAP/.vscode/extensions.json

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

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

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

Samples/5_Domain_Specific/simpleVulkanMMAP/.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/simpleVulkanMMAP/Build_instructions.txt

@@ -0,0 +1,35 @@
+For Windows:
+Follow these steps once you have installed Vulkan SDK for Windows from https://www.lunarg.com/vulkan-sdk/
+-- Install GLFW3 library at suitable location
+-- Open the simpleVulkan VS project file.
+To add the GLFW3 library path
+-- Right click on Project name "simpleVulkan" click on "Properties"
+-- In Property pages window go to Linker -> General. Here in "Additional Libraries Directories" edit and add path to glfw3dll.lib
+To add the GLFW3 headers path
+-- Right click on Project name "simpleVulkan" click on "Properties"
+-- In Property pages window go to "VC++ Directories" section. Here in "Include Directories" edit and add path to GLFW3 headers include directory location.
+** Make sure to add path to glfw3.dll in your PATH environment variable**
+
+
+For Linux:
+-- Install the Vulkan SDK from https://www.lunarg.com/vulkan-sdk/  and follow environment setup instructions.
+-- Install GLFW3 library through your OS package repository. For example: apt-get for Ubuntu and dnf for RHEL/CentOS. Below is for Ubuntu:
+    sudo apt-get install libglfw3
+    sudo apt-get install libglfw3-dev
+-- Install "libxcb1-dev" and "xorg-dev" as GLFW3 is depended on it
+-- Add Vulkan and GLFW3 libraries directories to LD_LIBRARY_PATH
+
+
+For Linux aarch64(L4T):
+-- Install GLFW3 library using "sudo apt-get install libglfw3-dev" this will provide glfw3 
+-- install above will also provide libvulkan-dev as dependencies
+-- Add Vulkan and GLFW3 libraries directories to LD_LIBRARY_PATH
+-- Pass path to vulkan sdk while building 'make VULKAN_SDK_PATH=<PATH_TO_VULKAN_SDK>', VULKAN_SDK_PATH in this scenario is typically "/usr"
+
+
+For Shader changes:
+-- Update the montecarlo.vert and/or montecarlo.frag shader source file as required
+-- Use the glslc shader compiler from the installed Vulkan SDK's bin directory to compile shaders as:
+    glslc montecarlo.vert -o vert.spv
+    glslc montecarlo.frag -o frag.spv
+** Make sure to add glslc's path in your PATH environment variable **

Samples/5_Domain_Specific/simpleVulkanMMAP/Makefile

@@ -0,0 +1,468 @@
+################################################################################
+# 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 Mac OSX
+ifeq ($(TARGET_OS),darwin)
+  $(info >>> WARNING - simpleVulkanMMAP is not supported on Mac OSX - waiving sample <<<)
+  SAMPLE_ENABLED := 0
+endif
+
+# This sample is not supported on ARMv7
+ifeq ($(TARGET_ARCH),armv7l)
+  $(info >>> WARNING - simpleVulkanMMAP is not supported on ARMv7 - waiving sample <<<)
+  SAMPLE_ENABLED := 0
+endif
+
+# This sample is not supported on QNX
+ifeq ($(TARGET_OS),qnx)
+  $(info >>> WARNING - simpleVulkanMMAP 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 Vulkan SDK and dependencies
+include ./findvulkan.mk
+
+# Vulkan specific libraries
+ifeq ($(TARGET_OS),linux)
+ ifneq ($(TARGET_ARCH),$(HOST_ARCH))
+  LIBRARIES += -L$(VULKAN_SDK_LIB) -lvulkan
+  LIBRARIES += -lglfw
+  INCLUDES  += -I$(VULKAN_HEADER)
+ else
+ LIBRARIES += -L$(VULKAN_SDK_LIB)
+ LIBRARIES += `pkg-config --static --libs glfw3` -lvulkan
+ INCLUDES  += `pkg-config --static --cflags glfw3` -I$(VULKAN_HEADER)
+ endif
+endif
+
+#Detect if installed version of GCC supports required C++11
+ifeq ($(TARGET_OS),linux)
+    empty :=
+    space := $(empty) $(empty)
+    GCCVERSIONSTRING := $(shell expr `$(HOST_COMPILER) -dumpversion`)
+#Create version number without "."
+    GCCVERSION := $(shell expr `echo $(GCCVERSIONSTRING)` | cut -f1 -d.)
+    GCCVERSION += $(shell expr `echo $(GCCVERSIONSTRING)` | cut -f2 -d.)
+    GCCVERSION += $(shell expr `echo $(GCCVERSIONSTRING)` | cut -f3 -d.)
+# Make sure the version number has at least 3 decimals
+    GCCVERSION += 00
+# Remove spaces from the version number
+    GCCVERSION := $(subst $(space),$(empty),$(GCCVERSION))
+#$(warning $(GCCVERSION))
+
+    IS_MIN_VERSION := $(shell expr `echo $(GCCVERSION)` \>= 47000)
+
+    ifeq ($(IS_MIN_VERSION), 1)
+        $(info >>> GCC Version is greater or equal to 4.7.0 <<<)
+    else
+        $(info >>> Waiving build. Minimum GCC version required is 4.7.0<<<)
+        SAMPLE_ENABLED := 0
+    endif
+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
+
+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 += --std=c++11 --threads 0
+
+ifeq ($(SAMPLE_ENABLED),0)
+EXEC ?= @echo "[@]"
+endif
+
+################################################################################
+
+# Target rules
+all: build
+
+build: simpleVulkanMMAP
+
+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
+
+helper_multiprocess.o:../../../Common/helper_multiprocess.cpp
+	$(EXEC) $(NVCC) $(INCLUDES) $(ALL_CCFLAGS) $(GENCODE_FLAGS) -o $@ -c $<
+
+MonteCarloPi.o:MonteCarloPi.cu
+	$(EXEC) $(NVCC) $(INCLUDES) $(ALL_CCFLAGS) $(GENCODE_FLAGS) -o $@ -c $<
+
+VulkanBaseApp.o:VulkanBaseApp.cpp
+	$(EXEC) $(NVCC) $(INCLUDES) $(ALL_CCFLAGS) $(GENCODE_FLAGS) -o $@ -c $<
+
+main.o:main.cpp
+	$(EXEC) $(NVCC) $(INCLUDES) $(ALL_CCFLAGS) $(GENCODE_FLAGS) -o $@ -c $<
+
+simpleVulkanMMAP: helper_multiprocess.o MonteCarloPi.o VulkanBaseApp.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) ./simpleVulkanMMAP
+
+testrun: build
+
+clean:
+	rm -f simpleVulkanMMAP helper_multiprocess.o MonteCarloPi.o VulkanBaseApp.o main.o
+	rm -rf ../../../bin/$(TARGET_ARCH)/$(TARGET_OS)/$(BUILD_TYPE)/simpleVulkanMMAP
+
+clobber: clean

Samples/5_Domain_Specific/simpleVulkanMMAP/MonteCarloPi.cu

@@ -0,0 +1,301 @@
+/* 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.
+ */
+
+/*
+ * See: https://www.piday.org/million/
+ */
+
+#include "MonteCarloPi.h"
+#include <algorithm>
+#define CUDA_DRIVER_API
+#include <helper_cuda.h>
+#include <iostream>
+
+#define ROUND_UP_TO_GRANULARITY(x, n) (((x + n - 1) / n) * n)
+
+// `ipcHandleTypeFlag` specifies the platform specific handle type this sample
+// uses for importing and exporting memory allocation. On Linux this sample
+// specifies the type as CU_MEM_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR meaning that
+// file descriptors will be used. On Windows this sample specifies the type as
+// CU_MEM_HANDLE_TYPE_WIN32 meaning that NT HANDLEs will be used. The
+// ipcHandleTypeFlag variable is a convenience variable and is passed by value
+// to individual requests.
+#if defined(__linux__)
+CUmemAllocationHandleType ipcHandleTypeFlag =
+    CU_MEM_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR;
+#else
+CUmemAllocationHandleType ipcHandleTypeFlag = CU_MEM_HANDLE_TYPE_WIN32;
+#endif
+
+// Windows-specific LPSECURITYATTRIBUTES
+void getDefaultSecurityDescriptor(CUmemAllocationProp *prop) {
+#if defined(__linux__)
+  return;
+#elif defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
+  static const char sddl[] = "D:P(OA;;GARCSDWDWOCCDCLCSWLODTWPRPCRFA;;;WD)";
+  static OBJECT_ATTRIBUTES objAttributes;
+  static bool objAttributesConfigured = false;
+
+  if (!objAttributesConfigured) {
+    PSECURITY_DESCRIPTOR secDesc;
+    BOOL result = ConvertStringSecurityDescriptorToSecurityDescriptorA(
+        sddl, SDDL_REVISION_1, &secDesc, NULL);
+    if (result == 0) {
+      printf("IPC failure: getDefaultSecurityDescriptor Failed! (%d)\n",
+             GetLastError());
+    }
+
+    InitializeObjectAttributes(&objAttributes, NULL, 0, NULL, secDesc);
+
+    objAttributesConfigured = true;
+  }
+
+  prop->win32HandleMetaData = &objAttributes;
+  return;
+#endif
+}
+
+__global__ void monte_carlo_kernel(vec2 *xyVector, float *pointsInsideCircle,
+                                   float *numPointsInCircle,
+                                   unsigned int numPoints, float time) {
+  const size_t stride = gridDim.x * blockDim.x;
+  size_t tid = blockIdx.x * blockDim.x + threadIdx.x;
+  float count = 0.0f;
+
+  curandState rgnState;
+  curand_init((unsigned long long)time, tid, 0, &rgnState);
+
+  for (; tid < numPoints; tid += stride) {
+    float x = curand_uniform(&rgnState);
+    float y = curand_uniform(&rgnState);
+    x = (2.0f * x) - 1.0f;
+    y = (2.0f * y) - 1.0f;
+    xyVector[tid][0] = x;
+    xyVector[tid][1] = y;
+
+    // Compute the distance of this point form the center(0, 0)
+    float dist = sqrtf((x * x) + (y * y));
+
+    // If distance is less than the radius of the unit circle, the point lies in
+    // the circle.
+    pointsInsideCircle[tid] = (dist <= 1.0f);
+    count += (dist <= 1.0f);
+  }
+  atomicAdd(numPointsInCircle, count);
+}
+
+MonteCarloPiSimulation::MonteCarloPiSimulation(size_t num_points)
+    : m_xyVector(nullptr),
+      m_pointsInsideCircle(nullptr),
+      m_totalPointsInsideCircle(0),
+      m_totalPointsSimulated(0),
+      m_numPoints(num_points) {}
+
+MonteCarloPiSimulation::~MonteCarloPiSimulation() {
+  if (m_numPointsInCircle) {
+    checkCudaErrors(cudaFree(m_numPointsInCircle));
+    m_numPointsInCircle = nullptr;
+  }
+  if (m_hostNumPointsInCircle) {
+    checkCudaErrors(cudaFreeHost(m_hostNumPointsInCircle));
+    m_hostNumPointsInCircle = nullptr;
+  }
+
+  cleanupSimulationAllocations();
+}
+
+void MonteCarloPiSimulation::initSimulation(int cudaDevice,
+                                            cudaStream_t stream) {
+  m_cudaDevice = cudaDevice;
+  getIdealExecutionConfiguration();
+
+  // Allocate a position buffer that contains random location of the points in
+  // XY cartesian plane.
+  // Allocate a bitmap buffer which holds information of whether a point in the
+  // position buffer is inside the unit circle or not.
+  setupSimulationAllocations();
+
+  checkCudaErrors(
+      cudaMalloc((float **)&m_numPointsInCircle, sizeof(*m_numPointsInCircle)));
+  checkCudaErrors(cudaMallocHost((float **)&m_hostNumPointsInCircle,
+                                 sizeof(*m_hostNumPointsInCircle)));
+}
+
+void MonteCarloPiSimulation::stepSimulation(float time, cudaStream_t stream) {
+  checkCudaErrors(cudaMemsetAsync(m_numPointsInCircle, 0,
+                                  sizeof(*m_numPointsInCircle), stream));
+
+  monte_carlo_kernel<<<m_blocks, m_threads, 0, stream>>>(
+      m_xyVector, m_pointsInsideCircle, m_numPointsInCircle, m_numPoints, time);
+  getLastCudaError("Failed to launch CUDA simulation");
+
+  checkCudaErrors(cudaMemcpyAsync(m_hostNumPointsInCircle, m_numPointsInCircle,
+                                  sizeof(*m_numPointsInCircle),
+                                  cudaMemcpyDeviceToHost, stream));
+
+  // Queue up a stream callback to compute and print the PI value.
+  checkCudaErrors(
+      cudaLaunchHostFunc(stream, this->computePiCallback, (void *)this));
+}
+
+void MonteCarloPiSimulation::computePiCallback(void *args) {
+  MonteCarloPiSimulation *cbData = (MonteCarloPiSimulation *)args;
+  cbData->m_totalPointsInsideCircle += *(cbData->m_hostNumPointsInCircle);
+  cbData->m_totalPointsSimulated += cbData->m_numPoints;
+  double piValue = 4.0 * ((double)cbData->m_totalPointsInsideCircle /
+                          (double)cbData->m_totalPointsSimulated);
+  printf("Approximate Pi value for %zd data points: %lf \n",
+         cbData->m_totalPointsSimulated, piValue);
+}
+
+void MonteCarloPiSimulation::getIdealExecutionConfiguration() {
+  int warpSize = 0;
+  int multiProcessorCount = 0;
+
+  checkCudaErrors(cudaSetDevice(m_cudaDevice));
+  checkCudaErrors(
+      cudaDeviceGetAttribute(&warpSize, cudaDevAttrWarpSize, m_cudaDevice));
+
+  // We don't need large block sizes, since there's not much inter-thread
+  // communication
+  m_threads = warpSize;
+
+  // Use the occupancy calculator and fill the gpu as best as we can
+  checkCudaErrors(cudaOccupancyMaxActiveBlocksPerMultiprocessor(
+      &m_blocks, monte_carlo_kernel, warpSize, 0));
+
+  checkCudaErrors(cudaDeviceGetAttribute(
+      &multiProcessorCount, cudaDevAttrMultiProcessorCount, m_cudaDevice));
+  m_blocks *= multiProcessorCount;
+
+  // Go ahead and the clamp the blocks to the minimum needed for this
+  // height/width
+  m_blocks =
+      std::min(m_blocks, (int)((m_numPoints + m_threads - 1) / m_threads));
+}
+
+void MonteCarloPiSimulation::setupSimulationAllocations() {
+  CUdeviceptr d_ptr = 0U;
+  size_t granularity = 0;
+  CUmemGenericAllocationHandle cudaPositionHandle, cudaInCircleHandle;
+
+  CUmemAllocationProp allocProp = {};
+  allocProp.type = CU_MEM_ALLOCATION_TYPE_PINNED;
+  allocProp.location.type = CU_MEM_LOCATION_TYPE_DEVICE;
+  allocProp.location.id = m_cudaDevice;
+  allocProp.win32HandleMetaData = NULL;
+  allocProp.requestedHandleTypes = ipcHandleTypeFlag;
+
+  // Windows-specific LPSECURITYATTRIBUTES is required when
+  // CU_MEM_HANDLE_TYPE_WIN32 is used. The security attribute defines the scope
+  // of which exported allocations may be tranferred to other processes. For all
+  // other handle types, pass NULL.
+  getDefaultSecurityDescriptor(&allocProp);
+
+  // Get the recommended granularity for m_cudaDevice.
+  checkCudaErrors(cuMemGetAllocationGranularity(
+      &granularity, &allocProp, CU_MEM_ALLOC_GRANULARITY_RECOMMENDED));
+
+  size_t xyPositionVecSize = m_numPoints * sizeof(*m_xyVector);
+  size_t inCircleVecSize = m_numPoints * sizeof(*m_pointsInsideCircle);
+
+  size_t xyPositionSize =
+      ROUND_UP_TO_GRANULARITY(xyPositionVecSize, granularity);
+  size_t inCircleSize = ROUND_UP_TO_GRANULARITY(inCircleVecSize, granularity);
+  m_totalAllocationSize = (xyPositionSize + inCircleSize);
+
+  // Reserve the required contiguous VA space for the allocations
+  checkCudaErrors(
+      cuMemAddressReserve(&d_ptr, m_totalAllocationSize, granularity, 0U, 0));
+
+  // Create the allocations as a pinned allocation on this device.
+  // Create an allocation to store all the positions of points on the xy plane
+  // and a second allocation which stores information if the corresponding
+  // position is inside the unit circle or not.
+  checkCudaErrors(
+      cuMemCreate(&cudaPositionHandle, xyPositionSize, &allocProp, 0));
+  checkCudaErrors(
+      cuMemCreate(&cudaInCircleHandle, inCircleSize, &allocProp, 0));
+
+  // Export the allocation to a platform-specific handle. The type of handle
+  // requested here must match the requestedHandleTypes field in the prop
+  // structure passed to cuMemCreate. The handle obtained here will be passed to
+  // vulkan to import the allocation.
+  checkCudaErrors(cuMemExportToShareableHandle(
+      (void *)&m_posShareableHandle, cudaPositionHandle, ipcHandleTypeFlag, 0));
+  checkCudaErrors(
+      cuMemExportToShareableHandle((void *)&m_inCircleShareableHandle,
+                                   cudaInCircleHandle, ipcHandleTypeFlag, 0));
+
+  CUdeviceptr va_position = d_ptr;
+  CUdeviceptr va_InCircle = va_position + xyPositionSize;
+  m_pointsInsideCircle = (float *)va_InCircle;
+  m_xyVector = (vec2 *)va_position;
+
+  // Assign the chunk to the appropriate VA range
+  checkCudaErrors(
+      cuMemMap(va_position, xyPositionSize, 0, cudaPositionHandle, 0));
+  checkCudaErrors(
+      cuMemMap(va_InCircle, inCircleSize, 0, cudaInCircleHandle, 0));
+
+  // Release the handles for the allocation. Since the allocation is currently
+  // mapped to a VA range with a previous call to cuMemMap the actual freeing of
+  // memory allocation will happen on an eventual call to cuMemUnmap. Thus the
+  // allocation will be kept live until it is unmapped.
+  checkCudaErrors(cuMemRelease(cudaPositionHandle));
+  checkCudaErrors(cuMemRelease(cudaInCircleHandle));
+
+  CUmemAccessDesc accessDescriptor = {};
+  accessDescriptor.location.id = m_cudaDevice;
+  accessDescriptor.location.type = CU_MEM_LOCATION_TYPE_DEVICE;
+  accessDescriptor.flags = CU_MEM_ACCESS_FLAGS_PROT_READWRITE;
+
+  // Apply the access descriptor to the whole VA range. Essentially enables
+  // Read-Write access to the range.
+  checkCudaErrors(
+      cuMemSetAccess(d_ptr, m_totalAllocationSize, &accessDescriptor, 1));
+}
+
+void MonteCarloPiSimulation::cleanupSimulationAllocations() {
+  if (m_xyVector && m_pointsInsideCircle) {
+    // Unmap the mapped virtual memory region
+    // Since the handles to the mapped backing stores have already been released
+    // by cuMemRelease, and these are the only/last mappings referencing them,
+    // The backing stores will be freed.
+    checkCudaErrors(cuMemUnmap((CUdeviceptr)m_xyVector, m_totalAllocationSize));
+
+    checkIpcErrors(ipcCloseShareableHandle(m_posShareableHandle));
+    checkIpcErrors(ipcCloseShareableHandle(m_inCircleShareableHandle));
+
+    // Free the virtual address region.
+    checkCudaErrors(
+        cuMemAddressFree((CUdeviceptr)m_xyVector, m_totalAllocationSize));
+
+    m_xyVector = nullptr;
+    m_pointsInsideCircle = nullptr;
+  }
+}

Samples/5_Domain_Specific/simpleVulkanMMAP/MonteCarloPi.h

@@ -0,0 +1,95 @@
+/* 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.
+ */
+
+#pragma once
+#ifndef __PISIM_H__
+#define __PISIM_H__
+
+#include <vector>
+#include <cuda_runtime_api.h>
+#include <curand.h>
+#include <curand_kernel.h>
+#include <cuda.h>
+
+#include "helper_multiprocess.h"
+
+typedef float vec2[2];
+
+class MonteCarloPiSimulation {
+  size_t m_numPoints;
+
+  // Pointers to Cuda allocated buffers which are imported and used by vulkan as
+  // vertex buffer
+  vec2 *m_xyVector;
+  float *m_pointsInsideCircle;
+
+  // Pointers to device and host allocated memories storing number of points
+  // that are inside the unit circle
+  float *m_numPointsInCircle;
+  float *m_hostNumPointsInCircle;
+
+  int m_blocks, m_threads;
+
+  // Total size of allocations created by cuMemMap Apis. This size is the sum of
+  // sizes of m_xyVector and m_pointsInsideCircle buffers.
+  size_t m_totalAllocationSize;
+
+  // Shareable Handles(a file descriptor on Linux and NT Handle on Windows),
+  // used for sharing cuda
+  // allocated memory with Vulkan
+  ShareableHandle m_posShareableHandle, m_inCircleShareableHandle;
+
+  // Cuda Device corresponding to the Vulkan Physical device
+  int m_cudaDevice;
+
+  // Track and accumulate total points that have been simulated since start of
+  // the sample. The idea is to get a closer approximation to PI with time.
+  size_t m_totalPointsInsideCircle;
+  size_t m_totalPointsSimulated;
+
+  void setupSimulationAllocations();
+  void cleanupSimulationAllocations();
+  void getIdealExecutionConfiguration();
+
+ public:
+  MonteCarloPiSimulation(size_t num_points);
+  ~MonteCarloPiSimulation();
+  void initSimulation(int cudaDevice, cudaStream_t stream = 0);
+  void stepSimulation(float time, cudaStream_t stream = 0);
+  static void computePiCallback(void *args);
+
+  size_t getNumPoints() const { return m_numPoints; }
+
+  float getNumPointsInCircle() const { return *m_hostNumPointsInCircle; }
+
+  ShareableHandle &getPositionShareableHandle() { return m_posShareableHandle; }
+  ShareableHandle &getInCircleShareableHandle() {
+    return m_inCircleShareableHandle;
+  }
+};
+
+#endif  // __PISIM_H__

Samples/5_Domain_Specific/simpleVulkanMMAP/NsightEclipse.xml

@@ -0,0 +1,117 @@
+<?xml version="1.0" encoding="UTF-8"?> 
+<!DOCTYPE entry SYSTEM "SamplesInfo.dtd">
+<entry>
+  <name>simpleVulkanMMAP</name>
+  <cflags>
+    <flag>--std=c++11</flag>
+  </cflags>
+  <cuda_api_list>
+    <driver>cuMemRelease</driver>
+    <driver>cuMemExportToShareableHandle</driver>
+    <driver>cuMemSetAccess</driver>
+    <driver>cuMemMap</driver>
+    <driver>cuMemCreate</driver>
+    <driver>cuMemAddressFree</driver>
+    <driver>cuMemGetAllocationGranularity</driver>
+    <driver>cuMemUnmap</driver>
+    <driver>cuMemAddressReserve</driver>
+    <toolkit>cudaOccupancyMaxActiveBlocksPerMultiprocessor</toolkit>
+    <toolkit>cudaImportExternalSemaphore</toolkit>
+    <toolkit>cudaStreamCreateWithFlags</toolkit>
+    <toolkit>cudaMemcpyAsync</toolkit>
+    <toolkit>cudaStreamDestroy</toolkit>
+    <toolkit>cudaSignalExternalSemaphoresAsync</toolkit>
+    <toolkit>cudaMallocHost</toolkit>
+    <toolkit>cudaMalloc</toolkit>
+    <toolkit>cudaSetDevice</toolkit>
+    <toolkit>cudaGetDeviceProperties</toolkit>
+    <toolkit>cudaGetDeviceCount</toolkit>
+    <toolkit>cudaDeviceGetAttribute</toolkit>
+    <toolkit>cudaSignalSemaphore</toolkit>
+    <toolkit>cudaWaitSemaphore</toolkit>
+    <toolkit>cudaDestroyExternalSemaphore</toolkit>
+    <toolkit>cudaStreamSynchronize</toolkit>
+    <toolkit>cudaFree</toolkit>
+    <toolkit>cudaLaunchHostFunc</toolkit>
+    <toolkit>cudaMemsetAsync</toolkit>
+    <toolkit>cudaFreeHost</toolkit>
+    <toolkit>cudaWaitExternalSemaphoresAsync</toolkit>
+  </cuda_api_list>
+  <description><![CDATA[ This sample demonstrates Vulkan CUDA Interop via cuMemMap APIs. CUDA exports buffers that Vulkan imports as vertex buffer. CUDA invokes kernels to operate on vertices and synchronizes with Vulkan through vulkan semaphores imported by CUDA. This sample depends on Vulkan SDK, GLFW3 libraries, for building this sample please refer to "Build_instructions.txt" provided in this sample's directory]]></description>
+  <devicecompilation>whole</devicecompilation>
+  <files>
+    <file>montecarlo.vert</file>
+    <file>montecarlo.frag</file>
+  </files>
+  <includepaths>
+    <path>./</path>
+    <path>../</path>
+    <path>../../../Common</path>
+  </includepaths>
+  <keyconcepts>
+    <concept level="basic">cuMemMap IPC</concept>
+    <concept level="basic">MMAP</concept>
+    <concept level="advanced">Graphics Interop</concept>
+    <concept level="advanced">CUDA Vulkan Interop</concept>
+    <concept level="advanced">Data Parallel Algorithms</concept>
+  </keyconcepts>
+  <keywords>
+    <keyword>CUDA</keyword>
+    <keyword>CPP11</keyword>
+    <keyword>monte-carlo</keyword>
+    <keyword>Vulkan</keyword>
+  </keywords>
+  <libraries>
+    <library os="linux">cuda</library>
+    <library framework="true" os="macosx">CUDA</library>
+  </libraries>
+  <librarypaths>
+  </librarypaths>
+  <nsight_eclipse>true</nsight_eclipse>
+  <primary_file>main.cpp</primary_file>
+  <required_dependencies>
+    <dependency>X11</dependency>
+    <dependency>VULKAN</dependency>
+  </required_dependencies>
+  <scopes>
+    <scope>2:Graphics Interop</scope>
+    <scope>1:CUDA Advanced Topics</scope>
+    <scope>1:CUDA Vulkan Interop</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>
+  <sources>
+    <extracompilation>../../../Common/helper_multiprocess.cpp</extracompilation>
+    <extraheader>../../../Common/helper_multiprocess.h</extraheader>
+  </sources>
+  <supported_envs>
+    <env>
+      <arch>x86_64</arch>
+      <platform>linux</platform>
+    </env>
+    <env>
+      <platform>windows7</platform>
+    </env>
+    <env>
+      <platform>aarch64</platform>
+    </env>
+    <env>
+      <platform>sbsa</platform>
+    </env>
+  </supported_envs>
+  <supported_sm_architectures>
+    <include>all</include>
+  </supported_sm_architectures>
+  <title>Vulkan CUDA Interop PI Approximation</title>
+</entry>

Samples/5_Domain_Specific/simpleVulkanMMAP/README.md

@@ -0,0 +1,77 @@
+# simpleVulkanMMAP - Vulkan CUDA Interop PI Approximation
+
+## Description
+
+ This sample demonstrates Vulkan CUDA Interop via cuMemMap APIs. CUDA exports buffers that Vulkan imports as vertex buffer. CUDA invokes kernels to operate on vertices and synchronizes with Vulkan through vulkan semaphores imported by CUDA. This sample depends on Vulkan SDK, GLFW3 libraries, for building this sample please refer to "Build_instructions.txt" provided in this sample's directory
+
+## Key Concepts
+
+cuMemMap IPC, MMAP, Graphics Interop, CUDA Vulkan Interop, 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, aarch64
+
+## CUDA APIs involved
+
+### [CUDA Driver API](http://docs.nvidia.com/cuda/cuda-driver-api/index.html)
+cuMemRelease, cuMemExportToShareableHandle, cuMemSetAccess, cuMemMap, cuMemCreate, cuMemAddressFree, cuMemGetAllocationGranularity, cuMemUnmap, cuMemAddressReserve
+
+### [CUDA Runtime API](http://docs.nvidia.com/cuda/cuda-runtime-api/index.html)
+cudaOccupancyMaxActiveBlocksPerMultiprocessor, cudaImportExternalSemaphore, cudaStreamCreateWithFlags, cudaMemcpyAsync, cudaStreamDestroy, cudaSignalExternalSemaphoresAsync, cudaMallocHost, cudaMalloc, cudaSetDevice, cudaGetDeviceProperties, cudaGetDeviceCount, cudaDeviceGetAttribute, cudaSignalSemaphore, cudaWaitSemaphore, cudaDestroyExternalSemaphore, cudaStreamSynchronize, cudaFree, cudaLaunchHostFunc, cudaMemsetAsync, cudaFreeHost, cudaWaitExternalSemaphoresAsync
+
+## Dependencies needed to build/run
+[X11](../../README.md#x11), [VULKAN](../../README.md#vulkan)
+
+## 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, 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=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/simpleVulkanMMAP/VulkanBaseApp.h

@@ -0,0 +1,160 @@
+/* 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.
+ */
+
+#pragma once
+#ifndef __VULKANBASEAPP_H__
+#define __VULKANBASEAPP_H__
+
+#include <string>
+#include <vector>
+#include <vulkan/vulkan.h>
+#ifdef _WIN64
+#define NOMINMAX
+#include <windows.h>
+#include <vulkan/vulkan_win32.h>
+#endif /* _WIN64 */
+
+struct GLFWwindow;
+
+class VulkanBaseApp {
+ public:
+  VulkanBaseApp(const std::string& appName, bool enableValidation = false);
+  static VkExternalSemaphoreHandleTypeFlagBits getDefaultSemaphoreHandleType();
+  static VkExternalMemoryHandleTypeFlagBits getDefaultMemHandleType();
+  virtual ~VulkanBaseApp();
+  void init();
+  void* getMemHandle(VkDeviceMemory memory,
+                     VkExternalMemoryHandleTypeFlagBits handleType);
+  void* getSemaphoreHandle(VkSemaphore semaphore,
+                           VkExternalSemaphoreHandleTypeFlagBits handleType);
+  bool isVkPhysicalDeviceUuid(void* Uuid);
+  void createExternalSemaphore(
+      VkSemaphore& semaphore, VkExternalSemaphoreHandleTypeFlagBits handleType);
+  void createBuffer(VkDeviceSize size, VkBufferUsageFlags usage,
+                    VkMemoryPropertyFlags properties, VkBuffer& buffer,
+                    VkDeviceMemory& bufferMemory);
+  void createExternalBuffer(VkDeviceSize size, VkBufferUsageFlags usage,
+                            VkMemoryPropertyFlags properties,
+                            VkExternalMemoryHandleTypeFlagsKHR extMemHandleType,
+                            VkBuffer& buffer, VkDeviceMemory& bufferMemory);
+  void importExternalBuffer(void* handle,
+                            VkExternalMemoryHandleTypeFlagBits handleType,
+                            size_t size, VkBufferUsageFlags usage,
+                            VkMemoryPropertyFlags properties, VkBuffer& buffer,
+                            VkDeviceMemory& memory);
+  void copyBuffer(VkBuffer dst, VkBuffer src, VkDeviceSize size);
+  VkCommandBuffer beginSingleTimeCommands();
+  void endSingleTimeCommands(VkCommandBuffer commandBuffer);
+  void mainLoop();
+
+ protected:
+  const std::string m_appName;
+  const bool m_enableValidation;
+  VkInstance m_instance;
+  VkDebugUtilsMessengerEXT m_debugMessenger;
+  VkSurfaceKHR m_surface;
+  VkPhysicalDevice m_physicalDevice;
+  uint8_t m_deviceUUID[VK_UUID_SIZE];
+  VkDevice m_device;
+  VkQueue m_graphicsQueue;
+  VkQueue m_presentQueue;
+  VkSwapchainKHR m_swapChain;
+  std::vector<VkImage> m_swapChainImages;
+  VkFormat m_swapChainFormat;
+  VkExtent2D m_swapChainExtent;
+  std::vector<VkImageView> m_swapChainImageViews;
+  std::vector<std::pair<VkShaderStageFlagBits, std::string> > m_shaderFiles;
+  VkRenderPass m_renderPass;
+  VkPipelineLayout m_pipelineLayout;
+  VkPipeline m_graphicsPipeline;
+  std::vector<VkFramebuffer> m_swapChainFramebuffers;
+  VkCommandPool m_commandPool;
+  std::vector<VkCommandBuffer> m_commandBuffers;
+  std::vector<VkSemaphore> m_imageAvailableSemaphores;
+  std::vector<VkSemaphore> m_renderFinishedSemaphores;
+  std::vector<VkFence> m_inFlightFences;
+  std::vector<VkBuffer> m_uniformBuffers;
+  std::vector<VkDeviceMemory> m_uniformMemory;
+  VkDescriptorSetLayout m_descriptorSetLayout;
+  VkDescriptorPool m_descriptorPool;
+  std::vector<VkDescriptorSet> m_descriptorSets;
+
+  VkImage m_depthImage;
+  VkDeviceMemory m_depthImageMemory;
+  VkImageView m_depthImageView;
+  size_t m_currentFrame;
+  bool m_framebufferResized;
+
+  virtual void initVulkanApp() {}
+  virtual void fillRenderingCommandBuffer(VkCommandBuffer& buffer) {}
+  virtual std::vector<const char*> getRequiredExtensions() const;
+  virtual std::vector<const char*> getRequiredDeviceExtensions() const;
+  virtual void getVertexDescriptions(
+      std::vector<VkVertexInputBindingDescription>& bindingDesc,
+      std::vector<VkVertexInputAttributeDescription>& attribDesc);
+  virtual void getAssemblyStateInfo(
+      VkPipelineInputAssemblyStateCreateInfo& info);
+  virtual void getWaitFrameSemaphores(
+      std::vector<VkSemaphore>& wait,
+      std::vector<VkPipelineStageFlags>& waitStages) const;
+  virtual void getSignalFrameSemaphores(std::vector<VkSemaphore>& signal) const;
+  virtual VkDeviceSize getUniformSize() const;
+  virtual void updateUniformBuffer(uint32_t imageIndex, size_t globalFrame);
+  virtual void drawFrame();
+
+ private:
+  GLFWwindow* m_window;
+
+  void initWindow();
+  void initVulkan();
+  void createInstance();
+  void createSurface();
+  void createDevice();
+  void createSwapChain();
+  void createImageViews();
+  void createRenderPass();
+  void createDescriptorSetLayout();
+  void createGraphicsPipeline();
+  void createFramebuffers();
+  void createCommandPool();
+  void createDepthResources();
+  void createUniformBuffers();
+  void createDescriptorPool();
+  void createDescriptorSets();
+  void createCommandBuffers();
+  void createSyncObjects();
+
+  void cleanupSwapChain();
+  void recreateSwapChain();
+
+  bool isSuitableDevice(VkPhysicalDevice dev) const;
+  static void resizeCallback(GLFWwindow* window, int width, int height);
+};
+
+void readFile(std::istream& s, std::vector<char>& data);
+
+#endif /* __VULKANBASEAPP_H__ */

Samples/5_Domain_Specific/simpleVulkanMMAP/VulkanCudaInterop.h

@@ -0,0 +1,82 @@
+/* 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.
+ */
+
+#pragma once
+#ifndef __VKCUDA_H__
+#define __VKCUDA_H__
+
+#include <cuda_runtime_api.h>
+#include "cuda.h"
+#define CUDA_DRIVER_API
+#include <helper_cuda.h>
+
+bool isDeviceCompatible(void *Uuid, size_t size) {
+  int cudaDevice = cudaInvalidDeviceId;
+  int deviceCount;
+  checkCudaErrors(cudaGetDeviceCount(&deviceCount));
+
+  for (int i = 0; i < deviceCount; ++i) {
+    cudaDeviceProp devProp = {};
+    checkCudaErrors(cudaGetDeviceProperties(&devProp, i));
+    if (!memcmp(&devProp.uuid, Uuid, size)) {
+      cudaDevice = i;
+      break;
+    }
+  }
+  if (cudaDevice == cudaInvalidDeviceId) {
+    return false;
+  }
+
+  int deviceSupportsHandle = 0;
+  int attributeVal = 0;
+  int deviceComputeMode = 0;
+
+  checkCudaErrors(cuDeviceGetAttribute(
+      &deviceComputeMode, CU_DEVICE_ATTRIBUTE_COMPUTE_MODE, cudaDevice));
+  checkCudaErrors(cuDeviceGetAttribute(
+      &attributeVal, CU_DEVICE_ATTRIBUTE_VIRTUAL_ADDRESS_MANAGEMENT_SUPPORTED,
+      cudaDevice));
+
+#if defined(__linux__)
+  checkCudaErrors(cuDeviceGetAttribute(
+      &deviceSupportsHandle,
+      CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR_SUPPORTED,
+      cudaDevice));
+#else
+  checkCudaErrors(cuDeviceGetAttribute(
+      &deviceSupportsHandle,
+      CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_WIN32_HANDLE_SUPPORTED, cudaDevice));
+#endif
+
+  if ((deviceComputeMode != CU_COMPUTEMODE_DEFAULT) || !attributeVal ||
+      !deviceSupportsHandle) {
+    return false;
+  }
+  return true;
+}
+
+#endif  // __VKCUDA_H__

Samples/5_Domain_Specific/simpleVulkanMMAP/findvulkan.mk

@@ -0,0 +1,146 @@
+################################################################################
+# 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.
+#
+################################################################################
+#
+#  findvulkan.mk is used to find the necessary Vulkan Libraries for specific distributions
+#               this is supported on Linux
+#
+################################################################################
+
+# Determine OS platform and unix distribution
+ifeq ("$(TARGET_OS)","linux")
+   # first search lsb_release
+   DISTRO  = $(shell lsb_release -i -s 2>/dev/null | tr "[:upper:]" "[:lower:]")
+   ifeq ("$(DISTRO)","")
+     # second search and parse /etc/issue
+     DISTRO = $(shell more /etc/issue | awk '{print $$1}' | sed '1!d' | sed -e "/^$$/d" 2>/dev/null | tr "[:upper:]" "[:lower:]")
+     # ensure data from /etc/issue is valid
+     ifneq (,$(filter-out $(DISTRO),ubuntu fedora red rhel centos suse))
+       DISTRO = 
+     endif
+     ifeq ("$(DISTRO)","")
+       # third, we can search in /etc/os-release or /etc/{distro}-release
+       DISTRO = $(shell awk '/ID/' /etc/*-release | sed 's/ID=//' | grep -v "VERSION" | grep -v "ID" | grep -v "DISTRIB")
+     endif
+   endif
+endif
+
+ifeq ("$(TARGET_OS)","linux")
+    # Each set of Linux Distros have different paths for where to find libraries
+    UBUNTU = $(shell echo $(DISTRO) | grep -i ubuntu      >/dev/null 2>&1; echo $$?)
+    FEDORA = $(shell echo $(DISTRO) | grep -i fedora      >/dev/null 2>&1; echo $$?)
+    RHEL   = $(shell echo $(DISTRO) | grep -i 'red\|rhel' >/dev/null 2>&1; echo $$?)
+    CENTOS = $(shell echo $(DISTRO) | grep -i centos      >/dev/null 2>&1; echo $$?)
+    SUSE   = $(shell echo $(DISTRO) | grep -i 'suse\|sles' >/dev/null 2>&1; echo $$?)
+    ifeq ("$(UBUNTU)","0")
+      ifeq ($(HOST_ARCH)-$(TARGET_ARCH),x86_64-armv7l)
+        GLPATH := /usr/arm-linux-gnueabihf/lib
+        GLLINK := -L/usr/arm-linux-gnueabihf/lib
+        ifneq ($(TARGET_FS),) 
+          GLPATH += $(TARGET_FS)/usr/lib/arm-linux-gnueabihf
+          GLLINK += -L$(TARGET_FS)/usr/lib/arm-linux-gnueabihf
+        endif 
+      else ifeq ($(HOST_ARCH)-$(TARGET_ARCH),x86_64-aarch64)
+        GLPATH := /usr/aarch64-linux-gnu/lib
+        GLLINK := -L/usr/aarch64-linux-gnu/lib
+        ifneq ($(TARGET_FS),) 
+          GLPATH += $(TARGET_FS)/usr/lib
+          GLPATH += $(TARGET_FS)/usr/lib/aarch64-linux-gnu
+          GLLINK += -L$(TARGET_FS)/usr/lib/aarch64-linux-gnu
+        endif 
+      else
+        UBUNTU_PKG_NAME = $(shell which dpkg >/dev/null 2>&1 && dpkg -l 'nvidia-*' | grep '^ii' | awk '{print $$2}' | head -1)
+        ifneq ("$(UBUNTU_PKG_NAME)","")
+          GLPATH    ?= /usr/lib/$(UBUNTU_PKG_NAME)
+          GLLINK    ?= -L/usr/lib/$(UBUNTU_PKG_NAME)
+        endif
+
+        DFLT_PATH ?= /usr/lib
+      endif
+    endif
+    ifeq ("$(SUSE)","0")
+      GLPATH    ?= /usr/X11R6/lib64
+      GLLINK    ?= -L/usr/X11R6/lib64
+      DFLT_PATH ?= /usr/lib64
+    endif
+    ifeq ("$(FEDORA)","0")
+      GLPATH    ?= /usr/lib64/nvidia
+      GLLINK    ?= -L/usr/lib64/nvidia
+      DFLT_PATH ?= /usr/lib64
+    endif
+    ifeq ("$(RHEL)","0")
+      GLPATH    ?= /usr/lib64/nvidia
+      GLLINK    ?= -L/usr/lib64/nvidia
+      DFLT_PATH ?= /usr/lib64
+    endif
+    ifeq ("$(CENTOS)","0")
+      GLPATH    ?= /usr/lib64/nvidia
+      GLLINK    ?= -L/usr/lib64/nvidia
+      DFLT_PATH ?= /usr/lib64
+    endif
+
+  VULKAN_SDK_PATH ?= ${VULKAN_SDK}
+
+  ifeq ("$(VULKAN_SDK_PATH)","")
+      VULKAN_SDK_PATH := $(DFLT_PATH)
+  endif
+
+  VULKAN_SDK_LIB  := $(shell find -L $(VULKAN_SDK_PATH) -name libvulkan.so    -print 2>/dev/null)
+  X11LIB          := $(shell find -L $(GLPATH) $(DFLT_PATH) -name libX11.so    -print 2>/dev/null)
+
+  ifeq ("$(VULKAN_SDK_LIB)","")
+      $(info >>> WARNING - libvulkan.so not found, please install Vulkan SDK and pass VULKAN_SDK_PATH=<PATH_TO_VULKAN_SDK> <<<)
+      SAMPLE_ENABLED := 0
+  else
+      VULKAN_SDK_LIB := $(shell echo $(VULKAN_SDK_LIB) | sed "s/ .*//" | sed "s/\/libvulkan.so//" )
+  endif
+
+  ifeq ("$(X11LIB)","")
+      $(info >>> WARNING - libX11.so not found, please install libX11.so <<<)
+      SAMPLE_ENABLED := 0
+  endif
+
+  HEADER_SEARCH_PATH ?= $(TARGET_FS)/usr/include
+  HEADER_SEARCH_PATH += $(TARGET_FS)/usr/local/include
+  ifeq ($(HOST_ARCH)-$(TARGET_ARCH)-$(TARGET_OS),x86_64-armv7l-linux)
+      HEADER_SEARCH_PATH += /usr/arm-linux-gnueabihf/include
+  else ifeq ($(HOST_ARCH)-$(TARGET_ARCH)-$(TARGET_OS),x86_64-aarch64-linux)
+      HEADER_SEARCH_PATH += /usr/aarch64-linux-gnu/include
+  endif
+
+  VULKAN_HEADER  := $(shell find -L $(VULKAN_SDK_PATH) $(HEADER_SEARCH_PATH) -name vulkan.h -print 2>/dev/null)
+
+  ifeq ("$(VULKAN_HEADER)","")
+      $(info >>> WARNING - vulkan.h not found, please install vulkan.h <<<)
+      SAMPLE_ENABLED := 0
+  else
+      VULKAN_HEADER := $(shell echo $(VULKAN_HEADER) | sed "s/ .*//" | sed "s/\/vulkan\/vulkan.h//" )
+  endif
+else
+endif
+

Samples/5_Domain_Specific/simpleVulkanMMAP/main.cpp

@@ -0,0 +1,352 @@
+/* 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 demonstrates CUDA Interop with Vulkan using cuMemMap APIs.
+ * Allocating device memory and updating values in those allocations are
+ * performed by CUDA and the contents of the allocation are visualized by
+ * Vulkan.
+ */
+
+#include "VulkanBaseApp.h"
+
+#include <iostream>
+#include <iomanip>
+#include <chrono>
+#include <algorithm>
+
+#include "MonteCarloPi.h"
+#include <helper_cuda.h>
+#include <cuda.h>
+
+#include "helper_multiprocess.h"
+
+//#define DEBUG
+#ifndef DEBUG
+#define ENABLE_VALIDATION (false)
+#else
+#define ENABLE_VALIDATION (true)
+#endif
+
+#define NUM_SIMULATION_POINTS 50000
+
+std::string execution_path;
+
+class VulkanCudaPi : public VulkanBaseApp {
+  typedef struct UniformBufferObject_st { float frame; } UniformBufferObject;
+
+  VkBuffer m_inCircleBuffer, m_xyPositionBuffer;
+  VkDeviceMemory m_inCircleMemory, m_xyPositionMemory;
+  VkSemaphore m_vkWaitSemaphore, m_vkSignalSemaphore;
+  MonteCarloPiSimulation m_sim;
+  UniformBufferObject m_ubo;
+  cudaStream_t m_stream;
+  cudaExternalSemaphore_t m_cudaWaitSemaphore, m_cudaSignalSemaphore;
+  using chrono_tp = std::chrono::time_point<std::chrono::high_resolution_clock>;
+  chrono_tp m_lastTime;
+  size_t m_lastFrame;
+
+ public:
+  VulkanCudaPi(size_t num_points)
+      : VulkanBaseApp("simpleVulkanMMAP", ENABLE_VALIDATION),
+        m_inCircleBuffer(VK_NULL_HANDLE),
+        m_xyPositionBuffer(VK_NULL_HANDLE),
+        m_inCircleMemory(VK_NULL_HANDLE),
+        m_xyPositionMemory(VK_NULL_HANDLE),
+        m_sim(num_points),
+        m_ubo(),
+        m_stream(0),
+        m_vkWaitSemaphore(VK_NULL_HANDLE),
+        m_vkSignalSemaphore(VK_NULL_HANDLE),
+        m_cudaWaitSemaphore(),
+        m_cudaSignalSemaphore(),
+        m_lastFrame(0) {
+    // Add our compiled vulkan shader files
+    char* vertex_shader_path =
+        sdkFindFilePath("vert.spv", execution_path.c_str());
+    char* fragment_shader_path =
+        sdkFindFilePath("frag.spv", execution_path.c_str());
+    m_shaderFiles.push_back(
+        std::make_pair(VK_SHADER_STAGE_VERTEX_BIT, vertex_shader_path));
+    m_shaderFiles.push_back(
+        std::make_pair(VK_SHADER_STAGE_FRAGMENT_BIT, fragment_shader_path));
+  }
+
+  ~VulkanCudaPi() {
+    if (m_stream) {
+      // Make sure there's no pending work before we start tearing down
+      checkCudaErrors(cudaStreamSynchronize(m_stream));
+      checkCudaErrors(cudaStreamDestroy(m_stream));
+    }
+
+    if (m_vkSignalSemaphore != VK_NULL_HANDLE) {
+      checkCudaErrors(cudaDestroyExternalSemaphore(m_cudaSignalSemaphore));
+      vkDestroySemaphore(m_device, m_vkSignalSemaphore, nullptr);
+    }
+    if (m_vkWaitSemaphore != VK_NULL_HANDLE) {
+      checkCudaErrors(cudaDestroyExternalSemaphore(m_cudaWaitSemaphore));
+      vkDestroySemaphore(m_device, m_vkWaitSemaphore, nullptr);
+    }
+    if (m_xyPositionBuffer != VK_NULL_HANDLE) {
+      vkDestroyBuffer(m_device, m_xyPositionBuffer, nullptr);
+    }
+    if (m_xyPositionMemory != VK_NULL_HANDLE) {
+      vkFreeMemory(m_device, m_xyPositionMemory, nullptr);
+    }
+    if (m_inCircleBuffer != VK_NULL_HANDLE) {
+      vkDestroyBuffer(m_device, m_inCircleBuffer, nullptr);
+    }
+    if (m_inCircleMemory != VK_NULL_HANDLE) {
+      vkFreeMemory(m_device, m_inCircleMemory, nullptr);
+    }
+  }
+
+  void fillRenderingCommandBuffer(VkCommandBuffer& commandBuffer) {
+    VkBuffer vertexBuffers[] = {m_inCircleBuffer, m_xyPositionBuffer};
+    VkDeviceSize offsets[] = {0, 0};
+    vkCmdBindVertexBuffers(commandBuffer, 0,
+                           sizeof(vertexBuffers) / sizeof(vertexBuffers[0]),
+                           vertexBuffers, offsets);
+    vkCmdDraw(commandBuffer, (uint32_t)(m_sim.getNumPoints()), 1, 0, 0);
+  }
+
+  void getVertexDescriptions(
+      std::vector<VkVertexInputBindingDescription>& bindingDesc,
+      std::vector<VkVertexInputAttributeDescription>& attribDesc) {
+    bindingDesc.resize(2);
+    attribDesc.resize(2);
+
+    bindingDesc[0].binding = 0;
+    bindingDesc[0].stride = sizeof(float);
+    bindingDesc[0].inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
+
+    bindingDesc[1].binding = 1;
+    bindingDesc[1].stride = sizeof(vec2);
+    bindingDesc[1].inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
+
+    attribDesc[0].binding = 0;
+    attribDesc[0].location = 0;
+    attribDesc[0].format = VK_FORMAT_R32_SFLOAT;
+    attribDesc[0].offset = 0;
+
+    attribDesc[1].binding = 1;
+    attribDesc[1].location = 1;
+    attribDesc[1].format = VK_FORMAT_R32G32_SFLOAT;
+    attribDesc[1].offset = 0;
+  }
+
+  void getAssemblyStateInfo(VkPipelineInputAssemblyStateCreateInfo& info) {
+    info.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
+    info.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
+    info.primitiveRestartEnable = VK_FALSE;
+  }
+
+  void getWaitFrameSemaphores(
+      std::vector<VkSemaphore>& wait,
+      std::vector<VkPipelineStageFlags>& waitStages) const {
+    if (m_currentFrame != 0) {
+      // Have vulkan wait until cuda is done with the vertex buffer before
+      // rendering
+      // We don't do this on the first frame, as the wait semaphore hasn't been
+      // initialized yet
+      wait.push_back(m_vkWaitSemaphore);
+      // We want to wait until all the pipeline commands are complete before
+      // letting cuda work
+      waitStages.push_back(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
+    }
+  }
+
+  void getSignalFrameSemaphores(std::vector<VkSemaphore>& signal) const {
+    // Add this semaphore for vulkan to signal once the vertex buffer is ready
+    // for cuda to modify
+    signal.push_back(m_vkSignalSemaphore);
+  }
+
+  void initVulkanApp() {
+    const size_t nVerts = m_sim.getNumPoints();
+
+    // Obtain cuda device id for the device corresponding to the Vulkan physical
+    // device
+    int deviceCount;
+    int cudaDevice = cudaInvalidDeviceId;
+    checkCudaErrors(cudaGetDeviceCount(&deviceCount));
+    for (int dev = 0; dev < deviceCount; ++dev) {
+      cudaDeviceProp devProp = {};
+      checkCudaErrors(cudaGetDeviceProperties(&devProp, dev));
+      if (isVkPhysicalDeviceUuid(&devProp.uuid)) {
+        cudaDevice = dev;
+        break;
+      }
+    }
+    if (cudaDevice == cudaInvalidDeviceId) {
+      throw std::runtime_error("No Suitable device found!");
+    }
+
+    // On the corresponding cuda device, create the cuda stream we'll using
+    checkCudaErrors(cudaSetDevice(cudaDevice));
+    checkCudaErrors(
+        cudaStreamCreateWithFlags(&m_stream, cudaStreamNonBlocking));
+    m_sim.initSimulation(cudaDevice, m_stream);
+
+    importExternalBuffer(
+        (void*)(uintptr_t)m_sim.getPositionShareableHandle(),
+        getDefaultMemHandleType(), nVerts * sizeof(vec2),
+        VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
+        VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, m_xyPositionBuffer,
+        m_xyPositionMemory);
+
+    importExternalBuffer(
+        (void*)(uintptr_t)m_sim.getInCircleShareableHandle(),
+        getDefaultMemHandleType(), nVerts * sizeof(float),
+        VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
+        VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, m_inCircleBuffer,
+        m_inCircleMemory);
+
+    // Create the semaphore vulkan will signal when it's done with the vertex
+    // buffer
+    createExternalSemaphore(m_vkSignalSemaphore,
+                            getDefaultSemaphoreHandleType());
+    // Create the semaphore vulkan will wait for before using the vertex buffer
+    createExternalSemaphore(m_vkWaitSemaphore, getDefaultSemaphoreHandleType());
+    // Import the semaphore cuda will use -- vulkan's signal will be cuda's wait
+    importCudaExternalSemaphore(m_cudaWaitSemaphore, m_vkSignalSemaphore,
+                                getDefaultSemaphoreHandleType());
+    // Import the semaphore cuda will use -- cuda's signal will be vulkan's wait
+    importCudaExternalSemaphore(m_cudaSignalSemaphore, m_vkWaitSemaphore,
+                                getDefaultSemaphoreHandleType());
+  }
+
+  void importCudaExternalSemaphore(
+      cudaExternalSemaphore_t& cudaSem, VkSemaphore& vkSem,
+      VkExternalSemaphoreHandleTypeFlagBits handleType) {
+    cudaExternalSemaphoreHandleDesc externalSemaphoreHandleDesc = {};
+
+    if (handleType & VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT) {
+      externalSemaphoreHandleDesc.type =
+          cudaExternalSemaphoreHandleTypeOpaqueWin32;
+    } else if (handleType &
+               VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT) {
+      externalSemaphoreHandleDesc.type =
+          cudaExternalSemaphoreHandleTypeOpaqueWin32Kmt;
+    } else if (handleType & VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT) {
+      externalSemaphoreHandleDesc.type =
+          cudaExternalSemaphoreHandleTypeOpaqueFd;
+    } else {
+      throw std::runtime_error("Unknown handle type requested!");
+    }
+
+#ifdef _WIN64
+    externalSemaphoreHandleDesc.handle.win32.handle =
+        (HANDLE)getSemaphoreHandle(vkSem, handleType);
+#else
+    externalSemaphoreHandleDesc.handle.fd =
+        (int)(uintptr_t)getSemaphoreHandle(vkSem, handleType);
+#endif
+
+    externalSemaphoreHandleDesc.flags = 0;
+
+    checkCudaErrors(
+        cudaImportExternalSemaphore(&cudaSem, &externalSemaphoreHandleDesc));
+  }
+
+  VkDeviceSize getUniformSize() const { return sizeof(UniformBufferObject); }
+
+  void updateUniformBuffer(uint32_t imageIndex, size_t globalFrame) {
+    m_ubo.frame = (float)globalFrame;
+    void* data;
+    vkMapMemory(m_device, m_uniformMemory[imageIndex], 0, getUniformSize(), 0,
+                &data);
+    memcpy(data, &m_ubo, sizeof(m_ubo));
+    vkUnmapMemory(m_device, m_uniformMemory[imageIndex]);
+  }
+
+  std::vector<const char*> getRequiredExtensions() const {
+    std::vector<const char*> extensions;
+    extensions.push_back(VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME);
+    extensions.push_back(VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME);
+    extensions.push_back(VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME);
+    extensions.push_back(
+        VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
+    return extensions;
+  }
+
+  std::vector<const char*> getRequiredDeviceExtensions() const {
+    std::vector<const char*> extensions;
+
+    extensions.push_back(VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME);
+    extensions.push_back(VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME);
+#ifdef _WIN64
+    extensions.push_back(VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME);
+    extensions.push_back(VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME);
+#else
+    extensions.push_back(VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME);
+    extensions.push_back(VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME);
+#endif /* _WIN64 */
+    return extensions;
+  }
+
+  void drawFrame() {
+    static chrono_tp startTime = std::chrono::high_resolution_clock::now();
+
+    chrono_tp currentTime = std::chrono::high_resolution_clock::now();
+    float time = std::chrono::duration<float, std::chrono::seconds::period>(
+                     currentTime - startTime)
+                     .count();
+
+    if (m_currentFrame == 0) {
+      m_lastTime = startTime;
+    }
+
+    cudaExternalSemaphoreWaitParams waitParams = {};
+    waitParams.flags = 0;
+    waitParams.params.fence.value = 0;
+
+    cudaExternalSemaphoreSignalParams signalParams = {};
+    signalParams.flags = 0;
+    signalParams.params.fence.value = 0;
+
+    // Have vulkan draw the current frame...
+    VulkanBaseApp::drawFrame();
+    // Wait for vulkan to complete it's work
+    checkCudaErrors(cudaWaitExternalSemaphoresAsync(&m_cudaWaitSemaphore,
+                                                    &waitParams, 1, m_stream));
+    // Now step the simulation
+    m_sim.stepSimulation(time, m_stream);
+
+    // Signal vulkan to continue with the updated buffers
+    checkCudaErrors(cudaSignalExternalSemaphoresAsync(
+        &m_cudaSignalSemaphore, &signalParams, 1, m_stream));
+  }
+};
+
+int main(int argc, char** argv) {
+  execution_path = argv[0];
+  VulkanCudaPi app(NUM_SIMULATION_POINTS);
+  app.init();
+  app.mainLoop();
+  return 0;
+}

Samples/5_Domain_Specific/simpleVulkanMMAP/montecarlo.frag

@@ -0,0 +1,37 @@
+/* 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.
+ */
+
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+
+layout(location = 0) in vec3 fragColor;
+
+layout(location = 0) out vec4 outColor;
+
+void main() {
+    outColor = vec4(fragColor, 1.0);
+}

Samples/5_Domain_Specific/simpleVulkanMMAP/montecarlo.vert

@@ -0,0 +1,55 @@
+/* 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.
+ */
+ 
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+
+layout(binding = 0) uniform UniformBufferObject {
+    float frame;
+} ubo;
+
+layout(location = 0) in float pointInsideCircle;
+layout(location = 1) in vec2 xyPos;
+ 
+layout(location = 0) out vec3 fragColor;
+ 
+const float PI = 3.1415926;
+ 
+out gl_PerVertex
+{
+    vec4 gl_Position;
+    float gl_PointSize;
+};
+ 
+void main() {
+    gl_PointSize = 1.0;
+    gl_Position = vec4(xyPos.xy, 0.0f, 1.0f);
+    float color_r = 1.0f + 0.5f * sin(ubo.frame / 100.0f);
+    float color_g = 1.0f + 0.5f * sin((ubo.frame / 100.0f) + (2.0f*PI/3.0f));
+    float color_b = 1.0f;
+    fragColor = vec3(pointInsideCircle.x * color_r, pointInsideCircle.x * color_g, color_b);
+}

Samples/5_Domain_Specific/simpleVulkanMMAP/simpleVulkanMMAP_vs2017.sln

@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2017
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "simpleVulkanMMAP", "simpleVulkanMMAP_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/simpleVulkanMMAP/simpleVulkanMMAP_vs2017.vcxproj

@@ -0,0 +1,128 @@
+<?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>simpleVulkanMMAP_vs2017</RootNamespace>
+    <ProjectName>simpleVulkanMMAP</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;$(VULKAN_SDK)/include;</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <AdditionalDependencies>cuda.lib;vulkan-1.lib;glfw3dll.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);$(VULKAN_SDK)/Lib;</AdditionalLibraryDirectories>
+      <OutputFile>$(OutDir)/simpleVulkanMMAP.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>
+      
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <CudaCompile Include="MonteCarloPi.cu" />
+    <ClCompile Include="VulkanBaseApp.cpp" />
+    <ClCompile Include="main.cpp" />
+    <ClCompile Include="../../../Common/helper_multiprocess.cpp" />
+    <ClInclude Include="MonteCarloPi.h" />
+    <ClInclude Include="VulkanBaseApp.h" />
+    <ClInclude Include="VulkanCudaInterop.h" />
+    <ClInclude Include="../../../Common/helper_multiprocess.h" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.6.targets" />
+  </ImportGroup>
+</Project>

Samples/5_Domain_Specific/simpleVulkanMMAP/simpleVulkanMMAP_vs2019.sln

@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2019
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "simpleVulkanMMAP", "simpleVulkanMMAP_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/simpleVulkanMMAP/simpleVulkanMMAP_vs2019.vcxproj

@@ -0,0 +1,124 @@
+<?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>simpleVulkanMMAP_vs2019</RootNamespace>
+    <ProjectName>simpleVulkanMMAP</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;$(VULKAN_SDK)/include;</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <AdditionalDependencies>cuda.lib;vulkan-1.lib;glfw3dll.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);$(VULKAN_SDK)/Lib;</AdditionalLibraryDirectories>
+      <OutputFile>$(OutDir)/simpleVulkanMMAP.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>
+      
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <CudaCompile Include="MonteCarloPi.cu" />
+    <ClCompile Include="VulkanBaseApp.cpp" />
+    <ClCompile Include="main.cpp" />
+    <ClCompile Include="../../../Common/helper_multiprocess.cpp" />
+    <ClInclude Include="MonteCarloPi.h" />
+    <ClInclude Include="VulkanBaseApp.h" />
+    <ClInclude Include="VulkanCudaInterop.h" />
+    <ClInclude Include="../../../Common/helper_multiprocess.h" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.6.targets" />
+  </ImportGroup>
+</Project>

Samples/5_Domain_Specific/simpleVulkanMMAP/simpleVulkanMMAP_vs2022.sln

@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2022
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "simpleVulkanMMAP", "simpleVulkanMMAP_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/simpleVulkanMMAP/simpleVulkanMMAP_vs2022.vcxproj

@@ -0,0 +1,124 @@
+<?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>simpleVulkanMMAP_vs2022</RootNamespace>
+    <ProjectName>simpleVulkanMMAP</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;$(VULKAN_SDK)/include;</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <AdditionalDependencies>cuda.lib;vulkan-1.lib;glfw3dll.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);$(VULKAN_SDK)/Lib;</AdditionalLibraryDirectories>
+      <OutputFile>$(OutDir)/simpleVulkanMMAP.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>
+      
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <CudaCompile Include="MonteCarloPi.cu" />
+    <ClCompile Include="VulkanBaseApp.cpp" />
+    <ClCompile Include="main.cpp" />
+    <ClCompile Include="../../../Common/helper_multiprocess.cpp" />
+    <ClInclude Include="MonteCarloPi.h" />
+    <ClInclude Include="VulkanBaseApp.h" />
+    <ClInclude Include="VulkanCudaInterop.h" />
+    <ClInclude Include="../../../Common/helper_multiprocess.h" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.6.targets" />
+  </ImportGroup>
+</Project>