add and update samples for CUDA 11.5

Samples/boxFilter/.vscode/c_cpp_properties.json

@@ -0,0 +1,18 @@
+{
+    "configurations": [
+        {
+            "name": "Linux",
+            "includePath": [
+                "${workspaceFolder}/**",
+                "${workspaceFolder}/../../Common"
+            ],
+            "defines": [],
+            "compilerPath": "/usr/local/cuda/bin/nvcc",
+            "cStandard": "gnu17",
+            "cppStandard": "gnu++14",
+            "intelliSenseMode": "linux-gcc-x64",
+            "configurationProvider": "ms-vscode.makefile-tools"
+        }
+    ],
+    "version": 4
+}

Samples/boxFilter/.vscode/extensions.json

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

Samples/boxFilter/.vscode/launch.json

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

Samples/boxFilter/.vscode/tasks.json

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

Samples/boxFilter/Makefile

@@ -0,0 +1,388 @@
+################################################################################
+# Copyright (c) 2019, 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 += --qpp-config 5.4.0,gcc_ntoaarch64le
+        CCFLAGS += -DWIN_INTERFACE_CUSTOM -I/usr/include/aarch64-qnx-gnu
+        LDFLAGS += -lsocket
+        LDFLAGS += -L/usr/lib/aarch64-qnx-gnu
+        CCFLAGS += "-Wl\,-rpath-link\,/usr/lib/aarch64-qnx-gnu"
+        ifdef TARGET_OVERRIDE
+            LDFLAGS += -lslog2
+        endif
+
+        ifneq ($(TARGET_FS),)
+            LDFLAGS += -L$(TARGET_FS)/usr/lib
+            CCFLAGS += "-Wl\,-rpath-link\,$(TARGET_FS)/usr/lib"
+            LDFLAGS += -L$(TARGET_FS)/usr/libnvidia
+            CCFLAGS += "-Wl\,-rpath-link\,$(TARGET_FS)/usr/libnvidia"
+            CCFLAGS += -I$(TARGET_FS)/../include
+        endif
+    endif
+endif
+
+ifdef TARGET_OVERRIDE # cuda toolkit targets override
+    NVCCFLAGS += -target-dir $(TARGET_OVERRIDE)
+endif
+
+# Install directory of different arch
+CUDA_INSTALL_TARGET_DIR :=
+ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-linux)
+    CUDA_INSTALL_TARGET_DIR = targets/armv7-linux-gnueabihf/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-linux)
+    CUDA_INSTALL_TARGET_DIR = targets/aarch64-linux/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),sbsa-linux)
+    CUDA_INSTALL_TARGET_DIR = targets/sbsa-linux/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-android)
+    CUDA_INSTALL_TARGET_DIR = targets/armv7-linux-androideabi/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-android)
+    CUDA_INSTALL_TARGET_DIR = targets/aarch64-linux-androideabi/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-qnx)
+    CUDA_INSTALL_TARGET_DIR = targets/ARMv7-linux-QNX/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-qnx)
+    CUDA_INSTALL_TARGET_DIR = targets/aarch64-qnx/
+else ifeq ($(TARGET_ARCH),ppc64le)
+    CUDA_INSTALL_TARGET_DIR = targets/ppc64le-linux/
+endif
+
+# Debug build flags
+ifeq ($(dbg),1)
+      NVCCFLAGS += -g -G
+      BUILD_TYPE := debug
+else
+      BUILD_TYPE := release
+endif
+
+ALL_CCFLAGS :=
+ALL_CCFLAGS += $(NVCCFLAGS)
+ALL_CCFLAGS += $(EXTRA_NVCCFLAGS)
+ALL_CCFLAGS += $(addprefix -Xcompiler ,$(CCFLAGS))
+ALL_CCFLAGS += $(addprefix -Xcompiler ,$(EXTRA_CCFLAGS))
+
+SAMPLE_ENABLED := 1
+
+# This sample is not supported on QNX
+ifeq ($(TARGET_OS),qnx)
+  $(info >>> WARNING - boxFilter is not supported on QNX - waiving sample <<<)
+  SAMPLE_ENABLED := 0
+endif
+
+ALL_LDFLAGS :=
+ALL_LDFLAGS += $(ALL_CCFLAGS)
+ALL_LDFLAGS += $(addprefix -Xlinker ,$(LDFLAGS))
+ALL_LDFLAGS += $(addprefix -Xlinker ,$(EXTRA_LDFLAGS))
+
+# Common includes and paths for CUDA
+INCLUDES  := -I../../Common
+LIBRARIES :=
+
+################################################################################
+
+# Makefile include to help find GL Libraries
+include ./findgllib.mk
+
+# OpenGL specific libraries
+ifeq ($(TARGET_OS),darwin)
+ # Mac OSX specific libraries and paths to include
+ LIBRARIES += -L/System/Library/Frameworks/OpenGL.framework/Libraries
+ LIBRARIES += -lGL -lGLU
+ ALL_LDFLAGS += -Xlinker -framework -Xlinker GLUT
+else
+ LIBRARIES += $(GLLINK)
+ LIBRARIES += -lGL -lGLU -lglut
+endif
+
+#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)` \>= 51000)
+
+    ifeq ($(IS_MIN_VERSION), 1)
+        $(info >>> GCC Version is greater or equal to 5.1.0 <<<)
+    else
+        $(info >>> Waiving build. Minimum GCC version required is 5.1.0<<<)
+        SAMPLE_ENABLED := 0
+    endif
+endif
+
+# Gencode arguments
+ifeq ($(TARGET_ARCH),$(filter $(TARGET_ARCH),armv7l aarch64))
+SMS ?= 35 37 50 52 60 61 70 72 75 80 86
+else
+SMS ?= 35 37 50 52 60 61 70 75 80 86
+endif
+
+ifeq ($(SMS),)
+$(info >>> WARNING - no SM architectures have been specified - waiving sample <<<)
+SAMPLE_ENABLED := 0
+endif
+
+ifeq ($(GENCODE_FLAGS),)
+# Generate SASS code for each SM architecture listed in $(SMS)
+$(foreach sm,$(SMS),$(eval GENCODE_FLAGS += -gencode arch=compute_$(sm),code=sm_$(sm)))
+
+# Generate PTX code from the highest SM architecture in $(SMS) to guarantee forward-compatibility
+HIGHEST_SM := $(lastword $(sort $(SMS)))
+ifneq ($(HIGHEST_SM),)
+GENCODE_FLAGS += -gencode arch=compute_$(HIGHEST_SM),code=compute_$(HIGHEST_SM)
+endif
+endif
+
+ALL_CCFLAGS += --threads 0 --std=c++11
+
+ifeq ($(SAMPLE_ENABLED),0)
+EXEC ?= @echo "[@]"
+endif
+
+################################################################################
+
+# Target rules
+all: build
+
+build: boxFilter
+
+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
+
+boxFilter.o:boxFilter.cpp
+	$(EXEC) $(NVCC) $(INCLUDES) $(ALL_CCFLAGS) $(GENCODE_FLAGS) -o $@ -c $<
+
+boxFilter_cpu.o:boxFilter_cpu.cpp
+	$(EXEC) $(NVCC) $(INCLUDES) $(ALL_CCFLAGS) $(GENCODE_FLAGS) -o $@ -c $<
+
+boxFilter_kernel.o:boxFilter_kernel.cu
+	$(EXEC) $(NVCC) $(INCLUDES) $(ALL_CCFLAGS) $(GENCODE_FLAGS) -o $@ -c $<
+
+boxFilter: boxFilter.o boxFilter_cpu.o boxFilter_kernel.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) ./boxFilter
+
+clean:
+	rm -f boxFilter boxFilter.o boxFilter_cpu.o boxFilter_kernel.o
+	rm -rf ../../bin/$(TARGET_ARCH)/$(TARGET_OS)/$(BUILD_TYPE)/boxFilter
+
+clobber: clean

