add and update samples for CUDA 11.5

2026-10-23 21:28:17 +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/dxtc/.vscode/c_cpp_properties.json
+++ b/Samples/dxtc/.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/dxtc/.vscode/extensions.json
+++ b/Samples/dxtc/.vscode/extensions.json
@@ -0,0 +1,7 @@
+{
+    "recommendations": [
+        "nvidia.nsight-vscode-edition",
+        "ms-vscode.cpptools",
+        "ms-vscode.makefile-tools"
+    ]
+}
--- a/Samples/dxtc/.vscode/launch.json
+++ b/Samples/dxtc/.vscode/launch.json
@@ -0,0 +1,10 @@
+{
+    "configurations": [
+        {
+            "name": "CUDA C++: Launch",
+            "type": "cuda-gdb",
+            "request": "launch",
+            "program": "${workspaceFolder}/dxtc"
+        }
+    ]
+}
--- a/Samples/dxtc/.vscode/tasks.json
+++ b/Samples/dxtc/.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/dxtc/CudaMath.h
+++ b/Samples/dxtc/CudaMath.h
@@ -0,0 +1,106 @@
+/* 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.
+ */
+
+// Math functions and operators to be used with vector types.
+
+#ifndef CUDAMATH_H
+#define CUDAMATH_H
+
+#include <cooperative_groups.h>
+
+namespace cg = cooperative_groups;
+
+// Use power method to find the first eigenvector.
+// https://en.wikipedia.org/wiki/Power_iteration
+inline __device__ __host__ float3 firstEigenVector(float matrix[6]) {
+  // 8 iterations seems to be more than enough.
+
+  float3 v = make_float3(1.0f, 1.0f, 1.0f);
+
+  for (int i = 0; i < 8; i++) {
+    float x = v.x * matrix[0] + v.y * matrix[1] + v.z * matrix[2];
+    float y = v.x * matrix[1] + v.y * matrix[3] + v.z * matrix[4];
+    float z = v.x * matrix[2] + v.y * matrix[4] + v.z * matrix[5];
+    float m = max(max(x, y), z);
+    float iv = 1.0f / m;
+    v = make_float3(x * iv, y * iv, z * iv);
+  }
+
+  return v;
+}
+
+inline __device__ void colorSums(const float3 *colors, float3 *sums,
+                                 cg::thread_group tile) {
+  const int idx = threadIdx.x;
+
+  sums[idx] = colors[idx];
+  cg::sync(tile);
+  sums[idx] += sums[idx ^ 8];
+  cg::sync(tile);
+  sums[idx] += sums[idx ^ 4];
+  cg::sync(tile);
+  sums[idx] += sums[idx ^ 2];
+  cg::sync(tile);
+  sums[idx] += sums[idx ^ 1];
+}
+
+inline __device__ float3 bestFitLine(const float3 *colors, float3 color_sum,
+                                     cg::thread_group tile) {
+  // Compute covariance matrix of the given colors.
+  const int idx = threadIdx.x;
+
+  float3 diff = colors[idx] - color_sum * (1.0f / 16.0f);
+
+  // @@ Eliminate two-way bank conflicts here.
+  // @@ It seems that doing that and unrolling the reduction doesn't help...
+  __shared__ float covariance[16 * 6];
+
+  covariance[6 * idx + 0] = diff.x * diff.x;  // 0, 6, 12, 2, 8, 14, 4, 10, 0
+  covariance[6 * idx + 1] = diff.x * diff.y;
+  covariance[6 * idx + 2] = diff.x * diff.z;
+  covariance[6 * idx + 3] = diff.y * diff.y;
+  covariance[6 * idx + 4] = diff.y * diff.z;
+  covariance[6 * idx + 5] = diff.z * diff.z;
+
+  cg::sync(tile);
+  for (int d = 8; d > 0; d >>= 1) {
+    if (idx < d) {
+      covariance[6 * idx + 0] += covariance[6 * (idx + d) + 0];
+      covariance[6 * idx + 1] += covariance[6 * (idx + d) + 1];
+      covariance[6 * idx + 2] += covariance[6 * (idx + d) + 2];
+      covariance[6 * idx + 3] += covariance[6 * (idx + d) + 3];
+      covariance[6 * idx + 4] += covariance[6 * (idx + d) + 4];
+      covariance[6 * idx + 5] += covariance[6 * (idx + d) + 5];
+    }
+    cg::sync(tile);
+  }
+
+  // Compute first eigen vector.
+  return firstEigenVector(covariance);
+}
+
+#endif  // CUDAMATH_H
--- a/Samples/dxtc/Makefile
+++ b/Samples/dxtc/Makefile
@@ -0,0 +1,362 @@
+################################################################################
+# 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
+
+ifeq ($(SAMPLE_ENABLED),0)
+EXEC ?= @echo "[@]"
+endif
+
+################################################################################
+
+# Target rules
+all: build
+
+build: dxtc
+
+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
+
+dxtc.o:dxtc.cu
+	$(EXEC) $(NVCC) $(INCLUDES) $(ALL_CCFLAGS) $(GENCODE_FLAGS) -o $@ -c $<
+
+dxtc: dxtc.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) ./dxtc
+
+clean:
+	rm -f dxtc dxtc.o
+	rm -rf ../../bin/$(TARGET_ARCH)/$(TARGET_OS)/$(BUILD_TYPE)/dxtc
+
+clobber: clean
--- a/Samples/dxtc/NsightEclipse.xml
+++ b/Samples/dxtc/NsightEclipse.xml
@@ -0,0 +1,80 @@
+<?xml version="1.0" encoding="UTF-8"?> 
+<!DOCTYPE entry SYSTEM "SamplesInfo.dtd">
+<entry>
+  <name>dxtc</name>
+  <description><![CDATA[High Quality DXT Compression using CUDA. This example shows how to implement an existing computationally-intensive CPU compression algorithm in parallel on the GPU, and obtain an order of magnitude performance improvement.]]></description>
+  <devicecompilation>whole</devicecompilation>
+  <files>
+    <file>data\lena-orig.ppm</file>
+    <file>data\lorikeet-orig.ppm</file>
+    <file>data\colors.ppm</file>
+    <file>data\lena_std.ppm</file>
+  </files>
+  <includepaths>
+    <path>./</path>
+    <path>../</path>
+    <path>../../Common</path>
+  </includepaths>
+  <keyconcepts>
+    <concept level="basic">Cooperative Groups</concept>
+    <concept level="advanced">Image Processing</concept>
+    <concept level="advanced">Image Compression</concept>
+  </keyconcepts>
+  <keywords>
+    <keyword>Texture Compression</keyword>
+    <keyword>DXTC</keyword>
+    <keyword>S3TC</keyword>
+    <keyword>cluster fit</keyword>
+    <keyword>power method</keyword>
+    <keyword>covariance</keyword>
+    <keyword>least squares</keyword>
+  </keywords>
+  <libraries>
+  </libraries>
+  <librarypaths>
+  </librarypaths>
+  <nsight_eclipse>true</nsight_eclipse>
+  <primary_file>dxtc.cu</primary_file>
+  <scopes>
+    <scope>1:CUDA Advanced Topics</scope>
+    <scope>2:Image Processing</scope>
+    <scope>2:Data Compression</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>DirectX Texture Compressor (DXTC)</title>
+  <type>exe</type>
+  <whitepaper>doc\cuda_dxtc.pdf</whitepaper>
+</entry>
--- a/Samples/dxtc/README.md
+++ b/Samples/dxtc/README.md
@@ -0,0 +1,67 @@
+# dxtc - DirectX Texture Compressor (DXTC)
+
+## Description
+
+High Quality DXT Compression using CUDA. This example shows how to implement an existing computationally-intensive CPU compression algorithm in parallel on the GPU, and obtain an order of magnitude performance improvement.
+
+## Key Concepts
+
+Cooperative Groups, Image Processing, Image Compression
+
+## 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
+
+## Prerequisites
+
+Download and install the [CUDA Toolkit 11.5](https://developer.nvidia.com/cuda-downloads) for your corresponding platform.
+
+## Build and Run
+
+### Windows
+The Windows samples are built using the Visual Studio IDE. Solution files (.sln) are provided for each supported version of Visual Studio, using the format:
+```
+*_vs<version>.sln - for Visual Studio <version>
+```
+Each individual sample has its own set of solution files in its directory:
+
+To build/examine all the samples at once, the complete solution files should be used. To build/examine a single sample, the individual sample solution files should be used.
+> **Note:** Some samples require that the Microsoft DirectX SDK (June 2010 or newer) be installed and that the VC++ directory paths are properly set up (**Tools > Options...**). Check DirectX Dependencies section for details."
+
+### Linux
+The Linux samples are built using makefiles. To use the makefiles, change the current directory to the sample directory you wish to build, and run make:
+```
+$ cd <sample_dir>
+$ make
+```
+The samples makefiles can take advantage of certain options:
+*  **TARGET_ARCH=<arch>** - cross-compile targeting a specific architecture. Allowed architectures are x86_64, ppc64le, armv7l.
+    By default, TARGET_ARCH is set to HOST_ARCH. On a x86_64 machine, not setting TARGET_ARCH is the equivalent of setting TARGET_ARCH=x86_64.<br/>
+`$ make TARGET_ARCH=x86_64` <br/> `$ make TARGET_ARCH=ppc64le` <br/> `$ make TARGET_ARCH=armv7l` <br/>
+    See [here](http://docs.nvidia.com/cuda/cuda-samples/index.html#cross-samples) for more details.
+*   **dbg=1** - build with debug symbols
+    ```
+    $ make dbg=1
+    ```
+*   **SMS="A B ..."** - override the SM architectures for which the sample will be built, where `"A B ..."` is a space-delimited list of SM architectures. For example, to generate SASS for SM 50 and SM 60, use `SMS="50 60"`.
+    ```
+    $ make SMS="50 60"
+    ```
+
+*  **HOST_COMPILER=<host_compiler>** - override the default g++ host compiler. See the [Linux Installation Guide](http://docs.nvidia.com/cuda/cuda-installation-guide-linux/index.html#system-requirements) for a list of supported host compilers.
+```
+    $ make HOST_COMPILER=g++
+```
+
+## References (for more details)
+
--- a/Samples/dxtc/data/colors.ppm
+++ b/Samples/dxtc/data/colors.ppm
--- a/Samples/dxtc/data/lena-orig.ppm
+++ b/Samples/dxtc/data/lena-orig.ppm
--- a/Samples/dxtc/data/lena_ref.dds
+++ b/Samples/dxtc/data/lena_ref.dds
--- a/Samples/dxtc/data/lena_std.ppm
+++ b/Samples/dxtc/data/lena_std.ppm
--- a/Samples/dxtc/data/lorikeet-orig.ppm
+++ b/Samples/dxtc/data/lorikeet-orig.ppm
--- a/Samples/dxtc/dds.h
+++ b/Samples/dxtc/dds.h
@@ -0,0 +1,84 @@
+/* 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 DDS_H
+#define DDS_H
+
+#if !defined(MAKEFOURCC)
+#define MAKEFOURCC(ch0, ch1, ch2, ch3)                \
+  ((unsigned int)(ch0) | ((unsigned int)(ch1) << 8) | \
+   ((unsigned int)(ch2) << 16) | ((unsigned int)(ch3) << 24))
+#endif
+
+typedef unsigned int uint;
+typedef unsigned short ushort;
+
+struct DDSPixelFormat {
+  uint size;
+  uint flags;
+  uint fourcc;
+  uint bitcount;
+  uint rmask;
+  uint gmask;
+  uint bmask;
+  uint amask;
+};
+
+struct DDSCaps {
+  uint caps1;
+  uint caps2;
+  uint caps3;
+  uint caps4;
+};
+
+/// DDS file header.
+struct DDSHeader {
+  uint fourcc;
+  uint size;
+  uint flags;
+  uint height;
+  uint width;
+  uint pitch;
+  uint depth;
+  uint mipmapcount;
+  uint reserved[11];
+  DDSPixelFormat pf;
+  DDSCaps caps;
+  uint notused;
+};
+
+static const uint FOURCC_DDS = MAKEFOURCC('D', 'D', 'S', ' ');
+static const uint FOURCC_DXT1 = MAKEFOURCC('D', 'X', 'T', '1');
+static const uint DDSD_WIDTH = 0x00000004U;
+static const uint DDSD_HEIGHT = 0x00000002U;
+static const uint DDSD_CAPS = 0x00000001U;
+static const uint DDSD_PIXELFORMAT = 0x00001000U;
+static const uint DDSCAPS_TEXTURE = 0x00001000U;
+static const uint DDPF_FOURCC = 0x00000004U;
+static const uint DDSD_LINEARSIZE = 0x00080000U;
+
+#endif  // DDS_H
--- a/Samples/dxtc/doc/cuda_dxtc.doc
+++ b/Samples/dxtc/doc/cuda_dxtc.doc
--- a/Samples/dxtc/doc/cuda_dxtc.pdf
+++ b/Samples/dxtc/doc/cuda_dxtc.pdf
--- a/Samples/dxtc/dxtc.cu
+++ b/Samples/dxtc/dxtc.cu
@@ -0,0 +1,786 @@
+/* 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.
+ */
+
+// Utilities and system includes
+#include <cooperative_groups.h>
+
+namespace cg = cooperative_groups;
+
+#include <helper_functions.h>
+#include <helper_cuda.h>
+
+#include <helper_math.h>
+#include <float.h>  // for FLT_MAX
+
+#include "CudaMath.h"
+#include "dds.h"
+#include "permutations.h"
+
+// Definitions
+#define INPUT_IMAGE "lena_std.ppm"
+#define REFERENCE_IMAGE "lena_ref.dds"
+
+#define ERROR_THRESHOLD 0.02f
+
+#define NUM_THREADS 64  // Number of threads per block.
+
+#define __debugsync()
+
+template <class T>
+__device__ inline void swap(T &a, T &b) {
+  T tmp = a;
+  a = b;
+  b = tmp;
+}
+
+//__constant__ float3 kColorMetric = { 0.2126f, 0.7152f, 0.0722f };
+__constant__ float3 kColorMetric = {1.0f, 1.0f, 1.0f};
+
+////////////////////////////////////////////////////////////////////////////////
+// Sort colors
+////////////////////////////////////////////////////////////////////////////////
+__device__ void sortColors(const float *values, int *ranks,
+                           cg::thread_group tile) {
+  const int tid = threadIdx.x;
+
+  int rank = 0;
+
+#pragma unroll
+
+  for (int i = 0; i < 16; i++) {
+    rank += (values[i] < values[tid]);
+  }
+
+  ranks[tid] = rank;
+
+  cg::sync(tile);
+
+  // Resolve elements with the same index.
+  for (int i = 0; i < 15; i++) {
+    if (tid > i && ranks[tid] == ranks[i]) {
+      ++ranks[tid];
+    }
+    cg::sync(tile);
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Load color block to shared mem
+////////////////////////////////////////////////////////////////////////////////
+__device__ void loadColorBlock(const uint *image, float3 colors[16],
+                               float3 sums[16], int xrefs[16], int blockOffset,
+                               cg::thread_block cta) {
+  const int bid = blockIdx.x + blockOffset;
+  const int idx = threadIdx.x;
+
+  __shared__ float dps[16];
+
+  float3 tmp;
+
+  cg::thread_group tile = cg::tiled_partition(cta, 16);
+
+  if (idx < 16) {
+    // Read color and copy to shared mem.
+    uint c = image[(bid)*16 + idx];
+
+    colors[idx].x = ((c >> 0) & 0xFF) * (1.0f / 255.0f);
+    colors[idx].y = ((c >> 8) & 0xFF) * (1.0f / 255.0f);
+    colors[idx].z = ((c >> 16) & 0xFF) * (1.0f / 255.0f);
+
+    cg::sync(tile);
+    // Sort colors along the best fit line.
+    colorSums(colors, sums, tile);
+
+    cg::sync(tile);
+
+    float3 axis = bestFitLine(colors, sums[0], tile);
+
+    cg::sync(tile);
+
+    dps[idx] = dot(colors[idx], axis);
+
+    cg::sync(tile);
+
+    sortColors(dps, xrefs, tile);
+
+    cg::sync(tile);
+
+    tmp = colors[idx];
+
+    cg::sync(tile);
+
+    colors[xrefs[idx]] = tmp;
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Round color to RGB565 and expand
+////////////////////////////////////////////////////////////////////////////////
+inline __device__ float3 roundAndExpand(float3 v, ushort *w) {
+  v.x = rintf(__saturatef(v.x) * 31.0f);
+  v.y = rintf(__saturatef(v.y) * 63.0f);
+  v.z = rintf(__saturatef(v.z) * 31.0f);
+
+  *w = ((ushort)v.x << 11) | ((ushort)v.y << 5) | (ushort)v.z;
+  v.x *= 0.03227752766457f;  // approximate integer bit expansion.
+  v.y *= 0.01583151765563f;
+  v.z *= 0.03227752766457f;
+  return v;
+}
+
+__constant__ float alphaTable4[4] = {9.0f, 0.0f, 6.0f, 3.0f};
+__constant__ float alphaTable3[4] = {4.0f, 0.0f, 2.0f, 2.0f};
+__constant__ const int prods4[4] = {0x090000, 0x000900, 0x040102, 0x010402};
+__constant__ const int prods3[4] = {0x040000, 0x000400, 0x040101, 0x010401};
+
+#define USE_TABLES 1
+
+////////////////////////////////////////////////////////////////////////////////
+// Evaluate permutations
+////////////////////////////////////////////////////////////////////////////////
+static __device__ float evalPermutation4(const float3 *colors, uint permutation,
+                                         ushort *start, ushort *end,
+                                         float3 color_sum) {
+// Compute endpoints using least squares.
+#if USE_TABLES
+  float3 alphax_sum = make_float3(0.0f, 0.0f, 0.0f);
+
+  int akku = 0;
+
+  // Compute alpha & beta for this permutation.
+  for (int i = 0; i < 16; i++) {
+    const uint bits = permutation >> (2 * i);
+
+    alphax_sum += alphaTable4[bits & 3] * colors[i];
+    akku += prods4[bits & 3];
+  }
+
+  float alpha2_sum = float(akku >> 16);
+  float beta2_sum = float((akku >> 8) & 0xff);
+  float alphabeta_sum = float((akku >> 0) & 0xff);
+  float3 betax_sum = (9.0f * color_sum) - alphax_sum;
+#else
+  float alpha2_sum = 0.0f;
+  float beta2_sum = 0.0f;
+  float alphabeta_sum = 0.0f;
+  float3 alphax_sum = make_float3(0.0f, 0.0f, 0.0f);
+
+  // Compute alpha & beta for this permutation.
+  for (int i = 0; i < 16; i++) {
+    const uint bits = permutation >> (2 * i);
+
+    float beta = (bits & 1);
+
+    if (bits & 2) {
+      beta = (1 + beta) * (1.0f / 3.0f);
+    }
+
+    float alpha = 1.0f - beta;
+
+    alpha2_sum += alpha * alpha;
+    beta2_sum += beta * beta;
+    alphabeta_sum += alpha * beta;
+    alphax_sum += alpha * colors[i];
+  }
+
+  float3 betax_sum = color_sum - alphax_sum;
+#endif
+
+  // alpha2, beta2, alphabeta and factor could be precomputed for each
+  // permutation, but it's faster to recompute them.
+  const float factor =
+      1.0f / (alpha2_sum * beta2_sum - alphabeta_sum * alphabeta_sum);
+
+  float3 a = (alphax_sum * beta2_sum - betax_sum * alphabeta_sum) * factor;
+  float3 b = (betax_sum * alpha2_sum - alphax_sum * alphabeta_sum) * factor;
+
+  // Round a, b to the closest 5-6-5 color and expand...
+  a = roundAndExpand(a, start);
+  b = roundAndExpand(b, end);
+
+  // compute the error
+  float3 e = a * a * alpha2_sum + b * b * beta2_sum +
+             2.0f * (a * b * alphabeta_sum - a * alphax_sum - b * betax_sum);
+
+  return (0.111111111111f) * dot(e, kColorMetric);
+}
+
+static __device__ float evalPermutation3(const float3 *colors, uint permutation,
+                                         ushort *start, ushort *end,
+                                         float3 color_sum) {
+// Compute endpoints using least squares.
+#if USE_TABLES
+  float3 alphax_sum = make_float3(0.0f, 0.0f, 0.0f);
+
+  int akku = 0;
+
+  // Compute alpha & beta for this permutation.
+  for (int i = 0; i < 16; i++) {
+    const uint bits = permutation >> (2 * i);
+
+    alphax_sum += alphaTable3[bits & 3] * colors[i];
+    akku += prods3[bits & 3];
+  }
+
+  float alpha2_sum = float(akku >> 16);
+  float beta2_sum = float((akku >> 8) & 0xff);
+  float alphabeta_sum = float((akku >> 0) & 0xff);
+  float3 betax_sum = (4.0f * color_sum) - alphax_sum;
+#else
+  float alpha2_sum = 0.0f;
+  float beta2_sum = 0.0f;
+  float alphabeta_sum = 0.0f;
+  float3 alphax_sum = make_float3(0.0f, 0.0f, 0.0f);
+
+  // Compute alpha & beta for this permutation.
+  for (int i = 0; i < 16; i++) {
+    const uint bits = permutation >> (2 * i);
+
+    float beta = (bits & 1);
+
+    if (bits & 2) {
+      beta = 0.5f;
+    }
+
+    float alpha = 1.0f - beta;
+
+    alpha2_sum += alpha * alpha;
+    beta2_sum += beta * beta;
+    alphabeta_sum += alpha * beta;
+    alphax_sum += alpha * colors[i];
+  }
+
+  float3 betax_sum = color_sum - alphax_sum;
+#endif
+
+  const float factor =
+      1.0f / (alpha2_sum * beta2_sum - alphabeta_sum * alphabeta_sum);
+
+  float3 a = (alphax_sum * beta2_sum - betax_sum * alphabeta_sum) * factor;
+  float3 b = (betax_sum * alpha2_sum - alphax_sum * alphabeta_sum) * factor;
+
+  // Round a, b to the closest 5-6-5 color and expand...
+  a = roundAndExpand(a, start);
+  b = roundAndExpand(b, end);
+
+  // compute the error
+  float3 e = a * a * alpha2_sum + b * b * beta2_sum +
+             2.0f * (a * b * alphabeta_sum - a * alphax_sum - b * betax_sum);
+
+  return (0.25f) * dot(e, kColorMetric);
+}
+
+__device__ void evalAllPermutations(const float3 *colors,
+                                    const uint *permutations, ushort &bestStart,
+                                    ushort &bestEnd, uint &bestPermutation,
+                                    float *errors, float3 color_sum,
+                                    cg::thread_block cta) {
+  const int idx = threadIdx.x;
+
+  float bestError = FLT_MAX;
+
+  __shared__ uint s_permutations[160];
+
+  for (int i = 0; i < 16; i++) {
+    int pidx = idx + NUM_THREADS * i;
+
+    if (pidx >= 992) {
+      break;
+    }
+
+    ushort start, end;
+    uint permutation = permutations[pidx];
+
+    if (pidx < 160) {
+      s_permutations[pidx] = permutation;
+    }
+
+    float error =
+        evalPermutation4(colors, permutation, &start, &end, color_sum);
+
+    if (error < bestError) {
+      bestError = error;
+      bestPermutation = permutation;
+      bestStart = start;
+      bestEnd = end;
+    }
+  }
+
+  if (bestStart < bestEnd) {
+    swap(bestEnd, bestStart);
+    bestPermutation ^= 0x55555555;  // Flip indices.
+  }
+
+  cg::sync(cta);  // Sync here to ensure s_permutations is valid going forward
+
+  for (int i = 0; i < 3; i++) {
+    int pidx = idx + NUM_THREADS * i;
+
+    if (pidx >= 160) {
+      break;
+    }
+
+    ushort start, end;
+    uint permutation = s_permutations[pidx];
+    float error =
+        evalPermutation3(colors, permutation, &start, &end, color_sum);
+
+    if (error < bestError) {
+      bestError = error;
+      bestPermutation = permutation;
+      bestStart = start;
+      bestEnd = end;
+
+      if (bestStart > bestEnd) {
+        swap(bestEnd, bestStart);
+        bestPermutation ^=
+            (~bestPermutation >> 1) & 0x55555555;  // Flip indices.
+      }
+    }
+  }
+
+  errors[idx] = bestError;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Find index with minimum error
+////////////////////////////////////////////////////////////////////////////////
+__device__ int findMinError(float *errors, cg::thread_block cta) {
+  const int idx = threadIdx.x;
+  __shared__ int indices[NUM_THREADS];
+  indices[idx] = idx;
+
+  cg::sync(cta);
+
+  for (int d = NUM_THREADS / 2; d > 0; d >>= 1) {
+    float err0 = errors[idx];
+    float err1 = (idx + d) < NUM_THREADS ? errors[idx + d] : FLT_MAX;
+    int index1 = (idx + d) < NUM_THREADS ? indices[idx + d] : 0;
+
+    cg::sync(cta);
+
+    if (err1 < err0) {
+      errors[idx] = err1;
+      indices[idx] = index1;
+    }
+
+    cg::sync(cta);
+  }
+
+  return indices[0];
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Save DXT block
+////////////////////////////////////////////////////////////////////////////////
+__device__ void saveBlockDXT1(ushort start, ushort end, uint permutation,
+                              int xrefs[16], uint2 *result, int blockOffset) {
+  const int bid = blockIdx.x + blockOffset;
+
+  if (start == end) {
+    permutation = 0;
+  }
+
+  // Reorder permutation.
+  uint indices = 0;
+
+  for (int i = 0; i < 16; i++) {
+    int ref = xrefs[i];
+    indices |= ((permutation >> (2 * ref)) & 3) << (2 * i);
+  }
+
+  // Write endpoints.
+  result[bid].x = (end << 16) | start;
+
+  // Write palette indices.
+  result[bid].y = indices;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Compress color block
+////////////////////////////////////////////////////////////////////////////////
+__global__ void compress(const uint *permutations, const uint *image,
+                         uint2 *result, int blockOffset) {
+  // Handle to thread block group
+  cg::thread_block cta = cg::this_thread_block();
+
+  const int idx = threadIdx.x;
+
+  __shared__ float3 colors[16];
+  __shared__ float3 sums[16];
+  __shared__ int xrefs[16];
+
+  loadColorBlock(image, colors, sums, xrefs, blockOffset, cta);
+
+  cg::sync(cta);
+
+  ushort bestStart, bestEnd;
+  uint bestPermutation;
+
+  __shared__ float errors[NUM_THREADS];
+
+  evalAllPermutations(colors, permutations, bestStart, bestEnd, bestPermutation,
+                      errors, sums[0], cta);
+
+  // Use a parallel reduction to find minimum error.
+  const int minIdx = findMinError(errors, cta);
+
+  cg::sync(cta);
+
+  // Only write the result of the winner thread.
+  if (idx == minIdx) {
+    saveBlockDXT1(bestStart, bestEnd, bestPermutation, xrefs, result,
+                  blockOffset);
+  }
+}
+
+// Helper structs and functions to validate the output of the compressor.
+// We cannot simply do a bitwise compare, because different compilers produce
+// different
+// results for different targets due to floating point arithmetic.
+
+union Color32 {
+  struct {
+    unsigned char b, g, r, a;
+  };
+  unsigned int u;
+};
+
+union Color16 {
+  struct {
+    unsigned short b : 5;
+    unsigned short g : 6;
+    unsigned short r : 5;
+  };
+  unsigned short u;
+};
+
+struct BlockDXT1 {
+  Color16 col0;
+  Color16 col1;
+  union {
+    unsigned char row[4];
+    unsigned int indices;
+  };
+
+  void decompress(Color32 colors[16]) const;
+};
+
+void BlockDXT1::decompress(Color32 *colors) const {
+  Color32 palette[4];
+
+  // Does bit expansion before interpolation.
+  palette[0].b = (col0.b << 3) | (col0.b >> 2);
+  palette[0].g = (col0.g << 2) | (col0.g >> 4);
+  palette[0].r = (col0.r << 3) | (col0.r >> 2);
+  palette[0].a = 0xFF;
+
+  palette[1].r = (col1.r << 3) | (col1.r >> 2);
+  palette[1].g = (col1.g << 2) | (col1.g >> 4);
+  palette[1].b = (col1.b << 3) | (col1.b >> 2);
+  palette[1].a = 0xFF;
+
+  if (col0.u > col1.u) {
+    // Four-color block: derive the other two colors.
+    palette[2].r = (2 * palette[0].r + palette[1].r) / 3;
+    palette[2].g = (2 * palette[0].g + palette[1].g) / 3;
+    palette[2].b = (2 * palette[0].b + palette[1].b) / 3;
+    palette[2].a = 0xFF;
+
+    palette[3].r = (2 * palette[1].r + palette[0].r) / 3;
+    palette[3].g = (2 * palette[1].g + palette[0].g) / 3;
+    palette[3].b = (2 * palette[1].b + palette[0].b) / 3;
+    palette[3].a = 0xFF;
+  } else {
+    // Three-color block: derive the other color.
+    palette[2].r = (palette[0].r + palette[1].r) / 2;
+    palette[2].g = (palette[0].g + palette[1].g) / 2;
+    palette[2].b = (palette[0].b + palette[1].b) / 2;
+    palette[2].a = 0xFF;
+
+    palette[3].r = 0x00;
+    palette[3].g = 0x00;
+    palette[3].b = 0x00;
+    palette[3].a = 0x00;
+  }
+
+  for (int i = 0; i < 16; i++) {
+    colors[i] = palette[(indices >> (2 * i)) & 0x3];
+  }
+}
+
+static int compareColors(const Color32 *b0, const Color32 *b1) {
+  int sum = 0;
+
+  for (int i = 0; i < 16; i++) {
+    int r = (b0[i].r - b1[i].r);
+    int g = (b0[i].g - b1[i].g);
+    int b = (b0[i].b - b1[i].b);
+    sum += r * r + g * g + b * b;
+  }
+
+  return sum;
+}
+
+static int compareBlock(const BlockDXT1 *b0, const BlockDXT1 *b1) {
+  Color32 colors0[16];
+  Color32 colors1[16];
+
+  if (memcmp(b0, b1, sizeof(BlockDXT1)) == 0) {
+    return 0;
+  } else {
+    b0->decompress(colors0);
+    b1->decompress(colors1);
+
+    return compareColors(colors0, colors1);
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Program main
+////////////////////////////////////////////////////////////////////////////////
+int main(int argc, char **argv) {
+  printf("%s Starting...\n\n", argv[0]);
+
+  // use command-line specified CUDA device, otherwise use device with highest
+  // Gflops/s
+  findCudaDevice(argc, (const char **)argv);
+
+  // Load input image.
+  unsigned char *data = NULL;
+  uint W, H;
+
+  char *image_path = sdkFindFilePath(INPUT_IMAGE, argv[0]);
+
+  if (image_path == 0) {
+    printf("Error, unable to find source image  <%s>\n", image_path);
+    exit(EXIT_FAILURE);
+  }
+
+  if (!sdkLoadPPM4ub(image_path, &data, &W, &H)) {
+    printf("Error, unable to open source image file <%s>\n", image_path);
+
+    exit(EXIT_FAILURE);
+  }
+
+  uint w = W, h = H;
+
+  printf("Image Loaded '%s', %d x %d pixels\n\n", image_path, w, h);
+
+  // Allocate input image.
+  const uint memSize = w * h * 4;
+  assert(0 != memSize);
+  uint *block_image = (uint *)malloc(memSize);
+
+  // Convert linear image to block linear.
+  for (uint by = 0; by < h / 4; by++) {
+    for (uint bx = 0; bx < w / 4; bx++) {
+      for (int i = 0; i < 16; i++) {
+        const int x = i & 3;
+        const int y = i / 4;
+        block_image[(by * w / 4 + bx) * 16 + i] =
+            ((uint *)data)[(by * 4 + y) * 4 * (W / 4) + bx * 4 + x];
+      }
+    }
+  }
+
+  // copy into global mem
+  uint *d_data = NULL;
+  checkCudaErrors(cudaMalloc((void **)&d_data, memSize));
+
+  // Result
+  uint *d_result = NULL;
+  const uint compressedSize = (w / 4) * (h / 4) * 8;
+  checkCudaErrors(cudaMalloc((void **)&d_result, compressedSize));
+  uint *h_result = (uint *)malloc(compressedSize);
+
+  // Compute permutations.
+  uint permutations[1024];
+  computePermutations(permutations);
+
+  // Copy permutations host to devie.
+  uint *d_permutations = NULL;
+  checkCudaErrors(cudaMalloc((void **)&d_permutations, 1024 * sizeof(uint)));
+  checkCudaErrors(cudaMemcpy(d_permutations, permutations, 1024 * sizeof(uint),
+                             cudaMemcpyHostToDevice));
+
+  // create a timer
+  StopWatchInterface *timer = NULL;
+  sdkCreateTimer(&timer);
+
+  // Copy image from host to device
+  checkCudaErrors(
+      cudaMemcpy(d_data, block_image, memSize, cudaMemcpyHostToDevice));
+
+  // Determine launch configuration and run timed computation numIterations
+  // times
+  uint blocks = ((w + 3) / 4) *
+                ((h + 3) / 4);  // rounds up by 1 block in each dim if %4 != 0
+
+  int devID;
+  cudaDeviceProp deviceProp;
+
+  // get number of SMs on this GPU
+  checkCudaErrors(cudaGetDevice(&devID));
+  checkCudaErrors(cudaGetDeviceProperties(&deviceProp, devID));
+
+  // Restrict the numbers of blocks to launch on low end GPUs to avoid kernel
+  // timeout
+  int blocksPerLaunch = min(blocks, 768 * deviceProp.multiProcessorCount);
+
+  printf("Running DXT Compression on %u x %u image...\n", w, h);
+  printf("\n%u Blocks, %u Threads per Block, %u Threads in Grid...\n\n", blocks,
+         NUM_THREADS, blocks * NUM_THREADS);
+  int numIterations = 1;
+
+  for (int i = -1; i < numIterations; ++i) {
+    if (i == 0) {
+      checkCudaErrors(cudaDeviceSynchronize());
+      sdkStartTimer(&timer);
+    }
+
+    for (int j = 0; j < (int)blocks; j += blocksPerLaunch) {
+      compress<<<min(blocksPerLaunch, blocks - j), NUM_THREADS>>>(
+          d_permutations, d_data, (uint2 *)d_result, j);
+    }
+  }
+
+  getLastCudaError("compress");
+
+  // sync to host, stop timer, record perf
+  checkCudaErrors(cudaDeviceSynchronize());
+  sdkStopTimer(&timer);
+  double dAvgTime = 1.0e-3 * sdkGetTimerValue(&timer) / (double)numIterations;
+  printf(
+      "dxtc, Throughput = %.4f MPixels/s, Time = %.5f s, Size = %u Pixels, "
+      "NumDevsUsed = %i, Workgroup = %d\n",
+      (1.0e-6 * (double)(W * H) / dAvgTime), dAvgTime, (W * H), 1, NUM_THREADS);
+
+  // copy result data from device to host
+  checkCudaErrors(
+      cudaMemcpy(h_result, d_result, compressedSize, cudaMemcpyDeviceToHost));
+
+  // Write out result data to DDS file
+  char output_filename[1024];
+  strcpy(output_filename, image_path);
+  strcpy(output_filename + strlen(image_path) - 3, "dds");
+  FILE *fp = fopen(output_filename, "wb");
+
+  if (fp == 0) {
+    printf("Error, unable to open output image <%s>\n", output_filename);
+    exit(EXIT_FAILURE);
+  }
+
+  DDSHeader header;
+  header.fourcc = FOURCC_DDS;
+  header.size = 124;
+  header.flags = (DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_PIXELFORMAT |
+                  DDSD_LINEARSIZE);
+  header.height = h;
+  header.width = w;
+  header.pitch = compressedSize;
+  header.depth = 0;
+  header.mipmapcount = 0;
+  memset(header.reserved, 0, sizeof(header.reserved));
+  header.pf.size = 32;
+  header.pf.flags = DDPF_FOURCC;
+  header.pf.fourcc = FOURCC_DXT1;
+  header.pf.bitcount = 0;
+  header.pf.rmask = 0;
+  header.pf.gmask = 0;
+  header.pf.bmask = 0;
+  header.pf.amask = 0;
+  header.caps.caps1 = DDSCAPS_TEXTURE;
+  header.caps.caps2 = 0;
+  header.caps.caps3 = 0;
+  header.caps.caps4 = 0;
+  header.notused = 0;
+  fwrite(&header, sizeof(DDSHeader), 1, fp);
+  fwrite(h_result, compressedSize, 1, fp);
+  fclose(fp);
+
+  // Make sure the generated image is correct.
+  const char *reference_image_path = sdkFindFilePath(REFERENCE_IMAGE, argv[0]);
+
+  if (reference_image_path == 0) {
+    printf("Error, unable to find reference image\n");
+
+    exit(EXIT_FAILURE);
+  }
+
+  fp = fopen(reference_image_path, "rb");
+
+  if (fp == 0) {
+    printf("Error, unable to open reference image\n");
+
+    exit(EXIT_FAILURE);
+  }
+
+  fseek(fp, sizeof(DDSHeader), SEEK_SET);
+  uint referenceSize = (W / 4) * (H / 4) * 8;
+  uint *reference = (uint *)malloc(referenceSize);
+  fread(reference, referenceSize, 1, fp);
+  fclose(fp);
+
+  printf("\nChecking accuracy...\n");
+  float rms = 0;
+
+  for (uint y = 0; y < h; y += 4) {
+    for (uint x = 0; x < w; x += 4) {
+      uint referenceBlockIdx = ((y / 4) * (W / 4) + (x / 4));
+      uint resultBlockIdx = ((y / 4) * (w / 4) + (x / 4));
+
+      int cmp = compareBlock(((BlockDXT1 *)h_result) + resultBlockIdx,
+                             ((BlockDXT1 *)reference) + referenceBlockIdx);
+
+      if (cmp != 0.0f) {
+        printf("Deviation at (%4d,%4d):\t%f rms\n", x / 4, y / 4,
+               float(cmp) / 16 / 3);
+      }
+
+      rms += cmp;
+    }
+  }
+
+  rms /= w * h * 3;
+
+  // Free allocated resources and exit
+  checkCudaErrors(cudaFree(d_permutations));
+  checkCudaErrors(cudaFree(d_data));
+  checkCudaErrors(cudaFree(d_result));
+  free(image_path);
+  free(data);
+  free(block_image);
+  free(h_result);
+  free(reference);
+  sdkDeleteTimer(&timer);
+
+  printf("RMS(reference, result) = %f\n\n", rms);
+  printf(rms <= ERROR_THRESHOLD ? "Test passed\n" : "Test failed!\n");
+  /* Return zero if test passed, one otherwise */
+  return rms > ERROR_THRESHOLD;
+}
--- a/Samples/dxtc/dxtc_vs2017.sln
+++ b/Samples/dxtc/dxtc_vs2017.sln
@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2017
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "dxtc", "dxtc_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/dxtc/dxtc_vs2017.vcxproj
+++ b/Samples/dxtc/dxtc_vs2017.vcxproj
@@ -0,0 +1,115 @@
+<?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>dxtc_vs2017</RootNamespace>
+    <ProjectName>dxtc</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;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)/dxtc.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="dxtc.cu" />
+    <ClInclude Include="CudaMath.h" />
+    <ClInclude Include="dds.h" />
+    <ClInclude Include="permutations.h" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.5.targets" />
+  </ImportGroup>
+</Project>
--- a/Samples/dxtc/dxtc_vs2019.sln
+++ b/Samples/dxtc/dxtc_vs2019.sln
@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2019
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "dxtc", "dxtc_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/dxtc/dxtc_vs2019.vcxproj
+++ b/Samples/dxtc/dxtc_vs2019.vcxproj
@@ -0,0 +1,111 @@
+<?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>dxtc_vs2019</RootNamespace>
+    <ProjectName>dxtc</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;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)/dxtc.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="dxtc.cu" />
+    <ClInclude Include="CudaMath.h" />
+    <ClInclude Include="dds.h" />
+    <ClInclude Include="permutations.h" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.5.targets" />
+  </ImportGroup>
+</Project>
--- a/Samples/dxtc/permutations.h
+++ b/Samples/dxtc/permutations.h
@@ -0,0 +1,143 @@
+/* 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 PERMUTATIONS_H
+#define PERMUTATIONS_H
+
+#include <helper_cuda.h>  // assert
+
+static void computePermutations(uint permutations[1024]) {
+  int indices[16];
+  int num = 0;
+
+  // 3 element permutations:
+
+  // first cluster [0,i) is at the start
+  for (int m = 0; m < 16; ++m) {
+    indices[m] = 0;
+  }
+
+  const int imax = 15;
+
+  for (int i = imax; i >= 0; --i) {
+    // second cluster [i,j) is half along
+    for (int m = i; m < 16; ++m) {
+      indices[m] = 2;
+    }
+
+    const int jmax = (i == 0) ? 15 : 16;
+
+    for (int j = jmax; j >= i; --j) {
+      // last cluster [j,k) is at the end
+      if (j < 16) {
+        indices[j] = 1;
+      }
+
+      uint permutation = 0;
+
+      for (int p = 0; p < 16; p++) {
+        permutation |= indices[p] << (p * 2);
+        // permutation |= indices[15-p] << (p * 2);
+      }
+
+      permutations[num] = permutation;
+
+      num++;
+    }
+  }
+
+  assert(num == 151);
+
+  for (int i = 0; i < 9; i++) {
+    permutations[num] = 0x000AA555;
+    num++;
+  }
+
+  assert(num == 160);
+
+  // Append 4 element permutations:
+
+  // first cluster [0,i) is at the start
+  for (int m = 0; m < 16; ++m) {
+    indices[m] = 0;
+  }
+
+  for (int i = imax; i >= 0; --i) {
+    // second cluster [i,j) is one third along
+    for (int m = i; m < 16; ++m) {
+      indices[m] = 2;
+    }
+
+    const int jmax = (i == 0) ? 15 : 16;
+
+    for (int j = jmax; j >= i; --j) {
+      // third cluster [j,k) is two thirds along
+      for (int m = j; m < 16; ++m) {
+        indices[m] = 3;
+      }
+
+      int kmax = (j == 0) ? 15 : 16;
+
+      for (int k = kmax; k >= j; --k) {
+        // last cluster [k,n) is at the end
+        if (k < 16) {
+          indices[k] = 1;
+        }
+
+        uint permutation = 0;
+
+        bool hasThree = false;
+
+        for (int p = 0; p < 16; p++) {
+          permutation |= indices[p] << (p * 2);
+          // permutation |= indices[15-p] << (p * 2);
+
+          if (indices[p] == 3) hasThree = true;
+        }
+
+        if (hasThree) {
+          permutations[num] = permutation;
+          num++;
+        }
+      }
+    }
+  }
+
+  assert(num == 975);
+
+  // 1024 - 969 - 7 = 48 extra elements
+
+  // It would be nice to set these extra elements with better values...
+  for (int i = 0; i < 49; i++) {
+    permutations[num] = 0x00AAFF55;
+    num++;
+  }
+
+  assert(num == 1024);
+}
+
+#endif  // PERMUTATIONS_H