add and update samples for CUDA 11.5

2026-10-23 13:18:16 +08:00 · 2021-10-21 16:34:49 +05:30
parent 3342d604fe
commit 1f76a2d110
2796 changed files with 1511725 additions and 827 deletions
--- a/Samples/convolutionFFT2D/.vscode/c_cpp_properties.json
+++ b/Samples/convolutionFFT2D/.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/convolutionFFT2D/.vscode/extensions.json
+++ b/Samples/convolutionFFT2D/.vscode/extensions.json
@@ -0,0 +1,7 @@
+{
+    "recommendations": [
+        "nvidia.nsight-vscode-edition",
+        "ms-vscode.cpptools",
+        "ms-vscode.makefile-tools"
+    ]
+}
--- a/Samples/convolutionFFT2D/.vscode/launch.json
+++ b/Samples/convolutionFFT2D/.vscode/launch.json
@@ -0,0 +1,10 @@
+{
+    "configurations": [
+        {
+            "name": "CUDA C++: Launch",
+            "type": "cuda-gdb",
+            "request": "launch",
+            "program": "${workspaceFolder}/convolutionFFT2D"
+        }
+    ]
+}
--- a/Samples/convolutionFFT2D/.vscode/tasks.json
+++ b/Samples/convolutionFFT2D/.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/convolutionFFT2D/Makefile
+++ b/Samples/convolutionFFT2D/Makefile
@@ -0,0 +1,370 @@
+################################################################################
+# 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
+
+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 :=
+
+################################################################################
+
+#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
+
+LIBRARIES += -lcufft
+
+ifeq ($(SAMPLE_ENABLED),0)
+EXEC ?= @echo "[@]"
+endif
+
+################################################################################
+
+# Target rules
+all: build
+
+build: convolutionFFT2D
+
+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
+
+convolutionFFT2D.o:convolutionFFT2D.cu
+	$(EXEC) $(NVCC) $(INCLUDES) $(ALL_CCFLAGS) $(GENCODE_FLAGS) -o $@ -c $<
+
+convolutionFFT2D_gold.o:convolutionFFT2D_gold.cpp
+	$(EXEC) $(NVCC) $(INCLUDES) $(ALL_CCFLAGS) $(GENCODE_FLAGS) -o $@ -c $<
+
+main.o:main.cpp
+	$(EXEC) $(NVCC) $(INCLUDES) $(ALL_CCFLAGS) $(GENCODE_FLAGS) -o $@ -c $<
+
+convolutionFFT2D: convolutionFFT2D.o convolutionFFT2D_gold.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) ./convolutionFFT2D
+
+clean:
+	rm -f convolutionFFT2D convolutionFFT2D.o convolutionFFT2D_gold.o main.o
+	rm -rf ../../bin/$(TARGET_ARCH)/$(TARGET_OS)/$(BUILD_TYPE)/convolutionFFT2D
+
+clobber: clean
--- a/Samples/convolutionFFT2D/NsightEclipse.xml
+++ b/Samples/convolutionFFT2D/NsightEclipse.xml
@@ -0,0 +1,81 @@
+<?xml version="1.0" encoding="UTF-8"?> 
+<!DOCTYPE entry SYSTEM "SamplesInfo.dtd">
+<entry>
+  <name>convolutionFFT2D</name>
+  <cuda_api_list>
+    <toolkit>cufftPlan2d</toolkit>
+    <toolkit>cufftExecR2C</toolkit>
+    <toolkit>cufftExecC2R</toolkit>
+    <toolkit>cufftDestroy</toolkit>
+  </cuda_api_list>
+  <description><![CDATA[This sample demonstrates how 2D convolutions with very large kernel sizes can be efficiently implemented using FFT transformations.]]></description>
+  <devicecompilation>whole</devicecompilation>
+  <includepaths>
+    <path>./</path>
+    <path>../</path>
+    <path>../../Common</path>
+  </includepaths>
+  <keyconcepts>
+    <concept level="advanced">Image Processing</concept>
+    <concept level="advanced">CUFFT Library</concept>
+  </keyconcepts>
+  <keywords>
+    <keyword>CUDA</keyword>
+    <keyword>CUFFT</keyword>
+    <keyword>DSP</keyword>
+    <keyword>non-separable convolution</keyword>
+    <keyword>finite impulse-response filter</keyword>
+    <keyword>Image Processing</keyword>
+  </keywords>
+  <libraries>
+    <library>cufft</library>
+  </libraries>
+  <librarypaths>
+  </librarypaths>
+  <nsight_eclipse>true</nsight_eclipse>
+  <primary_file>main.cpp</primary_file>
+  <required_dependencies>
+    <dependency>CUFFT</dependency>
+  </required_dependencies>
+  <scopes>
+    <scope>1:CUDA Advanced Topics</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>
+    <env>
+      <arch>ppc64le</arch>
+      <platform>linux</platform>
+    </env>
+  </supported_envs>
+  <supported_sm_architectures>
+    <include>all</include>
+  </supported_sm_architectures>
+  <title>FFT-Based 2D Convolution</title>
+  <type>exe</type>
+</entry>
--- a/Samples/convolutionFFT2D/README.md
+++ b/Samples/convolutionFFT2D/README.md
@@ -0,0 +1,74 @@
+# convolutionFFT2D - FFT-Based 2D Convolution
+
+## Description
+
+This sample demonstrates how 2D convolutions with very large kernel sizes can be efficiently implemented using FFT transformations.
+
+## Key Concepts
+
+Image Processing, CUFFT Library
+
+## 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, ppc64le, armv7l
+
+## CUDA APIs involved
+
+### [CUDA Runtime API](http://docs.nvidia.com/cuda/cuda-runtime-api/index.html)
+cufftPlan2d, cufftExecR2C, cufftExecC2R, cufftDestroy
+
+## Dependencies needed to build/run
+[CUFFT](../../README.md#cufft)
+
+## 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, ppc64le, armv7l.
+    By default, TARGET_ARCH is set to HOST_ARCH. On a x86_64 machine, not setting TARGET_ARCH is the equivalent of setting TARGET_ARCH=x86_64.<br/>
+`$ make TARGET_ARCH=x86_64` <br/> `$ make TARGET_ARCH=ppc64le` <br/> `$ make TARGET_ARCH=armv7l` <br/>
+    See [here](http://docs.nvidia.com/cuda/cuda-samples/index.html#cross-samples) for more details.
+*   **dbg=1** - build with debug symbols
+    ```
+    $ make dbg=1
+    ```
+*   **SMS="A B ..."** - override the SM architectures for which the sample will be built, where `"A B ..."` is a space-delimited list of SM architectures. For example, to generate SASS for SM 50 and SM 60, use `SMS="50 60"`.
+    ```
+    $ make SMS="50 60"
+    ```
+
+*  **HOST_COMPILER=<host_compiler>** - override the default g++ host compiler. See the [Linux Installation Guide](http://docs.nvidia.com/cuda/cuda-installation-guide-linux/index.html#system-requirements) for a list of supported host compilers.
+```
+    $ make HOST_COMPILER=g++
+```
+
+## References (for more details)
+
--- a/Samples/convolutionFFT2D/convolutionFFT2D.cu
+++ b/Samples/convolutionFFT2D/convolutionFFT2D.cu
@@ -0,0 +1,319 @@
+/* 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.
+ */
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <helper_cuda.h>
+#include "convolutionFFT2D_common.h"
+#include "convolutionFFT2D.cuh"
+
+////////////////////////////////////////////////////////////////////////////////
+/// Position convolution kernel center at (0, 0) in the image
+////////////////////////////////////////////////////////////////////////////////
+extern "C" void padKernel(float *d_Dst, float *d_Src, int fftH, int fftW,
+                          int kernelH, int kernelW, int kernelY, int kernelX) {
+  assert(d_Src != d_Dst);
+  dim3 threads(32, 8);
+  dim3 grid(iDivUp(kernelW, threads.x), iDivUp(kernelH, threads.y));
+
+  SET_FLOAT_BASE;
+#if (USE_TEXTURE)
+  cudaTextureObject_t texFloat;
+  cudaResourceDesc texRes;
+  memset(&texRes, 0, sizeof(cudaResourceDesc));
+
+  texRes.resType = cudaResourceTypeLinear;
+  texRes.res.linear.devPtr = d_Src;
+  texRes.res.linear.sizeInBytes = sizeof(float) * kernelH * kernelW;
+  texRes.res.linear.desc = cudaCreateChannelDesc<float>();
+
+  cudaTextureDesc texDescr;
+  memset(&texDescr, 0, sizeof(cudaTextureDesc));
+
+  texDescr.normalizedCoords = false;
+  texDescr.filterMode = cudaFilterModeLinear;
+  texDescr.addressMode[0] = cudaAddressModeWrap;
+  texDescr.readMode = cudaReadModeElementType;
+
+  checkCudaErrors(cudaCreateTextureObject(&texFloat, &texRes, &texDescr, NULL));
+#endif
+
+  padKernel_kernel<<<grid, threads>>>(d_Dst, d_Src, fftH, fftW, kernelH,
+                                      kernelW, kernelY, kernelX
+#if (USE_TEXTURE)
+                                      ,
+                                      texFloat
+#endif
+                                      );
+  getLastCudaError("padKernel_kernel<<<>>> execution failed\n");
+
+#if (USE_TEXTURE)
+  checkCudaErrors(cudaDestroyTextureObject(texFloat));
+#endif
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Prepare data for "pad to border" addressing mode
+////////////////////////////////////////////////////////////////////////////////
+extern "C" void padDataClampToBorder(float *d_Dst, float *d_Src, int fftH,
+                                     int fftW, int dataH, int dataW,
+                                     int kernelW, int kernelH, int kernelY,
+                                     int kernelX) {
+  assert(d_Src != d_Dst);
+  dim3 threads(32, 8);
+  dim3 grid(iDivUp(fftW, threads.x), iDivUp(fftH, threads.y));
+
+#if (USE_TEXTURE)
+  cudaTextureObject_t texFloat;
+  cudaResourceDesc texRes;
+  memset(&texRes, 0, sizeof(cudaResourceDesc));
+
+  texRes.resType = cudaResourceTypeLinear;
+  texRes.res.linear.devPtr = d_Src;
+  texRes.res.linear.sizeInBytes = sizeof(float) * dataH * dataW;
+  texRes.res.linear.desc = cudaCreateChannelDesc<float>();
+
+  cudaTextureDesc texDescr;
+  memset(&texDescr, 0, sizeof(cudaTextureDesc));
+
+  texDescr.normalizedCoords = false;
+  texDescr.filterMode = cudaFilterModeLinear;
+  texDescr.addressMode[0] = cudaAddressModeWrap;
+  texDescr.readMode = cudaReadModeElementType;
+
+  checkCudaErrors(cudaCreateTextureObject(&texFloat, &texRes, &texDescr, NULL));
+#endif
+
+  padDataClampToBorder_kernel<<<grid, threads>>>(
+      d_Dst, d_Src, fftH, fftW, dataH, dataW, kernelH, kernelW, kernelY, kernelX
+#if (USE_TEXTURE)
+      ,
+      texFloat
+#endif
+      );
+  getLastCudaError("padDataClampToBorder_kernel<<<>>> execution failed\n");
+
+#if (USE_TEXTURE)
+  checkCudaErrors(cudaDestroyTextureObject(texFloat));
+#endif
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Modulate Fourier image of padded data by Fourier image of padded kernel
+// and normalize by FFT size
+////////////////////////////////////////////////////////////////////////////////
+extern "C" void modulateAndNormalize(fComplex *d_Dst, fComplex *d_Src, int fftH,
+                                     int fftW, int padding) {
+  assert(fftW % 2 == 0);
+  const int dataSize = fftH * (fftW / 2 + padding);
+
+  modulateAndNormalize_kernel<<<iDivUp(dataSize, 256), 256>>>(
+      d_Dst, d_Src, dataSize, 1.0f / (float)(fftW * fftH));
+  getLastCudaError("modulateAndNormalize() execution failed\n");
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// 2D R2C / C2R post/preprocessing kernels
+////////////////////////////////////////////////////////////////////////////////
+static const double PI = 3.1415926535897932384626433832795;
+static const uint BLOCKDIM = 256;
+
+extern "C" void spPostprocess2D(void *d_Dst, void *d_Src, uint DY, uint DX,
+                                uint padding, int dir) {
+  assert(d_Src != d_Dst);
+  assert(DX % 2 == 0);
+
+#if (POWER_OF_TWO)
+  uint log2DX, log2DY;
+  uint factorizationRemX = factorRadix2(log2DX, DX);
+  uint factorizationRemY = factorRadix2(log2DY, DY);
+  assert(factorizationRemX == 1 && factorizationRemY == 1);
+#endif
+
+  const uint threadCount = DY * (DX / 2);
+  const double phaseBase = dir * PI / (double)DX;
+
+#if (USE_TEXTURE)
+  cudaTextureObject_t texComplex;
+  cudaResourceDesc texRes;
+  memset(&texRes, 0, sizeof(cudaResourceDesc));
+
+  texRes.resType = cudaResourceTypeLinear;
+  texRes.res.linear.devPtr = d_Src;
+  texRes.res.linear.sizeInBytes = sizeof(fComplex) * DY * (DX + padding);
+  texRes.res.linear.desc = cudaCreateChannelDesc<fComplex>();
+
+  cudaTextureDesc texDescr;
+  memset(&texDescr, 0, sizeof(cudaTextureDesc));
+
+  texDescr.normalizedCoords = false;
+  texDescr.filterMode = cudaFilterModeLinear;
+  texDescr.addressMode[0] = cudaAddressModeWrap;
+  texDescr.readMode = cudaReadModeElementType;
+
+  checkCudaErrors(
+      cudaCreateTextureObject(&texComplex, &texRes, &texDescr, NULL));
+#endif
+
+  spPostprocess2D_kernel<<<iDivUp(threadCount, BLOCKDIM), BLOCKDIM>>>(
+      (fComplex *)d_Dst, (fComplex *)d_Src, DY, DX, threadCount, padding,
+      (float)phaseBase
+#if (USE_TEXTURE)
+      ,
+      texComplex
+#endif
+      );
+  getLastCudaError("spPostprocess2D_kernel<<<>>> execution failed\n");
+
+#if (USE_TEXTURE)
+  checkCudaErrors(cudaDestroyTextureObject(texComplex));
+#endif
+}
+
+extern "C" void spPreprocess2D(void *d_Dst, void *d_Src, uint DY, uint DX,
+                               uint padding, int dir) {
+  assert(d_Src != d_Dst);
+  assert(DX % 2 == 0);
+
+#if (POWER_OF_TWO)
+  uint log2DX, log2DY;
+  uint factorizationRemX = factorRadix2(log2DX, DX);
+  uint factorizationRemY = factorRadix2(log2DY, DY);
+  assert(factorizationRemX == 1 && factorizationRemY == 1);
+#endif
+
+  const uint threadCount = DY * (DX / 2);
+  const double phaseBase = -dir * PI / (double)DX;
+
+#if (USE_TEXTURE)
+  cudaTextureObject_t texComplex;
+  cudaResourceDesc texRes;
+  memset(&texRes, 0, sizeof(cudaResourceDesc));
+
+  texRes.resType = cudaResourceTypeLinear;
+  texRes.res.linear.devPtr = d_Src;
+  texRes.res.linear.sizeInBytes = sizeof(fComplex) * DY * (DX + padding);
+  texRes.res.linear.desc = cudaCreateChannelDesc<fComplex>();
+
+  cudaTextureDesc texDescr;
+  memset(&texDescr, 0, sizeof(cudaTextureDesc));
+
+  texDescr.normalizedCoords = false;
+  texDescr.filterMode = cudaFilterModeLinear;
+  texDescr.addressMode[0] = cudaAddressModeWrap;
+  texDescr.readMode = cudaReadModeElementType;
+
+  checkCudaErrors(
+      cudaCreateTextureObject(&texComplex, &texRes, &texDescr, NULL));
+#endif
+  spPreprocess2D_kernel<<<iDivUp(threadCount, BLOCKDIM), BLOCKDIM>>>(
+      (fComplex *)d_Dst, (fComplex *)d_Src, DY, DX, threadCount, padding,
+      (float)phaseBase
+#if (USE_TEXTURE)
+      ,
+      texComplex
+#endif
+      );
+  getLastCudaError("spPreprocess2D_kernel<<<>>> execution failed\n");
+
+#if (USE_TEXTURE)
+  checkCudaErrors(cudaDestroyTextureObject(texComplex));
+#endif
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Combined spPostprocess2D + modulateAndNormalize + spPreprocess2D
+////////////////////////////////////////////////////////////////////////////////
+extern "C" void spProcess2D(void *d_Dst, void *d_SrcA, void *d_SrcB, uint DY,
+                            uint DX, int dir) {
+  assert(DY % 2 == 0);
+
+#if (POWER_OF_TWO)
+  uint log2DX, log2DY;
+  uint factorizationRemX = factorRadix2(log2DX, DX);
+  uint factorizationRemY = factorRadix2(log2DY, DY);
+  assert(factorizationRemX == 1 && factorizationRemY == 1);
+#endif
+
+  const uint threadCount = (DY / 2) * DX;
+  const double phaseBase = dir * PI / (double)DX;
+
+#if (USE_TEXTURE)
+  cudaTextureObject_t texComplexA, texComplexB;
+  cudaResourceDesc texRes;
+  memset(&texRes, 0, sizeof(cudaResourceDesc));
+
+  texRes.resType = cudaResourceTypeLinear;
+  texRes.res.linear.devPtr = d_SrcA;
+  texRes.res.linear.sizeInBytes = sizeof(fComplex) * DY * DX;
+  texRes.res.linear.desc = cudaCreateChannelDesc<fComplex>();
+
+  cudaTextureDesc texDescr;
+  memset(&texDescr, 0, sizeof(cudaTextureDesc));
+
+  texDescr.normalizedCoords = false;
+  texDescr.filterMode = cudaFilterModeLinear;
+  texDescr.addressMode[0] = cudaAddressModeWrap;
+  texDescr.readMode = cudaReadModeElementType;
+
+  checkCudaErrors(
+      cudaCreateTextureObject(&texComplexA, &texRes, &texDescr, NULL));
+
+  memset(&texRes, 0, sizeof(cudaResourceDesc));
+
+  texRes.resType = cudaResourceTypeLinear;
+  texRes.res.linear.devPtr = d_SrcB;
+  texRes.res.linear.sizeInBytes = sizeof(fComplex) * DY * DX;
+  texRes.res.linear.desc = cudaCreateChannelDesc<fComplex>();
+
+  memset(&texDescr, 0, sizeof(cudaTextureDesc));
+
+  texDescr.normalizedCoords = false;
+  texDescr.filterMode = cudaFilterModeLinear;
+  texDescr.addressMode[0] = cudaAddressModeWrap;
+  texDescr.readMode = cudaReadModeElementType;
+
+  checkCudaErrors(
+      cudaCreateTextureObject(&texComplexB, &texRes, &texDescr, NULL));
+#endif
+  spProcess2D_kernel<<<iDivUp(threadCount, BLOCKDIM), BLOCKDIM>>>(
+      (fComplex *)d_Dst, (fComplex *)d_SrcA, (fComplex *)d_SrcB, DY, DX,
+      threadCount, (float)phaseBase, 0.5f / (float)(DY * DX)
+#if (USE_TEXTURE)
+                                         ,
+      texComplexA, texComplexB
+#endif
+      );
+  getLastCudaError("spProcess2D_kernel<<<>>> execution failed\n");
+
+#if (USE_TEXTURE)
+  checkCudaErrors(cudaDestroyTextureObject(texComplexA));
+  checkCudaErrors(cudaDestroyTextureObject(texComplexB));
+#endif
+}
--- a/Samples/convolutionFFT2D/convolutionFFT2D.cuh
+++ b/Samples/convolutionFFT2D/convolutionFFT2D.cuh
@@ -0,0 +1,421 @@
+/* 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.
+ */
+
+#define USE_TEXTURE 1
+#define POWER_OF_TWO 1
+
+#if (USE_TEXTURE)
+#define LOAD_FLOAT(i) tex1Dfetch<float>(texFloat, i)
+#define SET_FLOAT_BASE
+#else
+#define LOAD_FLOAT(i) d_Src[i]
+#define SET_FLOAT_BASE
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+/// Position convolution kernel center at (0, 0) in the image
+////////////////////////////////////////////////////////////////////////////////
+__global__ void padKernel_kernel(float *d_Dst, float *d_Src, int fftH, int fftW,
+                                 int kernelH, int kernelW, int kernelY,
+                                 int kernelX
+#if (USE_TEXTURE)
+                                 ,
+                                 cudaTextureObject_t texFloat
+#endif
+                                 ) {
+  const int y = blockDim.y * blockIdx.y + threadIdx.y;
+  const int x = blockDim.x * blockIdx.x + threadIdx.x;
+
+  if (y < kernelH && x < kernelW) {
+    int ky = y - kernelY;
+
+    if (ky < 0) {
+      ky += fftH;
+    }
+
+    int kx = x - kernelX;
+
+    if (kx < 0) {
+      kx += fftW;
+    }
+
+    d_Dst[ky * fftW + kx] = LOAD_FLOAT(y * kernelW + x);
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Prepare data for "pad to border" addressing mode
+////////////////////////////////////////////////////////////////////////////////
+__global__ void padDataClampToBorder_kernel(float *d_Dst, float *d_Src,
+                                            int fftH, int fftW, int dataH,
+                                            int dataW, int kernelH, int kernelW,
+                                            int kernelY, int kernelX
+#if (USE_TEXTURE)
+                                            ,
+                                            cudaTextureObject_t texFloat
+#endif
+                                            ) {
+  const int y = blockDim.y * blockIdx.y + threadIdx.y;
+  const int x = blockDim.x * blockIdx.x + threadIdx.x;
+  const int borderH = dataH + kernelY;
+  const int borderW = dataW + kernelX;
+
+  if (y < fftH && x < fftW) {
+    int dy, dx;
+
+    if (y < dataH) {
+      dy = y;
+    }
+
+    if (x < dataW) {
+      dx = x;
+    }
+
+    if (y >= dataH && y < borderH) {
+      dy = dataH - 1;
+    }
+
+    if (x >= dataW && x < borderW) {
+      dx = dataW - 1;
+    }
+
+    if (y >= borderH) {
+      dy = 0;
+    }
+
+    if (x >= borderW) {
+      dx = 0;
+    }
+
+    d_Dst[y * fftW + x] = LOAD_FLOAT(dy * dataW + dx);
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Modulate Fourier image of padded data by Fourier image of padded kernel
+// and normalize by FFT size
+////////////////////////////////////////////////////////////////////////////////
+inline __device__ void mulAndScale(fComplex &a, const fComplex &b,
+                                   const float &c) {
+  fComplex t = {c * (a.x * b.x - a.y * b.y), c * (a.y * b.x + a.x * b.y)};
+  a = t;
+}
+
+__global__ void modulateAndNormalize_kernel(fComplex *d_Dst, fComplex *d_Src,
+                                            int dataSize, float c) {
+  const int i = blockDim.x * blockIdx.x + threadIdx.x;
+
+  if (i >= dataSize) {
+    return;
+  }
+
+  fComplex a = d_Src[i];
+  fComplex b = d_Dst[i];
+
+  mulAndScale(a, b, c);
+
+  d_Dst[i] = a;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// 2D R2C / C2R post/preprocessing kernels
+////////////////////////////////////////////////////////////////////////////////
+#if (USE_TEXTURE)
+#define LOAD_FCOMPLEX(i) tex1Dfetch<fComplex>(texComplex, i)
+#define LOAD_FCOMPLEX_A(i) tex1Dfetch<fComplex>(texComplexA, i)
+#define LOAD_FCOMPLEX_B(i) tex1Dfetch<fComplex>(texComplexB, i)
+
+#define SET_FCOMPLEX_BASE
+#define SET_FCOMPLEX_BASE_A
+#define SET_FCOMPLEX_BASE_B
+#else
+#define LOAD_FCOMPLEX(i) d_Src[i]
+#define LOAD_FCOMPLEX_A(i) d_SrcA[i]
+#define LOAD_FCOMPLEX_B(i) d_SrcB[i]
+
+#define SET_FCOMPLEX_BASE
+#define SET_FCOMPLEX_BASE_A
+#define SET_FCOMPLEX_BASE_B
+#endif
+
+inline __device__ void spPostprocessC2C(fComplex &D1, fComplex &D2,
+                                        const fComplex &twiddle) {
+  float A1 = 0.5f * (D1.x + D2.x);
+  float B1 = 0.5f * (D1.y - D2.y);
+  float A2 = 0.5f * (D1.y + D2.y);
+  float B2 = 0.5f * (D1.x - D2.x);
+
+  D1.x = A1 + (A2 * twiddle.x + B2 * twiddle.y);
+  D1.y = (A2 * twiddle.y - B2 * twiddle.x) + B1;
+  D2.x = A1 - (A2 * twiddle.x + B2 * twiddle.y);
+  D2.y = (A2 * twiddle.y - B2 * twiddle.x) - B1;
+}
+
+// Premultiply by 2 to account for 1.0 / (DZ * DY * DX) normalization
+inline __device__ void spPreprocessC2C(fComplex &D1, fComplex &D2,
+                                       const fComplex &twiddle) {
+  float A1 = /* 0.5f * */ (D1.x + D2.x);
+  float B1 = /* 0.5f * */ (D1.y - D2.y);
+  float A2 = /* 0.5f * */ (D1.y + D2.y);
+  float B2 = /* 0.5f * */ (D1.x - D2.x);
+
+  D1.x = A1 - (A2 * twiddle.x - B2 * twiddle.y);
+  D1.y = (B2 * twiddle.x + A2 * twiddle.y) + B1;
+  D2.x = A1 + (A2 * twiddle.x - B2 * twiddle.y);
+  D2.y = (B2 * twiddle.x + A2 * twiddle.y) - B1;
+}
+
+inline __device__ void getTwiddle(fComplex &twiddle, float phase) {
+  __sincosf(phase, &twiddle.y, &twiddle.x);
+}
+
+inline __device__ uint mod(uint a, uint DA) {
+  //(DA - a) % DA, assuming a <= DA
+  return a ? (DA - a) : a;
+}
+
+static inline uint factorRadix2(uint &log2N, uint n) {
+  if (!n) {
+    log2N = 0;
+    return 0;
+  } else {
+    for (log2N = 0; n % 2 == 0; n /= 2, log2N++)
+      ;
+
+    return n;
+  }
+}
+
+inline __device__ void udivmod(uint &dividend, uint divisor, uint &rem) {
+#if (!POWER_OF_TWO)
+  rem = dividend % divisor;
+  dividend /= divisor;
+#else
+  rem = dividend & (divisor - 1);
+  dividend >>= (__ffs(divisor) - 1);
+#endif
+}
+
+__global__ void spPostprocess2D_kernel(fComplex *d_Dst, fComplex *d_Src,
+                                       uint DY, uint DX, uint threadCount,
+                                       uint padding, float phaseBase
+#if (USE_TEXTURE)
+                                       ,
+                                       cudaTextureObject_t texComplex
+#endif
+                                       ) {
+  const uint threadId = blockIdx.x * blockDim.x + threadIdx.x;
+
+  if (threadId >= threadCount) {
+    return;
+  }
+
+  uint x, y, i = threadId;
+  udivmod(i, DX / 2, x);
+  udivmod(i, DY, y);
+
+  // Avoid overwrites in columns DX / 2 by different threads
+  if ((x == 0) && (y > DY / 2)) {
+    return;
+  }
+
+  const uint srcOffset = i * DY * DX;
+  const uint dstOffset = i * DY * (DX + padding);
+
+  // Process x = [0 .. DX / 2 - 1] U [DX / 2 + 1 .. DX]
+  {
+    const uint loadPos1 = srcOffset + y * DX + x;
+    const uint loadPos2 = srcOffset + mod(y, DY) * DX + mod(x, DX);
+    const uint storePos1 = dstOffset + y * (DX + padding) + x;
+    const uint storePos2 = dstOffset + mod(y, DY) * (DX + padding) + (DX - x);
+
+    fComplex D1 = LOAD_FCOMPLEX(loadPos1);
+    fComplex D2 = LOAD_FCOMPLEX(loadPos2);
+
+    fComplex twiddle;
+    getTwiddle(twiddle, phaseBase * (float)x);
+    spPostprocessC2C(D1, D2, twiddle);
+
+    d_Dst[storePos1] = D1;
+    d_Dst[storePos2] = D2;
+  }
+
+  // Process x = DX / 2
+  if (x == 0) {
+    const uint loadPos1 = srcOffset + y * DX + DX / 2;
+    const uint loadPos2 = srcOffset + mod(y, DY) * DX + DX / 2;
+    const uint storePos1 = dstOffset + y * (DX + padding) + DX / 2;
+    const uint storePos2 = dstOffset + mod(y, DY) * (DX + padding) + DX / 2;
+
+    fComplex D1 = LOAD_FCOMPLEX(loadPos1);
+    fComplex D2 = LOAD_FCOMPLEX(loadPos2);
+
+    // twiddle = getTwiddle(phaseBase * (DX / 2)) = exp(dir * j * PI / 2)
+    fComplex twiddle = {0, (phaseBase > 0) ? 1.0f : -1.0f};
+    spPostprocessC2C(D1, D2, twiddle);
+
+    d_Dst[storePos1] = D1;
+    d_Dst[storePos2] = D2;
+  }
+}
+
+__global__ void spPreprocess2D_kernel(fComplex *d_Dst, fComplex *d_Src, uint DY,
+                                      uint DX, uint threadCount, uint padding,
+                                      float phaseBase
+#if (USE_TEXTURE)
+                                      ,
+                                      cudaTextureObject_t texComplex
+#endif
+                                      ) {
+  const uint threadId = blockIdx.x * blockDim.x + threadIdx.x;
+
+  if (threadId >= threadCount) {
+    return;
+  }
+
+  uint x, y, i = threadId;
+  udivmod(i, DX / 2, x);
+  udivmod(i, DY, y);
+
+  // Avoid overwrites in columns 0 and DX / 2 by different threads (lower and
+  // upper halves)
+  if ((x == 0) && (y > DY / 2)) {
+    return;
+  }
+
+  const uint srcOffset = i * DY * (DX + padding);
+  const uint dstOffset = i * DY * DX;
+
+  // Process x = [0 .. DX / 2 - 1] U [DX / 2 + 1 .. DX]
+  {
+    const uint loadPos1 = srcOffset + y * (DX + padding) + x;
+    const uint loadPos2 = srcOffset + mod(y, DY) * (DX + padding) + (DX - x);
+    const uint storePos1 = dstOffset + y * DX + x;
+    const uint storePos2 = dstOffset + mod(y, DY) * DX + mod(x, DX);
+
+    fComplex D1 = LOAD_FCOMPLEX(loadPos1);
+    fComplex D2 = LOAD_FCOMPLEX(loadPos2);
+
+    fComplex twiddle;
+    getTwiddle(twiddle, phaseBase * (float)x);
+    spPreprocessC2C(D1, D2, twiddle);
+
+    d_Dst[storePos1] = D1;
+    d_Dst[storePos2] = D2;
+  }
+
+  // Process x = DX / 2
+  if (x == 0) {
+    const uint loadPos1 = srcOffset + y * (DX + padding) + DX / 2;
+    const uint loadPos2 = srcOffset + mod(y, DY) * (DX + padding) + DX / 2;
+    const uint storePos1 = dstOffset + y * DX + DX / 2;
+    const uint storePos2 = dstOffset + mod(y, DY) * DX + DX / 2;
+
+    fComplex D1 = LOAD_FCOMPLEX(loadPos1);
+    fComplex D2 = LOAD_FCOMPLEX(loadPos2);
+
+    // twiddle = getTwiddle(phaseBase * (DX / 2)) = exp(-dir * j * PI / 2)
+    fComplex twiddle = {0, (phaseBase > 0) ? 1.0f : -1.0f};
+    spPreprocessC2C(D1, D2, twiddle);
+
+    d_Dst[storePos1] = D1;
+    d_Dst[storePos2] = D2;
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Combined spPostprocess2D + modulateAndNormalize + spPreprocess2D
+////////////////////////////////////////////////////////////////////////////////
+__global__ void spProcess2D_kernel(fComplex *d_Dst, fComplex *d_SrcA,
+                                   fComplex *d_SrcB, uint DY, uint DX,
+                                   uint threadCount, float phaseBase, float c
+#if (USE_TEXTURE)
+                                   ,
+                                   cudaTextureObject_t texComplexA,
+                                   cudaTextureObject_t texComplexB
+#endif
+                                   ) {
+  const uint threadId = blockIdx.x * blockDim.x + threadIdx.x;
+
+  if (threadId >= threadCount) {
+    return;
+  }
+
+  uint x, y, i = threadId;
+  udivmod(i, DX, x);
+  udivmod(i, DY / 2, y);
+
+  const uint offset = i * DY * DX;
+
+  // Avoid overwrites in rows 0 and DY / 2 by different threads (left and right
+  // halves) Otherwise correctness for in-place transformations is affected
+  if ((y == 0) && (x > DX / 2)) {
+    return;
+  }
+
+  fComplex twiddle;
+
+  // Process y = [0 .. DY / 2 - 1] U [DY - (DY / 2) + 1 .. DY - 1]
+  {
+    const uint pos1 = offset + y * DX + x;
+    const uint pos2 = offset + mod(y, DY) * DX + mod(x, DX);
+
+    fComplex D1 = LOAD_FCOMPLEX_A(pos1);
+    fComplex D2 = LOAD_FCOMPLEX_A(pos2);
+    fComplex K1 = LOAD_FCOMPLEX_B(pos1);
+    fComplex K2 = LOAD_FCOMPLEX_B(pos2);
+    getTwiddle(twiddle, phaseBase * (float)x);
+
+    spPostprocessC2C(D1, D2, twiddle);
+    spPostprocessC2C(K1, K2, twiddle);
+    mulAndScale(D1, K1, c);
+    mulAndScale(D2, K2, c);
+    spPreprocessC2C(D1, D2, twiddle);
+
+    d_Dst[pos1] = D1;
+    d_Dst[pos2] = D2;
+  }
+
+  if (y == 0) {
+    const uint pos1 = offset + (DY / 2) * DX + x;
+    const uint pos2 = offset + (DY / 2) * DX + mod(x, DX);
+
+    fComplex D1 = LOAD_FCOMPLEX_A(pos1);
+    fComplex D2 = LOAD_FCOMPLEX_A(pos2);
+    fComplex K1 = LOAD_FCOMPLEX_B(pos1);
+    fComplex K2 = LOAD_FCOMPLEX_B(pos2);
+
+    spPostprocessC2C(D1, D2, twiddle);
+    spPostprocessC2C(K1, K2, twiddle);
+    mulAndScale(D1, K1, c);
+    mulAndScale(D2, K2, c);
+    spPreprocessC2C(D1, D2, twiddle);
+
+    d_Dst[pos1] = D1;
+    d_Dst[pos2] = D2;
+  }
+}
--- a/Samples/convolutionFFT2D/convolutionFFT2D_common.h
+++ b/Samples/convolutionFFT2D/convolutionFFT2D_common.h
@@ -0,0 +1,77 @@
+/* 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 CONVOLUTIONFFT2D_COMMON_H
+#define CONVOLUTIONFFT2D_COMMON_H
+
+typedef unsigned int uint;
+
+#ifdef __CUDACC__
+typedef float2 fComplex;
+#else
+typedef struct {
+  float x;
+  float y;
+} fComplex;
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// Helper functions
+////////////////////////////////////////////////////////////////////////////////
+// Round a / b to nearest higher integer value
+inline int iDivUp(int a, int b) { return (a % b != 0) ? (a / b + 1) : (a / b); }
+
+// Align a to nearest higher multiple of b
+inline int iAlignUp(int a, int b) { return (a % b != 0) ? (a - a % b + b) : a; }
+
+extern "C" void convolutionClampToBorderCPU(float *h_Result, float *h_Data,
+                                            float *h_Kernel, int dataH,
+                                            int dataW, int kernelH, int kernelW,
+                                            int kernelY, int kernelX);
+
+extern "C" void padKernel(float *d_PaddedKernel, float *d_Kernel, int fftH,
+                          int fftW, int kernelH, int kernelW, int kernelY,
+                          int kernelX);
+
+extern "C" void padDataClampToBorder(float *d_PaddedData, float *d_Data,
+                                     int fftH, int fftW, int dataH, int dataW,
+                                     int kernelH, int kernelW, int kernelY,
+                                     int kernelX);
+
+extern "C" void modulateAndNormalize(fComplex *d_Dst, fComplex *d_Src, int fftH,
+                                     int fftW, int padding);
+
+extern "C" void spPostprocess2D(void *d_Dst, void *d_Src, uint DY, uint DX,
+                                uint padding, int dir);
+
+extern "C" void spPreprocess2D(void *d_Dst, void *d_Src, uint DY, uint DX,
+                               uint padding, int dir);
+
+extern "C" void spProcess2D(void *d_Data, void *d_Data0, void *d_Kernel0,
+                            uint DY, uint DX, int dir);
+
+#endif  // CONVOLUTIONFFT2D_COMMON_H
--- a/Samples/convolutionFFT2D/convolutionFFT2D_gold.cpp
+++ b/Samples/convolutionFFT2D/convolutionFFT2D_gold.cpp
@@ -0,0 +1,61 @@
+/* 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.
+ */
+
+#include <assert.h>
+#include "convolutionFFT2D_common.h"
+
+////////////////////////////////////////////////////////////////////////////////
+// Reference straightforward CPU convolution
+////////////////////////////////////////////////////////////////////////////////
+extern "C" void convolutionClampToBorderCPU(float *h_Result, float *h_Data,
+                                            float *h_Kernel, int dataH,
+                                            int dataW, int kernelH, int kernelW,
+                                            int kernelY, int kernelX) {
+  for (int y = 0; y < dataH; y++)
+    for (int x = 0; x < dataW; x++) {
+      double sum = 0;
+
+      for (int ky = -(kernelH - kernelY - 1); ky <= kernelY; ky++)
+        for (int kx = -(kernelW - kernelX - 1); kx <= kernelX; kx++) {
+          int dy = y + ky;
+          int dx = x + kx;
+
+          if (dy < 0) dy = 0;
+
+          if (dx < 0) dx = 0;
+
+          if (dy >= dataH) dy = dataH - 1;
+
+          if (dx >= dataW) dx = dataW - 1;
+
+          sum += h_Data[dy * dataW + dx] *
+                 h_Kernel[(kernelY - ky) * kernelW + (kernelX - kx)];
+        }
+
+      h_Result[y * dataW + x] = (float)sum;
+    }
+}
--- a/Samples/convolutionFFT2D/convolutionFFT2D_vs2017.sln
+++ b/Samples/convolutionFFT2D/convolutionFFT2D_vs2017.sln
@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2017
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "convolutionFFT2D", "convolutionFFT2D_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/convolutionFFT2D/convolutionFFT2D_vs2017.vcxproj
+++ b/Samples/convolutionFFT2D/convolutionFFT2D_vs2017.vcxproj
@@ -0,0 +1,116 @@
+<?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>convolutionFFT2D_vs2017</RootNamespace>
+    <ProjectName>convolutionFFT2D</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;$(CudaToolkitIncludeDir);</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <AdditionalDependencies>cufft.lib;cudart_static.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>$(CudaToolkitLibDir);</AdditionalLibraryDirectories>
+      <OutputFile>$(OutDir)/convolutionFFT2D.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>
+  <ItemGroup>
+    <CudaCompile Include="convolutionFFT2D.cu" />
+    <ClCompile Include="convolutionFFT2D_gold.cpp" />
+    <ClCompile Include="main.cpp" />
+    <ClInclude Include="convolutionFFT2D_common.h" />
+    <None Include="convolutionFFT2D.cuh" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.5.targets" />
+  </ImportGroup>
+</Project>
--- a/Samples/convolutionFFT2D/convolutionFFT2D_vs2019.sln
+++ b/Samples/convolutionFFT2D/convolutionFFT2D_vs2019.sln
@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2019
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "convolutionFFT2D", "convolutionFFT2D_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/convolutionFFT2D/convolutionFFT2D_vs2019.vcxproj
+++ b/Samples/convolutionFFT2D/convolutionFFT2D_vs2019.vcxproj
@@ -0,0 +1,112 @@
+<?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>convolutionFFT2D_vs2019</RootNamespace>
+    <ProjectName>convolutionFFT2D</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;$(CudaToolkitIncludeDir);</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <AdditionalDependencies>cufft.lib;cudart_static.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>$(CudaToolkitLibDir);</AdditionalLibraryDirectories>
+      <OutputFile>$(OutDir)/convolutionFFT2D.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>
+  <ItemGroup>
+    <CudaCompile Include="convolutionFFT2D.cu" />
+    <ClCompile Include="convolutionFFT2D_gold.cpp" />
+    <ClCompile Include="main.cpp" />
+    <ClInclude Include="convolutionFFT2D_common.h" />
+    <None Include="convolutionFFT2D.cuh" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.5.targets" />
+  </ImportGroup>
+</Project>
--- a/Samples/convolutionFFT2D/main.cpp
+++ b/Samples/convolutionFFT2D/main.cpp
@@ -0,0 +1,586 @@
+/* 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.
+ */
+
+/*
+ * This sample demonstrates how 2D convolutions
+ * with very large kernel sizes
+ * can be efficiently implemented
+ * using FFT transformations.
+ */
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+// Include CUDA runtime and CUFFT
+#include <cuda_runtime.h>
+#include <cufft.h>
+
+// Helper functions for CUDA
+#include <helper_functions.h>
+#include <helper_cuda.h>
+
+#include "convolutionFFT2D_common.h"
+
+////////////////////////////////////////////////////////////////////////////////
+// Helper functions
+////////////////////////////////////////////////////////////////////////////////
+int snapTransformSize(int dataSize) {
+  int hiBit;
+  unsigned int lowPOT, hiPOT;
+
+  dataSize = iAlignUp(dataSize, 16);
+
+  for (hiBit = 31; hiBit >= 0; hiBit--)
+    if (dataSize & (1U << hiBit)) {
+      break;
+    }
+
+  lowPOT = 1U << hiBit;
+
+  if (lowPOT == (unsigned int)dataSize) {
+    return dataSize;
+  }
+
+  hiPOT = 1U << (hiBit + 1);
+
+  if (hiPOT <= 1024) {
+    return hiPOT;
+  } else {
+    return iAlignUp(dataSize, 512);
+  }
+}
+
+float getRand(void) { return (float)(rand() % 16); }
+
+bool test0(void) {
+  float *h_Data, *h_Kernel, *h_ResultCPU, *h_ResultGPU;
+
+  float *d_Data, *d_PaddedData, *d_Kernel, *d_PaddedKernel;
+
+  fComplex *d_DataSpectrum, *d_KernelSpectrum;
+
+  cufftHandle fftPlanFwd, fftPlanInv;
+
+  bool bRetVal;
+  StopWatchInterface *hTimer = NULL;
+  sdkCreateTimer(&hTimer);
+
+  printf("Testing built-in R2C / C2R FFT-based convolution\n");
+  const int kernelH = 7;
+  const int kernelW = 6;
+  const int kernelY = 3;
+  const int kernelX = 4;
+  const int dataH = 2000;
+  const int dataW = 2000;
+  const int fftH = snapTransformSize(dataH + kernelH - 1);
+  const int fftW = snapTransformSize(dataW + kernelW - 1);
+
+  printf("...allocating memory\n");
+  h_Data = (float *)malloc(dataH * dataW * sizeof(float));
+  h_Kernel = (float *)malloc(kernelH * kernelW * sizeof(float));
+  h_ResultCPU = (float *)malloc(dataH * dataW * sizeof(float));
+  h_ResultGPU = (float *)malloc(fftH * fftW * sizeof(float));
+
+  checkCudaErrors(cudaMalloc((void **)&d_Data, dataH * dataW * sizeof(float)));
+  checkCudaErrors(
+      cudaMalloc((void **)&d_Kernel, kernelH * kernelW * sizeof(float)));
+
+  checkCudaErrors(
+      cudaMalloc((void **)&d_PaddedData, fftH * fftW * sizeof(float)));
+  checkCudaErrors(
+      cudaMalloc((void **)&d_PaddedKernel, fftH * fftW * sizeof(float)));
+
+  checkCudaErrors(cudaMalloc((void **)&d_DataSpectrum,
+                             fftH * (fftW / 2 + 1) * sizeof(fComplex)));
+  checkCudaErrors(cudaMalloc((void **)&d_KernelSpectrum,
+                             fftH * (fftW / 2 + 1) * sizeof(fComplex)));
+  checkCudaErrors(cudaMemset(d_KernelSpectrum, 0,
+                             fftH * (fftW / 2 + 1) * sizeof(fComplex)));
+
+  printf("...generating random input data\n");
+  srand(2010);
+
+  for (int i = 0; i < dataH * dataW; i++) {
+    h_Data[i] = getRand();
+  }
+
+  for (int i = 0; i < kernelH * kernelW; i++) {
+    h_Kernel[i] = getRand();
+  }
+
+  printf("...creating R2C & C2R FFT plans for %i x %i\n", fftH, fftW);
+  checkCudaErrors(cufftPlan2d(&fftPlanFwd, fftH, fftW, CUFFT_R2C));
+  checkCudaErrors(cufftPlan2d(&fftPlanInv, fftH, fftW, CUFFT_C2R));
+
+  printf("...uploading to GPU and padding convolution kernel and input data\n");
+  checkCudaErrors(cudaMemcpy(d_Kernel, h_Kernel,
+                             kernelH * kernelW * sizeof(float),
+                             cudaMemcpyHostToDevice));
+  checkCudaErrors(cudaMemcpy(d_Data, h_Data, dataH * dataW * sizeof(float),
+                             cudaMemcpyHostToDevice));
+  checkCudaErrors(cudaMemset(d_PaddedKernel, 0, fftH * fftW * sizeof(float)));
+  checkCudaErrors(cudaMemset(d_PaddedData, 0, fftH * fftW * sizeof(float)));
+
+  padKernel(d_PaddedKernel, d_Kernel, fftH, fftW, kernelH, kernelW, kernelY,
+            kernelX);
+
+  padDataClampToBorder(d_PaddedData, d_Data, fftH, fftW, dataH, dataW, kernelH,
+                       kernelW, kernelY, kernelX);
+
+  // Not including kernel transformation into time measurement,
+  // since convolution kernel is not changed very frequently
+  printf("...transforming convolution kernel\n");
+  checkCudaErrors(cufftExecR2C(fftPlanFwd, (cufftReal *)d_PaddedKernel,
+                               (cufftComplex *)d_KernelSpectrum));
+
+  printf("...running GPU FFT convolution: ");
+  checkCudaErrors(cudaDeviceSynchronize());
+  sdkResetTimer(&hTimer);
+  sdkStartTimer(&hTimer);
+  checkCudaErrors(cufftExecR2C(fftPlanFwd, (cufftReal *)d_PaddedData,
+                               (cufftComplex *)d_DataSpectrum));
+  modulateAndNormalize(d_DataSpectrum, d_KernelSpectrum, fftH, fftW, 1);
+  checkCudaErrors(cufftExecC2R(fftPlanInv, (cufftComplex *)d_DataSpectrum,
+                               (cufftReal *)d_PaddedData));
+
+  checkCudaErrors(cudaDeviceSynchronize());
+  sdkStopTimer(&hTimer);
+  double gpuTime = sdkGetTimerValue(&hTimer);
+  printf("%f MPix/s (%f ms)\n",
+         (double)dataH * (double)dataW * 1e-6 / (gpuTime * 0.001), gpuTime);
+
+  printf("...reading back GPU convolution results\n");
+  checkCudaErrors(cudaMemcpy(h_ResultGPU, d_PaddedData,
+                             fftH * fftW * sizeof(float),
+                             cudaMemcpyDeviceToHost));
+
+  printf("...running reference CPU convolution\n");
+  convolutionClampToBorderCPU(h_ResultCPU, h_Data, h_Kernel, dataH, dataW,
+                              kernelH, kernelW, kernelY, kernelX);
+
+  printf("...comparing the results: ");
+  double sum_delta2 = 0;
+  double sum_ref2 = 0;
+  double max_delta_ref = 0;
+
+  for (int y = 0; y < dataH; y++)
+    for (int x = 0; x < dataW; x++) {
+      double rCPU = (double)h_ResultCPU[y * dataW + x];
+      double rGPU = (double)h_ResultGPU[y * fftW + x];
+      double delta = (rCPU - rGPU) * (rCPU - rGPU);
+      double ref = rCPU * rCPU + rCPU * rCPU;
+
+      if ((delta / ref) > max_delta_ref) {
+        max_delta_ref = delta / ref;
+      }
+
+      sum_delta2 += delta;
+      sum_ref2 += ref;
+    }
+
+  double L2norm = sqrt(sum_delta2 / sum_ref2);
+  printf("rel L2 = %E (max delta = %E)\n", L2norm, sqrt(max_delta_ref));
+  bRetVal = (L2norm < 1e-6) ? true : false;
+  printf(bRetVal ? "L2norm Error OK\n" : "L2norm Error too high!\n");
+
+  printf("...shutting down\n");
+  sdkDeleteTimer(&hTimer);
+
+  checkCudaErrors(cufftDestroy(fftPlanInv));
+  checkCudaErrors(cufftDestroy(fftPlanFwd));
+
+  checkCudaErrors(cudaFree(d_DataSpectrum));
+  checkCudaErrors(cudaFree(d_KernelSpectrum));
+  checkCudaErrors(cudaFree(d_PaddedData));
+  checkCudaErrors(cudaFree(d_PaddedKernel));
+  checkCudaErrors(cudaFree(d_Data));
+  checkCudaErrors(cudaFree(d_Kernel));
+
+  free(h_ResultGPU);
+  free(h_ResultCPU);
+  free(h_Data);
+  free(h_Kernel);
+
+  return bRetVal;
+}
+
+bool test1(void) {
+  float *h_Data, *h_Kernel, *h_ResultCPU, *h_ResultGPU;
+
+  float *d_Data, *d_Kernel, *d_PaddedData, *d_PaddedKernel;
+
+  fComplex *d_DataSpectrum0, *d_KernelSpectrum0, *d_DataSpectrum,
+      *d_KernelSpectrum;
+
+  cufftHandle fftPlan;
+
+  bool bRetVal;
+  StopWatchInterface *hTimer = NULL;
+  sdkCreateTimer(&hTimer);
+
+  printf("Testing custom R2C / C2R FFT-based convolution\n");
+  const uint fftPadding = 16;
+  const int kernelH = 7;
+  const int kernelW = 6;
+  const int kernelY = 3;
+  const int kernelX = 4;
+  const int dataH = 2000;
+  const int dataW = 2000;
+  const int fftH = snapTransformSize(dataH + kernelH - 1);
+  const int fftW = snapTransformSize(dataW + kernelW - 1);
+
+  printf("...allocating memory\n");
+  h_Data = (float *)malloc(dataH * dataW * sizeof(float));
+  h_Kernel = (float *)malloc(kernelH * kernelW * sizeof(float));
+  h_ResultCPU = (float *)malloc(dataH * dataW * sizeof(float));
+  h_ResultGPU = (float *)malloc(fftH * fftW * sizeof(float));
+
+  checkCudaErrors(cudaMalloc((void **)&d_Data, dataH * dataW * sizeof(float)));
+  checkCudaErrors(
+      cudaMalloc((void **)&d_Kernel, kernelH * kernelW * sizeof(float)));
+
+  checkCudaErrors(
+      cudaMalloc((void **)&d_PaddedData, fftH * fftW * sizeof(float)));
+  checkCudaErrors(
+      cudaMalloc((void **)&d_PaddedKernel, fftH * fftW * sizeof(float)));
+
+  checkCudaErrors(cudaMalloc((void **)&d_DataSpectrum0,
+                             fftH * (fftW / 2) * sizeof(fComplex)));
+  checkCudaErrors(cudaMalloc((void **)&d_KernelSpectrum0,
+                             fftH * (fftW / 2) * sizeof(fComplex)));
+  checkCudaErrors(
+      cudaMalloc((void **)&d_DataSpectrum,
+                 fftH * (fftW / 2 + fftPadding) * sizeof(fComplex)));
+  checkCudaErrors(
+      cudaMalloc((void **)&d_KernelSpectrum,
+                 fftH * (fftW / 2 + fftPadding) * sizeof(fComplex)));
+
+  printf("...generating random input data\n");
+  srand(2010);
+
+  for (int i = 0; i < dataH * dataW; i++) {
+    h_Data[i] = getRand();
+  }
+
+  for (int i = 0; i < kernelH * kernelW; i++) {
+    h_Kernel[i] = getRand();
+  }
+
+  printf("...creating C2C FFT plan for %i x %i\n", fftH, fftW / 2);
+  checkCudaErrors(cufftPlan2d(&fftPlan, fftH, fftW / 2, CUFFT_C2C));
+
+  printf("...uploading to GPU and padding convolution kernel and input data\n");
+  checkCudaErrors(cudaMemcpy(d_Data, h_Data, dataH * dataW * sizeof(float),
+                             cudaMemcpyHostToDevice));
+  checkCudaErrors(cudaMemcpy(d_Kernel, h_Kernel,
+                             kernelH * kernelW * sizeof(float),
+                             cudaMemcpyHostToDevice));
+  checkCudaErrors(cudaMemset(d_PaddedData, 0, fftH * fftW * sizeof(float)));
+  checkCudaErrors(cudaMemset(d_PaddedKernel, 0, fftH * fftW * sizeof(float)));
+
+  padDataClampToBorder(d_PaddedData, d_Data, fftH, fftW, dataH, dataW, kernelH,
+                       kernelW, kernelY, kernelX);
+
+  padKernel(d_PaddedKernel, d_Kernel, fftH, fftW, kernelH, kernelW, kernelY,
+            kernelX);
+
+  // CUFFT_INVERSE works just as well...
+  const int FFT_DIR = CUFFT_FORWARD;
+
+  // Not including kernel transformation into time measurement,
+  // since convolution kernel is not changed very frequently
+  printf("...transforming convolution kernel\n");
+  checkCudaErrors(cufftExecC2C(fftPlan, (cufftComplex *)d_PaddedKernel,
+                               (cufftComplex *)d_KernelSpectrum0, FFT_DIR));
+  spPostprocess2D(d_KernelSpectrum, d_KernelSpectrum0, fftH, fftW / 2,
+                  fftPadding, FFT_DIR);
+
+  printf("...running GPU FFT convolution: ");
+  checkCudaErrors(cudaDeviceSynchronize());
+  sdkResetTimer(&hTimer);
+  sdkStartTimer(&hTimer);
+
+  checkCudaErrors(cufftExecC2C(fftPlan, (cufftComplex *)d_PaddedData,
+                               (cufftComplex *)d_DataSpectrum0, FFT_DIR));
+
+  spPostprocess2D(d_DataSpectrum, d_DataSpectrum0, fftH, fftW / 2, fftPadding,
+                  FFT_DIR);
+  modulateAndNormalize(d_DataSpectrum, d_KernelSpectrum, fftH, fftW,
+                       fftPadding);
+  spPreprocess2D(d_DataSpectrum0, d_DataSpectrum, fftH, fftW / 2, fftPadding,
+                 -FFT_DIR);
+
+  checkCudaErrors(cufftExecC2C(fftPlan, (cufftComplex *)d_DataSpectrum0,
+                               (cufftComplex *)d_PaddedData, -FFT_DIR));
+
+  checkCudaErrors(cudaDeviceSynchronize());
+  sdkStopTimer(&hTimer);
+  double gpuTime = sdkGetTimerValue(&hTimer);
+  printf("%f MPix/s (%f ms)\n",
+         (double)dataH * (double)dataW * 1e-6 / (gpuTime * 0.001), gpuTime);
+
+  printf("...reading back GPU FFT results\n");
+  checkCudaErrors(cudaMemcpy(h_ResultGPU, d_PaddedData,
+                             fftH * fftW * sizeof(float),
+                             cudaMemcpyDeviceToHost));
+
+  printf("...running reference CPU convolution\n");
+  convolutionClampToBorderCPU(h_ResultCPU, h_Data, h_Kernel, dataH, dataW,
+                              kernelH, kernelW, kernelY, kernelX);
+
+  printf("...comparing the results: ");
+  double sum_delta2 = 0;
+  double sum_ref2 = 0;
+  double max_delta_ref = 0;
+
+  for (int y = 0; y < dataH; y++)
+    for (int x = 0; x < dataW; x++) {
+      double rCPU = (double)h_ResultCPU[y * dataW + x];
+      double rGPU = (double)h_ResultGPU[y * fftW + x];
+      double delta = (rCPU - rGPU) * (rCPU - rGPU);
+      double ref = rCPU * rCPU + rCPU * rCPU;
+
+      if ((delta / ref) > max_delta_ref) {
+        max_delta_ref = delta / ref;
+      }
+
+      sum_delta2 += delta;
+      sum_ref2 += ref;
+    }
+
+  double L2norm = sqrt(sum_delta2 / sum_ref2);
+  printf("rel L2 = %E (max delta = %E)\n", L2norm, sqrt(max_delta_ref));
+  bRetVal = (L2norm < 1e-6) ? true : false;
+  printf(bRetVal ? "L2norm Error OK\n" : "L2norm Error too high!\n");
+
+  printf("...shutting down\n");
+  sdkDeleteTimer(&hTimer);
+  checkCudaErrors(cufftDestroy(fftPlan));
+
+  checkCudaErrors(cudaFree(d_KernelSpectrum));
+  checkCudaErrors(cudaFree(d_DataSpectrum));
+  checkCudaErrors(cudaFree(d_KernelSpectrum0));
+  checkCudaErrors(cudaFree(d_DataSpectrum0));
+  checkCudaErrors(cudaFree(d_PaddedKernel));
+  checkCudaErrors(cudaFree(d_PaddedData));
+  checkCudaErrors(cudaFree(d_Kernel));
+  checkCudaErrors(cudaFree(d_Data));
+
+  free(h_ResultGPU);
+  free(h_ResultCPU);
+  free(h_Kernel);
+  free(h_Data);
+
+  return bRetVal;
+}
+
+bool test2(void) {
+  float *h_Data, *h_Kernel, *h_ResultCPU, *h_ResultGPU;
+
+  float *d_Data, *d_Kernel, *d_PaddedData, *d_PaddedKernel;
+
+  fComplex *d_DataSpectrum0, *d_KernelSpectrum0;
+
+  cufftHandle fftPlan;
+
+  bool bRetVal;
+  StopWatchInterface *hTimer = NULL;
+  sdkCreateTimer(&hTimer);
+
+  printf("Testing updated custom R2C / C2R FFT-based convolution\n");
+  const int kernelH = 7;
+  const int kernelW = 6;
+  const int kernelY = 3;
+  const int kernelX = 4;
+  const int dataH = 2000;
+  const int dataW = 2000;
+  const int fftH = snapTransformSize(dataH + kernelH - 1);
+  const int fftW = snapTransformSize(dataW + kernelW - 1);
+
+  printf("...allocating memory\n");
+  h_Data = (float *)malloc(dataH * dataW * sizeof(float));
+  h_Kernel = (float *)malloc(kernelH * kernelW * sizeof(float));
+  h_ResultCPU = (float *)malloc(dataH * dataW * sizeof(float));
+  h_ResultGPU = (float *)malloc(fftH * fftW * sizeof(float));
+
+  checkCudaErrors(cudaMalloc((void **)&d_Data, dataH * dataW * sizeof(float)));
+  checkCudaErrors(
+      cudaMalloc((void **)&d_Kernel, kernelH * kernelW * sizeof(float)));
+
+  checkCudaErrors(
+      cudaMalloc((void **)&d_PaddedData, fftH * fftW * sizeof(float)));
+  checkCudaErrors(
+      cudaMalloc((void **)&d_PaddedKernel, fftH * fftW * sizeof(float)));
+
+  checkCudaErrors(cudaMalloc((void **)&d_DataSpectrum0,
+                             fftH * (fftW / 2) * sizeof(fComplex)));
+  checkCudaErrors(cudaMalloc((void **)&d_KernelSpectrum0,
+                             fftH * (fftW / 2) * sizeof(fComplex)));
+
+  printf("...generating random input data\n");
+  srand(2010);
+
+  for (int i = 0; i < dataH * dataW; i++) {
+    h_Data[i] = getRand();
+  }
+
+  for (int i = 0; i < kernelH * kernelW; i++) {
+    h_Kernel[i] = getRand();
+  }
+
+  printf("...creating C2C FFT plan for %i x %i\n", fftH, fftW / 2);
+  checkCudaErrors(cufftPlan2d(&fftPlan, fftH, fftW / 2, CUFFT_C2C));
+
+  printf("...uploading to GPU and padding convolution kernel and input data\n");
+  checkCudaErrors(cudaMemcpy(d_Data, h_Data, dataH * dataW * sizeof(float),
+                             cudaMemcpyHostToDevice));
+  checkCudaErrors(cudaMemcpy(d_Kernel, h_Kernel,
+                             kernelH * kernelW * sizeof(float),
+                             cudaMemcpyHostToDevice));
+  checkCudaErrors(cudaMemset(d_PaddedData, 0, fftH * fftW * sizeof(float)));
+  checkCudaErrors(cudaMemset(d_PaddedKernel, 0, fftH * fftW * sizeof(float)));
+
+  padDataClampToBorder(d_PaddedData, d_Data, fftH, fftW, dataH, dataW, kernelH,
+                       kernelW, kernelY, kernelX);
+
+  padKernel(d_PaddedKernel, d_Kernel, fftH, fftW, kernelH, kernelW, kernelY,
+            kernelX);
+
+  // CUFFT_INVERSE works just as well...
+  const int FFT_DIR = CUFFT_FORWARD;
+
+  // Not including kernel transformation into time measurement,
+  // since convolution kernel is not changed very frequently
+  printf("...transforming convolution kernel\n");
+  checkCudaErrors(cufftExecC2C(fftPlan, (cufftComplex *)d_PaddedKernel,
+                               (cufftComplex *)d_KernelSpectrum0, FFT_DIR));
+
+  printf("...running GPU FFT convolution: ");
+  checkCudaErrors(cudaDeviceSynchronize());
+  sdkResetTimer(&hTimer);
+  sdkStartTimer(&hTimer);
+
+  checkCudaErrors(cufftExecC2C(fftPlan, (cufftComplex *)d_PaddedData,
+                               (cufftComplex *)d_DataSpectrum0, FFT_DIR));
+  spProcess2D(d_DataSpectrum0, d_DataSpectrum0, d_KernelSpectrum0, fftH,
+              fftW / 2, FFT_DIR);
+  checkCudaErrors(cufftExecC2C(fftPlan, (cufftComplex *)d_DataSpectrum0,
+                               (cufftComplex *)d_PaddedData, -FFT_DIR));
+
+  checkCudaErrors(cudaDeviceSynchronize());
+  sdkStopTimer(&hTimer);
+  double gpuTime = sdkGetTimerValue(&hTimer);
+  printf("%f MPix/s (%f ms)\n",
+         (double)dataH * (double)dataW * 1e-6 / (gpuTime * 0.001), gpuTime);
+
+  printf("...reading back GPU FFT results\n");
+  checkCudaErrors(cudaMemcpy(h_ResultGPU, d_PaddedData,
+                             fftH * fftW * sizeof(float),
+                             cudaMemcpyDeviceToHost));
+
+  printf("...running reference CPU convolution\n");
+  convolutionClampToBorderCPU(h_ResultCPU, h_Data, h_Kernel, dataH, dataW,
+                              kernelH, kernelW, kernelY, kernelX);
+
+  printf("...comparing the results: ");
+  double sum_delta2 = 0;
+  double sum_ref2 = 0;
+  double max_delta_ref = 0;
+
+  for (int y = 0; y < dataH; y++) {
+    for (int x = 0; x < dataW; x++) {
+      double rCPU = (double)h_ResultCPU[y * dataW + x];
+      double rGPU = (double)h_ResultGPU[y * fftW + x];
+      double delta = (rCPU - rGPU) * (rCPU - rGPU);
+      double ref = rCPU * rCPU + rCPU * rCPU;
+
+      if ((delta / ref) > max_delta_ref) {
+        max_delta_ref = delta / ref;
+      }
+
+      sum_delta2 += delta;
+      sum_ref2 += ref;
+    }
+  }
+
+  double L2norm = sqrt(sum_delta2 / sum_ref2);
+  printf("rel L2 = %E (max delta = %E)\n", L2norm, sqrt(max_delta_ref));
+  bRetVal = (L2norm < 1e-6) ? true : false;
+  printf(bRetVal ? "L2norm Error OK\n" : "L2norm Error too high!\n");
+
+  printf("...shutting down\n");
+  sdkDeleteTimer(&hTimer);
+  checkCudaErrors(cufftDestroy(fftPlan));
+
+  checkCudaErrors(cudaFree(d_KernelSpectrum0));
+  checkCudaErrors(cudaFree(d_DataSpectrum0));
+  checkCudaErrors(cudaFree(d_PaddedKernel));
+  checkCudaErrors(cudaFree(d_PaddedData));
+  checkCudaErrors(cudaFree(d_Kernel));
+  checkCudaErrors(cudaFree(d_Data));
+
+  free(h_ResultGPU);
+  free(h_ResultCPU);
+  free(h_Kernel);
+  free(h_Data);
+
+  return bRetVal;
+}
+
+int main(int argc, char **argv) {
+  printf("[%s] - Starting...\n", argv[0]);
+
+  // Use command-line specified CUDA device, otherwise use device with highest
+  // Gflops/s
+  findCudaDevice(argc, (const char **)argv);
+
+  int nFailures = 0;
+
+  if (!test0()) {
+    nFailures++;
+  }
+
+  if (!test1()) {
+    nFailures++;
+  }
+
+  if (!test2()) {
+    nFailures++;
+  }
+
+  printf("Test Summary: %d errors\n", nFailures);
+
+  if (nFailures > 0) {
+    printf("Test failed!\n");
+    exit(EXIT_FAILURE);
+  }
+
+  printf("Test passed\n");
+  exit(EXIT_SUCCESS);
+}