Samples/boxFilter/NsightEclipse.xml

@@ -0,0 +1,97 @@
+<?xml version="1.0" encoding="UTF-8"?> 
+<!DOCTYPE entry SYSTEM "SamplesInfo.dtd">
+<entry>
+  <name>boxFilter</name>
+  <cuda_api_list>
+    <toolkit>cudaGraphicsMapResources</toolkit>
+    <toolkit>cudaGraphicsUnmapResources</toolkit>
+    <toolkit>cudaGraphicsResourceGetMappedPointer</toolkit>
+    <toolkit>cudaGraphicsRegisterResource</toolkit>
+    <toolkit>cudaGraphicsGLRegisterBuffer</toolkit>
+    <toolkit>cudaGraphicsUnregisterResource</toolkit>
+  </cuda_api_list>
+  <description><![CDATA[Fast image box filter using CUDA with OpenGL rendering.]]></description>
+  <devicecompilation>whole</devicecompilation>
+  <files>
+    <file>data\lenaRGB.ppm</file>
+    <file>data\ref_14.ppm</file>
+    <file>data\ref_22.ppm</file>
+  </files>
+  <includepaths>
+    <path>./</path>
+    <path>../</path>
+    <path>../../Common</path>
+  </includepaths>
+  <keyconcepts>
+    <concept level="basic">Graphics Interop</concept>
+    <concept level="basic">Image Processing</concept>
+  </keyconcepts>
+  <keywords>
+    <keyword>GPGPU</keyword>
+    <keyword>CUDA</keyword>
+    <keyword>Image Processing</keyword>
+    <keyword>box filter</keyword>
+    <keyword>opengl</keyword>
+    <keyword>openGL</keyword>
+  </keywords>
+  <libraries>
+    <library>GLU</library>
+    <library>GL</library>
+    <library framework="true" os="macosx">GLUT</library>
+    <library os="linux">GLEW</library>
+    <library os="linux">glut</library>
+    <library os="linux">X11</library>
+  </libraries>
+  <librarypaths>
+    <path arch="x86_64" os="linux">../../common/lib/linux/x86_64</path>
+    <path arch="armv7l" os="linux">../../common/lib/linux/armv7l</path>
+    <path os="macosx">../../common/lib/darwin</path>
+  </librarypaths>
+  <nsight_eclipse>true</nsight_eclipse>
+  <primary_file>boxFilter.cpp</primary_file>
+  <qatests>
+    <qatest>-radius=14 -file=ref_14.ppm</qatest>
+    <qatest>-radius=22 -file=ref_22.ppm</qatest>
+  </qatests>
+  <required_dependencies>
+    <dependency>X11</dependency>
+    <dependency>GL</dependency>
+  </required_dependencies>
+  <scopes>
+    <scope>2:Graphics Interop</scope>
+    <scope>2:Image Processing</scope>
+    <scope>2:Computer Vision</scope>
+  </scopes>
+  <sm-arch>sm35</sm-arch>
+  <sm-arch>sm37</sm-arch>
+  <sm-arch>sm50</sm-arch>
+  <sm-arch>sm52</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>
+  <supported_envs>
+    <env>
+      <arch>x86_64</arch>
+      <platform>linux</platform>
+    </env>
+    <env>
+      <platform>windows7</platform>
+    </env>
+    <env>
+      <arch>x86_64</arch>
+      <platform>macosx</platform>
+    </env>
+    <env>
+      <arch>arm</arch>
+    </env>
+  </supported_envs>
+  <supported_sm_architectures>
+    <include>all</include>
+  </supported_sm_architectures>
+  <title>Box Filter</title>
+  <type>exe</type>
+</entry>

