add and update samples for CUDA 11.6

2026-10-23 21:28:17 +08:00 · 2022-01-13 11:35:24 +05:30
parent 11de19f00c
commit 2e41896e1b
4615 changed files with 178150 additions and 181350 deletions
--- a/Samples/5_Domain_Specific/simpleVulkan/.vscode/c_cpp_properties.json
+++ b/Samples/5_Domain_Specific/simpleVulkan/.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
+}
--- a/Samples/5_Domain_Specific/simpleVulkan/.vscode/extensions.json
+++ b/Samples/5_Domain_Specific/simpleVulkan/.vscode/extensions.json
@@ -0,0 +1,7 @@
+{
+    "recommendations": [
+        "nvidia.nsight-vscode-edition",
+        "ms-vscode.cpptools",
+        "ms-vscode.makefile-tools"
+    ]
+}
--- a/Samples/5_Domain_Specific/simpleVulkan/.vscode/launch.json
+++ b/Samples/5_Domain_Specific/simpleVulkan/.vscode/launch.json
@@ -0,0 +1,10 @@
+{
+    "configurations": [
+        {
+            "name": "CUDA C++: Launch",
+            "type": "cuda-gdb",
+            "request": "launch",
+            "program": "${workspaceFolder}/simpleVulkan"
+        }
+    ]
+}
--- a/Samples/5_Domain_Specific/simpleVulkan/.vscode/tasks.json
+++ b/Samples/5_Domain_Specific/simpleVulkan/.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
+            }
+        }
+    ]
+}
--- a/Samples/5_Domain_Specific/simpleVulkan/Build_instructions.txt
+++ b/Samples/5_Domain_Specific/simpleVulkan/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 sinewave.vert and/or sinewave.frag shader source file as required
+-- Use the glslc shader compiler from the installed Vulkan SDK's bin directory to compile shaders as:
+    glslc sinewave.vert -o vert.spv
+    glslc sinewave.frag -o frag.spv
+** Make sure to add glslc's path in your PATH environment variable **
--- a/Samples/5_Domain_Specific/simpleVulkan/Makefile
+++ b/Samples/5_Domain_Specific/simpleVulkan/Makefile
@@ -0,0 +1,405 @@
+################################################################################
+# Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#  * Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+#  * Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in the
+#    documentation and/or other materials provided with the distribution.
+#  * Neither the name of NVIDIA CORPORATION nor the names of its
+#    contributors may be used to endorse or promote products derived
+#    from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+# PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+# OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+################################################################################
+#
+# Makefile project only supported on Mac OS X and Linux Platforms)
+#
+################################################################################
+
+# Location of the CUDA Toolkit
+CUDA_PATH ?= /usr/local/cuda
+
+##############################
+# start deprecated interface #
+##############################
+ifeq ($(x86_64),1)
+    $(info WARNING - x86_64 variable has been deprecated)
+    $(info WARNING - please use TARGET_ARCH=x86_64 instead)
+    TARGET_ARCH ?= x86_64
+endif
+ifeq ($(ARMv7),1)
+    $(info WARNING - ARMv7 variable has been deprecated)
+    $(info WARNING - please use TARGET_ARCH=armv7l instead)
+    TARGET_ARCH ?= armv7l
+endif
+ifeq ($(aarch64),1)
+    $(info WARNING - aarch64 variable has been deprecated)
+    $(info WARNING - please use TARGET_ARCH=aarch64 instead)
+    TARGET_ARCH ?= aarch64
+endif
+ifeq ($(ppc64le),1)
+    $(info WARNING - ppc64le variable has been deprecated)
+    $(info WARNING - please use TARGET_ARCH=ppc64le instead)
+    TARGET_ARCH ?= ppc64le
+endif
+ifneq ($(GCC),)
+    $(info WARNING - GCC variable has been deprecated)
+    $(info WARNING - please use HOST_COMPILER=$(GCC) instead)
+    HOST_COMPILER ?= $(GCC)
+endif
+ifneq ($(abi),)
+    $(error ERROR - abi variable has been removed)
+endif
+############################
+# end deprecated interface #
+############################
+
+# architecture
+HOST_ARCH   := $(shell uname -m)
+TARGET_ARCH ?= $(HOST_ARCH)
+ifneq (,$(filter $(TARGET_ARCH),x86_64 aarch64 sbsa ppc64le armv7l))
+    ifneq ($(TARGET_ARCH),$(HOST_ARCH))
+        ifneq (,$(filter $(TARGET_ARCH),x86_64 aarch64 sbsa ppc64le))
+            TARGET_SIZE := 64
+        else ifneq (,$(filter $(TARGET_ARCH),armv7l))
+            TARGET_SIZE := 32
+        endif
+    else
+        TARGET_SIZE := $(shell getconf LONG_BIT)
+    endif
+else
+    $(error ERROR - unsupported value $(TARGET_ARCH) for TARGET_ARCH!)
+endif
+
+# sbsa and aarch64 systems look similar. Need to differentiate them at host level for now.
+ifeq ($(HOST_ARCH),aarch64)
+    ifeq ($(CUDA_PATH)/targets/sbsa-linux,$(shell ls -1d $(CUDA_PATH)/targets/sbsa-linux 2>/dev/null))
+        HOST_ARCH := sbsa
+        TARGET_ARCH := sbsa
+    endif
+endif
+
+ifneq ($(TARGET_ARCH),$(HOST_ARCH))
+    ifeq (,$(filter $(HOST_ARCH)-$(TARGET_ARCH),aarch64-armv7l x86_64-armv7l x86_64-aarch64 x86_64-sbsa x86_64-ppc64le))
+        $(error ERROR - cross compiling from $(HOST_ARCH) to $(TARGET_ARCH) is not supported!)
+    endif
+endif
+
+# When on native aarch64 system with userspace of 32-bit, change TARGET_ARCH to armv7l
+ifeq ($(HOST_ARCH)-$(TARGET_ARCH)-$(TARGET_SIZE),aarch64-aarch64-32)
+    TARGET_ARCH = armv7l
+endif
+
+# operating system
+HOST_OS   := $(shell uname -s 2>/dev/null | tr "[:upper:]" "[:lower:]")
+TARGET_OS ?= $(HOST_OS)
+ifeq (,$(filter $(TARGET_OS),linux darwin qnx android))
+    $(error ERROR - unsupported value $(TARGET_OS) for TARGET_OS!)
+endif
+
+# host compiler
+ifeq ($(TARGET_OS),darwin)
+    ifeq ($(shell expr `xcodebuild -version | grep -i xcode | awk '{print $$2}' | cut -d'.' -f1` \>= 5),1)
+        HOST_COMPILER ?= clang++
+    endif
+else ifneq ($(TARGET_ARCH),$(HOST_ARCH))
+    ifeq ($(HOST_ARCH)-$(TARGET_ARCH),x86_64-armv7l)
+        ifeq ($(TARGET_OS),linux)
+            HOST_COMPILER ?= arm-linux-gnueabihf-g++
+        else ifeq ($(TARGET_OS),qnx)
+            ifeq ($(QNX_HOST),)
+                $(error ERROR - QNX_HOST must be passed to the QNX host toolchain)
+            endif
+            ifeq ($(QNX_TARGET),)
+                $(error ERROR - QNX_TARGET must be passed to the QNX target toolchain)
+            endif
+            export QNX_HOST
+            export QNX_TARGET
+            HOST_COMPILER ?= $(QNX_HOST)/usr/bin/arm-unknown-nto-qnx6.6.0eabi-g++
+        else ifeq ($(TARGET_OS),android)
+            HOST_COMPILER ?= arm-linux-androideabi-g++
+        endif
+    else ifeq ($(TARGET_ARCH),aarch64)
+        ifeq ($(TARGET_OS), linux)
+            HOST_COMPILER ?= aarch64-linux-gnu-g++
+        else ifeq ($(TARGET_OS),qnx)
+            ifeq ($(QNX_HOST),)
+                $(error ERROR - QNX_HOST must be passed to the QNX host toolchain)
+            endif
+            ifeq ($(QNX_TARGET),)
+                $(error ERROR - QNX_TARGET must be passed to the QNX target toolchain)
+            endif
+            export QNX_HOST
+            export QNX_TARGET
+            HOST_COMPILER ?= $(QNX_HOST)/usr/bin/q++
+        else ifeq ($(TARGET_OS), android)
+            HOST_COMPILER ?= aarch64-linux-android-clang++
+        endif
+    else ifeq ($(TARGET_ARCH),sbsa)
+        HOST_COMPILER ?= aarch64-linux-gnu-g++
+    else ifeq ($(TARGET_ARCH),ppc64le)
+        HOST_COMPILER ?= powerpc64le-linux-gnu-g++
+    endif
+endif
+HOST_COMPILER ?= g++
+NVCC          := $(CUDA_PATH)/bin/nvcc -ccbin $(HOST_COMPILER)
+
+# internal flags
+NVCCFLAGS   := -m${TARGET_SIZE}
+CCFLAGS     :=
+LDFLAGS     :=
+
+# build flags
+ifeq ($(TARGET_OS),darwin)
+    LDFLAGS += -rpath $(CUDA_PATH)/lib
+    CCFLAGS += -arch $(HOST_ARCH)
+else ifeq ($(HOST_ARCH)-$(TARGET_ARCH)-$(TARGET_OS),x86_64-armv7l-linux)
+    LDFLAGS += --dynamic-linker=/lib/ld-linux-armhf.so.3
+    CCFLAGS += -mfloat-abi=hard
+else ifeq ($(TARGET_OS),android)
+    LDFLAGS += -pie
+    CCFLAGS += -fpie -fpic -fexceptions
+endif
+
+ifneq ($(TARGET_ARCH),$(HOST_ARCH))
+    ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-linux)
+        ifneq ($(TARGET_FS),)
+            GCCVERSIONLTEQ46 := $(shell expr `$(HOST_COMPILER) -dumpversion` \<= 4.6)
+            ifeq ($(GCCVERSIONLTEQ46),1)
+                CCFLAGS += --sysroot=$(TARGET_FS)
+            endif
+            LDFLAGS += --sysroot=$(TARGET_FS)
+            LDFLAGS += -rpath-link=$(TARGET_FS)/lib
+            LDFLAGS += -rpath-link=$(TARGET_FS)/usr/lib
+            LDFLAGS += -rpath-link=$(TARGET_FS)/usr/lib/arm-linux-gnueabihf
+        endif
+    endif
+    ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-linux)
+        ifneq ($(TARGET_FS),)
+            GCCVERSIONLTEQ46 := $(shell expr `$(HOST_COMPILER) -dumpversion` \<= 4.6)
+            ifeq ($(GCCVERSIONLTEQ46),1)
+                CCFLAGS += --sysroot=$(TARGET_FS)
+            endif
+            LDFLAGS += --sysroot=$(TARGET_FS)
+            LDFLAGS += -rpath-link=$(TARGET_FS)/lib -L$(TARGET_FS)/lib
+            LDFLAGS += -rpath-link=$(TARGET_FS)/lib/aarch64-linux-gnu -L$(TARGET_FS)/lib/aarch64-linux-gnu
+            LDFLAGS += -rpath-link=$(TARGET_FS)/usr/lib -L$(TARGET_FS)/usr/lib
+            LDFLAGS += -rpath-link=$(TARGET_FS)/usr/lib/aarch64-linux-gnu -L$(TARGET_FS)/usr/lib/aarch64-linux-gnu
+            LDFLAGS += --unresolved-symbols=ignore-in-shared-libs
+            CCFLAGS += -isystem=$(TARGET_FS)/usr/include -I$(TARGET_FS)/usr/include -I$(TARGET_FS)/usr/include/libdrm
+            CCFLAGS += -isystem=$(TARGET_FS)/usr/include/aarch64-linux-gnu -I$(TARGET_FS)/usr/include/aarch64-linux-gnu
+        endif
+    endif
+    ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-qnx)
+        NVCCFLAGS += -D_QNX_SOURCE
+        NVCCFLAGS += --qpp-config 8.3.0,gcc_ntoaarch64le
+        CCFLAGS += -DWIN_INTERFACE_CUSTOM -I/usr/include/aarch64-qnx-gnu
+        LDFLAGS += -lsocket
+        LDFLAGS += -L/usr/lib/aarch64-qnx-gnu
+        CCFLAGS += "-Wl\,-rpath-link\,/usr/lib/aarch64-qnx-gnu"
+        ifdef TARGET_OVERRIDE
+            LDFLAGS += -lslog2
+        endif
+
+        ifneq ($(TARGET_FS),)
+            LDFLAGS += -L$(TARGET_FS)/usr/lib
+            CCFLAGS += "-Wl\,-rpath-link\,$(TARGET_FS)/usr/lib"
+            LDFLAGS += -L$(TARGET_FS)/usr/libnvidia
+            CCFLAGS += "-Wl\,-rpath-link\,$(TARGET_FS)/usr/libnvidia"
+            CCFLAGS += -I$(TARGET_FS)/../include
+        endif
+    endif
+endif
+
+ifdef TARGET_OVERRIDE # cuda toolkit targets override
+    NVCCFLAGS += -target-dir $(TARGET_OVERRIDE)
+endif
+
+# Install directory of different arch
+CUDA_INSTALL_TARGET_DIR :=
+ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-linux)
+    CUDA_INSTALL_TARGET_DIR = targets/armv7-linux-gnueabihf/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-linux)
+    CUDA_INSTALL_TARGET_DIR = targets/aarch64-linux/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),sbsa-linux)
+    CUDA_INSTALL_TARGET_DIR = targets/sbsa-linux/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-android)
+    CUDA_INSTALL_TARGET_DIR = targets/armv7-linux-androideabi/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-android)
+    CUDA_INSTALL_TARGET_DIR = targets/aarch64-linux-androideabi/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-qnx)
+    CUDA_INSTALL_TARGET_DIR = targets/ARMv7-linux-QNX/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-qnx)
+    CUDA_INSTALL_TARGET_DIR = targets/aarch64-qnx/
+else ifeq ($(TARGET_ARCH),ppc64le)
+    CUDA_INSTALL_TARGET_DIR = targets/ppc64le-linux/
+endif
+
+# Debug build flags
+ifeq ($(dbg),1)
+      NVCCFLAGS += -g -G
+      BUILD_TYPE := debug
+else
+      BUILD_TYPE := release
+endif
+
+ALL_CCFLAGS :=
+ALL_CCFLAGS += $(NVCCFLAGS)
+ALL_CCFLAGS += $(EXTRA_NVCCFLAGS)
+ALL_CCFLAGS += $(addprefix -Xcompiler ,$(CCFLAGS))
+ALL_CCFLAGS += $(addprefix -Xcompiler ,$(EXTRA_CCFLAGS))
+
+SAMPLE_ENABLED := 1
+
+# This sample is not supported on Mac OSX
+ifeq ($(TARGET_OS),darwin)
+  $(info >>> WARNING - simpleVulkan 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 - simpleVulkan is not supported on ARMv7 - waiving sample <<<)
+  SAMPLE_ENABLED := 0
+endif
+
+# This sample is not supported on QNX
+ifeq ($(TARGET_OS),qnx)
+  $(info >>> WARNING - simpleVulkan 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
+
+ALL_CCFLAGS += --std=c++11 --threads 0
+
+ifeq ($(SAMPLE_ENABLED),0)
+EXEC ?= @echo "[@]"
+endif
+
+################################################################################
+
+# Target rules
+all: build
+
+build: simpleVulkan
+
+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
+
+SineWaveSimulation.o:SineWaveSimulation.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 $<
+
+simpleVulkan: SineWaveSimulation.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) ./simpleVulkan
+
+testrun: build
+
+clean:
+	rm -f simpleVulkan SineWaveSimulation.o VulkanBaseApp.o main.o
+	rm -rf ../../../bin/$(TARGET_ARCH)/$(TARGET_OS)/$(BUILD_TYPE)/simpleVulkan
+
+clobber: clean
--- a/Samples/5_Domain_Specific/simpleVulkan/NsightEclipse.xml
+++ b/Samples/5_Domain_Specific/simpleVulkan/NsightEclipse.xml
@@ -0,0 +1,98 @@
+<?xml version="1.0" encoding="UTF-8"?> 
+<!DOCTYPE entry SYSTEM "SamplesInfo.dtd">
+<entry>
+  <name>simpleVulkan</name>
+  <cflags>
+    <flag>--std=c++11</flag>
+  </cflags>
+  <cuda_api_list>
+    <toolkit>cudaTimelineSemaphore</toolkit>
+    <toolkit>cudaSignalExternalSemaphoresAsync</toolkit>
+    <toolkit>cudaOccupancyMaxActiveBlocksPerMultiprocessor</toolkit>
+    <toolkit>cudaGetDeviceCount</toolkit>
+    <toolkit>cudaImportExternalSemaphore</toolkit>
+    <toolkit>cudaVertMem</toolkit>
+    <toolkit>cudaImportExternalMemory</toolkit>
+    <toolkit>cudaDestroyExternalMemory</toolkit>
+    <toolkit>cudaExternalMemoryGetMappedBuffer</toolkit>
+    <toolkit>cudaSignalSemaphore</toolkit>
+    <toolkit>cudaStreamCreateWithFlags</toolkit>
+    <toolkit>cudaWaitSemaphore</toolkit>
+    <toolkit>cudaHeightMap</toolkit>
+    <toolkit>cudaDestroyExternalSemaphore</toolkit>
+    <toolkit>cudaSetDevice</toolkit>
+    <toolkit>cudaWaitExternalSemaphoresAsync</toolkit>
+    <toolkit>cudaStreamSynchronize</toolkit>
+    <toolkit>cudaGetDeviceProperties</toolkit>
+  </cuda_api_list>
+  <description><![CDATA[This sample demonstrates Vulkan CUDA Interop. CUDA imports the Vulkan vertex buffer and operates on it to create sinewave, 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>sinewave.vert</file>
+    <file>sinewave.frag</file>
+  </files>
+  <includepaths>
+    <path>./</path>
+    <path>../</path>
+    <path>../../../Common</path>
+  </includepaths>
+  <keyconcepts>
+    <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>sine-wave</keyword>
+    <keyword>Vulkan</keyword>
+  </keywords>
+  <libraries>
+  </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>
+  <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 Sinewave</title>
+  <type>exe</type>
+</entry>
--- a/Samples/5_Domain_Specific/simpleVulkan/README.md
+++ b/Samples/5_Domain_Specific/simpleVulkan/README.md
@@ -0,0 +1,74 @@
+# simpleVulkan - Vulkan CUDA Interop Sinewave
+
+## Description
+
+This sample demonstrates Vulkan CUDA Interop. CUDA imports the Vulkan vertex buffer and operates on it to create sinewave, 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
+
+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 Runtime API](http://docs.nvidia.com/cuda/cuda-runtime-api/index.html)
+cudaTimelineSemaphore, cudaSignalExternalSemaphoresAsync, cudaOccupancyMaxActiveBlocksPerMultiprocessor, cudaGetDeviceCount, cudaImportExternalSemaphore, cudaVertMem, cudaImportExternalMemory, cudaDestroyExternalMemory, cudaExternalMemoryGetMappedBuffer, cudaSignalSemaphore, cudaStreamCreateWithFlags, cudaWaitSemaphore, cudaHeightMap, cudaDestroyExternalSemaphore, cudaSetDevice, cudaWaitExternalSemaphoresAsync, cudaStreamSynchronize, cudaGetDeviceProperties
+
+## 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)
+
--- a/Samples/5_Domain_Specific/simpleVulkan/SineWaveSimulation.cu
+++ b/Samples/5_Domain_Specific/simpleVulkan/SineWaveSimulation.cu
@@ -0,0 +1,134 @@
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "SineWaveSimulation.h"
+#include <algorithm>
+#include <helper_cuda.h>
+
+__global__ void sinewave(float *heightMap, unsigned int width,
+                         unsigned int height, float time) {
+  const float freq = 4.0f;
+  const size_t stride = gridDim.x * blockDim.x;
+
+  // Iterate through the entire array in a way that is
+  // independent of the grid configuration
+  for (size_t tid = blockIdx.x * blockDim.x + threadIdx.x; tid < width * height;
+       tid += stride) {
+    // Calculate the x, y coordinates
+    const size_t y = tid / width;
+    const size_t x = tid - y * width;
+    // Normalize x, y to [0,1]
+    const float u = ((2.0f * x) / width) - 1.0f;
+    const float v = ((2.0f * y) / height) - 1.0f;
+    // Calculate the new height value
+    const float w = 0.5f * sinf(u * freq + time) * cosf(v * freq + time);
+    // Store this new height value
+    heightMap[tid] = w;
+  }
+}
+
+SineWaveSimulation::SineWaveSimulation(size_t width, size_t height)
+    : m_heightMap(nullptr), m_width(width), m_height(height) {}
+
+void SineWaveSimulation::initCudaLaunchConfig(int device) {
+  cudaDeviceProp prop = {};
+  checkCudaErrors(cudaSetDevice(device));
+  checkCudaErrors(cudaGetDeviceProperties(&prop, device));
+
+  // We don't need large block sizes, since there's not much inter-thread
+  // communication
+  m_threads = prop.warpSize;
+
+  // Use the occupancy calculator and fill the gpu as best as we can
+  checkCudaErrors(cudaOccupancyMaxActiveBlocksPerMultiprocessor(
+      &m_blocks, sinewave, prop.warpSize, 0));
+  m_blocks *= prop.multiProcessorCount;
+
+  // Go ahead and the clamp the blocks to the minimum needed for this
+  // height/width
+  m_blocks = std::min(m_blocks,
+                      (int)((m_width * m_height + m_threads - 1) / m_threads));
+}
+
+int SineWaveSimulation::initCuda(uint8_t *vkDeviceUUID, size_t UUID_SIZE) {
+  int current_device = 0;
+  int device_count = 0;
+  int devices_prohibited = 0;
+
+  cudaDeviceProp deviceProp;
+  checkCudaErrors(cudaGetDeviceCount(&device_count));
+
+  if (device_count == 0) {
+    fprintf(stderr, "CUDA error: no devices supporting CUDA.\n");
+    exit(EXIT_FAILURE);
+  }
+
+  // Find the GPU which is selected by Vulkan
+  while (current_device < device_count) {
+    cudaGetDeviceProperties(&deviceProp, current_device);
+
+    if ((deviceProp.computeMode != cudaComputeModeProhibited)) {
+      // Compare the cuda device UUID with vulkan UUID
+      int ret = memcmp((void *)&deviceProp.uuid, vkDeviceUUID, UUID_SIZE);
+      if (ret == 0) {
+        checkCudaErrors(cudaSetDevice(current_device));
+        checkCudaErrors(cudaGetDeviceProperties(&deviceProp, current_device));
+        printf("GPU Device %d: \"%s\" with compute capability %d.%d\n\n",
+               current_device, deviceProp.name, deviceProp.major,
+               deviceProp.minor);
+
+        return current_device;
+      }
+
+    } else {
+      devices_prohibited++;
+    }
+
+    current_device++;
+  }
+
+  if (devices_prohibited == device_count) {
+    fprintf(stderr,
+            "CUDA error:"
+            " No Vulkan-CUDA Interop capable GPU found.\n");
+    exit(EXIT_FAILURE);
+  }
+
+  return -1;
+}
+
+SineWaveSimulation::~SineWaveSimulation() { m_heightMap = NULL; }
+
+void SineWaveSimulation::initSimulation(float *heights) {
+  m_heightMap = heights;
+}
+
+void SineWaveSimulation::stepSimulation(float time, cudaStream_t stream) {
+  sinewave<<<m_blocks, m_threads, 0, stream>>>(m_heightMap, m_width, m_height,
+                                               time);
+  getLastCudaError("Failed to launch CUDA simulation");
+}
--- a/Samples/5_Domain_Specific/simpleVulkan/SineWaveSimulation.h
+++ b/Samples/5_Domain_Specific/simpleVulkan/SineWaveSimulation.h
@@ -0,0 +1,54 @@
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+#ifndef __SINESIM_H__
+#define __SINESIM_H__
+
+#include <vector>
+#include <cuda_runtime_api.h>
+#include <stdint.h>
+#include "linmath.h"
+
+class SineWaveSimulation {
+  float *m_heightMap;
+  size_t m_width, m_height;
+  int m_blocks, m_threads;
+
+ public:
+  SineWaveSimulation(size_t width, size_t height);
+  ~SineWaveSimulation();
+  void initSimulation(float *heightMap);
+  void stepSimulation(float time, cudaStream_t stream = 0);
+  void initCudaLaunchConfig(int device);
+  int initCuda(uint8_t *vkDeviceUUID, size_t UUID_SIZE);
+
+  size_t getWidth() const { return m_width; }
+  size_t getHeight() const { return m_height; }
+};
+
+#endif  // __SINESIM_H__
--- a/Samples/5_Domain_Specific/simpleVulkan/VulkanBaseApp.cpp
+++ b/Samples/5_Domain_Specific/simpleVulkan/VulkanBaseApp.cpp
--- a/Samples/5_Domain_Specific/simpleVulkan/VulkanBaseApp.h
+++ b/Samples/5_Domain_Specific/simpleVulkan/VulkanBaseApp.h
@@ -0,0 +1,164 @@
+/* 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 */
+
+/* remove _VK_TIMELINE_SEMAPHORE to use binary semaphores */
+// use vulkan timeline semaphore
+#define _VK_TIMELINE_SEMAPHORE
+
+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);
+  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;
+  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;
+  VkSemaphore m_vkPresentationSemaphore;
+  VkSemaphore m_vkTimelineSemaphore;
+  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;
+  uint8_t m_vkDeviceUUID[VK_UUID_SIZE];
+
+  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);
+  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__ */
--- a/Samples/5_Domain_Specific/simpleVulkan/findvulkan.mk
+++ b/Samples/5_Domain_Specific/simpleVulkan/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
+
--- a/Samples/5_Domain_Specific/simpleVulkan/frag.spv
+++ b/Samples/5_Domain_Specific/simpleVulkan/frag.spv
--- a/Samples/5_Domain_Specific/simpleVulkan/linmath.h
+++ b/Samples/5_Domain_Specific/simpleVulkan/linmath.h
@@ -0,0 +1,502 @@
+/*
+ * Copyright (c) 2015-2016 The Khronos Group Inc.
+ * Copyright (c) 2015-2016 Valve Corporation
+ * Copyright (c) 2015-2016 LunarG, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Relicensed from the WTFPL (http://www.wtfpl.net/faq/).
+ */
+
+#ifndef LINMATH_H
+#define LINMATH_H
+
+#define _USE_MATH_DEFINES
+#include <math.h>
+
+// Converts degrees to radians.
+#define degreesToRadians(angleDegrees) (angleDegrees * M_PI / 180.0)
+
+// Converts radians to degrees.
+#define radiansToDegrees(angleRadians) (angleRadians * 180.0 / M_PI)
+
+typedef float vec3[3];
+static inline void vec3_add(vec3 r, vec3 const a, vec3 const b) {
+    int i;
+    for (i = 0; i < 3; ++i) r[i] = a[i] + b[i];
+}
+static inline void vec3_sub(vec3 r, vec3 const a, vec3 const b) {
+    int i;
+    for (i = 0; i < 3; ++i) r[i] = a[i] - b[i];
+}
+static inline void vec3_scale(vec3 r, vec3 const v, float const s) {
+    int i;
+    for (i = 0; i < 3; ++i) r[i] = v[i] * s;
+}
+static inline float vec3_mul_inner(vec3 const a, vec3 const b) {
+    float p = 0.f;
+    int i;
+    for (i = 0; i < 3; ++i) p += b[i] * a[i];
+    return p;
+}
+static inline void vec3_mul_cross(vec3 r, vec3 const a, vec3 const b) {
+    r[0] = a[1] * b[2] - a[2] * b[1];
+    r[1] = a[2] * b[0] - a[0] * b[2];
+    r[2] = a[0] * b[1] - a[1] * b[0];
+}
+static inline float vec3_len(vec3 const v) { return sqrtf(vec3_mul_inner(v, v)); }
+static inline void vec3_norm(vec3 r, vec3 const v) {
+    float k = 1.f / vec3_len(v);
+    vec3_scale(r, v, k);
+}
+static inline void vec3_reflect(vec3 r, vec3 const v, vec3 const n) {
+    float p = 2.f * vec3_mul_inner(v, n);
+    int i;
+    for (i = 0; i < 3; ++i) r[i] = v[i] - p * n[i];
+}
+
+typedef float vec4[4];
+static inline void vec4_add(vec4 r, vec4 const a, vec4 const b) {
+    int i;
+    for (i = 0; i < 4; ++i) r[i] = a[i] + b[i];
+}
+static inline void vec4_sub(vec4 r, vec4 const a, vec4 const b) {
+    int i;
+    for (i = 0; i < 4; ++i) r[i] = a[i] - b[i];
+}
+static inline void vec4_scale(vec4 r, vec4 v, float s) {
+    int i;
+    for (i = 0; i < 4; ++i) r[i] = v[i] * s;
+}
+static inline float vec4_mul_inner(vec4 a, vec4 b) {
+    float p = 0.f;
+    int i;
+    for (i = 0; i < 4; ++i) p += b[i] * a[i];
+    return p;
+}
+static inline void vec4_mul_cross(vec4 r, vec4 a, vec4 b) {
+    r[0] = a[1] * b[2] - a[2] * b[1];
+    r[1] = a[2] * b[0] - a[0] * b[2];
+    r[2] = a[0] * b[1] - a[1] * b[0];
+    r[3] = 1.f;
+}
+static inline float vec4_len(vec4 v) { return sqrtf(vec4_mul_inner(v, v)); }
+static inline void vec4_norm(vec4 r, vec4 v) {
+    float k = 1.f / vec4_len(v);
+    vec4_scale(r, v, k);
+}
+static inline void vec4_reflect(vec4 r, vec4 v, vec4 n) {
+    float p = 2.f * vec4_mul_inner(v, n);
+    int i;
+    for (i = 0; i < 4; ++i) r[i] = v[i] - p * n[i];
+}
+
+typedef vec4 mat4x4[4];
+static inline void mat4x4_identity(mat4x4 M) {
+    int i, j;
+    for (i = 0; i < 4; ++i)
+        for (j = 0; j < 4; ++j) M[i][j] = i == j ? 1.f : 0.f;
+}
+static inline void mat4x4_dup(mat4x4 M, mat4x4 N) {
+    int i, j;
+    for (i = 0; i < 4; ++i)
+        for (j = 0; j < 4; ++j) M[i][j] = N[i][j];
+}
+static inline void mat4x4_row(vec4 r, mat4x4 M, int i) {
+    int k;
+    for (k = 0; k < 4; ++k) r[k] = M[k][i];
+}
+static inline void mat4x4_col(vec4 r, mat4x4 M, int i) {
+    int k;
+    for (k = 0; k < 4; ++k) r[k] = M[i][k];
+}
+static inline void mat4x4_transpose(mat4x4 M, mat4x4 N) {
+    int i, j;
+    for (j = 0; j < 4; ++j)
+        for (i = 0; i < 4; ++i) M[i][j] = N[j][i];
+}
+static inline void mat4x4_add(mat4x4 M, mat4x4 a, mat4x4 b) {
+    int i;
+    for (i = 0; i < 4; ++i) vec4_add(M[i], a[i], b[i]);
+}
+static inline void mat4x4_sub(mat4x4 M, mat4x4 a, mat4x4 b) {
+    int i;
+    for (i = 0; i < 4; ++i) vec4_sub(M[i], a[i], b[i]);
+}
+static inline void mat4x4_scale(mat4x4 M, mat4x4 a, float k) {
+    int i;
+    for (i = 0; i < 4; ++i) vec4_scale(M[i], a[i], k);
+}
+static inline void mat4x4_scale_aniso(mat4x4 M, mat4x4 a, float x, float y, float z) {
+    int i;
+    vec4_scale(M[0], a[0], x);
+    vec4_scale(M[1], a[1], y);
+    vec4_scale(M[2], a[2], z);
+    for (i = 0; i < 4; ++i) {
+        M[3][i] = a[3][i];
+    }
+}
+static inline void mat4x4_mul(mat4x4 M, mat4x4 a, mat4x4 b) {
+    int k, r, c;
+    for (c = 0; c < 4; ++c)
+        for (r = 0; r < 4; ++r) {
+            M[c][r] = 0.f;
+            for (k = 0; k < 4; ++k) M[c][r] += a[k][r] * b[c][k];
+        }
+}
+static inline void mat4x4_mul_vec4(vec4 r, mat4x4 M, vec4 v) {
+    int i, j;
+    for (j = 0; j < 4; ++j) {
+        r[j] = 0.f;
+        for (i = 0; i < 4; ++i) r[j] += M[i][j] * v[i];
+    }
+}
+static inline void mat4x4_translate(mat4x4 T, float x, float y, float z) {
+    mat4x4_identity(T);
+    T[3][0] = x;
+    T[3][1] = y;
+    T[3][2] = z;
+}
+static inline void mat4x4_translate_in_place(mat4x4 M, float x, float y, float z) {
+    vec4 t = {x, y, z, 0};
+    vec4 r;
+    int i;
+    for (i = 0; i < 4; ++i) {
+        mat4x4_row(r, M, i);
+        M[3][i] += vec4_mul_inner(r, t);
+    }
+}
+static inline void mat4x4_from_vec3_mul_outer(mat4x4 M, vec3 a, vec3 b) {
+    int i, j;
+    for (i = 0; i < 4; ++i)
+        for (j = 0; j < 4; ++j) M[i][j] = i < 3 && j < 3 ? a[i] * b[j] : 0.f;
+}
+static inline void mat4x4_rotate(mat4x4 R, mat4x4 M, float x, float y, float z, float angle) {
+    float s = sinf(angle);
+    float c = cosf(angle);
+    vec3 u = {x, y, z};
+
+    if (vec3_len(u) > 1e-4) {
+        vec3_norm(u, u);
+        mat4x4 T;
+        mat4x4_from_vec3_mul_outer(T, u, u);
+
+        mat4x4 S = {{0, u[2], -u[1], 0}, {-u[2], 0, u[0], 0}, {u[1], -u[0], 0, 0}, {0, 0, 0, 0}};
+        mat4x4_scale(S, S, s);
+
+        mat4x4 C;
+        mat4x4_identity(C);
+        mat4x4_sub(C, C, T);
+
+        mat4x4_scale(C, C, c);
+
+        mat4x4_add(T, T, C);
+        mat4x4_add(T, T, S);
+
+        T[3][3] = 1.;
+        mat4x4_mul(R, M, T);
+    } else {
+        mat4x4_dup(R, M);
+    }
+}
+static inline void mat4x4_rotate_X(mat4x4 Q, mat4x4 M, float angle) {
+    float s = sinf(angle);
+    float c = cosf(angle);
+    mat4x4 R = {{1.f, 0.f, 0.f, 0.f}, {0.f, c, s, 0.f}, {0.f, -s, c, 0.f}, {0.f, 0.f, 0.f, 1.f}};
+    mat4x4_mul(Q, M, R);
+}
+static inline void mat4x4_rotate_Y(mat4x4 Q, mat4x4 M, float angle) {
+    float s = sinf(angle);
+    float c = cosf(angle);
+    mat4x4 R = {{c, 0.f, s, 0.f}, {0.f, 1.f, 0.f, 0.f}, {-s, 0.f, c, 0.f}, {0.f, 0.f, 0.f, 1.f}};
+    mat4x4_mul(Q, M, R);
+}
+static inline void mat4x4_rotate_Z(mat4x4 Q, mat4x4 M, float angle) {
+    float s = sinf(angle);
+    float c = cosf(angle);
+    mat4x4 R = {{c, s, 0.f, 0.f}, {-s, c, 0.f, 0.f}, {0.f, 0.f, 1.f, 0.f}, {0.f, 0.f, 0.f, 1.f}};
+    mat4x4_mul(Q, M, R);
+}
+static inline void mat4x4_invert(mat4x4 T, mat4x4 M) {
+    float s[6];
+    float c[6];
+    s[0] = M[0][0] * M[1][1] - M[1][0] * M[0][1];
+    s[1] = M[0][0] * M[1][2] - M[1][0] * M[0][2];
+    s[2] = M[0][0] * M[1][3] - M[1][0] * M[0][3];
+    s[3] = M[0][1] * M[1][2] - M[1][1] * M[0][2];
+    s[4] = M[0][1] * M[1][3] - M[1][1] * M[0][3];
+    s[5] = M[0][2] * M[1][3] - M[1][2] * M[0][3];
+
+    c[0] = M[2][0] * M[3][1] - M[3][0] * M[2][1];
+    c[1] = M[2][0] * M[3][2] - M[3][0] * M[2][2];
+    c[2] = M[2][0] * M[3][3] - M[3][0] * M[2][3];
+    c[3] = M[2][1] * M[3][2] - M[3][1] * M[2][2];
+    c[4] = M[2][1] * M[3][3] - M[3][1] * M[2][3];
+    c[5] = M[2][2] * M[3][3] - M[3][2] * M[2][3];
+
+    /* Assumes it is invertible */
+    float idet = 1.0f / (s[0] * c[5] - s[1] * c[4] + s[2] * c[3] + s[3] * c[2] - s[4] * c[1] + s[5] * c[0]);
+
+    T[0][0] = (M[1][1] * c[5] - M[1][2] * c[4] + M[1][3] * c[3]) * idet;
+    T[0][1] = (-M[0][1] * c[5] + M[0][2] * c[4] - M[0][3] * c[3]) * idet;
+    T[0][2] = (M[3][1] * s[5] - M[3][2] * s[4] + M[3][3] * s[3]) * idet;
+    T[0][3] = (-M[2][1] * s[5] + M[2][2] * s[4] - M[2][3] * s[3]) * idet;
+
+    T[1][0] = (-M[1][0] * c[5] + M[1][2] * c[2] - M[1][3] * c[1]) * idet;
+    T[1][1] = (M[0][0] * c[5] - M[0][2] * c[2] + M[0][3] * c[1]) * idet;
+    T[1][2] = (-M[3][0] * s[5] + M[3][2] * s[2] - M[3][3] * s[1]) * idet;
+    T[1][3] = (M[2][0] * s[5] - M[2][2] * s[2] + M[2][3] * s[1]) * idet;
+
+    T[2][0] = (M[1][0] * c[4] - M[1][1] * c[2] + M[1][3] * c[0]) * idet;
+    T[2][1] = (-M[0][0] * c[4] + M[0][1] * c[2] - M[0][3] * c[0]) * idet;
+    T[2][2] = (M[3][0] * s[4] - M[3][1] * s[2] + M[3][3] * s[0]) * idet;
+    T[2][3] = (-M[2][0] * s[4] + M[2][1] * s[2] - M[2][3] * s[0]) * idet;
+
+    T[3][0] = (-M[1][0] * c[3] + M[1][1] * c[1] - M[1][2] * c[0]) * idet;
+    T[3][1] = (M[0][0] * c[3] - M[0][1] * c[1] + M[0][2] * c[0]) * idet;
+    T[3][2] = (-M[3][0] * s[3] + M[3][1] * s[1] - M[3][2] * s[0]) * idet;
+    T[3][3] = (M[2][0] * s[3] - M[2][1] * s[1] + M[2][2] * s[0]) * idet;
+}
+static inline void mat4x4_orthonormalize(mat4x4 R, mat4x4 M) {
+    mat4x4_dup(R, M);
+    float s = 1.;
+    vec3 h;
+
+    vec3_norm(R[2], R[2]);
+
+    s = vec3_mul_inner(R[1], R[2]);
+    vec3_scale(h, R[2], s);
+    vec3_sub(R[1], R[1], h);
+    vec3_norm(R[2], R[2]);
+
+    s = vec3_mul_inner(R[1], R[2]);
+    vec3_scale(h, R[2], s);
+    vec3_sub(R[1], R[1], h);
+    vec3_norm(R[1], R[1]);
+
+    s = vec3_mul_inner(R[0], R[1]);
+    vec3_scale(h, R[1], s);
+    vec3_sub(R[0], R[0], h);
+    vec3_norm(R[0], R[0]);
+}
+
+static inline void mat4x4_frustum(mat4x4 M, float l, float r, float b, float t, float n, float f) {
+    M[0][0] = 2.f * n / (r - l);
+    M[0][1] = M[0][2] = M[0][3] = 0.f;
+
+    M[1][1] = 2.f * n / (t - b);
+    M[1][0] = M[1][2] = M[1][3] = 0.f;
+
+    M[2][0] = (r + l) / (r - l);
+    M[2][1] = (t + b) / (t - b);
+    M[2][2] = -(f + n) / (f - n);
+    M[2][3] = -1.f;
+
+    M[3][2] = -2.f * (f * n) / (f - n);
+    M[3][0] = M[3][1] = M[3][3] = 0.f;
+}
+static inline void mat4x4_ortho(mat4x4 M, float l, float r, float b, float t, float n, float f) {
+    M[0][0] = 2.f / (r - l);
+    M[0][1] = M[0][2] = M[0][3] = 0.f;
+
+    M[1][1] = 2.f / (t - b);
+    M[1][0] = M[1][2] = M[1][3] = 0.f;
+
+    M[2][2] = -2.f / (f - n);
+    M[2][0] = M[2][1] = M[2][3] = 0.f;
+
+    M[3][0] = -(r + l) / (r - l);
+    M[3][1] = -(t + b) / (t - b);
+    M[3][2] = -(f + n) / (f - n);
+    M[3][3] = 1.f;
+}
+static inline void mat4x4_perspective(mat4x4 m, float y_fov, float aspect, float n, float f) {
+    /* NOTE: Degrees are an unhandy unit to work with.
+     * linmath.h uses radians for everything! */
+    float const a = (float)(1.f / tan(y_fov / 2.f));
+
+    m[0][0] = a / aspect;
+    m[0][1] = 0.f;
+    m[0][2] = 0.f;
+    m[0][3] = 0.f;
+
+    m[1][0] = 0.f;
+    m[1][1] = a;
+    m[1][2] = 0.f;
+    m[1][3] = 0.f;
+
+    m[2][0] = 0.f;
+    m[2][1] = 0.f;
+    m[2][2] = -((f + n) / (f - n));
+    m[2][3] = -1.f;
+
+    m[3][0] = 0.f;
+    m[3][1] = 0.f;
+    m[3][2] = -((2.f * f * n) / (f - n));
+    m[3][3] = 0.f;
+}
+static inline void mat4x4_look_at(mat4x4 m, vec3 eye, vec3 center, vec3 up) {
+    /* Adapted from Android's OpenGL Matrix.java.                        */
+    /* See the OpenGL GLUT documentation for gluLookAt for a description */
+    /* of the algorithm. We implement it in a straightforward way:       */
+
+    /* TODO: The negation of of can be spared by swapping the order of
+     *       operands in the following cross products in the right way. */
+    vec3 f;
+    vec3_sub(f, center, eye);
+    vec3_norm(f, f);
+
+    vec3 s;
+    vec3_mul_cross(s, f, up);
+    vec3_norm(s, s);
+
+    vec3 t;
+    vec3_mul_cross(t, s, f);
+
+    m[0][0] = s[0];
+    m[0][1] = t[0];
+    m[0][2] = -f[0];
+    m[0][3] = 0.f;
+
+    m[1][0] = s[1];
+    m[1][1] = t[1];
+    m[1][2] = -f[1];
+    m[1][3] = 0.f;
+
+    m[2][0] = s[2];
+    m[2][1] = t[2];
+    m[2][2] = -f[2];
+    m[2][3] = 0.f;
+
+    m[3][0] = 0.f;
+    m[3][1] = 0.f;
+    m[3][2] = 0.f;
+    m[3][3] = 1.f;
+
+    mat4x4_translate_in_place(m, -eye[0], -eye[1], -eye[2]);
+}
+
+typedef float quat[4];
+static inline void quat_identity(quat q) {
+    q[0] = q[1] = q[2] = 0.f;
+    q[3] = 1.f;
+}
+static inline void quat_add(quat r, quat a, quat b) {
+    int i;
+    for (i = 0; i < 4; ++i) r[i] = a[i] + b[i];
+}
+static inline void quat_sub(quat r, quat a, quat b) {
+    int i;
+    for (i = 0; i < 4; ++i) r[i] = a[i] - b[i];
+}
+static inline void quat_mul(quat r, quat p, quat q) {
+    vec3 w;
+    vec3_mul_cross(r, p, q);
+    vec3_scale(w, p, q[3]);
+    vec3_add(r, r, w);
+    vec3_scale(w, q, p[3]);
+    vec3_add(r, r, w);
+    r[3] = p[3] * q[3] - vec3_mul_inner(p, q);
+}
+static inline void quat_scale(quat r, quat v, float s) {
+    int i;
+    for (i = 0; i < 4; ++i) r[i] = v[i] * s;
+}
+static inline float quat_inner_product(quat a, quat b) {
+    float p = 0.f;
+    int i;
+    for (i = 0; i < 4; ++i) p += b[i] * a[i];
+    return p;
+}
+static inline void quat_conj(quat r, quat q) {
+    int i;
+    for (i = 0; i < 3; ++i) r[i] = -q[i];
+    r[3] = q[3];
+}
+#define quat_norm vec4_norm
+static inline void quat_mul_vec3(vec3 r, quat q, vec3 v) {
+    quat v_ = {v[0], v[1], v[2], 0.f};
+
+    quat_conj(r, q);
+    quat_norm(r, r);
+    quat_mul(r, v_, r);
+    quat_mul(r, q, r);
+}
+static inline void mat4x4_from_quat(mat4x4 M, quat q) {
+    float a = q[3];
+    float b = q[0];
+    float c = q[1];
+    float d = q[2];
+    float a2 = a * a;
+    float b2 = b * b;
+    float c2 = c * c;
+    float d2 = d * d;
+
+    M[0][0] = a2 + b2 - c2 - d2;
+    M[0][1] = 2.f * (b * c + a * d);
+    M[0][2] = 2.f * (b * d - a * c);
+    M[0][3] = 0.f;
+
+    M[1][0] = 2 * (b * c - a * d);
+    M[1][1] = a2 - b2 + c2 - d2;
+    M[1][2] = 2.f * (c * d + a * b);
+    M[1][3] = 0.f;
+
+    M[2][0] = 2.f * (b * d + a * c);
+    M[2][1] = 2.f * (c * d - a * b);
+    M[2][2] = a2 - b2 - c2 + d2;
+    M[2][3] = 0.f;
+
+    M[3][0] = M[3][1] = M[3][2] = 0.f;
+    M[3][3] = 1.f;
+}
+
+static inline void mat4x4o_mul_quat(mat4x4 R, mat4x4 M, quat q) {
+    /*  XXX: The way this is written only works for othogonal matrices. */
+    /* TODO: Take care of non-orthogonal case. */
+    quat_mul_vec3(R[0], q, M[0]);
+    quat_mul_vec3(R[1], q, M[1]);
+    quat_mul_vec3(R[2], q, M[2]);
+
+    R[3][0] = R[3][1] = R[3][2] = 0.f;
+    R[3][3] = 1.f;
+}
+static inline void quat_from_mat4x4(quat q, mat4x4 M) {
+    float r = 0.f;
+    int i;
+
+    int perm[] = {0, 1, 2, 0, 1};
+    int *p = perm;
+
+    for (i = 0; i < 3; i++) {
+        float m = M[i][i];
+        if (m < r) continue;
+        m = r;
+        p = &perm[i];
+    }
+
+    r = sqrtf(1.f + M[p[0]][p[0]] - M[p[1]][p[1]] - M[p[2]][p[2]]);
+
+    if (r < 1e-6) {
+        q[0] = 1.f;
+        q[1] = q[2] = q[3] = 0.f;
+        return;
+    }
+
+    q[0] = r / 2.f;
+    q[1] = (M[p[0]][p[1]] - M[p[1]][p[0]]) / (2.f * r);
+    q[2] = (M[p[2]][p[0]] - M[p[0]][p[2]]) / (2.f * r);
+    q[3] = (M[p[2]][p[1]] - M[p[1]][p[2]]) / (2.f * r);
+}
+
+#endif
--- a/Samples/5_Domain_Specific/simpleVulkan/main.cpp
+++ b/Samples/5_Domain_Specific/simpleVulkan/main.cpp
@@ -0,0 +1,543 @@
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "VulkanBaseApp.h"
+
+#include <iostream>
+#include <iomanip>
+#include <chrono>
+#include <algorithm>
+#include "linmath.h"
+
+#include "SineWaveSimulation.h"
+
+#include <helper_cuda.h>
+
+typedef float vec2[2];
+std::string execution_path;
+
+#ifndef NDEBUG
+#define ENABLE_VALIDATION (false)
+#else
+#define ENABLE_VALIDATION (true)
+#endif
+
+class VulkanCudaSineWave : public VulkanBaseApp {
+  typedef struct UniformBufferObject_st {
+    mat4x4 modelViewProj;
+  } UniformBufferObject;
+
+  VkBuffer m_heightBuffer, m_xyBuffer, m_indexBuffer;
+  VkDeviceMemory m_heightMemory, m_xyMemory, m_indexMemory;
+  UniformBufferObject m_ubo;
+  VkSemaphore m_vkWaitSemaphore, m_vkSignalSemaphore;
+  SineWaveSimulation m_sim;
+  cudaStream_t m_stream;
+  cudaExternalSemaphore_t m_cudaWaitSemaphore, m_cudaSignalSemaphore,
+      m_cudaTimelineSemaphore;
+  cudaExternalMemory_t m_cudaVertMem;
+  float *m_cudaHeightMap;
+  using chrono_tp = std::chrono::time_point<std::chrono::high_resolution_clock>;
+  chrono_tp m_lastTime;
+  size_t m_lastFrame;
+
+ public:
+  VulkanCudaSineWave(size_t width, size_t height)
+      : VulkanBaseApp("vulkanCudaSineWave", ENABLE_VALIDATION),
+        m_heightBuffer(VK_NULL_HANDLE),
+        m_xyBuffer(VK_NULL_HANDLE),
+        m_indexBuffer(VK_NULL_HANDLE),
+        m_heightMemory(VK_NULL_HANDLE),
+        m_xyMemory(VK_NULL_HANDLE),
+        m_indexMemory(VK_NULL_HANDLE),
+        m_ubo(),
+        m_sim(width, height),
+        m_stream(0),
+        m_vkWaitSemaphore(VK_NULL_HANDLE),
+        m_vkSignalSemaphore(VK_NULL_HANDLE),
+        m_cudaWaitSemaphore(),
+        m_cudaSignalSemaphore(),
+        m_cudaTimelineSemaphore(),
+        m_cudaVertMem(),
+        m_cudaHeightMap(nullptr),
+        m_lastFrame(0) {
+    // Our index buffer can only index 32-bits of the vertex buffer
+    if ((width * height) > (1ULL << 32ULL)) {
+      throw std::runtime_error(
+          "Requested height and width is too large for this sample!");
+    }
+    // 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));
+  }
+  ~VulkanCudaSineWave() {
+    // Make sure there's no pending work before we start tearing down
+    checkCudaErrors(cudaStreamSynchronize(m_stream));
+
+#ifdef _VK_TIMELINE_SEMAPHORE
+    if (m_vkTimelineSemaphore != VK_NULL_HANDLE) {
+      checkCudaErrors(cudaDestroyExternalSemaphore(m_cudaTimelineSemaphore));
+      vkDestroySemaphore(m_device, m_vkTimelineSemaphore, nullptr);
+    }
+#endif /* _VK_TIMELINE_SEMAPHORE */
+
+    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_xyBuffer != VK_NULL_HANDLE) {
+      vkDestroyBuffer(m_device, m_xyBuffer, nullptr);
+    }
+    if (m_xyMemory != VK_NULL_HANDLE) {
+      vkFreeMemory(m_device, m_xyMemory, nullptr);
+    }
+
+    if (m_heightBuffer != VK_NULL_HANDLE) {
+      vkDestroyBuffer(m_device, m_heightBuffer, nullptr);
+    }
+    if (m_heightMemory != VK_NULL_HANDLE) {
+      vkFreeMemory(m_device, m_heightMemory, nullptr);
+    }
+    if (m_cudaHeightMap) {
+      checkCudaErrors(cudaDestroyExternalMemory(m_cudaVertMem));
+    }
+
+    if (m_indexBuffer != VK_NULL_HANDLE) {
+      vkDestroyBuffer(m_device, m_indexBuffer, nullptr);
+    }
+    if (m_indexMemory != VK_NULL_HANDLE) {
+      vkFreeMemory(m_device, m_indexMemory, nullptr);
+    }
+  }
+
+  void fillRenderingCommandBuffer(VkCommandBuffer &commandBuffer) {
+    VkBuffer vertexBuffers[] = {m_heightBuffer, m_xyBuffer};
+    VkDeviceSize offsets[] = {0, 0};
+    vkCmdBindVertexBuffers(commandBuffer, 0,
+                           sizeof(vertexBuffers) / sizeof(vertexBuffers[0]),
+                           vertexBuffers, offsets);
+    vkCmdBindIndexBuffer(commandBuffer, m_indexBuffer, 0, VK_INDEX_TYPE_UINT32);
+    vkCmdDrawIndexed(commandBuffer, (uint32_t)((m_sim.getWidth() - 1) *
+                                               (m_sim.getHeight() - 1) * 6),
+                     1, 0, 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() {
+    int cuda_device = -1;
+
+    // Select cuda device where vulkan is running.
+    cuda_device = m_sim.initCuda(m_vkDeviceUUID, VK_UUID_SIZE);
+    if (cuda_device == -1) {
+      printf("Error: No CUDA-Vulkan interop capable device found\n");
+      exit(EXIT_FAILURE);
+    }
+
+    m_sim.initCudaLaunchConfig(cuda_device);
+
+    // Create the cuda stream we'll be using
+    checkCudaErrors(
+        cudaStreamCreateWithFlags(&m_stream, cudaStreamNonBlocking));
+
+    const size_t nVerts = m_sim.getWidth() * m_sim.getHeight();
+    const size_t nInds = (m_sim.getWidth() - 1) * (m_sim.getHeight() - 1) * 6;
+
+    // Create the height map cuda will write to
+    createExternalBuffer(
+        nVerts * sizeof(float),
+        VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
+        VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, getDefaultMemHandleType(),
+        m_heightBuffer, m_heightMemory);
+
+    // Create the vertex buffer that will hold the xy coordinates for the grid
+    createBuffer(nVerts * sizeof(vec2), VK_BUFFER_USAGE_TRANSFER_DST_BIT |
+                                            VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
+                 VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, m_xyBuffer, m_xyMemory);
+
+    // Create the index buffer that references from both buffers above
+    createBuffer(
+        nInds * sizeof(uint32_t),
+        VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
+        VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, m_indexBuffer, m_indexMemory);
+
+    // Import the height map into cuda and retrieve a device pointer to use
+    importCudaExternalMemory((void **)&m_cudaHeightMap, m_cudaVertMem,
+                             m_heightMemory, nVerts * sizeof(*m_cudaHeightMap),
+                             getDefaultMemHandleType());
+    // Set the height map to use in the simulation
+    m_sim.initSimulation(m_cudaHeightMap);
+
+    {
+      // Set up the initial values for the vertex buffers with Vulkan
+      void *stagingBase;
+      VkBuffer stagingBuffer;
+      VkDeviceMemory stagingMemory;
+      VkDeviceSize stagingSz =
+          std::max(nVerts * sizeof(vec2), nInds * sizeof(uint32_t));
+      createBuffer(stagingSz, VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
+                   VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
+                       VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
+                   stagingBuffer, stagingMemory);
+
+      vkMapMemory(m_device, stagingMemory, 0, stagingSz, 0, &stagingBase);
+
+      memset(stagingBase, 0, nVerts * sizeof(float));
+      copyBuffer(m_heightBuffer, stagingBuffer, nVerts * sizeof(float));
+
+      for (size_t y = 0; y < m_sim.getHeight(); y++) {
+        for (size_t x = 0; x < m_sim.getWidth(); x++) {
+          vec2 *stagedVert = (vec2 *)stagingBase;
+          stagedVert[y * m_sim.getWidth() + x][0] =
+              (2.0f * x) / (m_sim.getWidth() - 1) - 1;
+          stagedVert[y * m_sim.getWidth() + x][1] =
+              (2.0f * y) / (m_sim.getHeight() - 1) - 1;
+        }
+      }
+      copyBuffer(m_xyBuffer, stagingBuffer, nVerts * sizeof(vec2));
+
+      {
+        uint32_t *indices = (uint32_t *)stagingBase;
+        for (size_t y = 0; y < m_sim.getHeight() - 1; y++) {
+          for (size_t x = 0; x < m_sim.getWidth() - 1; x++) {
+            indices[0] = (uint32_t)((y + 0) * m_sim.getWidth() + (x + 0));
+            indices[1] = (uint32_t)((y + 1) * m_sim.getWidth() + (x + 0));
+            indices[2] = (uint32_t)((y + 0) * m_sim.getWidth() + (x + 1));
+            indices[3] = (uint32_t)((y + 1) * m_sim.getWidth() + (x + 0));
+            indices[4] = (uint32_t)((y + 1) * m_sim.getWidth() + (x + 1));
+            indices[5] = (uint32_t)((y + 0) * m_sim.getWidth() + (x + 1));
+            indices += 6;
+          }
+        }
+      }
+      copyBuffer(m_indexBuffer, stagingBuffer, nInds * sizeof(uint32_t));
+
+      vkUnmapMemory(m_device, stagingMemory);
+      vkDestroyBuffer(m_device, stagingBuffer, nullptr);
+      vkFreeMemory(m_device, stagingMemory, nullptr);
+    }
+
+#ifdef _VK_TIMELINE_SEMAPHORE
+    // Create the timeline semaphore to sync cuda and vulkan access to vertex
+    // buffer
+    createExternalSemaphore(m_vkTimelineSemaphore,
+                            getDefaultSemaphoreHandleType());
+    // Import the timeline semaphore cuda will use to sync cuda and vulkan
+    // access to vertex buffer
+    importCudaExternalSemaphore(m_cudaTimelineSemaphore, m_vkTimelineSemaphore,
+                                getDefaultSemaphoreHandleType());
+#else
+    // 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());
+#endif /* _VK_TIMELINE_SEMAPHORE */
+  }
+
+  void importCudaExternalMemory(void **cudaPtr, cudaExternalMemory_t &cudaMem,
+                                VkDeviceMemory &vkMem, VkDeviceSize size,
+                                VkExternalMemoryHandleTypeFlagBits handleType) {
+    cudaExternalMemoryHandleDesc externalMemoryHandleDesc = {};
+
+    if (handleType & VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT) {
+      externalMemoryHandleDesc.type = cudaExternalMemoryHandleTypeOpaqueWin32;
+    } else if (handleType &
+               VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT) {
+      externalMemoryHandleDesc.type =
+          cudaExternalMemoryHandleTypeOpaqueWin32Kmt;
+    } else if (handleType & VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT) {
+      externalMemoryHandleDesc.type = cudaExternalMemoryHandleTypeOpaqueFd;
+    } else {
+      throw std::runtime_error("Unknown handle type requested!");
+    }
+
+    externalMemoryHandleDesc.size = size;
+
+#ifdef _WIN64
+    externalMemoryHandleDesc.handle.win32.handle =
+        (HANDLE)getMemHandle(vkMem, handleType);
+#else
+    externalMemoryHandleDesc.handle.fd =
+        (int)(uintptr_t)getMemHandle(vkMem, handleType);
+#endif
+
+    checkCudaErrors(
+        cudaImportExternalMemory(&cudaMem, &externalMemoryHandleDesc));
+
+    cudaExternalMemoryBufferDesc externalMemBufferDesc = {};
+    externalMemBufferDesc.offset = 0;
+    externalMemBufferDesc.size = size;
+    externalMemBufferDesc.flags = 0;
+
+    checkCudaErrors(cudaExternalMemoryGetMappedBuffer(cudaPtr, cudaMem,
+                                                      &externalMemBufferDesc));
+  }
+
+  void importCudaExternalSemaphore(
+      cudaExternalSemaphore_t &cudaSem, VkSemaphore &vkSem,
+      VkExternalSemaphoreHandleTypeFlagBits handleType) {
+    cudaExternalSemaphoreHandleDesc externalSemaphoreHandleDesc = {};
+
+#ifdef _VK_TIMELINE_SEMAPHORE
+    if (handleType & VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT) {
+      externalSemaphoreHandleDesc.type =
+          cudaExternalSemaphoreHandleTypeTimelineSemaphoreWin32;
+    } else if (handleType &
+               VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT) {
+      externalSemaphoreHandleDesc.type =
+          cudaExternalSemaphoreHandleTypeTimelineSemaphoreWin32;
+    } else if (handleType & VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT) {
+      externalSemaphoreHandleDesc.type =
+          cudaExternalSemaphoreHandleTypeTimelineSemaphoreFd;
+    }
+#else
+    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;
+    }
+#endif /* _VK_TIMELINE_SEMAPHORE */
+    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) {
+    {
+      mat4x4 view, proj;
+      vec3 eye = {1.75f, 1.75f, 1.25f};
+      vec3 center = {0.0f, 0.0f, -0.25f};
+      vec3 up = {0.0f, 0.0f, 1.0f};
+
+      mat4x4_perspective(
+          proj, (float)degreesToRadians(45.0f),
+          m_swapChainExtent.width / (float)m_swapChainExtent.height, 0.1f,
+          10.0f);
+      proj[1][1] *= -1.0f;  // Flip y axis
+
+      mat4x4_look_at(view, eye, center, up);
+      mat4x4_mul(m_ubo.modelViewProj, proj, view);
+    }
+
+    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);
+    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);
+    extensions.push_back(VK_KHR_TIMELINE_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;
+    }
+
+    float frame_time =
+        std::chrono::duration<float, std::chrono::seconds::period>(currentTime -
+                                                                   m_lastTime)
+            .count();
+
+    // Have vulkan draw the current frame...
+    VulkanBaseApp::drawFrame();
+
+#ifdef _VK_TIMELINE_SEMAPHORE
+    static uint64_t waitValue = 1;
+    static uint64_t signalValue = 2;
+
+    cudaExternalSemaphoreWaitParams waitParams = {};
+    waitParams.flags = 0;
+    waitParams.params.fence.value = waitValue;
+
+    cudaExternalSemaphoreSignalParams signalParams = {};
+    signalParams.flags = 0;
+    signalParams.params.fence.value = signalValue;
+    // Wait for vulkan to complete it's work
+    checkCudaErrors(cudaWaitExternalSemaphoresAsync(&m_cudaTimelineSemaphore,
+                                                    &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_cudaTimelineSemaphore, &signalParams, 1, m_stream));
+
+    waitValue += 2;
+    signalValue += 2;
+#else
+    cudaExternalSemaphoreWaitParams waitParams = {};
+    waitParams.flags = 0;
+    waitParams.params.fence.value = 0;
+
+    cudaExternalSemaphoreSignalParams signalParams = {};
+    signalParams.flags = 0;
+    signalParams.params.fence.value = 0;
+
+    // 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));
+#endif /* _VK_TIMELINE_SEMAPHORE */
+
+    // Output a naive measurement of the frames per second every five seconds
+    if (frame_time > 5) {
+      std::cout << "Average FPS (over " << std::fixed << std::setprecision(2)
+                << frame_time << " seconds): " << std::fixed
+                << std::setprecision(2)
+                << ((m_currentFrame - m_lastFrame) / frame_time) << std::endl;
+      m_lastFrame = m_currentFrame;
+      m_lastTime = currentTime;
+    }
+  }
+};
+
+int main(int argc, char **argv) {
+  execution_path = argv[0];
+  VulkanCudaSineWave app((1ULL << 8ULL), (1ULL << 8ULL));
+  app.init();
+  app.mainLoop();
+  return 0;
+}
--- a/Samples/5_Domain_Specific/simpleVulkan/simpleVulkan_vs2017.sln
+++ b/Samples/5_Domain_Specific/simpleVulkan/simpleVulkan_vs2017.sln
@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2017
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "simpleVulkan", "simpleVulkan_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
--- a/Samples/5_Domain_Specific/simpleVulkan/simpleVulkan_vs2017.vcxproj
+++ b/Samples/5_Domain_Specific/simpleVulkan/simpleVulkan_vs2017.vcxproj
@@ -0,0 +1,126 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <CUDAPropsPath Condition="'$(CUDAPropsPath)'==''">$(VCTargetsPath)\BuildCustomizations</CUDAPropsPath>
+  </PropertyGroup>
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{997E0757-EA74-4A4E-A0FC-47D8C8831A15}</ProjectGuid>
+    <RootNamespace>simpleVulkan_vs2017</RootNamespace>
+    <ProjectName>simpleVulkan</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>cudart_static.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)/simpleVulkan.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="SineWaveSimulation.cu" />
+    <ClCompile Include="VulkanBaseApp.cpp" />
+    <ClCompile Include="main.cpp" />
+    <ClInclude Include="SineWaveSimulation.h" />
+    <ClInclude Include="VulkanBaseApp.h" />
+    <ClInclude Include="linmath.h" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.6.targets" />
+  </ImportGroup>
+</Project>
--- a/Samples/5_Domain_Specific/simpleVulkan/simpleVulkan_vs2019.sln
+++ b/Samples/5_Domain_Specific/simpleVulkan/simpleVulkan_vs2019.sln
@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2019
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "simpleVulkan", "simpleVulkan_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
--- a/Samples/5_Domain_Specific/simpleVulkan/simpleVulkan_vs2019.vcxproj
+++ b/Samples/5_Domain_Specific/simpleVulkan/simpleVulkan_vs2019.vcxproj
@@ -0,0 +1,122 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <CUDAPropsPath Condition="'$(CUDAPropsPath)'==''">$(VCTargetsPath)\BuildCustomizations</CUDAPropsPath>
+  </PropertyGroup>
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{997E0757-EA74-4A4E-A0FC-47D8C8831A15}</ProjectGuid>
+    <RootNamespace>simpleVulkan_vs2019</RootNamespace>
+    <ProjectName>simpleVulkan</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>cudart_static.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)/simpleVulkan.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="SineWaveSimulation.cu" />
+    <ClCompile Include="VulkanBaseApp.cpp" />
+    <ClCompile Include="main.cpp" />
+    <ClInclude Include="SineWaveSimulation.h" />
+    <ClInclude Include="VulkanBaseApp.h" />
+    <ClInclude Include="linmath.h" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.6.targets" />
+  </ImportGroup>
+</Project>
--- a/Samples/5_Domain_Specific/simpleVulkan/simpleVulkan_vs2022.sln
+++ b/Samples/5_Domain_Specific/simpleVulkan/simpleVulkan_vs2022.sln
@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2022
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "simpleVulkan", "simpleVulkan_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
--- a/Samples/5_Domain_Specific/simpleVulkan/simpleVulkan_vs2022.vcxproj
+++ b/Samples/5_Domain_Specific/simpleVulkan/simpleVulkan_vs2022.vcxproj
@@ -0,0 +1,122 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <CUDAPropsPath Condition="'$(CUDAPropsPath)'==''">$(VCTargetsPath)\BuildCustomizations</CUDAPropsPath>
+  </PropertyGroup>
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{997E0757-EA74-4A4E-A0FC-47D8C8831A15}</ProjectGuid>
+    <RootNamespace>simpleVulkan_vs2022</RootNamespace>
+    <ProjectName>simpleVulkan</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>cudart_static.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)/simpleVulkan.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="SineWaveSimulation.cu" />
+    <ClCompile Include="VulkanBaseApp.cpp" />
+    <ClCompile Include="main.cpp" />
+    <ClInclude Include="SineWaveSimulation.h" />
+    <ClInclude Include="VulkanBaseApp.h" />
+    <ClInclude Include="linmath.h" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.6.targets" />
+  </ImportGroup>
+</Project>
--- a/Samples/5_Domain_Specific/simpleVulkan/sinewave.frag
+++ b/Samples/5_Domain_Specific/simpleVulkan/sinewave.frag
@@ -0,0 +1,38 @@
+/* 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);
+}
--- a/Samples/5_Domain_Specific/simpleVulkan/sinewave.vert
+++ b/Samples/5_Domain_Specific/simpleVulkan/sinewave.vert
@@ -0,0 +1,43 @@
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+
+layout(binding = 0) uniform UniformBufferObject {
+	mat4 modelViewProj;
+} ubo;
+
+layout(location = 0) in float height;
+layout(location = 1) in vec2 xyPos;
+
+layout(location = 0) out vec3 fragColor;
+
+void main() {
+    gl_Position = ubo.modelViewProj * vec4(xyPos.xy, height, 1.0f);
+    fragColor = vec3(0.0f, (height + 0.5f), 0.0f);
+}
--- a/Samples/5_Domain_Specific/simpleVulkan/vert.spv
+++ b/Samples/5_Domain_Specific/simpleVulkan/vert.spv