CUDA 13.2 samples update (#432)

- Added Python samples for CUDA Python 1.0 release
- Renamed top-level `Samples` directory to `cpp` to accommodate Python samples.

cpp/4_CUDA_Libraries/cannyEdgeDetectorNPP/.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
+}

cpp/4_CUDA_Libraries/cannyEdgeDetectorNPP/.vscode/extensions.json

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

cpp/4_CUDA_Libraries/cannyEdgeDetectorNPP/CMakeLists.txt

@@ -0,0 +1,71 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../../cmake/Modules")
+
+project(cannyEdgeDetectorNPP LANGUAGES CXX)
+
+find_package(CUDAToolkit REQUIRED)
+
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+set(CMAKE_CUDA_ARCHITECTURES 75 80 86 87 89 90 100 110 120)
+set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -Wno-deprecated-gpu-targets")
+if(ENABLE_CUDA_DEBUG)
+    set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")        # enable cuda-gdb (may significantly affect performance on some targets)
+else()
+    set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -lineinfo") # add line information to all builds for debug tools (exclusive to -G option)
+endif()
+
+# Include directories and libraries
+include_directories(
+    ../../../Common
+    ../../../Common/UtilNPP
+)
+
+# Source file
+find_package(FreeImage)
+
+if(${FreeImage_FOUND})
+    # Add target for cannyEdgeDetectorNPP
+    add_executable(cannyEdgeDetectorNPP cannyEdgeDetectorNPP.cpp)
+
+target_compile_options(cannyEdgeDetectorNPP PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(cannyEdgeDetectorNPP PRIVATE cxx_std_17 cuda_std_17)
+
+    set_target_properties(cannyEdgeDetectorNPP PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
+
+    target_include_directories(cannyEdgeDetectorNPP PRIVATE
+        ${CUDAToolkit_INCLUDE_DIRS}
+        ${FreeImage_INCLUDE_DIRS}
+    )
+
+    target_link_libraries(cannyEdgeDetectorNPP PRIVATE
+        CUDA::nppc
+        CUDA::nppisu
+        CUDA::nppif
+        CUDA::cudart
+        ${FreeImage_LIBRARIES}
+    )
+
+    # Copy data files to output directory
+    add_custom_command(TARGET cannyEdgeDetectorNPP POST_BUILD
+        COMMAND ${CMAKE_COMMAND} -E copy_if_different
+        ${CMAKE_CURRENT_SOURCE_DIR}/teapot512.pgm
+        ${CMAKE_CURRENT_BINARY_DIR}
+    )
+    if(WIN32)
+        add_custom_command(TARGET cannyEdgeDetectorNPP
+        POST_BUILD
+        COMMAND ${CMAKE_COMMAND} -E copy
+        ${FreeImage_LIBRARY}/../FreeImage.dll
+        ${CMAKE_CURRENT_BINARY_DIR}/$<CONFIGURATION>
+        )
+    endif()
+else()
+    message(STATUS "FreeImage not found - will not build sample 'cannyEdgeDetectorNPP'")
+endif()
+
+# Include installation configuration
+include(${CMAKE_CURRENT_SOURCE_DIR}/../../../cmake/InstallSamples.cmake)
+setup_samples_install()

cpp/4_CUDA_Libraries/cannyEdgeDetectorNPP/README.md

@@ -0,0 +1,36 @@
+# cannyEdgeDetectorNPP - Canny Edge Detector NPP
+
+## Description
+
+An NPP CUDA Sample that demonstrates the recommended parameters to use with the nppiFilterCannyBorder_8u_C1R Canny Edge Detection image filter function. This function expects a single channel 8-bit grayscale input image. You can generate a grayscale image from a color image by first calling nppiColorToGray() or nppiRGBToGray(). The Canny Edge Detection function combines and improves on the techniques required to produce an edge detection image using multiple steps.
+
+## Key Concepts
+
+Performance Strategies, Image Processing, NPP Library
+
+## Supported SM Architectures
+
+[SM 5.0 ](https://developer.nvidia.com/cuda-gpus)  [SM 5.2 ](https://developer.nvidia.com/cuda-gpus)  [SM 5.3 ](https://developer.nvidia.com/cuda-gpus)  [SM 6.0 ](https://developer.nvidia.com/cuda-gpus)  [SM 6.1 ](https://developer.nvidia.com/cuda-gpus)  [SM 7.0 ](https://developer.nvidia.com/cuda-gpus)  [SM 7.2 ](https://developer.nvidia.com/cuda-gpus)  [SM 7.5 ](https://developer.nvidia.com/cuda-gpus)  [SM 8.0 ](https://developer.nvidia.com/cuda-gpus)  [SM 8.6 ](https://developer.nvidia.com/cuda-gpus)  [SM 8.7 ](https://developer.nvidia.com/cuda-gpus)  [SM 8.9 ](https://developer.nvidia.com/cuda-gpus)  [SM 9.0 ](https://developer.nvidia.com/cuda-gpus)
+
+## Supported OSes
+
+Linux, Windows
+
+## Supported CPU Architecture
+
+x86_64, armv7l
+
+## CUDA APIs involved
+
+### [CUDA Runtime API](http://docs.nvidia.com/cuda/cuda-runtime-api/index.html)
+cudaRuntimeGetVersion, cudaFree, cudaSetDevice, cudaGetDeviceCount, cudaDeviceInit, cudaDriverGetVersion, cudaMalloc, cudaGetDeviceProperties
+
+## Dependencies needed to build/run
+[FreeImage](../../../README.md#freeimage), [NPP](../../../README.md#npp)
+
+## Prerequisites
+
+Download and install the [CUDA Toolkit](https://developer.nvidia.com/cuda-downloads) for your corresponding platform.
+Make sure the dependencies mentioned in [Dependencies]() section above are installed.
+
+## References (for more details)

cpp/4_CUDA_Libraries/cannyEdgeDetectorNPP/cannyEdgeDetectorNPP.cpp

@@ -0,0 +1,260 @@
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
+#define WINDOWS_LEAN_AND_MEAN
+#define NOMINMAX
+#include <windows.h>
+#pragma warning(disable : 4819)
+#endif
+
+#include <Exceptions.h>
+#include <ImageIO.h>
+#include <ImagesCPU.h>
+#include <ImagesNPP.h>
+#include <cuda_runtime.h>
+#include <fstream>
+#include <helper_cuda.h>
+#include <helper_string.h>
+#include <iostream>
+#include <npp.h>
+#include <string.h>
+
+inline int cudaDeviceInit(int argc, const char **argv)
+{
+    int deviceCount;
+    checkCudaErrors(cudaGetDeviceCount(&deviceCount));
+
+    if (deviceCount == 0) {
+        std::cerr << "CUDA error: no devices supporting CUDA." << std::endl;
+        exit(EXIT_FAILURE);
+    }
+
+    int dev = findCudaDevice(argc, argv);
+
+    cudaDeviceProp deviceProp;
+    cudaGetDeviceProperties(&deviceProp, dev);
+    std::cerr << "cudaSetDevice GPU" << dev << " = " << deviceProp.name << std::endl;
+
+    checkCudaErrors(cudaSetDevice(dev));
+
+    return dev;
+}
+
+int main(int argc, char *argv[])
+{
+    printf("%s Starting...\n\n", argv[0]);
+
+    try {
+        std::string sFilename;
+        char       *filePath;
+
+        cudaDeviceInit(argc, (const char **)argv);
+
+        NppStreamContext nppStreamCtx;
+        nppStreamCtx.hStream =
+            0; // The NULL stream by default, set this to whatever your stream ID is if not the NULL stream.
+
+        cudaError_t cudaError = cudaGetDevice(&nppStreamCtx.nCudaDeviceId);
+        if (cudaError != cudaSuccess) {
+            printf("CUDA error: no devices supporting CUDA.\n");
+            return NPP_NOT_SUFFICIENT_COMPUTE_CAPABILITY;
+        }
+
+        const NppLibraryVersion *libVer = nppGetLibVersion();
+
+        printf("NPP Library Version %d.%d.%d\n", libVer->major, libVer->minor, libVer->build);
+
+        int driverVersion, runtimeVersion;
+        cudaDriverGetVersion(&driverVersion);
+        cudaRuntimeGetVersion(&runtimeVersion);
+
+        printf("CUDA Driver  Version: %d.%d\n", driverVersion / 1000, (driverVersion % 100) / 10);
+        printf("CUDA Runtime Version: %d.%d\n\n", runtimeVersion / 1000, (runtimeVersion % 100) / 10);
+
+        cudaError = cudaDeviceGetAttribute(&nppStreamCtx.nCudaDevAttrComputeCapabilityMajor,
+                                           cudaDevAttrComputeCapabilityMajor,
+                                           nppStreamCtx.nCudaDeviceId);
+        if (cudaError != cudaSuccess)
+            return NPP_NOT_SUFFICIENT_COMPUTE_CAPABILITY;
+
+        cudaError = cudaDeviceGetAttribute(&nppStreamCtx.nCudaDevAttrComputeCapabilityMinor,
+                                           cudaDevAttrComputeCapabilityMinor,
+                                           nppStreamCtx.nCudaDeviceId);
+        if (cudaError != cudaSuccess)
+            return NPP_NOT_SUFFICIENT_COMPUTE_CAPABILITY;
+
+        cudaError = cudaStreamGetFlags(nppStreamCtx.hStream, &nppStreamCtx.nStreamFlags);
+
+        cudaDeviceProp oDeviceProperties;
+
+        cudaError = cudaGetDeviceProperties(&oDeviceProperties, nppStreamCtx.nCudaDeviceId);
+
+        nppStreamCtx.nMultiProcessorCount         = oDeviceProperties.multiProcessorCount;
+        nppStreamCtx.nMaxThreadsPerMultiProcessor = oDeviceProperties.maxThreadsPerMultiProcessor;
+        nppStreamCtx.nMaxThreadsPerBlock          = oDeviceProperties.maxThreadsPerBlock;
+        nppStreamCtx.nSharedMemPerBlock           = oDeviceProperties.sharedMemPerBlock;
+
+        if (checkCmdLineFlag(argc, (const char **)argv, "input")) {
+            getCmdLineArgumentString(argc, (const char **)argv, "input", &filePath);
+        }
+        else {
+            filePath = sdkFindFilePath("teapot512.pgm", argv[0]);
+        }
+
+        if (filePath) {
+            sFilename = filePath;
+        }
+        else {
+            sFilename = "teapot512.pgm";
+        }
+
+        // if we specify the filename at the command line, then we only test
+        // sFilename[0].
+        int           file_errors = 0;
+        std::ifstream infile(sFilename.data(), std::ifstream::in);
+
+        if (infile.good()) {
+            std::cout << "cannyEdgeDetectionNPP opened: <" << sFilename.data() << "> successfully!" << std::endl;
+            file_errors = 0;
+            infile.close();
+        }
+        else {
+            std::cout << "cannyEdgeDetectionNPP unable to open: <" << sFilename.data() << ">" << std::endl;
+            file_errors++;
+            infile.close();
+        }
+
+        if (file_errors > 0) {
+            exit(EXIT_FAILURE);
+        }
+
+        std::string sResultFilename = sFilename;
+
+        std::string::size_type dot = sResultFilename.rfind('.');
+
+        if (dot != std::string::npos) {
+            sResultFilename = sResultFilename.substr(0, dot);
+        }
+
+        sResultFilename += "_cannyEdgeDetection.pgm";
+
+        if (checkCmdLineFlag(argc, (const char **)argv, "output")) {
+            char *outputFilePath;
+            getCmdLineArgumentString(argc, (const char **)argv, "output", &outputFilePath);
+            sResultFilename = outputFilePath;
+        }
+
+        // declare a host image object for an 8-bit grayscale image
+        npp::ImageCPU_8u_C1 oHostSrc;
+        // load gray-scale image from disk
+        npp::loadImage(sFilename, oHostSrc);
+        // declare a device image and copy construct from the host image,
+        // i.e. upload host to device
+        npp::ImageNPP_8u_C1 oDeviceSrc(oHostSrc);
+
+        NppiSize  oSrcSize   = {(int)oDeviceSrc.width(), (int)oDeviceSrc.height()};
+        NppiPoint oSrcOffset = {0, 0};
+
+        // create struct with ROI size
+        NppiSize oSizeROI = {(int)oDeviceSrc.width(), (int)oDeviceSrc.height()};
+        // allocate device image of appropriately reduced size
+        npp::ImageNPP_8u_C1 oDeviceDst(oSizeROI.width, oSizeROI.height);
+
+        int    nBufferSize       = 0;
+        Npp8u *pScratchBufferNPP = 0;
+
+        // get necessary scratch buffer size and allocate that much device memory
+        NPP_CHECK_NPP(nppiFilterCannyBorderGetBufferSize(oSizeROI, &nBufferSize));
+
+        cudaMalloc((void **)&pScratchBufferNPP, nBufferSize);
+
+        // now run the canny edge detection filter
+        // Using nppiNormL2 will produce larger magnitude values allowing for finer
+        // control of threshold values while nppiNormL1 will be slightly faster.
+        // Also, selecting the sobel gradient filter allows up to a 5x5 kernel size
+        // which can produce more precise results but is a bit slower. Commonly
+        // nppiNormL2 and sobel gradient filter size of 3x3 are used. Canny
+        // recommends that the high threshold value should be about 3 times the low
+        // threshold value. The threshold range will depend on the range of
+        // magnitude values that the sobel gradient filter generates for a
+        // particular image.
+
+        Npp16s nLowThreshold  = 72;
+        Npp16s nHighThreshold = 256;
+
+        if ((nBufferSize > 0) && (pScratchBufferNPP != 0)) {
+            NPP_CHECK_NPP(nppiFilterCannyBorder_8u_C1R_Ctx(oDeviceSrc.data(),
+                                                           oDeviceSrc.pitch(),
+                                                           oSrcSize,
+                                                           oSrcOffset,
+                                                           oDeviceDst.data(),
+                                                           oDeviceDst.pitch(),
+                                                           oSizeROI,
+                                                           NPP_FILTER_SOBEL,
+                                                           NPP_MASK_SIZE_3_X_3,
+                                                           nLowThreshold,
+                                                           nHighThreshold,
+                                                           nppiNormL2,
+                                                           NPP_BORDER_REPLICATE,
+                                                           pScratchBufferNPP,
+                                                           nppStreamCtx));
+        }
+
+        // free scratch buffer memory
+        cudaFree(pScratchBufferNPP);
+
+        // declare a host image for the result
+        npp::ImageCPU_8u_C1 oHostDst(oDeviceDst.size());
+        // and copy the device result data into it
+        oDeviceDst.copyTo(oHostDst.data(), oHostDst.pitch());
+
+        saveImage(sResultFilename, oHostDst);
+        std::cout << "Saved image: " << sResultFilename << std::endl;
+
+        nppiFree(oDeviceSrc.data());
+        nppiFree(oDeviceDst.data());
+
+        exit(EXIT_SUCCESS);
+    }
+    catch (npp::Exception &rException) {
+        std::cerr << "Program error! The following exception occurred: \n";
+        std::cerr << rException << std::endl;
+        std::cerr << "Aborting." << std::endl;
+
+        exit(EXIT_FAILURE);
+    }
+    catch (...) {
+        std::cerr << "Program error! An unknow type of exception occurred. \n";
+        std::cerr << "Aborting." << std::endl;
+
+        exit(EXIT_FAILURE);
+        return -1;
+    }
+
+    return 0;
+}