Samples/boxFilter/README.md

@@ -0,0 +1,74 @@
+# boxFilter - Box Filter
+
+## Description
+
+Fast image box filter using CUDA with OpenGL rendering.
+
+## Key Concepts
+
+Graphics Interop, Image Processing
+
+## 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 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)
+
+## Supported OSes
+
+Linux, Windows
+
+## Supported CPU Architecture
+
+x86_64, armv7l
+
+## CUDA APIs involved
+
+### [CUDA Runtime API](http://docs.nvidia.com/cuda/cuda-runtime-api/index.html)
+cudaGraphicsMapResources, cudaGraphicsUnmapResources, cudaGraphicsResourceGetMappedPointer, cudaGraphicsRegisterResource, cudaGraphicsGLRegisterBuffer, cudaGraphicsUnregisterResource
+
+## Dependencies needed to build/run
+[X11](../../README.md#x11), [GL](../../README.md#gl)
+
+## Prerequisites
+
+Download and install the [CUDA Toolkit 11.5](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, armv7l.
+    By default, TARGET_ARCH is set to HOST_ARCH. On a x86_64 machine, not setting TARGET_ARCH is the equivalent of setting TARGET_ARCH=x86_64.<br/>
+`$ make TARGET_ARCH=x86_64` <br/> `$ make TARGET_ARCH=armv7l` <br/>
+    See [here](http://docs.nvidia.com/cuda/cuda-samples/index.html#cross-samples) for more details.
+*   **dbg=1** - build with debug symbols
+    ```
+    $ make dbg=1
+    ```
+*   **SMS="A B ..."** - override the SM architectures for which the sample will be built, where `"A B ..."` is a space-delimited list of SM architectures. For example, to generate SASS for SM 50 and SM 60, use `SMS="50 60"`.
+    ```
+    $ make SMS="50 60"
+    ```
+
+*  **HOST_COMPILER=<host_compiler>** - override the default g++ host compiler. See the [Linux Installation Guide](http://docs.nvidia.com/cuda/cuda-installation-guide-linux/index.html#system-requirements) for a list of supported host compilers.
+```
+    $ make HOST_COMPILER=g++
+```
+
+## References (for more details)
+

Samples/boxFilter/boxFilter.cpp

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

Samples/boxFilter/boxFilter_cpu.cpp

@@ -0,0 +1,123 @@
+/* Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+////////////////////////////////////////////////////////////////////////////////
+// export C interface
+extern "C" void computeGold(float *id, float *od, int w, int h, int r);
+
+// CPU implementation
+void hboxfilter_x(float *id, float *od, int w, int h, int r) {
+  float scale = 1.0f / (2 * r + 1);
+
+  for (int y = 0; y < h; y++) {
+    float t;
+    // do left edge
+    t = id[y * w] * r;
+
+    for (int x = 0; x < r + 1; x++) {
+      t += id[y * w + x];
+    }
+
+    od[y * w] = t * scale;
+
+    for (int x = 1; x < r + 1; x++) {
+      int c = y * w + x;
+      t += id[c + r];
+      t -= id[y * w];
+      od[c] = t * scale;
+    }
+
+    // main loop
+    for (int x = r + 1; x < w - r; x++) {
+      int c = y * w + x;
+      t += id[c + r];
+      t -= id[c - r - 1];
+      od[c] = t * scale;
+    }
+
+    // do right edge
+    for (int x = w - r; x < w; x++) {
+      int c = y * w + x;
+      t += id[(y * w) + w - 1];
+      t -= id[c - r - 1];
+      od[c] = t * scale;
+    }
+  }
+}
+
+void hboxfilter_y(float *id, float *od, int w, int h, int r) {
+  float scale = 1.0f / (2 * r + 1);
+
+  for (int x = 0; x < w; x++) {
+    float t;
+    // do left edge
+    t = id[x] * r;
+
+    for (int y = 0; y < r + 1; y++) {
+      t += id[y * w + x];
+    }
+
+    od[x] = t * scale;
+
+    for (int y = 1; y < r + 1; y++) {
+      int c = y * w + x;
+      t += id[c + r * w];
+      t -= id[x];
+      od[c] = t * scale;
+    }
+
+    // main loop
+    for (int y = r + 1; y < h - r; y++) {
+      int c = y * w + x;
+      t += id[c + r * w];
+      t -= id[c - (r * w) - w];
+      od[c] = t * scale;
+    }
+
+    // do right edge
+    for (int y = h - r; y < h; y++) {
+      int c = y * w + x;
+      t += id[(h - 1) * w + x];
+      t -= id[c - (r * w) - w];
+      od[c] = t * scale;
+    }
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//! Compute reference data set
+//! @param image      pointer to input data
+//! @param temp       pointer to temporary store
+//! @param w          width of image
+//! @param h          height of image
+//! @param r          radius of filter
+////////////////////////////////////////////////////////////////////////////////
+
+void computeGold(float *image, float *temp, int w, int h, int r) {
+  hboxfilter_x(image, temp, w, h, r);
+  hboxfilter_y(temp, image, w, h, r);
+}

Samples/boxFilter/boxFilter_kernel.cu

@@ -0,0 +1,490 @@
+/* Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _BOXFILTER_KERNEL_CH_
+#define _BOXFILTER_KERNEL_CH_
+
+#include <helper_math.h>
+#include <helper_functions.h>
+
+cudaTextureObject_t tex;
+cudaTextureObject_t texTempArray;
+cudaTextureObject_t rgbaTex;
+cudaTextureObject_t rgbaTexTempArray;
+cudaArray *d_array, *d_tempArray;
+
+////////////////////////////////////////////////////////////////////////////////
+// These are CUDA Helper functions
+
+// This will output the proper CUDA error strings in the event that a CUDA host
+// call returns an error
+#define checkCudaErrors(err) __checkCudaErrors(err, __FILE__, __LINE__)
+
+inline void __checkCudaErrors(cudaError err, const char *file, const int line) {
+  if (cudaSuccess != err) {
+    fprintf(stderr, "%s(%i) : CUDA Runtime API error %d: %s.\n", file, line,
+            (int)err, cudaGetErrorString(err));
+    exit(EXIT_FAILURE);
+  }
+}
+
+/*
+  Perform a fast box filter using the sliding window method.
+
+  As the kernel moves from left to right, we add in the contribution of the
+  new sample on the right, and subtract the value of the exiting sample on the
+  left. This only requires 2 adds and a mul per output value, independent of the
+  filter radius. The box filter is separable, so to perform a 2D box filter we
+  perform the filter in the x direction, followed by the same filter in the y
+  direction. Applying multiple iterations of the box filter converges towards a
+  Gaussian blur. Using CUDA, rows or columns of the image are processed in
+  parallel. This version duplicates edge pixels.
+
+  Note that the x (row) pass suffers from uncoalesced global memory reads,
+  since each thread is reading from a different row. For this reason it is
+  better to use texture lookups for the x pass.
+  The y (column) pass is perfectly coalesced.
+
+  Parameters
+  id - pointer to input data in global memory
+  od - pointer to output data in global memory
+  w  - image width
+  h  - image height
+  r  - filter radius
+
+  e.g. for r = 2, w = 8:
+
+  0 1 2 3 4 5 6 7
+  x - -
+  - x - -
+  - - x - -
+    - - x - -
+      - - x - -
+        - - x - -
+          - - x -
+            - - x
+*/
+
+// process row
+__device__ void d_boxfilter_x(float *id, float *od, int w, int h, int r) {
+  float scale = 1.0f / (float)((r << 1) + 1);
+
+  float t;
+  // do left edge
+  t = id[0] * r;
+
+  for (int x = 0; x < (r + 1); x++) {
+    t += id[x];
+  }
+
+  od[0] = t * scale;
+
+  for (int x = 1; x < (r + 1); x++) {
+    t += id[x + r];
+    t -= id[0];
+    od[x] = t * scale;
+  }
+
+  // main loop
+  for (int x = (r + 1); x < w - r; x++) {
+    t += id[x + r];
+    t -= id[x - r - 1];
+    od[x] = t * scale;
+  }
+
+  // do right edge
+  for (int x = w - r; x < w; x++) {
+    t += id[w - 1];
+    t -= id[x - r - 1];
+    od[x] = t * scale;
+  }
+}
+
+// process column
+__device__ void d_boxfilter_y(float *id, float *od, int w, int h, int r) {
+  float scale = 1.0f / (float)((r << 1) + 1);
+
+  float t;
+  // do left edge
+  t = id[0] * r;
+
+  for (int y = 0; y < (r + 1); y++) {
+    t += id[y * w];
+  }
+
+  od[0] = t * scale;
+
+  for (int y = 1; y < (r + 1); y++) {
+    t += id[(y + r) * w];
+    t -= id[0];
+    od[y * w] = t * scale;
+  }
+
+  // main loop
+  for (int y = (r + 1); y < (h - r); y++) {
+    t += id[(y + r) * w];
+    t -= id[((y - r) * w) - w];
+    od[y * w] = t * scale;
+  }
+
+  // do right edge
+  for (int y = h - r; y < h; y++) {
+    t += id[(h - 1) * w];
+    t -= id[((y - r) * w) - w];
+    od[y * w] = t * scale;
+  }
+}
+
+__global__ void d_boxfilter_x_global(float *id, float *od, int w, int h,
+                                     int r) {
+  unsigned int y = blockIdx.x * blockDim.x + threadIdx.x;
+  d_boxfilter_x(&id[y * w], &od[y * w], w, h, r);
+}
+
+__global__ void d_boxfilter_y_global(float *id, float *od, int w, int h,
+                                     int r) {
+  unsigned int x = blockIdx.x * blockDim.x + threadIdx.x;
+  d_boxfilter_y(&id[x], &od[x], w, h, r);
+}
+
+// texture version
+// texture fetches automatically clamp to edge of image
+__global__ void d_boxfilter_x_tex(float *od, int w, int h, int r,
+                                  cudaTextureObject_t tex) {
+  float scale = 1.0f / (float)((r << 1) + 1);
+  unsigned int y = blockIdx.x * blockDim.x + threadIdx.x;
+
+  float t = 0.0f;
+
+  for (int x = -r; x <= r; x++) {
+    t += tex2D<float>(tex, x, y);
+  }
+
+  od[y * w] = t * scale;
+
+  for (int x = 1; x < w; x++) {
+    t += tex2D<float>(tex, x + r, y);
+    t -= tex2D<float>(tex, x - r - 1, y);
+    od[y * w + x] = t * scale;
+  }
+}
+
+__global__ void d_boxfilter_y_tex(float *od, int w, int h, int r,
+                                  cudaTextureObject_t tex) {
+  float scale = 1.0f / (float)((r << 1) + 1);
+  unsigned int x = blockIdx.x * blockDim.x + threadIdx.x;
+
+  float t = 0.0f;
+
+  for (int y = -r; y <= r; y++) {
+    t += tex2D<float>(tex, x, y);
+  }
+
+  od[x] = t * scale;
+
+  for (int y = 1; y < h; y++) {
+    t += tex2D<float>(tex, x, y + r);
+    t -= tex2D<float>(tex, x, y - r - 1);
+    od[y * w + x] = t * scale;
+  }
+}
+
+// RGBA version
+// reads from 32-bit unsigned int array holding 8-bit RGBA
+
+// convert floating point rgba color to 32-bit integer
+__device__ unsigned int rgbaFloatToInt(float4 rgba) {
+  rgba.x = __saturatef(rgba.x);  // clamp to [0.0, 1.0]
+  rgba.y = __saturatef(rgba.y);
+  rgba.z = __saturatef(rgba.z);
+  rgba.w = __saturatef(rgba.w);
+  return ((unsigned int)(rgba.w * 255.0f) << 24) |
+         ((unsigned int)(rgba.z * 255.0f) << 16) |
+         ((unsigned int)(rgba.y * 255.0f) << 8) |
+         ((unsigned int)(rgba.x * 255.0f));
+}
+
+__device__ float4 rgbaIntToFloat(unsigned int c) {
+  float4 rgba;
+  rgba.x = (c & 0xff) * 0.003921568627f;          //  /255.0f;
+  rgba.y = ((c >> 8) & 0xff) * 0.003921568627f;   //  /255.0f;
+  rgba.z = ((c >> 16) & 0xff) * 0.003921568627f;  //  /255.0f;
+  rgba.w = ((c >> 24) & 0xff) * 0.003921568627f;  //  /255.0f;
+  return rgba;
+}
+
+// row pass using texture lookups
+__global__ void d_boxfilter_rgba_x(unsigned int *od, int w, int h, int r,
+                                   cudaTextureObject_t rgbaTex) {
+  float scale = 1.0f / (float)((r << 1) + 1);
+  unsigned int y = blockIdx.x * blockDim.x + threadIdx.x;
+
+  // as long as address is always less than height, we do work
+  if (y < h) {
+    float4 t = make_float4(0.0f);
+
+    for (int x = -r; x <= r; x++) {
+      t += tex2D<float4>(rgbaTex, x, y);
+    }
+
+    od[y * w] = rgbaFloatToInt(t * scale);
+
+    for (int x = 1; x < w; x++) {
+      t += tex2D<float4>(rgbaTex, x + r, y);
+      t -= tex2D<float4>(rgbaTex, x - r - 1, y);
+      od[y * w + x] = rgbaFloatToInt(t * scale);
+    }
+  }
+}
+
+// column pass using coalesced global memory reads
+__global__ void d_boxfilter_rgba_y(unsigned int *id, unsigned int *od, int w,
+                                   int h, int r) {
+  unsigned int x = blockIdx.x * blockDim.x + threadIdx.x;
+  id = &id[x];
+  od = &od[x];
+
+  float scale = 1.0f / (float)((r << 1) + 1);
+
+  float4 t;
+  // do left edge
+  t = rgbaIntToFloat(id[0]) * r;
+
+  for (int y = 0; y < (r + 1); y++) {
+    t += rgbaIntToFloat(id[y * w]);
+  }
+
+  od[0] = rgbaFloatToInt(t * scale);
+
+  for (int y = 1; y < (r + 1); y++) {
+    t += rgbaIntToFloat(id[(y + r) * w]);
+    t -= rgbaIntToFloat(id[0]);
+    od[y * w] = rgbaFloatToInt(t * scale);
+  }
+
+  // main loop
+  for (int y = (r + 1); y < (h - r); y++) {
+    t += rgbaIntToFloat(id[(y + r) * w]);
+    t -= rgbaIntToFloat(id[((y - r) * w) - w]);
+    od[y * w] = rgbaFloatToInt(t * scale);
+  }
+
+  // do right edge
+  for (int y = h - r; y < h; y++) {
+    t += rgbaIntToFloat(id[(h - 1) * w]);
+    t -= rgbaIntToFloat(id[((y - r) * w) - w]);
+    od[y * w] = rgbaFloatToInt(t * scale);
+  }
+}
+
+extern "C" void initTexture(int width, int height, void *pImage, bool useRGBA) {
+  // copy image data to array
+  cudaChannelFormatDesc channelDesc;
+  if (useRGBA) {
+    channelDesc =
+        cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsigned);
+  } else {
+    channelDesc =
+        cudaCreateChannelDesc(32, 0, 0, 0, cudaChannelFormatKindFloat);
+  }
+  checkCudaErrors(cudaMallocArray(&d_array, &channelDesc, width, height));
+
+  size_t bytesPerElem = (useRGBA ? sizeof(uchar4) : sizeof(float));
+  checkCudaErrors(cudaMemcpy2DToArray(
+      d_array, 0, 0, pImage, width * bytesPerElem, width * bytesPerElem, height,
+      cudaMemcpyHostToDevice));
+
+  checkCudaErrors(cudaMallocArray(&d_tempArray, &channelDesc, width, height));
+
+  // set texture parameters
+  cudaResourceDesc texRes;
+  memset(&texRes, 0, sizeof(cudaResourceDesc));
+
+  texRes.resType = cudaResourceTypeArray;
+  texRes.res.array.array = d_array;
+
+  cudaTextureDesc texDescr;
+  memset(&texDescr, 0, sizeof(cudaTextureDesc));
+
+  texDescr.normalizedCoords = false;
+  texDescr.filterMode = cudaFilterModeLinear;
+  texDescr.addressMode[0] = cudaAddressModeWrap;
+  texDescr.addressMode[1] = cudaAddressModeWrap;
+  texDescr.readMode = cudaReadModeNormalizedFloat;
+
+  checkCudaErrors(cudaCreateTextureObject(&rgbaTex, &texRes, &texDescr, NULL));
+
+  memset(&texRes, 0, sizeof(cudaResourceDesc));
+
+  texRes.resType = cudaResourceTypeArray;
+  texRes.res.array.array = d_tempArray;
+
+  memset(&texDescr, 0, sizeof(cudaTextureDesc));
+
+  texDescr.normalizedCoords = false;
+  texDescr.filterMode = cudaFilterModeLinear;
+  texDescr.addressMode[0] = cudaAddressModeClamp;
+  texDescr.addressMode[1] = cudaAddressModeClamp;
+  texDescr.readMode = cudaReadModeNormalizedFloat;
+
+  checkCudaErrors(
+      cudaCreateTextureObject(&rgbaTexTempArray, &texRes, &texDescr, NULL));
+
+  memset(&texRes, 0, sizeof(cudaResourceDesc));
+
+  texRes.resType = cudaResourceTypeArray;
+  texRes.res.array.array = d_array;
+
+  memset(&texDescr, 0, sizeof(cudaTextureDesc));
+
+  texDescr.normalizedCoords = true;
+  texDescr.filterMode = cudaFilterModePoint;
+  texDescr.addressMode[0] = cudaAddressModeWrap;
+  texDescr.addressMode[1] = cudaAddressModeWrap;
+  texDescr.readMode = cudaReadModeElementType;
+
+  checkCudaErrors(cudaCreateTextureObject(&tex, &texRes, &texDescr, NULL));
+
+  memset(&texRes, 0, sizeof(cudaResourceDesc));
+
+  texRes.resType = cudaResourceTypeArray;
+  texRes.res.array.array = d_tempArray;
+
+  memset(&texDescr, 0, sizeof(cudaTextureDesc));
+
+  texDescr.normalizedCoords = true;
+  texDescr.filterMode = cudaFilterModePoint;
+  texDescr.addressMode[0] = cudaAddressModeWrap;
+  texDescr.addressMode[1] = cudaAddressModeWrap;
+  texDescr.readMode = cudaReadModeElementType;
+
+  checkCudaErrors(
+      cudaCreateTextureObject(&texTempArray, &texRes, &texDescr, NULL));
+}
+
+extern "C" void freeTextures() {
+  checkCudaErrors(cudaDestroyTextureObject(tex));
+  checkCudaErrors(cudaDestroyTextureObject(texTempArray));
+  checkCudaErrors(cudaDestroyTextureObject(rgbaTex));
+  checkCudaErrors(cudaDestroyTextureObject(rgbaTexTempArray));
+  checkCudaErrors(cudaFreeArray(d_array));
+  checkCudaErrors(cudaFreeArray(d_tempArray));
+}
+
+/*
+    Perform 2D box filter on image using CUDA
+
+    Parameters:
+    d_src  - pointer to input image in device memory
+    d_temp - pointer to temporary storage in device memory
+    d_dest - pointer to destination image in device memory
+    width  - image width
+    height - image height
+    radius - filter radius
+    iterations - number of iterations
+
+*/
+extern "C" double boxFilter(float *d_src, float *d_temp, float *d_dest,
+                            int width, int height, int radius, int iterations,
+                            int nthreads, StopWatchInterface *timer) {
+  // var for kernel timing
+  double dKernelTime = 0.0;
+
+  // sync host and start computation timer_kernel
+  checkCudaErrors(cudaDeviceSynchronize());
+
+  for (int i = 0; i < iterations; i++) {
+    sdkResetTimer(&timer);
+    // use texture for horizontal pass
+    if (iterations > 1) {
+      d_boxfilter_x_tex<<<height / nthreads, nthreads, 0>>>(
+          d_temp, width, height, radius, texTempArray);
+    } else {
+      d_boxfilter_x_tex<<<height / nthreads, nthreads, 0>>>(
+          d_temp, width, height, radius, tex);
+    }
+
+    d_boxfilter_y_global<<<width / nthreads, nthreads, 0>>>(
+        d_temp, d_dest, width, height, radius);
+
+    // sync host and stop computation timer_kernel
+    checkCudaErrors(cudaDeviceSynchronize());
+    dKernelTime += sdkGetTimerValue(&timer);
+
+    if (iterations > 1) {
+      // copy result back from global memory to array
+      checkCudaErrors(cudaMemcpy2DToArray(
+          d_tempArray, 0, 0, d_dest, width * sizeof(float),
+          width * sizeof(float), height, cudaMemcpyDeviceToDevice));
+    }
+  }
+
+  return ((dKernelTime / 1000.) / (double)iterations);
+}
+
+// RGBA version
+extern "C" double boxFilterRGBA(unsigned int *d_src, unsigned int *d_temp,
+                                unsigned int *d_dest, int width, int height,
+                                int radius, int iterations, int nthreads,
+                                StopWatchInterface *timer) {
+  // var for kernel computation timing
+  double dKernelTime;
+
+  for (int i = 0; i < iterations; i++) {
+    // sync host and start kernel computation timer_kernel
+    dKernelTime = 0.0;
+    checkCudaErrors(cudaDeviceSynchronize());
+    sdkResetTimer(&timer);
+
+    // use texture for horizontal pass
+    if (iterations > 1) {
+      d_boxfilter_rgba_x<<<height / nthreads, nthreads, 0>>>(
+          d_temp, width, height, radius, rgbaTexTempArray);
+    } else {
+      d_boxfilter_rgba_x<<<height / nthreads, nthreads, 0>>>(
+          d_temp, width, height, radius, rgbaTex);
+    }
+
+    d_boxfilter_rgba_y<<<width / nthreads, nthreads, 0>>>(d_temp, d_dest, width,
+                                                          height, radius);
+
+    // sync host and stop computation timer_kernel
+    checkCudaErrors(cudaDeviceSynchronize());
+    dKernelTime += sdkGetTimerValue(&timer);
+
+    if (iterations > 1) {
+      // copy result back from global memory to array
+      checkCudaErrors(cudaMemcpy2DToArray(
+          d_tempArray, 0, 0, d_dest, width * sizeof(unsigned int),
+          width * sizeof(unsigned int), height, cudaMemcpyDeviceToDevice));
+    }
+  }
+
+  return ((dKernelTime / 1000.) / (double)iterations);
+}
+
+#endif  // #ifndef _BOXFILTER_KERNEL_H_

Samples/boxFilter/boxFilter_vs2017.sln

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

Samples/boxFilter/boxFilter_vs2017.vcxproj

@@ -0,0 +1,125 @@
+<?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>boxFilter_vs2017</RootNamespace>
+    <ProjectName>boxFilter</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.5.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <IntDir>$(Platform)/$(Configuration)/</IntDir>
+    <IncludePath>$(IncludePath)</IncludePath>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules />
+    <CodeAnalysisRuleAssemblies />
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Platform)'=='x64'">
+    <OutDir>../../bin/win64/$(Configuration)/</OutDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;_MBCS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>./;$(CudaToolkitDir)/include;../../Common;</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <AdditionalDependencies>cudart_static.lib;freeglut.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>$(CudaToolkitLibDir);../../Common/lib/$(PlatformName);</AdditionalLibraryDirectories>
+      <OutputFile>$(OutDir)/boxFilter.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" %(AdditionalOptions)</AdditionalOptions>
+      <Include>./;../../Common</Include>
+      <Defines>WIN32</Defines>
+      <AdditionalOptions>--threads 0</AdditionalOptions>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Debug'">
+    <ClCompile>
+      <Optimization>Disabled</Optimization>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
+    </Link>
+    <CudaCompile>
+      <Runtime>MTd</Runtime>
+      <TargetMachinePlatform>64</TargetMachinePlatform>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Release'">
+    <ClCompile>
+      <Optimization>MaxSpeed</Optimization>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>false</GenerateDebugInformation>
+      <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
+    </Link>
+    <CudaCompile>
+      <Runtime>MT</Runtime>
+      <TargetMachinePlatform>64</TargetMachinePlatform>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Platform)'=='Win32'">
+    <Link>
+      
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Platform)'=='x64'">
+    <Link>
+      <AdditionalDependencies>glew64.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="boxFilter.cpp" />
+    <ClCompile Include="boxFilter_cpu.cpp" />
+    <CudaCompile Include="boxFilter_kernel.cu" />
+
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.5.targets" />
+  </ImportGroup>
+</Project>

Samples/boxFilter/boxFilter_vs2019.sln

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

Samples/boxFilter/boxFilter_vs2019.vcxproj

@@ -0,0 +1,121 @@
+<?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>boxFilter_vs2019</RootNamespace>
+    <ProjectName>boxFilter</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.5.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <IntDir>$(Platform)/$(Configuration)/</IntDir>
+    <IncludePath>$(IncludePath)</IncludePath>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules />
+    <CodeAnalysisRuleAssemblies />
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Platform)'=='x64'">
+    <OutDir>../../bin/win64/$(Configuration)/</OutDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;_MBCS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>./;$(CudaToolkitDir)/include;../../Common;</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <AdditionalDependencies>cudart_static.lib;freeglut.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>$(CudaToolkitLibDir);../../Common/lib/$(PlatformName);</AdditionalLibraryDirectories>
+      <OutputFile>$(OutDir)/boxFilter.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" %(AdditionalOptions)</AdditionalOptions>
+      <Include>./;../../Common</Include>
+      <Defines>WIN32</Defines>
+      <AdditionalOptions>--threads 0</AdditionalOptions>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Debug'">
+    <ClCompile>
+      <Optimization>Disabled</Optimization>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
+    </Link>
+    <CudaCompile>
+      <Runtime>MTd</Runtime>
+      <TargetMachinePlatform>64</TargetMachinePlatform>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Release'">
+    <ClCompile>
+      <Optimization>MaxSpeed</Optimization>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>false</GenerateDebugInformation>
+      <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
+    </Link>
+    <CudaCompile>
+      <Runtime>MT</Runtime>
+      <TargetMachinePlatform>64</TargetMachinePlatform>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Platform)'=='Win32'">
+    <Link>
+      
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Platform)'=='x64'">
+    <Link>
+      <AdditionalDependencies>glew64.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="boxFilter.cpp" />
+    <ClCompile Include="boxFilter_cpu.cpp" />
+    <CudaCompile Include="boxFilter_kernel.cu" />
+
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.5.targets" />
+  </ImportGroup>
+</Project>

Samples/boxFilter/findgllib.mk

@@ -0,0 +1,145 @@
+################################################################################
+# Copyright (c) 2020, 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.
+#
+################################################################################
+#
+#  findgllib.mk is used to find the necessary GL Libraries for specific distributions
+#               this is supported on Mac OSX and Linux Platforms
+#
+################################################################################
+
+# 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 awk '{print $$1}' /etc/issue | tr -d "[:space:]" | sed -e "/^$$/d" | tr "[:upper:]" "[:lower:]")
+     # ensure data from /etc/issue is valid
+     ifeq (,$(filter $(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")
+    # $(info) >> findgllib.mk -> LINUX path <<<)
+    # Each set of Linux Distros have different paths for where to find their OpenGL libraries reside
+    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 ifeq ($(HOST_ARCH)-$(TARGET_ARCH),x86_64-ppc64le)
+        GLPATH := /usr/powerpc64le-linux-gnu/lib
+        GLLINK := -L/usr/powerpc64le-linux-gnu/lib
+      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
+  
+  # find libGL, libGLU 
+  GLLIB  := $(shell find -L $(GLPATH) $(DFLT_PATH) -name libGL.so  -print 2>/dev/null)
+  GLULIB := $(shell find -L $(GLPATH) $(DFLT_PATH) -name libGLU.so -print 2>/dev/null)
+
+  ifeq ("$(GLLIB)","")
+      $(info >>> WARNING - libGL.so not found, refer to CUDA Getting Started Guide for how to find and install them. <<<)
+      SAMPLE_ENABLED := 0
+  endif
+  ifeq ("$(GLULIB)","")
+      $(info >>> WARNING - libGLU.so not found, refer to CUDA Getting Started Guide for how to find and install them. <<<)
+      SAMPLE_ENABLED := 0
+  endif
+
+  HEADER_SEARCH_PATH ?= $(TARGET_FS)/usr/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
+
+  GLHEADER  := $(shell find -L $(HEADER_SEARCH_PATH) -name gl.h -print 2>/dev/null)
+  GLUHEADER := $(shell find -L $(HEADER_SEARCH_PATH) -name glu.h -print 2>/dev/null)
+
+  ifeq ("$(GLHEADER)","")
+      $(info >>> WARNING - gl.h not found, refer to CUDA Getting Started Guide for how to find and install them. <<<)
+      SAMPLE_ENABLED := 0
+  endif
+  ifeq ("$(GLUHEADER)","")
+      $(info >>> WARNING - glu.h not found, refer to CUDA Getting Started Guide for how to find and install them. <<<)
+      SAMPLE_ENABLED := 0
+  endif
+else
+    # This would be the Mac OS X path if we had to do anything special
+endif
+