CUDA 13.4 samples update - v13.4-public

Release 13.4 of the CUDA Samples supported by CUDA Toolkit 13.4.
See Changelog for more information.

.clang-format

@@ -0,0 +1,49 @@
+---
+AccessModifierOffset: -4
+AlignAfterOpenBracket: Align
+AlignConsecutiveAssignments: Consecutive
+AlignConsecutiveDeclarations: Consecutive
+AlignConsecutiveMacros: Consecutive
+AlignEscapedNewlines: Left
+AlignOperands: AlignAfterOperator
+AlignTrailingComments: true
+AllowAllParametersOfDeclarationOnNextLine: false
+BinPackArguments: false
+BinPackParameters: false
+BraceWrapping:
+    AfterClass: true
+    AfterControlStatement: false
+    AfterExternBlock: true
+    AfterFunction: true
+    AfterStruct: true
+    AfterUnion: true
+    BeforeCatch: true
+    BeforeElse: true
+    IndentBraces: false
+BreakBeforeBraces: Custom
+BreakBeforeConceptDeclarations: true
+BreakBeforeBinaryOperators: NonAssignment
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializers: BeforeComma
+BreakInheritanceList: BeforeComma
+ColumnLimit: 120
+DerivePointerAlignment: false
+FixNamespaceComments: true
+IncludeCategories:
+  - Regex:           '^<.*>'
+    Priority:        1
+  - Regex:           '^".*"'
+    Priority:        2
+SortIncludes: true
+IncludeBlocks: Regroup
+IndentWidth: 4
+MaxEmptyLinesToKeep: 2
+PointerAlignment: Right
+SortUsingDeclarations: true
+SpaceAfterCStyleCast: false
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeParens: ControlStatements
+Standard: c++17
+TabWidth: 4
+UseTab: Never
+...

.gitignore

@@ -0,0 +1,12 @@
+build
+build-*/
+test-results*/
+.vs
+.vscode
+.clangd
+test
+settings.json
+launch.json
+__pycache__/
+*.py[co]
+.pytest_cache/

.pre-commit-config.yaml

@@ -0,0 +1,116 @@
+# Copyright (c) 2024, NVIDIA CORPORATION.
+ci:
+    autofix_commit_msg: |
+      [pre-commit.ci] auto code formatting
+    autofix_prs: false
+    autoupdate_branch: ''
+    autoupdate_commit_msg: '[pre-commit.ci] pre-commit autoupdate'
+    autoupdate_schedule: quarterly
+    skip: []
+    submodules: false
+
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+      - id: end-of-file-fixer
+        exclude: |
+          (?x)^(
+            .*\.raw$|
+            .*\.bin$|
+            .*\.dat$|
+            .*\.nv12$|
+            data/.*|
+            Common/.*
+          )
+        files: |
+          (?x)^(
+            .*\.txt$|
+            .*\.md$|
+            .*\.cpp$|
+            .*\.cxx$|
+            .*\.hpp$|
+            .*\.h$|
+            .*\.cu$|
+            .*\.cuh$|
+            .*\.py$|
+            .*\.json$
+          )
+      - id: mixed-line-ending
+        exclude: |
+          (?x)^(
+            .*\.raw$|
+            .*\.bin$|
+            .*\.dat$|
+            .*\.nv12$|
+            data/.*|
+            Common/.*
+          )
+        files: |
+          (?x)^(
+            .*\.txt$|
+            .*\.md$|
+            .*\.cpp$|
+            .*\.cxx$|
+            .*\.hpp$|
+            .*\.h$|
+            .*\.cu$|
+            .*\.cuh$|
+            .*\.py$|
+            .*\.json$
+          )
+      - id: trailing-whitespace
+        exclude: |
+          (?x)^(
+            .*\.raw$|
+            .*\.bin$|
+            .*\.dat$|
+            .*\.nv12$|
+            data/.*|
+            Common/.*
+          )
+        files: |
+          (?x)^(
+            .*\.txt$|
+            .*\.md$|
+            .*\.cpp$|
+            .*\.cxx$|
+            .*\.hpp$|
+            .*\.h$|
+            .*\.cu$|
+            .*\.cuh$|
+            .*\.py$|
+            .*\.json$
+          )
+  - repo: https://github.com/pre-commit/mirrors-clang-format
+    rev: v19.1.6
+    hooks:
+      - id: clang-format
+        types_or: [file]
+        files: |
+          (?x)^(
+            ^.*\.c$|
+            ^.*\.cpp$|
+            ^.*\.cu$|
+            ^.*\.cuh$|
+            ^.*\.cxx$|
+            ^.*\.h$|
+            ^.*\.hpp$|
+            ^.*\.inl$|
+            ^.*\.mm$
+          )
+        exclude: |
+          (?x)^(
+            Common/.*
+          )
+        args: ["-fallback-style=none", "-style=file", "-i"]
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.8.4
+    hooks:
+      - id: ruff
+        name: ruff lint
+        args: [--fix]
+        files: ^python/.*\.py$
+      - id: ruff-format
+        name: ruff format
+        files: ^python/.*\.py$

CHANGELOG.md

@@ -0,0 +1,324 @@
+## Changelog
+
+### CUDA 13.4
+* Removed obsolete samples `simpleHyperQ`, `simpleOccupancy`, `mergeSort`, `simpleTemplates`, `template`, `p2pBandwidthLatencyTest`.
+* Removed redundant `_nvrtc` sample variants (`clock_nvrtc`, `matrixMul_nvrtc`, `simpleAssert_nvrtc`, `simpleAtomicIntrinsics_nvrtc`, `inlinePTX_nvrtc`, `binomialOptions_nvrtc`, `BlackScholes_nvrtc`, `quasirandomGenerator_nvrtc`); `vectorAdd_nvrtc` remains as the canonical NVRTC example.
+* Rewrote `cpp/0_Introduction/simpleMultiGPU` to replace the hand-written reduction with `cub::BlockReduce` and the SDK stopwatch timer with CUDA events, removed helper header dependencies and merged `simpleMultiGPU.h` into the `.cu` for a single-file sample, modernized the code to C++17 (`std::vector`, `constexpr`), and added a minimum two-GPU check; updated README accordingly.
+* Modernized `cpp/3_CUDA_Features/simpleCudaGraphs`: dropped `helper_cuda.h`/`cooperative_groups.h`; used `cub::BlockReduce`; migrated to the unified `cudaGraphAddNode` API; split into `simpleCudaGraphs_explicit` and `simpleCudaGraphs_capture` sharing `simpleCudaGraphs.cuh`; added a graph-reuse demo (fresh input each launch); rewrote README.
+* Rewrote `cpp/0_Introduction/simpleAtomicIntrinsics` to show race conditions by comparing non-atomic vs atomic kernels (`atomicAdd`, `atomicMax`, `atomicCAS`), removed helper header dependencies; updated README accordingly.
+* Reorganized CMake build system for all C++ samples: centralized GPU architecture detection (`DetectCudaArch.cmake`) and common build setup (`CudaSampleCommon.cmake`) into shared modules. Samples with restricted arch support now declare a `SAMPLE_DISALLOW_ARCHS` list instead of hardcoding their own arch list, and are gracefully skipped at configure time when the requested arch is unsupported.
+* Added `sm_103` to the default set of GPU architectures the C++ samples build for.
+* Added `sm_107` to the default set of GPU architectures the C++ samples build for.
+* Rewrote `cpp/0_Introduction/simpleCallback` to replace the deprecated `cudaStreamAddCallback` with `cudaLaunchHostFunc`, replaced the `multithreading.h/.cpp` helpers with standard C++ `std::thread`, and simplified to a single-GPU, single-workload C++17 example; updated README accordingly.
+* Rewrote `cpp/0_Introduction/simpleStreams` to simplify code and remove helper header dependencies; updated README accordingly.
+* Added `python/2_CoreConcepts/persistentProgramCache` to demonstrate persisting and reusing compiled CUDA artifacts with `cuda.core` and `FileStreamProgramCache`.
+* Updated `cpp/0_Introduction/clock` to replace the manual shared-memory tree reduction with `cub::BlockReduce` min-reduction, removed dependency on `helper_cuda.h` and `helper_functions.h`, and updated README.
+* Rewrote `cpp/0_Introduction/vectorAdd` to match the corresponding example in the CUDA Programming Guide. The sample now uses Unified Memory (`cudaMallocManaged`) instead of explicit `cudaMalloc`/`cudaMemcpy`.
+* Restructured the `cpp/0_Introduction/simplePrintf` README with newer style and updated sample code by removing helper dependency.
+* Updated the `cpp/0_Introduction/simpleAssert` README to newer style, simplified code for better understanding.
+* Added `cpp/3_CUDA_Features/dmabufInterop` - a Linux-only CUDA dma-buf interoperability sample demonstrating three scenarios in a single binary: (1) same-process round-trip export/import, (2) cross-process IPC via `fork()` + `SCM_RIGHTS`, and (3) cross-GPU sharing across processes (self-skips on systems without a qualifying GPU pair).
+* Removed the unnecessary `set(CMAKE_POSITION_INDEPENDENT_CODE ON)` from the C++ sample `CMakeLists.txt` files.
+* Removed `CUDA_SEPARABLE_COMPILATION ON` from C++ samples that don't require relocatable device code (kept for the CDP samples).
+* Removed 26 math library samples from `cpp/4_CUDA_Libraries/` that are maintained in the [CUDA Library Samples](https://github.com/NVIDIA/CUDALibrarySamples) repository: cuBLAS (`simpleCUBLAS`, `simpleCUBLAS_LU`, `simpleCUBLASXT`, `matrixMulCUBLAS`, `batchCUBLAS`), cuFFT (`simpleCUFFT`, `simpleCUFFT_MGPU`, `simpleCUFFT_2d_MGPU`, `simpleCUFFT_callback`), cuRAND (`MersenneTwisterGP11213`), cuSOLVER (`cuSolverDn_LinearSolver`, `cuSolverRf`, `cuSolverSp_LinearSolver`, `cuSolverSp_LowlevelCholesky`, `cuSolverSp_LowlevelQR`), cuSPARSE (`conjugateGradient`, `conjugateGradientPrecond`, `conjugateGradientUM`), NPP (`boxFilterNPP`, `cannyEdgeDetectorNPP`, `FilterBorderControlNPP`, `freeImageInteropNPP`, `histEqualizationNPP`, `watershedSegmentationNPP`), and nvJPEG (`nvJPEG`, `nvJPEG_encoder`).
+* Lifted the LLVM 14 upper bound on `cpp/7_libNVVM/cuda-c-linking`, which now builds against LLVM 15 and newer.
+* Added samples for locality domains in `cpp/3_CUDA_FEATURES/localityDomains` and `cpp/3_CUDA_FEATURES/localityDomainsDrv`.
+* Added Windows on Arm support: `cpp/5_Domain_Specific/marchingCubes` now detects the `glew32` GLEW library name used on Windows on Arm, and `cpp/7_libNVVM` searches the `nvvm/lib/arm64` directory for libNVVM.
+
+### CUDA 13.3
+* Added **CUDA Tile C++** samples under `cpp/9_CUDA_Tile`.
+* Added a set of **CCCL 3.3 feature samples** under `cpp/4_CUDA_Libraries/`, each built against CCCL fetched via CPM (pinned to v3.3.3, with an optional `CCCL_SOURCE_DIR` override):
+    * `cubDeviceFind` - `cub::DeviceFind::FindIf`, `LowerBound`, and `UpperBound` device-wide search algorithms.
+    * `cubDeviceSegmentedScan` - `cub::DeviceSegmentedScan::ExclusiveSegmentedSum` and `InclusiveSegmentedScan` with a custom binary operator.
+    * `cubDeviceTransform` - N-to-M `cub::DeviceTransform::Transform` where the op returns a `cuda::std::tuple`.
+    * `libcuxxRandom` - `cuda::pcg64` and `cuda::std::philox4x32` engines driving the uniform, normal, Poisson, and Bernoulli distributions from `<cuda/std/random>`.
+    * `libcuxxMdspan` - DLPack <-> `cuda::std::mdspan` bridging via `cuda::to_device_mdspan` / `cuda::to_dlpack_tensor`, plus `cuda::shared_memory_mdspan` for multi-dimensional views of shared memory.
+* Added **cuda.compute 1.0 Python samples** under `python/2_CoreConcepts/`:
+    * `cudaComputeLambdas` - Python lambdas / regular callables driving `reduce_into`, `unary_transform`, and `inclusive_scan` in `cuda.compute` (from the `cuda-cccl` package).
+    * `binarySearch` - parallel `cuda.compute.upper_bound` / `lower_bound`, verified against `numpy.searchsorted`.
+
+
+### CUDA 13.2 (update)
+* Added **CUDA Python samples** under `python/`. These scripts use [CUDA Python](https://nvidia.github.io/cuda-python/) (including `cuda.core`) and are organized like the C++ tree: `1_GettingStarted`, `2_CoreConcepts`, `3_FrameworkInterop`, and `4_DistributedComputing`, plus shared helpers in `python/Utilities`. Each sample includes a `README.md` and `requirements.txt`. They are **not** built by the root CMake project; install dependencies with `pip install -r requirements.txt` in the sample directory, then run the corresponding `.py` file as documented in that sample’s README.
+* Renamed top-level `Samples` directory to `cpp` to accommodate Python samples alongside existing C++ samples; updated path references in `CMakeLists.txt`, `README.md`, and `Common` headers accordingly.
+
+### CUDA 13.2
+* Added the MSVC compile flag `-Xcompiler=/Zc:preprocessor` in CMakeLists.txt to comply with CUDA13.2 CCCL. Previously, using the traditional preprocessor triggered the warning “MSVC/cl.exe with traditional preprocessor is used…”, which now leads to a build error.
+
+### CUDA 13.1
+* Minor bug fixes and enhancements, no structural or functional changes
+
+### CUDA 13.0
+* Updated the samples using the cudaDeviceProp fields which are deprecated and removed in CUDA 13.0, replacing the fields with the equivalents in "cudaDeviceGetAttribute":
+    * Deprecated "cudaDeviceProp" fields
+        `int clockRate; // - Replaced with "cudaDevAttrClockRate"`
+        `int deviceOverlap; // - Replaced with "cudaDevAttrGpuOverlap */`
+        `int kernelExecTimeoutEnabled; // - Replaced with "cudaDevAttrKernelExecTimeout`
+        `int computeMode; // - Replaced with "cudaDevAttrComputeMode" */`
+        `int memoryClockRate; // - Replaced with "cudaDevAttrMemoryClockRate"`
+        `int cooperativeMultiDeviceLaunch; // - Deprecated, cudaLaunchCooperativeKernelMultiDevice is deprecated.`
+    * `0_Introduction`
+        * `UnifiedMemoryStreams`
+        * `simpleHyperQ`
+        * `simpleIPC`
+        * `simpleMultiCopy`
+        * `systemWideAtomics`
+    * `1_Utilitie`
+        * `deviceQuery`
+    * `2_Concepts_and_Techniques`
+        * `streamOrderedAllocationIPC`
+    * `4_CUDA_Libraries`
+        * `simpleCUBLASXT`
+    * `5_Domain_Specific`
+        * `simpleVulkan`
+        * `vulkanImageCUDA`
+* Updated the samples using the CUDA driver API "cuCtxCreate" with adding the parameter "CUctxCreateParams" as "cuCtxCreate" is updated to "cuCtxCreate_v4" by default in CUDA 13.0:
+    * `Common`
+        * `nvrtc_helper.h`
+    * `0_Introduction`
+        * `UnifiedMemoryStreams`
+        * `matrixMulDrv`
+        * `simpleTextureDrv`
+        * `vectorAddDrv`
+        * `vectorAddMMAP`
+    * `2_Concepts_and_Techniques`
+        * `EGLStream_CUDA_CrossGPU`
+        * `EGLStream_CUDA_Interop`
+        * `threadMigration`
+    * `3_CUDA_Features`
+        * `graphMemoryFootprint`
+        * `memMapIPCDrv`
+    * `4_CUDA_Libraries`
+        * `jitLto`
+    * `7_libNVVM`
+        * `cuda-c-linking`
+        * `device-side-launch`
+        * `simple`
+        * `uvmlite`
+    * `8_Platform_Specific/Tegra`
+        * `EGLSync_CUDAEvent_Interop`
+* Updated the sample using CUDA API "cudaGraphAddNode"/"cudaStreamGetCaptureInfo" with adding "cudaGraphEdgeData" pointer parameter as they are updated to "cudaGraphAddNode_v2"/"cudaStreamGetCaptureInfo_v3" by default in CUDA 13.0:
+    * `3_CUDA_Features`
+        * `graphConditionalNodes`
+* Updated the samples using CUDA API "cudaMemAdvise"/"cudaMemPrefetchAsync" with changing the parameter "int device" to "cudaMemLocation location" as they are updated to "cudaMemAdvise_v2"/"cudaMemPrefetchAsyn_v2" by default in CUDA 13.0.
+    * `4_CUDA_Libraries`
+        * `conjugateGradientMultiDeviceCG`
+    * `6_Performance`
+        * `UnifiedMemoryPerf`
+* Replaced "thrust::identity<uint>()" with "cuda::std::identity()" as it is deprecated in CUDA 13.0.
+    * `2_Concepts_and_Techniques`
+        * `segmentationTreeThrust`
+* Updated the the headers file and samples for CUFFT error codes update.
+    * Deprecated CUFFT errors:
+        * `CUFFT_INCOMPLETE_PARAMETER_LIST`
+        * `CUFFT_PARSE_ERROR`
+        * `CUFFT_LICENSE_ERROR`
+    * New added CUFFT errors:
+        * `CUFFT_MISSING_DEPENDENCY`
+        * `CUFFT_NVRTC_FAILURE`
+        * `CUFFT_NVJITLINK_FAILURE`
+        * `CUFFT_NVSHMEM_FAILURE`
+    * Header files and samples that are related with this change:
+        * `Common/helper_cuda.h`
+        * `4_CUDA_Libraries`
+            * `simpleCUFFT`
+            * `simpleCUFFT_2d_MGPU`
+            * `simpleCUFFT_MGPU`
+            * `simpleCUFFT_callback`
+* Updated toolchain for cross-compilation for Tegra QNX platforms.
+
+### CUDA 12.9
+* Updated toolchain for cross-compilation for Tegra Linux platforms.
+* Added `run_tests.py` utility to exercise all samples. See README.md for details
+* Repository has been updated with consistent code formatting across all samples
+* Many small code tweaks and bug fixes (see commit history for details)
+* Removed the following outdated samples:
+  * `1_Utilities`
+    * `bandwidthTest` - this sample was out of date and did not produce accurate results. For bandwidth
+    testing of NVIDIA GPU platforms, please refer to [NVBandwidth](https://github.com/NVIDIA/nvbandwidth)
+
+### CUDA 12.8
+* Updated build system across the repository to CMake. Removed Visual Studio project files and Makefiles.
+* Removed the following outdated samples:
+    * `0_Introduction`
+        * `c++11_cuda` demonstrating CUDA and C++ 11 interoperability (reason: obsolete)
+        * `concurrentKernels` demonstrating the ability to run multiple kernels simultaneously (reason: obsolete)
+        * `cppIntegration` demonstrating calling between .cu and .cpp files (reason: obsolete)
+        * `cppOverload` demonstrating C++ function overloading (reason: obsolete)
+        * `simpleSeparateCompilation` demonstrating NVCC compilation to a static library (reason: trivial)
+        * `simpleTemplates_nvrtc` demonstrating NVRTC usage for `simpleTemplates` sample (reason: redundant)
+        * `simpleVoteIntrinsics_nvrtc` demonstrating NVRTC usage for `simpleVoteIntrinsics` sample (reason: redundant)
+    * `2_Concepts_and_Techniques`
+        * `cuHook` demonstrating dlsym hooks. (reason: incompatible with modern `glibc`)
+    * `4_CUDA_Libraries`
+        * `batchedLabelMarkersAndLabelCompressionNPP` demonstrating NPP features (reason: some functionality removed from library)
+    * `5_Domain_Specific`
+        * Legacy Direct3D 9 and 10 interoperability samples:
+            * `fluidsD3D9`
+            * `simpleD3D10`
+            * `simpleD3D10RenderTarget`
+            * `simpleD3D10Texture`
+            * `simpleD3D9`
+            * `simpleD3D9Texture`
+            * `SLID3D10Texture`
+            * `VFlockingD3D10`
+    * `8_Platform_Specific/Tegra`
+        * Temporarily removed the following two samples pending updates:
+            * `nbody_screen` demonstrating the nbody sample in QNX
+            * `simpleGLES_screen` demonstrating GLES interop in QNX
+* Moved the following Tegra-specific samples to a dedicated subdirectory: `8_Platform_Specific/Tegra`
+    * `EGLSync_CUDAEvent_Interop`
+    * `cuDLAErrorReporting`
+    * `cuDLAHybridMode`
+    * `cuDLALayerwiseStatsHybrid`
+    * `cuDLALayerwiseStatsStandalone`
+    * `cuDLAStandaloneMode`
+    * `cudaNvSciBufMultiplanar`
+    * `cudaNvSciNvMedia`
+    * `fluidsGLES`
+    * `nbody_opengles`
+    * `simpleGLES`
+    * `simpleGLES_EGLOutput`
+
+
+
+### CUDA 12.5
+
+### CUDA 12.4
+* Added graphConditionalNodes Sample
+
+### CUDA 12.3
+* Added cuDLA samples
+* Fixed jitLto regression
+
+### CUDA 12.2
+* libNVVM samples received updates
+* Fixed jitLto Case issues
+* Enabled HOST_COMPILER flag to the makefiles for GCC which is untested but may still work.
+
+### CUDA 12.1
+* Added new sample for Large Kernels
+
+### CUDA 12.0
+* Added new flags for JIT compiling
+* Removed deprecated APIs in Hopper Architecture
+
+### CUDA 11.6
+* Added new folder structure for samples
+* Added support of Visual Studio 2022 to all samples supported on [Windows](#windows-1).
+* All CUDA samples are now only available on [GitHub](https://github.com/nvidia/cuda-samples). They are no longer available via CUDA toolkit.
+
+### CUDA 11.5
+* Added `cuDLAHybridMode`. Demonstrate usage of cuDLA in hybrid mode.
+* Added `cuDLAStandaloneMode`. Demonstrate usage of cuDLA in standalone mode.
+* Added `cuDLAErrorReporting`. Demonstrate DLA error detection via CUDA.
+* Added `graphMemoryNodes`. Demonstrates memory allocations and frees within CUDA graphs using Graph APIs and Stream Capture APIs.
+* Added `graphMemoryFootprint`. Demonstrates how graph memory nodes re-use virtual addresses and physical memory.
+* All samples from CUDA toolkit are now available on [GitHub](https://github.com/nvidia/cuda-samples).
+
+### CUDA 11.4 update 1
+* Added support for VS Code on linux platform.
+
+### CUDA 11.4
+* Added `cdpQuadtree`. Demonstrates Quad Trees implementation using CUDA Dynamic Parallelism.
+* Updated `simpleVulkan`, `simpleVulkanMMAP` and `vulkanImageCUDA`. Demonstrates use of SPIR-V shaders.
+
+### CUDA 11.3
+*  Added `streamOrderedAllocationIPC`. Demonstrates Inter Process Communication using one process per GPU for computation.
+*  Added `simpleCUBLAS_LU`. Demonstrates batched matrix LU decomposition using cuBLAS API `cublas<t>getrfBatched()`
+*  Updated `simpleVulkan`. Demonstrates use of timeline semaphore.
+*  Updated multiple samples to use pinned memory using `cudaMallocHost()`.
+
+### CUDA 11.2
+*  Added `streamOrderedAllocation`. Demonstrates stream ordered memory allocation on a GPU using cudaMallocAsync and cudaMemPool family of APIs.
+*  Added `streamOrderedAllocationP2P`. Demonstrates peer-to-peer access of stream ordered memory allocated using cudaMallocAsync and cudaMemPool family of APIs.
+*  Dropped Visual Studio 2015 support from all the windows supported samples.
+*  FreeImage is no longer distributed with the CUDA Samples. On Windows, see the [Dependencies](./README.md#freeimage) section for more details on how to set up FreeImage. On Linux, it is recommended to install FreeImage with your distribution's package manager.
+*  All the samples using CUDA Pipeline & Arrive-wait barriers are been updated to use new `cuda::pipeline` and `cuda::barrier` interfaces.
+*  Updated all the samples to build with parallel build option `--threads` of `nvcc` cuda compiler.
+*  Added `cudaNvSciNvMedia`. Demonstrates CUDA-NvMedia interop via NvSciBuf/NvSciSync APIs.
+*  Added `simpleGL`. Demonstrates interoperability between CUDA and OpenGL.
+
+### CUDA 11.1
+*  Added `watershedSegmentationNPP`. Demonstrates how to use the NPP watershed segmentation function.
+*  Added `batchedLabelMarkersAndLabelCompressionNPP`. Demonstrates how to use the NPP label markers generation and label compression functions based on a Union Find (UF) algorithm including both single image and batched image versions.
+*  Dropped Visual Studio 2012, 2013 support from all the windows supported samples.
+*  Added kernel performing warp aggregated atomic max in multi buckets using cg::labeled_partition & cg::reduce in `warpAggregatedAtomicsCG`.
+*  Added extended CG shuffle mechanics to `shfl_scan` sample.
+*  Added `cudaOpenMP`. Demonstrates how to use OpenMP API to write an application for multiple GPUs.
+*  Added `simpleZeroCopy`. Demonstrates how to use zero copy, kernels can read and write directly to pinned system memory.
+
+### CUDA 11.0
+*  Added `dmmaTensorCoreGemm`. Demonstrates double precision GEMM computation using the Double precision Warp Matrix Multiply and Accumulate (WMMA) API introduced with CUDA 11 in Ampere chip family tensor cores.
+*  Added `bf16TensorCoreGemm`. Demonstrates __nv_bfloat16 (e8m7) GEMM computation using the __nv_bfloat16 WMMA API introduced with CUDA 11 in Ampere chip family tensor cores.
+*  Added `tf32TensorCoreGemm`. Demonstrates tf32 (e8m10) GEMM computation using the tf32 WMMA API introduced with CUDA 11 in Ampere chip family tensor cores.
+*  Added `globalToShmemAsyncCopy`. Demonstrates async copy of data from global to shared memory when on compute capability 8.0 or higher. Also demonstrates arrive-wait barrier for synchronization.
+*  Added `simpleAWBarrier`. Demonstrates arrive wait barriers.
+*  Added `simpleAttributes`. Demonstrates the stream attributes that affect L2 locality.
+*  Added warp aggregated atomic multi bucket increments kernel using labeled_partition cooperative groups in `warpAggregatedAtomicsCG` which can be used on compute capability 7.0 and above GPU architectures.
+*  Added `binaryPartitionCG`. Demonstrates  binary partition cooperative groups and reduction within the thread block.
+*  Added two new reduction kernels in `reduction` one which demonstrates reduce_add_sync intrinstic supported on compute capability 8.0 and another which uses cooperative_groups::reduce function which does thread_block_tile level reduction introduced from CUDA 11.0.
+*  Added `cudaCompressibleMemory`. Demonstrates compressible memory allocation using cuMemMap API.
+*  Added `simpleVulkanMMAP`. Demonstrates Vulkan CUDA Interop via cuMemMap APIs.
+*  Added `concurrentKernels`. Demonstrates the use of CUDA streams for concurrent execution of several kernels on a GPU.
+*  Dropped Mac OSX support from all samples.
+
+### CUDA 10.2
+*  Added `simpleD3D11`. Demonstrates CUDA-D3D11 External Resource Interoperability APIs for updating D3D11 buffers from CUDA and synchronization between D3D11 and CUDA with Keyed Mutexes.
+*  Added `simpleDrvRuntime`. Demonstrates CUDA Driver and Runtime APIs working together to load fatbinary of a CUDA kernel.
+*  Added `vectorAddMMAP`. Demonstrates how cuMemMap API allows the user to specify the physical properties of their memory while retaining the contiguous nature of their access.
+*  Added `memMapIPCDrv`. Demonstrates Inter Process Communication using cuMemMap APIs.
+*  Added `cudaNvSci`. Demonstrates CUDA-NvSciBuf/NvSciSync Interop.
+*  Added `jacobiCudaGraphs`. Demonstrates Instantiated CUDA Graph Update with Jacobi Iterative Method using different approaches.
+*  Added `cuSolverSp_LinearSolver`. Demonstrates cuSolverSP's LU, QR and Cholesky factorization.
+*  Added `MersenneTwisterGP11213`. Demonstrates the Mersenne Twister random number generator GP11213 in cuRAND.
+
+### CUDA 10.1 Update 2
+*  Added `vulkanImageCUDA`. Demonstrates how to perform Vulkan image - CUDA Interop.
+*  Added `nvJPEG_encoder`. Demonstrates encoding of jpeg images using NVJPEG Library.
+*  Added Windows OS support to `nvJPEG` sample.
+*  Added `boxFilterNPP`. Demonstrates how to use NPP FilterBox function to perform a box filter.
+*  Added `cannyEdgeDetectorNPP`. Demonstrates the nppiFilterCannyBorder_8u_C1R Canny Edge Detection image filter function.
+
+### CUDA 10.1 Update 1
+*  Added `NV12toBGRandResize`. Demonstrates how to convert and resize NV12 frames to BGR planars frames using CUDA in batch.
+*  Added `EGLStream_CUDA_Interop`. Demonstrates data exchange between CUDA and EGL Streams.
+*  Added `cuSolverDn_LinearSolver`. Demonstrates cuSolverDN's LU, QR and Cholesky factorization.
+*  Added support of Visual Studio 2019 to all samples supported on [Windows](./README.md#windows-1).
+
+### CUDA 10.1
+*  Added `immaTensorCoreGemm`. Demonstrates integer GEMM computation using the Warp Matrix Multiply and Accumulate (WMMA) API for integers employing the Tensor Cores.
+*  Added `simpleIPC`. Demonstrates Inter Process Communication with one process per GPU for computation.
+*  Added `nvJPEG`. Demonstrates single and batched decoding of jpeg images using NVJPEG Library.
+*  Added `bandwidthTest`. It measures the memcopy bandwidth of the GPU and memcpy bandwidth across PCI-e.
+*  Added `reduction`. Demonstrates several important optimization strategies for Data-Parallel Algorithms like reduction.
+*  Update all the samples to support CUDA 10.1.
+
+
+### CUDA 10.0
+*  Added `simpleCudaGraphs`. Demonstrates CUDA Graphs creation, instantiation and launch using Graphs APIs and Stream Capture APIs.
+*  Added `conjugateGradientCudaGraphs`. Demonstrates conjugate gradient solver on GPU using CUBLAS and CUSPARSE library calls captured and called using CUDA Graph APIs.
+*  Added `simpleVulkan`. Demonstrates Vulkan - CUDA Interop.
+*  Added `simpleD3D12`. Demonstrates DX12 - CUDA Interop.
+*  Added `UnifiedMemoryPerf`. Demonstrates performance comparision of various memory types involved in system.
+*  Added `p2pBandwidthLatencyTest`. Demonstrates Peer-To-Peer (P2P) data transfers between pairs of GPUs and computes latency and bandwidth.
+*  Added `systemWideAtomics`. Demonstrates system wide atomic instructions.
+*  Added `simpleCUBLASXT`. Demonstrates CUBLAS-XT library which performs GEMM operations over multiple GPUs.
+*  Added Windows OS support to `conjugateGradientMultiDeviceCG` sample.
+*  Removed support of Visual Studio 2010 from all samples.
+
+
+### CUDA 9.2
+
+This is the first release of CUDA Samples on GitHub:
+*  Added `vectorAdd_nvrtc`. Demonstrates runtime compilation library using NVRTC of a simple vectorAdd kernel.
+*  Added `warpAggregatedAtomicsCG`. Demonstrates warp aggregated atomics using Cooperative Groups.
+*  Added `deviceQuery`. Enumerates the properties of the CUDA devices present in the system.
+*  Added `matrixMul`. Demonstrates a matrix multiplication using shared memory through tiled approach.
+*  Added `matrixMulDrv`. Demonstrates a matrix multiplication using shared memory through tiled approach, uses CUDA Driver API.
+*  Added `cudaTensorCoreGemm`. Demonstrates a GEMM computation using the Warp Matrix Multiply and Accumulate (WMMA) API introduced in CUDA 9, as well as the new Tensor Cores introduced in the Volta chip family.
+*  Added `simpleVoteIntrinsics` which uses *_sync equivalent of the vote intrinsics _any, _all added since CUDA 9.0.
+*  Added `shfl_scan` which uses *_sync equivalent of the shfl intrinsics added since CUDA 9.0.
+*  Added `conjugateGradientMultiBlockCG`. Demonstrates a conjugate gradient solver on GPU using Multi Block Cooperative Groups.
+*  Added `conjugateGradientMultiDeviceCG`. Demonstrates a conjugate gradient solver on multiple GPUs using Multi Device Cooperative Groups, also uses unified memory prefetching and usage hints APIs.
+*  Added `simpleCUBLAS`. Demonstrates how perform GEMM operations using CUBLAS library.
+*  Added `simpleCUFFT`. Demonstrates how perform FFT operations using CUFFT library.

CMakeLists.txt

@@ -0,0 +1,31 @@
+cmake_minimum_required(VERSION 3.20)
+
+include(cmake/CudaSampleArchs.cmake)
+
+# Default to all supported architectures if the user does not specify.
+# Gated on CUDA_SAMPLES_ARCHS_DEFAULTED rather than CMAKE_CUDA_ARCHITECTURES so this
+# decision is made once (on the first configure) and does not flip on reconfigure,
+# when CMAKE_CUDA_ARCHITECTURES is already defined from our own cached default.
+# The decision is revisited when the list itself moves, which the user can do with -D
+# on any later configure of the same build directory. Keep the list each configure
+# ends up with, so that such a change is told apart from our own cached default.
+if(NOT DEFINED CUDA_SAMPLES_ARCHS_DEFAULTED)
+    if(NOT DEFINED CMAKE_CUDA_ARCHITECTURES)
+        list(JOIN CUDA_SAMPLES_MASTER_ARCHS ";" _default_archs)
+        set(CMAKE_CUDA_ARCHITECTURES "${_default_archs}" CACHE STRING "CUDA architectures")
+        unset(_default_archs)
+        set(CUDA_SAMPLES_ARCHS_DEFAULTED TRUE CACHE INTERNAL "")
+    else()
+        set(CUDA_SAMPLES_ARCHS_DEFAULTED FALSE CACHE INTERNAL "")
+    endif()
+elseif(NOT "${CMAKE_CUDA_ARCHITECTURES}" STREQUAL "${CUDA_SAMPLES_LAST_CONFIGURED_ARCHS}")
+    set(CUDA_SAMPLES_ARCHS_DEFAULTED FALSE CACHE INTERNAL "")
+endif()
+
+set(CUDA_SAMPLES_LAST_CONFIGURED_ARCHS "${CMAKE_CUDA_ARCHITECTURES}" CACHE INTERNAL "")
+
+project(cuda-samples LANGUAGES C CXX CUDA)
+
+include(cmake/CudaSampleCommon.cmake)
+
+add_subdirectory(cpp)

CONTRIBUTING.md

@@ -0,0 +1,103 @@
+
+# Contributing to the CUDA Samples
+
+Thank you for your interest in contributing to the CUDA Samples!
+
+
+## Getting Started
+
+1. **Fork & Clone the Repository**:
+
+   Fork the reporistory and clone the fork. For more information, check [GitHub's documentation on forking](https://docs.github.com/en/github/getting-started-with-github/fork-a-repo) and [cloning a repository](https://docs.github.com/en/github/creating-cloning-and-archiving-repositories/cloning-a-repository).
+
+## Making Changes
+
+1. **Create a New Branch**:
+
+   ```bash
+   git checkout -b your-feature-branch
+   ```
+
+2. **Make Changes**.
+
+3. **Build and Test**:
+
+   Ensure changes don't break existing functionality by building and running tests.
+
+   For more details on building and testing, refer to the [Building and Testing](#building-and-testing) section below.
+
+4. **Commit Changes**:
+
+   ```bash
+   git commit -m "Brief description of the change"
+   ```
+
+## Building and Testing
+
+For information on building a running tests on the samples, please refer to the main [README](README.md)
+
+## Creating a Pull Request
+
+1. Push changes to your fork
+2. Create a pull request targeting the `master` branch of the original CUDA Samples repository. Refer to [GitHub's documentation](https://docs.github.com/en/github/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/about-pull-requests) for more information on creating a pull request.
+3. Describe the purpose and context of the changes in the pull request description.
+
+## Code Formatting (pre-commit hooks)
+
+The CUDA Samples repository uses [pre-commit](https://pre-commit.com/) to execute all code linters and formatters. These
+tools ensure a consistent coding style throughout the project. Using pre-commit ensures that linter
+versions and options are aligned for all developers. Additionally, there is a CI check in place to
+enforce that committed code follows our standards.
+
+The linters used by the CUDA Samples are listed in `.pre-commit-config.yaml`.
+For example, C++ and CUDA code is formatted with [`clang-format`](https://clang.llvm.org/docs/ClangFormat.html).
+
+To use `pre-commit`, install via `conda` or `pip`:
+
+```bash
+conda config --add channels conda-forge
+conda install pre-commit
+```
+
+```bash
+pip install pre-commit
+```
+
+Then run pre-commit hooks before committing code:
+
+```bash
+pre-commit run
+```
+
+By default, pre-commit runs on staged files (only changes and additions that will be committed).
+To run pre-commit checks on all files, execute:
+
+```bash
+pre-commit run --all-files
+```
+
+Optionally, you may set up the pre-commit hooks to run automatically when you make a git commit. This can be done by running:
+
+```bash
+pre-commit install
+```
+
+Now code linters and formatters will be run each time you commit changes.
+
+You can skip these checks with `git commit --no-verify` or with the short version `git commit -n`, althoguh please note
+that this may result in pull requests being rejected if subsequent checks fail.
+
+## Review Process
+
+Once submitted, maintainers will be automatically assigned to review the pull request. They might suggest changes or improvements. Constructive feedback is a part of the collaborative process, aimed at ensuring the highest quality code.
+
+For constructive feedback and effective communication during reviews, we recommend following [Conventional Comments](https://conventionalcomments.org/).
+
+Further recommended reading for successful PR reviews:
+
+- [How to Do Code Reviews Like a Human (Part One)](https://mtlynch.io/human-code-reviews-1/)
+- [How to Do Code Reviews Like a Human (Part Two)](https://mtlynch.io/human-code-reviews-2/)
+
+## Thank You
+
+Your contributions enhance the CUDA Samples for the entire community. We appreciate your effort and collaboration!

Common/GL/freeglut.h

@@ -0,0 +1,22 @@
+#ifndef  __FREEGLUT_H__
+#define  __FREEGLUT_H__
+
+/*
+ * freeglut.h
+ *
+ * The freeglut library include file
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * PAWEL W. OLSZTA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "freeglut_std.h"
+#include "freeglut_ext.h"
+
+/*** END OF FILE ***/
+
+#endif /* __FREEGLUT_H__ */

Common/GL/freeglut_ext.h

@@ -0,0 +1,115 @@
+#ifndef  __FREEGLUT_EXT_H__
+#define  __FREEGLUT_EXT_H__
+
+/*
+ * freeglut_ext.h
+ *
+ * The non-GLUT-compatible extensions to the freeglut library include file
+ *
+ * Copyright (c) 1999-2000 Pawel W. Olszta. All Rights Reserved.
+ * Written by Pawel W. Olszta, <olszta@sourceforge.net>
+ * Creation date: Thu Dec 2 1999
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * PAWEL W. OLSZTA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * GLUT API Extension macro definitions -- behaviour when the user clicks on an "x" to close a window
+ */
+#define GLUT_ACTION_EXIT                         0
+#define GLUT_ACTION_GLUTMAINLOOP_RETURNS         1
+#define GLUT_ACTION_CONTINUE_EXECUTION           2
+
+/*
+ * Create a new rendering context when the user opens a new window?
+ */
+#define GLUT_CREATE_NEW_CONTEXT                  0
+#define GLUT_USE_CURRENT_CONTEXT                 1
+
+/*
+ * GLUT API Extension macro definitions -- the glutGet parameters
+ */
+#define  GLUT_ACTION_ON_WINDOW_CLOSE        0x01F9
+
+#define  GLUT_WINDOW_BORDER_WIDTH           0x01FA
+#define  GLUT_WINDOW_HEADER_HEIGHT          0x01FB
+
+#define  GLUT_VERSION                       0x01FC
+
+#define  GLUT_RENDERING_CONTEXT             0x01FD
+
+/*
+ * Process loop function, see freeglut_main.c
+ */
+FGAPI void    FGAPIENTRY glutMainLoopEvent(void);
+FGAPI void    FGAPIENTRY glutLeaveMainLoop(void);
+
+/*
+ * Window-specific callback functions, see freeglut_callbacks.c
+ */
+FGAPI void    FGAPIENTRY glutMouseWheelFunc(void (* callback)(int, int, int, int));
+FGAPI void    FGAPIENTRY glutCloseFunc(void (* callback)(void));
+FGAPI void    FGAPIENTRY glutWMCloseFunc(void (* callback)(void));
+/* A. Donev: Also a destruction callback for menus */
+FGAPI void    FGAPIENTRY glutMenuDestroyFunc(void (* callback)(void));
+
+/*
+ * State setting and retrieval functions, see freeglut_state.c
+ */
+FGAPI void    FGAPIENTRY glutSetOption(GLenum option_flag, int value) ;
+/* A.Donev: User-data manipulation */
+FGAPI void   *FGAPIENTRY glutGetWindowData(void);
+FGAPI void    FGAPIENTRY glutSetWindowData(void *data);
+FGAPI void   *FGAPIENTRY glutGetMenuData(void);
+FGAPI void    FGAPIENTRY glutSetMenuData(void *data);
+
+/*
+ * Font stuff, see freeglut_font.c
+ */
+FGAPI int     FGAPIENTRY glutBitmapHeight(void *font);
+FGAPI GLfloat FGAPIENTRY glutStrokeHeight(void *font);
+FGAPI void    FGAPIENTRY glutBitmapString(void *font, const unsigned char *string);
+FGAPI void    FGAPIENTRY glutStrokeString(void *font, const unsigned char *string);
+
+/*
+ * Geometry functions, see freeglut_geometry.c
+ */
+FGAPI void    FGAPIENTRY glutWireRhombicDodecahedron(void);
+FGAPI void    FGAPIENTRY glutSolidRhombicDodecahedron(void);
+FGAPI void    FGAPIENTRY glutWireSierpinskiSponge(int num_levels, GLdouble offset[3], GLdouble scale) ;
+FGAPI void    FGAPIENTRY glutSolidSierpinskiSponge(int num_levels, GLdouble offset[3], GLdouble scale) ;
+FGAPI void    FGAPIENTRY glutWireCylinder(GLdouble radius, GLdouble height, GLint slices, GLint stacks);
+FGAPI void    FGAPIENTRY glutSolidCylinder(GLdouble radius, GLdouble height, GLint slices, GLint stacks);
+
+/*
+ * Extension functions, see freeglut_ext.c
+ */
+FGAPI void *FGAPIENTRY glutGetProcAddress(const char *procName);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+/*** END OF FILE ***/
+
+#endif /* __FREEGLUT_EXT_H__ */

Common/GL/freeglut_std.h

@@ -0,0 +1,547 @@
+#ifndef  __FREEGLUT_STD_H__
+#define  __FREEGLUT_STD_H__
+
+/*
+ * freeglut_std.h
+ *
+ * The GLUT-compatible part of the freeglut library include file
+ *
+ * Copyright (c) 1999-2000 Pawel W. Olszta. All Rights Reserved.
+ * Written by Pawel W. Olszta, <olszta@sourceforge.net>
+ * Creation date: Thu Dec 2 1999
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * PAWEL W. OLSZTA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Under windows, we have to differentiate between static and dynamic libraries
+ */
+#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
+#    include <windows.h>
+#    include <windowsx.h>
+#    include <mmsystem.h>
+#    define WINDOWS
+#ifdef FREEGLUT_STATIC
+#    define FGAPI
+#    define FGAPIENTRY
+
+#    pragma comment (lib, "freeglut_static.lib")    /* link with Win32 static freeglut lib */
+
+#else
+
+#        if defined(FREEGLUT_EXPORTS)
+#                define FGAPI __declspec(dllexport)
+/* #                define FGAPI */
+#        else
+#                define FGAPI __declspec(dllimport)
+#   pragma comment (lib, "freeglut.lib")    /* link with Win32 freeglut lib */
+#        endif
+#        define FGAPIENTRY __stdcall
+
+#endif
+
+#pragma comment (lib, "winmm.lib")       /* link with Windows MultiMedia lib */
+#pragma comment (lib, "user32.lib") /* link with Windows user lib */
+#pragma comment (lib, "gdi32.lib") /* link with Windows GDI lib */
+#pragma comment (lib, "opengl32.lib")    /* link with Microsoft OpenGL lib */
+#pragma comment (lib, "glu32.lib")       /* link with OpenGL Utility lib */
+
+
+#else
+#        define FGAPI
+#        define FGAPIENTRY
+#endif
+
+/*
+ * The freeglut and GLUT API versions
+ */
+#define  FREEGLUT             1
+#define  GLUT_API_VERSION     4
+#define  FREEGLUT_VERSION_2_0 1
+
+/*
+ * Always include OpenGL and GLU headers
+ */
+#include <GL/gl.h>
+#include <GL/glu.h>
+
+/*
+ * GLUT API macro definitions -- the special key codes:
+ */
+#define  GLUT_KEY_F1                        0x0001
+#define  GLUT_KEY_F2                        0x0002
+#define  GLUT_KEY_F3                        0x0003
+#define  GLUT_KEY_F4                        0x0004
+#define  GLUT_KEY_F5                        0x0005
+#define  GLUT_KEY_F6                        0x0006
+#define  GLUT_KEY_F7                        0x0007
+#define  GLUT_KEY_F8                        0x0008
+#define  GLUT_KEY_F9                        0x0009
+#define  GLUT_KEY_F10                       0x000A
+#define  GLUT_KEY_F11                       0x000B
+#define  GLUT_KEY_F12                       0x000C
+#define  GLUT_KEY_LEFT                      0x0064
+#define  GLUT_KEY_UP                        0x0065
+#define  GLUT_KEY_RIGHT                     0x0066
+#define  GLUT_KEY_DOWN                      0x0067
+#define  GLUT_KEY_PAGE_UP                   0x0068
+#define  GLUT_KEY_PAGE_DOWN                 0x0069
+#define  GLUT_KEY_HOME                      0x006A
+#define  GLUT_KEY_END                       0x006B
+#define  GLUT_KEY_INSERT                    0x006C
+
+/*
+ * GLUT API macro definitions -- mouse state definitions
+ */
+#define  GLUT_LEFT_BUTTON                   0x0000
+#define  GLUT_MIDDLE_BUTTON                 0x0001
+#define  GLUT_RIGHT_BUTTON                  0x0002
+#define  GLUT_DOWN                          0x0000
+#define  GLUT_UP                            0x0001
+#define  GLUT_LEFT                          0x0000
+#define  GLUT_ENTERED                       0x0001
+
+/*
+ * GLUT API macro definitions -- the display mode definitions
+ */
+#define  GLUT_RGB                           0x0000
+#define  GLUT_RGBA                          0x0000
+#define  GLUT_INDEX                         0x0001
+#define  GLUT_SINGLE                        0x0000
+#define  GLUT_DOUBLE                        0x0002
+#define  GLUT_ACCUM                         0x0004
+#define  GLUT_ALPHA                         0x0008
+#define  GLUT_DEPTH                         0x0010
+#define  GLUT_STENCIL                       0x0020
+#define  GLUT_MULTISAMPLE                   0x0080
+#define  GLUT_STEREO                        0x0100
+#define  GLUT_LUMINANCE                     0x0200
+
+/*
+ * GLUT API macro definitions -- windows and menu related definitions
+ */
+#define  GLUT_MENU_NOT_IN_USE               0x0000
+#define  GLUT_MENU_IN_USE                   0x0001
+#define  GLUT_NOT_VISIBLE                   0x0000
+#define  GLUT_VISIBLE                       0x0001
+#define  GLUT_HIDDEN                        0x0000
+#define  GLUT_FULLY_RETAINED                0x0001
+#define  GLUT_PARTIALLY_RETAINED            0x0002
+#define  GLUT_FULLY_COVERED                 0x0003
+
+/*
+ * GLUT API macro definitions -- fonts definitions
+ *
+ * Steve Baker suggested to make it binary compatible with GLUT:
+ */
+#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
+#   define  GLUT_STROKE_ROMAN               ((void *)0x0000)
+#   define  GLUT_STROKE_MONO_ROMAN          ((void *)0x0001)
+#   define  GLUT_BITMAP_9_BY_15             ((void *)0x0002)
+#   define  GLUT_BITMAP_8_BY_13             ((void *)0x0003)
+#   define  GLUT_BITMAP_TIMES_ROMAN_10      ((void *)0x0004)
+#   define  GLUT_BITMAP_TIMES_ROMAN_24      ((void *)0x0005)
+#   define  GLUT_BITMAP_HELVETICA_10        ((void *)0x0006)
+#   define  GLUT_BITMAP_HELVETICA_12        ((void *)0x0007)
+#   define  GLUT_BITMAP_HELVETICA_18        ((void *)0x0008)
+#else
+/*
+ * I don't really know if it's a good idea... But here it goes:
+ */
+extern void *glutStrokeRoman;
+extern void *glutStrokeMonoRoman;
+extern void *glutBitmap9By15;
+extern void *glutBitmap8By13;
+extern void *glutBitmapTimesRoman10;
+extern void *glutBitmapTimesRoman24;
+extern void *glutBitmapHelvetica10;
+extern void *glutBitmapHelvetica12;
+extern void *glutBitmapHelvetica18;
+
+/*
+ * Those pointers will be used by following definitions:
+ */
+#   define  GLUT_STROKE_ROMAN               ((void *) &glutStrokeRoman)
+#   define  GLUT_STROKE_MONO_ROMAN          ((void *) &glutStrokeMonoRoman)
+#   define  GLUT_BITMAP_9_BY_15             ((void *) &glutBitmap9By15)
+#   define  GLUT_BITMAP_8_BY_13             ((void *) &glutBitmap8By13)
+#   define  GLUT_BITMAP_TIMES_ROMAN_10      ((void *) &glutBitmapTimesRoman10)
+#   define  GLUT_BITMAP_TIMES_ROMAN_24      ((void *) &glutBitmapTimesRoman24)
+#   define  GLUT_BITMAP_HELVETICA_10        ((void *) &glutBitmapHelvetica10)
+#   define  GLUT_BITMAP_HELVETICA_12        ((void *) &glutBitmapHelvetica12)
+#   define  GLUT_BITMAP_HELVETICA_18        ((void *) &glutBitmapHelvetica18)
+#endif
+
+/*
+ * GLUT API macro definitions -- the glutGet parameters
+ */
+#define  GLUT_WINDOW_X                      0x0064
+#define  GLUT_WINDOW_Y                      0x0065
+#define  GLUT_WINDOW_WIDTH                  0x0066
+#define  GLUT_WINDOW_HEIGHT                 0x0067
+#define  GLUT_WINDOW_BUFFER_SIZE            0x0068
+#define  GLUT_WINDOW_STENCIL_SIZE           0x0069
+#define  GLUT_WINDOW_DEPTH_SIZE             0x006A
+#define  GLUT_WINDOW_RED_SIZE               0x006B
+#define  GLUT_WINDOW_GREEN_SIZE             0x006C
+#define  GLUT_WINDOW_BLUE_SIZE              0x006D
+#define  GLUT_WINDOW_ALPHA_SIZE             0x006E
+#define  GLUT_WINDOW_ACCUM_RED_SIZE         0x006F
+#define  GLUT_WINDOW_ACCUM_GREEN_SIZE       0x0070
+#define  GLUT_WINDOW_ACCUM_BLUE_SIZE        0x0071
+#define  GLUT_WINDOW_ACCUM_ALPHA_SIZE       0x0072
+#define  GLUT_WINDOW_DOUBLEBUFFER           0x0073
+#define  GLUT_WINDOW_RGBA                   0x0074
+#define  GLUT_WINDOW_PARENT                 0x0075
+#define  GLUT_WINDOW_NUM_CHILDREN           0x0076
+#define  GLUT_WINDOW_COLORMAP_SIZE          0x0077
+#define  GLUT_WINDOW_NUM_SAMPLES            0x0078
+#define  GLUT_WINDOW_STEREO                 0x0079
+#define  GLUT_WINDOW_CURSOR                 0x007A
+
+#define  GLUT_SCREEN_WIDTH                  0x00C8
+#define  GLUT_SCREEN_HEIGHT                 0x00C9
+#define  GLUT_SCREEN_WIDTH_MM               0x00CA
+#define  GLUT_SCREEN_HEIGHT_MM              0x00CB
+#define  GLUT_MENU_NUM_ITEMS                0x012C
+#define  GLUT_DISPLAY_MODE_POSSIBLE         0x0190
+#define  GLUT_INIT_WINDOW_X                 0x01F4
+#define  GLUT_INIT_WINDOW_Y                 0x01F5
+#define  GLUT_INIT_WINDOW_WIDTH             0x01F6
+#define  GLUT_INIT_WINDOW_HEIGHT            0x01F7
+#define  GLUT_INIT_DISPLAY_MODE             0x01F8
+#define  GLUT_ELAPSED_TIME                  0x02BC
+#define  GLUT_WINDOW_FORMAT_ID              0x007B
+#define  GLUT_INIT_STATE                    0x007C
+
+/*
+ * GLUT API macro definitions -- the glutDeviceGet parameters
+ */
+#define  GLUT_HAS_KEYBOARD                  0x0258
+#define  GLUT_HAS_MOUSE                     0x0259
+#define  GLUT_HAS_SPACEBALL                 0x025A
+#define  GLUT_HAS_DIAL_AND_BUTTON_BOX       0x025B
+#define  GLUT_HAS_TABLET                    0x025C
+#define  GLUT_NUM_MOUSE_BUTTONS             0x025D
+#define  GLUT_NUM_SPACEBALL_BUTTONS         0x025E
+#define  GLUT_NUM_BUTTON_BOX_BUTTONS        0x025F
+#define  GLUT_NUM_DIALS                     0x0260
+#define  GLUT_NUM_TABLET_BUTTONS            0x0261
+#define  GLUT_DEVICE_IGNORE_KEY_REPEAT      0x0262
+#define  GLUT_DEVICE_KEY_REPEAT             0x0263
+#define  GLUT_HAS_JOYSTICK                  0x0264
+#define  GLUT_OWNS_JOYSTICK                 0x0265
+#define  GLUT_JOYSTICK_BUTTONS              0x0266
+#define  GLUT_JOYSTICK_AXES                 0x0267
+#define  GLUT_JOYSTICK_POLL_RATE            0x0268
+
+/*
+ * GLUT API macro definitions -- the glutLayerGet parameters
+ */
+#define  GLUT_OVERLAY_POSSIBLE              0x0320
+#define  GLUT_LAYER_IN_USE                  0x0321
+#define  GLUT_HAS_OVERLAY                   0x0322
+#define  GLUT_TRANSPARENT_INDEX             0x0323
+#define  GLUT_NORMAL_DAMAGED                0x0324
+#define  GLUT_OVERLAY_DAMAGED               0x0325
+
+/*
+ * GLUT API macro definitions -- the glutVideoResizeGet parameters
+ */
+#define  GLUT_VIDEO_RESIZE_POSSIBLE         0x0384
+#define  GLUT_VIDEO_RESIZE_IN_USE           0x0385
+#define  GLUT_VIDEO_RESIZE_X_DELTA          0x0386
+#define  GLUT_VIDEO_RESIZE_Y_DELTA          0x0387
+#define  GLUT_VIDEO_RESIZE_WIDTH_DELTA      0x0388
+#define  GLUT_VIDEO_RESIZE_HEIGHT_DELTA     0x0389
+#define  GLUT_VIDEO_RESIZE_X                0x038A
+#define  GLUT_VIDEO_RESIZE_Y                0x038B
+#define  GLUT_VIDEO_RESIZE_WIDTH            0x038C
+#define  GLUT_VIDEO_RESIZE_HEIGHT           0x038D
+
+/*
+ * GLUT API macro definitions -- the glutUseLayer parameters
+ */
+#define  GLUT_NORMAL                        0x0000
+#define  GLUT_OVERLAY                       0x0001
+
+/*
+ * GLUT API macro definitions -- the glutGetModifiers parameters
+ */
+#define  GLUT_ACTIVE_SHIFT                  0x0001
+#define  GLUT_ACTIVE_CTRL                   0x0002
+#define  GLUT_ACTIVE_ALT                    0x0004
+
+/*
+ * GLUT API macro definitions -- the glutSetCursor parameters
+ */
+#define  GLUT_CURSOR_RIGHT_ARROW            0x0000
+#define  GLUT_CURSOR_LEFT_ARROW             0x0001
+#define  GLUT_CURSOR_INFO                   0x0002
+#define  GLUT_CURSOR_DESTROY                0x0003
+#define  GLUT_CURSOR_HELP                   0x0004
+#define  GLUT_CURSOR_CYCLE                  0x0005
+#define  GLUT_CURSOR_SPRAY                  0x0006
+#define  GLUT_CURSOR_WAIT                   0x0007
+#define  GLUT_CURSOR_TEXT                   0x0008
+#define  GLUT_CURSOR_CROSSHAIR              0x0009
+#define  GLUT_CURSOR_UP_DOWN                0x000A
+#define  GLUT_CURSOR_LEFT_RIGHT             0x000B
+#define  GLUT_CURSOR_TOP_SIDE               0x000C
+#define  GLUT_CURSOR_BOTTOM_SIDE            0x000D
+#define  GLUT_CURSOR_LEFT_SIDE              0x000E
+#define  GLUT_CURSOR_RIGHT_SIDE             0x000F
+#define  GLUT_CURSOR_TOP_LEFT_CORNER        0x0010
+#define  GLUT_CURSOR_TOP_RIGHT_CORNER       0x0011
+#define  GLUT_CURSOR_BOTTOM_RIGHT_CORNER    0x0012
+#define  GLUT_CURSOR_BOTTOM_LEFT_CORNER     0x0013
+#define  GLUT_CURSOR_INHERIT                0x0064
+#define  GLUT_CURSOR_NONE                   0x0065
+#define  GLUT_CURSOR_FULL_CROSSHAIR         0x0066
+
+/*
+ * GLUT API macro definitions -- RGB color component specification definitions
+ */
+#define  GLUT_RED                           0x0000
+#define  GLUT_GREEN                         0x0001
+#define  GLUT_BLUE                          0x0002
+
+/*
+ * GLUT API macro definitions -- additional keyboard and joystick definitions
+ */
+#define  GLUT_KEY_REPEAT_OFF                0x0000
+#define  GLUT_KEY_REPEAT_ON                 0x0001
+#define  GLUT_KEY_REPEAT_DEFAULT            0x0002
+
+#define  GLUT_JOYSTICK_BUTTON_A             0x0001
+#define  GLUT_JOYSTICK_BUTTON_B             0x0002
+#define  GLUT_JOYSTICK_BUTTON_C             0x0004
+#define  GLUT_JOYSTICK_BUTTON_D             0x0008
+
+/*
+ * GLUT API macro definitions -- game mode definitions
+ */
+#define  GLUT_GAME_MODE_ACTIVE              0x0000
+#define  GLUT_GAME_MODE_POSSIBLE            0x0001
+#define  GLUT_GAME_MODE_WIDTH               0x0002
+#define  GLUT_GAME_MODE_HEIGHT              0x0003
+#define  GLUT_GAME_MODE_PIXEL_DEPTH         0x0004
+#define  GLUT_GAME_MODE_REFRESH_RATE        0x0005
+#define  GLUT_GAME_MODE_DISPLAY_CHANGED     0x0006
+
+/*
+ * Initialization functions, see fglut_init.c
+ */
+FGAPI void    FGAPIENTRY glutInit(int *pargc, char **argv);
+FGAPI void    FGAPIENTRY glutInitWindowPosition(int x, int y);
+FGAPI void    FGAPIENTRY glutInitWindowSize(int width, int height);
+FGAPI void    FGAPIENTRY glutInitDisplayMode(unsigned int displayMode);
+FGAPI void    FGAPIENTRY glutInitDisplayString(const char *displayMode);
+
+/*
+ * Process loop function, see freeglut_main.c
+ */
+FGAPI void    FGAPIENTRY glutMainLoop(void);
+
+/*
+ * Window management functions, see freeglut_window.c
+ */
+FGAPI int     FGAPIENTRY glutCreateWindow(const char *title);
+FGAPI int     FGAPIENTRY glutCreateSubWindow(int window, int x, int y, int width, int height);
+FGAPI void    FGAPIENTRY glutDestroyWindow(int window);
+FGAPI void    FGAPIENTRY glutSetWindow(int window);
+FGAPI int     FGAPIENTRY glutGetWindow(void);
+FGAPI void    FGAPIENTRY glutSetWindowTitle(const char *title);
+FGAPI void    FGAPIENTRY glutSetIconTitle(const char *title);
+FGAPI void    FGAPIENTRY glutReshapeWindow(int width, int height);
+FGAPI void    FGAPIENTRY glutPositionWindow(int x, int y);
+FGAPI void    FGAPIENTRY glutShowWindow(void);
+FGAPI void    FGAPIENTRY glutHideWindow(void);
+FGAPI void    FGAPIENTRY glutIconifyWindow(void);
+FGAPI void    FGAPIENTRY glutPushWindow(void);
+FGAPI void    FGAPIENTRY glutPopWindow(void);
+FGAPI void    FGAPIENTRY glutFullScreen(void);
+
+/*
+ * Display-connected functions, see freeglut_display.c
+ */
+FGAPI void    FGAPIENTRY glutPostWindowRedisplay(int window);
+FGAPI void    FGAPIENTRY glutPostRedisplay(void);
+FGAPI void    FGAPIENTRY glutSwapBuffers(void);
+
+/*
+ * Mouse cursor functions, see freeglut_cursor.c
+ */
+FGAPI void    FGAPIENTRY glutWarpPointer(int x, int y);
+FGAPI void    FGAPIENTRY glutSetCursor(int cursor);
+
+/*
+ * Overlay stuff, see freeglut_overlay.c
+ */
+FGAPI void    FGAPIENTRY glutEstablishOverlay(void);
+FGAPI void    FGAPIENTRY glutRemoveOverlay(void);
+FGAPI void    FGAPIENTRY glutUseLayer(GLenum layer);
+FGAPI void    FGAPIENTRY glutPostOverlayRedisplay(void);
+FGAPI void    FGAPIENTRY glutPostWindowOverlayRedisplay(int window);
+FGAPI void    FGAPIENTRY glutShowOverlay(void);
+FGAPI void    FGAPIENTRY glutHideOverlay(void);
+
+/*
+ * Menu stuff, see freeglut_menu.c
+ */
+FGAPI int     FGAPIENTRY glutCreateMenu(void (* callback)(int menu));
+FGAPI void    FGAPIENTRY glutDestroyMenu(int menu);
+FGAPI int     FGAPIENTRY glutGetMenu(void);
+FGAPI void    FGAPIENTRY glutSetMenu(int menu);
+FGAPI void    FGAPIENTRY glutAddMenuEntry(const char *label, int value);
+FGAPI void    FGAPIENTRY glutAddSubMenu(const char *label, int subMenu);
+FGAPI void    FGAPIENTRY glutChangeToMenuEntry(int item, const char *label, int value);
+FGAPI void    FGAPIENTRY glutChangeToSubMenu(int item, const char *label, int value);
+FGAPI void    FGAPIENTRY glutRemoveMenuItem(int item);
+FGAPI void    FGAPIENTRY glutAttachMenu(int button);
+FGAPI void    FGAPIENTRY glutDetachMenu(int button);
+
+/*
+ * Global callback functions, see freeglut_callbacks.c
+ */
+FGAPI void    FGAPIENTRY glutTimerFunc(unsigned int time, void (* callback)(int), int value);
+FGAPI void    FGAPIENTRY glutIdleFunc(void (* callback)(void));
+
+/*
+ * Window-specific callback functions, see freeglut_callbacks.c
+ */
+FGAPI void    FGAPIENTRY glutKeyboardFunc(void (* callback)(unsigned char, int, int));
+FGAPI void    FGAPIENTRY glutSpecialFunc(void (* callback)(int, int, int));
+FGAPI void    FGAPIENTRY glutReshapeFunc(void (* callback)(int, int));
+FGAPI void    FGAPIENTRY glutVisibilityFunc(void (* callback)(int));
+FGAPI void    FGAPIENTRY glutDisplayFunc(void (* callback)(void));
+FGAPI void    FGAPIENTRY glutMouseFunc(void (* callback)(int, int, int, int));
+FGAPI void    FGAPIENTRY glutMotionFunc(void (* callback)(int, int));
+FGAPI void    FGAPIENTRY glutPassiveMotionFunc(void (* callback)(int, int));
+FGAPI void    FGAPIENTRY glutEntryFunc(void (* callback)(int));
+
+FGAPI void    FGAPIENTRY glutKeyboardUpFunc(void (* callback)(unsigned char, int, int));
+FGAPI void    FGAPIENTRY glutSpecialUpFunc(void (* callback)(int, int, int));
+FGAPI void    FGAPIENTRY glutJoystickFunc(void (* callback)(unsigned int, int, int, int), int pollInterval);
+FGAPI void    FGAPIENTRY glutMenuStateFunc(void (* callback)(int));
+FGAPI void    FGAPIENTRY glutMenuStatusFunc(void (* callback)(int, int, int));
+FGAPI void    FGAPIENTRY glutOverlayDisplayFunc(void (* callback)(void));
+FGAPI void    FGAPIENTRY glutWindowStatusFunc(void (* callback)(int));
+
+FGAPI void    FGAPIENTRY glutSpaceballMotionFunc(void (* callback)(int, int, int));
+FGAPI void    FGAPIENTRY glutSpaceballRotateFunc(void (* callback)(int, int, int));
+FGAPI void    FGAPIENTRY glutSpaceballButtonFunc(void (* callback)(int, int));
+FGAPI void    FGAPIENTRY glutButtonBoxFunc(void (* callback)(int, int));
+FGAPI void    FGAPIENTRY glutDialsFunc(void (* callback)(int, int));
+FGAPI void    FGAPIENTRY glutTabletMotionFunc(void (* callback)(int, int));
+FGAPI void    FGAPIENTRY glutTabletButtonFunc(void (* callback)(int, int, int, int));
+
+/*
+ * State setting and retrieval functions, see freeglut_state.c
+ */
+FGAPI int     FGAPIENTRY glutGet(GLenum query);
+FGAPI int     FGAPIENTRY glutDeviceGet(GLenum query);
+FGAPI int     FGAPIENTRY glutGetModifiers(void);
+FGAPI int     FGAPIENTRY glutLayerGet(GLenum query);
+
+/*
+ * Font stuff, see freeglut_font.c
+ */
+FGAPI void    FGAPIENTRY glutBitmapCharacter(void *font, int character);
+FGAPI int     FGAPIENTRY glutBitmapWidth(void *font, int character);
+FGAPI void    FGAPIENTRY glutStrokeCharacter(void *font, int character);
+FGAPI int     FGAPIENTRY glutStrokeWidth(void *font, int character);
+FGAPI int     FGAPIENTRY glutBitmapLength(void *font, const unsigned char *string);
+FGAPI int     FGAPIENTRY glutStrokeLength(void *font, const unsigned char *string);
+
+/*
+ * Geometry functions, see freeglut_geometry.c
+ */
+FGAPI void    FGAPIENTRY glutWireCube(GLdouble size);
+FGAPI void    FGAPIENTRY glutSolidCube(GLdouble size);
+FGAPI void    FGAPIENTRY glutWireSphere(GLdouble radius, GLint slices, GLint stacks);
+FGAPI void    FGAPIENTRY glutSolidSphere(GLdouble radius, GLint slices, GLint stacks);
+FGAPI void    FGAPIENTRY glutWireCone(GLdouble base, GLdouble height, GLint slices, GLint stacks);
+FGAPI void    FGAPIENTRY glutSolidCone(GLdouble base, GLdouble height, GLint slices, GLint stacks);
+
+FGAPI void    FGAPIENTRY glutWireTorus(GLdouble innerRadius, GLdouble outerRadius, GLint sides, GLint rings);
+FGAPI void    FGAPIENTRY glutSolidTorus(GLdouble innerRadius, GLdouble outerRadius, GLint sides, GLint rings);
+FGAPI void    FGAPIENTRY glutWireDodecahedron(void);
+FGAPI void    FGAPIENTRY glutSolidDodecahedron(void);
+FGAPI void    FGAPIENTRY glutWireOctahedron(void);
+FGAPI void    FGAPIENTRY glutSolidOctahedron(void);
+FGAPI void    FGAPIENTRY glutWireTetrahedron(void);
+FGAPI void    FGAPIENTRY glutSolidTetrahedron(void);
+FGAPI void    FGAPIENTRY glutWireIcosahedron(void);
+FGAPI void    FGAPIENTRY glutSolidIcosahedron(void);
+
+/*
+ * Teapot rendering functions, found in freeglut_teapot.c
+ */
+FGAPI void    FGAPIENTRY glutWireTeapot(GLdouble size);
+FGAPI void    FGAPIENTRY glutSolidTeapot(GLdouble size);
+
+/*
+ * Game mode functions, see freeglut_gamemode.c
+ */
+FGAPI void    FGAPIENTRY glutGameModeString(const char *string);
+FGAPI int     FGAPIENTRY glutEnterGameMode(void);
+FGAPI void    FGAPIENTRY glutLeaveGameMode(void);
+FGAPI int     FGAPIENTRY glutGameModeGet(GLenum query);
+
+/*
+ * Video resize functions, see freeglut_videoresize.c
+ */
+FGAPI int     FGAPIENTRY glutVideoResizeGet(GLenum query);
+FGAPI void    FGAPIENTRY glutSetupVideoResizing(void);
+FGAPI void    FGAPIENTRY glutStopVideoResizing(void);
+FGAPI void    FGAPIENTRY glutVideoResize(int x, int y, int width, int height);
+FGAPI void    FGAPIENTRY glutVideoPan(int x, int y, int width, int height);
+
+/*
+ * Colormap functions, see freeglut_misc.c
+ */
+FGAPI void    FGAPIENTRY glutSetColor(int color, GLfloat red, GLfloat green, GLfloat blue);
+FGAPI GLfloat FGAPIENTRY glutGetColor(int color, int component);
+FGAPI void    FGAPIENTRY glutCopyColormap(int window);
+
+/*
+ * Misc keyboard and joystick functions, see freeglut_misc.c
+ */
+FGAPI void    FGAPIENTRY glutIgnoreKeyRepeat(int ignore);
+FGAPI void    FGAPIENTRY glutSetKeyRepeat(int repeatMode);    /* DEPRECATED 11/4/02 - Do not use */
+FGAPI void    FGAPIENTRY glutForceJoystickFunc(void);
+
+/*
+ * Misc functions, see freeglut_misc.c
+ */
+FGAPI int     FGAPIENTRY glutExtensionSupported(const char *extension);
+FGAPI void    FGAPIENTRY glutReportErrors(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+/*** END OF FILE ***/
+
+#endif /* __FREEGLUT_STD_H__ */
+

Common/GL/glut.h

@@ -0,0 +1,597 @@
+#ifndef __glut_h__
+#define __glut_h__
+
+/* Copyright (c) Mark J. Kilgard, 1994, 1995, 1996, 1998. */
+
+/* This program is freely distributable without licensing fees  and is
+   provided without guarantee or warrantee expressed or  implied. This
+   program is -not- in the public domain. */
+
+#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
+
+/* GLUT 3.7 now tries to avoid including <windows.h>
+   to avoid name space pollution, but Win32's <GL/gl.h>
+   needs APIENTRY and WINGDIAPI defined properly. */
+# if 0
+#  define  WIN32_LEAN_AND_MEAN
+#  include <windows.h>
+# else
+/* XXX This is from Win32's <windef.h> */
+#  ifndef APIENTRY
+#   define GLUT_APIENTRY_DEFINED
+#   if (_MSC_VER >= 800) || defined(_STDCALL_SUPPORTED)
+#    define APIENTRY    __stdcall
+#   else
+#    define APIENTRY
+#   endif
+#  endif
+/* XXX This is from Win32's <winnt.h> */
+#  ifndef CALLBACK
+#   if (defined(_M_MRX000) || defined(_M_IX86) || defined(_M_ALPHA) || defined(_M_PPC)) && !defined(MIDL_PASS)
+#    define CALLBACK __stdcall
+#   else
+#    define CALLBACK
+#   endif
+#  endif
+/* XXX This is from Win32's <wingdi.h> and <winnt.h> */
+#  ifndef WINGDIAPI
+#   define GLUT_WINGDIAPI_DEFINED
+#   define WINGDIAPI __declspec(dllimport)
+#  endif
+/* XXX This is from Win32's <ctype.h> */
+#  ifndef _WCHAR_T_DEFINED
+typedef unsigned short wchar_t;
+#   define _WCHAR_T_DEFINED
+#  endif
+# endif
+
+#pragma comment (lib, "winmm.lib")     /* link with Windows MultiMedia lib */
+#pragma comment (lib, "opengl32.lib")  /* link with Microsoft OpenGL lib */
+#pragma comment (lib, "glu32.lib")     /* link with OpenGL Utility lib */
+#pragma message("Note: including lib: glut32.lib\n")
+#pragma comment (lib, "glut32.lib")    /* link with Win32 GLUT lib */
+
+#pragma warning (disable:4244)  /* Disable bogus conversion warnings. */
+#pragma warning (disable:4305)  /* VC++ 5.0 version of above warning. */
+
+#endif
+
+#include <GL/gl.h>
+#include <GL/glu.h>
+
+/* define APIENTRY and CALLBACK to null string if we aren't on Win32 */
+#if !defined(WIN32)
+#define APIENTRY
+#define GLUT_APIENTRY_DEFINED
+#define CALLBACK
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ GLUT API revision history:
+
+ GLUT_API_VERSION is updated to reflect incompatible GLUT
+ API changes (interface changes, semantic changes, deletions,
+ or additions).
+
+ GLUT_API_VERSION=1  First public release of GLUT.  11/29/94
+
+ GLUT_API_VERSION=2  Added support for OpenGL/GLX multisampling,
+ extension.  Supports new input devices like tablet, dial and button
+ box, and Spaceball.  Easy to query OpenGL extensions.
+
+ GLUT_API_VERSION=3  glutMenuStatus added.
+
+ GLUT_API_VERSION=4  glutInitDisplayString, glutWarpPointer,
+ glutBitmapLength, glutStrokeLength, glutWindowStatusFunc, dynamic
+ video resize subAPI, glutPostWindowRedisplay, glutKeyboardUpFunc,
+ glutSpecialUpFunc, glutIgnoreKeyRepeat, glutSetKeyRepeat,
+ glutJoystickFunc, glutForceJoystickFunc (NOT FINALIZED!).
+**/
+#ifndef GLUT_API_VERSION  /* allow this to be overriden */
+#define GLUT_API_VERSION        3
+#endif
+
+/**
+ GLUT implementation revision history:
+
+ GLUT_XLIB_IMPLEMENTATION is updated to reflect both GLUT
+ API revisions and implementation revisions (ie, bug fixes).
+
+ GLUT_XLIB_IMPLEMENTATION=1  mjk's first public release of
+ GLUT Xlib-based implementation.  11/29/94
+
+ GLUT_XLIB_IMPLEMENTATION=2  mjk's second public release of
+ GLUT Xlib-based implementation providing GLUT version 2
+ interfaces.
+
+ GLUT_XLIB_IMPLEMENTATION=3  mjk's GLUT 2.2 images. 4/17/95
+
+ GLUT_XLIB_IMPLEMENTATION=4  mjk's GLUT 2.3 images. 6/?/95
+
+ GLUT_XLIB_IMPLEMENTATION=5  mjk's GLUT 3.0 images. 10/?/95
+
+ GLUT_XLIB_IMPLEMENTATION=7  mjk's GLUT 3.1+ with glutWarpPoitner.  7/24/96
+
+ GLUT_XLIB_IMPLEMENTATION=8  mjk's GLUT 3.1+ with glutWarpPoitner
+ and video resize.  1/3/97
+
+ GLUT_XLIB_IMPLEMENTATION=9 mjk's GLUT 3.4 release with early GLUT 4 routines.
+
+ GLUT_XLIB_IMPLEMENTATION=11 Mesa 2.5's GLUT 3.6 release.
+
+ GLUT_XLIB_IMPLEMENTATION=12 mjk's GLUT 3.6 release with early GLUT 4 routines + signal handling.
+
+ GLUT_XLIB_IMPLEMENTATION=13 mjk's GLUT 3.7 release with GameGLUT support.
+**/
+#ifndef GLUT_XLIB_IMPLEMENTATION  /* Allow this to be overriden. */
+#define GLUT_XLIB_IMPLEMENTATION    13
+#endif
+
+/* Display mode bit masks. */
+#define GLUT_RGB            0
+#define GLUT_RGBA           GLUT_RGB
+#define GLUT_INDEX          1
+#define GLUT_SINGLE         0
+#define GLUT_DOUBLE         2
+#define GLUT_ACCUM          4
+#define GLUT_ALPHA          8
+#define GLUT_DEPTH          16
+#define GLUT_STENCIL            32
+#if (GLUT_API_VERSION >= 2)
+#define GLUT_MULTISAMPLE        128
+#define GLUT_STEREO         256
+#endif
+#if (GLUT_API_VERSION >= 3)
+#define GLUT_LUMINANCE          512
+#endif
+
+/* Mouse buttons. */
+#define GLUT_LEFT_BUTTON        0
+#define GLUT_MIDDLE_BUTTON      1
+#define GLUT_RIGHT_BUTTON       2
+
+/* Mouse button  state. */
+#define GLUT_DOWN           0
+#define GLUT_UP             1
+
+#if (GLUT_API_VERSION >= 2)
+/* function keys */
+#define GLUT_KEY_F1         1
+#define GLUT_KEY_F2         2
+#define GLUT_KEY_F3         3
+#define GLUT_KEY_F4         4
+#define GLUT_KEY_F5         5
+#define GLUT_KEY_F6         6
+#define GLUT_KEY_F7         7
+#define GLUT_KEY_F8         8
+#define GLUT_KEY_F9         9
+#define GLUT_KEY_F10            10
+#define GLUT_KEY_F11            11
+#define GLUT_KEY_F12            12
+/* directional keys */
+#define GLUT_KEY_LEFT           100
+#define GLUT_KEY_UP         101
+#define GLUT_KEY_RIGHT          102
+#define GLUT_KEY_DOWN           103
+#define GLUT_KEY_PAGE_UP        104
+#define GLUT_KEY_PAGE_DOWN      105
+#define GLUT_KEY_HOME           106
+#define GLUT_KEY_END            107
+#define GLUT_KEY_INSERT         108
+#endif
+
+/* Entry/exit  state. */
+#define GLUT_LEFT           0
+#define GLUT_ENTERED            1
+
+/* Menu usage  state. */
+#define GLUT_MENU_NOT_IN_USE        0
+#define GLUT_MENU_IN_USE        1
+
+/* Visibility  state. */
+#define GLUT_NOT_VISIBLE        0
+#define GLUT_VISIBLE            1
+
+/* Window status  state. */
+#define GLUT_HIDDEN         0
+#define GLUT_FULLY_RETAINED     1
+#define GLUT_PARTIALLY_RETAINED     2
+#define GLUT_FULLY_COVERED      3
+
+/* Color index component selection values. */
+#define GLUT_RED            0
+#define GLUT_GREEN          1
+#define GLUT_BLUE           2
+
+/* Layers for use. */
+#define GLUT_NORMAL         0
+#define GLUT_OVERLAY            1
+
+#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
+/* Stroke font constants (use these in GLUT program). */
+#define GLUT_STROKE_ROMAN       ((void*)0)
+#define GLUT_STROKE_MONO_ROMAN      ((void*)1)
+
+/* Bitmap font constants (use these in GLUT program). */
+#define GLUT_BITMAP_9_BY_15     ((void*)2)
+#define GLUT_BITMAP_8_BY_13     ((void*)3)
+#define GLUT_BITMAP_TIMES_ROMAN_10  ((void*)4)
+#define GLUT_BITMAP_TIMES_ROMAN_24  ((void*)5)
+#if (GLUT_API_VERSION >= 3)
+#define GLUT_BITMAP_HELVETICA_10    ((void*)6)
+#define GLUT_BITMAP_HELVETICA_12    ((void*)7)
+#define GLUT_BITMAP_HELVETICA_18    ((void*)8)
+#endif
+#else
+/* Stroke font opaque addresses (use constants instead in source code). */
+extern void *glutStrokeRoman;
+extern void *glutStrokeMonoRoman;
+
+/* Stroke font constants (use these in GLUT program). */
+#define GLUT_STROKE_ROMAN       (&glutStrokeRoman)
+#define GLUT_STROKE_MONO_ROMAN      (&glutStrokeMonoRoman)
+
+/* Bitmap font opaque addresses (use constants instead in source code). */
+extern void *glutBitmap9By15;
+extern void *glutBitmap8By13;
+extern void *glutBitmapTimesRoman10;
+extern void *glutBitmapTimesRoman24;
+extern void *glutBitmapHelvetica10;
+extern void *glutBitmapHelvetica12;
+extern void *glutBitmapHelvetica18;
+
+/* Bitmap font constants (use these in GLUT program). */
+#define GLUT_BITMAP_9_BY_15     (&glutBitmap9By15)
+#define GLUT_BITMAP_8_BY_13     (&glutBitmap8By13)
+#define GLUT_BITMAP_TIMES_ROMAN_10  (&glutBitmapTimesRoman10)
+#define GLUT_BITMAP_TIMES_ROMAN_24  (&glutBitmapTimesRoman24)
+#if (GLUT_API_VERSION >= 3)
+#define GLUT_BITMAP_HELVETICA_10    (&glutBitmapHelvetica10)
+#define GLUT_BITMAP_HELVETICA_12    (&glutBitmapHelvetica12)
+#define GLUT_BITMAP_HELVETICA_18    (&glutBitmapHelvetica18)
+#endif
+#endif
+
+/* glutGet parameters. */
+#define GLUT_WINDOW_X           100
+#define GLUT_WINDOW_Y           101
+#define GLUT_WINDOW_WIDTH       102
+#define GLUT_WINDOW_HEIGHT      103
+#define GLUT_WINDOW_BUFFER_SIZE     104
+#define GLUT_WINDOW_STENCIL_SIZE    105
+#define GLUT_WINDOW_DEPTH_SIZE      106
+#define GLUT_WINDOW_RED_SIZE        107
+#define GLUT_WINDOW_GREEN_SIZE      108
+#define GLUT_WINDOW_BLUE_SIZE       109
+#define GLUT_WINDOW_ALPHA_SIZE      110
+#define GLUT_WINDOW_ACCUM_RED_SIZE  111
+#define GLUT_WINDOW_ACCUM_GREEN_SIZE    112
+#define GLUT_WINDOW_ACCUM_BLUE_SIZE 113
+#define GLUT_WINDOW_ACCUM_ALPHA_SIZE    114
+#define GLUT_WINDOW_DOUBLEBUFFER    115
+#define GLUT_WINDOW_RGBA        116
+#define GLUT_WINDOW_PARENT      117
+#define GLUT_WINDOW_NUM_CHILDREN    118
+#define GLUT_WINDOW_COLORMAP_SIZE   119
+#if (GLUT_API_VERSION >= 2)
+#define GLUT_WINDOW_NUM_SAMPLES     120
+#define GLUT_WINDOW_STEREO      121
+#endif
+#if (GLUT_API_VERSION >= 3)
+#define GLUT_WINDOW_CURSOR      122
+#endif
+#define GLUT_SCREEN_WIDTH       200
+#define GLUT_SCREEN_HEIGHT      201
+#define GLUT_SCREEN_WIDTH_MM        202
+#define GLUT_SCREEN_HEIGHT_MM       203
+#define GLUT_MENU_NUM_ITEMS     300
+#define GLUT_DISPLAY_MODE_POSSIBLE  400
+#define GLUT_INIT_WINDOW_X      500
+#define GLUT_INIT_WINDOW_Y      501
+#define GLUT_INIT_WINDOW_WIDTH      502
+#define GLUT_INIT_WINDOW_HEIGHT     503
+#define GLUT_INIT_DISPLAY_MODE      504
+#if (GLUT_API_VERSION >= 2)
+#define GLUT_ELAPSED_TIME       700
+#endif
+#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 13)
+#define GLUT_WINDOW_FORMAT_ID       123
+#endif
+
+#if (GLUT_API_VERSION >= 2)
+/* glutDeviceGet parameters. */
+#define GLUT_HAS_KEYBOARD       600
+#define GLUT_HAS_MOUSE          601
+#define GLUT_HAS_SPACEBALL      602
+#define GLUT_HAS_DIAL_AND_BUTTON_BOX    603
+#define GLUT_HAS_TABLET         604
+#define GLUT_NUM_MOUSE_BUTTONS      605
+#define GLUT_NUM_SPACEBALL_BUTTONS  606
+#define GLUT_NUM_BUTTON_BOX_BUTTONS 607
+#define GLUT_NUM_DIALS          608
+#define GLUT_NUM_TABLET_BUTTONS     609
+#endif
+#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 13)
+#define GLUT_DEVICE_IGNORE_KEY_REPEAT   610
+#define GLUT_DEVICE_KEY_REPEAT          611
+#define GLUT_HAS_JOYSTICK       612
+#define GLUT_OWNS_JOYSTICK      613
+#define GLUT_JOYSTICK_BUTTONS       614
+#define GLUT_JOYSTICK_AXES      615
+#define GLUT_JOYSTICK_POLL_RATE     616
+#endif
+
+#if (GLUT_API_VERSION >= 3)
+/* glutLayerGet parameters. */
+#define GLUT_OVERLAY_POSSIBLE           800
+#define GLUT_LAYER_IN_USE       801
+#define GLUT_HAS_OVERLAY        802
+#define GLUT_TRANSPARENT_INDEX      803
+#define GLUT_NORMAL_DAMAGED     804
+#define GLUT_OVERLAY_DAMAGED        805
+
+#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 9)
+/* glutVideoResizeGet parameters. */
+#define GLUT_VIDEO_RESIZE_POSSIBLE  900
+#define GLUT_VIDEO_RESIZE_IN_USE    901
+#define GLUT_VIDEO_RESIZE_X_DELTA   902
+#define GLUT_VIDEO_RESIZE_Y_DELTA   903
+#define GLUT_VIDEO_RESIZE_WIDTH_DELTA   904
+#define GLUT_VIDEO_RESIZE_HEIGHT_DELTA  905
+#define GLUT_VIDEO_RESIZE_X     906
+#define GLUT_VIDEO_RESIZE_Y     907
+#define GLUT_VIDEO_RESIZE_WIDTH     908
+#define GLUT_VIDEO_RESIZE_HEIGHT    909
+#endif
+
+/* glutUseLayer parameters. */
+#define GLUT_NORMAL         0
+#define GLUT_OVERLAY            1
+
+/* glutGetModifiers return mask. */
+#define GLUT_ACTIVE_SHIFT               1
+#define GLUT_ACTIVE_CTRL                2
+#define GLUT_ACTIVE_ALT                 4
+
+/* glutSetCursor parameters. */
+/* Basic arrows. */
+#define GLUT_CURSOR_RIGHT_ARROW     0
+#define GLUT_CURSOR_LEFT_ARROW      1
+/* Symbolic cursor shapes. */
+#define GLUT_CURSOR_INFO        2
+#define GLUT_CURSOR_DESTROY     3
+#define GLUT_CURSOR_HELP        4
+#define GLUT_CURSOR_CYCLE       5
+#define GLUT_CURSOR_SPRAY       6
+#define GLUT_CURSOR_WAIT        7
+#define GLUT_CURSOR_TEXT        8
+#define GLUT_CURSOR_CROSSHAIR       9
+/* Directional cursors. */
+#define GLUT_CURSOR_UP_DOWN     10
+#define GLUT_CURSOR_LEFT_RIGHT      11
+/* Sizing cursors. */
+#define GLUT_CURSOR_TOP_SIDE        12
+#define GLUT_CURSOR_BOTTOM_SIDE     13
+#define GLUT_CURSOR_LEFT_SIDE       14
+#define GLUT_CURSOR_RIGHT_SIDE      15
+#define GLUT_CURSOR_TOP_LEFT_CORNER 16
+#define GLUT_CURSOR_TOP_RIGHT_CORNER    17
+#define GLUT_CURSOR_BOTTOM_RIGHT_CORNER 18
+#define GLUT_CURSOR_BOTTOM_LEFT_CORNER  19
+/* Inherit from parent window. */
+#define GLUT_CURSOR_INHERIT     100
+/* Blank cursor. */
+#define GLUT_CURSOR_NONE        101
+/* Fullscreen crosshair (if available). */
+#define GLUT_CURSOR_FULL_CROSSHAIR  102
+#endif
+
+/* GLUT initialization sub-API. */
+extern void APIENTRY glutInit(int *argcp, char **argv);
+extern void APIENTRY glutInitDisplayMode(unsigned int mode);
+#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 9)
+extern void APIENTRY glutInitDisplayString(const char *string);
+#endif
+extern void APIENTRY glutInitWindowPosition(int x, int y);
+extern void APIENTRY glutInitWindowSize(int width, int height);
+extern void APIENTRY glutMainLoop(void);
+
+/* GLUT window sub-API. */
+extern int APIENTRY glutCreateWindow(const char *title);
+extern int APIENTRY glutCreateSubWindow(int win, int x, int y, int width, int height);
+extern void APIENTRY glutDestroyWindow(int win);
+extern void APIENTRY glutPostRedisplay(void);
+#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 11)
+extern void APIENTRY glutPostWindowRedisplay(int win);
+#endif
+extern void APIENTRY glutSwapBuffers(void);
+extern int APIENTRY glutGetWindow(void);
+extern void APIENTRY glutSetWindow(int win);
+extern void APIENTRY glutSetWindowTitle(const char *title);
+extern void APIENTRY glutSetIconTitle(const char *title);
+extern void APIENTRY glutPositionWindow(int x, int y);
+extern void APIENTRY glutReshapeWindow(int width, int height);
+extern void APIENTRY glutPopWindow(void);
+extern void APIENTRY glutPushWindow(void);
+extern void APIENTRY glutIconifyWindow(void);
+extern void APIENTRY glutShowWindow(void);
+extern void APIENTRY glutHideWindow(void);
+#if (GLUT_API_VERSION >= 3)
+extern void APIENTRY glutFullScreen(void);
+extern void APIENTRY glutSetCursor(int cursor);
+#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 9)
+extern void APIENTRY glutWarpPointer(int x, int y);
+#endif
+
+/* GLUT overlay sub-API. */
+extern void APIENTRY glutEstablishOverlay(void);
+extern void APIENTRY glutRemoveOverlay(void);
+extern void APIENTRY glutUseLayer(GLenum layer);
+extern void APIENTRY glutPostOverlayRedisplay(void);
+#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 11)
+extern void APIENTRY glutPostWindowOverlayRedisplay(int win);
+#endif
+extern void APIENTRY glutShowOverlay(void);
+extern void APIENTRY glutHideOverlay(void);
+#endif
+
+/* GLUT menu sub-API. */
+extern int APIENTRY glutCreateMenu(void ( *)(int));
+extern void APIENTRY glutDestroyMenu(int menu);
+extern int APIENTRY glutGetMenu(void);
+extern void APIENTRY glutSetMenu(int menu);
+extern void APIENTRY glutAddMenuEntry(const char *label, int value);
+extern void APIENTRY glutAddSubMenu(const char *label, int submenu);
+extern void APIENTRY glutChangeToMenuEntry(int item, const char *label, int value);
+extern void APIENTRY glutChangeToSubMenu(int item, const char *label, int submenu);
+extern void APIENTRY glutRemoveMenuItem(int item);
+extern void APIENTRY glutAttachMenu(int button);
+extern void APIENTRY glutDetachMenu(int button);
+
+/* GLUT window callback sub-API. */
+extern void APIENTRY glutDisplayFunc(void (*func)(void));
+extern void APIENTRY glutReshapeFunc(void (*func)(int width, int height));
+extern void APIENTRY glutKeyboardFunc(void (*func)(unsigned char key, int x, int y));
+extern void APIENTRY glutMouseFunc(void (*func)(int button, int state, int x, int y));
+extern void APIENTRY glutMotionFunc(void (*func)(int x, int y));
+extern void APIENTRY glutPassiveMotionFunc(void (*func)(int x, int y));
+extern void APIENTRY glutEntryFunc(void (*func)(int state));
+extern void APIENTRY glutVisibilityFunc(void (*func)(int state));
+extern void APIENTRY glutIdleFunc(void (*func)(void));
+extern void APIENTRY glutTimerFunc(unsigned int millis, void (*func)(int value), int value);
+extern void APIENTRY glutMenuStateFunc(void (*func)(int state));
+#if (GLUT_API_VERSION >= 2)
+extern void APIENTRY glutSpecialFunc(void (*func)(int key, int x, int y));
+extern void APIENTRY glutSpaceballMotionFunc(void (*func)(int x, int y, int z));
+extern void APIENTRY glutSpaceballRotateFunc(void (*func)(int x, int y, int z));
+extern void APIENTRY glutSpaceballButtonFunc(void (*func)(int button, int state));
+extern void APIENTRY glutButtonBoxFunc(void (*func)(int button, int state));
+extern void APIENTRY glutDialsFunc(void (*func)(int dial, int value));
+extern void APIENTRY glutTabletMotionFunc(void (*func)(int x, int y));
+extern void APIENTRY glutTabletButtonFunc(void (*func)(int button, int state, int x, int y));
+#if (GLUT_API_VERSION >= 3)
+extern void APIENTRY glutMenuStatusFunc(void (*func)(int status, int x, int y));
+extern void APIENTRY glutOverlayDisplayFunc(void (*func)(void));
+#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 9)
+extern void APIENTRY glutWindowStatusFunc(void (*func)(int state));
+#endif
+#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 13)
+extern void APIENTRY glutKeyboardUpFunc(void (*func)(unsigned char key, int x, int y));
+extern void APIENTRY glutSpecialUpFunc(void (*func)(int key, int x, int y));
+extern void APIENTRY glutJoystickFunc(void (*func)(unsigned int buttonMask, int x, int y, int z), int pollInterval);
+#endif
+#endif
+#endif
+
+/* GLUT color index sub-API. */
+extern void APIENTRY glutSetColor(int, GLfloat red, GLfloat green, GLfloat blue);
+extern GLfloat APIENTRY glutGetColor(int ndx, int component);
+extern void APIENTRY glutCopyColormap(int win);
+
+/* GLUT state retrieval sub-API. */
+extern int APIENTRY glutGet(GLenum type);
+extern int APIENTRY glutDeviceGet(GLenum type);
+#if (GLUT_API_VERSION >= 2)
+/* GLUT extension support sub-API */
+extern int APIENTRY glutExtensionSupported(const char *name);
+#endif
+#if (GLUT_API_VERSION >= 3)
+extern int APIENTRY glutGetModifiers(void);
+extern int APIENTRY glutLayerGet(GLenum type);
+#endif
+
+/* GLUT font sub-API */
+extern void APIENTRY glutBitmapCharacter(void *font, int character);
+extern int APIENTRY glutBitmapWidth(void *font, int character);
+extern void APIENTRY glutStrokeCharacter(void *font, int character);
+extern int APIENTRY glutStrokeWidth(void *font, int character);
+#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 9)
+extern int APIENTRY glutBitmapLength(void *font, const unsigned char *string);
+extern int APIENTRY glutStrokeLength(void *font, const unsigned char *string);
+#endif
+
+/* GLUT pre-built models sub-API */
+extern void APIENTRY glutWireSphere(GLdouble radius, GLint slices, GLint stacks);
+extern void APIENTRY glutSolidSphere(GLdouble radius, GLint slices, GLint stacks);
+extern void APIENTRY glutWireCone(GLdouble base, GLdouble height, GLint slices, GLint stacks);
+extern void APIENTRY glutSolidCone(GLdouble base, GLdouble height, GLint slices, GLint stacks);
+extern void APIENTRY glutWireCube(GLdouble size);
+extern void APIENTRY glutSolidCube(GLdouble size);
+extern void APIENTRY glutWireTorus(GLdouble innerRadius, GLdouble outerRadius, GLint sides, GLint rings);
+extern void APIENTRY glutSolidTorus(GLdouble innerRadius, GLdouble outerRadius, GLint sides, GLint rings);
+extern void APIENTRY glutWireDodecahedron(void);
+extern void APIENTRY glutSolidDodecahedron(void);
+extern void APIENTRY glutWireTeapot(GLdouble size);
+extern void APIENTRY glutSolidTeapot(GLdouble size);
+extern void APIENTRY glutWireOctahedron(void);
+extern void APIENTRY glutSolidOctahedron(void);
+extern void APIENTRY glutWireTetrahedron(void);
+extern void APIENTRY glutSolidTetrahedron(void);
+extern void APIENTRY glutWireIcosahedron(void);
+extern void APIENTRY glutSolidIcosahedron(void);
+
+#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 9)
+/* GLUT video resize sub-API. */
+extern int APIENTRY glutVideoResizeGet(GLenum param);
+extern void APIENTRY glutSetupVideoResizing(void);
+extern void APIENTRY glutStopVideoResizing(void);
+extern void APIENTRY glutVideoResize(int x, int y, int width, int height);
+extern void APIENTRY glutVideoPan(int x, int y, int width, int height);
+
+/* GLUT debugging sub-API. */
+extern void APIENTRY glutReportErrors(void);
+#endif
+
+#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 13)
+/* GLUT device control sub-API. */
+/* glutSetKeyRepeat modes. */
+#define GLUT_KEY_REPEAT_OFF     0
+#define GLUT_KEY_REPEAT_ON      1
+#define GLUT_KEY_REPEAT_DEFAULT     2
+
+/* Joystick button masks. */
+#define GLUT_JOYSTICK_BUTTON_A      1
+#define GLUT_JOYSTICK_BUTTON_B      2
+#define GLUT_JOYSTICK_BUTTON_C      4
+#define GLUT_JOYSTICK_BUTTON_D      8
+
+extern void APIENTRY glutIgnoreKeyRepeat(int ignore);
+extern void APIENTRY glutSetKeyRepeat(int repeatMode);
+extern void APIENTRY glutForceJoystickFunc(void);
+
+/* GLUT game mode sub-API. */
+/* glutGameModeGet. */
+#define GLUT_GAME_MODE_ACTIVE           0
+#define GLUT_GAME_MODE_POSSIBLE         1
+#define GLUT_GAME_MODE_WIDTH            2
+#define GLUT_GAME_MODE_HEIGHT           3
+#define GLUT_GAME_MODE_PIXEL_DEPTH      4
+#define GLUT_GAME_MODE_REFRESH_RATE     5
+#define GLUT_GAME_MODE_DISPLAY_CHANGED  6
+
+extern void APIENTRY glutGameModeString(const char *string);
+extern int APIENTRY glutEnterGameMode(void);
+extern void APIENTRY glutLeaveGameMode(void);
+extern int APIENTRY glutGameModeGet(GLenum mode);
+#endif
+
+#ifdef __cplusplus
+}
+
+#endif
+
+#ifdef GLUT_APIENTRY_DEFINED
+# undef GLUT_APIENTRY_DEFINED
+# undef APIENTRY
+#endif
+
+#ifdef GLUT_WINGDIAPI_DEFINED
+# undef GLUT_WINGDIAPI_DEFINED
+# undef WINGDIAPI
+#endif
+
+#endif                  /* __glut_h__ */

Common/GL/glxext.h

@@ -0,0 +1,805 @@
+#ifndef __glxext_h_
+#define __glxext_h_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+**
+** http://oss.sgi.com/projects/FreeB
+**
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+**
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2004 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+**
+** Additional Notice Provisions: This software was created using the
+** OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
+** not been independently verified as being compliant with the OpenGL(R)
+** version 1.2.1 Specification.
+*/
+
+#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__)
+#define WIN32_LEAN_AND_MEAN 1
+#include <windows.h>
+#endif
+
+#ifndef APIENTRY
+#define APIENTRY
+#endif
+#ifndef APIENTRYP
+#define APIENTRYP APIENTRY *
+#endif
+#ifndef GLAPI
+#define GLAPI extern
+#endif
+
+/*************************************************************/
+
+/* Header file version number, required by OpenGL ABI for Linux */
+/* glxext.h last updated 2005/01/20 */
+/* Current version at http://oss.sgi.com/projects/ogl-sample/registry/ */
+#define GLX_GLXEXT_VERSION 10
+
+#ifndef GLX_ARB_get_proc_address
+#endif
+
+#ifndef GLX_ARB_multisample
+#define GLX_SAMPLE_BUFFERS_ARB             100000
+#define GLX_SAMPLES_ARB                    100001
+#endif
+
+#ifndef GLX_ARB_fbconfig_float
+#define GLX_RGBA_FLOAT_TYPE_ARB            0x20B9
+#define GLX_RGBA_FLOAT_BIT_ARB             0x00000004
+#endif
+
+#ifndef GLX_SGIS_multisample
+#define GLX_SAMPLE_BUFFERS_SGIS            100000
+#define GLX_SAMPLES_SGIS                   100001
+#endif
+
+#ifndef GLX_EXT_visual_info
+#define GLX_X_VISUAL_TYPE_EXT              0x22
+#define GLX_TRANSPARENT_TYPE_EXT           0x23
+#define GLX_TRANSPARENT_INDEX_VALUE_EXT    0x24
+#define GLX_TRANSPARENT_RED_VALUE_EXT      0x25
+#define GLX_TRANSPARENT_GREEN_VALUE_EXT    0x26
+#define GLX_TRANSPARENT_BLUE_VALUE_EXT     0x27
+#define GLX_TRANSPARENT_ALPHA_VALUE_EXT    0x28
+#define GLX_NONE_EXT                       0x8000
+#define GLX_TRUE_COLOR_EXT                 0x8002
+#define GLX_DIRECT_COLOR_EXT               0x8003
+#define GLX_PSEUDO_COLOR_EXT               0x8004
+#define GLX_STATIC_COLOR_EXT               0x8005
+#define GLX_GRAY_SCALE_EXT                 0x8006
+#define GLX_STATIC_GRAY_EXT                0x8007
+#define GLX_TRANSPARENT_RGB_EXT            0x8008
+#define GLX_TRANSPARENT_INDEX_EXT          0x8009
+#endif
+
+#ifndef GLX_SGI_swap_control
+#endif
+
+#ifndef GLX_SGI_video_sync
+#endif
+
+#ifndef GLX_SGI_make_current_read
+#endif
+
+#ifndef GLX_SGIX_video_source
+#endif
+
+#ifndef GLX_EXT_visual_rating
+#define GLX_VISUAL_CAVEAT_EXT              0x20
+#define GLX_SLOW_VISUAL_EXT                0x8001
+#define GLX_NON_CONFORMANT_VISUAL_EXT      0x800D
+/* reuse GLX_NONE_EXT */
+#endif
+
+#ifndef GLX_EXT_import_context
+#define GLX_SHARE_CONTEXT_EXT              0x800A
+#define GLX_VISUAL_ID_EXT                  0x800B
+#define GLX_SCREEN_EXT                     0x800C
+#endif
+
+#ifndef GLX_SGIX_fbconfig
+#define GLX_WINDOW_BIT_SGIX                0x00000001
+#define GLX_PIXMAP_BIT_SGIX                0x00000002
+#define GLX_RGBA_BIT_SGIX                  0x00000001
+#define GLX_COLOR_INDEX_BIT_SGIX           0x00000002
+#define GLX_DRAWABLE_TYPE_SGIX             0x8010
+#define GLX_RENDER_TYPE_SGIX               0x8011
+#define GLX_X_RENDERABLE_SGIX              0x8012
+#define GLX_FBCONFIG_ID_SGIX               0x8013
+#define GLX_RGBA_TYPE_SGIX                 0x8014
+#define GLX_COLOR_INDEX_TYPE_SGIX          0x8015
+/* reuse GLX_SCREEN_EXT */
+#endif
+
+#ifndef GLX_SGIX_pbuffer
+#define GLX_PBUFFER_BIT_SGIX               0x00000004
+#define GLX_BUFFER_CLOBBER_MASK_SGIX       0x08000000
+#define GLX_FRONT_LEFT_BUFFER_BIT_SGIX     0x00000001
+#define GLX_FRONT_RIGHT_BUFFER_BIT_SGIX    0x00000002
+#define GLX_BACK_LEFT_BUFFER_BIT_SGIX      0x00000004
+#define GLX_BACK_RIGHT_BUFFER_BIT_SGIX     0x00000008
+#define GLX_AUX_BUFFERS_BIT_SGIX           0x00000010
+#define GLX_DEPTH_BUFFER_BIT_SGIX          0x00000020
+#define GLX_STENCIL_BUFFER_BIT_SGIX        0x00000040
+#define GLX_ACCUM_BUFFER_BIT_SGIX          0x00000080
+#define GLX_SAMPLE_BUFFERS_BIT_SGIX        0x00000100
+#define GLX_MAX_PBUFFER_WIDTH_SGIX         0x8016
+#define GLX_MAX_PBUFFER_HEIGHT_SGIX        0x8017
+#define GLX_MAX_PBUFFER_PIXELS_SGIX        0x8018
+#define GLX_OPTIMAL_PBUFFER_WIDTH_SGIX     0x8019
+#define GLX_OPTIMAL_PBUFFER_HEIGHT_SGIX    0x801A
+#define GLX_PRESERVED_CONTENTS_SGIX        0x801B
+#define GLX_LARGEST_PBUFFER_SGIX           0x801C
+#define GLX_WIDTH_SGIX                     0x801D
+#define GLX_HEIGHT_SGIX                    0x801E
+#define GLX_EVENT_MASK_SGIX                0x801F
+#define GLX_DAMAGED_SGIX                   0x8020
+#define GLX_SAVED_SGIX                     0x8021
+#define GLX_WINDOW_SGIX                    0x8022
+#define GLX_PBUFFER_SGIX                   0x8023
+#endif
+
+#ifndef GLX_SGI_cushion
+#endif
+
+#ifndef GLX_SGIX_video_resize
+#define GLX_SYNC_FRAME_SGIX                0x00000000
+#define GLX_SYNC_SWAP_SGIX                 0x00000001
+#endif
+
+#ifndef GLX_SGIX_dmbuffer
+#define GLX_DIGITAL_MEDIA_PBUFFER_SGIX     0x8024
+#endif
+
+#ifndef GLX_SGIX_swap_group
+#endif
+
+#ifndef GLX_SGIX_swap_barrier
+#endif
+
+#ifndef GLX_SGIS_blended_overlay
+#define GLX_BLENDED_RGBA_SGIS              0x8025
+#endif
+
+#ifndef GLX_SGIS_shared_multisample
+#define GLX_MULTISAMPLE_SUB_RECT_WIDTH_SGIS 0x8026
+#define GLX_MULTISAMPLE_SUB_RECT_HEIGHT_SGIS 0x8027
+#endif
+
+#ifndef GLX_SUN_get_transparent_index
+#endif
+
+#ifndef GLX_3DFX_multisample
+#define GLX_SAMPLE_BUFFERS_3DFX            0x8050
+#define GLX_SAMPLES_3DFX                   0x8051
+#endif
+
+#ifndef GLX_MESA_copy_sub_buffer
+#endif
+
+#ifndef GLX_MESA_pixmap_colormap
+#endif
+
+#ifndef GLX_MESA_release_buffers
+#endif
+
+#ifndef GLX_MESA_set_3dfx_mode
+#define GLX_3DFX_WINDOW_MODE_MESA          0x1
+#define GLX_3DFX_FULLSCREEN_MODE_MESA      0x2
+#endif
+
+#ifndef GLX_SGIX_visual_select_group
+#define GLX_VISUAL_SELECT_GROUP_SGIX       0x8028
+#endif
+
+#ifndef GLX_OML_swap_method
+#define GLX_SWAP_METHOD_OML                0x8060
+#define GLX_SWAP_EXCHANGE_OML              0x8061
+#define GLX_SWAP_COPY_OML                  0x8062
+#define GLX_SWAP_UNDEFINED_OML             0x8063
+#endif
+
+#ifndef GLX_OML_sync_control
+#endif
+
+#ifndef GLX_NV_float_buffer
+#define GLX_FLOAT_COMPONENTS_NV            0x20B0
+#endif
+
+#ifndef GLX_SGIX_hyperpipe
+#define GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX 80
+#define GLX_BAD_HYPERPIPE_CONFIG_SGIX      91
+#define GLX_BAD_HYPERPIPE_SGIX             92
+#define GLX_HYPERPIPE_DISPLAY_PIPE_SGIX    0x00000001
+#define GLX_HYPERPIPE_RENDER_PIPE_SGIX     0x00000002
+#define GLX_PIPE_RECT_SGIX                 0x00000001
+#define GLX_PIPE_RECT_LIMITS_SGIX          0x00000002
+#define GLX_HYPERPIPE_STEREO_SGIX          0x00000003
+#define GLX_HYPERPIPE_PIXEL_AVERAGE_SGIX   0x00000004
+#define GLX_HYPERPIPE_ID_SGIX              0x8030
+#endif
+
+#ifndef GLX_MESA_agp_offset
+#endif
+
+
+/*************************************************************/
+
+#ifndef GLX_ARB_get_proc_address
+/*
+ * Linux OpenGL ABI specifies glXGetProcAddressARB should be
+ * in glx.h moving related defines there as well.
+ */
+#endif
+
+#ifndef GLX_SGIX_video_source
+typedef XID GLXVideoSourceSGIX;
+#endif
+
+#ifndef GLX_SGIX_fbconfig
+typedef XID GLXFBConfigIDSGIX;
+typedef struct __GLXFBConfigRec *GLXFBConfigSGIX;
+#endif
+
+#ifndef GLX_SGIX_pbuffer
+typedef XID GLXPbufferSGIX;
+typedef struct
+{
+    int type;
+    unsigned long serial;     /* # of last request processed by server */
+    Bool send_event;          /* true if this came for SendEvent request */
+    Display *display;         /* display the event was read from */
+    GLXDrawable drawable;     /* i.d. of Drawable */
+    int event_type;       /* GLX_DAMAGED_SGIX or GLX_SAVED_SGIX */
+    int draw_type;        /* GLX_WINDOW_SGIX or GLX_PBUFFER_SGIX */
+    unsigned int mask;    /* mask indicating which buffers are affected*/
+    int x, y;
+    int width, height;
+    int count;        /* if nonzero, at least this many more */
+} GLXBufferClobberEventSGIX;
+#endif
+
+#ifndef GLX_NV_swap_group
+#endif
+
+#ifndef GLX_NV_video_out
+/*
+ * GLXVideoDeviceNV is an opaque handle to a video device (part of the
+ * GLX_NV_video_out extension).
+ */
+typedef unsigned int GLXVideoDeviceNV;
+
+/* glXBindVideoImageNV iVideoBuffer values (NV_video_out) */
+#define GLX_VIDEO_OUT_COLOR_NV           0x20C3
+#define GLX_VIDEO_OUT_ALPHA_NV           0x20C4
+#define GLX_VIDEO_OUT_DEPTH_NV           0x20C5
+#define GLX_VIDEO_OUT_COLOR_AND_ALPHA_NV 0x20C6
+#define GLX_VIDEO_OUT_COLOR_AND_DEPTH_NV 0x20C7
+
+/* glXSendPbufferToVideoNV iBufferType values (NV_video_out) */
+#define GLX_VIDEO_OUT_FRAME_NV           0x20C8
+#define GLX_VIDEO_OUT_FIELD_1_NV         0x20C9
+#define GLX_VIDEO_OUT_FIELD_2_NV         0x20CA
+#endif
+
+#ifndef GLX_EXT_texture_from_pixmap
+/* New glXGetFBConfigAttrib <attrib_list> tokens */
+#define GLX_BIND_TO_TEXTURE_RGB_EXT      0x20D0
+#define GLX_BIND_TO_TEXTURE_RGBA_EXT     0x20D1
+#define GLX_BIND_TO_MIPMAP_TEXTURE_EXT   0x20D2
+#define GLX_BIND_TO_TEXTURE_TARGETS_EXT  0x20D3
+#define GLX_Y_INVERTED_EXT               0x20D4
+
+/* New glXCreatePixmap attributes and glXQueryDrawable attributes */
+#define GLX_TEXTURE_FORMAT_EXT           0x20D5
+#define GLX_TEXTURE_TARGET_EXT           0x20D6
+#define GLX_MIPMAP_TEXTURE_EXT           0x20D7
+
+/* Values for GLX_TEXTURE_FORMAT_EXT */
+#define GLX_TEXTURE_FORMAT_NONE_EXT      0x20D8
+#define GLX_TEXTURE_FORMAT_RGB_EXT       0x20D9
+#define GLX_TEXTURE_FORMAT_RGBA_EXT      0x20DA
+
+/* Bits for GLX_BIND_TO_TEXTURE_TARGETS_EXT mask */
+#define GLX_TEXTURE_1D_BIT_EXT           0x00000001
+#define GLX_TEXTURE_2D_BIT_EXT           0x00000002
+#define GLX_TEXTURE_RECTANGLE_BIT_EXT    0x00000004
+
+/* Values for GLX_TEXTURE_TARGET_EXT */
+#define GLX_TEXTURE_1D_EXT               0x20DB
+#define GLX_TEXTURE_2D_EXT               0x20DC
+#define GLX_TEXTURE_RECTANGLE_EXT        0x20DD
+
+/*
+ * Values for the buffer parameter of glXBindTexImageEXT and
+ * glXReleaseTexImageEXT
+ */
+#define GLX_FRONT_LEFT_EXT               0x20DE
+#define GLX_FRONT_RIGHT_EXT              0x20DF
+#define GLX_BACK_LEFT_EXT                0x20E0
+#define GLX_BACK_RIGHT_EXT               0x20E1
+#define GLX_FRONT_EXT                    GLX_FRONT_LEFT_EXT
+#define GLX_BACK_EXT                     GLX_BACK_LEFT_EXT
+#define GLX_AUX0_EXT                     0x20E2
+#define GLX_AUX1_EXT                     0x20E3
+#define GLX_AUX2_EXT                     0x20E4
+#define GLX_AUX3_EXT                     0x20E5
+#define GLX_AUX4_EXT                     0x20E6
+#define GLX_AUX5_EXT                     0x20E7
+#define GLX_AUX6_EXT                     0x20E8
+#define GLX_AUX7_EXT                     0x20E9
+#define GLX_AUX8_EXT                     0x20EA
+#define GLX_AUX9_EXT                     0x20EB
+
+#endif
+
+/* Define int32_t and int64_t types for UST/MSC */
+/* (as used in the GLX_OML_sync_control extension). */
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+#include <inttypes.h>
+#elif defined( __VMS ) || defined(__FreeBSD__)
+#include <inttypes.h>
+#elif (defined(__sun__) && defined(__svr4__)) || (defined(__sun) && defined(__SVR4))
+#include <inttypes.h>
+#elif defined(__SCO__) || defined(__USLC__) || defined(__linux__)
+#include <stdint.h>
+#elif defined(__UNIXOS2__) || defined(__SOL64__)
+typedef long int int32_t;
+typedef long long int int64_t;
+#else
+#error "int32_t and int64_t are undefined!"
+#endif
+
+#ifndef GLX_ARB_get_proc_address
+/* Moved to glx.h */
+#endif
+
+#ifndef GLX_ARB_multisample
+#define GLX_ARB_multisample 1
+#endif
+
+#ifndef GLX_ARB_fbconfig_float
+#define GLX_ARB_fbconfig_float 1
+#endif
+
+#ifndef GLX_SGIS_multisample
+#define GLX_SGIS_multisample 1
+#endif
+
+#ifndef GLX_EXT_visual_info
+#define GLX_EXT_visual_info 1
+#endif
+
+#ifndef GLX_SGI_swap_control
+#define GLX_SGI_swap_control 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern int glXSwapIntervalSGI(int);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef int (* PFNGLXSWAPINTERVALSGIPROC)(int interval);
+#endif
+
+#ifndef GLX_SGI_video_sync
+#define GLX_SGI_video_sync 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern int glXGetVideoSyncSGI(unsigned int *);
+extern int glXWaitVideoSyncSGI(int, int, unsigned int *);
+extern int glXGetRefreshRateSGI(unsigned int *);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef int (* PFNGLXGETVIDEOSYNCSGIPROC)(unsigned int *count);
+typedef int (* PFNGLXWAITVIDEOSYNCSGIPROC)(int divisor, int remainder, unsigned int *count);
+typedef int (* PFNGLXGETREFRESHRATESGIPROC)(unsigned int *);
+#endif
+
+#ifndef GLX_SGI_make_current_read
+#define GLX_SGI_make_current_read 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern Bool glXMakeCurrentReadSGI(Display *, GLXDrawable, GLXDrawable, GLXContext);
+extern GLXDrawable glXGetCurrentReadDrawableSGI(void);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef Bool(* PFNGLXMAKECURRENTREADSGIPROC)(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx);
+typedef GLXDrawable(* PFNGLXGETCURRENTREADDRAWABLESGIPROC)(void);
+#endif
+
+#ifndef GLX_SGIX_video_source
+#define GLX_SGIX_video_source 1
+#ifdef _VL_H
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern GLXVideoSourceSGIX glXCreateGLXVideoSourceSGIX(Display *, int, VLServer, VLPath, int, VLNode);
+extern void glXDestroyGLXVideoSourceSGIX(Display *, GLXVideoSourceSGIX);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef GLXVideoSourceSGIX(* PFNGLXCREATEGLXVIDEOSOURCESGIXPROC)(Display *display, int screen, VLServer server, VLPath path, int nodeClass, VLNode drainNode);
+typedef void (* PFNGLXDESTROYGLXVIDEOSOURCESGIXPROC)(Display *dpy, GLXVideoSourceSGIX glxvideosource);
+#endif /* _VL_H */
+#endif
+
+#ifndef GLX_EXT_visual_rating
+#define GLX_EXT_visual_rating 1
+#endif
+
+#ifndef GLX_EXT_import_context
+#define GLX_EXT_import_context 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern Display *glXGetCurrentDisplayEXT(void);
+extern int glXQueryContextInfoEXT(Display *, GLXContext, int, int *);
+extern GLXContextID glXGetContextIDEXT(const GLXContext);
+extern GLXContext glXImportContextEXT(Display *, GLXContextID);
+extern void glXFreeContextEXT(Display *, GLXContext);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef Display *(* PFNGLXGETCURRENTDISPLAYEXTPROC)(void);
+typedef int (* PFNGLXQUERYCONTEXTINFOEXTPROC)(Display *dpy, GLXContext context, int attribute, int *value);
+typedef GLXContextID(* PFNGLXGETCONTEXTIDEXTPROC)(const GLXContext context);
+typedef GLXContext(* PFNGLXIMPORTCONTEXTEXTPROC)(Display *dpy, GLXContextID contextID);
+typedef void (* PFNGLXFREECONTEXTEXTPROC)(Display *dpy, GLXContext context);
+#endif
+
+#ifndef GLX_SGIX_fbconfig
+#define GLX_SGIX_fbconfig 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern int glXGetFBConfigAttribSGIX(Display *, GLXFBConfigSGIX, int, int *);
+extern GLXFBConfigSGIX *glXChooseFBConfigSGIX(Display *, int, int *, int *);
+extern GLXPixmap glXCreateGLXPixmapWithConfigSGIX(Display *, GLXFBConfigSGIX, Pixmap);
+extern GLXContext glXCreateContextWithConfigSGIX(Display *, GLXFBConfigSGIX, int, GLXContext, Bool);
+extern XVisualInfo *glXGetVisualFromFBConfigSGIX(Display *, GLXFBConfigSGIX);
+extern GLXFBConfigSGIX glXGetFBConfigFromVisualSGIX(Display *, XVisualInfo *);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef int (* PFNGLXGETFBCONFIGATTRIBSGIXPROC)(Display *dpy, GLXFBConfigSGIX config, int attribute, int *value);
+typedef GLXFBConfigSGIX *(* PFNGLXCHOOSEFBCONFIGSGIXPROC)(Display *dpy, int screen, int *attrib_list, int *nelements);
+typedef GLXPixmap(* PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC)(Display *dpy, GLXFBConfigSGIX config, Pixmap pixmap);
+typedef GLXContext(* PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC)(Display *dpy, GLXFBConfigSGIX config, int render_type, GLXContext share_list, Bool direct);
+typedef XVisualInfo *(* PFNGLXGETVISUALFROMFBCONFIGSGIXPROC)(Display *dpy, GLXFBConfigSGIX config);
+typedef GLXFBConfigSGIX(* PFNGLXGETFBCONFIGFROMVISUALSGIXPROC)(Display *dpy, XVisualInfo *vis);
+#endif
+
+#ifndef GLX_SGIX_pbuffer
+#define GLX_SGIX_pbuffer 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern GLXPbufferSGIX glXCreateGLXPbufferSGIX(Display *, GLXFBConfigSGIX, unsigned int, unsigned int, int *);
+extern void glXDestroyGLXPbufferSGIX(Display *, GLXPbufferSGIX);
+extern int glXQueryGLXPbufferSGIX(Display *, GLXPbufferSGIX, int, unsigned int *);
+extern void glXSelectEventSGIX(Display *, GLXDrawable, unsigned long);
+extern void glXGetSelectedEventSGIX(Display *, GLXDrawable, unsigned long *);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef GLXPbufferSGIX(* PFNGLXCREATEGLXPBUFFERSGIXPROC)(Display *dpy, GLXFBConfigSGIX config, unsigned int width, unsigned int height, int *attrib_list);
+typedef void (* PFNGLXDESTROYGLXPBUFFERSGIXPROC)(Display *dpy, GLXPbufferSGIX pbuf);
+typedef int (* PFNGLXQUERYGLXPBUFFERSGIXPROC)(Display *dpy, GLXPbufferSGIX pbuf, int attribute, unsigned int *value);
+typedef void (* PFNGLXSELECTEVENTSGIXPROC)(Display *dpy, GLXDrawable drawable, unsigned long mask);
+typedef void (* PFNGLXGETSELECTEDEVENTSGIXPROC)(Display *dpy, GLXDrawable drawable, unsigned long *mask);
+#endif
+
+#ifndef GLX_SGI_cushion
+#define GLX_SGI_cushion 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern void glXCushionSGI(Display *, Window, float);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef void (* PFNGLXCUSHIONSGIPROC)(Display *dpy, Window window, float cushion);
+#endif
+
+#ifndef GLX_SGIX_video_resize
+#define GLX_SGIX_video_resize 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern int glXBindChannelToWindowSGIX(Display *, int, int, Window);
+extern int glXChannelRectSGIX(Display *, int, int, int, int, int, int);
+extern int glXQueryChannelRectSGIX(Display *, int, int, int *, int *, int *, int *);
+extern int glXQueryChannelDeltasSGIX(Display *, int, int, int *, int *, int *, int *);
+extern int glXChannelRectSyncSGIX(Display *, int, int, GLenum);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef int (* PFNGLXBINDCHANNELTOWINDOWSGIXPROC)(Display *display, int screen, int channel, Window window);
+typedef int (* PFNGLXCHANNELRECTSGIXPROC)(Display *display, int screen, int channel, int x, int y, int w, int h);
+typedef int (* PFNGLXQUERYCHANNELRECTSGIXPROC)(Display *display, int screen, int channel, int *dx, int *dy, int *dw, int *dh);
+typedef int (* PFNGLXQUERYCHANNELDELTASSGIXPROC)(Display *display, int screen, int channel, int *x, int *y, int *w, int *h);
+typedef int (* PFNGLXCHANNELRECTSYNCSGIXPROC)(Display *display, int screen, int channel, GLenum synctype);
+#endif
+
+#ifndef GLX_SGIX_dmbuffer
+#define GLX_SGIX_dmbuffer 1
+#ifdef _DM_BUFFER_H_
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern Bool glXAssociateDMPbufferSGIX(Display *, GLXPbufferSGIX, DMparams *, DMbuffer);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef Bool(* PFNGLXASSOCIATEDMPBUFFERSGIXPROC)(Display *dpy, GLXPbufferSGIX pbuffer, DMparams *params, DMbuffer dmbuffer);
+#endif /* _DM_BUFFER_H_ */
+#endif
+
+#ifndef GLX_SGIX_swap_group
+#define GLX_SGIX_swap_group 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern void glXJoinSwapGroupSGIX(Display *, GLXDrawable, GLXDrawable);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef void (* PFNGLXJOINSWAPGROUPSGIXPROC)(Display *dpy, GLXDrawable drawable, GLXDrawable member);
+#endif
+
+#ifndef GLX_SGIX_swap_barrier
+#define GLX_SGIX_swap_barrier 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern void glXBindSwapBarrierSGIX(Display *, GLXDrawable, int);
+extern Bool glXQueryMaxSwapBarriersSGIX(Display *, int, int *);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef void (* PFNGLXBINDSWAPBARRIERSGIXPROC)(Display *dpy, GLXDrawable drawable, int barrier);
+typedef Bool(* PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC)(Display *dpy, int screen, int *max);
+#endif
+
+#ifndef GLX_SUN_get_transparent_index
+#define GLX_SUN_get_transparent_index 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern Status glXGetTransparentIndexSUN(Display *, Window, Window, long *);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef Status(* PFNGLXGETTRANSPARENTINDEXSUNPROC)(Display *dpy, Window overlay, Window underlay, long *pTransparentIndex);
+#endif
+
+#ifndef GLX_MESA_copy_sub_buffer
+#define GLX_MESA_copy_sub_buffer 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern void glXCopySubBufferMESA(Display *, GLXDrawable, int, int, int, int);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef void (* PFNGLXCOPYSUBBUFFERMESAPROC)(Display *dpy, GLXDrawable drawable, int x, int y, int width, int height);
+#endif
+
+#ifndef GLX_MESA_pixmap_colormap
+#define GLX_MESA_pixmap_colormap 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern GLXPixmap glXCreateGLXPixmapMESA(Display *, XVisualInfo *, Pixmap, Colormap);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef GLXPixmap(* PFNGLXCREATEGLXPIXMAPMESAPROC)(Display *dpy, XVisualInfo *visual, Pixmap pixmap, Colormap cmap);
+#endif
+
+#ifndef GLX_MESA_release_buffers
+#define GLX_MESA_release_buffers 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern Bool glXReleaseBuffersMESA(Display *, GLXDrawable);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef Bool(* PFNGLXRELEASEBUFFERSMESAPROC)(Display *dpy, GLXDrawable drawable);
+#endif
+
+#ifndef GLX_MESA_set_3dfx_mode
+#define GLX_MESA_set_3dfx_mode 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern Bool glXSet3DfxModeMESA(int);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef Bool(* PFNGLXSET3DFXMODEMESAPROC)(int mode);
+#endif
+
+#ifndef GLX_SGIX_visual_select_group
+#define GLX_SGIX_visual_select_group 1
+#endif
+
+#ifndef GLX_OML_swap_method
+#define GLX_OML_swap_method 1
+#endif
+
+#ifndef GLX_OML_sync_control
+#define GLX_OML_sync_control 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern Bool glXGetSyncValuesOML(Display *, GLXDrawable, int64_t *, int64_t *, int64_t *);
+extern Bool glXGetMscRateOML(Display *, GLXDrawable, int32_t *, int32_t *);
+extern int64_t glXSwapBuffersMscOML(Display *, GLXDrawable, int64_t, int64_t, int64_t);
+extern Bool glXWaitForMscOML(Display *, GLXDrawable, int64_t, int64_t, int64_t, int64_t *, int64_t *, int64_t *);
+extern Bool glXWaitForSbcOML(Display *, GLXDrawable, int64_t, int64_t *, int64_t *, int64_t *);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef Bool(* PFNGLXGETSYNCVALUESOMLPROC)(Display *dpy, GLXDrawable drawable, int64_t *ust, int64_t *msc, int64_t *sbc);
+typedef Bool(* PFNGLXGETMSCRATEOMLPROC)(Display *dpy, GLXDrawable drawable, int32_t *numerator, int32_t *denominator);
+typedef int64_t (* PFNGLXSWAPBUFFERSMSCOMLPROC)(Display *dpy, GLXDrawable drawable, int64_t target_msc, int64_t divisor, int64_t remainder);
+typedef Bool(* PFNGLXWAITFORMSCOMLPROC)(Display *dpy, GLXDrawable drawable, int64_t target_msc, int64_t divisor, int64_t remainder, int64_t *ust, int64_t *msc, int64_t *sbc);
+typedef Bool(* PFNGLXWAITFORSBCOMLPROC)(Display *dpy, GLXDrawable drawable, int64_t target_sbc, int64_t *ust, int64_t *msc, int64_t *sbc);
+#endif
+
+#ifndef GLX_NV_float_buffer
+#define GLX_NV_float_buffer 1
+#endif
+
+#ifndef GLX_SGIX_hyperpipe
+#define GLX_SGIX_hyperpipe 1
+
+typedef struct
+{
+    char    pipeName[GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX];
+    int     networkId;
+} GLXHyperpipeNetworkSGIX;
+
+typedef struct
+{
+    char    pipeName[GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX];
+    int     channel;
+    unsigned int
+    participationType;
+    int     timeSlice;
+} GLXHyperpipeConfigSGIX;
+
+typedef struct
+{
+    char pipeName[GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX];
+    int srcXOrigin, srcYOrigin, srcWidth, srcHeight;
+    int destXOrigin, destYOrigin, destWidth, destHeight;
+} GLXPipeRect;
+
+typedef struct
+{
+    char pipeName[GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX];
+    int XOrigin, YOrigin, maxHeight, maxWidth;
+} GLXPipeRectLimits;
+
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern GLXHyperpipeNetworkSGIX *glXQueryHyperpipeNetworkSGIX(Display *, int *);
+extern int glXHyperpipeConfigSGIX(Display *, int, int, GLXHyperpipeConfigSGIX *, int *);
+extern GLXHyperpipeConfigSGIX *glXQueryHyperpipeConfigSGIX(Display *, int, int *);
+extern int glXDestroyHyperpipeConfigSGIX(Display *, int);
+extern int glXBindHyperpipeSGIX(Display *, int);
+extern int glXQueryHyperpipeBestAttribSGIX(Display *, int, int, int, void *, void *);
+extern int glXHyperpipeAttribSGIX(Display *, int, int, int, void *);
+extern int glXQueryHyperpipeAttribSGIX(Display *, int, int, int, void *);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef GLXHyperpipeNetworkSGIX *(* PFNGLXQUERYHYPERPIPENETWORKSGIXPROC)(Display *dpy, int *npipes);
+typedef int (* PFNGLXHYPERPIPECONFIGSGIXPROC)(Display *dpy, int networkId, int npipes, GLXHyperpipeConfigSGIX *cfg, int *hpId);
+typedef GLXHyperpipeConfigSGIX *(* PFNGLXQUERYHYPERPIPECONFIGSGIXPROC)(Display *dpy, int hpId, int *npipes);
+typedef int (* PFNGLXDESTROYHYPERPIPECONFIGSGIXPROC)(Display *dpy, int hpId);
+typedef int (* PFNGLXBINDHYPERPIPESGIXPROC)(Display *dpy, int hpId);
+typedef int (* PFNGLXQUERYHYPERPIPEBESTATTRIBSGIXPROC)(Display *dpy, int timeSlice, int attrib, int size, void *attribList, void *returnAttribList);
+typedef int (* PFNGLXHYPERPIPEATTRIBSGIXPROC)(Display *dpy, int timeSlice, int attrib, int size, void *attribList);
+typedef int (* PFNGLXQUERYHYPERPIPEATTRIBSGIXPROC)(Display *dpy, int timeSlice, int attrib, int size, void *returnAttribList);
+#endif
+
+#ifndef GLX_MESA_agp_offset
+#define GLX_MESA_agp_offset 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern unsigned int glXGetAGPOffsetMESA(const void *);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef unsigned int (* PFNGLXGETAGPOFFSETMESAPROC)(const void *pointer);
+#endif
+
+/*
+ * GLX_NV_vertex_array_range is not a real extension name...
+ */
+#ifndef GLX_NV_vertex_array_range
+#define GLX_NV_vertex_array_range 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern void *glXAllocateMemoryNV(GLsizei size, GLfloat readfreq,
+                                 GLfloat writefreq, GLfloat priority);
+
+extern void glXFreeMemoryNV(GLvoid *pointer);
+#endif
+typedef void *(* PFNGLXALLOCATEMEMORYNVPROC)(GLsizei size,
+                                             GLfloat readfreq,
+                                             GLfloat writefreq,
+                                             GLfloat priority);
+
+typedef void (* PFNGLXFREEMEMORYNVPROC)(GLvoid *pointer);
+#endif
+
+#ifndef GLX_NV_swap_group
+#define GLX_NV_swap_group 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern Bool glXJoinSwapGroupNV(Display *dpy, GLXDrawable drawable,
+                               GLuint group);
+
+extern Bool glXBindSwapBarrierNV(Display *dpy, GLuint group, GLuint barrier);
+
+extern Bool glXQuerySwapGroupNV(Display *dpy, GLXDrawable drawable,
+                                GLuint *group, GLuint *barrier);
+
+extern Bool glXQueryMaxSwapGroupsNV(Display *dpy, int screen,
+                                    GLuint *maxGroups, GLuint *maxBarriers);
+
+extern Bool glXQueryFrameCountNV(Display *dpy, int screen, GLuint *count);
+
+extern Bool glXResetFrameCountNV(Display *dpy, int screen);
+#endif
+typedef Bool(* PFNGLXJOINSWAPGROUPNVPROC)(Display *dpy,
+                                          GLXDrawable drawable,
+                                          GLuint group);
+
+typedef Bool(* PFNGLXBINDSWAPBARRIERNVPROC)(Display *dpy,
+                                            GLuint group,
+                                            GLuint barrier);
+
+typedef Bool(* PFNGLXQUERYSWAPGROUPNVPROC)(Display *dpy,
+                                           GLXDrawable drawable,
+                                           GLuint *group,
+                                           GLuint *barrier);
+
+typedef Bool(* PFNGLXQUERYMAXSWAPGROUPSNVPROC)(Display *dpy,
+                                               int screen,
+                                               GLuint *maxGroups,
+                                               GLuint *maxBarriers);
+
+typedef Bool(* PFNGLXQUERYFRAMECOUNTNVPROC)(Display *dpy,
+                                            int screen,
+                                            GLuint *count);
+
+typedef Bool(* PFNGLXRESETFRAMECOUNTNVPROC)(Display *dpy, int screen);
+#endif
+
+#ifndef GLX_NV_video_out
+#define GLX_NV_video_out 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern int glXGetVideoDeviceNV(Display *dpy, int screen, int numVideoDevices,
+                               GLXVideoDeviceNV *pVideoDevice);
+
+extern int glXReleaseVideoDeviceNV(Display *dpy, int screen,
+                                   GLXVideoDeviceNV VideoDevice);
+
+extern int glXBindVideoImageNV(Display *dpy, GLXVideoDeviceNV VideoDevice,
+                               GLXPbuffer pbuf, int iVideoBuffer);
+
+extern int glXReleaseVideoImageNV(Display *dpy, GLXPbuffer pbuf);
+
+extern int glXSendPbufferToVideoNV(Display *dpy, GLXPbuffer pbuf,
+                                   int iBufferType,
+                                   unsigned long *pulCounterPbuffer,
+                                   GLboolean bBlock);
+
+extern int glXGetVideoInfoNV(Display *dpy, int screen,
+                             GLXVideoDeviceNV VideoDevice,
+                             unsigned long *pulCounterOutputVideo,
+                             unsigned long *pulCounterOutputPbuffer);
+#endif
+typedef int (* PFNGLXGETVIDEODEVICENVPROC)(Display *dpy,
+                                           int screen,
+                                           int numVideoDevices,
+                                           GLXVideoDeviceNV *pVideoDevice);
+
+typedef int (* PFNGLXRELEASEVIDEODEVICENVPROC)(Display *dpy,
+                                               int screen,
+                                               GLXVideoDeviceNV VideoDevice);
+
+typedef int (* PFNGLXBINDVIDEOIMAGENVPROC)(Display *dpy,
+                                           GLXVideoDeviceNV VideoDevice,
+                                           GLXPbuffer pbuf,
+                                           int iVideoBuffer);
+
+typedef int (* PFNGLXRELEASEVIDEOIMAGENVPROC)(Display *dpy,
+                                              GLXPbuffer pbuf);
+
+typedef int (* PFNGLXSENDPBUFFERTOVIDEONVPROC)(Display *dpy,
+                                               GLXPbuffer pbuf,
+                                               int iBufferType,
+                                               unsigned long *pulCounterPbuffer,
+                                               GLboolean bBlock);
+
+typedef int (* PFNGLXGETVIDEOINFONVPROC)(Display *dpy, int screen,
+                                         GLXVideoDeviceNV VideoDevice,
+                                         unsigned long *pulCounterOutputVideo,
+                                         unsigned long *pulCounterOutputPbuffer);
+#endif
+
+#ifndef GLX_EXT_texture_from_pixmap
+#define GLX_EXT_texture_from_pixmap
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern void glXBindTexImageEXT(Display *dpy, GLXDrawable drawable,
+                               int buffer, const int *attrib_list);
+extern void glXReleaseTexImageEXT(Display *dpy, GLXDrawable drawable,
+                                  int buffer);
+#endif
+typedef void (* PFNGLXBINDTEXIMAGEEXTPROC)(Display *dpy,
+                                           GLXDrawable drawable,
+                                           int buffer,
+                                           const int *attrib_list);
+typedef void (* PFNGLXRELEASETEXIMAGEEXTPROC)(Display *dpy,
+                                              GLXDrawable drawable,
+                                              int buffer);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

Common/GL/wglew.h

@@ -0,0 +1,958 @@
+/*
+** The OpenGL Extension Wrangler Library
+** Copyright (C) 2002-2006, Milan Ikits <milan ikits[]ieee org>
+** Copyright (C) 2002-2006, Marcelo E. Magallon <mmagallo[]debian org>
+** Copyright (C) 2002, Lev Povalahev
+** 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.
+** * The name of the author 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 AND CONTRIBUTORS "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 __wglew_h__
+#define __wglew_h__
+#define __WGLEW_H__
+
+#ifdef __wglext_h_
+#error wglext.h included before wglew.h
+#endif
+
+#define __wglext_h_
+
+#if !defined(APIENTRY) && !defined(__CYGWIN__)
+#  ifndef WIN32_LEAN_AND_MEAN
+#    define WIN32_LEAN_AND_MEAN 1
+#  endif
+#include <windows.h>
+#endif
+
+/*
+ * GLEW_STATIC needs to be set when using the static version.
+ * GLEW_BUILD is set when building the DLL version.
+ */
+#ifdef GLEW_STATIC
+#  define GLEWAPI extern
+#else
+#  ifdef GLEW_BUILD
+#    define GLEWAPI extern __declspec(dllexport)
+#  else
+#    define GLEWAPI extern __declspec(dllimport)
+#  endif
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* -------------------------- WGL_3DFX_multisample ------------------------- */
+
+#ifndef WGL_3DFX_multisample
+#define WGL_3DFX_multisample 1
+
+#define WGL_SAMPLE_BUFFERS_3DFX 0x2060
+#define WGL_SAMPLES_3DFX 0x2061
+
+#define WGLEW_3DFX_multisample WGLEW_GET_VAR(__WGLEW_3DFX_multisample)
+
+#endif /* WGL_3DFX_multisample */
+
+/* ------------------------- WGL_3DL_stereo_control ------------------------ */
+
+#ifndef WGL_3DL_stereo_control
+#define WGL_3DL_stereo_control 1
+
+#define WGL_STEREO_EMITTER_ENABLE_3DL 0x2055
+#define WGL_STEREO_EMITTER_DISABLE_3DL 0x2056
+#define WGL_STEREO_POLARITY_NORMAL_3DL 0x2057
+#define WGL_STEREO_POLARITY_INVERT_3DL 0x2058
+
+typedef BOOL (WINAPI *PFNWGLSETSTEREOEMITTERSTATE3DLPROC)(HDC hDC, UINT uState);
+
+#define wglSetStereoEmitterState3DL WGLEW_GET_FUN(__wglewSetStereoEmitterState3DL)
+
+#define WGLEW_3DL_stereo_control WGLEW_GET_VAR(__WGLEW_3DL_stereo_control)
+
+#endif /* WGL_3DL_stereo_control */
+
+/* ------------------------- WGL_ARB_buffer_region ------------------------- */
+
+#ifndef WGL_ARB_buffer_region
+#define WGL_ARB_buffer_region 1
+
+#define WGL_FRONT_COLOR_BUFFER_BIT_ARB 0x00000001
+#define WGL_BACK_COLOR_BUFFER_BIT_ARB 0x00000002
+#define WGL_DEPTH_BUFFER_BIT_ARB 0x00000004
+#define WGL_STENCIL_BUFFER_BIT_ARB 0x00000008
+
+typedef HANDLE(WINAPI *PFNWGLCREATEBUFFERREGIONARBPROC)(HDC hDC, int iLayerPlane, UINT uType);
+typedef VOID (WINAPI *PFNWGLDELETEBUFFERREGIONARBPROC)(HANDLE hRegion);
+typedef BOOL (WINAPI *PFNWGLRESTOREBUFFERREGIONARBPROC)(HANDLE hRegion, int x, int y, int width, int height, int xSrc, int ySrc);
+typedef BOOL (WINAPI *PFNWGLSAVEBUFFERREGIONARBPROC)(HANDLE hRegion, int x, int y, int width, int height);
+
+#define wglCreateBufferRegionARB WGLEW_GET_FUN(__wglewCreateBufferRegionARB)
+#define wglDeleteBufferRegionARB WGLEW_GET_FUN(__wglewDeleteBufferRegionARB)
+#define wglRestoreBufferRegionARB WGLEW_GET_FUN(__wglewRestoreBufferRegionARB)
+#define wglSaveBufferRegionARB WGLEW_GET_FUN(__wglewSaveBufferRegionARB)
+
+#define WGLEW_ARB_buffer_region WGLEW_GET_VAR(__WGLEW_ARB_buffer_region)
+
+#endif /* WGL_ARB_buffer_region */
+
+/* ----------------------- WGL_ARB_extensions_string ----------------------- */
+
+#ifndef WGL_ARB_extensions_string
+#define WGL_ARB_extensions_string 1
+
+typedef const char *(WINAPI *PFNWGLGETEXTENSIONSSTRINGARBPROC)(HDC hdc);
+
+#define wglGetExtensionsStringARB WGLEW_GET_FUN(__wglewGetExtensionsStringARB)
+
+#define WGLEW_ARB_extensions_string WGLEW_GET_VAR(__WGLEW_ARB_extensions_string)
+
+#endif /* WGL_ARB_extensions_string */
+
+/* ----------------------- WGL_ARB_make_current_read ----------------------- */
+
+#ifndef WGL_ARB_make_current_read
+#define WGL_ARB_make_current_read 1
+
+typedef HDC(WINAPI *PFNWGLGETCURRENTREADDCARBPROC)(VOID);
+typedef BOOL (WINAPI *PFNWGLMAKECONTEXTCURRENTARBPROC)(HDC hDrawDC, HDC hReadDC, HGLRC hglrc);
+
+#define wglGetCurrentReadDCARB WGLEW_GET_FUN(__wglewGetCurrentReadDCARB)
+#define wglMakeContextCurrentARB WGLEW_GET_FUN(__wglewMakeContextCurrentARB)
+
+#define WGLEW_ARB_make_current_read WGLEW_GET_VAR(__WGLEW_ARB_make_current_read)
+
+#endif /* WGL_ARB_make_current_read */
+
+/* -------------------------- WGL_ARB_multisample -------------------------- */
+
+#ifndef WGL_ARB_multisample
+#define WGL_ARB_multisample 1
+
+#define WGL_SAMPLE_BUFFERS_ARB 0x2041
+#define WGL_SAMPLES_ARB 0x2042
+
+#define WGLEW_ARB_multisample WGLEW_GET_VAR(__WGLEW_ARB_multisample)
+
+#endif /* WGL_ARB_multisample */
+
+/* ---------------------------- WGL_ARB_pbuffer ---------------------------- */
+
+#ifndef WGL_ARB_pbuffer
+#define WGL_ARB_pbuffer 1
+
+#define WGL_DRAW_TO_PBUFFER_ARB 0x202D
+#define WGL_MAX_PBUFFER_PIXELS_ARB 0x202E
+#define WGL_MAX_PBUFFER_WIDTH_ARB 0x202F
+#define WGL_MAX_PBUFFER_HEIGHT_ARB 0x2030
+#define WGL_PBUFFER_LARGEST_ARB 0x2033
+#define WGL_PBUFFER_WIDTH_ARB 0x2034
+#define WGL_PBUFFER_HEIGHT_ARB 0x2035
+#define WGL_PBUFFER_LOST_ARB 0x2036
+
+DECLARE_HANDLE(HPBUFFERARB);
+
+typedef HPBUFFERARB(WINAPI *PFNWGLCREATEPBUFFERARBPROC)(HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList);
+typedef BOOL (WINAPI *PFNWGLDESTROYPBUFFERARBPROC)(HPBUFFERARB hPbuffer);
+typedef HDC(WINAPI *PFNWGLGETPBUFFERDCARBPROC)(HPBUFFERARB hPbuffer);
+typedef BOOL (WINAPI *PFNWGLQUERYPBUFFERARBPROC)(HPBUFFERARB hPbuffer, int iAttribute, int *piValue);
+typedef int (WINAPI *PFNWGLRELEASEPBUFFERDCARBPROC)(HPBUFFERARB hPbuffer, HDC hDC);
+
+#define wglCreatePbufferARB WGLEW_GET_FUN(__wglewCreatePbufferARB)
+#define wglDestroyPbufferARB WGLEW_GET_FUN(__wglewDestroyPbufferARB)
+#define wglGetPbufferDCARB WGLEW_GET_FUN(__wglewGetPbufferDCARB)
+#define wglQueryPbufferARB WGLEW_GET_FUN(__wglewQueryPbufferARB)
+#define wglReleasePbufferDCARB WGLEW_GET_FUN(__wglewReleasePbufferDCARB)
+
+#define WGLEW_ARB_pbuffer WGLEW_GET_VAR(__WGLEW_ARB_pbuffer)
+
+#endif /* WGL_ARB_pbuffer */
+
+/* -------------------------- WGL_ARB_pixel_format ------------------------- */
+
+#ifndef WGL_ARB_pixel_format
+#define WGL_ARB_pixel_format 1
+
+#define WGL_NUMBER_PIXEL_FORMATS_ARB 0x2000
+#define WGL_DRAW_TO_WINDOW_ARB 0x2001
+#define WGL_DRAW_TO_BITMAP_ARB 0x2002
+#define WGL_ACCELERATION_ARB 0x2003
+#define WGL_NEED_PALETTE_ARB 0x2004
+#define WGL_NEED_SYSTEM_PALETTE_ARB 0x2005
+#define WGL_SWAP_LAYER_BUFFERS_ARB 0x2006
+#define WGL_SWAP_METHOD_ARB 0x2007
+#define WGL_NUMBER_OVERLAYS_ARB 0x2008
+#define WGL_NUMBER_UNDERLAYS_ARB 0x2009
+#define WGL_TRANSPARENT_ARB 0x200A
+#define WGL_SHARE_DEPTH_ARB 0x200C
+#define WGL_SHARE_STENCIL_ARB 0x200D
+#define WGL_SHARE_ACCUM_ARB 0x200E
+#define WGL_SUPPORT_GDI_ARB 0x200F
+#define WGL_SUPPORT_OPENGL_ARB 0x2010
+#define WGL_DOUBLE_BUFFER_ARB 0x2011
+#define WGL_STEREO_ARB 0x2012
+#define WGL_PIXEL_TYPE_ARB 0x2013
+#define WGL_COLOR_BITS_ARB 0x2014
+#define WGL_RED_BITS_ARB 0x2015
+#define WGL_RED_SHIFT_ARB 0x2016
+#define WGL_GREEN_BITS_ARB 0x2017
+#define WGL_GREEN_SHIFT_ARB 0x2018
+#define WGL_BLUE_BITS_ARB 0x2019
+#define WGL_BLUE_SHIFT_ARB 0x201A
+#define WGL_ALPHA_BITS_ARB 0x201B
+#define WGL_ALPHA_SHIFT_ARB 0x201C
+#define WGL_ACCUM_BITS_ARB 0x201D
+#define WGL_ACCUM_RED_BITS_ARB 0x201E
+#define WGL_ACCUM_GREEN_BITS_ARB 0x201F
+#define WGL_ACCUM_BLUE_BITS_ARB 0x2020
+#define WGL_ACCUM_ALPHA_BITS_ARB 0x2021
+#define WGL_DEPTH_BITS_ARB 0x2022
+#define WGL_STENCIL_BITS_ARB 0x2023
+#define WGL_AUX_BUFFERS_ARB 0x2024
+#define WGL_NO_ACCELERATION_ARB 0x2025
+#define WGL_GENERIC_ACCELERATION_ARB 0x2026
+#define WGL_FULL_ACCELERATION_ARB 0x2027
+#define WGL_SWAP_EXCHANGE_ARB 0x2028
+#define WGL_SWAP_COPY_ARB 0x2029
+#define WGL_SWAP_UNDEFINED_ARB 0x202A
+#define WGL_TYPE_RGBA_ARB 0x202B
+#define WGL_TYPE_COLORINDEX_ARB 0x202C
+#define WGL_TRANSPARENT_RED_VALUE_ARB 0x2037
+#define WGL_TRANSPARENT_GREEN_VALUE_ARB 0x2038
+#define WGL_TRANSPARENT_BLUE_VALUE_ARB 0x2039
+#define WGL_TRANSPARENT_ALPHA_VALUE_ARB 0x203A
+#define WGL_TRANSPARENT_INDEX_VALUE_ARB 0x203B
+
+typedef BOOL (WINAPI *PFNWGLCHOOSEPIXELFORMATARBPROC)(HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats);
+typedef BOOL (WINAPI *PFNWGLGETPIXELFORMATATTRIBFVARBPROC)(HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, FLOAT *pfValues);
+typedef BOOL (WINAPI *PFNWGLGETPIXELFORMATATTRIBIVARBPROC)(HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, int *piValues);
+
+#define wglChoosePixelFormatARB WGLEW_GET_FUN(__wglewChoosePixelFormatARB)
+#define wglGetPixelFormatAttribfvARB WGLEW_GET_FUN(__wglewGetPixelFormatAttribfvARB)
+#define wglGetPixelFormatAttribivARB WGLEW_GET_FUN(__wglewGetPixelFormatAttribivARB)
+
+#define WGLEW_ARB_pixel_format WGLEW_GET_VAR(__WGLEW_ARB_pixel_format)
+
+#endif /* WGL_ARB_pixel_format */
+
+/* ----------------------- WGL_ARB_pixel_format_float ---------------------- */
+
+#ifndef WGL_ARB_pixel_format_float
+#define WGL_ARB_pixel_format_float 1
+
+#define WGL_TYPE_RGBA_FLOAT_ARB 0x21A0
+
+#define WGLEW_ARB_pixel_format_float WGLEW_GET_VAR(__WGLEW_ARB_pixel_format_float)
+
+#endif /* WGL_ARB_pixel_format_float */
+
+/* ------------------------- WGL_ARB_render_texture ------------------------ */
+
+#ifndef WGL_ARB_render_texture
+#define WGL_ARB_render_texture 1
+
+#define WGL_BIND_TO_TEXTURE_RGB_ARB 0x2070
+#define WGL_BIND_TO_TEXTURE_RGBA_ARB 0x2071
+#define WGL_TEXTURE_FORMAT_ARB 0x2072
+#define WGL_TEXTURE_TARGET_ARB 0x2073
+#define WGL_MIPMAP_TEXTURE_ARB 0x2074
+#define WGL_TEXTURE_RGB_ARB 0x2075
+#define WGL_TEXTURE_RGBA_ARB 0x2076
+#define WGL_NO_TEXTURE_ARB 0x2077
+#define WGL_TEXTURE_CUBE_MAP_ARB 0x2078
+#define WGL_TEXTURE_1D_ARB 0x2079
+#define WGL_TEXTURE_2D_ARB 0x207A
+#define WGL_MIPMAP_LEVEL_ARB 0x207B
+#define WGL_CUBE_MAP_FACE_ARB 0x207C
+#define WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB 0x207D
+#define WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB 0x207E
+#define WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB 0x207F
+#define WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB 0x2080
+#define WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB 0x2081
+#define WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB 0x2082
+#define WGL_FRONT_LEFT_ARB 0x2083
+#define WGL_FRONT_RIGHT_ARB 0x2084
+#define WGL_BACK_LEFT_ARB 0x2085
+#define WGL_BACK_RIGHT_ARB 0x2086
+#define WGL_AUX0_ARB 0x2087
+#define WGL_AUX1_ARB 0x2088
+#define WGL_AUX2_ARB 0x2089
+#define WGL_AUX3_ARB 0x208A
+#define WGL_AUX4_ARB 0x208B
+#define WGL_AUX5_ARB 0x208C
+#define WGL_AUX6_ARB 0x208D
+#define WGL_AUX7_ARB 0x208E
+#define WGL_AUX8_ARB 0x208F
+#define WGL_AUX9_ARB 0x2090
+
+typedef BOOL (WINAPI *PFNWGLBINDTEXIMAGEARBPROC)(HPBUFFERARB hPbuffer, int iBuffer);
+typedef BOOL (WINAPI *PFNWGLRELEASETEXIMAGEARBPROC)(HPBUFFERARB hPbuffer, int iBuffer);
+typedef BOOL (WINAPI *PFNWGLSETPBUFFERATTRIBARBPROC)(HPBUFFERARB hPbuffer, const int *piAttribList);
+
+#define wglBindTexImageARB WGLEW_GET_FUN(__wglewBindTexImageARB)
+#define wglReleaseTexImageARB WGLEW_GET_FUN(__wglewReleaseTexImageARB)
+#define wglSetPbufferAttribARB WGLEW_GET_FUN(__wglewSetPbufferAttribARB)
+
+#define WGLEW_ARB_render_texture WGLEW_GET_VAR(__WGLEW_ARB_render_texture)
+
+#endif /* WGL_ARB_render_texture */
+
+/* ----------------------- WGL_ATI_pixel_format_float ---------------------- */
+
+#ifndef WGL_ATI_pixel_format_float
+#define WGL_ATI_pixel_format_float 1
+
+#define WGL_TYPE_RGBA_FLOAT_ATI 0x21A0
+#define GL_RGBA_FLOAT_MODE_ATI 0x8820
+#define GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI 0x8835
+
+#define WGLEW_ATI_pixel_format_float WGLEW_GET_VAR(__WGLEW_ATI_pixel_format_float)
+
+#endif /* WGL_ATI_pixel_format_float */
+
+/* -------------------- WGL_ATI_render_texture_rectangle ------------------- */
+
+#ifndef WGL_ATI_render_texture_rectangle
+#define WGL_ATI_render_texture_rectangle 1
+
+#define WGL_TEXTURE_RECTANGLE_ATI 0x21A5
+
+#define WGLEW_ATI_render_texture_rectangle WGLEW_GET_VAR(__WGLEW_ATI_render_texture_rectangle)
+
+#endif /* WGL_ATI_render_texture_rectangle */
+
+/* -------------------------- WGL_EXT_depth_float -------------------------- */
+
+#ifndef WGL_EXT_depth_float
+#define WGL_EXT_depth_float 1
+
+#define WGL_DEPTH_FLOAT_EXT 0x2040
+
+#define WGLEW_EXT_depth_float WGLEW_GET_VAR(__WGLEW_EXT_depth_float)
+
+#endif /* WGL_EXT_depth_float */
+
+/* ---------------------- WGL_EXT_display_color_table ---------------------- */
+
+#ifndef WGL_EXT_display_color_table
+#define WGL_EXT_display_color_table 1
+
+typedef GLboolean(WINAPI *PFNWGLBINDDISPLAYCOLORTABLEEXTPROC)(GLushort id);
+typedef GLboolean(WINAPI *PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC)(GLushort id);
+typedef void (WINAPI *PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC)(GLushort id);
+typedef GLboolean(WINAPI *PFNWGLLOADDISPLAYCOLORTABLEEXTPROC)(GLushort *table, GLuint length);
+
+#define wglBindDisplayColorTableEXT WGLEW_GET_FUN(__wglewBindDisplayColorTableEXT)
+#define wglCreateDisplayColorTableEXT WGLEW_GET_FUN(__wglewCreateDisplayColorTableEXT)
+#define wglDestroyDisplayColorTableEXT WGLEW_GET_FUN(__wglewDestroyDisplayColorTableEXT)
+#define wglLoadDisplayColorTableEXT WGLEW_GET_FUN(__wglewLoadDisplayColorTableEXT)
+
+#define WGLEW_EXT_display_color_table WGLEW_GET_VAR(__WGLEW_EXT_display_color_table)
+
+#endif /* WGL_EXT_display_color_table */
+
+/* ----------------------- WGL_EXT_extensions_string ----------------------- */
+
+#ifndef WGL_EXT_extensions_string
+#define WGL_EXT_extensions_string 1
+
+typedef const char *(WINAPI *PFNWGLGETEXTENSIONSSTRINGEXTPROC)(void);
+
+#define wglGetExtensionsStringEXT WGLEW_GET_FUN(__wglewGetExtensionsStringEXT)
+
+#define WGLEW_EXT_extensions_string WGLEW_GET_VAR(__WGLEW_EXT_extensions_string)
+
+#endif /* WGL_EXT_extensions_string */
+
+/* ------------------------ WGL_EXT_framebuffer_sRGB ----------------------- */
+
+#ifndef WGL_EXT_framebuffer_sRGB
+#define WGL_EXT_framebuffer_sRGB 1
+
+#define WGL_FRAMEBUFFER_SRGB_CAPABLE_EXT 0x20A9
+
+#define WGLEW_EXT_framebuffer_sRGB WGLEW_GET_VAR(__WGLEW_EXT_framebuffer_sRGB)
+
+#endif /* WGL_EXT_framebuffer_sRGB */
+
+/* ----------------------- WGL_EXT_make_current_read ----------------------- */
+
+#ifndef WGL_EXT_make_current_read
+#define WGL_EXT_make_current_read 1
+
+typedef HDC(WINAPI *PFNWGLGETCURRENTREADDCEXTPROC)(VOID);
+typedef BOOL (WINAPI *PFNWGLMAKECONTEXTCURRENTEXTPROC)(HDC hDrawDC, HDC hReadDC, HGLRC hglrc);
+
+#define wglGetCurrentReadDCEXT WGLEW_GET_FUN(__wglewGetCurrentReadDCEXT)
+#define wglMakeContextCurrentEXT WGLEW_GET_FUN(__wglewMakeContextCurrentEXT)
+
+#define WGLEW_EXT_make_current_read WGLEW_GET_VAR(__WGLEW_EXT_make_current_read)
+
+#endif /* WGL_EXT_make_current_read */
+
+/* -------------------------- WGL_EXT_multisample -------------------------- */
+
+#ifndef WGL_EXT_multisample
+#define WGL_EXT_multisample 1
+
+#define WGL_SAMPLE_BUFFERS_EXT 0x2041
+#define WGL_SAMPLES_EXT 0x2042
+
+#define WGLEW_EXT_multisample WGLEW_GET_VAR(__WGLEW_EXT_multisample)
+
+#endif /* WGL_EXT_multisample */
+
+/* ---------------------------- WGL_EXT_pbuffer ---------------------------- */
+
+#ifndef WGL_EXT_pbuffer
+#define WGL_EXT_pbuffer 1
+
+#define WGL_DRAW_TO_PBUFFER_EXT 0x202D
+#define WGL_MAX_PBUFFER_PIXELS_EXT 0x202E
+#define WGL_MAX_PBUFFER_WIDTH_EXT 0x202F
+#define WGL_MAX_PBUFFER_HEIGHT_EXT 0x2030
+#define WGL_OPTIMAL_PBUFFER_WIDTH_EXT 0x2031
+#define WGL_OPTIMAL_PBUFFER_HEIGHT_EXT 0x2032
+#define WGL_PBUFFER_LARGEST_EXT 0x2033
+#define WGL_PBUFFER_WIDTH_EXT 0x2034
+#define WGL_PBUFFER_HEIGHT_EXT 0x2035
+
+DECLARE_HANDLE(HPBUFFEREXT);
+
+typedef HPBUFFEREXT(WINAPI *PFNWGLCREATEPBUFFEREXTPROC)(HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList);
+typedef BOOL (WINAPI *PFNWGLDESTROYPBUFFEREXTPROC)(HPBUFFEREXT hPbuffer);
+typedef HDC(WINAPI *PFNWGLGETPBUFFERDCEXTPROC)(HPBUFFEREXT hPbuffer);
+typedef BOOL (WINAPI *PFNWGLQUERYPBUFFEREXTPROC)(HPBUFFEREXT hPbuffer, int iAttribute, int *piValue);
+typedef int (WINAPI *PFNWGLRELEASEPBUFFERDCEXTPROC)(HPBUFFEREXT hPbuffer, HDC hDC);
+
+#define wglCreatePbufferEXT WGLEW_GET_FUN(__wglewCreatePbufferEXT)
+#define wglDestroyPbufferEXT WGLEW_GET_FUN(__wglewDestroyPbufferEXT)
+#define wglGetPbufferDCEXT WGLEW_GET_FUN(__wglewGetPbufferDCEXT)
+#define wglQueryPbufferEXT WGLEW_GET_FUN(__wglewQueryPbufferEXT)
+#define wglReleasePbufferDCEXT WGLEW_GET_FUN(__wglewReleasePbufferDCEXT)
+
+#define WGLEW_EXT_pbuffer WGLEW_GET_VAR(__WGLEW_EXT_pbuffer)
+
+#endif /* WGL_EXT_pbuffer */
+
+/* -------------------------- WGL_EXT_pixel_format ------------------------- */
+
+#ifndef WGL_EXT_pixel_format
+#define WGL_EXT_pixel_format 1
+
+#define WGL_NUMBER_PIXEL_FORMATS_EXT 0x2000
+#define WGL_DRAW_TO_WINDOW_EXT 0x2001
+#define WGL_DRAW_TO_BITMAP_EXT 0x2002
+#define WGL_ACCELERATION_EXT 0x2003
+#define WGL_NEED_PALETTE_EXT 0x2004
+#define WGL_NEED_SYSTEM_PALETTE_EXT 0x2005
+#define WGL_SWAP_LAYER_BUFFERS_EXT 0x2006
+#define WGL_SWAP_METHOD_EXT 0x2007
+#define WGL_NUMBER_OVERLAYS_EXT 0x2008
+#define WGL_NUMBER_UNDERLAYS_EXT 0x2009
+#define WGL_TRANSPARENT_EXT 0x200A
+#define WGL_TRANSPARENT_VALUE_EXT 0x200B
+#define WGL_SHARE_DEPTH_EXT 0x200C
+#define WGL_SHARE_STENCIL_EXT 0x200D
+#define WGL_SHARE_ACCUM_EXT 0x200E
+#define WGL_SUPPORT_GDI_EXT 0x200F
+#define WGL_SUPPORT_OPENGL_EXT 0x2010
+#define WGL_DOUBLE_BUFFER_EXT 0x2011
+#define WGL_STEREO_EXT 0x2012
+#define WGL_PIXEL_TYPE_EXT 0x2013
+#define WGL_COLOR_BITS_EXT 0x2014
+#define WGL_RED_BITS_EXT 0x2015
+#define WGL_RED_SHIFT_EXT 0x2016
+#define WGL_GREEN_BITS_EXT 0x2017
+#define WGL_GREEN_SHIFT_EXT 0x2018
+#define WGL_BLUE_BITS_EXT 0x2019
+#define WGL_BLUE_SHIFT_EXT 0x201A
+#define WGL_ALPHA_BITS_EXT 0x201B
+#define WGL_ALPHA_SHIFT_EXT 0x201C
+#define WGL_ACCUM_BITS_EXT 0x201D
+#define WGL_ACCUM_RED_BITS_EXT 0x201E
+#define WGL_ACCUM_GREEN_BITS_EXT 0x201F
+#define WGL_ACCUM_BLUE_BITS_EXT 0x2020
+#define WGL_ACCUM_ALPHA_BITS_EXT 0x2021
+#define WGL_DEPTH_BITS_EXT 0x2022
+#define WGL_STENCIL_BITS_EXT 0x2023
+#define WGL_AUX_BUFFERS_EXT 0x2024
+#define WGL_NO_ACCELERATION_EXT 0x2025
+#define WGL_GENERIC_ACCELERATION_EXT 0x2026
+#define WGL_FULL_ACCELERATION_EXT 0x2027
+#define WGL_SWAP_EXCHANGE_EXT 0x2028
+#define WGL_SWAP_COPY_EXT 0x2029
+#define WGL_SWAP_UNDEFINED_EXT 0x202A
+#define WGL_TYPE_RGBA_EXT 0x202B
+#define WGL_TYPE_COLORINDEX_EXT 0x202C
+
+typedef BOOL (WINAPI *PFNWGLCHOOSEPIXELFORMATEXTPROC)(HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats);
+typedef BOOL (WINAPI *PFNWGLGETPIXELFORMATATTRIBFVEXTPROC)(HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int *piAttributes, FLOAT *pfValues);
+typedef BOOL (WINAPI *PFNWGLGETPIXELFORMATATTRIBIVEXTPROC)(HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int *piAttributes, int *piValues);
+
+#define wglChoosePixelFormatEXT WGLEW_GET_FUN(__wglewChoosePixelFormatEXT)
+#define wglGetPixelFormatAttribfvEXT WGLEW_GET_FUN(__wglewGetPixelFormatAttribfvEXT)
+#define wglGetPixelFormatAttribivEXT WGLEW_GET_FUN(__wglewGetPixelFormatAttribivEXT)
+
+#define WGLEW_EXT_pixel_format WGLEW_GET_VAR(__WGLEW_EXT_pixel_format)
+
+#endif /* WGL_EXT_pixel_format */
+
+/* ------------------- WGL_EXT_pixel_format_packed_float ------------------- */
+
+#ifndef WGL_EXT_pixel_format_packed_float
+#define WGL_EXT_pixel_format_packed_float 1
+
+#define WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT 0x20A8
+
+#define WGLEW_EXT_pixel_format_packed_float WGLEW_GET_VAR(__WGLEW_EXT_pixel_format_packed_float)
+
+#endif /* WGL_EXT_pixel_format_packed_float */
+
+/* -------------------------- WGL_EXT_swap_control ------------------------- */
+
+#ifndef WGL_EXT_swap_control
+#define WGL_EXT_swap_control 1
+
+typedef int (WINAPI *PFNWGLGETSWAPINTERVALEXTPROC)(void);
+typedef BOOL (WINAPI *PFNWGLSWAPINTERVALEXTPROC)(int interval);
+
+#define wglGetSwapIntervalEXT WGLEW_GET_FUN(__wglewGetSwapIntervalEXT)
+#define wglSwapIntervalEXT WGLEW_GET_FUN(__wglewSwapIntervalEXT)
+
+#define WGLEW_EXT_swap_control WGLEW_GET_VAR(__WGLEW_EXT_swap_control)
+
+#endif /* WGL_EXT_swap_control */
+
+/* --------------------- WGL_I3D_digital_video_control --------------------- */
+
+#ifndef WGL_I3D_digital_video_control
+#define WGL_I3D_digital_video_control 1
+
+#define WGL_DIGITAL_VIDEO_CURSOR_ALPHA_FRAMEBUFFER_I3D 0x2050
+#define WGL_DIGITAL_VIDEO_CURSOR_ALPHA_VALUE_I3D 0x2051
+#define WGL_DIGITAL_VIDEO_CURSOR_INCLUDED_I3D 0x2052
+#define WGL_DIGITAL_VIDEO_GAMMA_CORRECTED_I3D 0x2053
+
+typedef BOOL (WINAPI *PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC)(HDC hDC, int iAttribute, int *piValue);
+typedef BOOL (WINAPI *PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC)(HDC hDC, int iAttribute, const int *piValue);
+
+#define wglGetDigitalVideoParametersI3D WGLEW_GET_FUN(__wglewGetDigitalVideoParametersI3D)
+#define wglSetDigitalVideoParametersI3D WGLEW_GET_FUN(__wglewSetDigitalVideoParametersI3D)
+
+#define WGLEW_I3D_digital_video_control WGLEW_GET_VAR(__WGLEW_I3D_digital_video_control)
+
+#endif /* WGL_I3D_digital_video_control */
+
+/* ----------------------------- WGL_I3D_gamma ----------------------------- */
+
+#ifndef WGL_I3D_gamma
+#define WGL_I3D_gamma 1
+
+#define WGL_GAMMA_TABLE_SIZE_I3D 0x204E
+#define WGL_GAMMA_EXCLUDE_DESKTOP_I3D 0x204F
+
+typedef BOOL (WINAPI *PFNWGLGETGAMMATABLEI3DPROC)(HDC hDC, int iEntries, USHORT *puRed, USHORT *puGreen, USHORT *puBlue);
+typedef BOOL (WINAPI *PFNWGLGETGAMMATABLEPARAMETERSI3DPROC)(HDC hDC, int iAttribute, int *piValue);
+typedef BOOL (WINAPI *PFNWGLSETGAMMATABLEI3DPROC)(HDC hDC, int iEntries, const USHORT *puRed, const USHORT *puGreen, const USHORT *puBlue);
+typedef BOOL (WINAPI *PFNWGLSETGAMMATABLEPARAMETERSI3DPROC)(HDC hDC, int iAttribute, const int *piValue);
+
+#define wglGetGammaTableI3D WGLEW_GET_FUN(__wglewGetGammaTableI3D)
+#define wglGetGammaTableParametersI3D WGLEW_GET_FUN(__wglewGetGammaTableParametersI3D)
+#define wglSetGammaTableI3D WGLEW_GET_FUN(__wglewSetGammaTableI3D)
+#define wglSetGammaTableParametersI3D WGLEW_GET_FUN(__wglewSetGammaTableParametersI3D)
+
+#define WGLEW_I3D_gamma WGLEW_GET_VAR(__WGLEW_I3D_gamma)
+
+#endif /* WGL_I3D_gamma */
+
+/* ---------------------------- WGL_I3D_genlock ---------------------------- */
+
+#ifndef WGL_I3D_genlock
+#define WGL_I3D_genlock 1
+
+#define WGL_GENLOCK_SOURCE_MULTIVIEW_I3D 0x2044
+#define WGL_GENLOCK_SOURCE_EXTERNAL_SYNC_I3D 0x2045
+#define WGL_GENLOCK_SOURCE_EXTERNAL_FIELD_I3D 0x2046
+#define WGL_GENLOCK_SOURCE_EXTERNAL_TTL_I3D 0x2047
+#define WGL_GENLOCK_SOURCE_DIGITAL_SYNC_I3D 0x2048
+#define WGL_GENLOCK_SOURCE_DIGITAL_FIELD_I3D 0x2049
+#define WGL_GENLOCK_SOURCE_EDGE_FALLING_I3D 0x204A
+#define WGL_GENLOCK_SOURCE_EDGE_RISING_I3D 0x204B
+#define WGL_GENLOCK_SOURCE_EDGE_BOTH_I3D 0x204C
+
+typedef BOOL (WINAPI *PFNWGLDISABLEGENLOCKI3DPROC)(HDC hDC);
+typedef BOOL (WINAPI *PFNWGLENABLEGENLOCKI3DPROC)(HDC hDC);
+typedef BOOL (WINAPI *PFNWGLGENLOCKSAMPLERATEI3DPROC)(HDC hDC, UINT uRate);
+typedef BOOL (WINAPI *PFNWGLGENLOCKSOURCEDELAYI3DPROC)(HDC hDC, UINT uDelay);
+typedef BOOL (WINAPI *PFNWGLGENLOCKSOURCEEDGEI3DPROC)(HDC hDC, UINT uEdge);
+typedef BOOL (WINAPI *PFNWGLGENLOCKSOURCEI3DPROC)(HDC hDC, UINT uSource);
+typedef BOOL (WINAPI *PFNWGLGETGENLOCKSAMPLERATEI3DPROC)(HDC hDC, UINT *uRate);
+typedef BOOL (WINAPI *PFNWGLGETGENLOCKSOURCEDELAYI3DPROC)(HDC hDC, UINT *uDelay);
+typedef BOOL (WINAPI *PFNWGLGETGENLOCKSOURCEEDGEI3DPROC)(HDC hDC, UINT *uEdge);
+typedef BOOL (WINAPI *PFNWGLGETGENLOCKSOURCEI3DPROC)(HDC hDC, UINT *uSource);
+typedef BOOL (WINAPI *PFNWGLISENABLEDGENLOCKI3DPROC)(HDC hDC, BOOL *pFlag);
+typedef BOOL (WINAPI *PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC)(HDC hDC, UINT *uMaxLineDelay, UINT *uMaxPixelDelay);
+
+#define wglDisableGenlockI3D WGLEW_GET_FUN(__wglewDisableGenlockI3D)
+#define wglEnableGenlockI3D WGLEW_GET_FUN(__wglewEnableGenlockI3D)
+#define wglGenlockSampleRateI3D WGLEW_GET_FUN(__wglewGenlockSampleRateI3D)
+#define wglGenlockSourceDelayI3D WGLEW_GET_FUN(__wglewGenlockSourceDelayI3D)
+#define wglGenlockSourceEdgeI3D WGLEW_GET_FUN(__wglewGenlockSourceEdgeI3D)
+#define wglGenlockSourceI3D WGLEW_GET_FUN(__wglewGenlockSourceI3D)
+#define wglGetGenlockSampleRateI3D WGLEW_GET_FUN(__wglewGetGenlockSampleRateI3D)
+#define wglGetGenlockSourceDelayI3D WGLEW_GET_FUN(__wglewGetGenlockSourceDelayI3D)
+#define wglGetGenlockSourceEdgeI3D WGLEW_GET_FUN(__wglewGetGenlockSourceEdgeI3D)
+#define wglGetGenlockSourceI3D WGLEW_GET_FUN(__wglewGetGenlockSourceI3D)
+#define wglIsEnabledGenlockI3D WGLEW_GET_FUN(__wglewIsEnabledGenlockI3D)
+#define wglQueryGenlockMaxSourceDelayI3D WGLEW_GET_FUN(__wglewQueryGenlockMaxSourceDelayI3D)
+
+#define WGLEW_I3D_genlock WGLEW_GET_VAR(__WGLEW_I3D_genlock)
+
+#endif /* WGL_I3D_genlock */
+
+/* -------------------------- WGL_I3D_image_buffer ------------------------- */
+
+#ifndef WGL_I3D_image_buffer
+#define WGL_I3D_image_buffer 1
+
+#define WGL_IMAGE_BUFFER_MIN_ACCESS_I3D 0x00000001
+#define WGL_IMAGE_BUFFER_LOCK_I3D 0x00000002
+
+typedef BOOL (WINAPI *PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC)(HDC hdc, HANDLE *pEvent, LPVOID *pAddress, DWORD *pSize, UINT count);
+typedef LPVOID (WINAPI *PFNWGLCREATEIMAGEBUFFERI3DPROC)(HDC hDC, DWORD dwSize, UINT uFlags);
+typedef BOOL (WINAPI *PFNWGLDESTROYIMAGEBUFFERI3DPROC)(HDC hDC, LPVOID pAddress);
+typedef BOOL (WINAPI *PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC)(HDC hdc, LPVOID *pAddress, UINT count);
+
+#define wglAssociateImageBufferEventsI3D WGLEW_GET_FUN(__wglewAssociateImageBufferEventsI3D)
+#define wglCreateImageBufferI3D WGLEW_GET_FUN(__wglewCreateImageBufferI3D)
+#define wglDestroyImageBufferI3D WGLEW_GET_FUN(__wglewDestroyImageBufferI3D)
+#define wglReleaseImageBufferEventsI3D WGLEW_GET_FUN(__wglewReleaseImageBufferEventsI3D)
+
+#define WGLEW_I3D_image_buffer WGLEW_GET_VAR(__WGLEW_I3D_image_buffer)
+
+#endif /* WGL_I3D_image_buffer */
+
+/* ------------------------ WGL_I3D_swap_frame_lock ------------------------ */
+
+#ifndef WGL_I3D_swap_frame_lock
+#define WGL_I3D_swap_frame_lock 1
+
+typedef BOOL (WINAPI *PFNWGLDISABLEFRAMELOCKI3DPROC)(VOID);
+typedef BOOL (WINAPI *PFNWGLENABLEFRAMELOCKI3DPROC)(VOID);
+typedef BOOL (WINAPI *PFNWGLISENABLEDFRAMELOCKI3DPROC)(BOOL *pFlag);
+typedef BOOL (WINAPI *PFNWGLQUERYFRAMELOCKMASTERI3DPROC)(BOOL *pFlag);
+
+#define wglDisableFrameLockI3D WGLEW_GET_FUN(__wglewDisableFrameLockI3D)
+#define wglEnableFrameLockI3D WGLEW_GET_FUN(__wglewEnableFrameLockI3D)
+#define wglIsEnabledFrameLockI3D WGLEW_GET_FUN(__wglewIsEnabledFrameLockI3D)
+#define wglQueryFrameLockMasterI3D WGLEW_GET_FUN(__wglewQueryFrameLockMasterI3D)
+
+#define WGLEW_I3D_swap_frame_lock WGLEW_GET_VAR(__WGLEW_I3D_swap_frame_lock)
+
+#endif /* WGL_I3D_swap_frame_lock */
+
+/* ------------------------ WGL_I3D_swap_frame_usage ----------------------- */
+
+#ifndef WGL_I3D_swap_frame_usage
+#define WGL_I3D_swap_frame_usage 1
+
+typedef BOOL (WINAPI *PFNWGLBEGINFRAMETRACKINGI3DPROC)(void);
+typedef BOOL (WINAPI *PFNWGLENDFRAMETRACKINGI3DPROC)(void);
+typedef BOOL (WINAPI *PFNWGLGETFRAMEUSAGEI3DPROC)(float *pUsage);
+typedef BOOL (WINAPI *PFNWGLQUERYFRAMETRACKINGI3DPROC)(DWORD *pFrameCount, DWORD *pMissedFrames, float *pLastMissedUsage);
+
+#define wglBeginFrameTrackingI3D WGLEW_GET_FUN(__wglewBeginFrameTrackingI3D)
+#define wglEndFrameTrackingI3D WGLEW_GET_FUN(__wglewEndFrameTrackingI3D)
+#define wglGetFrameUsageI3D WGLEW_GET_FUN(__wglewGetFrameUsageI3D)
+#define wglQueryFrameTrackingI3D WGLEW_GET_FUN(__wglewQueryFrameTrackingI3D)
+
+#define WGLEW_I3D_swap_frame_usage WGLEW_GET_VAR(__WGLEW_I3D_swap_frame_usage)
+
+#endif /* WGL_I3D_swap_frame_usage */
+
+/* -------------------------- WGL_NV_float_buffer -------------------------- */
+
+#ifndef WGL_NV_float_buffer
+#define WGL_NV_float_buffer 1
+
+#define WGL_FLOAT_COMPONENTS_NV 0x20B0
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_R_NV 0x20B1
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RG_NV 0x20B2
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGB_NV 0x20B3
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGBA_NV 0x20B4
+#define WGL_TEXTURE_FLOAT_R_NV 0x20B5
+#define WGL_TEXTURE_FLOAT_RG_NV 0x20B6
+#define WGL_TEXTURE_FLOAT_RGB_NV 0x20B7
+#define WGL_TEXTURE_FLOAT_RGBA_NV 0x20B8
+
+#define WGLEW_NV_float_buffer WGLEW_GET_VAR(__WGLEW_NV_float_buffer)
+
+#endif /* WGL_NV_float_buffer */
+
+/* ---------------------- WGL_NV_render_depth_texture ---------------------- */
+
+#ifndef WGL_NV_render_depth_texture
+#define WGL_NV_render_depth_texture 1
+
+#define WGL_NO_TEXTURE_ARB 0x2077
+#define WGL_BIND_TO_TEXTURE_DEPTH_NV 0x20A3
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_DEPTH_NV 0x20A4
+#define WGL_DEPTH_TEXTURE_FORMAT_NV 0x20A5
+#define WGL_TEXTURE_DEPTH_COMPONENT_NV 0x20A6
+#define WGL_DEPTH_COMPONENT_NV 0x20A7
+
+#define WGLEW_NV_render_depth_texture WGLEW_GET_VAR(__WGLEW_NV_render_depth_texture)
+
+#endif /* WGL_NV_render_depth_texture */
+
+/* -------------------- WGL_NV_render_texture_rectangle -------------------- */
+
+#ifndef WGL_NV_render_texture_rectangle
+#define WGL_NV_render_texture_rectangle 1
+
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV 0x20A0
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV 0x20A1
+#define WGL_TEXTURE_RECTANGLE_NV 0x20A2
+
+#define WGLEW_NV_render_texture_rectangle WGLEW_GET_VAR(__WGLEW_NV_render_texture_rectangle)
+
+#endif /* WGL_NV_render_texture_rectangle */
+
+/* ----------------------- WGL_NV_vertex_array_range ----------------------- */
+
+#ifndef WGL_NV_vertex_array_range
+#define WGL_NV_vertex_array_range 1
+
+typedef void *(WINAPI *PFNWGLALLOCATEMEMORYNVPROC)(GLsizei size, GLfloat readFrequency, GLfloat writeFrequency, GLfloat priority);
+typedef void (WINAPI *PFNWGLFREEMEMORYNVPROC)(void *pointer);
+
+#define wglAllocateMemoryNV WGLEW_GET_FUN(__wglewAllocateMemoryNV)
+#define wglFreeMemoryNV WGLEW_GET_FUN(__wglewFreeMemoryNV)
+
+#define WGLEW_NV_vertex_array_range WGLEW_GET_VAR(__WGLEW_NV_vertex_array_range)
+
+#endif /* WGL_NV_vertex_array_range */
+
+/* -------------------------- WGL_OML_sync_control ------------------------- */
+
+#ifndef WGL_OML_sync_control
+#define WGL_OML_sync_control 1
+
+typedef BOOL (WINAPI *PFNWGLGETMSCRATEOMLPROC)(HDC hdc, INT32 *numerator, INT32 *denominator);
+typedef BOOL (WINAPI *PFNWGLGETSYNCVALUESOMLPROC)(HDC hdc, INT64 *ust, INT64 *msc, INT64 *sbc);
+typedef INT64(WINAPI *PFNWGLSWAPBUFFERSMSCOMLPROC)(HDC hdc, INT64 target_msc, INT64 divisor, INT64 remainder);
+typedef INT64(WINAPI *PFNWGLSWAPLAYERBUFFERSMSCOMLPROC)(HDC hdc, INT fuPlanes, INT64 target_msc, INT64 divisor, INT64 remainder);
+typedef BOOL (WINAPI *PFNWGLWAITFORMSCOMLPROC)(HDC hdc, INT64 target_msc, INT64 divisor, INT64 remainder, INT64 *ust, INT64 *msc, INT64 *sbc);
+typedef BOOL (WINAPI *PFNWGLWAITFORSBCOMLPROC)(HDC hdc, INT64 target_sbc, INT64 *ust, INT64 *msc, INT64 *sbc);
+
+#define wglGetMscRateOML WGLEW_GET_FUN(__wglewGetMscRateOML)
+#define wglGetSyncValuesOML WGLEW_GET_FUN(__wglewGetSyncValuesOML)
+#define wglSwapBuffersMscOML WGLEW_GET_FUN(__wglewSwapBuffersMscOML)
+#define wglSwapLayerBuffersMscOML WGLEW_GET_FUN(__wglewSwapLayerBuffersMscOML)
+#define wglWaitForMscOML WGLEW_GET_FUN(__wglewWaitForMscOML)
+#define wglWaitForSbcOML WGLEW_GET_FUN(__wglewWaitForSbcOML)
+
+#define WGLEW_OML_sync_control WGLEW_GET_VAR(__WGLEW_OML_sync_control)
+
+#endif /* WGL_OML_sync_control */
+
+/* ------------------------------------------------------------------------- */
+
+#ifdef GLEW_MX
+#define WGLEW_EXPORT
+#else
+#define WGLEW_EXPORT GLEWAPI
+#endif /* GLEW_MX */
+
+#ifdef GLEW_MX
+struct WGLEWContextStruct
+{
+#endif /* GLEW_MX */
+
+    WGLEW_EXPORT PFNWGLSETSTEREOEMITTERSTATE3DLPROC __wglewSetStereoEmitterState3DL;
+
+    WGLEW_EXPORT PFNWGLCREATEBUFFERREGIONARBPROC __wglewCreateBufferRegionARB;
+    WGLEW_EXPORT PFNWGLDELETEBUFFERREGIONARBPROC __wglewDeleteBufferRegionARB;
+    WGLEW_EXPORT PFNWGLRESTOREBUFFERREGIONARBPROC __wglewRestoreBufferRegionARB;
+    WGLEW_EXPORT PFNWGLSAVEBUFFERREGIONARBPROC __wglewSaveBufferRegionARB;
+
+    WGLEW_EXPORT PFNWGLGETEXTENSIONSSTRINGARBPROC __wglewGetExtensionsStringARB;
+
+    WGLEW_EXPORT PFNWGLGETCURRENTREADDCARBPROC __wglewGetCurrentReadDCARB;
+    WGLEW_EXPORT PFNWGLMAKECONTEXTCURRENTARBPROC __wglewMakeContextCurrentARB;
+
+    WGLEW_EXPORT PFNWGLCREATEPBUFFERARBPROC __wglewCreatePbufferARB;
+    WGLEW_EXPORT PFNWGLDESTROYPBUFFERARBPROC __wglewDestroyPbufferARB;
+    WGLEW_EXPORT PFNWGLGETPBUFFERDCARBPROC __wglewGetPbufferDCARB;
+    WGLEW_EXPORT PFNWGLQUERYPBUFFERARBPROC __wglewQueryPbufferARB;
+    WGLEW_EXPORT PFNWGLRELEASEPBUFFERDCARBPROC __wglewReleasePbufferDCARB;
+
+    WGLEW_EXPORT PFNWGLCHOOSEPIXELFORMATARBPROC __wglewChoosePixelFormatARB;
+    WGLEW_EXPORT PFNWGLGETPIXELFORMATATTRIBFVARBPROC __wglewGetPixelFormatAttribfvARB;
+    WGLEW_EXPORT PFNWGLGETPIXELFORMATATTRIBIVARBPROC __wglewGetPixelFormatAttribivARB;
+
+    WGLEW_EXPORT PFNWGLBINDTEXIMAGEARBPROC __wglewBindTexImageARB;
+    WGLEW_EXPORT PFNWGLRELEASETEXIMAGEARBPROC __wglewReleaseTexImageARB;
+    WGLEW_EXPORT PFNWGLSETPBUFFERATTRIBARBPROC __wglewSetPbufferAttribARB;
+
+    WGLEW_EXPORT PFNWGLBINDDISPLAYCOLORTABLEEXTPROC __wglewBindDisplayColorTableEXT;
+    WGLEW_EXPORT PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC __wglewCreateDisplayColorTableEXT;
+    WGLEW_EXPORT PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC __wglewDestroyDisplayColorTableEXT;
+    WGLEW_EXPORT PFNWGLLOADDISPLAYCOLORTABLEEXTPROC __wglewLoadDisplayColorTableEXT;
+
+    WGLEW_EXPORT PFNWGLGETEXTENSIONSSTRINGEXTPROC __wglewGetExtensionsStringEXT;
+
+    WGLEW_EXPORT PFNWGLGETCURRENTREADDCEXTPROC __wglewGetCurrentReadDCEXT;
+    WGLEW_EXPORT PFNWGLMAKECONTEXTCURRENTEXTPROC __wglewMakeContextCurrentEXT;
+
+    WGLEW_EXPORT PFNWGLCREATEPBUFFEREXTPROC __wglewCreatePbufferEXT;
+    WGLEW_EXPORT PFNWGLDESTROYPBUFFEREXTPROC __wglewDestroyPbufferEXT;
+    WGLEW_EXPORT PFNWGLGETPBUFFERDCEXTPROC __wglewGetPbufferDCEXT;
+    WGLEW_EXPORT PFNWGLQUERYPBUFFEREXTPROC __wglewQueryPbufferEXT;
+    WGLEW_EXPORT PFNWGLRELEASEPBUFFERDCEXTPROC __wglewReleasePbufferDCEXT;
+
+    WGLEW_EXPORT PFNWGLCHOOSEPIXELFORMATEXTPROC __wglewChoosePixelFormatEXT;
+    WGLEW_EXPORT PFNWGLGETPIXELFORMATATTRIBFVEXTPROC __wglewGetPixelFormatAttribfvEXT;
+    WGLEW_EXPORT PFNWGLGETPIXELFORMATATTRIBIVEXTPROC __wglewGetPixelFormatAttribivEXT;
+
+    WGLEW_EXPORT PFNWGLGETSWAPINTERVALEXTPROC __wglewGetSwapIntervalEXT;
+    WGLEW_EXPORT PFNWGLSWAPINTERVALEXTPROC __wglewSwapIntervalEXT;
+
+    WGLEW_EXPORT PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC __wglewGetDigitalVideoParametersI3D;
+    WGLEW_EXPORT PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC __wglewSetDigitalVideoParametersI3D;
+
+    WGLEW_EXPORT PFNWGLGETGAMMATABLEI3DPROC __wglewGetGammaTableI3D;
+    WGLEW_EXPORT PFNWGLGETGAMMATABLEPARAMETERSI3DPROC __wglewGetGammaTableParametersI3D;
+    WGLEW_EXPORT PFNWGLSETGAMMATABLEI3DPROC __wglewSetGammaTableI3D;
+    WGLEW_EXPORT PFNWGLSETGAMMATABLEPARAMETERSI3DPROC __wglewSetGammaTableParametersI3D;
+
+    WGLEW_EXPORT PFNWGLDISABLEGENLOCKI3DPROC __wglewDisableGenlockI3D;
+    WGLEW_EXPORT PFNWGLENABLEGENLOCKI3DPROC __wglewEnableGenlockI3D;
+    WGLEW_EXPORT PFNWGLGENLOCKSAMPLERATEI3DPROC __wglewGenlockSampleRateI3D;
+    WGLEW_EXPORT PFNWGLGENLOCKSOURCEDELAYI3DPROC __wglewGenlockSourceDelayI3D;
+    WGLEW_EXPORT PFNWGLGENLOCKSOURCEEDGEI3DPROC __wglewGenlockSourceEdgeI3D;
+    WGLEW_EXPORT PFNWGLGENLOCKSOURCEI3DPROC __wglewGenlockSourceI3D;
+    WGLEW_EXPORT PFNWGLGETGENLOCKSAMPLERATEI3DPROC __wglewGetGenlockSampleRateI3D;
+    WGLEW_EXPORT PFNWGLGETGENLOCKSOURCEDELAYI3DPROC __wglewGetGenlockSourceDelayI3D;
+    WGLEW_EXPORT PFNWGLGETGENLOCKSOURCEEDGEI3DPROC __wglewGetGenlockSourceEdgeI3D;
+    WGLEW_EXPORT PFNWGLGETGENLOCKSOURCEI3DPROC __wglewGetGenlockSourceI3D;
+    WGLEW_EXPORT PFNWGLISENABLEDGENLOCKI3DPROC __wglewIsEnabledGenlockI3D;
+    WGLEW_EXPORT PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC __wglewQueryGenlockMaxSourceDelayI3D;
+
+    WGLEW_EXPORT PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC __wglewAssociateImageBufferEventsI3D;
+    WGLEW_EXPORT PFNWGLCREATEIMAGEBUFFERI3DPROC __wglewCreateImageBufferI3D;
+    WGLEW_EXPORT PFNWGLDESTROYIMAGEBUFFERI3DPROC __wglewDestroyImageBufferI3D;
+    WGLEW_EXPORT PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC __wglewReleaseImageBufferEventsI3D;
+
+    WGLEW_EXPORT PFNWGLDISABLEFRAMELOCKI3DPROC __wglewDisableFrameLockI3D;
+    WGLEW_EXPORT PFNWGLENABLEFRAMELOCKI3DPROC __wglewEnableFrameLockI3D;
+    WGLEW_EXPORT PFNWGLISENABLEDFRAMELOCKI3DPROC __wglewIsEnabledFrameLockI3D;
+    WGLEW_EXPORT PFNWGLQUERYFRAMELOCKMASTERI3DPROC __wglewQueryFrameLockMasterI3D;
+
+    WGLEW_EXPORT PFNWGLBEGINFRAMETRACKINGI3DPROC __wglewBeginFrameTrackingI3D;
+    WGLEW_EXPORT PFNWGLENDFRAMETRACKINGI3DPROC __wglewEndFrameTrackingI3D;
+    WGLEW_EXPORT PFNWGLGETFRAMEUSAGEI3DPROC __wglewGetFrameUsageI3D;
+    WGLEW_EXPORT PFNWGLQUERYFRAMETRACKINGI3DPROC __wglewQueryFrameTrackingI3D;
+
+    WGLEW_EXPORT PFNWGLALLOCATEMEMORYNVPROC __wglewAllocateMemoryNV;
+    WGLEW_EXPORT PFNWGLFREEMEMORYNVPROC __wglewFreeMemoryNV;
+
+    WGLEW_EXPORT PFNWGLGETMSCRATEOMLPROC __wglewGetMscRateOML;
+    WGLEW_EXPORT PFNWGLGETSYNCVALUESOMLPROC __wglewGetSyncValuesOML;
+    WGLEW_EXPORT PFNWGLSWAPBUFFERSMSCOMLPROC __wglewSwapBuffersMscOML;
+    WGLEW_EXPORT PFNWGLSWAPLAYERBUFFERSMSCOMLPROC __wglewSwapLayerBuffersMscOML;
+    WGLEW_EXPORT PFNWGLWAITFORMSCOMLPROC __wglewWaitForMscOML;
+    WGLEW_EXPORT PFNWGLWAITFORSBCOMLPROC __wglewWaitForSbcOML;
+    WGLEW_EXPORT GLboolean __WGLEW_3DFX_multisample;
+    WGLEW_EXPORT GLboolean __WGLEW_3DL_stereo_control;
+    WGLEW_EXPORT GLboolean __WGLEW_ARB_buffer_region;
+    WGLEW_EXPORT GLboolean __WGLEW_ARB_extensions_string;
+    WGLEW_EXPORT GLboolean __WGLEW_ARB_make_current_read;
+    WGLEW_EXPORT GLboolean __WGLEW_ARB_multisample;
+    WGLEW_EXPORT GLboolean __WGLEW_ARB_pbuffer;
+    WGLEW_EXPORT GLboolean __WGLEW_ARB_pixel_format;
+    WGLEW_EXPORT GLboolean __WGLEW_ARB_pixel_format_float;
+    WGLEW_EXPORT GLboolean __WGLEW_ARB_render_texture;
+    WGLEW_EXPORT GLboolean __WGLEW_ATI_pixel_format_float;
+    WGLEW_EXPORT GLboolean __WGLEW_ATI_render_texture_rectangle;
+    WGLEW_EXPORT GLboolean __WGLEW_EXT_depth_float;
+    WGLEW_EXPORT GLboolean __WGLEW_EXT_display_color_table;
+    WGLEW_EXPORT GLboolean __WGLEW_EXT_extensions_string;
+    WGLEW_EXPORT GLboolean __WGLEW_EXT_framebuffer_sRGB;
+    WGLEW_EXPORT GLboolean __WGLEW_EXT_make_current_read;
+    WGLEW_EXPORT GLboolean __WGLEW_EXT_multisample;
+    WGLEW_EXPORT GLboolean __WGLEW_EXT_pbuffer;
+    WGLEW_EXPORT GLboolean __WGLEW_EXT_pixel_format;
+    WGLEW_EXPORT GLboolean __WGLEW_EXT_pixel_format_packed_float;
+    WGLEW_EXPORT GLboolean __WGLEW_EXT_swap_control;
+    WGLEW_EXPORT GLboolean __WGLEW_I3D_digital_video_control;
+    WGLEW_EXPORT GLboolean __WGLEW_I3D_gamma;
+    WGLEW_EXPORT GLboolean __WGLEW_I3D_genlock;
+    WGLEW_EXPORT GLboolean __WGLEW_I3D_image_buffer;
+    WGLEW_EXPORT GLboolean __WGLEW_I3D_swap_frame_lock;
+    WGLEW_EXPORT GLboolean __WGLEW_I3D_swap_frame_usage;
+    WGLEW_EXPORT GLboolean __WGLEW_NV_float_buffer;
+    WGLEW_EXPORT GLboolean __WGLEW_NV_render_depth_texture;
+    WGLEW_EXPORT GLboolean __WGLEW_NV_render_texture_rectangle;
+    WGLEW_EXPORT GLboolean __WGLEW_NV_vertex_array_range;
+    WGLEW_EXPORT GLboolean __WGLEW_OML_sync_control;
+
+#ifdef GLEW_MX
+}; /* WGLEWContextStruct */
+#endif /* GLEW_MX */
+
+/* ------------------------------------------------------------------------- */
+
+#ifdef GLEW_MX
+
+typedef struct WGLEWContextStruct WGLEWContext;
+GLEWAPI GLenum wglewContextInit(WGLEWContext *ctx);
+GLEWAPI GLboolean wglewContextIsSupported(WGLEWContext *ctx, const char *name);
+
+#define wglewInit() wglewContextInit(wglewGetContext())
+#define wglewIsSupported(x) wglewContextIsSupported(wglewGetContext(), x)
+
+#define WGLEW_GET_VAR(x) wglewGetContext()->x
+#define WGLEW_GET_FUN(x) wglewGetContext()->x
+
+#else /* GLEW_MX */
+
+#define WGLEW_GET_VAR(x) x
+#define WGLEW_GET_FUN(x) x
+
+GLEWAPI GLboolean wglewIsSupported(const char *name);
+
+#endif /* GLEW_MX */
+
+GLEWAPI GLboolean wglewGetExtension(const char *name);
+
+#ifdef __cplusplus
+}
+#endif
+
+#undef GLEWAPI
+
+#endif /* __wglew_h__ */

Common/GL/wglext.h

@@ -0,0 +1,696 @@
+#ifndef __wglext_h_
+#define __wglext_h_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+**
+** http://oss.sgi.com/projects/FreeB
+**
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+**
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2004 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+**
+** Additional Notice Provisions: This software was created using the
+** OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
+** not been independently verified as being compliant with the OpenGL(R)
+** version 1.2.1 Specification.
+*/
+
+#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__)
+#define WIN32_LEAN_AND_MEAN 1
+#include <windows.h>
+#endif
+
+#ifndef APIENTRY
+#define APIENTRY
+#endif
+#ifndef APIENTRYP
+#define APIENTRYP APIENTRY *
+#endif
+#ifndef GLAPI
+#define GLAPI extern
+#endif
+
+
+/*************************************************************/
+
+/* Header file version number */
+/* wglext.h last updated 2005/01/07 */
+/* Current version at http://oss.sgi.com/projects/ogl-sample/registry/ */
+#define WGL_WGLEXT_VERSION 6
+
+#ifndef WGL_ARB_buffer_region
+#define WGL_FRONT_COLOR_BUFFER_BIT_ARB 0x00000001
+#define WGL_BACK_COLOR_BUFFER_BIT_ARB  0x00000002
+#define WGL_DEPTH_BUFFER_BIT_ARB       0x00000004
+#define WGL_STENCIL_BUFFER_BIT_ARB     0x00000008
+#endif
+
+#ifndef WGL_ARB_multisample
+#define WGL_SAMPLE_BUFFERS_ARB         0x2041
+#define WGL_SAMPLES_ARB                0x2042
+#endif
+
+#ifndef WGL_ARB_extensions_string
+#endif
+
+#ifndef WGL_ARB_pixel_format
+#define WGL_NUMBER_PIXEL_FORMATS_ARB   0x2000
+#define WGL_DRAW_TO_WINDOW_ARB         0x2001
+#define WGL_DRAW_TO_BITMAP_ARB         0x2002
+#define WGL_ACCELERATION_ARB           0x2003
+#define WGL_NEED_PALETTE_ARB           0x2004
+#define WGL_NEED_SYSTEM_PALETTE_ARB    0x2005
+#define WGL_SWAP_LAYER_BUFFERS_ARB     0x2006
+#define WGL_SWAP_METHOD_ARB            0x2007
+#define WGL_NUMBER_OVERLAYS_ARB        0x2008
+#define WGL_NUMBER_UNDERLAYS_ARB       0x2009
+#define WGL_TRANSPARENT_ARB            0x200A
+#define WGL_TRANSPARENT_RED_VALUE_ARB  0x2037
+#define WGL_TRANSPARENT_GREEN_VALUE_ARB 0x2038
+#define WGL_TRANSPARENT_BLUE_VALUE_ARB 0x2039
+#define WGL_TRANSPARENT_ALPHA_VALUE_ARB 0x203A
+#define WGL_TRANSPARENT_INDEX_VALUE_ARB 0x203B
+#define WGL_SHARE_DEPTH_ARB            0x200C
+#define WGL_SHARE_STENCIL_ARB          0x200D
+#define WGL_SHARE_ACCUM_ARB            0x200E
+#define WGL_SUPPORT_GDI_ARB            0x200F
+#define WGL_SUPPORT_OPENGL_ARB         0x2010
+#define WGL_DOUBLE_BUFFER_ARB          0x2011
+#define WGL_STEREO_ARB                 0x2012
+#define WGL_PIXEL_TYPE_ARB             0x2013
+#define WGL_COLOR_BITS_ARB             0x2014
+#define WGL_RED_BITS_ARB               0x2015
+#define WGL_RED_SHIFT_ARB              0x2016
+#define WGL_GREEN_BITS_ARB             0x2017
+#define WGL_GREEN_SHIFT_ARB            0x2018
+#define WGL_BLUE_BITS_ARB              0x2019
+#define WGL_BLUE_SHIFT_ARB             0x201A
+#define WGL_ALPHA_BITS_ARB             0x201B
+#define WGL_ALPHA_SHIFT_ARB            0x201C
+#define WGL_ACCUM_BITS_ARB             0x201D
+#define WGL_ACCUM_RED_BITS_ARB         0x201E
+#define WGL_ACCUM_GREEN_BITS_ARB       0x201F
+#define WGL_ACCUM_BLUE_BITS_ARB        0x2020
+#define WGL_ACCUM_ALPHA_BITS_ARB       0x2021
+#define WGL_DEPTH_BITS_ARB             0x2022
+#define WGL_STENCIL_BITS_ARB           0x2023
+#define WGL_AUX_BUFFERS_ARB            0x2024
+#define WGL_NO_ACCELERATION_ARB        0x2025
+#define WGL_GENERIC_ACCELERATION_ARB   0x2026
+#define WGL_FULL_ACCELERATION_ARB      0x2027
+#define WGL_SWAP_EXCHANGE_ARB          0x2028
+#define WGL_SWAP_COPY_ARB              0x2029
+#define WGL_SWAP_UNDEFINED_ARB         0x202A
+#define WGL_TYPE_RGBA_ARB              0x202B
+#define WGL_TYPE_COLORINDEX_ARB        0x202C
+#endif
+
+#ifndef WGL_ARB_make_current_read
+#define ERROR_INVALID_PIXEL_TYPE_ARB   0x2043
+#define ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB 0x2054
+#endif
+
+#ifndef WGL_ARB_pbuffer
+#define WGL_DRAW_TO_PBUFFER_ARB        0x202D
+#define WGL_MAX_PBUFFER_PIXELS_ARB     0x202E
+#define WGL_MAX_PBUFFER_WIDTH_ARB      0x202F
+#define WGL_MAX_PBUFFER_HEIGHT_ARB     0x2030
+#define WGL_PBUFFER_LARGEST_ARB        0x2033
+#define WGL_PBUFFER_WIDTH_ARB          0x2034
+#define WGL_PBUFFER_HEIGHT_ARB         0x2035
+#define WGL_PBUFFER_LOST_ARB           0x2036
+#endif
+
+#ifndef WGL_ARB_render_texture
+#define WGL_BIND_TO_TEXTURE_RGB_ARB    0x2070
+#define WGL_BIND_TO_TEXTURE_RGBA_ARB   0x2071
+#define WGL_TEXTURE_FORMAT_ARB         0x2072
+#define WGL_TEXTURE_TARGET_ARB         0x2073
+#define WGL_MIPMAP_TEXTURE_ARB         0x2074
+#define WGL_TEXTURE_RGB_ARB            0x2075
+#define WGL_TEXTURE_RGBA_ARB           0x2076
+#define WGL_NO_TEXTURE_ARB             0x2077
+#define WGL_TEXTURE_CUBE_MAP_ARB       0x2078
+#define WGL_TEXTURE_1D_ARB             0x2079
+#define WGL_TEXTURE_2D_ARB             0x207A
+#define WGL_MIPMAP_LEVEL_ARB           0x207B
+#define WGL_CUBE_MAP_FACE_ARB          0x207C
+#define WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB 0x207D
+#define WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB 0x207E
+#define WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB 0x207F
+#define WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB 0x2080
+#define WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB 0x2081
+#define WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB 0x2082
+#define WGL_FRONT_LEFT_ARB             0x2083
+#define WGL_FRONT_RIGHT_ARB            0x2084
+#define WGL_BACK_LEFT_ARB              0x2085
+#define WGL_BACK_RIGHT_ARB             0x2086
+#define WGL_AUX0_ARB                   0x2087
+#define WGL_AUX1_ARB                   0x2088
+#define WGL_AUX2_ARB                   0x2089
+#define WGL_AUX3_ARB                   0x208A
+#define WGL_AUX4_ARB                   0x208B
+#define WGL_AUX5_ARB                   0x208C
+#define WGL_AUX6_ARB                   0x208D
+#define WGL_AUX7_ARB                   0x208E
+#define WGL_AUX8_ARB                   0x208F
+#define WGL_AUX9_ARB                   0x2090
+#endif
+
+#ifndef WGL_ARB_pixel_format_float
+#define WGL_TYPE_RGBA_FLOAT_ARB        0x21A0
+#endif
+
+#ifndef WGL_EXT_make_current_read
+#define ERROR_INVALID_PIXEL_TYPE_EXT   0x2043
+#endif
+
+#ifndef WGL_EXT_pixel_format
+#define WGL_NUMBER_PIXEL_FORMATS_EXT   0x2000
+#define WGL_DRAW_TO_WINDOW_EXT         0x2001
+#define WGL_DRAW_TO_BITMAP_EXT         0x2002
+#define WGL_ACCELERATION_EXT           0x2003
+#define WGL_NEED_PALETTE_EXT           0x2004
+#define WGL_NEED_SYSTEM_PALETTE_EXT    0x2005
+#define WGL_SWAP_LAYER_BUFFERS_EXT     0x2006
+#define WGL_SWAP_METHOD_EXT            0x2007
+#define WGL_NUMBER_OVERLAYS_EXT        0x2008
+#define WGL_NUMBER_UNDERLAYS_EXT       0x2009
+#define WGL_TRANSPARENT_EXT            0x200A
+#define WGL_TRANSPARENT_VALUE_EXT      0x200B
+#define WGL_SHARE_DEPTH_EXT            0x200C
+#define WGL_SHARE_STENCIL_EXT          0x200D
+#define WGL_SHARE_ACCUM_EXT            0x200E
+#define WGL_SUPPORT_GDI_EXT            0x200F
+#define WGL_SUPPORT_OPENGL_EXT         0x2010
+#define WGL_DOUBLE_BUFFER_EXT          0x2011
+#define WGL_STEREO_EXT                 0x2012
+#define WGL_PIXEL_TYPE_EXT             0x2013
+#define WGL_COLOR_BITS_EXT             0x2014
+#define WGL_RED_BITS_EXT               0x2015
+#define WGL_RED_SHIFT_EXT              0x2016
+#define WGL_GREEN_BITS_EXT             0x2017
+#define WGL_GREEN_SHIFT_EXT            0x2018
+#define WGL_BLUE_BITS_EXT              0x2019
+#define WGL_BLUE_SHIFT_EXT             0x201A
+#define WGL_ALPHA_BITS_EXT             0x201B
+#define WGL_ALPHA_SHIFT_EXT            0x201C
+#define WGL_ACCUM_BITS_EXT             0x201D
+#define WGL_ACCUM_RED_BITS_EXT         0x201E
+#define WGL_ACCUM_GREEN_BITS_EXT       0x201F
+#define WGL_ACCUM_BLUE_BITS_EXT        0x2020
+#define WGL_ACCUM_ALPHA_BITS_EXT       0x2021
+#define WGL_DEPTH_BITS_EXT             0x2022
+#define WGL_STENCIL_BITS_EXT           0x2023
+#define WGL_AUX_BUFFERS_EXT            0x2024
+#define WGL_NO_ACCELERATION_EXT        0x2025
+#define WGL_GENERIC_ACCELERATION_EXT   0x2026
+#define WGL_FULL_ACCELERATION_EXT      0x2027
+#define WGL_SWAP_EXCHANGE_EXT          0x2028
+#define WGL_SWAP_COPY_EXT              0x2029
+#define WGL_SWAP_UNDEFINED_EXT         0x202A
+#define WGL_TYPE_RGBA_EXT              0x202B
+#define WGL_TYPE_COLORINDEX_EXT        0x202C
+#endif
+
+#ifndef WGL_EXT_pbuffer
+#define WGL_DRAW_TO_PBUFFER_EXT        0x202D
+#define WGL_MAX_PBUFFER_PIXELS_EXT     0x202E
+#define WGL_MAX_PBUFFER_WIDTH_EXT      0x202F
+#define WGL_MAX_PBUFFER_HEIGHT_EXT     0x2030
+#define WGL_OPTIMAL_PBUFFER_WIDTH_EXT  0x2031
+#define WGL_OPTIMAL_PBUFFER_HEIGHT_EXT 0x2032
+#define WGL_PBUFFER_LARGEST_EXT        0x2033
+#define WGL_PBUFFER_WIDTH_EXT          0x2034
+#define WGL_PBUFFER_HEIGHT_EXT         0x2035
+#endif
+
+#ifndef WGL_EXT_depth_float
+#define WGL_DEPTH_FLOAT_EXT            0x2040
+#endif
+
+#ifndef WGL_3DFX_multisample
+#define WGL_SAMPLE_BUFFERS_3DFX        0x2060
+#define WGL_SAMPLES_3DFX               0x2061
+#endif
+
+#ifndef WGL_EXT_multisample
+#define WGL_SAMPLE_BUFFERS_EXT         0x2041
+#define WGL_SAMPLES_EXT                0x2042
+#endif
+
+#ifndef WGL_I3D_digital_video_control
+#define WGL_DIGITAL_VIDEO_CURSOR_ALPHA_FRAMEBUFFER_I3D 0x2050
+#define WGL_DIGITAL_VIDEO_CURSOR_ALPHA_VALUE_I3D 0x2051
+#define WGL_DIGITAL_VIDEO_CURSOR_INCLUDED_I3D 0x2052
+#define WGL_DIGITAL_VIDEO_GAMMA_CORRECTED_I3D 0x2053
+#endif
+
+#ifndef WGL_I3D_gamma
+#define WGL_GAMMA_TABLE_SIZE_I3D       0x204E
+#define WGL_GAMMA_EXCLUDE_DESKTOP_I3D  0x204F
+#endif
+
+#ifndef WGL_I3D_genlock
+#define WGL_GENLOCK_SOURCE_MULTIVIEW_I3D 0x2044
+#define WGL_GENLOCK_SOURCE_EXTENAL_SYNC_I3D 0x2045
+#define WGL_GENLOCK_SOURCE_EXTENAL_FIELD_I3D 0x2046
+#define WGL_GENLOCK_SOURCE_EXTENAL_TTL_I3D 0x2047
+#define WGL_GENLOCK_SOURCE_DIGITAL_SYNC_I3D 0x2048
+#define WGL_GENLOCK_SOURCE_DIGITAL_FIELD_I3D 0x2049
+#define WGL_GENLOCK_SOURCE_EDGE_FALLING_I3D 0x204A
+#define WGL_GENLOCK_SOURCE_EDGE_RISING_I3D 0x204B
+#define WGL_GENLOCK_SOURCE_EDGE_BOTH_I3D 0x204C
+#endif
+
+#ifndef WGL_I3D_image_buffer
+#define WGL_IMAGE_BUFFER_MIN_ACCESS_I3D 0x00000001
+#define WGL_IMAGE_BUFFER_LOCK_I3D      0x00000002
+#endif
+
+#ifndef WGL_I3D_swap_frame_lock
+#endif
+
+#ifndef WGL_NV_render_depth_texture
+#define WGL_BIND_TO_TEXTURE_DEPTH_NV   0x20A3
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_DEPTH_NV 0x20A4
+#define WGL_DEPTH_TEXTURE_FORMAT_NV    0x20A5
+#define WGL_TEXTURE_DEPTH_COMPONENT_NV 0x20A6
+#define WGL_DEPTH_COMPONENT_NV         0x20A7
+#endif
+
+#ifndef WGL_NV_render_texture_rectangle
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV 0x20A0
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV 0x20A1
+#define WGL_TEXTURE_RECTANGLE_NV       0x20A2
+#endif
+
+#ifndef WGL_ATI_pixel_format_float
+#define WGL_TYPE_RGBA_FLOAT_ATI        0x21A0
+#define WGL_RGBA_FLOAT_MODE_ATI        0x8820
+#define WGL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI 0x8835
+#endif
+
+#ifndef WGL_NV_float_buffer
+#define WGL_FLOAT_COMPONENTS_NV        0x20B0
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_R_NV 0x20B1
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RG_NV 0x20B2
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGB_NV 0x20B3
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGBA_NV 0x20B4
+#define WGL_TEXTURE_FLOAT_R_NV         0x20B5
+#define WGL_TEXTURE_FLOAT_RG_NV        0x20B6
+#define WGL_TEXTURE_FLOAT_RGB_NV       0x20B7
+#define WGL_TEXTURE_FLOAT_RGBA_NV      0x20B8
+#endif
+
+#ifndef WGL_NV_swap_group
+#endif
+
+#ifndef WGL_NV_gpu_affinity
+#define WGL_ERROR_INCOMPATIBLE_AFFINITY_MASKS_NV 0x20D0
+#define WGL_ERROR_MISSING_AFFINITY_MASK_NV 0x20D1
+#endif
+
+
+/*************************************************************/
+
+#ifndef WGL_ARB_pbuffer
+DECLARE_HANDLE(HPBUFFERARB);
+#endif
+#ifndef WGL_EXT_pbuffer
+DECLARE_HANDLE(HPBUFFEREXT);
+#endif
+
+#ifndef WGL_NV_gpu_affinity
+DECLARE_HANDLE(HGPUNV);
+typedef struct _GPU_DEVICE
+{
+    DWORD  cb;
+    CHAR   DeviceName[32];
+    CHAR   DeviceString[128];
+    DWORD  Flags;
+    RECT   rcVirtualScreen;
+} GPU_DEVICE, *PGPU_DEVICE;
+#endif
+
+#ifndef WGL_ARB_buffer_region
+#define WGL_ARB_buffer_region 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern HANDLE WINAPI wglCreateBufferRegionARB(HDC, int, UINT);
+extern VOID WINAPI wglDeleteBufferRegionARB(HANDLE);
+extern BOOL WINAPI wglSaveBufferRegionARB(HANDLE, int, int, int, int);
+extern BOOL WINAPI wglRestoreBufferRegionARB(HANDLE, int, int, int, int, int, int);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef HANDLE(WINAPI *PFNWGLCREATEBUFFERREGIONARBPROC)(HDC hDC, int iLayerPlane, UINT uType);
+typedef VOID (WINAPI *PFNWGLDELETEBUFFERREGIONARBPROC)(HANDLE hRegion);
+typedef BOOL (WINAPI *PFNWGLSAVEBUFFERREGIONARBPROC)(HANDLE hRegion, int x, int y, int width, int height);
+typedef BOOL (WINAPI *PFNWGLRESTOREBUFFERREGIONARBPROC)(HANDLE hRegion, int x, int y, int width, int height, int xSrc, int ySrc);
+#endif
+
+#ifndef WGL_ARB_multisample
+#define WGL_ARB_multisample 1
+#endif
+
+#ifndef WGL_ARB_extensions_string
+#define WGL_ARB_extensions_string 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern const char *WINAPI wglGetExtensionsStringARB(HDC);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef const char *(WINAPI *PFNWGLGETEXTENSIONSSTRINGARBPROC)(HDC hdc);
+#endif
+
+#ifndef WGL_ARB_pixel_format
+#define WGL_ARB_pixel_format 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern BOOL WINAPI wglGetPixelFormatAttribivARB(HDC, int, int, UINT, const int *, int *);
+extern BOOL WINAPI wglGetPixelFormatAttribfvARB(HDC, int, int, UINT, const int *, FLOAT *);
+extern BOOL WINAPI wglChoosePixelFormatARB(HDC, const int *, const FLOAT *, UINT, int *, UINT *);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef BOOL (WINAPI *PFNWGLGETPIXELFORMATATTRIBIVARBPROC)(HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, int *piValues);
+typedef BOOL (WINAPI *PFNWGLGETPIXELFORMATATTRIBFVARBPROC)(HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, FLOAT *pfValues);
+typedef BOOL (WINAPI *PFNWGLCHOOSEPIXELFORMATARBPROC)(HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats);
+#endif
+
+#ifndef WGL_ARB_make_current_read
+#define WGL_ARB_make_current_read 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern BOOL WINAPI wglMakeContextCurrentARB(HDC, HDC, HGLRC);
+extern HDC WINAPI wglGetCurrentReadDCARB(void);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef BOOL (WINAPI *PFNWGLMAKECONTEXTCURRENTARBPROC)(HDC hDrawDC, HDC hReadDC, HGLRC hglrc);
+typedef HDC(WINAPI *PFNWGLGETCURRENTREADDCARBPROC)(void);
+#endif
+
+#ifndef WGL_ARB_pbuffer
+#define WGL_ARB_pbuffer 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern HPBUFFERARB WINAPI wglCreatePbufferARB(HDC, int, int, int, const int *);
+extern HDC WINAPI wglGetPbufferDCARB(HPBUFFERARB);
+extern int WINAPI wglReleasePbufferDCARB(HPBUFFERARB, HDC);
+extern BOOL WINAPI wglDestroyPbufferARB(HPBUFFERARB);
+extern BOOL WINAPI wglQueryPbufferARB(HPBUFFERARB, int, int *);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef HPBUFFERARB(WINAPI *PFNWGLCREATEPBUFFERARBPROC)(HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList);
+typedef HDC(WINAPI *PFNWGLGETPBUFFERDCARBPROC)(HPBUFFERARB hPbuffer);
+typedef int (WINAPI *PFNWGLRELEASEPBUFFERDCARBPROC)(HPBUFFERARB hPbuffer, HDC hDC);
+typedef BOOL (WINAPI *PFNWGLDESTROYPBUFFERARBPROC)(HPBUFFERARB hPbuffer);
+typedef BOOL (WINAPI *PFNWGLQUERYPBUFFERARBPROC)(HPBUFFERARB hPbuffer, int iAttribute, int *piValue);
+#endif
+
+#ifndef WGL_ARB_render_texture
+#define WGL_ARB_render_texture 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern BOOL WINAPI wglBindTexImageARB(HPBUFFERARB, int);
+extern BOOL WINAPI wglReleaseTexImageARB(HPBUFFERARB, int);
+extern BOOL WINAPI wglSetPbufferAttribARB(HPBUFFERARB, const int *);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef BOOL (WINAPI *PFNWGLBINDTEXIMAGEARBPROC)(HPBUFFERARB hPbuffer, int iBuffer);
+typedef BOOL (WINAPI *PFNWGLRELEASETEXIMAGEARBPROC)(HPBUFFERARB hPbuffer, int iBuffer);
+typedef BOOL (WINAPI *PFNWGLSETPBUFFERATTRIBARBPROC)(HPBUFFERARB hPbuffer, const int *piAttribList);
+#endif
+
+#ifndef WGL_ARB_pixel_format_float
+#define WGL_ARB_pixel_format_float 1
+#endif
+
+#ifndef WGL_EXT_display_color_table
+#define WGL_EXT_display_color_table 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern GLboolean WINAPI wglCreateDisplayColorTableEXT(GLushort);
+extern GLboolean WINAPI wglLoadDisplayColorTableEXT(const GLushort *, GLuint);
+extern GLboolean WINAPI wglBindDisplayColorTableEXT(GLushort);
+extern VOID WINAPI wglDestroyDisplayColorTableEXT(GLushort);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef GLboolean(WINAPI *PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC)(GLushort id);
+typedef GLboolean(WINAPI *PFNWGLLOADDISPLAYCOLORTABLEEXTPROC)(const GLushort *table, GLuint length);
+typedef GLboolean(WINAPI *PFNWGLBINDDISPLAYCOLORTABLEEXTPROC)(GLushort id);
+typedef VOID (WINAPI *PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC)(GLushort id);
+#endif
+
+#ifndef WGL_EXT_extensions_string
+#define WGL_EXT_extensions_string 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern const char *WINAPI wglGetExtensionsStringEXT(void);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef const char *(WINAPI *PFNWGLGETEXTENSIONSSTRINGEXTPROC)(void);
+#endif
+
+#ifndef WGL_EXT_make_current_read
+#define WGL_EXT_make_current_read 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern BOOL WINAPI wglMakeContextCurrentEXT(HDC, HDC, HGLRC);
+extern HDC WINAPI wglGetCurrentReadDCEXT(void);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef BOOL (WINAPI *PFNWGLMAKECONTEXTCURRENTEXTPROC)(HDC hDrawDC, HDC hReadDC, HGLRC hglrc);
+typedef HDC(WINAPI *PFNWGLGETCURRENTREADDCEXTPROC)(void);
+#endif
+
+#ifndef WGL_EXT_pbuffer
+#define WGL_EXT_pbuffer 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern HPBUFFEREXT WINAPI wglCreatePbufferEXT(HDC, int, int, int, const int *);
+extern HDC WINAPI wglGetPbufferDCEXT(HPBUFFEREXT);
+extern int WINAPI wglReleasePbufferDCEXT(HPBUFFEREXT, HDC);
+extern BOOL WINAPI wglDestroyPbufferEXT(HPBUFFEREXT);
+extern BOOL WINAPI wglQueryPbufferEXT(HPBUFFEREXT, int, int *);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef HPBUFFEREXT(WINAPI *PFNWGLCREATEPBUFFEREXTPROC)(HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList);
+typedef HDC(WINAPI *PFNWGLGETPBUFFERDCEXTPROC)(HPBUFFEREXT hPbuffer);
+typedef int (WINAPI *PFNWGLRELEASEPBUFFERDCEXTPROC)(HPBUFFEREXT hPbuffer, HDC hDC);
+typedef BOOL (WINAPI *PFNWGLDESTROYPBUFFEREXTPROC)(HPBUFFEREXT hPbuffer);
+typedef BOOL (WINAPI *PFNWGLQUERYPBUFFEREXTPROC)(HPBUFFEREXT hPbuffer, int iAttribute, int *piValue);
+#endif
+
+#ifndef WGL_EXT_pixel_format
+#define WGL_EXT_pixel_format 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern BOOL WINAPI wglGetPixelFormatAttribivEXT(HDC, int, int, UINT, int *, int *);
+extern BOOL WINAPI wglGetPixelFormatAttribfvEXT(HDC, int, int, UINT, int *, FLOAT *);
+extern BOOL WINAPI wglChoosePixelFormatEXT(HDC, const int *, const FLOAT *, UINT, int *, UINT *);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef BOOL (WINAPI *PFNWGLGETPIXELFORMATATTRIBIVEXTPROC)(HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int *piAttributes, int *piValues);
+typedef BOOL (WINAPI *PFNWGLGETPIXELFORMATATTRIBFVEXTPROC)(HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int *piAttributes, FLOAT *pfValues);
+typedef BOOL (WINAPI *PFNWGLCHOOSEPIXELFORMATEXTPROC)(HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats);
+#endif
+
+#ifndef WGL_EXT_swap_control
+#define WGL_EXT_swap_control 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern BOOL WINAPI wglSwapIntervalEXT(int);
+extern int WINAPI wglGetSwapIntervalEXT(void);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef BOOL (WINAPI *PFNWGLSWAPINTERVALEXTPROC)(int interval);
+typedef int (WINAPI *PFNWGLGETSWAPINTERVALEXTPROC)(void);
+#endif
+
+#ifndef WGL_EXT_depth_float
+#define WGL_EXT_depth_float 1
+#endif
+
+#ifndef WGL_NV_vertex_array_range
+#define WGL_NV_vertex_array_range 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern void *WINAPI wglAllocateMemoryNV(GLsizei, GLfloat, GLfloat, GLfloat);
+extern void WINAPI wglFreeMemoryNV(void *);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef void *(WINAPI *PFNWGLALLOCATEMEMORYNVPROC)(GLsizei size, GLfloat readfreq, GLfloat writefreq, GLfloat priority);
+typedef void (WINAPI *PFNWGLFREEMEMORYNVPROC)(void *pointer);
+#endif
+
+#ifndef WGL_3DFX_multisample
+#define WGL_3DFX_multisample 1
+#endif
+
+#ifndef WGL_EXT_multisample
+#define WGL_EXT_multisample 1
+#endif
+
+#ifndef WGL_OML_sync_control
+#define WGL_OML_sync_control 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern BOOL WINAPI wglGetSyncValuesOML(HDC, INT64 *, INT64 *, INT64 *);
+extern BOOL WINAPI wglGetMscRateOML(HDC, INT32 *, INT32 *);
+extern INT64 WINAPI wglSwapBuffersMscOML(HDC, INT64, INT64, INT64);
+extern INT64 WINAPI wglSwapLayerBuffersMscOML(HDC, int, INT64, INT64, INT64);
+extern BOOL WINAPI wglWaitForMscOML(HDC, INT64, INT64, INT64, INT64 *, INT64 *, INT64 *);
+extern BOOL WINAPI wglWaitForSbcOML(HDC, INT64, INT64 *, INT64 *, INT64 *);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef BOOL (WINAPI *PFNWGLGETSYNCVALUESOMLPROC)(HDC hdc, INT64 *ust, INT64 *msc, INT64 *sbc);
+typedef BOOL (WINAPI *PFNWGLGETMSCRATEOMLPROC)(HDC hdc, INT32 *numerator, INT32 *denominator);
+typedef INT64(WINAPI *PFNWGLSWAPBUFFERSMSCOMLPROC)(HDC hdc, INT64 target_msc, INT64 divisor, INT64 remainder);
+typedef INT64(WINAPI *PFNWGLSWAPLAYERBUFFERSMSCOMLPROC)(HDC hdc, int fuPlanes, INT64 target_msc, INT64 divisor, INT64 remainder);
+typedef BOOL (WINAPI *PFNWGLWAITFORMSCOMLPROC)(HDC hdc, INT64 target_msc, INT64 divisor, INT64 remainder, INT64 *ust, INT64 *msc, INT64 *sbc);
+typedef BOOL (WINAPI *PFNWGLWAITFORSBCOMLPROC)(HDC hdc, INT64 target_sbc, INT64 *ust, INT64 *msc, INT64 *sbc);
+#endif
+
+#ifndef WGL_I3D_digital_video_control
+#define WGL_I3D_digital_video_control 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern BOOL WINAPI wglGetDigitalVideoParametersI3D(HDC, int, int *);
+extern BOOL WINAPI wglSetDigitalVideoParametersI3D(HDC, int, const int *);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef BOOL (WINAPI *PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC)(HDC hDC, int iAttribute, int *piValue);
+typedef BOOL (WINAPI *PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC)(HDC hDC, int iAttribute, const int *piValue);
+#endif
+
+#ifndef WGL_I3D_gamma
+#define WGL_I3D_gamma 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern BOOL WINAPI wglGetGammaTableParametersI3D(HDC, int, int *);
+extern BOOL WINAPI wglSetGammaTableParametersI3D(HDC, int, const int *);
+extern BOOL WINAPI wglGetGammaTableI3D(HDC, int, USHORT *, USHORT *, USHORT *);
+extern BOOL WINAPI wglSetGammaTableI3D(HDC, int, const USHORT *, const USHORT *, const USHORT *);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef BOOL (WINAPI *PFNWGLGETGAMMATABLEPARAMETERSI3DPROC)(HDC hDC, int iAttribute, int *piValue);
+typedef BOOL (WINAPI *PFNWGLSETGAMMATABLEPARAMETERSI3DPROC)(HDC hDC, int iAttribute, const int *piValue);
+typedef BOOL (WINAPI *PFNWGLGETGAMMATABLEI3DPROC)(HDC hDC, int iEntries, USHORT *puRed, USHORT *puGreen, USHORT *puBlue);
+typedef BOOL (WINAPI *PFNWGLSETGAMMATABLEI3DPROC)(HDC hDC, int iEntries, const USHORT *puRed, const USHORT *puGreen, const USHORT *puBlue);
+#endif
+
+#ifndef WGL_I3D_genlock
+#define WGL_I3D_genlock 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern BOOL WINAPI wglEnableGenlockI3D(HDC);
+extern BOOL WINAPI wglDisableGenlockI3D(HDC);
+extern BOOL WINAPI wglIsEnabledGenlockI3D(HDC, BOOL *);
+extern BOOL WINAPI wglGenlockSourceI3D(HDC, UINT);
+extern BOOL WINAPI wglGetGenlockSourceI3D(HDC, UINT *);
+extern BOOL WINAPI wglGenlockSourceEdgeI3D(HDC, UINT);
+extern BOOL WINAPI wglGetGenlockSourceEdgeI3D(HDC, UINT *);
+extern BOOL WINAPI wglGenlockSampleRateI3D(HDC, UINT);
+extern BOOL WINAPI wglGetGenlockSampleRateI3D(HDC, UINT *);
+extern BOOL WINAPI wglGenlockSourceDelayI3D(HDC, UINT);
+extern BOOL WINAPI wglGetGenlockSourceDelayI3D(HDC, UINT *);
+extern BOOL WINAPI wglQueryGenlockMaxSourceDelayI3D(HDC, UINT *, UINT *);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef BOOL (WINAPI *PFNWGLENABLEGENLOCKI3DPROC)(HDC hDC);
+typedef BOOL (WINAPI *PFNWGLDISABLEGENLOCKI3DPROC)(HDC hDC);
+typedef BOOL (WINAPI *PFNWGLISENABLEDGENLOCKI3DPROC)(HDC hDC, BOOL *pFlag);
+typedef BOOL (WINAPI *PFNWGLGENLOCKSOURCEI3DPROC)(HDC hDC, UINT uSource);
+typedef BOOL (WINAPI *PFNWGLGETGENLOCKSOURCEI3DPROC)(HDC hDC, UINT *uSource);
+typedef BOOL (WINAPI *PFNWGLGENLOCKSOURCEEDGEI3DPROC)(HDC hDC, UINT uEdge);
+typedef BOOL (WINAPI *PFNWGLGETGENLOCKSOURCEEDGEI3DPROC)(HDC hDC, UINT *uEdge);
+typedef BOOL (WINAPI *PFNWGLGENLOCKSAMPLERATEI3DPROC)(HDC hDC, UINT uRate);
+typedef BOOL (WINAPI *PFNWGLGETGENLOCKSAMPLERATEI3DPROC)(HDC hDC, UINT *uRate);
+typedef BOOL (WINAPI *PFNWGLGENLOCKSOURCEDELAYI3DPROC)(HDC hDC, UINT uDelay);
+typedef BOOL (WINAPI *PFNWGLGETGENLOCKSOURCEDELAYI3DPROC)(HDC hDC, UINT *uDelay);
+typedef BOOL (WINAPI *PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC)(HDC hDC, UINT *uMaxLineDelay, UINT *uMaxPixelDelay);
+#endif
+
+#ifndef WGL_I3D_image_buffer
+#define WGL_I3D_image_buffer 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern LPVOID WINAPI wglCreateImageBufferI3D(HDC, DWORD, UINT);
+extern BOOL WINAPI wglDestroyImageBufferI3D(HDC, LPVOID);
+extern BOOL WINAPI wglAssociateImageBufferEventsI3D(HDC, const HANDLE *, const LPVOID *, const DWORD *, UINT);
+extern BOOL WINAPI wglReleaseImageBufferEventsI3D(HDC, const LPVOID *, UINT);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef LPVOID (WINAPI *PFNWGLCREATEIMAGEBUFFERI3DPROC)(HDC hDC, DWORD dwSize, UINT uFlags);
+typedef BOOL (WINAPI *PFNWGLDESTROYIMAGEBUFFERI3DPROC)(HDC hDC, LPVOID pAddress);
+typedef BOOL (WINAPI *PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC)(HDC hDC, const HANDLE *pEvent, const LPVOID *pAddress, const DWORD *pSize, UINT count);
+typedef BOOL (WINAPI *PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC)(HDC hDC, const LPVOID *pAddress, UINT count);
+#endif
+
+#ifndef WGL_I3D_swap_frame_lock
+#define WGL_I3D_swap_frame_lock 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern BOOL WINAPI wglEnableFrameLockI3D(void);
+extern BOOL WINAPI wglDisableFrameLockI3D(void);
+extern BOOL WINAPI wglIsEnabledFrameLockI3D(BOOL *);
+extern BOOL WINAPI wglQueryFrameLockMasterI3D(BOOL *);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef BOOL (WINAPI *PFNWGLENABLEFRAMELOCKI3DPROC)(void);
+typedef BOOL (WINAPI *PFNWGLDISABLEFRAMELOCKI3DPROC)(void);
+typedef BOOL (WINAPI *PFNWGLISENABLEDFRAMELOCKI3DPROC)(BOOL *pFlag);
+typedef BOOL (WINAPI *PFNWGLQUERYFRAMELOCKMASTERI3DPROC)(BOOL *pFlag);
+#endif
+
+#ifndef WGL_I3D_swap_frame_usage
+#define WGL_I3D_swap_frame_usage 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern BOOL WINAPI wglGetFrameUsageI3D(float *);
+extern BOOL WINAPI wglBeginFrameTrackingI3D(void);
+extern BOOL WINAPI wglEndFrameTrackingI3D(void);
+extern BOOL WINAPI wglQueryFrameTrackingI3D(DWORD *, DWORD *, float *);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef BOOL (WINAPI *PFNWGLGETFRAMEUSAGEI3DPROC)(float *pUsage);
+typedef BOOL (WINAPI *PFNWGLBEGINFRAMETRACKINGI3DPROC)(void);
+typedef BOOL (WINAPI *PFNWGLENDFRAMETRACKINGI3DPROC)(void);
+typedef BOOL (WINAPI *PFNWGLQUERYFRAMETRACKINGI3DPROC)(DWORD *pFrameCount, DWORD *pMissedFrames, float *pLastMissedUsage);
+#endif
+
+#ifndef WGL_ATI_pixel_format_float
+#define WGL_ATI_pixel_format_float 1
+#endif
+
+#ifndef WGL_NV_render_depth_texture
+#define WGL_NV_render_depth_texture 1
+#endif
+
+#ifndef WGL_NV_render_texture_rectangle
+#define WGL_NV_render_texture_rectangle 1
+#endif
+
+#ifndef WGL_NV_float_buffer
+#define WGL_NV_float_buffer 1
+#endif
+
+#ifndef WGL_NV_swap_group
+#define WGL_NV_swap_group 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern BOOL WINAPI wglJoinSwapGroupNV(HDC hDC, GLuint group);
+extern BOOL WINAPI wglBindSwapBarrierNV(GLuint group, GLuint barrier);
+extern BOOL WINAPI wglQuerySwapGroupNV(HDC hDC, GLuint *group, GLuint *barrier);
+extern BOOL WINAPI wglQueryMaxSwapGroupsNV(HDC hDC, GLuint *maxGroups, GLuint *maxBarriers);
+extern BOOL WINAPI wglQueryFrameCountNV(HDC hDC, GLuint *count);
+extern BOOL WINAPI wglResetFrameCountNV(HDC hDC);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef BOOL (WINAPI *PFNWGLJOINSWAPGROUPNVPROC)(HDC hDC, GLuint group);
+typedef BOOL (WINAPI *PFNWGLBINDSWAPBARRIERNVPROC)(GLuint group, GLuint barrier);
+typedef BOOL (WINAPI *PFNWGLQUERYSWAPGROUPNVPROC)(HDC hDC, GLuint *group, GLuint *barrier);
+typedef BOOL (WINAPI *PFNWGLQUERYMAXSWAPGROUPSNVPROC)(HDC hDC, GLuint *maxGroups, GLuint *maxBarriers);
+typedef BOOL (WINAPI *PFNWGLQUERYFRAMECOUNTNVPROC)(HDC hDC, GLuint *count);
+typedef BOOL (WINAPI *PFNWGLRESETFRAMECOUNTNVPROC)(HDC hDC);
+#endif
+
+#ifndef WGL_NV_gpu_affinity
+#define WGL_NV_gpu_affinity 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern BOOL WINAPI wglEnumGpusNV(UINT iIndex, HGPUNV *hGpu);
+extern BOOL WINAPI wglEnumGpuDevicesNV(HGPUNV hGpu, UINT iIndex, PGPU_DEVICE pGpuDevice);
+extern HDC WINAPI wglCreateAffinityDCNV(const HGPUNV *pGpuList);
+extern BOOL WINAPI wglEnumGpusFromAffinityDCNV(HDC hAffinityDC, UINT iIndex, HGPUNV *hGpu);
+extern BOOL WINAPI wglDeleteDCNV(HDC hAffinityDC);
+#else
+typedef BOOL (WINAPI *PFNWGLENUMGPUSNVPROC)(UINT iIndex, HGPUNV *hGpu);
+typedef BOOL (WINAPI *PFNWGLENUMGPUDEVICESNVPROC)(HGPUNV hGpu, UINT iIndex, PGPU_DEVICE pGpuDevice);
+typedef HDC(WINAPI *PFNWGLCREATEAFFINITYDCNVPROC)(const HGPUNV *pGpuList);
+typedef BOOL (WINAPI *PFNWGLENUMGPUSFROMAFFINITYDCNVPROC)(HDC hAffinityDC, UINT iIndex, HGPUNV *hGpu);
+typedef BOOL (WINAPI *PFNWGLDELETEDCNVPROC)(HDC hAffinityDC);
+#endif
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

Common/drvapi_error_string.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved.
+/* 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

Common/dynlink_d3d11.h

@@ -0,0 +1,160 @@
+/* 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.
+ */
+
+//--------------------------------------------------------------------------------------
+// File: dynlink_d3d11.h
+//
+// Shortcut macros and functions for using DX objects
+//
+// Copyright (c) Microsoft Corporation. All rights reserved
+//--------------------------------------------------------------------------------------
+
+#ifndef _DYNLINK_D3D11_H_
+#define _DYNLINK_D3D11_H_
+
+// Standard Windows includes
+#include <windows.h>
+#include <initguid.h>
+#include <assert.h>
+#include <wchar.h>
+#include <mmsystem.h>
+#include <commctrl.h> // for InitCommonControls() 
+#include <shellapi.h> // for ExtractIcon()
+#include <new.h>      // for placement new
+#include <shlobj.h>
+#include <math.h>
+#include <limits.h>
+#include <stdio.h>
+
+// CRT's memory leak detection
+#if defined(DEBUG) || defined(_DEBUG)
+#include <crtdbg.h>
+#endif
+
+// Direct3D10 includes
+#include <dxgi.h>
+#include <d3d11.h>
+// #include <..\Samples\C++\Effects11\Inc\d3dx11effect.h>
+
+// XInput includes
+#include <xinput.h>
+
+// strsafe.h deprecates old unsecure string functions.  If you
+// really do not want to it to (not recommended), then uncomment the next line
+//#define STRSAFE_NO_DEPRECATE
+
+#ifndef STRSAFE_NO_DEPRECATE
+#pragma deprecated("strncpy")
+#pragma deprecated("wcsncpy")
+#pragma deprecated("_tcsncpy")
+#pragma deprecated("wcsncat")
+#pragma deprecated("strncat")
+#pragma deprecated("_tcsncat")
+#endif
+
+#pragma warning( disable : 4996 ) // disable deprecated warning 
+#include <strsafe.h>
+#pragma warning( default : 4996 )
+
+typedef HRESULT(WINAPI *LPCREATEDXGIFACTORY)(REFIID, void **);
+typedef HRESULT(WINAPI *LPD3D11CREATEDEVICEANDSWAPCHAIN)(__in_opt IDXGIAdapter *pAdapter, D3D_DRIVER_TYPE DriverType, HMODULE Software, UINT Flags, __in_ecount_opt(FeatureLevels) CONST D3D_FEATURE_LEVEL *pFeatureLevels, UINT FeatureLevels, UINT SDKVersion, __in_opt CONST DXGI_SWAP_CHAIN_DESC *pSwapChainDesc, __out_opt IDXGISwapChain **ppSwapChain, __out_opt ID3D11Device **ppDevice, __out_opt D3D_FEATURE_LEVEL *pFeatureLevel, __out_opt ID3D11DeviceContext **ppImmediateContext);
+typedef HRESULT(WINAPI *LPD3D11CREATEDEVICE)(IDXGIAdapter *, D3D_DRIVER_TYPE, HMODULE, UINT32, D3D_FEATURE_LEVEL *, UINT, UINT32, ID3D11Device **, D3D_FEATURE_LEVEL *, ID3D11DeviceContext **);
+
+static HMODULE                              s_hModDXGI = NULL;
+static LPCREATEDXGIFACTORY                  sFnPtr_CreateDXGIFactory = NULL;
+static HMODULE                              s_hModD3D11 = NULL;
+static LPD3D11CREATEDEVICE                  sFnPtr_D3D11CreateDevice = NULL;
+static LPD3D11CREATEDEVICEANDSWAPCHAIN      sFnPtr_D3D11CreateDeviceAndSwapChain = NULL;
+
+// unload the D3D10 DLLs
+static bool dynlinkUnloadD3D11API(void)
+{
+    if (s_hModDXGI)
+    {
+        FreeLibrary(s_hModDXGI);
+        s_hModDXGI = NULL;
+    }
+
+    if (s_hModD3D11)
+    {
+        FreeLibrary(s_hModD3D11);
+        s_hModD3D11 = NULL;
+    }
+
+    return true;
+}
+
+// Dynamically load the D3D11 DLLs loaded and map the function pointers
+static bool dynlinkLoadD3D11API(void)
+{
+    // If both modules are non-NULL, this function has already been called.  Note
+    // that this doesn't guarantee that all ProcAddresses were found.
+    if (s_hModD3D11 != NULL && s_hModDXGI != NULL)
+    {
+        return true;
+    }
+
+#if 1
+    // This may fail if Direct3D 11 isn't installed
+    s_hModD3D11 = LoadLibrary("d3d11.dll");
+
+    if (s_hModD3D11 != NULL)
+    {
+        sFnPtr_D3D11CreateDevice = (LPD3D11CREATEDEVICE)GetProcAddress(s_hModD3D11, "D3D11CreateDevice");
+        sFnPtr_D3D11CreateDeviceAndSwapChain = (LPD3D11CREATEDEVICEANDSWAPCHAIN)GetProcAddress(s_hModD3D11, "D3D11CreateDeviceAndSwapChain");
+    }
+    else
+    {
+        printf("\nLoad d3d11.dll failed\n");
+        fflush(0);
+    }
+
+    if (!sFnPtr_CreateDXGIFactory)
+    {
+        s_hModDXGI = LoadLibrary("dxgi.dll");
+
+        if (s_hModDXGI)
+        {
+            sFnPtr_CreateDXGIFactory = (LPCREATEDXGIFACTORY)GetProcAddress(s_hModDXGI, "CreateDXGIFactory1");
+        }
+
+        return (s_hModDXGI != NULL) && (s_hModD3D11 != NULL);
+    }
+
+    return (s_hModD3D11 != NULL);
+#else
+    sFnPtr_D3D11CreateDevice = (LPD3D11CREATEDEVICE)D3D11CreateDeviceAndSwapChain;
+    sFnPtr_D3D11CreateDeviceAndSwapChain = (LPD3D11CREATEDEVICEANDSWAPCHAIN)D3D11CreateDeviceAndSwapChain;
+    //sFnPtr_D3DX11CreateEffectFromMemory  = ( LPD3DX11CREATEEFFECTFROMMEMORY )D3DX11CreateEffectFromMemory;
+    sFnPtr_D3DX11CompileFromMemory = (LPD3DX11COMPILEFROMMEMORY)D3DX11CompileFromMemory;
+    sFnPtr_CreateDXGIFactory = (LPCREATEDXGIFACTORY)CreateDXGIFactory;
+    return true;
+#endif
+    return true;
+}
+
+#endif

Common/exception.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved.
+/* 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

Common/helper_cuda.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved.
+/* 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
@@ -138,26 +138,29 @@ static const char *_cudaGetErrorEnum(cufftResult error) {
     case CUFFT_UNALIGNED_DATA:
       return "CUFFT_UNALIGNED_DATA";
 
-    case CUFFT_INCOMPLETE_PARAMETER_LIST:
-      return "CUFFT_INCOMPLETE_PARAMETER_LIST";
-
     case CUFFT_INVALID_DEVICE:
       return "CUFFT_INVALID_DEVICE";
 
-    case CUFFT_PARSE_ERROR:
-      return "CUFFT_PARSE_ERROR";
-
     case CUFFT_NO_WORKSPACE:
       return "CUFFT_NO_WORKSPACE";
 
     case CUFFT_NOT_IMPLEMENTED:
       return "CUFFT_NOT_IMPLEMENTED";
 
-    case CUFFT_LICENSE_ERROR:
-      return "CUFFT_LICENSE_ERROR";
-
     case CUFFT_NOT_SUPPORTED:
       return "CUFFT_NOT_SUPPORTED";
+
+    case CUFFT_MISSING_DEPENDENCY:
+      return "CUFFT_MISSING_DEPENDENCY";
+
+    case CUFFT_NVRTC_FAILURE:
+      return "CUFFT_NVRTC_FAILURE";
+
+    case CUFFT_NVJITLINK_FAILURE:
+      return "CUFFT_NVJITLINK_FAILURE";
+
+    case CUFFT_NVSHMEM_FAILURE:
+      return "CUFFT_NVSHMEM_FAILURE";
   }
 
   return "<unknown>";
@@ -579,24 +582,12 @@ static const char *_cudaGetErrorEnum(NppStatus error) {
 }
 #endif
 
-#ifdef __DRIVER_TYPES_H__
-#ifndef DEVICE_RESET
-#define DEVICE_RESET cudaDeviceReset();
-#endif
-#else
-#ifndef DEVICE_RESET
-#define DEVICE_RESET
-#endif
-#endif
-
 template <typename T>
 void check(T result, char const *const func, const char *const file,
            int const line) {
   if (result) {
     fprintf(stderr, "CUDA error at %s:%d code=%d(%s) \"%s\" \n", file, line,
             static_cast<unsigned int>(result), _cudaGetErrorEnum(result), func);
-    DEVICE_RESET
-    // Make sure we call CUDA Device Reset before exiting
     exit(EXIT_FAILURE);
   }
 }
@@ -619,7 +610,6 @@ inline void __getLastCudaError(const char *errorMessage, const char *file,
             " %s : (%d) %s.\n",
             file, line, errorMessage, static_cast<int>(err),
             cudaGetErrorString(err));
-    DEVICE_RESET
     exit(EXIT_FAILURE);
   }
 }
@@ -676,6 +666,18 @@ inline int _ConvertSMVer2Cores(int major, int minor) {
       {0x70,  64},
       {0x72,  64},
       {0x75,  64},
+      {0x80,  64},
+      {0x86, 128},
+      {0x87, 128},
+      {0x89, 128},
+      {0x90, 128},
+      {0xa0, 128},
+      {0xa1, 128},
+      {0xa3, 128},
+      {0xa7, 128},
+      {0xb0, 128},
+      {0xc0, 128},
+      {0xc1, 128},
       {-1, -1}};
 
   int index = 0;
@@ -696,6 +698,62 @@ inline int _ConvertSMVer2Cores(int major, int minor) {
       major, minor, nGpuArchCoresPerSM[index - 1].Cores);
   return nGpuArchCoresPerSM[index - 1].Cores;
 }
+
+inline const char* _ConvertSMVer2ArchName(int major, int minor) {
+  // Defines for GPU Architecture types (using the SM version to determine
+  // the GPU Arch name)
+  typedef struct {
+    int SM;  // 0xMm (hexidecimal notation), M = SM Major version,
+    // and m = SM minor version
+    const char* name;
+  } sSMtoArchName;
+
+  sSMtoArchName nGpuArchNameSM[] = {
+      {0x30, "Kepler"},
+      {0x32, "Kepler"},
+      {0x35, "Kepler"},
+      {0x37, "Kepler"},
+      {0x50, "Maxwell"},
+      {0x52, "Maxwell"},
+      {0x53, "Maxwell"},
+      {0x60, "Pascal"},
+      {0x61, "Pascal"},
+      {0x62, "Pascal"},
+      {0x70, "Volta"},
+      {0x72, "Xavier"},
+      {0x75, "Turing"},
+      {0x80, "Ampere"},
+      {0x86, "Ampere"},
+      {0x87, "Ampere"},
+      {0x89, "Ada"},
+      {0x90, "Hopper"},
+      {0xa0, "Blackwell"},
+      {0xa1, "Blackwell"},
+      {0xa3, "Blackwell"},
+      {0xa7, "Rubin"},
+      {0xb0, "Blackwell"},
+      {0xc0, "Blackwell"},
+      {0xc1, "Blackwell"},
+      {-1, "Graphics Device"}};
+
+  int index = 0;
+
+  while (nGpuArchNameSM[index].SM != -1) {
+    if (nGpuArchNameSM[index].SM == ((major << 4) + minor)) {
+      return nGpuArchNameSM[index].name;
+    }
+
+    index++;
+  }
+
+  // If we don't find the values, we default use the previous one
+  // to run properly
+  printf(
+      "MapSMtoArchName for SM %d.%d is undefined."
+      "  Default to use %s\n",
+      major, minor, nGpuArchNameSM[index - 1].name);
+  return nGpuArchNameSM[index - 1].name;
+}
   // end of GPU Architecture definitions
 
 #ifdef __CUDA_RUNTIME_H__
@@ -727,23 +785,24 @@ inline int gpuDeviceInit(int devID) {
     return -devID;
   }
 
-  cudaDeviceProp deviceProp;
-  checkCudaErrors(cudaGetDeviceProperties(&deviceProp, devID));
-
-  if (deviceProp.computeMode == cudaComputeModeProhibited) {
+  int computeMode = -1, major = 0, minor = 0;
+  checkCudaErrors(cudaDeviceGetAttribute(&computeMode, cudaDevAttrComputeMode, devID));
+  checkCudaErrors(cudaDeviceGetAttribute(&major, cudaDevAttrComputeCapabilityMajor, devID));
+  checkCudaErrors(cudaDeviceGetAttribute(&minor, cudaDevAttrComputeCapabilityMinor, devID));
+  if (computeMode == cudaComputeModeProhibited) {
     fprintf(stderr,
             "Error: device is running in <Compute Mode "
             "Prohibited>, no threads can use cudaSetDevice().\n");
     return -1;
   }
 
-  if (deviceProp.major < 1) {
+  if (major < 1) {
     fprintf(stderr, "gpuDeviceInit(): GPU device does not support CUDA.\n");
     exit(EXIT_FAILURE);
   }
 
   checkCudaErrors(cudaSetDevice(devID));
-  printf("gpuDeviceInit() CUDA Device [%d]: \"%s\n", devID, deviceProp.name);
+  printf("gpuDeviceInit() CUDA Device [%d]: \"%s\n", devID, _ConvertSMVer2ArchName(major, minor));
 
   return devID;
 }
@@ -756,7 +815,6 @@ inline int gpuGetMaxGflopsDeviceId() {
   int devices_prohibited = 0;
 
   uint64_t max_compute_perf = 0;
-  cudaDeviceProp deviceProp;
   checkCudaErrors(cudaGetDeviceCount(&device_count));
 
   if (device_count == 0) {
@@ -770,20 +828,36 @@ inline int gpuGetMaxGflopsDeviceId() {
   current_device = 0;
 
   while (current_device < device_count) {
-    cudaGetDeviceProperties(&deviceProp, current_device);
+    int computeMode = -1, major = 0, minor = 0;
+    checkCudaErrors(cudaDeviceGetAttribute(&computeMode, cudaDevAttrComputeMode, current_device));
+    checkCudaErrors(cudaDeviceGetAttribute(&major, cudaDevAttrComputeCapabilityMajor, current_device));
+    checkCudaErrors(cudaDeviceGetAttribute(&minor, cudaDevAttrComputeCapabilityMinor, current_device));
 
     // If this GPU is not running on Compute Mode prohibited,
     // then we can add it to the list
-    if (deviceProp.computeMode != cudaComputeModeProhibited) {
-      if (deviceProp.major == 9999 && deviceProp.minor == 9999) {
+    if (computeMode != cudaComputeModeProhibited) {
+      if (major == 9999 && minor == 9999) {
         sm_per_multiproc = 1;
       } else {
         sm_per_multiproc =
-            _ConvertSMVer2Cores(deviceProp.major, deviceProp.minor);
+            _ConvertSMVer2Cores(major,  minor);
       }
-
-      uint64_t compute_perf = (uint64_t)deviceProp.multiProcessorCount *
-                              sm_per_multiproc * deviceProp.clockRate;
+      int multiProcessorCount = 0, clockRate = 0;
+      checkCudaErrors(cudaDeviceGetAttribute(&multiProcessorCount, cudaDevAttrMultiProcessorCount, current_device));
+      cudaError_t result = cudaDeviceGetAttribute(&clockRate, cudaDevAttrClockRate, current_device);
+      if (result != cudaSuccess) {
+        // If cudaDevAttrClockRate attribute is not supported we
+        // set clockRate as 1, to consider GPU with most SMs and CUDA Cores.
+        if(result == cudaErrorInvalidValue) {
+          clockRate = 1;
+        }
+        else {
+          fprintf(stderr, "CUDA error at %s:%d code=%d(%s) \n", __FILE__, __LINE__,
+            static_cast<unsigned int>(result), _cudaGetErrorEnum(result));
+          exit(EXIT_FAILURE);
+        }
+      }
+      uint64_t compute_perf = (uint64_t)multiProcessorCount * sm_per_multiproc * clockRate;
 
       if (compute_perf > max_compute_perf) {
         max_compute_perf = compute_perf;
@@ -808,7 +882,6 @@ inline int gpuGetMaxGflopsDeviceId() {
 
 // Initialization code to find the best CUDA Device
 inline int findCudaDevice(int argc, const char **argv) {
-  cudaDeviceProp deviceProp;
   int devID = 0;
 
   // If the command-line has a device number specified, use it
@@ -830,9 +903,12 @@ inline int findCudaDevice(int argc, const char **argv) {
     // Otherwise pick the device with highest Gflops/s
     devID = gpuGetMaxGflopsDeviceId();
     checkCudaErrors(cudaSetDevice(devID));
-    checkCudaErrors(cudaGetDeviceProperties(&deviceProp, devID));
-    printf("GPU Device %d: \"%s\" with compute capability %d.%d\n\n", devID,
-           deviceProp.name, deviceProp.major, deviceProp.minor);
+    int major = 0, minor = 0;
+    checkCudaErrors(cudaDeviceGetAttribute(&major, cudaDevAttrComputeCapabilityMajor, devID));
+    checkCudaErrors(cudaDeviceGetAttribute(&minor, cudaDevAttrComputeCapabilityMinor, devID));
+    printf("GPU Device %d: \"%s\" with compute capability %d.%d\n\n",
+           devID, _ConvertSMVer2ArchName(major, minor), major, minor);
+
   }
 
   return devID;
@@ -843,7 +919,6 @@ inline int findIntegratedGPU() {
   int device_count = 0;
   int devices_prohibited = 0;
 
-  cudaDeviceProp deviceProp;
   checkCudaErrors(cudaGetDeviceCount(&device_count));
 
   if (device_count == 0) {
@@ -853,17 +928,19 @@ inline int findIntegratedGPU() {
 
   // Find the integrated GPU which is compute capable
   while (current_device < device_count) {
-    cudaGetDeviceProperties(&deviceProp, current_device);
-
+    int computeMode = -1, integrated = -1;
+    checkCudaErrors(cudaDeviceGetAttribute(&computeMode, cudaDevAttrComputeMode, current_device));
+    checkCudaErrors(cudaDeviceGetAttribute(&integrated, cudaDevAttrIntegrated, current_device));
     // If GPU is integrated and is not running on Compute Mode prohibited,
     // then cuda can map to GLES resource
-    if (deviceProp.integrated &&
-        (deviceProp.computeMode != cudaComputeModeProhibited)) {
+    if (integrated && (computeMode != cudaComputeModeProhibited)) {
       checkCudaErrors(cudaSetDevice(current_device));
-      checkCudaErrors(cudaGetDeviceProperties(&deviceProp, current_device));
+
+      int major = 0, minor = 0;
+      checkCudaErrors(cudaDeviceGetAttribute(&major, cudaDevAttrComputeCapabilityMajor, current_device));
+      checkCudaErrors(cudaDeviceGetAttribute(&minor, cudaDevAttrComputeCapabilityMinor, current_device));
       printf("GPU Device %d: \"%s\" with compute capability %d.%d\n\n",
-             current_device, deviceProp.name, deviceProp.major,
-             deviceProp.minor);
+             current_device, _ConvertSMVer2ArchName(major, minor), major, minor);
 
       return current_device;
     } else {
@@ -885,19 +962,18 @@ inline int findIntegratedGPU() {
 
 // General check for CUDA GPU SM Capabilities
 inline bool checkCudaCapabilities(int major_version, int minor_version) {
-  cudaDeviceProp deviceProp;
-  deviceProp.major = 0;
-  deviceProp.minor = 0;
   int dev;
+  int major = 0, minor = 0;
 
   checkCudaErrors(cudaGetDevice(&dev));
-  checkCudaErrors(cudaGetDeviceProperties(&deviceProp, dev));
+  checkCudaErrors(cudaDeviceGetAttribute(&major, cudaDevAttrComputeCapabilityMajor, dev));
+  checkCudaErrors(cudaDeviceGetAttribute(&minor, cudaDevAttrComputeCapabilityMinor, dev));
 
-  if ((deviceProp.major > major_version) ||
-      (deviceProp.major == major_version &&
-       deviceProp.minor >= minor_version)) {
+  if ((major > major_version) ||
+      (major == major_version &&
+       minor >= minor_version)) {
     printf("  Device %d: <%16s >, Compute SM %d.%d detected\n", dev,
-           deviceProp.name, deviceProp.major, deviceProp.minor);
+           _ConvertSMVer2ArchName(major, minor), major, minor);
     return true;
   } else {
     printf(

Common/helper_cuda_drvapi.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved.
+/* 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
@@ -33,8 +33,10 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <iostream>
+#include <cstring>
+#include <sstream>
 
-#include <drvapi_error_string.h>
 #include <helper_string.h>
 
 #ifndef MAX
@@ -66,48 +68,22 @@ inline int ftoi(float value) {
 // These are the inline versions for all of the SDK helper functions
 inline void __checkCudaErrors(CUresult err, const char *file, const int line) {
   if (CUDA_SUCCESS != err) {
+    const char *errorStr = NULL;
+    cuGetErrorString(err, &errorStr);
     fprintf(stderr,
             "checkCudaErrors() Driver API error = %04d \"%s\" from file <%s>, "
             "line %i.\n",
-            err, getCudaDrvErrorString(err), file, line);
+            err, errorStr, file, line);
     exit(EXIT_FAILURE);
   }
 }
 #endif
 
-#ifdef getLastCudaDrvErrorMsg
-#undef getLastCudaDrvErrorMsg
-#endif
-
-#define getLastCudaDrvErrorMsg(msg) \
-  __getLastCudaDrvErrorMsg(msg, __FILE__, __LINE__)
-
-inline void __getLastCudaDrvErrorMsg(const char *msg, const char *file,
-                                     const int line) {
-  CUresult err = cuCtxSynchronize();
-
-  if (CUDA_SUCCESS != err) {
-    fprintf(stderr, "getLastCudaDrvErrorMsg -> %s", msg);
-    fprintf(stderr,
-            "getLastCudaDrvErrorMsg -> cuCtxSynchronize API error = %04d "
-            "\"%s\" in file <%s>, line %i.\n",
-            err, getCudaDrvErrorString(err), file, line);
-    exit(EXIT_FAILURE);
-  }
-}
-
 // This function wraps the CUDA Driver API into a template function
 template <class T>
 inline void getCudaAttribute(T *attribute, CUdevice_attribute device_attribute,
                              int device) {
-  CUresult error_result =
-      cuDeviceGetAttribute(attribute, device_attribute, device);
-
-  if (error_result != CUDA_SUCCESS) {
-    printf("cuDeviceGetAttribute returned %d\n-> %s\n",
-           static_cast<int>(error_result), getCudaDrvErrorString(error_result));
-    exit(EXIT_SUCCESS);
-  }
+  checkCudaErrors(cuDeviceGetAttribute(attribute, device_attribute, device));
 }
 #endif
 
@@ -135,6 +111,18 @@ inline int _ConvertSMVer2CoresDRV(int major, int minor) {
       {0x70,  64},
       {0x72,  64},
       {0x75,  64},
+      {0x80,  64},
+      {0x86, 128},
+      {0x87, 128},
+      {0x89, 128},
+      {0x90, 128},
+      {0xa0, 128},
+      {0xa1, 128},
+      {0xa3, 128},
+      {0xa7, 128},
+      {0xb0, 128},
+      {0xc0, 128},
+      {0xc1, 128},
       {-1, -1}};
 
   int index = 0;
@@ -161,11 +149,9 @@ inline int _ConvertSMVer2CoresDRV(int major, int minor) {
 inline int gpuDeviceInitDRV(int ARGC, const char **ARGV) {
   int cuDevice = 0;
   int deviceCount = 0;
-  CUresult err = cuInit(0);
+  checkCudaErrors(cuInit(0));
 
-  if (CUDA_SUCCESS == err) {
   checkCudaErrors(cuDeviceGetCount(&deviceCount));
-  }
 
   if (deviceCount == 0) {
     fprintf(stderr, "cudaDeviceInit error: no devices supporting CUDA\n");
@@ -192,7 +178,7 @@ inline int gpuDeviceInitDRV(int ARGC, const char **ARGV) {
 
   checkCudaErrors(cuDeviceGet(&cuDevice, dev));
   char name[100];
-  cuDeviceGetName(name, 100, cuDevice);
+  checkCudaErrors(cuDeviceGetName(name, 100, cuDevice));
 
   int computeMode;
   getCudaAttribute<int>(&computeMode, CU_DEVICE_ATTRIBUTE_COMPUTE_MODE, dev);
@@ -218,7 +204,6 @@ inline int gpuGetMaxGflopsDeviceIdDRV() {
   int device_count = 0;
   int sm_per_multiproc = 0;
   unsigned long long max_compute_perf = 0;
-  int best_SM_arch = 0;
   int major = 0;
   int minor = 0;
   int multiProcessorCount;
@@ -234,19 +219,6 @@ inline int gpuGetMaxGflopsDeviceIdDRV() {
     exit(EXIT_FAILURE);
   }
 
-  // Find the best major SM Architecture GPU device
-  while (current_device < device_count) {
-    checkCudaErrors(cuDeviceGetAttribute(
-        &major, CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR, current_device));
-    checkCudaErrors(cuDeviceGetAttribute(
-        &minor, CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR, current_device));
-    if (major > 0 && major < 9999) {
-      best_SM_arch = MAX(best_SM_arch, major);
-    }
-
-    current_device++;
-  }
-
   // Find the best CUDA capable GPU device
   current_device = 0;
 
@@ -273,22 +245,13 @@ inline int gpuGetMaxGflopsDeviceIdDRV() {
       }
 
       unsigned long long compute_perf =
-          (unsigned long long)(multiProcessorCount * sm_per_multiproc *
+          ((unsigned long long)multiProcessorCount * sm_per_multiproc *
                                clockRate);
 
       if (compute_perf > max_compute_perf) {
-        // If we find GPU with SM major > 2, search only these
-        if (best_SM_arch > 2) {
-          // If our device==dest_SM_arch, choose this, or else pass
-          if (major == best_SM_arch) {
           max_compute_perf = compute_perf;
           max_perf_device = current_device;
       }
-        } else {
-          max_compute_perf = compute_perf;
-          max_perf_device = current_device;
-        }
-      }
     } else {
       devices_prohibited++;
     }
@@ -414,6 +377,37 @@ inline bool checkCudaCapabilitiesDRV(int major_version, int minor_version,
   }
 }
 #endif
+bool inline findFatbinPath(const char *module_file, std::string &module_path, char **argv, std::ostringstream &ostrm)
+{
+    char *actual_path = sdkFindFilePath(module_file, argv[0]);
+
+    if (actual_path)
+    {
+        module_path = actual_path;
+    }
+    else
+    {
+        printf("> findModulePath file not found: <%s> \n", module_file);
+        return false;
+    }
+
+    if (module_path.empty())
+    {
+        printf("> findModulePath could not find file: <%s> \n", module_file);
+        return false;
+    }
+    else
+    {
+        printf("> findModulePath found file at <%s>\n", module_path.c_str());
+        if (module_path.rfind("fatbin") != std::string::npos)
+        {
+            std::ifstream fileIn(module_path.c_str(), std::ios::binary);
+            ostrm << fileIn.rdbuf();
+            fileIn.close();
+        }
+        return true;
+    }
+}
 
   // end of CUDA Helper Functions
 

Common/helper_cusolver.h

@@ -0,0 +1,166 @@
+/* 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.
+ */
+
+#ifndef HELPER_CUSOLVER
+#define HELPER_CUSOLVER
+
+#include <ctype.h>
+#include <cuda_runtime.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "cusparse.h"
+
+#define SWITCH_CHAR '-'
+
+struct testOpts {
+  char *sparse_mat_filename;  // by switch -F<filename>
+  const char *testFunc;       // by switch -R<name>
+  const char *reorder;        // by switch -P<name>
+  int lda;                    // by switch -lda<int>
+};
+
+double vec_norminf(int n, const double *x) {
+  double norminf = 0;
+  for (int j = 0; j < n; j++) {
+    double x_abs = fabs(x[j]);
+    norminf = (norminf > x_abs) ? norminf : x_abs;
+  }
+  return norminf;
+}
+
+/*
+ * |A| = max { |A|*ones(m,1) }
+ */
+double mat_norminf(int m, int n, const double *A, int lda) {
+  double norminf = 0;
+  for (int i = 0; i < m; i++) {
+    double sum = 0.0;
+    for (int j = 0; j < n; j++) {
+      double A_abs = fabs(A[i + j * lda]);
+      sum += A_abs;
+    }
+    norminf = (norminf > sum) ? norminf : sum;
+  }
+  return norminf;
+}
+
+/*
+ * |A| = max { |A|*ones(m,1) }
+ */
+double csr_mat_norminf(int m, int n, int nnzA, const cusparseMatDescr_t descrA,
+                       const double *csrValA, const int *csrRowPtrA,
+                       const int *csrColIndA) {
+  const int baseA =
+      (CUSPARSE_INDEX_BASE_ONE == cusparseGetMatIndexBase(descrA)) ? 1 : 0;
+
+  double norminf = 0;
+  for (int i = 0; i < m; i++) {
+    double sum = 0.0;
+    const int start = csrRowPtrA[i] - baseA;
+    const int end = csrRowPtrA[i + 1] - baseA;
+    for (int colidx = start; colidx < end; colidx++) {
+      // const int j = csrColIndA[colidx] - baseA;
+      double A_abs = fabs(csrValA[colidx]);
+      sum += A_abs;
+    }
+    norminf = (norminf > sum) ? norminf : sum;
+  }
+  return norminf;
+}
+
+void display_matrix(int m, int n, int nnzA, const cusparseMatDescr_t descrA,
+                    const double *csrValA, const int *csrRowPtrA,
+                    const int *csrColIndA) {
+  const int baseA =
+      (CUSPARSE_INDEX_BASE_ONE == cusparseGetMatIndexBase(descrA)) ? 1 : 0;
+
+  printf("m = %d, n = %d, nnz = %d, matlab base-1\n", m, n, nnzA);
+
+  for (int row = 0; row < m; row++) {
+    const int start = csrRowPtrA[row] - baseA;
+    const int end = csrRowPtrA[row + 1] - baseA;
+    for (int colidx = start; colidx < end; colidx++) {
+      const int col = csrColIndA[colidx] - baseA;
+      double Areg = csrValA[colidx];
+      printf("A(%d, %d) = %20.16E\n", row + 1, col + 1, Areg);
+    }
+  }
+}
+
+#if defined(_WIN32)
+#if !defined(WIN32_LEAN_AND_MEAN)
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+double second(void) {
+  LARGE_INTEGER t;
+  static double oofreq;
+  static int checkedForHighResTimer;
+  static BOOL hasHighResTimer;
+
+  if (!checkedForHighResTimer) {
+    hasHighResTimer = QueryPerformanceFrequency(&t);
+    oofreq = 1.0 / (double)t.QuadPart;
+    checkedForHighResTimer = 1;
+  }
+  if (hasHighResTimer) {
+    QueryPerformanceCounter(&t);
+    return (double)t.QuadPart * oofreq;
+  } else {
+    return (double)GetTickCount() / 1000.0;
+  }
+}
+
+#elif defined(__linux__) || defined(__QNX__)
+#include <stddef.h>
+#include <sys/resource.h>
+#include <sys/time.h>
+double second(void) {
+  struct timeval tv;
+  gettimeofday(&tv, NULL);
+  return (double)tv.tv_sec + (double)tv.tv_usec / 1000000.0;
+}
+
+#elif defined(__APPLE__)
+#include <stddef.h>
+#include <sys/resource.h>
+#include <sys/sysctl.h>
+#include <sys/time.h>
+#include <sys/types.h>
+double second(void) {
+  struct timeval tv;
+  gettimeofday(&tv, NULL);
+  return (double)tv.tv_sec + (double)tv.tv_usec / 1000000.0;
+}
+#else
+#error unsupported platform
+#endif
+
+#endif

Common/helper_functions.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved.
+/* 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

Common/helper_gl.h

@@ -0,0 +1,267 @@
+/* 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.
+ */
+
+// These are helper functions for the SDK samples (OpenGL)
+#ifndef HELPER_GL_H
+#define HELPER_GL_H
+
+#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
+    #include <GL/glew.h>
+#endif
+
+#if defined(__APPLE__) || defined(MACOSX)
+    #include <OpenGL/gl.h>
+#else
+    #include <GL/gl.h>
+    #ifdef __linux__
+    #include <GL/glx.h>
+    #endif /* __linux__ */
+#endif
+
+#include <iostream>
+#include <cstdio>
+#include <string>
+#include <sstream>
+#include <algorithm>
+#include <iterator>
+#include <vector>
+#include <assert.h>
+
+
+/* Prototypes */
+namespace __HelperGL {
+    static int isGLVersionSupported(unsigned reqMajor, unsigned reqMinor);
+    static int areGLExtensionsSupported(const std::string &);
+#ifdef __linux__
+
+    #ifndef HELPERGL_EXTERN_GL_FUNC_IMPLEMENTATION
+    #define USE_GL_FUNC(name, proto) proto name = (proto) glXGetProcAddress ((const GLubyte *)#name)
+    #else
+    #define USE_GL_FUNC(name, proto) extern proto name
+    #endif
+
+    USE_GL_FUNC(glBindBuffer, PFNGLBINDBUFFERPROC);
+    USE_GL_FUNC(glDeleteBuffers, PFNGLDELETEBUFFERSPROC);
+    USE_GL_FUNC(glBufferData, PFNGLBUFFERDATAPROC);
+    USE_GL_FUNC(glBufferSubData, PFNGLBUFFERSUBDATAPROC);
+    USE_GL_FUNC(glGenBuffers, PFNGLGENBUFFERSPROC);
+    USE_GL_FUNC(glCreateProgram, PFNGLCREATEPROGRAMPROC);
+    USE_GL_FUNC(glBindProgramARB, PFNGLBINDPROGRAMARBPROC);
+    USE_GL_FUNC(glGenProgramsARB, PFNGLGENPROGRAMSARBPROC);
+    USE_GL_FUNC(glDeleteProgramsARB, PFNGLDELETEPROGRAMSARBPROC);
+    USE_GL_FUNC(glDeleteProgram, PFNGLDELETEPROGRAMPROC);
+    USE_GL_FUNC(glGetProgramInfoLog, PFNGLGETPROGRAMINFOLOGPROC);
+    USE_GL_FUNC(glGetProgramiv, PFNGLGETPROGRAMIVPROC);
+    USE_GL_FUNC(glProgramParameteriEXT, PFNGLPROGRAMPARAMETERIEXTPROC);
+    USE_GL_FUNC(glProgramStringARB, PFNGLPROGRAMSTRINGARBPROC);
+    USE_GL_FUNC(glUnmapBuffer, PFNGLUNMAPBUFFERPROC);
+    USE_GL_FUNC(glMapBuffer, PFNGLMAPBUFFERPROC);
+    USE_GL_FUNC(glGetBufferParameteriv, PFNGLGETBUFFERPARAMETERIVPROC);
+    USE_GL_FUNC(glLinkProgram, PFNGLLINKPROGRAMPROC);
+    USE_GL_FUNC(glUseProgram, PFNGLUSEPROGRAMPROC);
+    USE_GL_FUNC(glAttachShader, PFNGLATTACHSHADERPROC);
+    USE_GL_FUNC(glCreateShader, PFNGLCREATESHADERPROC);
+    USE_GL_FUNC(glShaderSource, PFNGLSHADERSOURCEPROC);
+    USE_GL_FUNC(glCompileShader, PFNGLCOMPILESHADERPROC);
+    USE_GL_FUNC(glDeleteShader, PFNGLDELETESHADERPROC);
+    USE_GL_FUNC(glGetShaderInfoLog, PFNGLGETSHADERINFOLOGPROC);
+    USE_GL_FUNC(glGetShaderiv, PFNGLGETSHADERIVPROC);
+    USE_GL_FUNC(glUniform1i, PFNGLUNIFORM1IPROC);
+    USE_GL_FUNC(glUniform1f, PFNGLUNIFORM1FPROC);
+    USE_GL_FUNC(glUniform2f, PFNGLUNIFORM2FPROC);
+    USE_GL_FUNC(glUniform3f, PFNGLUNIFORM3FPROC);
+    USE_GL_FUNC(glUniform4f, PFNGLUNIFORM4FPROC);
+    USE_GL_FUNC(glUniform1fv, PFNGLUNIFORM1FVPROC);
+    USE_GL_FUNC(glUniform2fv, PFNGLUNIFORM2FVPROC);
+    USE_GL_FUNC(glUniform3fv, PFNGLUNIFORM3FVPROC);
+    USE_GL_FUNC(glUniform4fv, PFNGLUNIFORM4FVPROC);
+    USE_GL_FUNC(glUniformMatrix4fv, PFNGLUNIFORMMATRIX4FVPROC);
+    USE_GL_FUNC(glSecondaryColor3fv, PFNGLSECONDARYCOLOR3FVPROC);
+    USE_GL_FUNC(glGetUniformLocation, PFNGLGETUNIFORMLOCATIONPROC);
+    USE_GL_FUNC(glGenFramebuffersEXT, PFNGLGENFRAMEBUFFERSEXTPROC);
+    USE_GL_FUNC(glBindFramebufferEXT, PFNGLBINDFRAMEBUFFEREXTPROC);
+    USE_GL_FUNC(glDeleteFramebuffersEXT, PFNGLDELETEFRAMEBUFFERSEXTPROC);
+    USE_GL_FUNC(glCheckFramebufferStatusEXT, PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC);
+    USE_GL_FUNC(glGetFramebufferAttachmentParameterivEXT, PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC);
+    USE_GL_FUNC(glFramebufferTexture1DEXT, PFNGLFRAMEBUFFERTEXTURE1DEXTPROC);
+    USE_GL_FUNC(glFramebufferTexture2DEXT, PFNGLFRAMEBUFFERTEXTURE2DEXTPROC);
+    USE_GL_FUNC(glFramebufferTexture3DEXT, PFNGLFRAMEBUFFERTEXTURE3DEXTPROC);
+    USE_GL_FUNC(glGenerateMipmapEXT, PFNGLGENERATEMIPMAPEXTPROC);
+    USE_GL_FUNC(glGenRenderbuffersEXT, PFNGLGENRENDERBUFFERSEXTPROC);
+    USE_GL_FUNC(glDeleteRenderbuffersEXT, PFNGLDELETERENDERBUFFERSEXTPROC);
+    USE_GL_FUNC(glBindRenderbufferEXT, PFNGLBINDRENDERBUFFEREXTPROC);
+    USE_GL_FUNC(glRenderbufferStorageEXT, PFNGLRENDERBUFFERSTORAGEEXTPROC);
+    USE_GL_FUNC(glFramebufferRenderbufferEXT, PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC);
+    USE_GL_FUNC(glClampColorARB, PFNGLCLAMPCOLORARBPROC);
+    USE_GL_FUNC(glBindFragDataLocationEXT, PFNGLBINDFRAGDATALOCATIONEXTPROC);
+
+#if !defined(GLX_EXTENSION_NAME) || !defined(GL_VERSION_1_3)
+    USE_GL_FUNC(glActiveTexture, PFNGLACTIVETEXTUREPROC);
+    USE_GL_FUNC(glClientActiveTexture, PFNGLACTIVETEXTUREPROC);
+#endif
+
+    #undef USE_GL_FUNC
+#endif /*__linux__ */
+}
+
+
+namespace __HelperGL {
+    namespace __Int {
+        static std::vector<std::string> split(const std::string &str)
+        {
+            std::istringstream ss(str);
+            std::istream_iterator<std::string> it(ss);
+            return std::vector<std::string> (it, std::istream_iterator<std::string>());
+        }
+
+        /* Sort the vector passed by reference */
+        template<typename T> static inline void sort(std::vector<T> &a)
+        {
+            std::sort(a.begin(), a.end());
+        }
+
+        /* Compare two vectors */
+        template<typename T> static int equals(std::vector<T> a, std::vector<T> b)
+        {
+            if (a.size() != b.size()) return 0;
+            sort(a);
+            sort(b);
+
+            return std::equal(a.begin(), a.end(), b.begin());
+        }
+
+        template<typename T> static std::vector<T> getIntersection(std::vector<T> a, std::vector<T> b)
+        {
+            sort(a);
+            sort(b);
+
+            std::vector<T> rc;
+            std::set_intersection(a.begin(), a.end(), b.begin(), b.end(),
+                             std::back_inserter<std::vector<std::string> >(rc));
+            return rc;
+        }
+
+        static std::vector<std::string> getGLExtensions()
+        {
+            std::string extensionsStr( (const char *)glGetString(GL_EXTENSIONS));
+            return split (extensionsStr);
+        }
+    }
+
+    static int areGLExtensionsSupported(const std::string &extensions)
+    {
+        std::vector<std::string> all = __Int::getGLExtensions();
+
+        std::vector<std::string> requested = __Int::split(extensions);
+        std::vector<std::string> matched = __Int::getIntersection(all, requested);
+
+        return __Int::equals(matched, requested);
+    }
+
+    static int isGLVersionSupported(unsigned reqMajor, unsigned reqMinor)
+    {
+#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
+        if (glewInit() != GLEW_OK)
+        {
+            std::cerr << "glewInit() failed!" << std::endl;
+            return 0;
+        }
+#endif
+        std::string version ((const char *) glGetString (GL_VERSION));
+        std::stringstream stream (version);
+        unsigned major, minor;
+        char dot;
+
+        stream >> major >> dot >> minor;
+
+        assert (dot == '.');
+        return major > reqMajor || (major == reqMajor && minor >= reqMinor);
+    }
+
+    static inline const char* glErrorToString(GLenum err)
+    {
+#define CASE_RETURN_MACRO(arg) case arg: return #arg
+        switch(err)
+        {
+            CASE_RETURN_MACRO(GL_NO_ERROR);
+            CASE_RETURN_MACRO(GL_INVALID_ENUM);
+            CASE_RETURN_MACRO(GL_INVALID_VALUE);
+            CASE_RETURN_MACRO(GL_INVALID_OPERATION);
+            CASE_RETURN_MACRO(GL_OUT_OF_MEMORY);
+            CASE_RETURN_MACRO(GL_STACK_UNDERFLOW);
+            CASE_RETURN_MACRO(GL_STACK_OVERFLOW);
+#ifdef GL_INVALID_FRAMEBUFFER_OPERATION
+            CASE_RETURN_MACRO(GL_INVALID_FRAMEBUFFER_OPERATION);
+#endif
+            default: break;
+        }
+#undef CASE_RETURN_MACRO
+        return "*UNKNOWN*";
+    }
+
+////////////////////////////////////////////////////////////////////////////
+//! Check for OpenGL error
+//! @return bool if no GL error has been encountered, otherwise 0
+//! @param file  __FILE__ macro
+//! @param line  __LINE__ macro
+//! @note The GL error is listed on stderr
+//! @note This function should be used via the CHECK_ERROR_GL() macro
+////////////////////////////////////////////////////////////////////////////
+    inline bool sdkCheckErrorGL(const char *file, const int line)
+    {
+        bool ret_val = true;
+
+        // check for error
+        GLenum gl_error = glGetError();
+
+        if (gl_error != GL_NO_ERROR)
+        {
+#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
+            char tmpStr[512];
+            // NOTE: "%s(%i) : " allows Visual Studio to directly jump to the file at the right line
+            // when the user double clicks on the error line in the Output pane. Like any compile error.
+            sprintf_s(tmpStr, 255, "\n%s(%i) : GL Error : %s\n\n", file, line, glErrorToString(gl_error));
+            fprintf(stderr, "%s", tmpStr);
+#endif
+            fprintf(stderr, "GL Error in file '%s' in line %d :\n", file, line);
+            fprintf(stderr, "%s\n", glErrorToString(gl_error));
+            ret_val = false;
+        }
+
+        return ret_val;
+    }
+
+#define SDK_CHECK_ERROR_GL()                                              \
+    if( false == sdkCheckErrorGL( __FILE__, __LINE__)) {                  \
+        exit(EXIT_FAILURE);                                               \
+    }                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           
+
+} /* of namespace __HelperGL*/
+
+using namespace __HelperGL;
+
+#endif /*HELPER_GL_H*/

Common/helper_image.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved.
+/* 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

Common/helper_multiprocess.cpp

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved.
+/* 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
@@ -29,16 +29,11 @@
 #include <cstdlib>
 #include <string>
 
-int sharedMemoryCreate(const char *name, size_t sz, sharedMemoryInfo *info)
-{
+int sharedMemoryCreate(const char *name, size_t sz, sharedMemoryInfo *info) {
 #if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
   info->size = sz;
-    info->shmHandle = CreateFileMapping(INVALID_HANDLE_VALUE,
-                                        NULL,
-                                        PAGE_READWRITE,
-                                        0,
-                                        (DWORD)sz,
-                                        name);
+  info->shmHandle = CreateFileMapping(INVALID_HANDLE_VALUE, NULL,
+                                      PAGE_READWRITE, 0, (DWORD)sz, name);
   if (info->shmHandle == 0) {
     return GetLastError();
   }
@@ -73,8 +68,7 @@ int sharedMemoryCreate(const char *name, size_t sz, sharedMemoryInfo *info)
 #endif
 }
 
-int sharedMemoryOpen(const char *name, size_t sz, sharedMemoryInfo *info)
-{
+int sharedMemoryOpen(const char *name, size_t sz, sharedMemoryInfo *info) {
 #if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
   info->size = sz;
 
@@ -106,8 +100,7 @@ int sharedMemoryOpen(const char *name, size_t sz, sharedMemoryInfo *info)
 #endif
 }
 
-void sharedMemoryClose(sharedMemoryInfo *info)
-{
+void sharedMemoryClose(sharedMemoryInfo *info) {
 #if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
   if (info->addr) {
     UnmapViewOfFile(info->addr);
@@ -125,8 +118,7 @@ void sharedMemoryClose(sharedMemoryInfo *info)
 #endif
 }
 
-int spawnProcess(Process *process, const char *app, char * const *args)
-{
+int spawnProcess(Process *process, const char *app, char *const *args) {
 #if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
   STARTUPINFO si = {0};
   BOOL status;
@@ -140,7 +132,8 @@ int spawnProcess(Process *process, const char *app, char * const *args)
     args++;
   }
 
-    status = CreateProcess(app, LPSTR(arg_string.c_str()), NULL, NULL, FALSE, 0, NULL, NULL, &si, process);
+  status = CreateProcess(app, LPSTR(arg_string.c_str()), NULL, NULL, FALSE, 0,
+                         NULL, NULL, &si, process);
 
   return status ? 0 : GetLastError();
 #else
@@ -149,16 +142,14 @@ int spawnProcess(Process *process, const char *app, char * const *args)
     if (0 > execvp(app, args)) {
       return errno;
     }
-    }
-    else if (*process < 0) {
+  } else if (*process < 0) {
     return errno;
   }
   return 0;
 #endif
 }
 
-int waitProcess(Process *process)
-{
+int waitProcess(Process *process) {
 #if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
   DWORD exitCode;
   WaitForSingleObject(process->hProcess, INFINITE);
@@ -176,3 +167,410 @@ int waitProcess(Process *process)
   return WEXITSTATUS(status);
 #endif
 }
+
+#if defined(__linux__) || defined(__QNX__)
+int ipcCreateSocket(ipcHandle *&handle, const char *name,
+                    const std::vector<Process> &processes) {
+  int server_fd;
+  struct sockaddr_un servaddr;
+
+  handle = new ipcHandle;
+  memset(handle, 0, sizeof(*handle));
+  handle->socket = -1;
+  handle->socketName = NULL;
+
+  // Creating socket file descriptor
+  if ((server_fd = socket(AF_UNIX, SOCK_DGRAM, 0)) == 0) {
+    perror("IPC failure: Socket creation failed");
+    return -1;
+  }
+
+  char path_name[sizeof(servaddr.sun_path)];
+
+  // Create unique name for the socket with path if SOCK_FOLDER is set.
+  int written = snprintf(path_name, sizeof(path_name), "%s/%u",
+                         getSocketFolder().c_str(), getpid());
+  if (written < 0 || (size_t)written >= sizeof(path_name)) {
+    perror("IPC failure: Cannot bind provided name to socket. Name too large");
+    close(server_fd);
+    delete handle;
+    handle = NULL;
+    return -1;
+  }
+
+  unlink(path_name);
+  memset(&servaddr, 0, sizeof(servaddr));
+  servaddr.sun_family = AF_UNIX;
+
+  strncpy(servaddr.sun_path, path_name, sizeof(servaddr.sun_path) - 1);
+
+  if (bind(server_fd, (struct sockaddr *)&servaddr, SUN_LEN(&servaddr)) < 0) {
+    perror("IPC failure: Binding socket failed");
+    return -1;
+  }
+
+  handle->socketName = new char[strlen(path_name) + 1];
+  strcpy(handle->socketName, path_name);
+  handle->socket = server_fd;
+  return 0;
+}
+
+int ipcOpenSocket(ipcHandle *&handle) {
+  int sock = 0;
+  struct sockaddr_un cliaddr;
+
+  handle = new ipcHandle;
+  memset(handle, 0, sizeof(*handle));
+
+  if ((sock = socket(AF_UNIX, SOCK_DGRAM, 0)) < 0) {
+    perror("IPC failure:Socket creation error");
+    return -1;
+  }
+  
+  memset(&cliaddr, 0, sizeof(cliaddr));
+  cliaddr.sun_family = AF_UNIX;
+  char temp[sizeof(cliaddr.sun_path)];
+
+  // Create unique name for the socket with path if SOCK_FOLDER is set.
+  int written = snprintf(temp, sizeof(temp), "%s/%u", getSocketFolder().c_str(),
+                         getpid());
+  if (written < 0 || (size_t)written >= sizeof(temp)) {
+    perror("IPC failure: Cannot bind provided name to socket. Name too large");
+    close(sock);
+    delete handle;
+    handle = NULL;
+    return -1;
+  }
+
+  strcpy(cliaddr.sun_path, temp);
+  if (bind(sock, (struct sockaddr *)&cliaddr, sizeof(cliaddr)) < 0) {
+    perror("IPC failure: Binding socket failed");
+    return -1;
+  }
+
+  handle->socket = sock;
+  handle->socketName = new char[strlen(temp) + 1];
+  strcpy(handle->socketName, temp);
+
+  return 0;
+}
+
+int ipcCloseSocket(ipcHandle *handle) {
+  if (!handle) {
+    return -1;
+  }
+
+  if (handle->socketName) {
+    unlink(handle->socketName);
+    delete[] handle->socketName;
+  }
+  close(handle->socket);
+  delete handle;
+  return 0;
+}
+
+int ipcRecvShareableHandle(ipcHandle *handle, ShareableHandle *shHandle) {
+  struct msghdr msg = {0};
+  struct iovec iov[1];
+  struct cmsghdr cm;
+
+  // Union to guarantee alignment requirements for control array
+  union {
+    struct cmsghdr cm;
+    // This will not work on QNX as QNX CMSG_SPACE calls __cmsg_alignbytes
+    // And __cmsg_alignbytes is a runtime function instead of compile-time macros
+    // char control[CMSG_SPACE(sizeof(int))]
+    char* control;
+  } control_un;
+
+  size_t sizeof_control = CMSG_SPACE(sizeof(int)) * sizeof(char);
+  control_un.control = (char*) malloc(sizeof_control);
+  struct cmsghdr *cmptr;
+  ssize_t n;
+  int receivedfd;
+  char dummy_buffer[1];
+  ssize_t sendResult;
+  msg.msg_control = control_un.control;
+  msg.msg_controllen = sizeof_control;
+
+  iov[0].iov_base = (void *)dummy_buffer;
+  iov[0].iov_len = sizeof(dummy_buffer);
+
+  msg.msg_iov = iov;
+  msg.msg_iovlen = 1;
+  if ((n = recvmsg(handle->socket, &msg, 0)) <= 0) {
+    perror("IPC failure: Receiving data over socket failed");
+    free(control_un.control);
+    return -1;
+  }
+
+  if (((cmptr = CMSG_FIRSTHDR(&msg)) != NULL) &&
+      (cmptr->cmsg_len == CMSG_LEN(sizeof(int)))) {
+    if ((cmptr->cmsg_level != SOL_SOCKET) || (cmptr->cmsg_type != SCM_RIGHTS)) {
+      free(control_un.control);
+      return -1;
+    }
+
+    memmove(&receivedfd, CMSG_DATA(cmptr), sizeof(receivedfd));
+    *(int *)shHandle = receivedfd;
+  } else {
+    free(control_un.control);
+    return -1;
+  }
+
+  free(control_un.control);
+  return 0;
+}
+
+int ipcRecvDataFromClient(ipcHandle *serverHandle, void *data, size_t size) {
+  ssize_t readResult;
+  struct sockaddr_un cliaddr;
+  socklen_t len = sizeof(cliaddr);
+
+  readResult = recvfrom(serverHandle->socket, data, size, 0,
+                        (struct sockaddr *)&cliaddr, &len);
+  if (readResult == -1) {
+    perror("IPC failure: Receiving data over socket failed");
+    return -1;
+  }
+  return 0;
+}
+
+int ipcSendDataToServer(ipcHandle *handle, const char *serverName,
+                        const void *data, size_t size) {
+  ssize_t sendResult;
+  struct sockaddr_un serveraddr;
+
+  memset(&serveraddr, 0, sizeof(serveraddr));
+  serveraddr.sun_family = AF_UNIX;
+  strncpy(serveraddr.sun_path, serverName, sizeof(serveraddr.sun_path) - 1);
+
+  sendResult = sendto(handle->socket, data, size, 0,
+                      (struct sockaddr *)&serveraddr, sizeof(serveraddr));
+  if (sendResult <= 0) {
+    perror("IPC failure: Sending data over socket failed");
+  }
+
+  return 0;
+}
+
+int ipcSendShareableHandle(ipcHandle *handle,
+                           const std::vector<ShareableHandle> &shareableHandles,
+                           Process process, int data) {
+  struct msghdr msg;
+  struct iovec iov[1];
+
+  union {
+    struct cmsghdr cm;
+    char* control;
+  } control_un;
+
+  size_t sizeof_control = CMSG_SPACE(sizeof(int)) * sizeof(char);
+  control_un.control = (char*) malloc(sizeof_control);
+
+  struct cmsghdr *cmptr;
+  ssize_t readResult;
+  struct sockaddr_un cliaddr;
+  socklen_t len = sizeof(cliaddr);
+
+  // Construct client address to send this SHareable handle to
+  memset(&cliaddr, 0, sizeof(cliaddr));
+  cliaddr.sun_family = AF_UNIX;
+  char temp[sizeof(cliaddr.sun_path)];
+  int written =
+      snprintf(temp, sizeof(temp), "%s/%u", getSocketFolder().c_str(), process);
+  if (written < 0 || (size_t)written >= sizeof(temp)) {
+    perror("IPC failure: Cannot address client socket. Name too large");
+    free(control_un.control);
+    return -1;
+  }
+  strcpy(cliaddr.sun_path, temp);
+  len = sizeof(cliaddr);
+
+  // Send corresponding shareable handle to the client
+  int sendfd = (int)shareableHandles[data];
+
+  msg.msg_control = control_un.control;
+  msg.msg_controllen = sizeof_control;
+
+  cmptr = CMSG_FIRSTHDR(&msg);
+  cmptr->cmsg_len = CMSG_LEN(sizeof(int));
+  cmptr->cmsg_level = SOL_SOCKET;
+  cmptr->cmsg_type = SCM_RIGHTS;
+
+  memmove(CMSG_DATA(cmptr), &sendfd, sizeof(sendfd));
+
+  msg.msg_name = (void *)&cliaddr;
+  msg.msg_namelen = sizeof(struct sockaddr_un);
+
+  iov[0].iov_base = (void *)"";
+  iov[0].iov_len = 1;
+  msg.msg_iov = iov;
+  msg.msg_iovlen = 1;
+
+  ssize_t sendResult = sendmsg(handle->socket, &msg, 0);
+  if (sendResult <= 0) {
+    perror("IPC failure: Sending data over socket failed");
+    free(control_un.control);
+    return -1;
+  }
+
+  free(control_un.control);
+  return 0;
+}
+
+int ipcSendShareableHandles(
+    ipcHandle *handle, const std::vector<ShareableHandle> &shareableHandles,
+    const std::vector<Process> &processes) {
+  // Send all shareable handles to every single process.
+  for (int i = 0; i < shareableHandles.size(); i++) {
+    for (int j = 0; j < processes.size(); j++) {
+      checkIpcErrors(
+          ipcSendShareableHandle(handle, shareableHandles, processes[j], i));
+    }
+  }
+  return 0;
+}
+
+int ipcRecvShareableHandles(ipcHandle *handle,
+                            std::vector<ShareableHandle> &shareableHandles) {
+  for (int i = 0; i < shareableHandles.size(); i++) {
+    checkIpcErrors(ipcRecvShareableHandle(handle, &shareableHandles[i]));
+  }
+  return 0;
+}
+
+int ipcCloseShareableHandle(ShareableHandle shHandle) {
+  return close(shHandle);
+}
+
+#elif defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
+// Generic name to build individual Mailslot names by appending process ids.
+LPTSTR SlotName = (LPTSTR)TEXT("\\\\.\\mailslot\\sample_mailslot_");
+
+int ipcCreateSocket(ipcHandle *&handle, const char *name,
+                    const std::vector<Process> &processes) {
+  handle = new ipcHandle;
+  handle->hMailslot.resize(processes.size());
+
+  // Open Mailslots of all clients and store respective handles.
+  for (int i = 0; i < handle->hMailslot.size(); ++i) {
+    std::basic_string<TCHAR> childSlotName(SlotName);
+    char tempBuf[20];
+    _itoa_s(processes[i].dwProcessId, tempBuf, 10);
+    childSlotName += TEXT(tempBuf);
+
+    HANDLE hFile =
+        CreateFile(TEXT(childSlotName.c_str()), GENERIC_WRITE, FILE_SHARE_READ,
+                   (LPSECURITY_ATTRIBUTES)NULL, OPEN_EXISTING,
+                   FILE_ATTRIBUTE_NORMAL, (HANDLE)NULL);
+    if (hFile == INVALID_HANDLE_VALUE) {
+      printf("IPC failure: Opening Mailslot by CreateFile failed with %d\n",
+             GetLastError());
+      return -1;
+    }
+    handle->hMailslot[i] = hFile;
+  }
+  return 0;
+}
+
+int ipcOpenSocket(ipcHandle *&handle) {
+  handle = new ipcHandle;
+  HANDLE hSlot;
+
+  std::basic_string<TCHAR> clientSlotName(SlotName);
+  char tempBuf[20];
+  _itoa_s(GetCurrentProcessId(), tempBuf, 10);
+  clientSlotName += TEXT(tempBuf);
+
+  hSlot = CreateMailslot((LPSTR)clientSlotName.c_str(), 0,
+                         MAILSLOT_WAIT_FOREVER, (LPSECURITY_ATTRIBUTES)NULL);
+  if (hSlot == INVALID_HANDLE_VALUE) {
+    printf("IPC failure: CreateMailslot failed for client with %d\n",
+           GetLastError());
+    return -1;
+  }
+
+  handle->hMailslot.push_back(hSlot);
+  return 0;
+}
+
+int ipcSendData(HANDLE mailslot, const void *data, size_t sz) {
+  BOOL result;
+  DWORD cbWritten;
+
+  result = WriteFile(mailslot, data, (DWORD)sz, &cbWritten, (LPOVERLAPPED)NULL);
+  if (!result) {
+    printf("IPC failure: WriteFile failed with %d.\n", GetLastError());
+    return -1;
+  }
+  return 0;
+}
+
+int ipcRecvData(ipcHandle *handle, void *data, size_t sz) {
+  DWORD cbRead = 0;
+
+  if (!ReadFile(handle->hMailslot[0], data, (DWORD)sz, &cbRead, NULL)) {
+    printf("IPC failure: ReadFile failed with %d.\n", GetLastError());
+    return -1;
+  }
+
+  if (sz != (size_t)cbRead) {
+    printf(
+        "IPC failure: ReadFile didn't receive the expected number of bytes\n");
+    return -1;
+  }
+
+  return 0;
+}
+
+int ipcSendShareableHandles(
+    ipcHandle *handle, const std::vector<ShareableHandle> &shareableHandles,
+    const std::vector<Process> &processes) {
+  // Send all shareable handles to every single process.
+  for (int i = 0; i < processes.size(); i++) {
+    HANDLE hProcess =
+        OpenProcess(PROCESS_DUP_HANDLE, FALSE, processes[i].dwProcessId);
+    if (hProcess == INVALID_HANDLE_VALUE) {
+      printf("IPC failure: OpenProcess failed (%d)\n", GetLastError());
+      return -1;
+    }
+
+    for (int j = 0; j < shareableHandles.size(); j++) {
+      HANDLE hDup = INVALID_HANDLE_VALUE;
+      // Duplicate the handle into the target process's space
+      if (!DuplicateHandle(GetCurrentProcess(), shareableHandles[j], hProcess,
+                           &hDup, 0, FALSE, DUPLICATE_SAME_ACCESS)) {
+        printf("IPC failure: DuplicateHandle failed (%d)\n", GetLastError());
+        return -1;
+      }
+      checkIpcErrors(ipcSendData(handle->hMailslot[i], &hDup, sizeof(hDup)));
+    }
+    CloseHandle(hProcess);
+  }
+  return 0;
+}
+
+int ipcRecvShareableHandles(ipcHandle *handle,
+                            std::vector<ShareableHandle> &shareableHandles) {
+  for (int i = 0; i < shareableHandles.size(); i++) {
+    checkIpcErrors(
+        ipcRecvData(handle, &shareableHandles[i], sizeof(shareableHandles[i])));
+  }
+  return 0;
+}
+
+int ipcCloseSocket(ipcHandle *handle) {
+  for (int i = 0; i < handle->hMailslot.size(); i++) {
+    CloseHandle(handle->hMailslot[i]);
+  }
+  delete handle;
+  return 0;
+}
+
+int ipcCloseShareableHandle(ShareableHandle shHandle) {
+  CloseHandle(shHandle);
+  return 0;
+}
+
+#endif

Common/helper_multiprocess.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved.
+/* 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
@@ -33,12 +33,46 @@
 #define WIN32_LEAN_AND_MEAN
 #endif
 #include <windows.h>
+#include <iostream>
+#include <stdio.h>
+#include <tchar.h>
+#include <strsafe.h>
+#include <sddl.h>
+#include <aclapi.h>
+#include <winternl.h>
 #else
+#include <stdio.h>
 #include <fcntl.h>
 #include <sys/mman.h>
 #include <unistd.h>
 #include <errno.h>
 #include <sys/wait.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <memory.h>
+#include <sys/un.h>
+#endif
+#include <vector>
+
+// The Unix domain sockets creating folder on QNX has been restricted to qnx6-mounted directories since QNX SDP 8.0.3.
+#if defined(__QNX__)
+    #include <string>
+    inline std::string getSocketFolder() {
+        return "/storage";
+    }
+// Simple filesystem compatibility for GCC 8.x
+#elif defined(__GNUC__) && __GNUC__ < 9
+    #include <cstdlib>
+    #include <string>
+    inline std::string getSocketFolder() {
+        const char* tmpdir = std::getenv("TMPDIR");
+        return tmpdir ? std::string(tmpdir) : "/tmp";
+    }
+#else
+    #include <filesystem>
+    inline std::string getSocketFolder() {
+        return std::filesystem::temp_directory_path().string();
+    }
 #endif
 
 typedef struct sharedMemoryInfo_st {
@@ -68,4 +102,40 @@ int spawnProcess(Process *process, const char *app, char * const *args);
 
 int waitProcess(Process *process);
 
+#define checkIpcErrors(ipcFuncResult) \
+    if (ipcFuncResult == -1) { fprintf(stderr, "Failure at %u %s\n", __LINE__, __FILE__); exit(EXIT_FAILURE); }
+
+#if defined(__linux__) || defined(__QNX__)
+struct ipcHandle_st {
+    int socket;
+    char *socketName;
+};
+typedef int ShareableHandle;
+#elif defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
+struct ipcHandle_st {
+    std::vector<HANDLE> hMailslot; // 1 Handle in case of child and `num children` Handles for parent.
+};
+typedef HANDLE ShareableHandle;
+#endif
+
+typedef struct ipcHandle_st ipcHandle;
+
+int
+ipcCreateSocket(ipcHandle *&handle, const char *name, const std::vector<Process>& processes);
+
+int
+ipcOpenSocket(ipcHandle *&handle);
+
+int
+ipcCloseSocket(ipcHandle *handle);
+
+int
+ipcRecvShareableHandles(ipcHandle *handle, std::vector<ShareableHandle>& shareableHandles);
+
+int
+ipcSendShareableHandles(ipcHandle *handle, const std::vector<ShareableHandle>& shareableHandles, const std::vector<Process>& processes);
+
+int
+ipcCloseShareableHandle(ShareableHandle shHandle);
+
 #endif // HELPER_MULTIPROCESS_H

Common/helper_nvJPEG.hxx

@@ -1,4 +1,4 @@
-/* Copyright (c) 2019, NVIDIA CORPORATION. All rights reserved.
+/* 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
@@ -25,12 +25,16 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-// This sample needs at least CUDA 10.0.
+// This sample needs at least CUDA 10.1.
 // It demonstrates usages of the nvJPEG library
 
 #ifndef NV_JPEG_EXAMPLE
 #define NV_JPEG_EXAMPLE
 
+#ifdef _WIN64
+#include <windows.h>
+#endif
+
 #include "cuda_runtime.h"
 #include "nvjpeg.h"
 #include "helper_cuda.h"
@@ -44,12 +48,14 @@
 #include <vector>
 
 #include <string.h>  // strcmpi
+#ifndef _WIN64
 #include <sys/time.h>  // timings
 
 #include <dirent.h>  // linux dir traverse
+#include <unistd.h>
+#endif
 #include <sys/stat.h>
 #include <sys/types.h>
-#include <unistd.h>
 
 // write bmp, input - RGB, device
 int writeBMP(const char *filename, const unsigned char *d_chanR, int pitchR,
@@ -291,9 +297,23 @@ int writeBMPi(const char *filename, const unsigned char *d_RGB, int pitch,
   return 0;
 }
 
+int inputDirExists(const char *pathname) {
+  struct stat info;
+  if (stat(pathname, &info) != 0) {
+    return 0;  // Directory does not exists
+  } else if (info.st_mode & S_IFDIR) {
+    // is a directory
+    return 1;
+  } else {
+    // is not a directory
+    return 0;
+  }
+}
+
 int readInput(const std::string &sInputPath,
               std::vector<std::string> &filelist) {
   int error_code = 1;
+#ifndef _WIN64
   struct stat s;
 
   if (stat(sInputPath.c_str(), &s) == 0) {
@@ -308,15 +328,18 @@ int readInput(const std::string &sInputPath,
       if (dir_handle) {
         error_code = 0;
         while ((dir = readdir(dir_handle)) != NULL) {
-          if (dir->d_type == DT_REG) {
           std::string sFileName = sInputPath + dir->d_name;
-            filelist.push_back(sFileName);
-          } else if (dir->d_type == DT_DIR) {
+          if (inputDirExists(sFileName.c_str()))
+          {
             std::string sname = dir->d_name;
             if (sname != "." && sname != "..") {
               readInput(sInputPath + sname + "/", filelist);
             }
           }
+          else
+          {
+            filelist.push_back(sFileName);
+          }
         }
         closedir(dir_handle);
       } else {
@@ -331,8 +354,75 @@ int readInput(const std::string &sInputPath,
     std::cout << "Cannot find input path " << sInputPath << std::endl;
     return error_code;
   }
-
+#else
+  std::string search_path = sInputPath + "/*.*";
+  WIN32_FIND_DATA fd;
+  HANDLE hFind = ::FindFirstFile(search_path.c_str(), &fd);
+  if (hFind != INVALID_HANDLE_VALUE) {
+    do {
+      // read all (real) files in current folder
+      // , delete '!' read other 2 default folder . and ..
+      if (!(fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
+        std::string temp(sInputPath + "\\" + fd.cFileName);
+        filelist.push_back(temp);
+      }
+    } while (::FindNextFile(hFind, &fd));
+    ::FindClose(hFind);
+  } else {
+    std::cout << "Cannot open input directory: " << sInputPath << std::endl;
+    return error_code;
+  }
+#endif
   return 0;
 }
 
+
+int getInputDir(std::string &input_dir, const char *executable_path) {
+  int found = 0;
+  if (executable_path != 0) {
+    std::string executable_name = std::string(executable_path);
+#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
+    // Windows path delimiter
+    size_t delimiter_pos = executable_name.find_last_of('\\');
+    executable_name.erase(0, delimiter_pos + 1);
+
+    if (executable_name.rfind(".exe") != std::string::npos) {
+      // we strip .exe, only if the .exe is found
+      executable_name.resize(executable_name.size() - 4);
+    }
+#else
+    // Linux & OSX path delimiter
+    size_t delimiter_pos = executable_name.find_last_of('/');
+    executable_name.erase(0, delimiter_pos + 1);
+#endif
+
+    // Search in default paths for input images.
+    std::string pathname = "";
+    const char *searchPath[] = {
+        "./images",
+        "../../../../cpp/4_CUDA_Libraries/<executable_name>/images",
+        "../../../cpp/4_CUDA_Libraries/<executable_name>/images",
+        "../../cpp/4_CUDA_Libraries/<executable_name>/images"};
+
+    for (unsigned int i = 0; i < sizeof(searchPath) / sizeof(char *); ++i) {
+      std::string pathname(searchPath[i]);
+      size_t executable_name_pos = pathname.find("<executable_name>");
+
+      // If there is executable_name variable in the searchPath
+      // replace it with the value
+      if (executable_name_pos != std::string::npos) {
+        pathname.replace(executable_name_pos, strlen("<executable_name>"),
+                         executable_name);
+      }
+
+      if (inputDirExists(pathname.c_str())) {
+        input_dir = pathname + "/";
+        found = 1;
+        break;
+      }
+    }
+  }
+  return found;
+}
+
 #endif

Common/helper_string.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved.
+/* 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
@@ -287,12 +287,80 @@ inline char *sdkFindFilePath(const char *filename,
   const char *searchPath[] = {
       "./",                                           // same dir
       "./data/",                                      // same dir
-      "../../../../Samples/<executable_name>/",       // up 4 in tree
-      "../../../Samples/<executable_name>/",          // up 3 in tree
-      "../../Samples/<executable_name>/",             // up 2 in tree
-      "../../../../Samples/<executable_name>/data/",  // up 4 in tree
-      "../../../Samples/<executable_name>/data/",     // up 3 in tree
-      "../../Samples/<executable_name>/data/",        // up 2 in tree
+
+      "../../../../cpp/<executable_name>/",       // up 4 in tree
+      "../../../cpp/<executable_name>/",          // up 3 in tree
+      "../../cpp/<executable_name>/",             // up 2 in tree
+
+      "../../../../cpp/<executable_name>/data/",  // up 4 in tree
+      "../../../cpp/<executable_name>/data/",     // up 3 in tree
+      "../../cpp/<executable_name>/data/",        // up 2 in tree
+
+      "../../../../cpp/0_Introduction/<executable_name>/",  // up 4 in tree
+      "../../../cpp/0_Introduction/<executable_name>/",     // up 3 in tree
+      "../../cpp/0_Introduction/<executable_name>/",        // up 2 in tree
+
+      "../../../../cpp/1_Utilities/<executable_name>/",  // up 4 in tree
+      "../../../cpp/1_Utilities/<executable_name>/",     // up 3 in tree
+      "../../cpp/1_Utilities/<executable_name>/",        // up 2 in tree
+
+      "../../../../cpp/2_Concepts_and_Techniques/<executable_name>/",  // up 4 in tree
+      "../../../cpp/2_Concepts_and_Techniques/<executable_name>/",     // up 3 in tree
+      "../../cpp/2_Concepts_and_Techniques/<executable_name>/",        // up 2 in tree
+
+      "../../../../cpp/3_CUDA_Features/<executable_name>/",  // up 4 in tree
+      "../../../cpp/3_CUDA_Features/<executable_name>/",     // up 3 in tree
+      "../../cpp/3_CUDA_Features/<executable_name>/",        // up 2 in tree
+
+      "../../../../cpp/4_CUDA_Libraries/<executable_name>/",  // up 4 in tree
+      "../../../cpp/4_CUDA_Libraries/<executable_name>/",     // up 3 in tree
+      "../../cpp/4_CUDA_Libraries/<executable_name>/",        // up 2 in tree
+
+      "../../../../cpp/5_Domain_Specific/<executable_name>/",  // up 4 in tree
+      "../../../cpp/5_Domain_Specific/<executable_name>/",     // up 3 in tree
+      "../../cpp/5_Domain_Specific/<executable_name>/",        // up 2 in tree
+
+      "../../../../cpp/6_Performance/<executable_name>/",  // up 4 in tree
+      "../../../cpp/6_Performance/<executable_name>/",     // up 3 in tree
+      "../../cpp/6_Performance/<executable_name>/",        // up 2 in tree
+
+      "../../../../cpp/0_Introduction/<executable_name>/data/",  // up 4 in tree
+      "../../../cpp/0_Introduction/<executable_name>/data/",     // up 3 in tree
+      "../../cpp/0_Introduction/<executable_name>/data/",        // up 2 in tree
+
+      "../../../../cpp/1_Utilities/<executable_name>/data/",  // up 4 in tree
+      "../../../cpp/1_Utilities/<executable_name>/data/",     // up 3 in tree
+      "../../cpp/1_Utilities/<executable_name>/data/",        // up 2 in tree
+
+      "../../../../cpp/2_Concepts_and_Techniques/<executable_name>/data/",  // up 4 in tree
+      "../../../cpp/2_Concepts_and_Techniques/<executable_name>/data/",     // up 3 in tree
+      "../../cpp/2_Concepts_and_Techniques/<executable_name>/data/",        // up 2 in tree
+
+      "../../../../cpp/3_CUDA_Features/<executable_name>/data/",  // up 4 in tree
+      "../../../cpp/3_CUDA_Features/<executable_name>/data/",     // up 3 in tree
+      "../../cpp/3_CUDA_Features/<executable_name>/data/",        // up 2 in tree
+
+      "../../../../cpp/4_CUDA_Libraries/<executable_name>/data/",  // up 4 in tree
+      "../../../cpp/4_CUDA_Libraries/<executable_name>/data/",     // up 3 in tree
+      "../../cpp/4_CUDA_Libraries/<executable_name>/data/",        // up 2 in tree
+
+      "../../../../cpp/5_Domain_Specific/<executable_name>/data/",  // up 4 in tree
+      "../../../cpp/5_Domain_Specific/<executable_name>/data/",     // up 3 in tree
+      "../../cpp/5_Domain_Specific/<executable_name>/data/",        // up 2 in tree
+
+      "../../../../cpp/6_Performance/<executable_name>/data/",  // up 4 in tree
+      "../../../cpp/6_Performance/<executable_name>/data/",     // up 3 in tree
+      "../../cpp/6_Performance/<executable_name>/data/",        // up 2 in tree
+
+      "../../../../Common/data/",                     // up 4 in tree
+      "../../../Common/data/",                        // up 3 in tree
+      "../../Common/data/",                           // up 2 in tree
+
+      "../../../../cpp/9_CUDA_Tile/<executable_name>/",        // up 4 in tree
+      "../../../cpp/9_CUDA_Tile/<executable_name>/",           // up 3 in tree
+      "../../cpp/9_CUDA_Tile/<executable_name>/",              // up 2 in tree
+      "../cpp/9_CUDA_Tile/<executable_name>/",                 // up 1 in tree
+      "./cpp/9_CUDA_Tile/<executable_name>/"                   // up 0 in tree
   };
 
   // Extract the executable name
@@ -359,6 +427,7 @@ inline char *sdkFindFilePath(const char *filename,
   }
 
   // File not found
+  printf("\nerror: sdkFindFilePath: file <%s> not found!\n", filename);
   return 0;
 }
 

Common/helper_timer.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved.
+/* 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

Common/multithreading.cpp

@@ -0,0 +1,78 @@
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <multithreading.h>
+
+#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
+// Create thread
+CUTThread cutStartThread(CUT_THREADROUTINE func, void *data) {
+  return CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)func, data, 0, NULL);
+}
+
+// Wait for thread to finish
+void cutEndThread(CUTThread thread) {
+  WaitForSingleObject(thread, INFINITE);
+  CloseHandle(thread);
+}
+
+// Destroy thread
+void cutDestroyThread(CUTThread thread) {
+  TerminateThread(thread, 0);
+  CloseHandle(thread);
+}
+
+// Wait for multiple threads
+void cutWaitForThreads(const CUTThread *threads, int num) {
+  WaitForMultipleObjects(num, threads, true, INFINITE);
+
+  for (int i = 0; i < num; i++) {
+    CloseHandle(threads[i]);
+  }
+}
+
+#else
+// Create thread
+CUTThread cutStartThread(CUT_THREADROUTINE func, void *data) {
+  pthread_t thread;
+  pthread_create(&thread, NULL, func, data);
+  return thread;
+}
+
+// Wait for thread to finish
+void cutEndThread(CUTThread thread) { pthread_join(thread, NULL); }
+
+// Destroy thread
+void cutDestroyThread(CUTThread thread) { pthread_cancel(thread); }
+
+// Wait for multiple threads
+void cutWaitForThreads(const CUTThread *threads, int num) {
+  for (int i = 0; i < num; i++) {
+    cutEndThread(threads[i]);
+  }
+}
+
+#endif

Common/multithreading.h

@@ -0,0 +1,76 @@
+/* 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.
+ */
+
+#ifndef MULTITHREADING_H
+#define MULTITHREADING_H
+
+
+//Simple portable thread library.
+
+//Windows threads.
+#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
+#include <windows.h>
+
+typedef HANDLE CUTThread;
+typedef unsigned(WINAPI *CUT_THREADROUTINE)(void *);
+
+#define CUT_THREADPROC unsigned WINAPI
+#define  CUT_THREADEND return 0
+
+#else
+//POSIX threads.
+#include <pthread.h>
+
+typedef pthread_t CUTThread;
+typedef void *(*CUT_THREADROUTINE)(void *);
+
+#define CUT_THREADPROC void
+#define  CUT_THREADEND
+#endif
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+//Create thread.
+CUTThread cutStartThread(CUT_THREADROUTINE, void *data);
+
+//Wait for thread to finish.
+void cutEndThread(CUTThread thread);
+
+//Destroy thread.
+void cutDestroyThread(CUTThread thread);
+
+//Wait for multiple threads.
+void cutWaitForThreads(const CUTThread *threads, int num);
+
+#ifdef __cplusplus
+} //extern "C"
+#endif
+
+#endif //MULTITHREADING_H

Common/nvMath.h

@@ -0,0 +1,111 @@
+/* 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.
+ */
+
+//
+// Template math library for common 3D functionality
+//
+// This code is in part deriver from glh, a cross platform glut helper library.
+// The copyright for glh follows this notice.
+//
+// Copyright (c) NVIDIA Corporation. All rights reserved.
+////////////////////////////////////////////////////////////////////////////////
+
+/*
+    Copyright (c) 2000 Cass Everitt
+    Copyright (c) 2000 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.
+
+     * The names of contributors to this software may not be used
+       to endorse or promote products derived from this software
+       without specific prior written permission.
+
+       THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+       ``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
+       REGENTS 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.
+
+
+    Cass Everitt - cass@r3.nu
+*/
+
+#ifndef NV_MATH_H
+#define NV_MATH_H
+
+#include <math.h>
+
+#include <nvVector.h>
+#include <nvMatrix.h>
+#include <nvQuaternion.h>
+
+#define NV_PI   float(3.1415926535897932384626433832795)
+
+namespace nv
+{
+
+    typedef vec2<float> vec2f;
+    typedef vec3<float> vec3f;
+    typedef vec3<int> vec3i;
+    typedef vec3<unsigned int> vec3ui;
+    typedef vec4<float> vec4f;
+    typedef matrix4<float> matrix4f;
+    typedef quaternion<float> quaternionf;
+
+
+    inline void applyRotation(const quaternionf &r)
+    {
+        float angle;
+        vec3f axis;
+        r.get_value(axis, angle);
+        glRotatef(angle/3.1415926f * 180.0f, axis[0], axis[1], axis[2]);
+    }
+
+
+
+};
+
+#endif

Common/nvMatrix.h

@@ -0,0 +1,540 @@
+/* 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.
+ */
+
+//
+// Template math library for common 3D functionality
+//
+// nvMatrix.h - template matrix code
+//
+// This code is in part deriver from glh, a cross platform glut helper library.
+// The copyright for glh follows this notice.
+//
+// Copyright (c) NVIDIA Corporation. All rights reserved.
+////////////////////////////////////////////////////////////////////////////////
+
+/*
+    Copyright (c) 2000 Cass Everitt
+    Copyright (c) 2000 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.
+
+     * The names of contributors to this software may not be used
+       to endorse or promote products derived from this software
+       without specific prior written permission.
+
+       THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+       ``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
+       REGENTS 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.
+
+
+    Cass Everitt - cass@r3.nu
+*/
+
+#ifndef NV_MATRIX_H
+#define NV_MATRIX_H
+
+namespace nv
+{
+
+    template <class T> class vec2;
+    template <class T> class vec3;
+    template <class T> class vec4;
+
+    ////////////////////////////////////////////////////////////////////////////////
+    //
+    //  Matrix
+    //
+    ////////////////////////////////////////////////////////////////////////////////
+    template<class T>
+    class matrix4
+    {
+
+        public:
+
+            matrix4()
+            {
+                make_identity();
+            }
+
+            matrix4(T t)
+            {
+                set_value(t);
+            }
+
+            matrix4(const T *m)
+            {
+                set_value(m);
+            }
+
+            matrix4(T a00, T a01, T a02, T a03,
+                    T a10, T a11, T a12, T a13,
+                    T a20, T a21, T a22, T a23,
+                    T a30, T a31, T a32, T a33) :
+                _11(a00), _12(a01), _13(a02), _14(a03),
+                _21(a10), _22(a11), _23(a12), _24(a13),
+                _31(a20), _32(a21), _33(a22), _34(a23),
+                _41(a30), _42(a31), _43(a32), _44(a33)
+            {}
+
+
+            void get_value(T *mp) const
+            {
+                int c = 0;
+
+                for (int j=0; j < 4; j++)
+                    for (int i=0; i < 4; i++)
+                    {
+                        mp[c++] = element(i,j);
+                    }
+            }
+
+            const T *get_value() const
+            {
+                return _array;
+            }
+
+            void set_value(T *mp)
+            {
+                int c = 0;
+
+                for (int j=0; j < 4; j++)
+                    for (int i=0; i < 4; i++)
+                    {
+                        element(i,j) = mp[c++];
+                    }
+            }
+
+            void set_value(T r)
+            {
+                for (int i=0; i < 4; i++)
+                    for (int j=0; j < 4; j++)
+                    {
+                        element(i,j) = r;
+                    }
+            }
+
+            void make_identity()
+            {
+                element(0,0) = 1.0;
+                element(0,1) = 0.0;
+                element(0,2) = 0.0;
+                element(0,3) = 0.0;
+
+                element(1,0) = 0.0;
+                element(1,1) = 1.0;
+                element(1,2) = 0.0;
+                element(1,3) = 0.0;
+
+                element(2,0) = 0.0;
+                element(2,1) = 0.0;
+                element(2,2) = 1.0;
+                element(2,3) = 0.0;
+
+                element(3,0) = 0.0;
+                element(3,1) = 0.0;
+                element(3,2) = 0.0;
+                element(3,3) = 1.0;
+            }
+
+            // set a uniform scale
+            void set_scale(T s)
+            {
+                element(0,0) = s;
+                element(1,1) = s;
+                element(2,2) = s;
+            }
+
+            void set_scale(const vec3<T> &s)
+            {
+                for (int i = 0; i < 3; i++)
+                {
+                    element(i,i) = s[i];
+                }
+            }
+
+
+            void set_translate(const vec3<T> &t)
+            {
+                for (int i = 0; i < 3; i++)
+                {
+                    element(i,3) = t[i];
+                }
+            }
+
+            void set_row(int r, const vec4<T> &t)
+            {
+                for (int i = 0; i < 4; i++)
+                {
+                    element(r,i) = t[i];
+                }
+            }
+
+            void set_column(int c, const vec4<T> &t)
+            {
+                for (int i = 0; i < 4; i++)
+                {
+                    element(i,c) = t[i];
+                }
+            }
+
+            vec4<T> get_row(int r) const
+            {
+                vec4<T> v;
+
+                for (int i = 0; i < 4; i++)
+                {
+                    v[i] = element(r,i);
+                }
+
+                return v;
+            }
+
+            vec4<T> get_column(int c) const
+            {
+                vec4<T> v;
+
+                for (int i = 0; i < 4; i++)
+                {
+                    v[i] = element(i,c);
+                }
+
+                return v;
+            }
+
+            friend matrix4 inverse(const matrix4 &m)
+            {
+                matrix4 minv;
+
+                T r1[8], r2[8], r3[8], r4[8];
+                T *s[4], *tmprow;
+
+                s[0] = &r1[0];
+                s[1] = &r2[0];
+                s[2] = &r3[0];
+                s[3] = &r4[0];
+
+                int i,j,p,jj;
+
+                for (i=0; i<4; i++)
+                {
+                    for (j=0; j<4; j++)
+                    {
+                        s[i][j] = m.element(i,j);
+
+                        if (i==j)
+                        {
+                            s[i][j+4] = 1.0;
+                        }
+                        else
+                        {
+                            s[i][j+4] = 0.0;
+                        }
+                    }
+                }
+
+                T scp[4];
+
+                for (i=0; i<4; i++)
+                {
+                    scp[i] = T(fabs(s[i][0]));
+
+                    for (j=1; j<4; j++)
+                        if (T(fabs(s[i][j])) > scp[i])
+                        {
+                            scp[i] = T(fabs(s[i][j]));
+                        }
+
+                    if (scp[i] == 0.0)
+                    {
+                        return minv;    // singular matrix!
+                    }
+                }
+
+                int pivot_to;
+                T scp_max;
+
+                for (i=0; i<4; i++)
+                {
+                    // select pivot row
+                    pivot_to = i;
+                    scp_max = T(fabs(s[i][i]/scp[i]));
+
+                    // find out which row should be on top
+                    for (p=i+1; p<4; p++)
+                        if (T(fabs(s[p][i]/scp[p])) > scp_max)
+                        {
+                            scp_max = T(fabs(s[p][i]/scp[p]));
+                            pivot_to = p;
+                        }
+
+                    // Pivot if necessary
+                    if (pivot_to != i)
+                    {
+                        tmprow = s[i];
+                        s[i] = s[pivot_to];
+                        s[pivot_to] = tmprow;
+                        T tmpscp;
+                        tmpscp = scp[i];
+                        scp[i] = scp[pivot_to];
+                        scp[pivot_to] = tmpscp;
+                    }
+
+                    T mji;
+
+                    // perform gaussian elimination
+                    for (j=i+1; j<4; j++)
+                    {
+                        mji = s[j][i]/s[i][i];
+                        s[j][i] = 0.0;
+
+                        for (jj=i+1; jj<8; jj++)
+                        {
+                            s[j][jj] -= mji*s[i][jj];
+                        }
+                    }
+                }
+
+                if (s[3][3] == 0.0)
+                {
+                    return minv;    // singular matrix!
+                }
+
+                //
+                // Now we have an upper triangular matrix.
+                //
+                //  x x x x | y y y y
+                //  0 x x x | y y y y
+                //  0 0 x x | y y y y
+                //  0 0 0 x | y y y y
+                //
+                //  we'll back substitute to get the inverse
+                //
+                //  1 0 0 0 | z z z z
+                //  0 1 0 0 | z z z z
+                //  0 0 1 0 | z z z z
+                //  0 0 0 1 | z z z z
+                //
+
+                T mij;
+
+                for (i=3; i>0; i--)
+                {
+                    for (j=i-1; j > -1; j--)
+                    {
+                        mij = s[j][i]/s[i][i];
+
+                        for (jj=j+1; jj<8; jj++)
+                        {
+                            s[j][jj] -= mij*s[i][jj];
+                        }
+                    }
+                }
+
+                for (i=0; i<4; i++)
+                    for (j=0; j<4; j++)
+                    {
+                        minv(i,j) = s[i][j+4] / s[i][i];
+                    }
+
+                return minv;
+            }
+
+
+            friend matrix4 transpose(const matrix4 &m)
+            {
+                matrix4 mtrans;
+
+                for (int i=0; i<4; i++)
+                    for (int j=0; j<4; j++)
+                    {
+                        mtrans(i,j) = m.element(j,i);
+                    }
+
+                return mtrans;
+            }
+
+            matrix4 &operator *= (const matrix4 &rhs)
+            {
+                matrix4 mt(*this);
+                set_value(T(0));
+
+                for (int i=0; i < 4; i++)
+                    for (int j=0; j < 4; j++)
+                        for (int c=0; c < 4; c++)
+                        {
+                            element(i,j) += mt(i,c) * rhs(c,j);
+                        }
+
+                return *this;
+            }
+
+            friend matrix4 operator * (const matrix4 &lhs, const matrix4 &rhs)
+            {
+                matrix4 r(T(0));
+
+                for (int i=0; i < 4; i++)
+                    for (int j=0; j < 4; j++)
+                        for (int c=0; c < 4; c++)
+                        {
+                            r.element(i,j) += lhs(i,c) * rhs(c,j);
+                        }
+
+                return r;
+            }
+
+            // dst = M * src
+            vec4<T> operator *(const vec4<T> &src) const
+            {
+                vec4<T> r;
+
+                for (int i = 0; i < 4; i++)
+                    r[i]  = (src[0] * element(i,0) + src[1] * element(i,1) +
+                             src[2] * element(i,2) + src[3] * element(i,3));
+
+                return r;
+            }
+
+            // dst = src * M
+            friend vec4<T> operator *(const vec4<T> &lhs, const matrix4 &rhs)
+            {
+                vec4<T> r;
+
+                for (int i = 0; i < 4; i++)
+                    r[i]  = (lhs[0] * rhs.element(0,i) + lhs[1] * rhs.element(1,i) +
+                             lhs[2] * rhs.element(2,i) + lhs[3] * rhs.element(3,i));
+
+                return r;
+            }
+
+            T &operator()(int row, int col)
+            {
+                return element(row,col);
+            }
+
+            const T &operator()(int row, int col) const
+            {
+                return element(row,col);
+            }
+
+            T &element(int row, int col)
+            {
+                return _array[row | (col<<2)];
+            }
+
+            const T &element(int row, int col) const
+            {
+                return _array[row | (col<<2)];
+            }
+
+            matrix4 &operator *= (const T &r)
+            {
+                for (int i = 0; i < 4; ++i)
+                {
+                    element(0,i) *= r;
+                    element(1,i) *= r;
+                    element(2,i) *= r;
+                    element(3,i) *= r;
+                }
+
+                return *this;
+            }
+
+            matrix4 &operator += (const matrix4 &mat)
+            {
+                for (int i = 0; i < 4; ++i)
+                {
+                    element(0,i) += mat.element(0,i);
+                    element(1,i) += mat.element(1,i);
+                    element(2,i) += mat.element(2,i);
+                    element(3,i) += mat.element(3,i);
+                }
+
+                return *this;
+            }
+
+
+            friend bool operator == (const matrix4 &lhs, const matrix4 &rhs)
+            {
+                bool r = true;
+
+                for (int i = 0; i < 16; i++)
+                {
+                    r &= lhs._array[i] == rhs._array[i];
+                }
+
+                return r;
+            }
+
+            friend bool operator != (const matrix4 &lhs, const matrix4 &rhs)
+            {
+                bool r = true;
+
+                for (int i = 0; i < 16; i++)
+                {
+                    r &= lhs._array[i] != rhs._array[i];
+                }
+
+                return r;
+            }
+
+            union
+            {
+                struct
+                {
+                    T _11, _12, _13, _14;   // standard names for components
+                    T _21, _22, _23, _24;   // standard names for components
+                    T _31, _32, _33, _34;   // standard names for components
+                    T _41, _42, _43, _44;   // standard names for components
+                };
+                T _array[16];     // array access
+            };
+    };
+
+};
+
+#endif

Common/nvQuaternion.h

@@ -0,0 +1,530 @@
+/* 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.
+ */
+
+//
+// Template math library for common 3D functionality
+//
+// nvQuaterion.h - quaternion template and utility functions
+//
+// This code is in part deriver from glh, a cross platform glut helper library.
+// The copyright for glh follows this notice.
+//
+// Copyright (c) NVIDIA Corporation. All rights reserved.
+////////////////////////////////////////////////////////////////////////////////
+
+/*
+    Copyright (c) 2000 Cass Everitt
+    Copyright (c) 2000 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.
+
+     * The names of contributors to this software may not be used
+       to endorse or promote products derived from this software
+       without specific prior written permission.
+
+       THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+       ``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
+       REGENTS 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.
+
+
+    Cass Everitt - cass@r3.nu
+*/
+#ifndef NV_QUATERNION_H
+#define NV_QUATERNION_H
+
+namespace nv
+{
+
+    template <class T> class vec2;
+    template <class T> class vec3;
+    template <class T> class vec4;
+
+    ////////////////////////////////////////////////////////////////////////////////
+    //
+    //  Quaternion
+    //
+    ////////////////////////////////////////////////////////////////////////////////
+
+    template< class T>
+    class quaternion
+    {
+        public:
+
+            quaternion() : x(0.0), y(0.0), z(0.0), w(0.0)
+            {
+            }
+
+            quaternion(const T v[4])
+            {
+                set_value(v);
+            }
+
+
+            quaternion(T q0, T q1, T q2, T q3)
+            {
+                set_value(q0, q1, q2, q3);
+            }
+
+
+            quaternion(const matrix4<T> &m)
+            {
+                set_value(m);
+            }
+
+
+            quaternion(const vec3<T> &axis, T radians)
+            {
+                set_value(axis, radians);
+            }
+
+
+            quaternion(const vec3<T> &rotateFrom, const vec3<T> &rotateTo)
+            {
+                set_value(rotateFrom, rotateTo);
+            }
+
+            quaternion(const vec3<T> &from_look, const vec3<T> &from_up,
+                       const vec3<T> &to_look, const vec3<T> &to_up)
+            {
+                set_value(from_look, from_up, to_look, to_up);
+            }
+
+            const T *get_value() const
+            {
+                return  &_array[0];
+            }
+
+            void get_value(T &q0, T &q1, T &q2, T &q3) const
+            {
+                q0 = _array[0];
+                q1 = _array[1];
+                q2 = _array[2];
+                q3 = _array[3];
+            }
+
+            quaternion &set_value(T q0, T q1, T q2, T q3)
+            {
+                _array[0] = q0;
+                _array[1] = q1;
+                _array[2] = q2;
+                _array[3] = q3;
+                return *this;
+            }
+
+            void get_value(vec3<T> &axis, T &radians) const
+            {
+                radians = T(acos(_array[3]) * T(2.0));
+
+                if (radians == T(0.0))
+                {
+                    axis = vec3<T>(0.0, 0.0, 1.0);
+                }
+                else
+                {
+                    axis[0] = _array[0];
+                    axis[1] = _array[1];
+                    axis[2] = _array[2];
+                    axis = normalize(axis);
+                }
+            }
+
+            void get_value(matrix4<T> &m) const
+            {
+                T s, xs, ys, zs, wx, wy, wz, xx, xy, xz, yy, yz, zz;
+
+                T norm = _array[0] * _array[0] + _array[1] * _array[1] + _array[2] * _array[2] + _array[3] * _array[3];
+
+                s = (norm == T(0.0)) ? T(0.0) : (T(2.0) / norm);
+
+                xs = _array[0] * s;
+                ys = _array[1] * s;
+                zs = _array[2] * s;
+
+                wx = _array[3] * xs;
+                wy = _array[3] * ys;
+                wz = _array[3] * zs;
+
+                xx = _array[0] * xs;
+                xy = _array[0] * ys;
+                xz = _array[0] * zs;
+
+                yy = _array[1] * ys;
+                yz = _array[1] * zs;
+                zz = _array[2] * zs;
+
+                m(0,0) = T(T(1.0) - (yy + zz));
+                m(1,0) = T(xy + wz);
+                m(2,0) = T(xz - wy);
+
+                m(0,1) = T(xy - wz);
+                m(1,1) = T(T(1.0) - (xx + zz));
+                m(2,1) = T(yz + wx);
+
+                m(0,2) = T(xz + wy);
+                m(1,2) = T(yz - wx);
+                m(2,2) = T(T(1.0) - (xx + yy));
+
+                m(3,0) = m(3,1) = m(3,2) = m(0,3) = m(1,3) = m(2,3) = T(0.0);
+                m(3,3) = T(1.0);
+            }
+
+            quaternion &set_value(const T *qp)
+            {
+                for (int i = 0; i < 4; i++)
+                {
+                    _array[i] = qp[i];
+                }
+
+                return *this;
+            }
+
+            quaternion &set_value(const matrix4<T> &m)
+            {
+                T tr, s;
+                int i, j, k;
+                const int nxt[3] = { 1, 2, 0 };
+
+                tr = m(0,0) + m(1,1) + m(2,2);
+
+                if (tr > T(0))
+                {
+                    s = T(sqrt(tr + m(3,3)));
+                    _array[3] = T(s * 0.5);
+                    s = T(0.5) / s;
+
+                    _array[0] = T((m(1,2) - m(2,1)) * s);
+                    _array[1] = T((m(2,0) - m(0,2)) * s);
+                    _array[2] = T((m(0,1) - m(1,0)) * s);
+                }
+                else
+                {
+                    i = 0;
+
+                    if (m(1,1) > m(0,0))
+                    {
+                        i = 1;
+                    }
+
+                    if (m(2,2) > m(i,i))
+                    {
+                        i = 2;
+                    }
+
+                    j = nxt[i];
+                    k = nxt[j];
+
+                    s = T(sqrt((m(i,j) - (m(j,j) + m(k,k))) + T(1.0)));
+
+                    _array[i] = T(s * 0.5);
+                    s = T(0.5 / s);
+
+                    _array[3] = T((m(j,k) - m(k,j)) * s);
+                    _array[j] = T((m(i,j) + m(j,i)) * s);
+                    _array[k] = T((m(i,k) + m(k,i)) * s);
+                }
+
+                return *this;
+            }
+
+            quaternion &set_value(const vec3<T> &axis, T theta)
+            {
+                T sqnorm = square_norm(axis);
+
+                if (sqnorm == T(0.0))
+                {
+                    // axis too small.
+                    x = y = z = T(0.0);
+                    w = T(1.0);
+                }
+                else
+                {
+                    theta *= T(0.5);
+                    T sin_theta = T(sin(theta));
+
+                    if (sqnorm != T(1))
+                    {
+                        sin_theta /= T(sqrt(sqnorm));
+                    }
+
+                    x = sin_theta * axis[0];
+                    y = sin_theta * axis[1];
+                    z = sin_theta * axis[2];
+                    w = T(cos(theta));
+                }
+
+                return *this;
+            }
+
+            quaternion &set_value(const vec3<T> &rotateFrom, const vec3<T> &rotateTo)
+            {
+                vec3<T> p1, p2;
+                T alpha;
+
+                p1 = normalize(rotateFrom);
+                p2 = normalize(rotateTo);
+
+                alpha = dot(p1, p2);
+
+                if (alpha == T(1.0))
+                {
+                    *this = quaternion();
+                    return *this;
+                }
+
+                // ensures that the anti-parallel case leads to a positive dot
+                if (alpha == T(-1.0))
+                {
+                    vec3<T> v;
+
+                    if (p1[0] != p1[1] || p1[0] != p1[2])
+                    {
+                        v = vec3<T>(p1[1], p1[2], p1[0]);
+                    }
+                    else
+                    {
+                        v = vec3<T>(-p1[0], p1[1], p1[2]);
+                    }
+
+                    v -= p1 * dot(p1, v);
+                    v = normalize(v);
+
+                    set_value(v, T(3.1415926));
+                    return *this;
+                }
+
+                p1 = normalize(cross(p1, p2));
+
+                set_value(p1,T(acos(alpha)));
+
+                return *this;
+            }
+
+            quaternion &set_value(const vec3<T> &from_look, const vec3<T> &from_up,
+                                  const vec3<T> &to_look, const vec3<T> &to_up)
+            {
+                quaternion r_look = quaternion(from_look, to_look);
+
+                vec3<T> rotated_from_up(from_up);
+                r_look.mult_vec(rotated_from_up);
+
+                quaternion r_twist = quaternion(rotated_from_up, to_up);
+
+                *this = r_twist;
+                *this *= r_look;
+                return *this;
+            }
+
+            quaternion &operator *= (const quaternion<T> &qr)
+            {
+                quaternion ql(*this);
+
+                w = ql.w * qr.w - ql.x * qr.x - ql.y * qr.y - ql.z * qr.z;
+                x = ql.w * qr.x + ql.x * qr.w + ql.y * qr.z - ql.z * qr.y;
+                y = ql.w * qr.y + ql.y * qr.w + ql.z * qr.x - ql.x * qr.z;
+                z = ql.w * qr.z + ql.z * qr.w + ql.x * qr.y - ql.y * qr.x;
+
+                return *this;
+            }
+
+            friend quaternion normalize(const quaternion<T> &q)
+            {
+                quaternion r(q);
+                T rnorm = T(1.0) / T(sqrt(q.w * q.w + q.x * q.x + q.y * q.y + q.z * q.z));
+
+                r.x *= rnorm;
+                r.y *= rnorm;
+                r.z *= rnorm;
+                r.w *= rnorm;
+            }
+
+            friend quaternion<T> conjugate(const quaternion<T> &q)
+            {
+                quaternion<T> r(q);
+                r._array[0] *= T(-1.0);
+                r._array[1] *= T(-1.0);
+                r._array[2] *= T(-1.0);
+                return r;
+            }
+
+            friend quaternion<T> inverse(const quaternion<T> &q)
+            {
+                return conjugate(q);
+            }
+
+            //
+            // Quaternion multiplication with cartesian vector
+            // v' = q*v*q(star)
+            //
+            void mult_vec(const vec3<T> &src, vec3<T> &dst) const
+            {
+                T v_coef = w * w - x * x - y * y - z * z;
+                T u_coef = T(2.0) * (src[0] * x + src[1] * y + src[2] * z);
+                T c_coef = T(2.0) * w;
+
+                dst.v[0] = v_coef * src.v[0] + u_coef * x + c_coef * (y * src.v[2] - z * src.v[1]);
+                dst.v[1] = v_coef * src.v[1] + u_coef * y + c_coef * (z * src.v[0] - x * src.v[2]);
+                dst.v[2] = v_coef * src.v[2] + u_coef * z + c_coef * (x * src.v[1] - y * src.v[0]);
+            }
+
+            void mult_vec(vec3<T> &src_and_dst) const
+            {
+                mult_vec(vec3<T>(src_and_dst), src_and_dst);
+            }
+
+            void scale_angle(T scaleFactor)
+            {
+                vec3<T> axis;
+                T radians;
+
+                get_value(axis, radians);
+                radians *= scaleFactor;
+                set_value(axis, radians);
+            }
+
+            friend quaternion<T> slerp(const quaternion<T> &p, const quaternion<T> &q, T alpha)
+            {
+                quaternion r;
+
+                T cos_omega = p.x * q.x + p.y * q.y + p.z * q.z + p.w * q.w;
+                // if B is on opposite hemisphere from A, use -B instead
+
+                int bflip;
+
+                if ((bflip = (cos_omega < T(0))))
+                {
+                    cos_omega = -cos_omega;
+                }
+
+                // complementary interpolation parameter
+                T beta = T(1) - alpha;
+
+                if (cos_omega >= T(1))
+                {
+                    return p;
+                }
+
+                T omega = T(acos(cos_omega));
+                T one_over_sin_omega = T(1.0) / T(sin(omega));
+
+                beta    = T(sin(omega*beta)  * one_over_sin_omega);
+                alpha   = T(sin(omega*alpha) * one_over_sin_omega);
+
+                if (bflip)
+                {
+                    alpha = -alpha;
+                }
+
+                r.x = beta * p._array[0]+ alpha * q._array[0];
+                r.y = beta * p._array[1]+ alpha * q._array[1];
+                r.z = beta * p._array[2]+ alpha * q._array[2];
+                r.w = beta * p._array[3]+ alpha * q._array[3];
+                return r;
+            }
+
+            T &operator [](int i)
+            {
+                return _array[i];
+            }
+
+            const T &operator [](int i) const
+            {
+                return _array[i];
+            }
+
+
+            friend bool operator == (const quaternion<T> &lhs, const quaternion<T> &rhs)
+            {
+                bool r = true;
+
+                for (int i = 0; i < 4; i++)
+                {
+                    r &= lhs._array[i] == rhs._array[i];
+                }
+
+                return r;
+            }
+
+            friend bool operator != (const quaternion<T> &lhs, const quaternion<T> &rhs)
+            {
+                bool r = true;
+
+                for (int i = 0; i < 4; i++)
+                {
+                    r &= lhs._array[i] == rhs._array[i];
+                }
+
+                return r;
+            }
+
+            friend quaternion<T> operator * (const quaternion<T> &lhs, const quaternion<T> &rhs)
+            {
+                quaternion r(lhs);
+                r *= rhs;
+                return r;
+            }
+
+
+            union
+            {
+                struct
+                {
+                    T x;
+                    T y;
+                    T z;
+                    T w;
+                };
+                T _array[4];
+            };
+
+    };
+
+
+
+};
+
+#endif

Common/nvShaderUtils.h

@@ -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.
+ */
+
+/*
+ *
+ * Utility functions for compiling shaders and programs
+ *
+ * Author: Evan Hart
+ * Copyright (c) NVIDIA Corporation. All rights reserved.
+ *
+ */
+
+
+#ifndef NV_SHADER_UTILS_H
+#define NV_SHADER_UTILS_H
+
+#include <stdio.h>
+#include <string.h>
+
+namespace nv {
+
+//
+//
+////////////////////////////////////////////////////////////
+inline GLuint CompileGLSLShader(GLenum target, const char *shader) {
+  GLuint object;
+
+  object = glCreateShader(target);
+
+  if (!object) {
+    return object;
+  }
+
+  glShaderSource(object, 1, &shader, NULL);
+
+  glCompileShader(object);
+
+  // check if shader compiled
+  GLint compiled = 0;
+  glGetShaderiv(object, GL_COMPILE_STATUS, &compiled);
+
+  if (!compiled) {
+#ifdef NV_REPORT_COMPILE_ERRORS
+    char temp[256] = "";
+    glGetShaderInfoLog(object, 256, NULL, temp);
+    fprintf(stderr, "Compile failed:\n%s\n", temp);
+#endif
+    glDeleteShader(object);
+    return 0;
+  }
+
+  return object;
+}
+
+//
+//
+////////////////////////////////////////////////////////////
+inline GLuint CompileGLSLShaderFromFile(GLenum target, const char *filename) {
+  FILE *shaderFile;
+  char *text;
+  long size;
+  size_t fsize = 0;
+
+  // read files as binary to prevent problems from newline translation
+#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
+
+  if (fopen_s(&shaderFile, filename, "rb") != 0)
+#else
+  if ((shaderFile = fopen(filename, "rb")) == 0)
+#endif
+  {
+    return 0;
+  }
+
+  // Get the length of the file
+  fseek(shaderFile, 0, SEEK_END);
+  size = ftell(shaderFile);
+
+  // Read the file contents from the start, then close file and add a null
+  // terminator
+  fseek(shaderFile, 0, SEEK_SET);
+  text = new char[size + 1];
+  fsize = fread(text, size, 1, shaderFile);
+  fclose(shaderFile);
+
+  if (fsize == 0) {
+    printf("CompileGLSLShaderFromFile(), error... fsize = 0\n");
+  }
+
+  text[size] = '\0';
+
+  GLuint object = CompileGLSLShader(target, text);
+
+  delete[] text;
+
+  return object;
+}
+
+// Create a program composed of vertex and fragment shaders.
+inline GLuint LinkGLSLProgram(GLuint vertexShader, GLuint fragmentShader) {
+  GLuint program = glCreateProgram();
+  glAttachShader(program, vertexShader);
+  glAttachShader(program, fragmentShader);
+  glLinkProgram(program);
+
+#ifdef NV_REPORT_COMPILE_ERRORS
+  // Get error log.
+  GLint charsWritten, infoLogLength;
+  glGetProgramiv(program, GL_INFO_LOG_LENGTH, &infoLogLength);
+
+  char *infoLog = new char[infoLogLength];
+  glGetProgramInfoLog(program, infoLogLength, &charsWritten, infoLog);
+  printf(infoLog);
+  delete[] infoLog;
+#endif
+
+  // Test linker result.
+  GLint linkSucceed = GL_FALSE;
+  glGetProgramiv(program, GL_LINK_STATUS, &linkSucceed);
+
+  if (linkSucceed == GL_FALSE) {
+    glDeleteProgram(program);
+    return 0;
+  }
+
+  return program;
+}
+
+// Create a program composed of vertex, geometry and fragment shaders.
+inline GLuint LinkGLSLProgram(GLuint vertexShader, GLuint geometryShader,
+                              GLint inputType, GLint vertexOut,
+                              GLint outputType, GLuint fragmentShader) {
+  GLuint program = glCreateProgram();
+  glAttachShader(program, vertexShader);
+  glAttachShader(program, geometryShader);
+  glProgramParameteriEXT(program, GL_GEOMETRY_INPUT_TYPE_EXT, inputType);
+  glProgramParameteriEXT(program, GL_GEOMETRY_VERTICES_OUT_EXT, vertexOut);
+  glProgramParameteriEXT(program, GL_GEOMETRY_OUTPUT_TYPE_EXT, outputType);
+  glAttachShader(program, fragmentShader);
+  glLinkProgram(program);
+
+#ifdef NV_REPORT_COMPILE_ERRORS
+  // Get error log.
+  GLint charsWritten, infoLogLength;
+  glGetProgramiv(program, GL_INFO_LOG_LENGTH, &infoLogLength);
+
+  char *infoLog = new char[infoLogLength];
+  glGetProgramInfoLog(program, infoLogLength, &charsWritten, infoLog);
+  printf(infoLog);
+  delete[] infoLog;
+#endif
+
+  // Test linker result.
+  GLint linkSucceed = GL_FALSE;
+  glGetProgramiv(program, GL_LINK_STATUS, &linkSucceed);
+
+  if (linkSucceed == GL_FALSE) {
+    glDeleteProgram(program);
+    return 0;
+  }
+
+  return program;
+}
+
+//
+//
+////////////////////////////////////////////////////////////
+inline GLuint CompileASMShader(GLenum program_type, const char *code) {
+  GLuint program_id;
+  glGenProgramsARB(1, &program_id);
+  glBindProgramARB(program_type, program_id);
+  glProgramStringARB(program_type, GL_PROGRAM_FORMAT_ASCII_ARB,
+                     (GLsizei)strlen(code), (GLubyte *)code);
+
+  GLint error_pos;
+  glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &error_pos);
+
+  if (error_pos != -1) {
+#ifdef NV_REPORT_COMPILE_ERRORS
+    const GLubyte *error_string;
+    error_string = glGetString(GL_PROGRAM_ERROR_STRING_ARB);
+    fprintf(stderr, "Program error at position: %d\n%s\n", (int)error_pos,
+            error_string);
+#endif
+    return 0;
+  }
+
+  return program_id;
+}
+
+//
+//
+////////////////////////////////////////////////////////////
+inline GLuint CompileASMShaderFromFile(GLenum target, const char *filename) {
+  FILE *shaderFile;
+  char *text;
+  long size;
+  size_t fsize = 0;
+
+  // read files as binary to prevent problems from newline translation
+#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
+
+  if (fopen_s(&shaderFile, filename, "rb") != 0)
+#else
+  if ((shaderFile = fopen(filename, "rb")) == 0)
+#endif
+  {
+    return 0;
+  }
+
+  // Get the length of the file
+  fseek(shaderFile, 0, SEEK_END);
+  size = ftell(shaderFile);
+
+  // Read the file contents from the start, then close file and add a null
+  // terminator
+  fseek(shaderFile, 0, SEEK_SET);
+  text = new char[size + 1];
+  fsize = fread(text, size, 1, shaderFile);
+  fclose(shaderFile);
+
+  if (fsize == 0) {
+    printf("CompileGLSLShaderFromFile(), error... fsize = 0\n");
+  }
+
+  text[size] = '\0';
+
+  GLuint program_id = CompileASMShader(target, text);
+
+  delete[] text;
+
+  return program_id;
+}
+
+}  // namespace nv
+#endif

Common/nvrtc_helper.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved.
+/* 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
@@ -47,8 +47,13 @@
     }                                                           \
   } while (0)
 
-void compileFileToPTX(char *filename, int argc, char **argv, char **ptxResult,
-                      size_t *ptxResultSize, int requiresCGheaders) {
+void compileFileToCUBIN(char *filename, int argc, char **argv, char **cubinResult,
+                      size_t *cubinResultSize, int requiresCGheaders) {
+  if (!filename) {
+    std::cerr << "\nerror: filename is empty for compileFileToCUBIN()!\n";
+    exit(1);
+  }
+
   std::ifstream inputFile(filename,
                           std::ios::in | std::ios::binary | std::ios::ate);
 
@@ -68,7 +73,37 @@ void compileFileToPTX(char *filename, int argc, char **argv, char **ptxResult,
 
   int numCompileOptions = 0;
 
-  char *compileParams[1];
+  char *compileParams[2];
+
+  int major = 0, minor = 0;
+  char deviceName[256];
+
+  // Picks the best CUDA device available
+  CUdevice cuDevice = findCudaDeviceDRV(argc, (const char **)argv);
+
+  // get compute capabilities and the devicename
+  checkCudaErrors(cuDeviceGetAttribute(
+      &major, CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR, cuDevice));
+  checkCudaErrors(cuDeviceGetAttribute(
+      &minor, CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR, cuDevice));
+  
+  {
+  // Compile cubin for the GPU arch on which are going to run cuda kernel.
+  std::string compileOptions;
+  compileOptions = "--gpu-architecture=sm_";
+
+  compileParams[numCompileOptions] = reinterpret_cast<char *>(
+                  malloc(sizeof(char) * (compileOptions.length() + 10)));
+#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
+  sprintf_s(compileParams[numCompileOptions], sizeof(char) * (compileOptions.length() + 10),
+            "%s%d%d", compileOptions.c_str(), major, minor);
+#else
+  snprintf(compileParams[numCompileOptions], compileOptions.size() + 10, "%s%d%d",
+           compileOptions.c_str(), major, minor);
+#endif
+  }
+
+  numCompileOptions++;
 
   if (requiresCGheaders) {
     std::string compileOptions;
@@ -81,7 +116,12 @@ void compileFileToPTX(char *filename, int argc, char **argv, char **ptxResult,
 
     compileOptions = "--include-path=";
 
-    std::string path = sdkFindFilePath(HeaderNames, argv[0]);
+    char *strPath = sdkFindFilePath(HeaderNames, argv[0]);
+    if (!strPath) {
+      std::cerr << "\nerror: header file " << HeaderNames << " not found!\n";
+      exit(1);
+    }
+    std::string path = strPath;
     if (!path.empty()) {
       std::size_t found = path.find(HeaderNames);
       path.erase(found);
@@ -90,15 +130,16 @@ void compileFileToPTX(char *filename, int argc, char **argv, char **ptxResult,
           "\nCooperativeGroups headers not found, please install it in %s "
           "sample directory..\n Exiting..\n",
           argv[0]);
+      exit(1);
     }
     compileOptions += path.c_str();
-    compileParams[0] = reinterpret_cast<char *>(
+    compileParams[numCompileOptions] = reinterpret_cast<char *>(
         malloc(sizeof(char) * (compileOptions.length() + 1)));
 #if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
-    sprintf_s(compileParams[0], sizeof(char) * (compileOptions.length() + 1),
+    sprintf_s(compileParams[numCompileOptions], sizeof(char) * (compileOptions.length() + 1),
               "%s", compileOptions.c_str());
 #else
-    snprintf(compileParams[0], compileOptions.size(), "%s",
+    snprintf(compileParams[numCompileOptions], compileOptions.size(), "%s",
              compileOptions.c_str());
 #endif
     numCompileOptions++;
@@ -128,23 +169,25 @@ void compileFileToPTX(char *filename, int argc, char **argv, char **ptxResult,
   free(log);
 
   NVRTC_SAFE_CALL("nvrtcCompileProgram", res);
-  // fetch PTX
-  size_t ptxSize;
-  NVRTC_SAFE_CALL("nvrtcGetPTXSize", nvrtcGetPTXSize(prog, &ptxSize));
-  char *ptx = reinterpret_cast<char *>(malloc(sizeof(char) * ptxSize));
-  NVRTC_SAFE_CALL("nvrtcGetPTX", nvrtcGetPTX(prog, ptx));
-  NVRTC_SAFE_CALL("nvrtcDestroyProgram", nvrtcDestroyProgram(&prog));
-  *ptxResult = ptx;
-  *ptxResultSize = ptxSize;
 
-  if (requiresCGheaders) free(compileParams[0]);
+  size_t codeSize;
+  NVRTC_SAFE_CALL("nvrtcGetCUBINSize", nvrtcGetCUBINSize(prog, &codeSize));
+  char *code = new char[codeSize];
+  NVRTC_SAFE_CALL("nvrtcGetCUBIN", nvrtcGetCUBIN(prog, code));
+  *cubinResult = code;
+  *cubinResultSize = codeSize;
+
+  for (int i = 0; i < numCompileOptions; i++) {
+    free(compileParams[i]);
+  }
 }
 
-CUmodule loadPTX(char *ptx, int argc, char **argv) {
+CUmodule loadCUBIN(char *cubin, int argc, char **argv) {
   CUmodule module;
   CUcontext context;
   int major = 0, minor = 0;
   char deviceName[256];
+  CUctxCreateParams ctxCreateParams = {};
 
   // Picks the best CUDA device available
   CUdevice cuDevice = findCudaDeviceDRV(argc, (const char **)argv);
@@ -158,11 +201,10 @@ CUmodule loadPTX(char *ptx, int argc, char **argv) {
   printf("> GPU Device has SM %d.%d compute capability\n", major, minor);
 
   checkCudaErrors(cuInit(0));
-  checkCudaErrors(cuDeviceGet(&cuDevice, 0));
-  checkCudaErrors(cuCtxCreate(&context, 0, cuDevice));
+  checkCudaErrors(cuCtxCreate(&context, &ctxCreateParams, 0, cuDevice));
 
-  checkCudaErrors(cuModuleLoadDataEx(&module, ptx, 0, 0, 0));
-  free(ptx);
+  checkCudaErrors(cuModuleLoadData(&module, cubin));
+  free(cubin);
 
   return module;
 }

Common/param.h

@@ -0,0 +1,236 @@
+/* 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.
+ */
+
+/*
+ Simple parameter system
+ sgreen@nvidia.com 4/2001
+*/
+
+#ifndef PARAM_H
+#define PARAM_H
+
+#include <iomanip>
+#include <iostream>
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+// base class for named parameter
+class ParamBase {
+ public:
+  ParamBase(const char *name) : m_name(name) {}
+  virtual ~ParamBase() {}
+
+  std::string &GetName() { return m_name; }
+
+  virtual float GetFloatValue() = 0;
+  virtual int GetIntValue() = 0;
+  virtual std::string GetValueString() = 0;
+
+  virtual void Reset() = 0;
+  virtual void Increment() = 0;
+  virtual void Decrement() = 0;
+
+  virtual float GetPercentage() = 0;
+  virtual void SetPercentage(float p) = 0;
+
+  virtual void Write(std::ostream &stream) = 0;
+  virtual void Read(std::istream &stream) = 0;
+
+  virtual bool IsList() = 0;
+
+ protected:
+  std::string m_name;
+};
+
+// derived class for single-valued parameter
+template <class T>
+class Param : public ParamBase {
+ public:
+  Param(const char *name, T value = 0, T min = 0, T max = 10000, T step = 1,
+        T *ptr = 0)
+      : ParamBase(name),
+        m_default(value),
+        m_min(min),
+        m_max(max),
+        m_step(step),
+        m_precision(3) {
+    if (ptr) {
+      m_ptr = ptr;
+    } else {
+      m_ptr = &m_value;
+    }
+
+    *m_ptr = value;
+  }
+  ~Param() {}
+
+  T GetValue() const { return *m_ptr; }
+  T SetValue(const T value) { *m_ptr = value; }
+
+  float GetFloatValue() { return (float)*m_ptr; }
+  int GetIntValue() { return (int)*m_ptr; }
+
+  std::string GetValueString() {
+    std::ostringstream ost;
+    ost << std::setprecision(m_precision) << std::fixed;
+    ost << *m_ptr;
+    return ost.str();
+  }
+
+  void SetPrecision(int x) { m_precision = x; }
+
+  float GetPercentage() { return (*m_ptr - m_min) / (float)(m_max - m_min); }
+
+  void SetPercentage(float p) { *m_ptr = (T)(m_min + p * (m_max - m_min)); }
+
+  void Reset() { *m_ptr = m_default; }
+
+  void Increment() {
+    *m_ptr += m_step;
+
+    if (*m_ptr > m_max) {
+      *m_ptr = m_max;
+    }
+  }
+
+  void Decrement() {
+    *m_ptr -= m_step;
+
+    if (*m_ptr < m_min) {
+      *m_ptr = m_min;
+    }
+  }
+
+  void Write(std::ostream &stream) {
+    stream << m_name << " " << *m_ptr << '\n';
+  }
+  void Read(std::istream &stream) { stream >> m_name >> *m_ptr; }
+
+  bool IsList() { return false; }
+
+ private:
+  T m_value;
+  T *m_ptr;  // pointer to value declared elsewhere
+  T m_default, m_min, m_max, m_step;
+  int m_precision;  // number of digits after decimal point in string output
+};
+
+const Param<int> dummy("error");
+
+// list of parameters
+class ParamList : public ParamBase {
+ public:
+  ParamList(const char *name = "") : ParamBase(name) { active = true; }
+  ~ParamList() {}
+
+  float GetFloatValue() { return 0.0f; }
+  int GetIntValue() { return 0; }
+
+  void AddParam(ParamBase *param) {
+    m_params.push_back(param);
+    m_map[param->GetName()] = param;
+    m_current = m_params.begin();
+  }
+
+  // look-up parameter based on name
+  ParamBase *GetParam(char *name) {
+    ParamBase *p = m_map[name];
+
+    if (p) {
+      return p;
+    } else {
+      return (ParamBase *)&dummy;
+    }
+  }
+
+  ParamBase *GetParam(int i) { return m_params[i]; }
+
+  ParamBase *GetCurrent() { return *m_current; }
+
+  int GetSize() { return (int)m_params.size(); }
+
+  std::string GetValueString() { return m_name; }
+
+  // functions to traverse list
+  void Reset() { m_current = m_params.begin(); }
+
+  void Increment() {
+    m_current++;
+
+    if (m_current == m_params.end()) {
+      m_current = m_params.begin();
+    }
+  }
+
+  void Decrement() {
+    if (m_current == m_params.begin()) {
+      m_current = m_params.end() - 1;
+    } else {
+      m_current--;
+    }
+  }
+
+  float GetPercentage() { return 0.0f; }
+  void SetPercentage(float /*p*/) {}
+
+  void Write(std::ostream &stream) {
+    stream << m_name << '\n';
+
+    for (std::vector<ParamBase *>::const_iterator p = m_params.begin();
+         p != m_params.end(); ++p) {
+      (*p)->Write(stream);
+    }
+  }
+
+  void Read(std::istream &stream) {
+    stream >> m_name;
+
+    for (std::vector<ParamBase *>::const_iterator p = m_params.begin();
+         p != m_params.end(); ++p) {
+      (*p)->Read(stream);
+    }
+  }
+
+  bool IsList() { return true; }
+
+  void ResetAll() {
+    for (std::vector<ParamBase *>::const_iterator p = m_params.begin();
+         p != m_params.end(); ++p) {
+      (*p)->Reset();
+    }
+  }
+
+ protected:
+  bool active;
+  std::vector<ParamBase *> m_params;
+  std::map<std::string, ParamBase *> m_map;
+  std::vector<ParamBase *>::const_iterator m_current;
+};
+
+#endif

Common/paramgl.h

@@ -0,0 +1,307 @@
+/* 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.
+ */
+
+/*
+   ParamListGL
+   - class derived from ParamList to do simple OpenGL rendering of a parameter
+   list sgg 8/2001
+*/
+
+#ifndef PARAMGL_H
+#define PARAMGL_H
+
+#if defined(__APPLE__) || defined(MACOSX)
+#include <GLUT/glut.h>
+#else
+#include <GL/freeglut.h>
+#endif
+
+#include <param.h>
+#include <string.h>
+
+inline void beginWinCoords(void) {
+  glMatrixMode(GL_MODELVIEW);
+  glPushMatrix();
+  glLoadIdentity();
+  glTranslatef(0.0, (GLfloat)(glutGet(GLUT_WINDOW_HEIGHT) - 1.0), 0.0);
+  glScalef(1.0, -1.0, 1.0);
+
+  glMatrixMode(GL_PROJECTION);
+  glPushMatrix();
+  glLoadIdentity();
+  glOrtho(0, glutGet(GLUT_WINDOW_WIDTH), 0, glutGet(GLUT_WINDOW_HEIGHT), -1, 1);
+
+  glMatrixMode(GL_MODELVIEW);
+}
+
+inline void endWinCoords(void) {
+  glMatrixMode(GL_PROJECTION);
+  glPopMatrix();
+
+  glMatrixMode(GL_MODELVIEW);
+  glPopMatrix();
+}
+
+inline void glPrint(int x, int y, const char *s, void *font) {
+  glRasterPos2f((GLfloat)x, (GLfloat)y);
+  int len = (int)strlen(s);
+
+  for (int i = 0; i < len; i++) {
+    glutBitmapCharacter(font, s[i]);
+  }
+}
+
+inline void glPrintShadowed(int x, int y, const char *s, void *font,
+                            float *color) {
+  glColor3f(0.0, 0.0, 0.0);
+  glPrint(x - 1, y - 1, s, font);
+
+  glColor3fv((GLfloat *)color);
+  glPrint(x, y, s, font);
+}
+
+class ParamListGL : public ParamList {
+ public:
+  ParamListGL(const char *name = "")
+      : ParamList(name),
+        m_active(true),
+        m_text_color_selected(1.0, 1.0, 1.0),
+        m_text_color_unselected(0.75, 0.75, 0.75),
+        m_text_color_shadow(0.0, 0.0, 0.0),
+        m_bar_color_outer(0.25, 0.25, 0.25),
+        m_bar_color_inner(1.0, 1.0, 1.0) {
+    m_font = (void *)GLUT_BITMAP_9_BY_15;  // GLUT_BITMAP_8_BY_13;
+    m_font_h = 15;
+    m_bar_x = 260;
+    m_bar_w = 250;
+    m_bar_h = 10;
+    m_bar_offset = 5;
+    m_text_x = 5;
+    m_separation = 15;
+    m_value_x = 200;
+    m_start_x = 0;
+    m_start_y = 0;
+  }
+
+  void Render(int x, int y, bool shadow = false) {
+    beginWinCoords();
+
+    m_start_x = x;
+    m_start_y = y;
+
+    for (std::vector<ParamBase *>::const_iterator p = m_params.begin();
+         p != m_params.end(); ++p) {
+      if ((*p)->IsList()) {
+        ParamListGL *list = (ParamListGL *)(*p);
+        list->Render(x + 10, y);
+        y += m_separation * list->GetSize();
+      } else {
+        if (p == m_current) {
+          glColor3fv(&m_text_color_selected.r);
+        } else {
+          glColor3fv(&m_text_color_unselected.r);
+        }
+
+        if (shadow) {
+          glPrintShadowed(x + m_text_x, y + m_font_h, (*p)->GetName().c_str(),
+                          m_font,
+                          (p == m_current) ? &m_text_color_selected.r
+                                           : &m_text_color_unselected.r);
+          glPrintShadowed(x + m_value_x, y + m_font_h,
+                          (*p)->GetValueString().c_str(), m_font,
+                          (p == m_current) ? &m_text_color_selected.r
+                                           : &m_text_color_unselected.r);
+        } else {
+          glPrint(x + m_text_x, y + m_font_h, (*p)->GetName().c_str(), m_font);
+          glPrint(x + m_value_x, y + m_font_h, (*p)->GetValueString().c_str(),
+                  m_font);
+        }
+
+        glColor3fv((GLfloat *)&m_bar_color_outer.r);
+        glBegin(GL_LINE_LOOP);
+        glVertex2f((GLfloat)(x + m_bar_x), (GLfloat)(y + m_bar_offset));
+        glVertex2f((GLfloat)(x + m_bar_x + m_bar_w),
+                   (GLfloat)(y + m_bar_offset));
+        glVertex2f((GLfloat)(x + m_bar_x + m_bar_w),
+                   (GLfloat)(y + m_bar_offset + m_bar_h));
+        glVertex2f((GLfloat)(x + m_bar_x),
+                   (GLfloat)(y + m_bar_offset + m_bar_h));
+        glEnd();
+
+        glColor3fv((GLfloat *)&m_bar_color_inner.r);
+        glRectf(
+            (GLfloat)(x + m_bar_x), (GLfloat)(y + m_bar_offset + m_bar_h),
+            (GLfloat)(x + m_bar_x + ((m_bar_w - 1) * (*p)->GetPercentage())),
+            (GLfloat)(y + m_bar_offset + 1));
+
+        y += m_separation;
+      }
+    }
+
+    endWinCoords();
+  }
+
+  bool Mouse(int x, int y, int button = GLUT_LEFT_BUTTON,
+             int state = GLUT_DOWN) {
+    if ((y < m_start_y) ||
+        (y > (int)(m_start_y + (m_separation * m_params.size()) - 1))) {
+      m_active = false;
+      return false;
+    }
+
+    m_active = true;
+
+    int i = (y - m_start_y) / m_separation;
+
+    if ((button == GLUT_LEFT_BUTTON) && (state == GLUT_DOWN)) {
+#if defined(__GNUC__) && (__GNUC__ < 3)
+      m_current = &m_params[i];
+#else
+
+      // MJH: workaround since the version of vector::at used here is
+      // non-standard
+      for (m_current = m_params.begin(); m_current != m_params.end() && i > 0;
+           m_current++, i--)
+        ;
+
+        // m_current = (std::vector<ParamBase
+        // *>::const_iterator)&m_params.at(i);
+#endif
+
+      if ((x > m_bar_x) && (x < m_bar_x + m_bar_w)) {
+        Motion(x, y);
+      }
+    }
+
+    return true;
+  }
+
+  bool Motion(int x, int y) {
+    if ((y < m_start_y) ||
+        (y > m_start_y + (m_separation * (int)m_params.size()) - 1)) {
+      return false;
+    }
+
+    if (x < m_bar_x) {
+      (*m_current)->SetPercentage(0.0);
+      return true;
+    }
+
+    if (x > m_bar_x + m_bar_w) {
+      (*m_current)->SetPercentage(1.0);
+      return true;
+    }
+
+    (*m_current)->SetPercentage((x - m_bar_x) / (float)m_bar_w);
+    return true;
+  }
+
+  void Special(int key, int x, int y) {
+    if (!m_active) return;
+
+    switch (key) {
+      case GLUT_KEY_DOWN:
+        Increment();
+        break;
+
+      case GLUT_KEY_UP:
+        Decrement();
+        break;
+
+      case GLUT_KEY_RIGHT:
+        GetCurrent()->Increment();
+        break;
+
+      case GLUT_KEY_LEFT:
+        GetCurrent()->Decrement();
+        break;
+
+      case GLUT_KEY_HOME:
+        GetCurrent()->Reset();
+        break;
+
+      case GLUT_KEY_END:
+        GetCurrent()->SetPercentage(1.0);
+        break;
+    }
+
+    glutPostRedisplay();
+  }
+
+  void SetFont(void *font, int height) {
+    m_font = font;
+    m_font_h = height;
+  }
+
+  void SetSelectedColor(float r, float g, float b) {
+    m_text_color_selected = Color(r, g, b);
+  }
+  void SetUnSelectedColor(float r, float g, float b) {
+    m_text_color_unselected = Color(r, g, b);
+  }
+  void SetBarColorInner(float r, float g, float b) {
+    m_bar_color_inner = Color(r, g, b);
+  }
+  void SetBarColorOuter(float r, float g, float b) {
+    m_bar_color_outer = Color(r, g, b);
+  }
+
+  void SetActive(bool b) { m_active = b; }
+
+ private:
+  void *m_font;
+  int m_font_h;  // font height
+
+  int m_bar_x;       // bar start x position
+  int m_bar_w;       // bar width
+  int m_bar_h;       // bar height
+  int m_text_x;      // text start x position
+  int m_separation;  // bar separation in y
+  int m_value_x;     // value text x position
+  int m_bar_offset;  // bar offset in y
+
+  int m_start_x, m_start_y;
+
+  bool m_active;
+
+  struct Color {
+    Color(float _r, float _g, float _b) {
+      r = _r;
+      g = _g;
+      b = _b;
+    }
+    float r, g, b;
+  };
+
+  Color m_text_color_selected;
+  Color m_text_color_unselected;
+  Color m_text_color_shadow;
+  Color m_bar_color_outer;
+  Color m_bar_color_inner;
+};
+
+#endif

Common/rendercheck_d3d11.cpp

@@ -0,0 +1,124 @@
+/* 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.
+ */
+
+////////////////////////////////////////////////////////////////////////////////
+//
+//  Utility funcs to wrap up saving a surface or the back buffer as a PPM file
+//  In addition, wraps up a threshold comparision of two PPMs.
+//
+//  These functions are designed to be used to implement an automated QA testing for SDK samples.
+//
+//  Author: Bryan Dudash
+//  Email: sdkfeedback@nvidia.com
+//
+// Copyright (c) NVIDIA Corporation. All rights reserved.
+////////////////////////////////////////////////////////////////////////////////
+
+#include <helper_functions.h>
+#include <rendercheck_d3d11.h>
+
+HRESULT CheckRenderD3D11::ActiveRenderTargetToPPM(ID3D11Device *pDevice, const char *zFileName)
+{
+    ID3D11DeviceContext *pDeviceCtxt;
+    pDevice->GetImmediateContext(&pDeviceCtxt);
+    ID3D11RenderTargetView *pRTV = NULL;
+    pDeviceCtxt->OMGetRenderTargets(1,&pRTV,NULL);
+
+    ID3D11Resource *pSourceResource = NULL;
+    pRTV->GetResource(&pSourceResource);
+
+    return ResourceToPPM(pDevice,pSourceResource,zFileName);
+}
+
+HRESULT CheckRenderD3D11::ResourceToPPM(ID3D11Device *pDevice, ID3D11Resource *pResource, const char *zFileName)
+{
+    ID3D11DeviceContext *pDeviceCtxt;
+    pDevice->GetImmediateContext(&pDeviceCtxt);
+    D3D11_RESOURCE_DIMENSION rType;
+    pResource->GetType(&rType);
+
+    if (rType != D3D11_RESOURCE_DIMENSION_TEXTURE2D)
+    {
+        printf("SurfaceToPPM: pResource is not a 2D texture! Aborting...\n");
+        return E_FAIL;
+    }
+
+    ID3D11Texture2D *pSourceTexture = (ID3D11Texture2D *)pResource;
+    ID3D11Texture2D *pTargetTexture = NULL;
+
+    D3D11_TEXTURE2D_DESC desc;
+    pSourceTexture->GetDesc(&desc);
+    desc.BindFlags = 0;
+    desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
+    desc.Usage = D3D11_USAGE_STAGING;
+
+    if (FAILED(pDevice->CreateTexture2D(&desc,NULL,&pTargetTexture)))
+    {
+        printf("SurfaceToPPM: Unable to create target Texture resoruce! Aborting... \n");
+        return E_FAIL;
+    }
+
+    pDeviceCtxt->CopyResource(pTargetTexture,pSourceTexture);
+
+    D3D11_MAPPED_SUBRESOURCE mappedTex2D;
+    pDeviceCtxt->Map(pTargetTexture, 0, D3D11_MAP_READ,0,&mappedTex2D);
+
+    // Need to convert from dx pitch to pitch=width
+    unsigned char *pPPMData = new unsigned char[desc.Width*desc.Height*4];
+
+    for (unsigned int iHeight = 0; iHeight<desc.Height; iHeight++)
+    {
+        memcpy(&(pPPMData[iHeight*desc.Width*4]),(unsigned char *)(mappedTex2D.pData)+iHeight*mappedTex2D.RowPitch,desc.Width*4);
+    }
+
+    pDeviceCtxt->Unmap(pTargetTexture, 0);
+
+    // Prepends the PPM header info and bumps byte data afterwards
+    sdkSavePPM4ub(zFileName, pPPMData, desc.Width, desc.Height);
+
+    delete [] pPPMData;
+    pTargetTexture->Release();
+
+    return S_OK;
+}
+
+bool CheckRenderD3D11::PPMvsPPM(const char *src_file, const char *ref_file, const char *exec_path,
+                                const float epsilon, const float threshold)
+{
+    char *ref_file_path = sdkFindFilePath(ref_file, exec_path);
+
+    if (ref_file_path == NULL)
+    {
+        printf("CheckRenderD3D11::PPMvsPPM unable to find <%s> in <%s> Aborting comparison!\n", ref_file, exec_path);
+        printf(">>> Check info.xml and [project//data] folder <%s> <<<\n", ref_file);
+        printf("Aborting comparison!\n");
+        printf("  FAILURE!\n");
+        return false;
+    }
+
+    return sdkComparePPM(src_file,ref_file_path,epsilon,threshold,true) == true;
+}

Common/rendercheck_d3d11.h

@@ -0,0 +1,52 @@
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#ifndef _RENDERCHECK_D3D11_H_
+#define _RENDERCHECK_D3D11_H_
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <d3d11.h>
+
+class CheckRenderD3D11
+{
+    public:
+
+        CheckRenderD3D11() {}
+
+        static HRESULT ActiveRenderTargetToPPM(ID3D11Device  *pDevice, const char *zFileName);
+        static HRESULT ResourceToPPM(ID3D11Device *pDevice, ID3D11Resource *pResource, const char *zFileName);
+
+        static bool PPMvsPPM(const char *src_file, const char *ref_file, const char *exec_path,
+                             const float epsilon, const float threshold = 0.0f);
+};
+
+#endif

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved.
+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

README.md

@@ -1,53 +1,21 @@
 # CUDA Samples
 
-Samples for CUDA Developers which demonstrates features in CUDA Toolkit. This version supports [CUDA Toolkit 10.1](https://developer.nvidia.com/cuda-downloads).
+Samples for CUDA Developers which demonstrates features in CUDA Toolkit. This version supports [CUDA Toolkit 13.4](https://developer.nvidia.com/cuda-downloads).
 
 ## Release Notes
 
 This section describes the release notes for the CUDA Samples on GitHub only.
 
-### CUDA 10.1
-*  Added `immaTensorCoreGemm`. Demonstrates integer GEMM computation using the Warp Matrix Multiply and Accumulate (WMMA) API for integers employing the Tensor Cores.
-*  Added `simpleIPC`. Demonstrates Inter Process Communication with one process per GPU for computation.
-*  Added `nvJPEG`. Demonstrates single and batched decoding of jpeg images using NVJPEG Library.
-*  Added `bandwidthTest`. It measures the memcopy bandwidth of the GPU and memcpy bandwidth across PCI-e.
-*  Added `reduction`. Demonstrates several important optimization strategies for Data-Parallel Algorithms like reduction.
-*  Update all the samples to support CUDA 10.1.
+### Change Log
 
-### CUDA 10.0
-*  Added `simpleCudaGraphs`. Demonstrates CUDA Graphs creation, instantiation and launch using Graphs APIs and Stream Capture APIs.
-*  Added `conjugateGradientCudaGraphs`. Demonstrates conjugate gradient solver on GPU using CUBLAS and CUSPARSE library calls captured and called using CUDA Graph APIs.
-*  Added `simpleVulkan`. Demonstrates Vulkan - CUDA Interop.
-*  Added `simpleD3D12`. Demonstrates DX12 - CUDA Interop.
-*  Added `UnifiedMemoryPerf`. Demonstrates performance comparision of various memory types involved in system.
-*  Added `p2pBandwidthLatencyTest`. Demonstrates Peer-To-Peer (P2P) data transfers between pairs of GPUs and computes latency and bandwidth.
-*  Added `systemWideAtomics`. Demonstrates system wide atomic instructions.
-*  Added `simpleCUBLASXT`. Demonstrates CUBLAS-XT library which performs GEMM operations over multiple GPUs.
-*  Added Windows OS support to `conjugateGradientMultiDeviceCG` sample.
-*  Removed support of Visual Studio 2010 from all samples.
-
-### CUDA 9.2
-
-This is the first release of CUDA Samples on GitHub:
-*  Added `vectorAdd_nvrtc`. Demonstrates runtime compilation library using NVRTC of a simple vectorAdd kernel.
-*  Added `warpAggregatedAtomicsCG`. Demonstrates warp aggregated atomics using Cooperative Groups.
-*  Added `deviceQuery`. Enumerates the properties of the CUDA devices present in the system.
-*  Added `matrixMul`. Demonstrates a matrix multiplication using shared memory through tiled approach.
-*  Added `matrixMulDrv`. Demonstrates a matrix multiplication using shared memory through tiled approach, uses CUDA Driver API.
-*  Added `cudaTensorCoreGemm`. Demonstrates a GEMM computation using the Warp Matrix Multiply and Accumulate (WMMA) API introduced in CUDA 9, as well as the new Tensor Cores introduced in the Volta chip family.
-*  Added `simpleVoteIntrinsics` which uses *_sync equivalent of the vote intrinsics _any, _all added since CUDA 9.0.
-*  Added `shfl_scan` which uses *_sync equivalent of the shfl intrinsics added since CUDA 9.0.
-*  Added `conjugateGradientMultiBlockCG`. Demonstrates a conjugate gradient solver on GPU using Multi Block Cooperative Groups.
-*  Added `conjugateGradientMultiDeviceCG`. Demonstrates a conjugate gradient solver on multiple GPUs using Multi Device Cooperative Groups, also uses unified memory prefetching and usage hints APIs.
-*  Added `simpleCUBLAS`. Demonstrates how perform GEMM operations using CUBLAS library.
-*  Added `simpleCUFFT`. Demonstrates how perform FFT operations using CUFFT library.
+### [Revision History](./CHANGELOG.md)
 
 ## Getting Started
 
 ### Prerequisites
 
-Download and install the [CUDA Toolkit 10.1](https://developer.nvidia.com/cuda-downloads) for your corresponding platform.
-For system requirements and installation instructions of cuda toolkit, please refer to the [Linux Installation Guide](http://docs.nvidia.com/cuda/cuda-installation-guide-linux/), the [Windows Installation Guide](http://docs.nvidia.com/cuda/cuda-installation-guide-microsoft-windows/index.html), and the [Mac Installation Guide](http://docs.nvidia.com/cuda/cuda-installation-guide-mac-os-x/index.html).
+Download and install the [CUDA Toolkit](https://developer.nvidia.com/cuda-downloads) for your corresponding platform.
+For system requirements and installation instructions of cuda toolkit, please refer to the [Linux Installation Guide](http://docs.nvidia.com/cuda/cuda-installation-guide-linux/), and the [Windows Installation Guide](http://docs.nvidia.com/cuda/cuda-installation-guide-microsoft-windows/index.html).
 
 ### Getting the CUDA Samples
 
@@ -60,97 +28,517 @@ Without using git the easiest way to use these samples is to download the zip fi
 
 ## Building CUDA Samples
 
-### 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>
-```
-Complete samples solution files exist at parent directory of the repo:
-
-Each individual sample has its own set of solution files at:
-`<CUDA_SAMPLES_REPO>\Samples\<sample_dir>\`
-
-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](#directx) section for details."
+The CUDA Samples are built using CMake. Follow the instructions below for building on Linux, Windows, and for cross-compilation to Tegra devices.
 
 ### 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:
+
+Ensure that CMake (version 3.20 or later) is installed. Install it using your package manager if necessary:
+
+e.g.
+```sudo apt install cmake```
+
+Navigate to the root of the cloned repository and create a build directory:
 ```
-$ cd <sample_dir>
-$ make
+mkdir build && cd build
 ```
-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, aarch64.
-    By default, TARGET_ARCH is set to HOST_ARCH. On a x86_64 machine, not setting TARGET_ARCH is the equivalent of setting TARGET_ARCH=x86_64.<br/>
-`$ make TARGET_ARCH=x86_64` <br/> `$ make TARGET_ARCH=ppc64le` <br/> `$ make TARGET_ARCH=armv7l` <br/> `$ make TARGET_ARCH=aarch64` <br/>
-    See [here](http://docs.nvidia.com/cuda/cuda-samples/index.html#cross-samples) for more details on cross platform compilation of cuda samples.
-*   **dbg=1** - build with debug symbols
+Configure the project with CMake:
 ```
-    $ make dbg=1
+cmake ..
 ```
-*   **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"`.
+Build the samples:
 ```
-    $ make SMS="50 60"
+make -j$(nproc)
 ```
 
-*  **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.
+By default, samples are compiled for all GPU architectures supported by this release. If you only need to target a specific GPU, you can override this to build for a single architecture and reduce build time considerably:
 ```
-    $ make HOST_COMPILER=g++
+cmake -DCMAKE_CUDA_ARCHITECTURES=<arch> ..
+```
+Replace `<arch>` with your GPU's SM version (e.g. `90` for sm_90).
+
+Run the samples from their respective directories in the build folder.
+
+### Building a Single Sample
+
+To build just one sample, configure CMake from within the sample's directory. You must explicitly specify a GPU architecture — standalone builds have no top-level default:
+
+```bash
+cd cpp/<category>/<sampleName>
+mkdir -p build && cd build
+cmake -DCMAKE_CUDA_ARCHITECTURES=<arch> ..
+make
 ```
 
-### Mac
-The Mac samples are built using makefiles. To use the makefiles, change directory into the sample directory you wish to build, and run make:
+Replace `<arch>` with your GPU's SM version (e.g. `90` for sm_90).
+
+### Windows
+
+Language services for CMake are available in Visual Studio 2019 version 16.5 or later, and you can directly import the CUDA samples repository from either the root level or from any
+subdirectory or individual sample.
+
+To build from the command line, open the `x64 Native Tools Command Prompt for VS` provided with your Visual Studio installation.
+
+Navigate to the root of the cloned repository and create a build directory:
 ```
-$ cd <sample_dir>
-$ make
+mkdir build && cd build
+```
+Configure the project with CMake - for example:
+```
+cmake .. -G "Visual Studio 16 2019" -A x64
+```
+Open the generated solution file CUDA_Samples.sln in Visual Studio. Build the samples by selecting the desired configuration (e.g., Debug or Release) and pressing F7 (Build Solution).
+
+Run the samples from the output directories specified in Visual Studio.
+
+### Enabling On-GPU Debugging
+
+NVIDIA GPUs support on-GPU debugging through cuda-gdb. Enabling this may significantly affect application performance as certain compiler optimizations are disabled
+in this configuration, hence it's not on by default. Enablement of on-device debugging is controlled via the `-G` switch to nvcc.
+
+To enable cuda-gdb for samples builds, define the `ENABLE_CUDA_DEBUG` flag on the CMake command line. For example:
+
+```
+cmake -DENABLE_CUDA_DEBUG=True ...
 ```
 
-The samples makefiles can take advantage of certain options:
+### Platform-Specific Samples
+
+Some CUDA samples are specific to certain platforms, and require passing flags into CMake to enable. In particular, we define the following platform-specific flags:
+
+* `BUILD_TEGRA` - for Tegra-specific samples
+
+To build these samples, set the variables either on the command line or through your CMake GUI. For example:
 
-*  **dbg=1** - build with debug symbols
 ```
-    $ make dbg=1
+cmake -DBUILD_TEGRA=True ..
 ```
 
-*  **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".
+### Cross-Compilation for Tegra Platforms
+
+Install the NVIDIA toolchain and cross-compilation environment for Tegra devices as described in the Tegra Development Guide.
+
+Ensure that CMake (version 3.20 or later) is installed.
+
+Navigate to the root of the cloned repository and create a build directory:
 ```
-    $ make SMS="A B ..."
+mkdir build && cd build
+```
+Configure the project with CMake, specifying the Tegra toolchain file. And you can use -DTARGET_FS to point to the target file system root path for necessary include and library files:
+```
+cmake .. -DCMAKE_TOOLCHAIN_FILE=../cmake/toolchains/toolchain-aarch64-linux.cmake -DTARGET_FS=/path/to/target/system/file/system
+```
+Build the samples:
+```
+make -j$(nproc)
+```
+Transfer the built binaries to the Tegra device and execute them there.
+
+
+### Cross Building for Automotive Linux Platforms from the DriveOS Docker containers
+
+To build CUDA samples to the target platform from the DriveOS Docker containers, use the following instructions.
+
+Mount the target Root Filesystem (RFS) in the container so that the CUDA cmake process has the correct paths to CUDA and other system libraries required to build the samples.
+
+Create a temporary directory, `<temp>` is any temporary directory of your choosing, for example, you can use `/drive/temp`:
+
+```
+$ mkdir /drive/<temp>
 ```
 
-*  **HOST_COMPILER=<host_compiler>** - override the default clang host compiler. See the [Mac Installation Guide](http://docs.nvidia.com/cuda/cuda-installation-guide-mac-os-x/index.html#system-requirements) for a list of supported host compilers.
+Mount the filesystem by running the following command:
+
 ```
-    $ make HOST_COMPILER=clang
+$ mount /drive/drive-linux/filesystem/targetfs-images/dev_nsr_desktop_ubuntu-24.04_thor_rfs.img /drive/temp
 ```
 
+Configure the project by running the following cmake command:
+
+```
+$ mkdir build && cd build
+$ cmake .. -DBUILD_TEGRA=True \
+  -DCMAKE_CUDA_COMPILER=/usr/local/cuda/bin/nvcc \
+  -DCMAKE_TOOLCHAIN_FILE=../cmake/toolchains/toolchain-aarch64-linux.cmake \
+  -DTARGET_FS=/drive/temp \
+  -DCMAKE_LIBRARY_PATH=/drive/temp/usr/local/cuda-13.1/thor/lib64/ \
+  -DCMAKE_INCLUDE_PATH=/drive/temp/usr/local/cuda-13.1/thor/include/
+```
+
+Please note that the following libraries are not pre-installed in the DriveOS dev-nsr target filesystem:
+* libdrm-dev
+* Vulkan
+
+This causes the cmake command to throw errors related to the missing files, and as a result, the related samples will not build in later steps. This issue will be addressed in a future DriveOS release.
+
+To build the samples with ignore the error mentioned above, you can use `--ignore-errors`/`--keep-going` or comment out the comment out the corresponding `add_subdirectory` command in the CMakeLists.txt in the parent folder for the samples requiring Vulkan and libdrm_dev:
+
+```
+$ make -j$(nproc) --ignore-errors # or --keep-going
+```
+
+```
+# In cpp/5_Domain_Specific/CMakeList.txt
+# add_subdirectory(simpleGL)
+# add_subdirectory(simpleVulkan)
+# add_subdirectory(simpleVulkanMMAP)
+
+# In cpp/8_Platform_Specific/Tegra/CMakeList.txt
+# add_subdirectory(simpleGLES_EGLOutput)
+```
+
+### QNX
+
+Cross-compilation for QNX with CMake is supported in the CUDA 13.0 samples release and newer.
+
+Set up the QNX SDP paths:
+
+```bash
+export QNX_HOST=/path/to/qnx/host
+export QNX_TARGET=/path/to/qnx/target
+```
+
+Build the samples for the Tegra Thor QNX platform:
+
+```bash
+mkdir -p build && cd build
+cmake .. \
+  -DBUILD_TEGRA=True \
+  -DCMAKE_CUDA_COMPILER=/usr/local/cuda-13.3/bin/nvcc \
+  -DCMAKE_TOOLCHAIN_FILE=../cmake/toolchains/toolchain-aarch64-qnx.cmake \
+  -DTARGET_FS=/path/to/qnx/targetfs \
+  -DCMAKE_LIBRARY_PATH=/usr/local/cuda-13.3/thor/targets/aarch64-qnx/lib/stubs/ \
+  -DCMAKE_INCLUDE_PATH=/usr/local/cuda-13.3/thor/targets/aarch64-qnx/include/
+cmake --build .
+```
+
+`TARGET_FS` is the QNX target filesystem of your board. The `cudaNvSci` sample needs it, because the NvSci headers and libraries ship with the target filesystem and not with the CUDA toolkit. Without `TARGET_FS` the build reports `NvSCI not found` and skips the sample.
+
+The target filesystem is part of the NVIDIA DRIVE OS QNX SDK, which registered users download from [NVONLINE](https://partners.nvidia.com). After the SDK is installed, the filesystem is in the DRIVE OS workspace: `<NV_WORKSPACE>/drive-qnx` for the standard SDK and `<NV_WORKSPACE>/drive-qnx-safety` for the safety SDK. See the [DRIVE OS documentation](https://docs.nvidia.com/drive/) for the installation guides.
+
+For both QNX toolchains the build looks for `nvscibuf.h` in `<TARGET_FS>/include`, `<TARGET_FS>/../include` and `<TARGET_FS>/usr/include`, and for `libnvscibuf.so` in `<TARGET_FS>/lib-target`, `<TARGET_FS>/usr/libnvidia` and `<TARGET_FS>/usr/lib`. If your filesystem uses a different layout, set `NVSCIBUF_INCLUDE_DIR`, `NVSCISYNC_INCLUDE_DIR`, `NVSCIBUF_LIBRARY` and `NVSCISYNC_LIBRARY` on the cmake command line instead.
+
+### QNX Safety (CUDA Safe toolkit)
+
+Cross-compilation for **QNX Safety** uses the CUDA Safe toolkit (for example `/usr/local/cuda-13.3-safe`).
+
+Set up the QNX SDP and Safe toolkit paths:
+
+```bash
+export QNX_HOST=/path/to/qnx/host
+export QNX_TARGET=/path/to/qnx/target
+export CUDA_PATH=/usr/local/cuda-13.3-safe
+export PATH=$CUDA_PATH/nvvm/bin:$PATH
+```
+
+Build a single sample (standalone configure from the sample directory).
+
+```bash
+mkdir -p build && cd build
+cmake .. \
+  -DCMAKE_TOOLCHAIN_FILE=../../../cmake/toolchains/toolchain-aarch64-qnx-safe.cmake \
+  -DCMAKE_CUDA_COMPILER=$CUDA_PATH/bin/nvcc \
+  -DCMAKE_CUDA_ARCHITECTURES=110 \
+  -DTARGET_FS=/path/to/qnx/safety/targetfs
+cmake --build .
+```
+
+The safe toolchain sets `-safety-compat`, links shared `libcudart` and `libcuda`, and uses QNX `q++` as the CUDA host compiler (`CMAKE_CUDA_HOST_COMPILER`). Set `CMAKE_CUDA_ARCHITECTURES` to match your GPU (`87` for Orin, `110` for Thor).
+
+Supported QNX Safety samples: `matrixMul`, `cudaNvSci`.
+
+`TARGET_FS` is only needed for `cudaNvSci`, which links the NvSci libraries from the safety target filesystem (`<NV_WORKSPACE>/drive-qnx-safety`, part of the DRIVE OS QNX Safety SDK). `matrixMul` builds without it. The NvSci search paths are the same as for the standard QNX build above.
+
+### Forward Compatibility
+
+To build samples with new CUDA Toolkit(CUDA 13.0 or later) and UMD(Version 580 or later) and old KMD(Version 550 or earlier)，you need to set the `CMAKE_PREFIX_PATH` for using new driver library, the command might like this:
+
+```
+cmake -DCMAKE_PREFIX_PATH=/usr/local/cuda/lib64/stubs/ ..
+```
+
+## CUDA Python samples
+
+The repository includes **Python** examples under the [`python/`](./python) directory. **These samples are cuda.core–focused:** they use [CUDA Python](https://nvidia.github.io/cuda-python/), with [`cuda.core`](https://nvidia.github.io/cuda-python/cuda-core/latest/) for devices, programs, launches, and memory, alongside NumPy, CuPy, or framework interop where each sample notes.
+
+**Layout (same themes as the C++ samples):**
+
+| Directory | Contents |
+|-----------|----------|
+| `python/1_GettingStarted/` | Introductory scripts (e.g. `vectorAdd`, `deviceQuery`, `systemInfo`, image blur with unified memory, NumPy vs CuPy). |
+| `python/2_CoreConcepts/` | Algorithms and techniques (e.g. reductions, histograms, FFT, stream overlap, `memoryResources`, `cudaGraphs`, `jitLtoLinking`, `tmaTensorMap`). |
+| `python/3_FrameworkInterop/` | Integration with PyTorch and TensorFlow. |
+| `python/4_DistributedComputing/` | Multi-GPU, peer-to-peer, and IPC patterns (`ipcMemoryPool`). |
+| `python/Utilities/` | Shared helpers imported by some samples. |
+
+**How to run:** The top-level CMake build does **not** compile these samples. For each sample, use a Python 3.10+ environment with a matching [CUDA Toolkit](https://developer.nvidia.com/cuda-downloads) (the samples target CUDA 13.x and document exact package pins in `requirements.txt`):
+
+```bash
+cd python/<category>/<sampleName>
+pip install -r requirements.txt
+python <sampleScript>.py
+```
+
+Use each sample’s `README.md` for prerequisites, CLI options, and expected output.
+
+## Install Samples
+
+### Installation Path Structure
+
+The installation system automatically organizes samples into a structured directory layout based on:
+- **Target Architecture**: ${CMAKE_SYSTEM_PROCESSOR}, e.g. `x64`, `aarch64`, `amd64`, etc.
+- **Target OS**: `linux`, `windows`, `darwin`, `qnx`
+- **Build Type**: `release`, `debug`, etc.
+
+The default installation path is: `build/bin/${TARGET_ARCH}/${TARGET_OS}/${BUILD_TYPE}`
+
+**Examples:**
+- Linux x86_64 Release: `build/bin/x64/linux/release`
+- Linux aarch64 Release: `build/bin/aarch64/linux/release`
+- Windows amd64 Release: `build/bin/amd64/windows/release`
+
+### Customizing Installation Paths
+
+You can customize the installation location using CMake variables during the configuration step:
+
+- `CMAKE_INSTALL_PREFIX`: Changes the root installation directory (default: `build/bin`)
+  ```
+  cmake -DCMAKE_INSTALL_PREFIX=/custom/path ..
+  ```
+  This will install to: `/custom/path/${TARGET_ARCH}/${TARGET_OS}/${BUILD_TYPE}`
+
+- `CUDA_SAMPLES_INSTALL_DIR`: Specifies the exact final installation directory (overrides the structured path)
+  ```
+  cmake -DCUDA_SAMPLES_INSTALL_DIR=/exact/install/path ..
+  ```
+
+### Install Samples on Linux
+
+**Prerequisites:** You must first configure the project with CMake as described in the [Building CUDA Samples - Linux](#linux) or [Building]section.
+
+After configuring and building, install the samples:
+
+```
+cd build/
+make install
+```
+
+### Install Samples on Windows
+
+**Prerequisites:** You must first configure the project with CMake as described in the [Building CUDA Samples - Windows](#windows) section.
+
+#### Using Command Line
+
+After configuring with CMake, build and install from the `x64 Native Tools Command Prompt for VS`:
+
+```cmd
+cd build
+cmake --build . --config Release
+cmake --install . --config Release
+```
+
+**Note:** Replace `Release` with `Debug` if you want to install debug builds. For multi-configuration generators (like Visual Studio), the `--config` flag determines which build type to install.
+
+#### Using Visual Studio IDE
+
+Alternatively, open the generated solution file `CUDA_Samples.sln` in Visual Studio:
+1. Select the desired configuration (`Release` or `Debug`)
+2. Build the solution (F7 or Build > Build Solution)
+3. Right-click on the `INSTALL` target under `CMakePredefinedTargets` in Solution Explorer
+4. Select "Build"
+
+## Running All Samples as Tests
+
+It's important to note that the CUDA samples are _not_ intended as a validation suite for CUDA. They do not cover corner cases, they do not completely cover the
+runtime and driver APIs, are not intended for performance benchmarking, etc. That said, it can sometimes be useful to run all of the samples as a quick sanity check and
+we provide a script to do so, `run_tests.py`.
+
+This Python3 script finds all executables in a subdirectory you choose, matching application names with command line arguments specified in `test_args.json`. It accepts
+the following command line arguments:
+
+| Switch     | Purpose                                                                                                        | Example                 |
+| ---------- | -------------------------------------------------------------------------------------------------------------- | ----------------------- |
+| --dir      | Specify the root directory to search for executables (recursively)                                             | --dir ./build/cpp   |
+| --config   | JSON configuration file for executable arguments                                                               | --config test_args.json |
+| --output   | Output directory for test results (stdout saved to .txt files - directory will be created if it doesn't exist) | --output ./test         |
+| --args     | Global arguments to pass to all executables (not currently used)                                               | --args arg_1 arg_2 ...  |
+| --parallel | Number of applications to execute in parallel.                                                                 | --parallel 8            |
+
+
+Application configurations are loaded from `test_args.json` and matched against executable names (discarding the `.exe` extension on Windows).
+
+The script returns 0 on success, or the first non-zero error code encountered during testing on failure. It will also print a condensed list of samples that failed, if any.
+
+There are three primary modes of configuration:
+
+**Skip**
+
+An executable configured with "skip" will not be executed. These generally rely on having attached graphical displays and are not suited to this kind of automation.
+
+Configuration example:
+```json
+"fluidsGL": {
+    "skip": true
+}
+```
+
+You will see:
+```
+Skipping fluidsGL (marked as skip in config)
+```
+
+**Single Run**
+
+For executables to run one time only with arguments, specify each argument as a list entry. Each entry in the JSON file will be appended to the command line, separated
+by a space.
+
+All applications execute from their current directory, so all paths are relative to the application's location.
+
+Note that if an application needs no arguments, this entry is optional. An executable found without a matching entry in the JSON will just run as `./application` from its
+current directory.
+
+Configuration example:
+```json
+"ptxgen": {
+    "args": [
+        "test.ll",
+        "-arch=compute_75"
+    ]
+}
+```
+
+You will see:
+```
+Running ptxgen
+    Command: ./ptxgen test.ll -arch=compute_75
+    Test completed with return code 0
+```
+
+**Multiple Runs**
+
+For executables to run multiple times with different command line arguments, specify any number of sets of args within a "runs" list.
+
+As with single runs, all applications execute from their current directory, so all paths are relative to the application's location.
+
+Configuration example:
+```json
+"recursiveGaussian": {
+    "runs": [
+        {
+            "args": [
+                "-sigma=10",
+                "-file=data/ref_10.ppm"
+            ]
+        },
+        {
+            "args": [
+                "-sigma=14",
+                "-file=data/ref_14.ppm"
+            ]
+        },
+        {
+            "args": [
+                "-sigma=18",
+                "-file=data/ref_18.ppm"
+            ]
+        },
+        {
+            "args": [
+                "-sigma=22",
+                "-file=data/ref_22.ppm"
+            ]
+        }
+    ]
+}
+```
+
+You will see:
+```
+Running recursiveGaussian (run 1/4)
+    Command: ./recursiveGaussian -sigma=10 -file=data/ref_10.ppm
+    Test completed with return code 0
+Running recursiveGaussian (run 2/4)
+    Command: ./recursiveGaussian -sigma=14 -file=data/ref_14.ppm
+    Test completed with return code 0
+Running recursiveGaussian (run 3/4)
+    Command: ./recursiveGaussian -sigma=18 -file=data/ref_18.ppm
+    Test completed with return code 0
+Running recursiveGaussian (run 4/4)
+    Command: ./recursiveGaussian -sigma=22 -file=data/ref_22.ppm
+    Test completed with return code 0
+```
+
+### Example Usage
+
+Here is an example set of commands to build and test all of the samples.
+
+First, build:
+```bash
+mkdir build
+cd build
+cmake ..
+make -j$(nproc)
+```
+
+Now, return to the samples root directory and run the test script:
+```bash
+cd ..
+python3 run_tests.py --output ./test --dir ./build/cpp --config test_args.json
+```
+
+If all applications run successfully, you will see something similar to this (the specific number of samples will depend on your build type
+and system configuration):
+
+```
+Test Summary:
+Ran 199 test runs for 180 executables.
+All test runs passed!
+```
+
+If some samples fail, you will see something like this:
+
+```
+Test Summary:
+Ran 199 test runs for 180 executables.
+Failed runs (2):
+  bicubicTexture (run 1/5): Failed (code 1)
+  Mandelbrot (run 1/2): Failed (code 1)
+```
+
+You can inspect the stdout logs in the output directory (generally `APM_<application_name>.txt` or `APM_<application_name>.run<n>.txt`) to help
+determine what may have gone wrong from the output logs. Please file issues against the samples repository if you believe a sample is failing
+incorrectly on your system.
+
 ## Samples list
 
-### Samples by OS
+### [0. Introduction](./cpp/0_Introduction/README.md)
+Basic CUDA samples for beginners that illustrate key concepts with using CUDA and CUDA runtime APIs.
 
-#### Linux
-**[warpAggregatedAtomicsCG](./Samples/warpAggregatedAtomicsCG)** | **[conjugateGradientMultiBlockCG](./Samples/conjugateGradientMultiBlockCG)** | **[simpleIPC](./Samples/simpleIPC)** | **[shfl_scan](./Samples/shfl_scan)** |
----|---|---|---|
-**[conjugateGradientCudaGraphs](./Samples/conjugateGradientCudaGraphs)** | **[nvJPEG](./Samples/nvJPEG)** | **[simpleCudaGraphs](./Samples/simpleCudaGraphs)** | **[deviceQuery](./Samples/deviceQuery)** |
-**[simpleVoteIntrinsics](./Samples/simpleVoteIntrinsics)** | **[simpleCUBLASXT](./Samples/simpleCUBLASXT)** | **[UnifiedMemoryPerf](./Samples/UnifiedMemoryPerf)** | **[conjugateGradientMultiDeviceCG](./Samples/conjugateGradientMultiDeviceCG)** |
-**[matrixMulDrv](./Samples/matrixMulDrv)** | **[simpleCUFFT](./Samples/simpleCUFFT)** | **[reduction](./Samples/reduction)** | **[immaTensorCoreGemm](./Samples/immaTensorCoreGemm)** |
-**[bandwidthTest](./Samples/bandwidthTest)** | **[simpleCUBLAS](./Samples/simpleCUBLAS)** | **[cudaTensorCoreGemm](./Samples/cudaTensorCoreGemm)** | **[simpleVulkan](./Samples/simpleVulkan)** |
-**[vectorAdd_nvrtc](./Samples/vectorAdd_nvrtc)** | **[p2pBandwidthLatencyTest](./Samples/p2pBandwidthLatencyTest)** | **[matrixMul](./Samples/matrixMul)** | **[systemWideAtomics](./Samples/systemWideAtomics)** |
+### [1. Utilities](./cpp/1_Utilities/README.md)
+Utility samples that demonstrate how to query device capabilities and measure GPU/CPU bandwidth.
 
-#### Windows
-**[warpAggregatedAtomicsCG](./Samples/warpAggregatedAtomicsCG)** | **[conjugateGradientMultiBlockCG](./Samples/conjugateGradientMultiBlockCG)** | **[simpleIPC](./Samples/simpleIPC)** | **[shfl_scan](./Samples/shfl_scan)** |
----|---|---|---|
-**[conjugateGradientCudaGraphs](./Samples/conjugateGradientCudaGraphs)** | **[simpleD3D12](./Samples/simpleD3D12)** | **[simpleCudaGraphs](./Samples/simpleCudaGraphs)** | **[deviceQuery](./Samples/deviceQuery)** |
-**[simpleVoteIntrinsics](./Samples/simpleVoteIntrinsics)** | **[simpleCUBLASXT](./Samples/simpleCUBLASXT)** | **[UnifiedMemoryPerf](./Samples/UnifiedMemoryPerf)** | **[conjugateGradientMultiDeviceCG](./Samples/conjugateGradientMultiDeviceCG)** |
-**[matrixMulDrv](./Samples/matrixMulDrv)** | **[simpleCUFFT](./Samples/simpleCUFFT)** | **[reduction](./Samples/reduction)** | **[immaTensorCoreGemm](./Samples/immaTensorCoreGemm)** |
-**[bandwidthTest](./Samples/bandwidthTest)** | **[simpleCUBLAS](./Samples/simpleCUBLAS)** | **[cudaTensorCoreGemm](./Samples/cudaTensorCoreGemm)** | **[simpleVulkan](./Samples/simpleVulkan)** |
-**[vectorAdd_nvrtc](./Samples/vectorAdd_nvrtc)** | **[p2pBandwidthLatencyTest](./Samples/p2pBandwidthLatencyTest)** | **[matrixMul](./Samples/matrixMul)** |
+### [2. Concepts and Techniques](./cpp/2_Concepts_and_Techniques/README.md)
+Samples that demonstrate CUDA related concepts and common problem solving techniques.
 
-#### Mac OSX
-**[warpAggregatedAtomicsCG](./Samples/warpAggregatedAtomicsCG)** | **[shfl_scan](./Samples/shfl_scan)** | **[conjugateGradientCudaGraphs](./Samples/conjugateGradientCudaGraphs)** | **[simpleCudaGraphs](./Samples/simpleCudaGraphs)** |
----|---|---|---|
-**[deviceQuery](./Samples/deviceQuery)** | **[simpleVoteIntrinsics](./Samples/simpleVoteIntrinsics)** | **[simpleCUBLASXT](./Samples/simpleCUBLASXT)** | **[UnifiedMemoryPerf](./Samples/UnifiedMemoryPerf)** |
-**[matrixMulDrv](./Samples/matrixMulDrv)** | **[simpleCUFFT](./Samples/simpleCUFFT)** | **[reduction](./Samples/reduction)** | **[bandwidthTest](./Samples/bandwidthTest)** |
-**[simpleCUBLAS](./Samples/simpleCUBLAS)** | **[vectorAdd_nvrtc](./Samples/vectorAdd_nvrtc)** | **[p2pBandwidthLatencyTest](./Samples/p2pBandwidthLatencyTest)** | **[matrixMul](./Samples/matrixMul)** |
+### [3. CUDA Features](./cpp/3_CUDA_Features/README.md)
+Samples that demonstrate CUDA Features (Cooperative Groups, CUDA Dynamic Parallelism, CUDA Graphs etc).
+
+### [4. CUDA Libraries](./cpp/4_CUDA_Libraries/README.md)
+Samples that demonstrate how to use CUDA platform libraries (NPP, NVJPEG, NVGRAPH cuBLAS, cuFFT, cuSPARSE, cuSOLVER and cuRAND).
+
+### [5. Domain Specific](./cpp/5_Domain_Specific/README.md)
+Samples that are specific to domain (Graphics, Finance, Image Processing).
+
+### [6. Performance](./cpp/6_Performance/README.md)
+Samples that demonstrate performance optimization.
+
+### [7. libNVVM](./cpp/7_libNVVM/README.md)
+Samples that demonstrate the use of libNVVVM and NVVM IR.
+
+### [8. Platform Specific](./cpp/8_Platform_Specific/Tegra/README.md)
+Samples that are specific to certain platforms (Tegra, cuDLA, NvMedia, NvSci, OpenGL ES).
+
+### [9. CUDA Tile](./cpp/9_CUDA_Tile/README.md)
+Samples that demonstrate how to use CUDA Tile C++.
 
 ## Dependencies
 
@@ -166,7 +554,9 @@ These third-party dependencies are required by some CUDA samples. If available,
 
 #### FreeImage
 
-FreeImage is an open source imaging library. FreeImage can usually be installed on Linux using your distribution's package manager system. FreeImage can also be downloaded from the [FreeImage website](http://freeimage.sourceforge.net/). FreeImage is also redistributed with the CUDA Samples.
+FreeImage is an open source imaging library. FreeImage can usually be installed on Linux using your distribution's package manager system. FreeImage can also be downloaded from the FreeImage website.
+
+To set up FreeImage on a Windows system, extract the FreeImage DLL distribution into the folder `./Common/FreeImage/Dist/x64` such that it contains the .h and .lib files. Copy the .dll file to the Release/ Debug/ execution folder or pass the FreeImage folder when cmake configuring with the `-DFreeImage_INCLUDE_DIR` and `-DFreeImage_LIBRARY` options.
 
 #### Message Passing Interface
 
@@ -178,7 +568,7 @@ Some samples can only be run on a 64-bit operating system.
 
 #### DirectX
 
-DirectX is a collection of APIs designed to allow development of multimedia applications on Microsoft platforms. For Microsoft platforms, NVIDIA's CUDA Driver supports DirectX. Several CUDA Samples for Windows demonstrates CUDA-DirectX Interoperability, for building such samples one needs to install [Direct X SDK (June 2010 or newer)](http://www.microsoft.com/en-us/download/details.aspx?id=6812) , this is required to be installed on Windows 7, Windows 10 and Windows Server 2008, Other Windows OSes do not need to explicitly install the DirectX SDK.
+DirectX is a collection of APIs designed to allow development of multimedia applications on Microsoft platforms. For Microsoft platforms, NVIDIA's CUDA Driver supports DirectX. Several CUDA Samples for Windows demonstrates CUDA-DirectX Interoperability, for building such samples one needs to install Microsoft Visual Studio 2012 or higher which provides Microsoft Windows SDK for Windows 8.
 
 #### DirectX12
 
@@ -192,13 +582,27 @@ OpenGL is a graphics library used for 2D and 3D rendering. On systems which supp
 
 OpenGL ES is an embedded systems graphics library used for 2D and 3D rendering. On systems which support OpenGL ES, NVIDIA's OpenGL ES implementation is provided with the CUDA Driver.
 
+#### Freeglut
+
+Freeglut is an open-source software library that serves as a replacement for the original OpenGL Utility Toolkit (GLUT). Its primary purpose is to make it easier for developers to create and manage windows containing OpenGL contexts, as well as handle input from devices like the mouse, keyboard, and joystick, across a wide range of platforms. To set up Freeglut on a Windowson on ARM system, you need to download the source from [Freeglut website](https://freeglut.sourceforge.net/), build freeglut on your system, and copy the freeglut.lib into the folder `./Common/lib/x64` and copy the freeglut.dll file into the `./bin/win64/${BUILD_TYPE}` execution folder.
+
 #### Vulkan
 
 Vulkan is a low-overhead, cross-platform 3D graphics and compute API. Vulkan targets high-performance realtime 3D graphics applications such as video games and interactive media across all platforms. On systems which support Vulkan, NVIDIA's Vulkan implementation is provided with the CUDA Driver. For building and running Vulkan applications one needs to install the [Vulkan SDK](https://www.lunarg.com/vulkan-sdk/).
 
+#### GLEW
+
+GLEW (OpenGL Extension Wrangler Library) is a cross-platform, open-source C/C++ library designed to simplify the process of using modern OpenGL features and extensions. Its main function is to dynamically load OpenGL function pointers at runtime, allowing developers to access both core OpenGL functions and additional features provided by hardware vendors, known as extensions. To set up GLEW on a Windows on ARM system, you need to download the source from [GLEW website](https://glew.sourceforge.net/), build GLEW on your system, and copy the glew32.lib into the folder `./Common/lib/x64` and the glew32.dll into the `./bin/win64/${BUILD_TYPE}` execution folder.
+
+#### GLFW
+
+GLFW is a lightweight, open-source library designed for managing OpenGL, OpenGL ES, and Vulkan contexts. It simplifies the process of creating and managing windows, handling user input (keyboard, mouse, and joystick), and working with multiple monitors in a cross-platform manner.
+
+To set up GLFW on a Windows system, Download the pre-built binaries from [GLFW website](https://www.glfw.org/download.html) and extract the zip file into the folder, pass the GLFW include header folder as `-DGLFW_INCLUDE_DIR` and lib folder as `-DGLFW_LIB_DIR` for cmake configuring.
+
 #### OpenMP
 
-OpenMP is an API for multiprocessing programming. OpenMP can be installed using your Linux distribution's package manager system. It usually comes preinstalled with GCC. It can also be found at the [OpenMP website](http://openmp.org/).
+OpenMP is an API for multiprocessing programming. OpenMP can be installed using your Linux distribution's package manager system. It usually comes preinstalled with GCC. It can also be found at the [OpenMP website](http://openmp.org/). For compilers such as clang, make sure OpenMP is enabled when building LLVM by including `openmp` in `LLVM_ENABLE_PROJECTS`. If you use clang (from an installed prefix or directly from an LLVM build tree) with OpenMP enabled, set CMAKE_CXX_COMPILER and CMAKE_CUDA_HOST_COMPILER to that clang++ and let CMake detect OpenMP; extra OpenMP_* CMake variables are usually not needed. When using clang++ directly from an LLVM build tree, you may need to copy the generated `omp.h` into the `include/` directory under the path reported by `clang++ --print-resource-dir` before building the samples. When using an installed clang with OpenMP, if you see libomp.so: cannot open shared object file at runtime, add the directory that contains libomp.so to LD_LIBRARY_PATH (or configure it via ld.so.conf.d) so the dynamic linker can locate the OpenMP runtime.
 
 #### Screen
 
@@ -220,6 +624,14 @@ EGLOutput is a set of EGL extensions which allow EGL to render directly to the d
 
 EGLSync is a set of EGL extensions which provides sync objects that are synchronization primitive, representing events whose completion can be tested or waited upon.
 
+#### NVSCI
+
+NvSci is a set of communication interface libraries out of which CUDA interops with NvSciBuf and NvSciSync. NvSciBuf allows applications to allocate and exchange buffers in memory. NvSciSync allows applications to manage synchronization objects which coordinate when sequences of operations begin and end.
+
+#### NvMedia
+
+NvMedia provides powerful processing of multimedia data for true hardware acceleration across NVIDIA Tegra devices. Applications leverage the NvMedia Application Programming Interface (API) to process the image and video data.
+
 ### CUDA Features
 
 These CUDA features are needed by some CUDA samples. They are provided by either the CUDA Toolkit or CUDA Driver. Some features may not be available on your system.
@@ -280,6 +692,11 @@ NVJPEG library provides high-performance, GPU accelerated JPEG decoding function
 
 NVRTC (CUDA RunTime Compilation) is a runtime compilation library for CUDA C++.
 
+#### NVJITLINK
+
+NVJITLINK is a CUDA runtime library that links multiple GPU device code objects at runtime and enables just‑in‑time link‑time optimization (JIT LTO).
+It can take device code from tools such as NVCC and NVRTC, link and optimize it on the fly, and produce the final GPU binary.For more details, see: https://docs.nvidia.com/cuda/nvjitlink/index.html
+
 #### Stream Priorities
 
 Stream Priorities allows the creation of streams with specified priorities. Stream Priorities is only available on GPUs with SM architecture of 3.5 or above.
@@ -296,6 +713,10 @@ FP16 is a 16-bit floating-point format. One bit is used for the sign, five bits
 
 NVCC support of [C++11 features](https://en.wikipedia.org/wiki/C++11).
 
+#### CMake
+
+The libNVVM samples are built using [CMake](https://cmake.org/) 3.10 or later.
+
 ## Contributors Guide
 
 We welcome your input on issues and suggestions for samples. At this time we are not accepting contributions from the public, check back here as we evolve our contribution model.
@@ -308,6 +729,9 @@ Answers to frequently asked questions about CUDA can be found at http://develope
 
 ## References
 
-*   [CUDA Programming Guide](http://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html)
-*   [Accelerated Computing Blog](https://devblogs.nvidia.com/category/accelerated-computing/)
+*   [CUDA Programming Guide](https://docs.nvidia.com/cuda/cuda-programming-guide/index.html)
+*   [Accelerated Computing Blog](https://developer.nvidia.com/blog/?tags=accelerated-computing)
 
+## Attributions
+
+*   Teapot image is obtained from [Wikimedia](https://en.wikipedia.org/wiki/File:Original_Utah_Teapot.jpg) and is licensed under the Creative Commons [Attribution-Share Alike 2.0](https://creativecommons.org/licenses/by-sa/2.0/deed.en) Generic license. The image is modified for samples use cases.

Samples/UnifiedMemoryPerf/Makefile

@@ -1,316 +0,0 @@
-################################################################################
-# Copyright (c) 2018, 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 ppc64le armv7l))
-    ifneq ($(TARGET_ARCH),$(HOST_ARCH))
-        ifneq (,$(filter $(TARGET_ARCH),x86_64 aarch64 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
-ifneq ($(TARGET_ARCH),$(HOST_ARCH))
-    ifeq (,$(filter $(HOST_ARCH)-$(TARGET_ARCH),aarch64-armv7l x86_64-armv7l x86_64-aarch64 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/aarch64-unknown-nto-qnx7.0.0-g++
-        else ifeq ($(TARGET_OS), android)
-            HOST_COMPILER ?= aarch64-linux-android-clang++
-        endif
-    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)/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
-            CCFLAGS += -isystem=$(TARGET_FS)/usr/include/aarch64-linux-gnu
-        endif
-    endif
-endif
-
-ifeq ($(TARGET_OS),qnx)
-    CCFLAGS += -DWIN_INTERFACE_CUSTOM
-    LDFLAGS += -lsocket
-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),armv7l-android)
-    CUDA_INSTALL_TARGET_DIR = targets/armv7-linux-androideabi/
-else ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-android)
-    CUDA_INSTALL_TARGET_DIR = targets/aarch64-linux-androideabi/
-else ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-qnx)
-    CUDA_INSTALL_TARGET_DIR = targets/ARMv7-linux-QNX/
-else ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-qnx)
-    CUDA_INSTALL_TARGET_DIR = targets/aarch64-qnx/
-else ifeq ($(TARGET_ARCH),ppc64le)
-    CUDA_INSTALL_TARGET_DIR = targets/ppc64le-linux/
-endif
-
-# Debug build flags
-ifeq ($(dbg),1)
-      NVCCFLAGS += -g -G
-      BUILD_TYPE := debug
-else
-      BUILD_TYPE := release
-endif
-
-ALL_CCFLAGS :=
-ALL_CCFLAGS += $(NVCCFLAGS)
-ALL_CCFLAGS += $(EXTRA_NVCCFLAGS)
-ALL_CCFLAGS += $(addprefix -Xcompiler ,$(CCFLAGS))
-ALL_CCFLAGS += $(addprefix -Xcompiler ,$(EXTRA_CCFLAGS))
-
-SAMPLE_ENABLED := 1
-
-# This sample is not supported on QNX
-ifeq ($(TARGET_OS),qnx)
-  $(info >>> WARNING - UnifiedMemoryPerf is not supported on QNX - waiving sample <<<)
-  SAMPLE_ENABLED := 0
-endif
-
-ALL_LDFLAGS :=
-ALL_LDFLAGS += $(ALL_CCFLAGS)
-ALL_LDFLAGS += $(addprefix -Xlinker ,$(LDFLAGS))
-ALL_LDFLAGS += $(addprefix -Xlinker ,$(EXTRA_LDFLAGS))
-
-# Common includes and paths for CUDA
-INCLUDES  := -I../../Common
-LIBRARIES :=
-
-################################################################################
-
-# Gencode arguments
-ifeq ($(TARGET_ARCH),$(filter $(TARGET_ARCH),armv7l aarch64))
-SMS ?= 30 35 37 50 52 60 61 70 72 75
-else
-SMS ?= 30 35 37 50 52 60 61 70 75
-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
-
-ifeq ($(SAMPLE_ENABLED),0)
-EXEC ?= @echo "[@]"
-endif
-
-################################################################################
-
-# Target rules
-all: build
-
-build: UnifiedMemoryPerf
-
-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
-
-commonKernels.o:commonKernels.cu
-	$(EXEC) $(NVCC) $(INCLUDES) $(ALL_CCFLAGS) $(GENCODE_FLAGS) -o $@ -c $<
-
-helperFunctions.o:helperFunctions.cpp
-	$(EXEC) $(NVCC) $(INCLUDES) $(ALL_CCFLAGS) $(GENCODE_FLAGS) -o $@ -c $<
-
-matrixMultiplyPerf.o:matrixMultiplyPerf.cu
-	$(EXEC) $(NVCC) $(INCLUDES) $(ALL_CCFLAGS) $(GENCODE_FLAGS) -o $@ -c $<
-
-UnifiedMemoryPerf: commonKernels.o helperFunctions.o matrixMultiplyPerf.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) ./UnifiedMemoryPerf
-
-clean:
-	rm -f UnifiedMemoryPerf commonKernels.o helperFunctions.o matrixMultiplyPerf.o
-	rm -rf ../../bin/$(TARGET_ARCH)/$(TARGET_OS)/$(BUILD_TYPE)/UnifiedMemoryPerf
-
-clobber: clean

Samples/UnifiedMemoryPerf/NsightEclipse.xml

@@ -1,85 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?> 
-<!DOCTYPE entry SYSTEM "SamplesInfo.dtd">
-<entry>
-  <name>UnifiedMemoryPerf</name>
-  <cuda_api_list>
-    <toolkit>cudaMallocManaged</toolkit>
-    <toolkit>cudaStreamAttachMemAsync</toolkit>
-    <toolkit>cudaMemcpyAsync</toolkit>
-    <toolkit>cudaMallocHost</toolkit>
-    <toolkit>cudaMalloc</toolkit>
-  </cuda_api_list>
-  <description><![CDATA[This sample demonstrates the performance comparision using matrix multiplication kernel of Unified Memory with/without hints and other types of memory like zero copy buffers, pageable, pagelocked memory performing synchronous and Asynchronous transfers on a single GPU.]]></description>
-  <devicecompilation>whole</devicecompilation>
-  <includepaths>
-    <path>./</path>
-    <path>../</path>
-    <path>../../common/inc</path>
-  </includepaths>
-  <keyconcepts>
-    <concept level="basic">CUDA Systems Integration</concept>
-    <concept level="basic">Unified Memory</concept>
-    <concept level="basic">CUDA Streams and Events</concept>
-    <concept level="basic">Pinned System Paged Memory</concept>
-  </keyconcepts>
-  <keywords>
-    <keyword>CUDA</keyword>
-    <keyword>Unified Memory</keyword>
-    <keyword>Pinned Memory</keyword>
-    <keyword>Zero copy buffer</keyword>
-    <keyword>UVM</keyword>
-    <keyword>Streams</keyword>
-  </keywords>
-  <libraries>
-  </libraries>
-  <librarypaths>
-  </librarypaths>
-  <nsight_eclipse>true</nsight_eclipse>
-  <primary_file>matrixMultiplyPerf.cu</primary_file>
-  <required_dependencies>
-    <dependency>UVM</dependency>
-  </required_dependencies>
-  <scopes>
-    <scope>1:CUDA Basic Topics</scope>
-    <scope>1:CUDA Systems Integration</scope>
-    <scope>1:Unified Memory</scope>
-  </scopes>
-  <sm-arch>sm30</sm-arch>
-  <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>
-  <supported_envs>
-    <env>
-      <arch>x86_64</arch>
-      <platform>linux</platform>
-    </env>
-    <env>
-      <arch>x86_64</arch>
-      <platform>macosx</platform>
-    </env>
-    <env>
-      <platform>windows7</platform>
-    </env>
-    <env>
-      <arch>arm</arch>
-    </env>
-    <env>
-      <arch>aarch64</arch>
-    </env>
-    <env>
-      <arch>ppc64le</arch>
-      <platform>linux</platform>
-    </env>
-  </supported_envs>
-  <supported_sm_architectures>
-    <from>3.0</from>
-  </supported_sm_architectures>
-  <title>Unified and other CUDA Memories Performance</title>
-  <type>exe</type>
-</entry>

Samples/UnifiedMemoryPerf/README.md

@@ -1,98 +0,0 @@
-# UnifiedMemoryPerf - Unified and other CUDA Memories Performance
-
-## Description
-
-This sample demonstrates the performance comparision using matrix multiplication kernel of Unified Memory with/without hints and other types of memory like zero copy buffers, pageable, pagelocked memory performing synchronous and Asynchronous transfers on a single GPU.
-
-## Key Concepts
-
-CUDA Systems Integration, Unified Memory, CUDA Streams and Events, Pinned System Paged Memory
-
-## Supported SM Architectures
-
-[SM 3.0 ](https://developer.nvidia.com/cuda-gpus)  [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)
-
-## Supported OSes
-
-Linux, Windows, MacOSX
-
-## Supported CPU Architecture
-
-x86_64, ppc64le, armv7l, aarch64
-
-## CUDA APIs involved
-
-### [CUDA Runtime API](http://docs.nvidia.com/cuda/cuda-runtime-api/index.html)
-cudaMallocManaged, cudaStreamAttachMemAsync, cudaMemcpyAsync, cudaMallocHost, cudaMalloc
-
-## Dependencies needed to build/run
-[UVM](../../README.md#uvm)
-
-## Prerequisites
-
-Download and install the [CUDA Toolkit 10.1](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, aarch64.
-    By default, TARGET_ARCH is set to HOST_ARCH. On a x86_64 machine, not setting TARGET_ARCH is the equivalent of setting TARGET_ARCH=x86_64.<br/>
-`$ make TARGET_ARCH=x86_64` <br/> `$ make TARGET_ARCH=ppc64le` <br/> `$ make TARGET_ARCH=armv7l` <br/> `$ make TARGET_ARCH=aarch64` <br/>
-    See [here](http://docs.nvidia.com/cuda/cuda-samples/index.html#cross-samples) for more details.
-*   **dbg=1** - build with debug symbols
-    ```
-    $ make dbg=1
-    ```
-*   **SMS="A B ..."** - override the SM architectures for which the sample will be built, where `"A B ..."` is a space-delimited list of SM architectures. For example, to generate SASS for SM 50 and SM 60, use `SMS="50 60"`.
-    ```
-    $ make SMS="50 60"
-    ```
-
-*  **HOST_COMPILER=<host_compiler>** - override the default g++ host compiler. See the [Linux Installation Guide](http://docs.nvidia.com/cuda/cuda-installation-guide-linux/index.html#system-requirements) for a list of supported host compilers.
-```
-    $ make HOST_COMPILER=g++
-```
-
-### Mac
-The Mac samples are built using makefiles. To use the makefiles, change directory into the sample directory you wish to build, and run make:
-```
-$ cd <sample_dir>
-$ make
-```
-
-The samples makefiles can take advantage of certain options:
-
-*  **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="A B ..."
-    ```
-
-*  **HOST_COMPILER=<host_compiler>** - override the default clang host compiler. See the [Mac Installation Guide](http://docs.nvidia.com/cuda/cuda-installation-guide-mac-os-x/index.html#system-requirements) for a list of supported host compilers.
-    ```
-    $ make HOST_COMPILER=clang
-    ```
-
-## References (for more details)
-

Samples/UnifiedMemoryPerf/UnifiedMemoryPerf_vs2012.sln

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

Samples/UnifiedMemoryPerf/UnifiedMemoryPerf_vs2012.vcxproj

@@ -1,110 +0,0 @@
-<?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>UnifiedMemoryPerf_vs2012</RootNamespace>
-    <ProjectName>UnifiedMemoryPerf</ProjectName>
-    <CudaToolkitCustomDir />
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup>
-    <ConfigurationType>Application</ConfigurationType>
-    <CharacterSet>MultiByte</CharacterSet>
-    <PlatformToolset>v110</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 10.1.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)/UnifiedMemoryPerf.exe</OutputFile>
-    </Link>
-    <CudaCompile>
-      <CodeGeneration>compute_30,sm_30;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;</CodeGeneration>
-      <AdditionalOptions>-Xcompiler "/wd 4819" %(AdditionalOptions)</AdditionalOptions>
-      <Include>./;../../Common</Include>
-      <Defines>WIN32</Defines>
-    </CudaCompile>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)'=='Debug'">
-    <ClCompile>
-      <Optimization>Disabled</Optimization>
-      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
-    </ClCompile>
-    <Link>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
-    </Link>
-    <CudaCompile>
-      <Runtime>MTd</Runtime>
-      <TargetMachinePlatform>64</TargetMachinePlatform>
-    </CudaCompile>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)'=='Release'">
-    <ClCompile>
-      <Optimization>MaxSpeed</Optimization>
-      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
-    </ClCompile>
-    <Link>
-      <GenerateDebugInformation>false</GenerateDebugInformation>
-      <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
-    </Link>
-    <CudaCompile>
-      <Runtime>MT</Runtime>
-      <TargetMachinePlatform>64</TargetMachinePlatform>
-    </CudaCompile>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <CudaCompile Include="commonKernels.cu" />
-    <ClCompile Include="helperFunctions.cpp" />
-    <CudaCompile Include="matrixMultiplyPerf.cu" />
-    <ClInclude Include="commonDefs.hpp" />
-    <ClInclude Include="commonKernels.hpp" />
-  </ItemGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-    <Import Project="$(CUDAPropsPath)\CUDA 10.1.targets" />
-  </ImportGroup>
-</Project>

Samples/UnifiedMemoryPerf/UnifiedMemoryPerf_vs2013.sln

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

Samples/UnifiedMemoryPerf/UnifiedMemoryPerf_vs2013.vcxproj

@@ -1,110 +0,0 @@
-<?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>UnifiedMemoryPerf_vs2013</RootNamespace>
-    <ProjectName>UnifiedMemoryPerf</ProjectName>
-    <CudaToolkitCustomDir />
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup>
-    <ConfigurationType>Application</ConfigurationType>
-    <CharacterSet>MultiByte</CharacterSet>
-    <PlatformToolset>v120</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 10.1.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)/UnifiedMemoryPerf.exe</OutputFile>
-    </Link>
-    <CudaCompile>
-      <CodeGeneration>compute_30,sm_30;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;</CodeGeneration>
-      <AdditionalOptions>-Xcompiler "/wd 4819" %(AdditionalOptions)</AdditionalOptions>
-      <Include>./;../../Common</Include>
-      <Defines>WIN32</Defines>
-    </CudaCompile>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)'=='Debug'">
-    <ClCompile>
-      <Optimization>Disabled</Optimization>
-      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
-    </ClCompile>
-    <Link>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
-    </Link>
-    <CudaCompile>
-      <Runtime>MTd</Runtime>
-      <TargetMachinePlatform>64</TargetMachinePlatform>
-    </CudaCompile>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)'=='Release'">
-    <ClCompile>
-      <Optimization>MaxSpeed</Optimization>
-      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
-    </ClCompile>
-    <Link>
-      <GenerateDebugInformation>false</GenerateDebugInformation>
-      <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
-    </Link>
-    <CudaCompile>
-      <Runtime>MT</Runtime>
-      <TargetMachinePlatform>64</TargetMachinePlatform>
-    </CudaCompile>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <CudaCompile Include="commonKernels.cu" />
-    <ClCompile Include="helperFunctions.cpp" />
-    <CudaCompile Include="matrixMultiplyPerf.cu" />
-    <ClInclude Include="commonDefs.hpp" />
-    <ClInclude Include="commonKernels.hpp" />
-  </ItemGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-    <Import Project="$(CUDAPropsPath)\CUDA 10.1.targets" />
-  </ImportGroup>
-</Project>

Samples/UnifiedMemoryPerf/UnifiedMemoryPerf_vs2015.sln

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

Samples/UnifiedMemoryPerf/UnifiedMemoryPerf_vs2015.vcxproj

@@ -1,110 +0,0 @@
-<?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>UnifiedMemoryPerf_vs2015</RootNamespace>
-    <ProjectName>UnifiedMemoryPerf</ProjectName>
-    <CudaToolkitCustomDir />
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup>
-    <ConfigurationType>Application</ConfigurationType>
-    <CharacterSet>MultiByte</CharacterSet>
-    <PlatformToolset>v140</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 10.1.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)/UnifiedMemoryPerf.exe</OutputFile>
-    </Link>
-    <CudaCompile>
-      <CodeGeneration>compute_30,sm_30;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;</CodeGeneration>
-      <AdditionalOptions>-Xcompiler "/wd 4819" %(AdditionalOptions)</AdditionalOptions>
-      <Include>./;../../Common</Include>
-      <Defines>WIN32</Defines>
-    </CudaCompile>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)'=='Debug'">
-    <ClCompile>
-      <Optimization>Disabled</Optimization>
-      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
-    </ClCompile>
-    <Link>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
-    </Link>
-    <CudaCompile>
-      <Runtime>MTd</Runtime>
-      <TargetMachinePlatform>64</TargetMachinePlatform>
-    </CudaCompile>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)'=='Release'">
-    <ClCompile>
-      <Optimization>MaxSpeed</Optimization>
-      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
-    </ClCompile>
-    <Link>
-      <GenerateDebugInformation>false</GenerateDebugInformation>
-      <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
-    </Link>
-    <CudaCompile>
-      <Runtime>MT</Runtime>
-      <TargetMachinePlatform>64</TargetMachinePlatform>
-    </CudaCompile>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <CudaCompile Include="commonKernels.cu" />
-    <ClCompile Include="helperFunctions.cpp" />
-    <CudaCompile Include="matrixMultiplyPerf.cu" />
-    <ClInclude Include="commonDefs.hpp" />
-    <ClInclude Include="commonKernels.hpp" />
-  </ItemGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-    <Import Project="$(CUDAPropsPath)\CUDA 10.1.targets" />
-  </ImportGroup>
-</Project>

Samples/UnifiedMemoryPerf/UnifiedMemoryPerf_vs2017.sln

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

Samples/UnifiedMemoryPerf/UnifiedMemoryPerf_vs2017.vcxproj

@@ -1,111 +0,0 @@
-<?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>UnifiedMemoryPerf_vs2017</RootNamespace>
-    <ProjectName>UnifiedMemoryPerf</ProjectName>
-    <CudaToolkitCustomDir />
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup>
-    <ConfigurationType>Application</ConfigurationType>
-    <CharacterSet>MultiByte</CharacterSet>
-    <PlatformToolset>v141</PlatformToolset>
-	<WindowsTargetPlatformVersion>10.0.15063.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 10.1.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)/UnifiedMemoryPerf.exe</OutputFile>
-    </Link>
-    <CudaCompile>
-      <CodeGeneration>compute_30,sm_30;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;</CodeGeneration>
-      <AdditionalOptions>-Xcompiler "/wd 4819" %(AdditionalOptions)</AdditionalOptions>
-      <Include>./;../../Common</Include>
-      <Defines>WIN32</Defines>
-    </CudaCompile>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)'=='Debug'">
-    <ClCompile>
-      <Optimization>Disabled</Optimization>
-      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
-    </ClCompile>
-    <Link>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
-    </Link>
-    <CudaCompile>
-      <Runtime>MTd</Runtime>
-      <TargetMachinePlatform>64</TargetMachinePlatform>
-    </CudaCompile>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)'=='Release'">
-    <ClCompile>
-      <Optimization>MaxSpeed</Optimization>
-      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
-    </ClCompile>
-    <Link>
-      <GenerateDebugInformation>false</GenerateDebugInformation>
-      <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
-    </Link>
-    <CudaCompile>
-      <Runtime>MT</Runtime>
-      <TargetMachinePlatform>64</TargetMachinePlatform>
-    </CudaCompile>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <CudaCompile Include="commonKernels.cu" />
-    <ClCompile Include="helperFunctions.cpp" />
-    <CudaCompile Include="matrixMultiplyPerf.cu" />
-    <ClInclude Include="commonDefs.hpp" />
-    <ClInclude Include="commonKernels.hpp" />
-  </ItemGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-    <Import Project="$(CUDAPropsPath)\CUDA 10.1.targets" />
-  </ImportGroup>
-</Project>

Samples/UnifiedMemoryPerf/helperFunctions.cpp

@@ -1,303 +0,0 @@
-/* Copyright (c) 2018, 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 <stdio.h>
-#include <string.h>
-#include "commonDefs.hpp"
-#define CU_INIT_UUID
-#include <cmath>
-
-#define UNITS_Time "ms"
-#define UNITS_BW "MB/s"
-#define KB_str "KB"
-#define MB_str "MB"
-
-struct resultsData {
-  char resultsName[64];
-  struct testResults *results;
-  // this has MEMALLOC_TYPE_COUNT * results->numSizesToTest *
-  // results->numMeasurements elements
-  double **runTimesInMs[MEMALLOC_TYPE_COUNT];
-  double *averageRunTimesInMs[MEMALLOC_TYPE_COUNT];
-  double *stdDevRunTimesInMs[MEMALLOC_TYPE_COUNT];
-  double *stdDevBandwidthInMBps[MEMALLOC_TYPE_COUNT];
-  bool printOnlyInVerbose;
-  bool reportAsBandwidth;
-  struct resultsData *next;
-};
-
-struct testResults {
-  char testName[64];
-  unsigned int numMeasurements;
-  unsigned long *sizesToTest;
-  unsigned int numSizesToTest;
-  struct resultsData *resultsDataHead;
-  struct resultsData *resultsDataTail;
-};
-
-unsigned int findNumSizesToTest(unsigned int minSize, unsigned int maxSize,
-                                unsigned int multiplier) {
-  unsigned int numSizesToTest = 0;
-  while (minSize <= maxSize) {
-    numSizesToTest++;
-    minSize *= multiplier;
-  }
-  return numSizesToTest;
-}
-
-int compareDoubles(const void *ptr1, const void *ptr2) {
-  return (*(double *)ptr1 > *(double *)ptr2) ? 1 : -1;
-}
-
-static inline double getTimeOrBandwidth(double runTimeInMs, unsigned long size,
-                                        bool getBandwidth) {
-  return (getBandwidth) ? (1000 * (size / runTimeInMs)) / ONE_MB : runTimeInMs;
-}
-
-void createAndInitTestResults(struct testResults **ptrResults,
-                              const char *testName,
-                              unsigned int numMeasurements,
-                              unsigned int numSizesToTest) {
-  unsigned int i;
-  struct testResults *results;
-  results = (struct testResults *)malloc(sizeof(struct testResults));
-  memset(results, 0, sizeof(struct testResults));
-  strcpy(results->testName, testName);
-  results->numMeasurements = numMeasurements;
-  results->numSizesToTest = numSizesToTest;
-  results->sizesToTest =
-      (unsigned long *)malloc(numSizesToTest * sizeof(unsigned long));
-  results->resultsDataHead = NULL;
-  results->resultsDataTail = NULL;
-
-  *ptrResults = results;
-}
-
-unsigned long *getPtrSizesToTest(struct testResults *results) {
-  return results->sizesToTest;
-}
-
-void createResultDataAndAddToTestResults(struct resultsData **ptrData,
-                                         struct testResults *results,
-                                         const char *resultsName,
-                                         bool printOnlyInVerbose,
-                                         bool reportAsBandwidth) {
-  unsigned int i, j;
-  struct resultsData *data;
-  data = (struct resultsData *)malloc(sizeof(struct resultsData));
-  memset(data, 0, sizeof(struct resultsData));
-  strcpy(data->resultsName, resultsName);
-  data->results = results;
-  for (i = 0; i < MEMALLOC_TYPE_COUNT; i++) {
-    data->runTimesInMs[i] =
-        (double **)malloc(results->numSizesToTest * sizeof(double *));
-    for (j = 0; j < results->numSizesToTest; j++) {
-      data->runTimesInMs[i][j] =
-          (double *)malloc(results->numMeasurements * sizeof(double));
-    }
-    data->averageRunTimesInMs[i] =
-        (double *)malloc(results->numSizesToTest * sizeof(double));
-    data->stdDevRunTimesInMs[i] =
-        (double *)malloc(results->numSizesToTest * sizeof(double));
-    data->stdDevBandwidthInMBps[i] =
-        (double *)malloc(results->numSizesToTest * sizeof(double));
-  }
-  data->printOnlyInVerbose = printOnlyInVerbose;
-  data->reportAsBandwidth = reportAsBandwidth;
-  data->next = NULL;
-  *ptrData = data;
-  if (results->resultsDataHead == NULL) {
-    results->resultsDataHead = data;
-    results->resultsDataTail = data;
-  } else {
-    results->resultsDataTail->next = data;
-    results->resultsDataTail = data;
-  }
-}
-
-double *getPtrRunTimesInMs(struct resultsData *data, int allocType,
-                           int sizeIndex) {
-  return data->runTimesInMs[allocType][sizeIndex];
-}
-
-void freeTestResultsAndAllResultsData(struct testResults *results) {
-  struct resultsData *data, *dataToFree;
-  unsigned int i, j;
-  for (data = results->resultsDataHead; data != NULL;) {
-    for (i = 0; i < MEMALLOC_TYPE_COUNT; i++) {
-      for (j = 0; j < results->numSizesToTest; j++) {
-        free(data->runTimesInMs[i][j]);
-      }
-      free(data->runTimesInMs[i]);
-      free(data->averageRunTimesInMs[i]);
-      free(data->stdDevRunTimesInMs[i]);
-      free(data->stdDevBandwidthInMBps[i]);
-    }
-    dataToFree = data;
-    data = data->next;
-    free(dataToFree);
-  }
-  free(results->sizesToTest);
-  free(results);
-}
-
-void calculateAverageAndStdDev(double *pAverage, double *pStdDev,
-                               double *allResults, unsigned int count) {
-  unsigned int i;
-  double average = 0.0;
-  double stdDev = 0.0;
-  for (i = 0; i < count; i++) {
-    average += allResults[i];
-  }
-  average /= count;
-  for (i = 0; i < count; i++) {
-    stdDev += (allResults[i] - average) * (allResults[i] - average);
-  }
-  stdDev /= count;
-  stdDev = sqrt(stdDev);
-  *pAverage = average;
-  *pStdDev = (average == 0.0) ? 0.0 : ((100.0 * stdDev) / average);
-}
-
-void calculateStdDevBandwidth(double *pStdDev, double *allResults,
-                              unsigned int count, unsigned long size) {
-  unsigned int i;
-  double bandwidth;
-  double average = 0.0;
-  double stdDev = 0.0;
-  for (i = 0; i < count; i++) {
-    bandwidth = (1000 * (size / allResults[i])) / ONE_MB;
-    average += bandwidth;
-  }
-  average /= count;
-  for (i = 0; i < count; i++) {
-    bandwidth = (1000 * (size / allResults[i])) / ONE_MB;
-    stdDev += (bandwidth - average) * (bandwidth - average);
-  }
-  stdDev /= count;
-  stdDev = sqrt(stdDev);
-  *pStdDev = (average == 0.0) ? 0.0 : ((100.0 * stdDev) / average);
-}
-
-void printTimesInTableFormat(struct testResults *results,
-                             struct resultsData *data, bool printAverage,
-                             bool printStdDev) {
-  unsigned int i, j;
-  bool printStdDevBandwidth = printStdDev && data->reportAsBandwidth;
-  printf("Size_KB");
-  for (i = 0; i < MEMALLOC_TYPE_COUNT; i++) {
-    printf("\t%7s", memAllocTypeShortStr[i]);
-  }
-  printf("\n");
-  for (j = 0; j < results->numSizesToTest; j++) {
-    printf("%lu", results->sizesToTest[j] / ONE_KB);
-    for (i = 0; i < MEMALLOC_TYPE_COUNT; i++) {
-      printf(data->reportAsBandwidth ? "\t%7.2lf" : "\t%7.3lf",
-             printStdDevBandwidth
-                 ? data->stdDevBandwidthInMBps[i][j]
-                 : getTimeOrBandwidth(
-                       printAverage ? data->averageRunTimesInMs[i][j]
-                                    : data->stdDevRunTimesInMs[i][j],
-                       results->sizesToTest[j], data->reportAsBandwidth));
-    }
-    printf("\n");
-  }
-}
-
-void printAllResultsInVerboseMode(struct testResults *results,
-                                  struct resultsData *data) {
-  unsigned int i, j, k;
-  for (i = 0; i < MEMALLOC_TYPE_COUNT; i++) {
-    printf("Verbose mode, printing all results for %s\n", memAllocTypeStr[i]);
-    printf("Instance");
-    for (j = 0; j < results->numSizesToTest; j++) {
-      printf("\t%lu", results->sizesToTest[j] / ONE_KB);
-    }
-    printf("\n");
-    for (k = 0; k < results->numMeasurements; k++) {
-      printf("%u", k);
-      for (j = 0; j < results->numSizesToTest; j++) {
-        printf(data->reportAsBandwidth ? "\t%7.2lf" : "\t%7.3lf",
-               getTimeOrBandwidth(data->runTimesInMs[i][j][k],
-                                  results->sizesToTest[j],
-                                  data->reportAsBandwidth));
-      }
-      printf("\n");
-    }
-  }
-}
-
-void printResults(struct testResults *results,
-                  bool print_launch_transfer_results,
-                  bool print_std_deviation) {
-  char vulcanPrint[256];
-  char resultNameNoSpaces[64];
-  unsigned int i, j, k;
-  struct resultsData *resultsIter;
-  bool sizeGreaterThan1MB;
-  for (resultsIter = results->resultsDataHead; resultsIter != NULL;
-       resultsIter = resultsIter->next) {
-    if (!verboseResults && resultsIter->printOnlyInVerbose) {
-      continue;
-    }
-    if (!print_launch_transfer_results) {
-      if (!(strcmp(resultsIter->resultsName, "Overall Time") == 0)) {
-        continue;
-      }
-    }
-    // regular print
-    printf("\n%s For %s ", resultsIter->resultsName, results->testName);
-    printf("\n");
-    for (j = 0; j < results->numSizesToTest; j++) {
-      for (i = 0; i < MEMALLOC_TYPE_COUNT; i++) {
-        calculateAverageAndStdDev(&resultsIter->averageRunTimesInMs[i][j],
-                                  &resultsIter->stdDevRunTimesInMs[i][j],
-                                  resultsIter->runTimesInMs[i][j],
-                                  results->numMeasurements);
-        if (resultsIter->reportAsBandwidth) {
-          calculateStdDevBandwidth(&resultsIter->stdDevBandwidthInMBps[i][j],
-                                   resultsIter->runTimesInMs[i][j],
-                                   results->numMeasurements,
-                                   results->sizesToTest[j]);
-        }
-      }
-    }
-    printf("\nPrinting Average of %u measurements in (%s)\n",
-           results->numMeasurements,
-           resultsIter->reportAsBandwidth ? UNITS_BW : UNITS_Time);
-    printTimesInTableFormat(results, resultsIter, true, false);
-    if (print_std_deviation) {
-      printf(
-          "\nPrinting Standard Deviation as %% of average of %u measurements\n",
-          results->numMeasurements);
-      printTimesInTableFormat(results, resultsIter, false, true);
-    }
-    if (verboseResults) {
-      printAllResultsInVerboseMode(results, resultsIter);
-    }
-  }
-}

Samples/UnifiedMemoryPerf/matrixMultiplyPerf.cu

@@ -1,697 +0,0 @@
-/* Copyright (c) 2018, 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 <helper_cuda.h>
-#include <helper_timer.h>
-#include "commonDefs.hpp"
-#include "commonKernels.hpp"
-
-#define VERIFY_GPU_CORRECTNESS 0
-
-size_t maxSampleSizeInMb = 64;
-int numKernelRuns = 100;
-int verboseResults = 0;
-
-const char *memAllocTypeStr[MEMALLOC_TYPE_COUNT] = {
-    "Managed_Memory_With_Hints",
-    "Managed_Memory_With_Hints_FullyAsync",
-    "Managed_Memory_NoHints",
-    "Zero_Copy",
-    "Memcpy_HostMalloc_DeviceCudaMalloc",
-    "MemcpyAsync_HostMalloc_DeviceCudaMalloc",
-    "Memcpy_HostCudaHostAlloc_DeviceCudaMalloc",
-    "MemcpyAsync_HostCudaHostAlloc_DeviceCudaMalloc"};
-
-const char *memAllocTypeShortStr[MEMALLOC_TYPE_COUNT] = {
-    "UMhint",   // Managed Memory With Hints
-    "UMhntAs",  // Managed Memory With_Hints Async
-    "UMeasy",   // Managed_Memory with No Hints
-    "0Copy",    // Zero Copy
-    "MemCopy",  // USE HOST PAGEABLE AND DEVICE_MEMORY
-    "CpAsync",  // USE HOST PAGEABLE AND DEVICE_MEMORY ASYNC
-    "CpHpglk",  // USE HOST PAGELOCKED AND DEVICE MEMORY
-    "CpPglAs"   // USE HOST PAGELOCKED AND DEVICE MEMORY ASYNC
-};
-
-static float RandFloat(float low, float high) {
-  float t = (float)rand() / (float)RAND_MAX;
-  return (1.0f - t) * low + t * high;
-}
-
-void fillMatrixWithRandomValues(float *matrix, unsigned int matrixDim) {
-  unsigned int i, j;
-  for (i = 0; i < matrixDim; ++i) {
-    for (j = 0; j < matrixDim; ++j) {
-      matrix[j + i * matrixDim] = RandFloat(0.0f, 10.0f);
-    }
-  }
-}
-
-#if VERIFY_GPU_CORRECTNESS
-void verifyMatrixMultiplyCorrectness(float *C, float *A, float *B,
-                                     unsigned int matrixDim) {
-  unsigned int i, j, k, numErrors = 0;
-  for (i = 0; i < matrixDim; ++i) {
-    for (j = 0; j < matrixDim; ++j) {
-      float result = 0.0f;
-      for (k = 0; k < matrixDim; ++k) {
-        result += A[k + i * matrixDim] * B[j + k * matrixDim];
-      }
-      if (fabs(C[j + i * matrixDim] - result) > 0.001 * matrixDim) {
-        printf("At [%u, %u]: Expected %f, Found %f\n", i, j, result,
-               C[j + i * matrixDim]);
-        ++numErrors;
-      }
-    }
-  }
-  if (numErrors != 0) {
-    printf("%d value mismatches occured\n", numErrors);
-    fflush(stdout);
-    exit(EXIT_FAILURE);  // exit since value mismatches occured
-  }
-}
-#endif
-
-void copyMatrix(float *dstMatrix, float *srcMatrix, unsigned int matrixDim) {
-  size_t size = matrixDim * matrixDim * sizeof(float);
-  memcpy(dstMatrix, srcMatrix, size);
-}
-
-void verifyMatrixData(float *expectedData, float *observedData,
-                      unsigned int matrixDim) {
-  unsigned int i, j, numErrors = 0;
-  for (i = 0; i < matrixDim; ++i) {
-    for (j = 0; j < matrixDim; ++j) {
-      if (expectedData[j + i * matrixDim] != observedData[j + i * matrixDim]) {
-        ++numErrors;
-        if (verboseResults) {
-          printf("At [%u, %u]: Expected %f, Found %f\n", i, j,
-                 expectedData[j + i * matrixDim],
-                 observedData[j + i * matrixDim]);
-        }
-      }
-    }
-  }
-  if (numErrors != 0) {
-    printf("%d value mismatches occured\n", numErrors);
-    fflush(stdout);
-    exit(EXIT_FAILURE);  // exit since value mismatches occured
-  }
-}
-
-#define BLOCK_SIZE 32
-__global__ void matrixMultiplyKernel(float *C, float *A, float *B,
-                                     unsigned int matrixDim) {
-  // Block index
-  int bx = blockIdx.x;
-  int by = blockIdx.y;
-
-  // Thread index
-  int tx = threadIdx.x;
-  int ty = threadIdx.y;
-
-  unsigned int wA = matrixDim;
-  unsigned int wB = matrixDim;
-
-  // Index of the first sub-matrix of A processed by the block
-  int aBegin = matrixDim * BLOCK_SIZE * by;
-
-  // Index of the last sub-matrix of A processed by the block
-  int aEnd = aBegin + wA - 1;
-
-  // Step size used to iterate through the sub-matrices of A
-  int aStep = BLOCK_SIZE;
-
-  // Index of the first sub-matrix of B processed by the block
-  int bBegin = BLOCK_SIZE * bx;
-
-  // Step size used to iterate through the sub-matrices of B
-  int bStep = BLOCK_SIZE * wB;
-
-  // Csub is used to store the element of the block sub-matrix
-  // that is computed by the thread
-  float Csub = 0;
-
-  // Loop over all the sub-matrices of A and B
-  // required to compute the block sub-matrix
-  for (int a = aBegin, b = bBegin; a <= aEnd; a += aStep, b += bStep) {
-    // Declaration of the shared memory array As used to
-    // store the sub-matrix of A
-    __shared__ float As[BLOCK_SIZE][BLOCK_SIZE];
-
-    // Declaration of the shared memory array Bs used to
-    // store the sub-matrix of B
-    __shared__ float Bs[BLOCK_SIZE][BLOCK_SIZE];
-
-    // Load the matrices from device memory
-    // to shared memory; each thread loads
-    // one element of each matrix
-    As[ty][tx] = A[a + wA * ty + tx];
-    Bs[ty][tx] = B[b + wB * ty + tx];
-
-    // Synchronize to make sure the matrices are loaded
-    __syncthreads();
-
-    // Multiply the two matrices together;
-    // each thread computes one element
-    // of the block sub-matrix
-#pragma unroll
-
-    for (int k = 0; k < BLOCK_SIZE; ++k) {
-      Csub += As[ty][k] * Bs[k][tx];
-    }
-
-    // Synchronize to make sure that the preceding
-    // computation is done before loading two new
-    // sub-matrices of A and B in the next iteration
-    __syncthreads();
-  }
-
-  // Write the block sub-matrix to device memory;
-  // each thread writes one element
-  int c = wB * BLOCK_SIZE * by + BLOCK_SIZE * bx;
-  C[c + wB * ty + tx] = Csub;
-}
-
-void runMatrixMultiplyKernel(unsigned int matrixDim, int allocType,
-                             unsigned int numLoops, double *gpuLaunchCallsTimes,
-                             double *gpuTransferToCallsTimes,
-                             double *gpuTransferFromCallsTimes,
-                             double *gpuLaunchAndTransferCallsTimes,
-                             double *gpuLaunchTransferSyncTimes,
-                             double *cpuAccessTimes, double *overallTimes,
-                             int device_id) {
-  float *dptrA = NULL, *hptrA = NULL;
-  float *dptrB = NULL, *hptrB = NULL;
-  float *dptrC = NULL, *hptrC = NULL;
-  float *randValuesX = NULL, *randValuesY = NULL;
-  float *randValuesVerifyXmulY = NULL, *randValuesVerifyYmulX = NULL;
-  bool copyRequired = false, hintsRequired = false;
-  bool someTransferOpRequired;
-  bool isAsync = false;
-  cudaStream_t streamToRunOn;
-  unsigned int *latch;
-  size_t size = matrixDim * matrixDim * sizeof(float);
-  dim3 threads(32, 32);
-  dim3 grid(matrixDim / threads.x, matrixDim / threads.y);
-  StopWatchInterface *gpuLaunchCallsTimer = 0, *gpuTransferCallsTimer = 0;
-  StopWatchInterface *gpuSyncTimer = 0, *cpuAccessTimer = 0;
-  sdkCreateTimer(&gpuLaunchCallsTimer);
-  sdkCreateTimer(&gpuTransferCallsTimer);
-  sdkCreateTimer(&gpuSyncTimer);
-  sdkCreateTimer(&cpuAccessTimer);
-  unsigned int i;
-
-  cudaDeviceProp deviceProp;
-  checkCudaErrors(cudaGetDeviceProperties(&deviceProp, device_id));
-  checkCudaErrors(cudaStreamCreate(&streamToRunOn));
-
-  randValuesX = (float *)malloc(size);
-  if (!randValuesX) {
-    exit(EXIT_FAILURE);  // exit since memory allocation error
-  }
-  randValuesY = (float *)malloc(size);
-  if (!randValuesY) {
-    exit(EXIT_FAILURE);  // exit since memory allocation error
-  }
-  randValuesVerifyXmulY = (float *)malloc(size);
-  if (!randValuesVerifyXmulY) {
-    exit(EXIT_FAILURE);  // exit since memory allocation error
-  }
-  randValuesVerifyYmulX = (float *)malloc(size);
-  if (!randValuesVerifyYmulX) {
-    exit(EXIT_FAILURE);  // exit since memory allocation error
-  }
-  checkCudaErrors(cudaMalloc(&dptrA, size));
-  checkCudaErrors(cudaMalloc(&dptrB, size));
-  checkCudaErrors(cudaMalloc(&dptrC, size));
-
-  fillMatrixWithRandomValues(randValuesX, matrixDim);
-  fillMatrixWithRandomValues(randValuesY, matrixDim);
-
-  checkCudaErrors(
-      cudaMemcpyAsync(dptrA, randValuesX, size, cudaMemcpyHostToDevice));
-  checkCudaErrors(
-      cudaMemcpyAsync(dptrB, randValuesY, size, cudaMemcpyHostToDevice));
-  matrixMultiplyKernel<<<grid, threads>>>(dptrC, dptrA, dptrB, matrixDim);
-  checkCudaErrors(cudaMemcpyAsync(randValuesVerifyXmulY, dptrC, size,
-                                  cudaMemcpyDeviceToHost));
-  checkCudaErrors(cudaStreamSynchronize(NULL));
-  matrixMultiplyKernel<<<grid, threads>>>(dptrC, dptrB, dptrA, matrixDim);
-  checkCudaErrors(cudaMemcpyAsync(randValuesVerifyYmulX, dptrC, size,
-                                  cudaMemcpyDeviceToHost));
-  checkCudaErrors(cudaStreamSynchronize(NULL));
-#if VERIFY_GPU_CORRECTNESS
-  verifyMatrixMultiplyCorrectness(randValuesVerifyXmulY, randValuesX,
-                                  randValuesY, matrixDim);
-  verifyMatrixMultiplyCorrectness(randValuesVerifyYmulX, randValuesY,
-                                  randValuesX, matrixDim);
-#endif
-  checkCudaErrors(cudaFree(dptrA));
-  checkCudaErrors(cudaFree(dptrB));
-  checkCudaErrors(cudaFree(dptrC));
-
-  checkCudaErrors(cudaMallocHost(&latch, sizeof(unsigned int)));
-
-  switch (allocType) {
-    case USE_HOST_PAGEABLE_AND_DEVICE_MEMORY:
-    case USE_HOST_PAGEABLE_AND_DEVICE_MEMORY_ASYNC:
-      hptrA = (float *)malloc(size);
-      if (!hptrA) {
-        exit(EXIT_FAILURE);  // exit since memory allocation error
-      }
-      hptrB = (float *)malloc(size);
-      if (!hptrB) {
-        exit(EXIT_FAILURE);  // exit since memory allocation error
-      }
-      hptrC = (float *)malloc(size);
-      if (!hptrC) {
-        exit(EXIT_FAILURE);  // exit since memory allocation error
-      }
-      checkCudaErrors(cudaMalloc(&dptrA, size));
-      checkCudaErrors(cudaMalloc(&dptrB, size));
-      checkCudaErrors(cudaMalloc(&dptrC, size));
-      copyRequired = true;
-      break;
-
-    case USE_HOST_PAGELOCKED_AND_DEVICE_MEMORY:
-    case USE_HOST_PAGELOCKED_AND_DEVICE_MEMORY_ASYNC:
-      checkCudaErrors(cudaMallocHost(&hptrA, size));
-      checkCudaErrors(cudaMallocHost(&hptrB, size));
-      checkCudaErrors(cudaMallocHost(&hptrC, size));
-      checkCudaErrors(cudaMalloc(&dptrA, size));
-      checkCudaErrors(cudaMalloc(&dptrB, size));
-      checkCudaErrors(cudaMalloc(&dptrC, size));
-      copyRequired = true;
-      break;
-
-    case USE_ZERO_COPY:
-      checkCudaErrors(cudaMallocHost(&hptrA, size));
-      checkCudaErrors(cudaMallocHost(&hptrB, size));
-      checkCudaErrors(cudaMallocHost(&hptrC, size));
-      checkCudaErrors(cudaHostGetDevicePointer(&dptrA, hptrA, 0));
-      checkCudaErrors(cudaHostGetDevicePointer(&dptrB, hptrB, 0));
-      checkCudaErrors(cudaHostGetDevicePointer(&dptrC, hptrC, 0));
-      break;
-
-    case USE_MANAGED_MEMORY:
-      checkCudaErrors(cudaMallocManaged(&dptrA, size));
-      checkCudaErrors(cudaMallocManaged(&dptrB, size));
-      checkCudaErrors(cudaMallocManaged(&dptrC, size));
-      hptrA = dptrA;
-      hptrB = dptrB;
-      hptrC = dptrC;
-      break;
-
-    case USE_MANAGED_MEMORY_WITH_HINTS:
-    case USE_MANAGED_MEMORY_WITH_HINTS_ASYNC:
-      if (deviceProp.concurrentManagedAccess) {
-        checkCudaErrors(cudaMallocManaged(&dptrA, size));
-        checkCudaErrors(cudaMallocManaged(&dptrB, size));
-        checkCudaErrors(cudaMallocManaged(&dptrC, size));
-        checkCudaErrors(cudaMemPrefetchAsync(dptrA, size, cudaCpuDeviceId));
-        checkCudaErrors(cudaMemPrefetchAsync(dptrB, size, cudaCpuDeviceId));
-        checkCudaErrors(cudaMemPrefetchAsync(dptrC, size, cudaCpuDeviceId));
-      } else {
-        checkCudaErrors(cudaMallocManaged(&dptrA, size, cudaMemAttachHost));
-        checkCudaErrors(cudaMallocManaged(&dptrB, size, cudaMemAttachHost));
-        checkCudaErrors(cudaMallocManaged(&dptrC, size, cudaMemAttachHost));
-      }
-      hptrA = dptrA;
-      hptrB = dptrB;
-      hptrC = dptrC;
-      hintsRequired = true;
-      break;
-
-    default:
-      exit(EXIT_FAILURE);  // exit with error
-  }
-
-  if (allocType == USE_HOST_PAGEABLE_AND_DEVICE_MEMORY_ASYNC ||
-      allocType == USE_HOST_PAGELOCKED_AND_DEVICE_MEMORY_ASYNC ||
-      allocType == USE_MANAGED_MEMORY_WITH_HINTS_ASYNC) {
-    isAsync = true;
-  }
-
-  someTransferOpRequired = copyRequired || hintsRequired;
-
-  // fill buffers with 0 to avoid any first access page-fault overheads.
-  memset(hptrA, 0, size);
-  memset(hptrB, 0, size);
-  memset(hptrC, 0, size);
-
-  for (i = 0; i < numLoops; i++) {
-    cpuAccessTimes[i] = 0.0;
-    gpuLaunchCallsTimes[i] = 0.0;
-    gpuTransferToCallsTimes[i] = 0.0;
-    gpuTransferFromCallsTimes[i] = 0.0;
-
-    sdkStartTimer(&cpuAccessTimer);
-    {
-      copyMatrix(hptrA, (i & 0x1 == 0) ? randValuesX : randValuesY, matrixDim);
-      copyMatrix(hptrB, (i & 0x1 == 0) ? randValuesY : randValuesX, matrixDim);
-    }
-    sdkStopTimer(&cpuAccessTimer);
-    cpuAccessTimes[i] += sdkGetAverageTimerValue(&cpuAccessTimer);
-    sdkResetTimer(&cpuAccessTimer);
-
-    if (isAsync && hintsRequired) {
-      *latch = 0;
-      // Prevent any work on stream from starting until all work is pushed
-      spinWhileLessThanOne<<<1, 1, 0, streamToRunOn>>>(latch);
-    }
-
-    if (someTransferOpRequired) {
-      sdkStartTimer(&gpuTransferCallsTimer);
-      if (copyRequired) {
-        if (isAsync) {
-          checkCudaErrors(cudaMemcpyAsync(
-              dptrA, hptrA, size, cudaMemcpyHostToDevice, streamToRunOn));
-          checkCudaErrors(cudaMemcpyAsync(
-              dptrB, hptrB, size, cudaMemcpyHostToDevice, streamToRunOn));
-        } else {
-          checkCudaErrors(
-              cudaMemcpy(dptrA, hptrA, size, cudaMemcpyHostToDevice));
-          checkCudaErrors(
-              cudaMemcpy(dptrB, hptrB, size, cudaMemcpyHostToDevice));
-        }
-      }
-      if (hintsRequired) {
-        if (deviceProp.concurrentManagedAccess) {
-          checkCudaErrors(
-              cudaMemPrefetchAsync(dptrA, size, device_id, streamToRunOn));
-          checkCudaErrors(
-              cudaMemPrefetchAsync(dptrB, size, device_id, streamToRunOn));
-          checkCudaErrors(
-              cudaMemPrefetchAsync(dptrC, size, device_id, streamToRunOn));
-        } else {
-          checkCudaErrors(cudaStreamAttachMemAsync(streamToRunOn, dptrA, 0,
-                                                   cudaMemAttachGlobal));
-          checkCudaErrors(cudaStreamAttachMemAsync(streamToRunOn, dptrB, 0,
-                                                   cudaMemAttachGlobal));
-          checkCudaErrors(cudaStreamAttachMemAsync(streamToRunOn, dptrC, 0,
-                                                   cudaMemAttachGlobal));
-        }
-        if (!isAsync) {
-          checkCudaErrors(cudaStreamSynchronize(streamToRunOn));
-        }
-      }
-
-      sdkStopTimer(&gpuTransferCallsTimer);
-      gpuTransferToCallsTimes[i] +=
-          sdkGetAverageTimerValue(&gpuTransferCallsTimer);
-      sdkResetTimer(&gpuTransferCallsTimer);
-    }
-
-    sdkStartTimer(&gpuLaunchCallsTimer);
-    {
-      matrixMultiplyKernel<<<grid, threads, 0, streamToRunOn>>>(
-          dptrC, dptrA, dptrB, matrixDim);
-      if (!isAsync) {
-        checkCudaErrors(cudaStreamSynchronize(streamToRunOn));
-      }
-    }
-    sdkStopTimer(&gpuLaunchCallsTimer);
-
-    gpuLaunchCallsTimes[i] += sdkGetAverageTimerValue(&gpuLaunchCallsTimer);
-    sdkResetTimer(&gpuLaunchCallsTimer);
-
-    if (someTransferOpRequired) {
-      sdkStartTimer(&gpuTransferCallsTimer);
-      if (hintsRequired) {
-        if (deviceProp.concurrentManagedAccess) {
-          checkCudaErrors(cudaMemPrefetchAsync(dptrA, size, cudaCpuDeviceId));
-          checkCudaErrors(cudaMemPrefetchAsync(dptrB, size, cudaCpuDeviceId));
-          checkCudaErrors(cudaMemPrefetchAsync(dptrC, size, cudaCpuDeviceId));
-        } else {
-          checkCudaErrors(cudaStreamAttachMemAsync(streamToRunOn, dptrA, 0,
-                                                   cudaMemAttachHost));
-          checkCudaErrors(cudaStreamAttachMemAsync(streamToRunOn, dptrB, 0,
-                                                   cudaMemAttachHost));
-          checkCudaErrors(cudaStreamAttachMemAsync(streamToRunOn, dptrC, 0,
-                                                   cudaMemAttachHost));
-        }
-        if (!isAsync) {
-          checkCudaErrors(cudaStreamSynchronize(streamToRunOn));
-        }
-      }
-      if (copyRequired) {
-        if (isAsync) {
-          checkCudaErrors(cudaMemcpyAsync(
-              hptrC, dptrC, size, cudaMemcpyDeviceToHost, streamToRunOn));
-        } else {
-          checkCudaErrors(
-              cudaMemcpy(hptrC, dptrC, size, cudaMemcpyDeviceToHost));
-        }
-      }
-      sdkStopTimer(&gpuTransferCallsTimer);
-      gpuTransferFromCallsTimes[i] +=
-          sdkGetAverageTimerValue(&gpuTransferCallsTimer);
-      sdkResetTimer(&gpuTransferCallsTimer);
-    }
-    gpuLaunchAndTransferCallsTimes[i] = gpuLaunchCallsTimes[i] +
-                                        gpuTransferToCallsTimes[i] +
-                                        gpuTransferFromCallsTimes[i];
-    gpuLaunchTransferSyncTimes[i] = gpuLaunchAndTransferCallsTimes[i];
-    if (isAsync) {
-      sdkStartTimer(&gpuSyncTimer);
-      {
-        if (hintsRequired) {
-          *latch = 1;
-        }
-        checkCudaErrors(cudaStreamSynchronize(streamToRunOn));
-      }
-      sdkStopTimer(&gpuSyncTimer);
-      gpuLaunchTransferSyncTimes[i] += sdkGetAverageTimerValue(&gpuSyncTimer);
-      sdkResetTimer(&gpuSyncTimer);
-    }
-
-    sdkStartTimer(&cpuAccessTimer);
-    {
-      verifyMatrixData(
-          (i & 0x1 == 0) ? randValuesVerifyXmulY : randValuesVerifyYmulX, hptrC,
-          matrixDim);
-    }
-    sdkStopTimer(&cpuAccessTimer);
-    cpuAccessTimes[i] += sdkGetAverageTimerValue(&cpuAccessTimer);
-    sdkResetTimer(&cpuAccessTimer);
-    overallTimes[i] = cpuAccessTimes[i] + gpuLaunchTransferSyncTimes[i];
-  }
-
-  switch (allocType) {
-    case USE_HOST_PAGEABLE_AND_DEVICE_MEMORY:
-    case USE_HOST_PAGEABLE_AND_DEVICE_MEMORY_ASYNC:
-      free(hptrA);
-      free(hptrB);
-      free(hptrC);
-      checkCudaErrors(cudaFree(dptrA));
-      checkCudaErrors(cudaFree(dptrB));
-      checkCudaErrors(cudaFree(dptrC));
-      break;
-
-    case USE_HOST_PAGELOCKED_AND_DEVICE_MEMORY:
-    case USE_HOST_PAGELOCKED_AND_DEVICE_MEMORY_ASYNC:
-      checkCudaErrors(cudaFreeHost(hptrA));
-      checkCudaErrors(cudaFreeHost(hptrB));
-      checkCudaErrors(cudaFreeHost(hptrC));
-      checkCudaErrors(cudaFree(dptrA));
-      checkCudaErrors(cudaFree(dptrB));
-      checkCudaErrors(cudaFree(dptrC));
-      break;
-
-    case USE_ZERO_COPY:
-      checkCudaErrors(cudaFreeHost(hptrA));
-      checkCudaErrors(cudaFreeHost(hptrB));
-      checkCudaErrors(cudaFreeHost(hptrC));
-      break;
-
-    case USE_MANAGED_MEMORY:
-    case USE_MANAGED_MEMORY_WITH_HINTS:
-    case USE_MANAGED_MEMORY_WITH_HINTS_ASYNC:
-      checkCudaErrors(cudaFree(dptrA));
-      checkCudaErrors(cudaFree(dptrB));
-      checkCudaErrors(cudaFree(dptrC));
-      break;
-
-    default:
-      exit(EXIT_FAILURE);  // exit due to error
-  }
-
-  checkCudaErrors(cudaStreamDestroy(streamToRunOn));
-  checkCudaErrors(cudaFreeHost(latch));
-  free(randValuesX);
-  free(randValuesY);
-  free(randValuesVerifyXmulY);
-  free(randValuesVerifyYmulX);
-  sdkDeleteTimer(&gpuLaunchCallsTimer);
-  sdkDeleteTimer(&gpuTransferCallsTimer);
-  sdkDeleteTimer(&gpuSyncTimer);
-  sdkDeleteTimer(&cpuAccessTimer);
-}
-
-void matrixMultiplyPerfRunner(bool reportAsBandwidth,
-                              bool print_launch_transfer_results,
-                              bool print_std_deviation, int device_id) {
-  int i;
-  unsigned int minMatrixDim = 32;
-  unsigned int multiplierDim = 2;
-  unsigned int matrixDim;
-  unsigned int minSize = minMatrixDim * minMatrixDim * sizeof(float);
-  unsigned int maxSize =
-      (maxSampleSizeInMb * ONE_MB) /
-      4;  // 3 buffers are used, but dividing by 4 (power of 2)
-  unsigned int multiplier = multiplierDim * multiplierDim;
-  unsigned int numSizesToTest;
-
-  struct testResults *results;
-  struct resultsData *gpuLaunchCallsTimes;
-  struct resultsData *gpuTransferToCallsTimes;
-  struct resultsData *gpuTransferFromCallsTimes;
-  struct resultsData *gpuLaunchAndTransferCallsTimes;
-  struct resultsData *gpuLaunchTransferSyncTimes;
-  struct resultsData *cpuAccessTimes;
-  struct resultsData *overallTimes;
-  unsigned long *sizesToTest;
-  unsigned int j;
-
-  numSizesToTest = findNumSizesToTest(minSize, maxSize, multiplier);
-
-  createAndInitTestResults(&results, "matrixMultiplyPerf", numKernelRuns,
-                           numSizesToTest);
-
-  sizesToTest = getPtrSizesToTest(results);
-
-  createResultDataAndAddToTestResults(&gpuLaunchCallsTimes, results,
-                                      "GPU Kernel Launch Call Time", false,
-                                      reportAsBandwidth);
-  createResultDataAndAddToTestResults(&gpuTransferToCallsTimes, results,
-                                      "CPU to GPU Transfer Calls Time", false,
-                                      reportAsBandwidth);
-  createResultDataAndAddToTestResults(&gpuTransferFromCallsTimes, results,
-                                      "GPU to CPU Transfer Calls Time", false,
-                                      reportAsBandwidth);
-  createResultDataAndAddToTestResults(&gpuLaunchAndTransferCallsTimes, results,
-                                      "GPU Launch and Transfer Calls Time",
-                                      false, reportAsBandwidth);
-  createResultDataAndAddToTestResults(&gpuLaunchTransferSyncTimes, results,
-                                      "GPU Launch Transfer and Sync Time",
-                                      false, reportAsBandwidth);
-  createResultDataAndAddToTestResults(
-      &cpuAccessTimes, results, "CPU Access Time", false, reportAsBandwidth);
-  createResultDataAndAddToTestResults(&overallTimes, results, "Overall Time",
-                                      false, reportAsBandwidth);
-
-  printf("Running ");
-  for (matrixDim = minMatrixDim, j = 0;
-       matrixDim * matrixDim <= maxSize / sizeof(float);
-       matrixDim *= multiplierDim, ++j) {
-    sizesToTest[j] = matrixDim * matrixDim * sizeof(float);
-    for (i = MEMALLOC_TYPE_START; i <= MEMALLOC_TYPE_END; i++) {
-      printf(".");
-      fflush(stdout);
-      runMatrixMultiplyKernel(
-          matrixDim, i, numKernelRuns,
-          getPtrRunTimesInMs(gpuLaunchCallsTimes, i, j),
-          getPtrRunTimesInMs(gpuTransferToCallsTimes, i, j),
-          getPtrRunTimesInMs(gpuTransferFromCallsTimes, i, j),
-          getPtrRunTimesInMs(gpuLaunchAndTransferCallsTimes, i, j),
-          getPtrRunTimesInMs(gpuLaunchTransferSyncTimes, i, j),
-          getPtrRunTimesInMs(cpuAccessTimes, i, j),
-          getPtrRunTimesInMs(overallTimes, i, j), device_id);
-    }
-  }
-  printf("\n");
-  printResults(results, print_launch_transfer_results, print_std_deviation);
-  freeTestResultsAndAllResultsData(results);
-}
-
-static void usage() {
-  printf(
-      "./cudaMemoryTypesPerf [-device=<device_id>] [-reportAsBandwidth] "
-      "[-print-launch-transfer-results] [-print-std-deviation] [-verbose]\n");
-  printf("Options:\n");
-  printf(
-      "-reportAsBandwidth:             By default time taken is printed, this "
-      "option allows to instead print bandwidth.\n");
-  printf(
-      "-print-launch-transfer-results: By default overall results are printed, "
-      "this option allows to print data transfers and kernel time as well.\n");
-  printf(
-      "-print-std-deviation:           Prints std deviation of the results.\n");
-  printf(
-      "-kernel-iterations=<num>:       Number of times the kernel tests should "
-      "be run[default is 100 iterations].\n");
-  printf(
-      "-device=<device_id>:            Allows to pass GPU Device ID on which "
-      "the tests will be run.\n");
-  printf("-verbose:                       Prints highly verbose output.\n");
-}
-
-int main(int argc, char **argv) {
-  bool reportAsBandwidth = false;
-  bool print_launch_transfer_results = false;
-  bool print_std_deviation = false;
-
-  if (checkCmdLineFlag(argc, (const char **)argv, "help") ||
-      checkCmdLineFlag(argc, (const char **)argv, "h")) {
-    usage();
-    printf("&&&& %s WAIVED\n", argv[0]);
-    exit(EXIT_WAIVED);
-  }
-
-  if (checkCmdLineFlag(argc, (const char **)argv, "reportAsBandwidth")) {
-    reportAsBandwidth = true;
-  }
-
-  if (checkCmdLineFlag(argc, (const char **)argv,
-                       "print-launch-transfer-results")) {
-    print_launch_transfer_results = true;
-  }
-
-  if (checkCmdLineFlag(argc, (const char **)argv, "print-std-deviation")) {
-    print_std_deviation = true;
-  }
-
-  if (checkCmdLineFlag(argc, (const char **)argv, "kernel-iterations")) {
-    numKernelRuns =
-        getCmdLineArgumentInt(argc, (const char **)argv, "kernel-iterations");
-  }
-
-  if (checkCmdLineFlag(argc, (const char **)argv, "verbose")) {
-    verboseResults = 1;
-  }
-
-  int device_id = findCudaDevice(argc, (const char **)argv);
-
-  matrixMultiplyPerfRunner(reportAsBandwidth, print_launch_transfer_results,
-                           print_std_deviation, device_id);
-
-  printf(
-      "\nNOTE: The CUDA Samples are not meant for performance measurements. "
-      "Results may vary when GPU Boost is enabled.\n");
-  exit(EXIT_SUCCESS);
-}

Samples/bandwidthTest/Makefile

@@ -1,304 +0,0 @@
-################################################################################
-# Copyright (c) 2018, 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 ppc64le armv7l))
-    ifneq ($(TARGET_ARCH),$(HOST_ARCH))
-        ifneq (,$(filter $(TARGET_ARCH),x86_64 aarch64 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
-ifneq ($(TARGET_ARCH),$(HOST_ARCH))
-    ifeq (,$(filter $(HOST_ARCH)-$(TARGET_ARCH),aarch64-armv7l x86_64-armv7l x86_64-aarch64 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/aarch64-unknown-nto-qnx7.0.0-g++
-        else ifeq ($(TARGET_OS), android)
-            HOST_COMPILER ?= aarch64-linux-android-clang++
-        endif
-    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)/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
-            CCFLAGS += -isystem=$(TARGET_FS)/usr/include/aarch64-linux-gnu
-        endif
-    endif
-endif
-
-ifeq ($(TARGET_OS),qnx)
-    CCFLAGS += -DWIN_INTERFACE_CUSTOM
-    LDFLAGS += -lsocket
-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),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 :=
-
-################################################################################
-
-# Gencode arguments
-ifeq ($(TARGET_ARCH),$(filter $(TARGET_ARCH),armv7l aarch64))
-SMS ?= 30 35 37 50 52 60 61 70 72 75
-else
-SMS ?= 30 35 37 50 52 60 61 70 75
-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
-
-ifeq ($(SAMPLE_ENABLED),0)
-EXEC ?= @echo "[@]"
-endif
-
-################################################################################
-
-# Target rules
-all: build
-
-build: bandwidthTest
-
-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
-
-bandwidthTest.o:bandwidthTest.cu
-	$(EXEC) $(NVCC) $(INCLUDES) $(ALL_CCFLAGS) $(GENCODE_FLAGS) -o $@ -c $<
-
-bandwidthTest: bandwidthTest.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) ./bandwidthTest
-
-clean:
-	rm -f bandwidthTest bandwidthTest.o
-	rm -rf ../../bin/$(TARGET_ARCH)/$(TARGET_OS)/$(BUILD_TYPE)/bandwidthTest
-
-clobber: clean

Samples/bandwidthTest/NsightEclipse.xml

@@ -1,79 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?> 
-<!DOCTYPE entry SYSTEM "SamplesInfo.dtd">
-<entry>
-  <name>bandwidthTest</name>
-  <cuda_api_list>
-    <toolkit>cudaSetDevice</toolkit>
-    <toolkit>cudaHostAlloc</toolkit>
-    <toolkit>cudaFree</toolkit>
-    <toolkit>cudaMallocHost</toolkit>
-    <toolkit>cudaFreeHost</toolkit>
-    <toolkit>cudaMemcpy</toolkit>
-    <toolkit>cudaMemcpyAsync</toolkit>
-    <toolkit>cudaEventCreate</toolkit>
-    <toolkit>cudaEventRecord</toolkit>
-    <toolkit>cudaEventDestroy</toolkit>
-    <toolkit>cudaDeviceSynchronize</toolkit>
-    <toolkit>cudaEventElapsedTime</toolkit>
-  </cuda_api_list>
-  <description><![CDATA[This is a simple test program to measure the memcopy bandwidth of the GPU and memcpy bandwidth across PCI-e. This test application is capable of measuring device to device copy bandwidth, host to device copy bandwidth for pageable and page-locked memory, and device to host copy bandwidth for pageable and page-locked memory.]]></description>
-  <devicecompilation>whole</devicecompilation>
-  <includepaths>
-    <path>./</path>
-    <path>../</path>
-    <path>../../common/inc</path>
-  </includepaths>
-  <keyconcepts>
-    <concept level="basic">CUDA Streams and Events</concept>
-    <concept level="basic">Performance Strategies</concept>
-  </keyconcepts>
-  <keywords>
-    <keyword>GPGPU</keyword>
-    <keyword>bandwidth</keyword>
-  </keywords>
-  <libraries>
-  </libraries>
-  <librarypaths>
-  </librarypaths>
-  <nsight_eclipse>true</nsight_eclipse>
-  <primary_file>bandwidthTest.cu</primary_file>
-  <scopes>
-    <scope>1:CUDA Basic Topics</scope>
-    <scope>1:Performance Strategies</scope>
-  </scopes>
-  <sm-arch>sm30</sm-arch>
-  <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>
-  <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>Bandwidth Test</title>
-  <type>exe</type>
-</entry>

Samples/bandwidthTest/README.md

@@ -1,94 +0,0 @@
-# bandwidthTest - Bandwidth Test
-
-## Description
-
-This is a simple test program to measure the memcopy bandwidth of the GPU and memcpy bandwidth across PCI-e. This test application is capable of measuring device to device copy bandwidth, host to device copy bandwidth for pageable and page-locked memory, and device to host copy bandwidth for pageable and page-locked memory.
-
-## Key Concepts
-
-CUDA Streams and Events, Performance Strategies
-
-## Supported SM Architectures
-
-[SM 3.0 ](https://developer.nvidia.com/cuda-gpus)  [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)
-
-## Supported OSes
-
-Linux, Windows, MacOSX
-
-## Supported CPU Architecture
-
-x86_64, ppc64le, armv7l
-
-## CUDA APIs involved
-
-### [CUDA Runtime API](http://docs.nvidia.com/cuda/cuda-runtime-api/index.html)
-cudaSetDevice, cudaHostAlloc, cudaFree, cudaMallocHost, cudaFreeHost, cudaMemcpy, cudaMemcpyAsync, cudaEventCreate, cudaEventRecord, cudaEventDestroy, cudaDeviceSynchronize, cudaEventElapsedTime
-
-## Prerequisites
-
-Download and install the [CUDA Toolkit 10.1](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++
-```
-
-### Mac
-The Mac samples are built using makefiles. To use the makefiles, change directory into the sample directory you wish to build, and run make:
-```
-$ cd <sample_dir>
-$ make
-```
-
-The samples makefiles can take advantage of certain options:
-
-*  **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="A B ..."
-    ```
-
-*  **HOST_COMPILER=<host_compiler>** - override the default clang host compiler. See the [Mac Installation Guide](http://docs.nvidia.com/cuda/cuda-installation-guide-mac-os-x/index.html#system-requirements) for a list of supported host compilers.
-    ```
-    $ make HOST_COMPILER=clang
-    ```
-
-## References (for more details)
-

Samples/bandwidthTest/bandwidthTest.cu

@@ -1,969 +0,0 @@
-/* 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.
- */
-
-/*
- * This is a simple test program to measure the memcopy bandwidth of the GPU.
- * It can measure device to device copy bandwidth, host to device copy bandwidth
- * for pageable and pinned memory, and device to host copy bandwidth for
- * pageable and pinned memory.
- *
- * Usage:
- * ./bandwidthTest [option]...
- */
-
-// CUDA runtime
-#include <cuda_runtime.h>
-
-// includes
-#include <helper_cuda.h>  // helper functions for CUDA error checking and initialization
-#include <helper_functions.h>  // helper for shared functions common to CUDA Samples
-
-#include <cuda.h>
-
-#include <cassert>
-#include <iostream>
-#include <memory>
-
-static const char *sSDKsample = "CUDA Bandwidth Test";
-
-// defines, project
-#define MEMCOPY_ITERATIONS 100
-#define DEFAULT_SIZE (32 * (1e6))      // 32 M
-#define DEFAULT_INCREMENT (4 * (1e6))  // 4 M
-#define CACHE_CLEAR_SIZE (16 * (1e6))  // 16 M
-
-// shmoo mode defines
-#define SHMOO_MEMSIZE_MAX (64 * (1e6))       // 64 M
-#define SHMOO_MEMSIZE_START (1e3)            // 1 KB
-#define SHMOO_INCREMENT_1KB (1e3)            // 1 KB
-#define SHMOO_INCREMENT_2KB (2 * 1e3)        // 2 KB
-#define SHMOO_INCREMENT_10KB (10 * (1e3))    // 10KB
-#define SHMOO_INCREMENT_100KB (100 * (1e3))  // 100 KB
-#define SHMOO_INCREMENT_1MB (1e6)            // 1 MB
-#define SHMOO_INCREMENT_2MB (2 * 1e6)        // 2 MB
-#define SHMOO_INCREMENT_4MB (4 * 1e6)        // 4 MB
-#define SHMOO_LIMIT_20KB (20 * (1e3))        // 20 KB
-#define SHMOO_LIMIT_50KB (50 * (1e3))        // 50 KB
-#define SHMOO_LIMIT_100KB (100 * (1e3))      // 100 KB
-#define SHMOO_LIMIT_1MB (1e6)                // 1 MB
-#define SHMOO_LIMIT_16MB (16 * 1e6)          // 16 MB
-#define SHMOO_LIMIT_32MB (32 * 1e6)          // 32 MB
-
-// CPU cache flush
-#define FLUSH_SIZE (256 * 1024 * 1024)
-char *flush_buf;
-
-// enums, project
-enum testMode { QUICK_MODE, RANGE_MODE, SHMOO_MODE };
-enum memcpyKind { DEVICE_TO_HOST, HOST_TO_DEVICE, DEVICE_TO_DEVICE };
-enum printMode { USER_READABLE, CSV };
-enum memoryMode { PINNED, PAGEABLE };
-
-const char *sMemoryCopyKind[] = {"Device to Host", "Host to Device",
-                                 "Device to Device", NULL};
-
-const char *sMemoryMode[] = {"PINNED", "PAGEABLE", NULL};
-
-// if true, use CPU based timing for everything
-static bool bDontUseGPUTiming;
-
-int *pArgc = NULL;
-char **pArgv = NULL;
-
-////////////////////////////////////////////////////////////////////////////////
-// declaration, forward
-int runTest(const int argc, const char **argv);
-void testBandwidth(unsigned int start, unsigned int end, unsigned int increment,
-                   testMode mode, memcpyKind kind, printMode printmode,
-                   memoryMode memMode, int startDevice, int endDevice, bool wc);
-void testBandwidthQuick(unsigned int size, memcpyKind kind, printMode printmode,
-                        memoryMode memMode, int startDevice, int endDevice,
-                        bool wc);
-void testBandwidthRange(unsigned int start, unsigned int end,
-                        unsigned int increment, memcpyKind kind,
-                        printMode printmode, memoryMode memMode,
-                        int startDevice, int endDevice, bool wc);
-void testBandwidthShmoo(memcpyKind kind, printMode printmode,
-                        memoryMode memMode, int startDevice, int endDevice,
-                        bool wc);
-float testDeviceToHostTransfer(unsigned int memSize, memoryMode memMode,
-                               bool wc);
-float testHostToDeviceTransfer(unsigned int memSize, memoryMode memMode,
-                               bool wc);
-float testDeviceToDeviceTransfer(unsigned int memSize);
-void printResultsReadable(unsigned int *memSizes, double *bandwidths,
-                          unsigned int count, memcpyKind kind,
-                          memoryMode memMode, int iNumDevs, bool wc);
-void printResultsCSV(unsigned int *memSizes, double *bandwidths,
-                     unsigned int count, memcpyKind kind, memoryMode memMode,
-                     int iNumDevs, bool wc);
-void printHelp(void);
-
-////////////////////////////////////////////////////////////////////////////////
-// Program main
-////////////////////////////////////////////////////////////////////////////////
-int main(int argc, char **argv) {
-  pArgc = &argc;
-  pArgv = argv;
-
-  flush_buf = (char *)malloc(FLUSH_SIZE);
-
-  // set logfile name and start logs
-  printf("[%s] - Starting...\n", sSDKsample);
-
-  int iRetVal = runTest(argc, (const char **)argv);
-
-  if (iRetVal < 0) {
-    checkCudaErrors(cudaSetDevice(0));
-  }
-
-  // finish
-  printf("%s\n", (iRetVal == 0) ? "Result = PASS" : "Result = FAIL");
-
-  printf(
-      "\nNOTE: The CUDA Samples are not meant for performance measurements. "
-      "Results may vary when GPU Boost is enabled.\n");
-
-  free(flush_buf);
-
-  exit((iRetVal == 0) ? EXIT_SUCCESS : EXIT_FAILURE);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// Parse args, run the appropriate tests
-///////////////////////////////////////////////////////////////////////////////
-int runTest(const int argc, const char **argv) {
-  int start = DEFAULT_SIZE;
-  int end = DEFAULT_SIZE;
-  int startDevice = 0;
-  int endDevice = 0;
-  int increment = DEFAULT_INCREMENT;
-  testMode mode = QUICK_MODE;
-  bool htod = false;
-  bool dtoh = false;
-  bool dtod = false;
-  bool wc = false;
-  char *modeStr;
-  char *device = NULL;
-  printMode printmode = USER_READABLE;
-  char *memModeStr = NULL;
-  memoryMode memMode = PINNED;
-
-  // process command line args
-  if (checkCmdLineFlag(argc, argv, "help")) {
-    printHelp();
-    return 0;
-  }
-
-  if (checkCmdLineFlag(argc, argv, "csv")) {
-    printmode = CSV;
-  }
-
-  if (getCmdLineArgumentString(argc, argv, "memory", &memModeStr)) {
-    if (strcmp(memModeStr, "pageable") == 0) {
-      memMode = PAGEABLE;
-    } else if (strcmp(memModeStr, "pinned") == 0) {
-      memMode = PINNED;
-    } else {
-      printf("Invalid memory mode - valid modes are pageable or pinned\n");
-      printf("See --help for more information\n");
-      return -1000;
-    }
-  } else {
-    // default - pinned memory
-    memMode = PINNED;
-  }
-
-  if (getCmdLineArgumentString(argc, argv, "device", &device)) {
-    int deviceCount;
-    cudaError_t error_id = cudaGetDeviceCount(&deviceCount);
-
-    if (error_id != cudaSuccess) {
-      printf("cudaGetDeviceCount returned %d\n-> %s\n", (int)error_id,
-             cudaGetErrorString(error_id));
-      exit(EXIT_FAILURE);
-    }
-
-    if (deviceCount == 0) {
-      printf("!!!!!No devices found!!!!!\n");
-      return -2000;
-    }
-
-    if (strcmp(device, "all") == 0) {
-      printf(
-          "\n!!!!!Cumulative Bandwidth to be computed from all the devices "
-          "!!!!!!\n\n");
-      startDevice = 0;
-      endDevice = deviceCount - 1;
-    } else {
-      startDevice = endDevice = atoi(device);
-
-      if (startDevice >= deviceCount || startDevice < 0) {
-        printf(
-            "\n!!!!!Invalid GPU number %d given hence default gpu %d will be "
-            "used !!!!!\n",
-            startDevice, 0);
-        startDevice = endDevice = 0;
-      }
-    }
-  }
-
-  printf("Running on...\n\n");
-
-  for (int currentDevice = startDevice; currentDevice <= endDevice;
-       currentDevice++) {
-    cudaDeviceProp deviceProp;
-    cudaError_t error_id = cudaGetDeviceProperties(&deviceProp, currentDevice);
-
-    if (error_id == cudaSuccess) {
-      printf(" Device %d: %s\n", currentDevice, deviceProp.name);
-
-      if (deviceProp.computeMode == cudaComputeModeProhibited) {
-        fprintf(stderr,
-                "Error: device is running in <Compute Mode Prohibited>, no "
-                "threads can use ::cudaSetDevice().\n");
-        checkCudaErrors(cudaSetDevice(currentDevice));
-
-        exit(EXIT_FAILURE);
-      }
-    } else {
-      printf("cudaGetDeviceProperties returned %d\n-> %s\n", (int)error_id,
-             cudaGetErrorString(error_id));
-      checkCudaErrors(cudaSetDevice(currentDevice));
-
-      exit(EXIT_FAILURE);
-    }
-  }
-
-  if (getCmdLineArgumentString(argc, argv, "mode", &modeStr)) {
-    // figure out the mode
-    if (strcmp(modeStr, "quick") == 0) {
-      printf(" Quick Mode\n\n");
-      mode = QUICK_MODE;
-    } else if (strcmp(modeStr, "shmoo") == 0) {
-      printf(" Shmoo Mode\n\n");
-      mode = SHMOO_MODE;
-    } else if (strcmp(modeStr, "range") == 0) {
-      printf(" Range Mode\n\n");
-      mode = RANGE_MODE;
-    } else {
-      printf("Invalid mode - valid modes are quick, range, or shmoo\n");
-      printf("See --help for more information\n");
-      return -3000;
-    }
-  } else {
-    // default mode - quick
-    printf(" Quick Mode\n\n");
-    mode = QUICK_MODE;
-  }
-
-  if (checkCmdLineFlag(argc, argv, "htod")) {
-    htod = true;
-  }
-
-  if (checkCmdLineFlag(argc, argv, "dtoh")) {
-    dtoh = true;
-  }
-
-  if (checkCmdLineFlag(argc, argv, "dtod")) {
-    dtod = true;
-  }
-
-#if CUDART_VERSION >= 2020
-
-  if (checkCmdLineFlag(argc, argv, "wc")) {
-    wc = true;
-  }
-
-#endif
-
-  if (checkCmdLineFlag(argc, argv, "cputiming")) {
-    bDontUseGPUTiming = true;
-  }
-
-  if (!htod && !dtoh && !dtod) {
-    // default:  All
-    htod = true;
-    dtoh = true;
-    dtod = true;
-  }
-
-  if (RANGE_MODE == mode) {
-    if (checkCmdLineFlag(argc, (const char **)argv, "start")) {
-      start = getCmdLineArgumentInt(argc, argv, "start");
-
-      if (start <= 0) {
-        printf("Illegal argument - start must be greater than zero\n");
-        return -4000;
-      }
-    } else {
-      printf("Must specify a starting size in range mode\n");
-      printf("See --help for more information\n");
-      return -5000;
-    }
-
-    if (checkCmdLineFlag(argc, (const char **)argv, "end")) {
-      end = getCmdLineArgumentInt(argc, argv, "end");
-
-      if (end <= 0) {
-        printf("Illegal argument - end must be greater than zero\n");
-        return -6000;
-      }
-
-      if (start > end) {
-        printf("Illegal argument - start is greater than end\n");
-        return -7000;
-      }
-    } else {
-      printf("Must specify an end size in range mode.\n");
-      printf("See --help for more information\n");
-      return -8000;
-    }
-
-    if (checkCmdLineFlag(argc, argv, "increment")) {
-      increment = getCmdLineArgumentInt(argc, argv, "increment");
-
-      if (increment <= 0) {
-        printf("Illegal argument - increment must be greater than zero\n");
-        return -9000;
-      }
-    } else {
-      printf("Must specify an increment in user mode\n");
-      printf("See --help for more information\n");
-      return -10000;
-    }
-  }
-
-  if (htod) {
-    testBandwidth((unsigned int)start, (unsigned int)end,
-                  (unsigned int)increment, mode, HOST_TO_DEVICE, printmode,
-                  memMode, startDevice, endDevice, wc);
-  }
-
-  if (dtoh) {
-    testBandwidth((unsigned int)start, (unsigned int)end,
-                  (unsigned int)increment, mode, DEVICE_TO_HOST, printmode,
-                  memMode, startDevice, endDevice, wc);
-  }
-
-  if (dtod) {
-    testBandwidth((unsigned int)start, (unsigned int)end,
-                  (unsigned int)increment, mode, DEVICE_TO_DEVICE, printmode,
-                  memMode, startDevice, endDevice, wc);
-  }
-
-  // Ensure that we reset all CUDA Devices in question
-  for (int nDevice = startDevice; nDevice <= endDevice; nDevice++) {
-    cudaSetDevice(nDevice);
-  }
-
-  return 0;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//  Run a bandwidth test
-///////////////////////////////////////////////////////////////////////////////
-void testBandwidth(unsigned int start, unsigned int end, unsigned int increment,
-                   testMode mode, memcpyKind kind, printMode printmode,
-                   memoryMode memMode, int startDevice, int endDevice,
-                   bool wc) {
-  switch (mode) {
-    case QUICK_MODE:
-      testBandwidthQuick(DEFAULT_SIZE, kind, printmode, memMode, startDevice,
-                         endDevice, wc);
-      break;
-
-    case RANGE_MODE:
-      testBandwidthRange(start, end, increment, kind, printmode, memMode,
-                         startDevice, endDevice, wc);
-      break;
-
-    case SHMOO_MODE:
-      testBandwidthShmoo(kind, printmode, memMode, startDevice, endDevice, wc);
-      break;
-
-    default:
-      break;
-  }
-}
-
-//////////////////////////////////////////////////////////////////////
-//  Run a quick mode bandwidth test
-//////////////////////////////////////////////////////////////////////
-void testBandwidthQuick(unsigned int size, memcpyKind kind, printMode printmode,
-                        memoryMode memMode, int startDevice, int endDevice,
-                        bool wc) {
-  testBandwidthRange(size, size, DEFAULT_INCREMENT, kind, printmode, memMode,
-                     startDevice, endDevice, wc);
-}
-
-///////////////////////////////////////////////////////////////////////
-//  Run a range mode bandwidth test
-//////////////////////////////////////////////////////////////////////
-void testBandwidthRange(unsigned int start, unsigned int end,
-                        unsigned int increment, memcpyKind kind,
-                        printMode printmode, memoryMode memMode,
-                        int startDevice, int endDevice, bool wc) {
-  // count the number of copies we're going to run
-  unsigned int count = 1 + ((end - start) / increment);
-
-  unsigned int *memSizes = (unsigned int *)malloc(count * sizeof(unsigned int));
-  double *bandwidths = (double *)malloc(count * sizeof(double));
-
-  // Before calculating the cumulative bandwidth, initialize bandwidths array to
-  // NULL
-  for (unsigned int i = 0; i < count; i++) {
-    bandwidths[i] = 0.0;
-  }
-
-  // Use the device asked by the user
-  for (int currentDevice = startDevice; currentDevice <= endDevice;
-       currentDevice++) {
-    cudaSetDevice(currentDevice);
-
-    // run each of the copies
-    for (unsigned int i = 0; i < count; i++) {
-      memSizes[i] = start + i * increment;
-
-      switch (kind) {
-        case DEVICE_TO_HOST:
-          bandwidths[i] += testDeviceToHostTransfer(memSizes[i], memMode, wc);
-          break;
-
-        case HOST_TO_DEVICE:
-          bandwidths[i] += testHostToDeviceTransfer(memSizes[i], memMode, wc);
-          break;
-
-        case DEVICE_TO_DEVICE:
-          bandwidths[i] += testDeviceToDeviceTransfer(memSizes[i]);
-          break;
-      }
-    }
-  }  // Complete the bandwidth computation on all the devices
-
-  // print results
-  if (printmode == CSV) {
-    printResultsCSV(memSizes, bandwidths, count, kind, memMode,
-                    (1 + endDevice - startDevice), wc);
-  } else {
-    printResultsReadable(memSizes, bandwidths, count, kind, memMode,
-                         (1 + endDevice - startDevice), wc);
-  }
-
-  // clean up
-  free(memSizes);
-  free(bandwidths);
-}
-
-//////////////////////////////////////////////////////////////////////////////
-// Intense shmoo mode - covers a large range of values with varying increments
-//////////////////////////////////////////////////////////////////////////////
-void testBandwidthShmoo(memcpyKind kind, printMode printmode,
-                        memoryMode memMode, int startDevice, int endDevice,
-                        bool wc) {
-  // count the number of copies to make
-  unsigned int count =
-      1 + (SHMOO_LIMIT_20KB / SHMOO_INCREMENT_1KB) +
-      ((SHMOO_LIMIT_50KB - SHMOO_LIMIT_20KB) / SHMOO_INCREMENT_2KB) +
-      ((SHMOO_LIMIT_100KB - SHMOO_LIMIT_50KB) / SHMOO_INCREMENT_10KB) +
-      ((SHMOO_LIMIT_1MB - SHMOO_LIMIT_100KB) / SHMOO_INCREMENT_100KB) +
-      ((SHMOO_LIMIT_16MB - SHMOO_LIMIT_1MB) / SHMOO_INCREMENT_1MB) +
-      ((SHMOO_LIMIT_32MB - SHMOO_LIMIT_16MB) / SHMOO_INCREMENT_2MB) +
-      ((SHMOO_MEMSIZE_MAX - SHMOO_LIMIT_32MB) / SHMOO_INCREMENT_4MB);
-
-  unsigned int *memSizes = (unsigned int *)malloc(count * sizeof(unsigned int));
-  double *bandwidths = (double *)malloc(count * sizeof(double));
-
-  // Before calculating the cumulative bandwidth, initialize bandwidths array to
-  // NULL
-  for (unsigned int i = 0; i < count; i++) {
-    bandwidths[i] = 0.0;
-  }
-
-  // Use the device asked by the user
-  for (int currentDevice = startDevice; currentDevice <= endDevice;
-       currentDevice++) {
-    cudaSetDevice(currentDevice);
-    // Run the shmoo
-    int iteration = 0;
-    unsigned int memSize = 0;
-
-    while (memSize <= SHMOO_MEMSIZE_MAX) {
-      if (memSize < SHMOO_LIMIT_20KB) {
-        memSize += SHMOO_INCREMENT_1KB;
-      } else if (memSize < SHMOO_LIMIT_50KB) {
-        memSize += SHMOO_INCREMENT_2KB;
-      } else if (memSize < SHMOO_LIMIT_100KB) {
-        memSize += SHMOO_INCREMENT_10KB;
-      } else if (memSize < SHMOO_LIMIT_1MB) {
-        memSize += SHMOO_INCREMENT_100KB;
-      } else if (memSize < SHMOO_LIMIT_16MB) {
-        memSize += SHMOO_INCREMENT_1MB;
-      } else if (memSize < SHMOO_LIMIT_32MB) {
-        memSize += SHMOO_INCREMENT_2MB;
-      } else {
-        memSize += SHMOO_INCREMENT_4MB;
-      }
-
-      memSizes[iteration] = memSize;
-
-      switch (kind) {
-        case DEVICE_TO_HOST:
-          bandwidths[iteration] +=
-              testDeviceToHostTransfer(memSizes[iteration], memMode, wc);
-          break;
-
-        case HOST_TO_DEVICE:
-          bandwidths[iteration] +=
-              testHostToDeviceTransfer(memSizes[iteration], memMode, wc);
-          break;
-
-        case DEVICE_TO_DEVICE:
-          bandwidths[iteration] +=
-              testDeviceToDeviceTransfer(memSizes[iteration]);
-          break;
-      }
-
-      iteration++;
-      printf(".");
-      fflush(0);
-    }
-  }  // Complete the bandwidth computation on all the devices
-
-  // print results
-  printf("\n");
-
-  if (CSV == printmode) {
-    printResultsCSV(memSizes, bandwidths, count, kind, memMode,
-                    (1 + endDevice - startDevice), wc);
-  } else {
-    printResultsReadable(memSizes, bandwidths, count, kind, memMode,
-                         (1 + endDevice - startDevice), wc);
-  }
-
-  // clean up
-  free(memSizes);
-  free(bandwidths);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//  test the bandwidth of a device to host memcopy of a specific size
-///////////////////////////////////////////////////////////////////////////////
-float testDeviceToHostTransfer(unsigned int memSize, memoryMode memMode,
-                               bool wc) {
-  StopWatchInterface *timer = NULL;
-  float elapsedTimeInMs = 0.0f;
-  float bandwidthInGBs = 0.0f;
-  unsigned char *h_idata = NULL;
-  unsigned char *h_odata = NULL;
-  cudaEvent_t start, stop;
-
-  sdkCreateTimer(&timer);
-  checkCudaErrors(cudaEventCreate(&start));
-  checkCudaErrors(cudaEventCreate(&stop));
-
-  // allocate host memory
-  if (PINNED == memMode) {
-  // pinned memory mode - use special function to get OS-pinned memory
-#if CUDART_VERSION >= 2020
-    checkCudaErrors(cudaHostAlloc((void **)&h_idata, memSize,
-                                  (wc) ? cudaHostAllocWriteCombined : 0));
-    checkCudaErrors(cudaHostAlloc((void **)&h_odata, memSize,
-                                  (wc) ? cudaHostAllocWriteCombined : 0));
-#else
-    checkCudaErrors(cudaMallocHost((void **)&h_idata, memSize));
-    checkCudaErrors(cudaMallocHost((void **)&h_odata, memSize));
-#endif
-  } else {
-    // pageable memory mode - use malloc
-    h_idata = (unsigned char *)malloc(memSize);
-    h_odata = (unsigned char *)malloc(memSize);
-
-    if (h_idata == 0 || h_odata == 0) {
-      fprintf(stderr, "Not enough memory avaialable on host to run test!\n");
-      exit(EXIT_FAILURE);
-    }
-  }
-
-  // initialize the memory
-  for (unsigned int i = 0; i < memSize / sizeof(unsigned char); i++) {
-    h_idata[i] = (unsigned char)(i & 0xff);
-  }
-
-  // allocate device memory
-  unsigned char *d_idata;
-  checkCudaErrors(cudaMalloc((void **)&d_idata, memSize));
-
-  // initialize the device memory
-  checkCudaErrors(
-      cudaMemcpy(d_idata, h_idata, memSize, cudaMemcpyHostToDevice));
-
-  // copy data from GPU to Host
-  if (PINNED == memMode) {
-    if (bDontUseGPUTiming) sdkStartTimer(&timer);
-    checkCudaErrors(cudaEventRecord(start, 0));
-    for (unsigned int i = 0; i < MEMCOPY_ITERATIONS; i++) {
-      checkCudaErrors(cudaMemcpyAsync(h_odata, d_idata, memSize,
-                                      cudaMemcpyDeviceToHost, 0));
-    }
-    checkCudaErrors(cudaEventRecord(stop, 0));
-    checkCudaErrors(cudaDeviceSynchronize());
-    checkCudaErrors(cudaEventElapsedTime(&elapsedTimeInMs, start, stop));
-    if (bDontUseGPUTiming) {
-      sdkStopTimer(&timer);
-      elapsedTimeInMs = sdkGetTimerValue(&timer);
-      sdkResetTimer(&timer);
-    }
-  } else {
-    elapsedTimeInMs = 0;
-    for (unsigned int i = 0; i < MEMCOPY_ITERATIONS; i++) {
-      sdkStartTimer(&timer);
-      checkCudaErrors(
-          cudaMemcpy(h_odata, d_idata, memSize, cudaMemcpyDeviceToHost));
-      sdkStopTimer(&timer);
-      elapsedTimeInMs += sdkGetTimerValue(&timer);
-      sdkResetTimer(&timer);
-      memset(flush_buf, i, FLUSH_SIZE);
-    }
-  }
-
-  // calculate bandwidth in GB/s
-  double time_s = elapsedTimeInMs / 1e3;
-  bandwidthInGBs = (memSize * (float)MEMCOPY_ITERATIONS) / (double)1e9;
-  bandwidthInGBs = bandwidthInGBs / time_s;
-  // clean up memory
-  checkCudaErrors(cudaEventDestroy(stop));
-  checkCudaErrors(cudaEventDestroy(start));
-  sdkDeleteTimer(&timer);
-
-  if (PINNED == memMode) {
-    checkCudaErrors(cudaFreeHost(h_idata));
-    checkCudaErrors(cudaFreeHost(h_odata));
-  } else {
-    free(h_idata);
-    free(h_odata);
-  }
-
-  checkCudaErrors(cudaFree(d_idata));
-
-  return bandwidthInGBs;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//! test the bandwidth of a host to device memcopy of a specific size
-///////////////////////////////////////////////////////////////////////////////
-float testHostToDeviceTransfer(unsigned int memSize, memoryMode memMode,
-                               bool wc) {
-  StopWatchInterface *timer = NULL;
-  float elapsedTimeInMs = 0.0f;
-  float bandwidthInGBs = 0.0f;
-  cudaEvent_t start, stop;
-  sdkCreateTimer(&timer);
-  checkCudaErrors(cudaEventCreate(&start));
-  checkCudaErrors(cudaEventCreate(&stop));
-
-  // allocate host memory
-  unsigned char *h_odata = NULL;
-
-  if (PINNED == memMode) {
-#if CUDART_VERSION >= 2020
-    // pinned memory mode - use special function to get OS-pinned memory
-    checkCudaErrors(cudaHostAlloc((void **)&h_odata, memSize,
-                                  (wc) ? cudaHostAllocWriteCombined : 0));
-#else
-    // pinned memory mode - use special function to get OS-pinned memory
-    checkCudaErrors(cudaMallocHost((void **)&h_odata, memSize));
-#endif
-  } else {
-    // pageable memory mode - use malloc
-    h_odata = (unsigned char *)malloc(memSize);
-
-    if (h_odata == 0) {
-      fprintf(stderr, "Not enough memory available on host to run test!\n");
-      exit(EXIT_FAILURE);
-    }
-  }
-
-  unsigned char *h_cacheClear1 = (unsigned char *)malloc(CACHE_CLEAR_SIZE);
-  unsigned char *h_cacheClear2 = (unsigned char *)malloc(CACHE_CLEAR_SIZE);
-
-  if (h_cacheClear1 == 0 || h_cacheClear2 == 0) {
-    fprintf(stderr, "Not enough memory available on host to run test!\n");
-    exit(EXIT_FAILURE);
-  }
-
-  // initialize the memory
-  for (unsigned int i = 0; i < memSize / sizeof(unsigned char); i++) {
-    h_odata[i] = (unsigned char)(i & 0xff);
-  }
-
-  for (unsigned int i = 0; i < CACHE_CLEAR_SIZE / sizeof(unsigned char); i++) {
-    h_cacheClear1[i] = (unsigned char)(i & 0xff);
-    h_cacheClear2[i] = (unsigned char)(0xff - (i & 0xff));
-  }
-
-  // allocate device memory
-  unsigned char *d_idata;
-  checkCudaErrors(cudaMalloc((void **)&d_idata, memSize));
-
-  // copy host memory to device memory
-  if (PINNED == memMode) {
-    if (bDontUseGPUTiming) sdkStartTimer(&timer);
-    checkCudaErrors(cudaEventRecord(start, 0));
-    for (unsigned int i = 0; i < MEMCOPY_ITERATIONS; i++) {
-      checkCudaErrors(cudaMemcpyAsync(d_idata, h_odata, memSize,
-                                      cudaMemcpyHostToDevice, 0));
-    }
-    checkCudaErrors(cudaEventRecord(stop, 0));
-    checkCudaErrors(cudaDeviceSynchronize());
-    checkCudaErrors(cudaEventElapsedTime(&elapsedTimeInMs, start, stop));
-    if (bDontUseGPUTiming) {
-      sdkStopTimer(&timer);
-      elapsedTimeInMs = sdkGetTimerValue(&timer);
-      sdkResetTimer(&timer);
-    }
-  } else {
-    elapsedTimeInMs = 0;
-    for (unsigned int i = 0; i < MEMCOPY_ITERATIONS; i++) {
-      sdkStartTimer(&timer);
-      checkCudaErrors(
-          cudaMemcpy(d_idata, h_odata, memSize, cudaMemcpyHostToDevice));
-      sdkStopTimer(&timer);
-      elapsedTimeInMs += sdkGetTimerValue(&timer);
-      sdkResetTimer(&timer);
-      memset(flush_buf, i, FLUSH_SIZE);
-    }
-  }
-
-  // calculate bandwidth in GB/s
-  double time_s = elapsedTimeInMs / 1e3;
-  bandwidthInGBs = (memSize * (float)MEMCOPY_ITERATIONS) / (double)1e9;
-  bandwidthInGBs = bandwidthInGBs / time_s;
-  // clean up memory
-  checkCudaErrors(cudaEventDestroy(stop));
-  checkCudaErrors(cudaEventDestroy(start));
-  sdkDeleteTimer(&timer);
-
-  if (PINNED == memMode) {
-    checkCudaErrors(cudaFreeHost(h_odata));
-  } else {
-    free(h_odata);
-  }
-
-  free(h_cacheClear1);
-  free(h_cacheClear2);
-  checkCudaErrors(cudaFree(d_idata));
-
-  return bandwidthInGBs;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//! test the bandwidth of a device to device memcopy of a specific size
-///////////////////////////////////////////////////////////////////////////////
-float testDeviceToDeviceTransfer(unsigned int memSize) {
-  StopWatchInterface *timer = NULL;
-  float elapsedTimeInMs = 0.0f;
-  float bandwidthInGBs = 0.0f;
-  cudaEvent_t start, stop;
-
-  sdkCreateTimer(&timer);
-  checkCudaErrors(cudaEventCreate(&start));
-  checkCudaErrors(cudaEventCreate(&stop));
-
-  // allocate host memory
-  unsigned char *h_idata = (unsigned char *)malloc(memSize);
-
-  if (h_idata == 0) {
-    fprintf(stderr, "Not enough memory avaialable on host to run test!\n");
-    exit(EXIT_FAILURE);
-  }
-
-  // initialize the host memory
-  for (unsigned int i = 0; i < memSize / sizeof(unsigned char); i++) {
-    h_idata[i] = (unsigned char)(i & 0xff);
-  }
-
-  // allocate device memory
-  unsigned char *d_idata;
-  checkCudaErrors(cudaMalloc((void **)&d_idata, memSize));
-  unsigned char *d_odata;
-  checkCudaErrors(cudaMalloc((void **)&d_odata, memSize));
-
-  // initialize memory
-  checkCudaErrors(
-      cudaMemcpy(d_idata, h_idata, memSize, cudaMemcpyHostToDevice));
-
-  // run the memcopy
-  sdkStartTimer(&timer);
-  checkCudaErrors(cudaEventRecord(start, 0));
-
-  for (unsigned int i = 0; i < MEMCOPY_ITERATIONS; i++) {
-    checkCudaErrors(
-        cudaMemcpy(d_odata, d_idata, memSize, cudaMemcpyDeviceToDevice));
-  }
-
-  checkCudaErrors(cudaEventRecord(stop, 0));
-
-  // Since device to device memory copies are non-blocking,
-  // cudaDeviceSynchronize() is required in order to get
-  // proper timing.
-  checkCudaErrors(cudaDeviceSynchronize());
-
-  // get the total elapsed time in ms
-  sdkStopTimer(&timer);
-  checkCudaErrors(cudaEventElapsedTime(&elapsedTimeInMs, start, stop));
-
-  if (bDontUseGPUTiming) {
-    elapsedTimeInMs = sdkGetTimerValue(&timer);
-  }
-
-  // calculate bandwidth in GB/s
-  double time_s = elapsedTimeInMs / 1e3;
-  bandwidthInGBs = (2.0f * memSize * (float)MEMCOPY_ITERATIONS) / (double)1e9;
-  bandwidthInGBs = bandwidthInGBs / time_s;
-
-  // clean up memory
-  sdkDeleteTimer(&timer);
-  free(h_idata);
-  checkCudaErrors(cudaEventDestroy(stop));
-  checkCudaErrors(cudaEventDestroy(start));
-  checkCudaErrors(cudaFree(d_idata));
-  checkCudaErrors(cudaFree(d_odata));
-
-  return bandwidthInGBs;
-}
-
-/////////////////////////////////////////////////////////
-// print results in an easily read format
-////////////////////////////////////////////////////////
-void printResultsReadable(unsigned int *memSizes, double *bandwidths,
-                          unsigned int count, memcpyKind kind,
-                          memoryMode memMode, int iNumDevs, bool wc) {
-  printf(" %s Bandwidth, %i Device(s)\n", sMemoryCopyKind[kind], iNumDevs);
-  printf(" %s Memory Transfers\n", sMemoryMode[memMode]);
-
-  if (wc) {
-    printf(" Write-Combined Memory Writes are Enabled");
-  }
-
-  printf("   Transfer Size (Bytes)\tBandwidth(GB/s)\n");
-  unsigned int i;
-
-  for (i = 0; i < (count - 1); i++) {
-    printf("   %u\t\t\t%s%.1f\n", memSizes[i],
-           (memSizes[i] < 10000) ? "\t" : "", bandwidths[i]);
-  }
-
-  printf("   %u\t\t\t%s%.1f\n\n", memSizes[i],
-         (memSizes[i] < 10000) ? "\t" : "", bandwidths[i]);
-}
-
-///////////////////////////////////////////////////////////////////////////
-// print results in a database format
-///////////////////////////////////////////////////////////////////////////
-void printResultsCSV(unsigned int *memSizes, double *bandwidths,
-                     unsigned int count, memcpyKind kind, memoryMode memMode,
-                     int iNumDevs, bool wc) {
-  std::string sConfig;
-
-  // log config information
-  if (kind == DEVICE_TO_DEVICE) {
-    sConfig += "D2D";
-  } else {
-    if (kind == DEVICE_TO_HOST) {
-      sConfig += "D2H";
-    } else if (kind == HOST_TO_DEVICE) {
-      sConfig += "H2D";
-    }
-
-    if (memMode == PAGEABLE) {
-      sConfig += "-Paged";
-    } else if (memMode == PINNED) {
-      sConfig += "-Pinned";
-
-      if (wc) {
-        sConfig += "-WriteCombined";
-      }
-    }
-  }
-
-  unsigned int i;
-  double dSeconds = 0.0;
-
-  for (i = 0; i < count; i++) {
-    dSeconds = (double)memSizes[i] / (bandwidths[i] * (double)(1 << 20));
-    printf(
-        "bandwidthTest-%s, Bandwidth = %.1f GB/s, Time = %.5f s, Size = %u "
-        "bytes, NumDevsUsed = %d\n",
-        sConfig.c_str(), bandwidths[i], dSeconds, memSizes[i], iNumDevs);
-  }
-}
-
-///////////////////////////////////////////////////////////////////////////
-// Print help screen
-///////////////////////////////////////////////////////////////////////////
-void printHelp(void) {
-  printf("Usage:  bandwidthTest [OPTION]...\n");
-  printf(
-      "Test the bandwidth for device to host, host to device, and device to "
-      "device transfers\n");
-  printf("\n");
-  printf(
-      "Example:  measure the bandwidth of device to host pinned memory copies "
-      "in the range 1024 Bytes to 102400 Bytes in 1024 Byte increments\n");
-  printf(
-      "./bandwidthTest --memory=pinned --mode=range --start=1024 --end=102400 "
-      "--increment=1024 --dtoh\n");
-
-  printf("\n");
-  printf("Options:\n");
-  printf("--help\tDisplay this help menu\n");
-  printf("--csv\tPrint results as a CSV\n");
-  printf("--device=[deviceno]\tSpecify the device device to be used\n");
-  printf("  all - compute cumulative bandwidth on all the devices\n");
-  printf("  0,1,2,...,n - Specify any particular device to be used\n");
-  printf("--memory=[MEMMODE]\tSpecify which memory mode to use\n");
-  printf("  pageable - pageable memory\n");
-  printf("  pinned   - non-pageable system memory\n");
-  printf("--mode=[MODE]\tSpecify the mode to use\n");
-  printf("  quick - performs a quick measurement\n");
-  printf("  range - measures a user-specified range of values\n");
-  printf("  shmoo - performs an intense shmoo of a large range of values\n");
-
-  printf("--htod\tMeasure host to device transfers\n");
-  printf("--dtoh\tMeasure device to host transfers\n");
-  printf("--dtod\tMeasure device to device transfers\n");
-#if CUDART_VERSION >= 2020
-  printf("--wc\tAllocate pinned memory as write-combined\n");
-#endif
-  printf("--cputiming\tForce CPU-based timing always\n");
-
-  printf("Range mode options\n");
-  printf("--start=[SIZE]\tStarting transfer size in bytes\n");
-  printf("--end=[SIZE]\tEnding transfer size in bytes\n");
-  printf("--increment=[SIZE]\tIncrement size in bytes\n");
-}

Samples/bandwidthTest/bandwidthTest_vs2012.sln

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

Samples/bandwidthTest/bandwidthTest_vs2012.vcxproj

@@ -1,107 +0,0 @@
-<?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>bandwidthTest_vs2012</RootNamespace>
-    <ProjectName>bandwidthTest</ProjectName>
-    <CudaToolkitCustomDir />
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup>
-    <ConfigurationType>Application</ConfigurationType>
-    <CharacterSet>MultiByte</CharacterSet>
-    <PlatformToolset>v110</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 10.1.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)/bandwidthTest.exe</OutputFile>
-    </Link>
-    <CudaCompile>
-      <CodeGeneration>compute_30,sm_30;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;</CodeGeneration>
-      <AdditionalOptions>-Xcompiler "/wd 4819" %(AdditionalOptions)</AdditionalOptions>
-      <Include>./;../../Common</Include>
-      <Defines>WIN32</Defines>
-    </CudaCompile>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)'=='Debug'">
-    <ClCompile>
-      <Optimization>Disabled</Optimization>
-      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
-    </ClCompile>
-    <Link>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
-    </Link>
-    <CudaCompile>
-      <Runtime>MTd</Runtime>
-      <TargetMachinePlatform>64</TargetMachinePlatform>
-    </CudaCompile>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)'=='Release'">
-    <ClCompile>
-      <Optimization>MaxSpeed</Optimization>
-      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
-    </ClCompile>
-    <Link>
-      <GenerateDebugInformation>false</GenerateDebugInformation>
-      <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
-    </Link>
-    <CudaCompile>
-      <Runtime>MT</Runtime>
-      <TargetMachinePlatform>64</TargetMachinePlatform>
-    </CudaCompile>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <CudaCompile Include="bandwidthTest.cu" />
-
-  </ItemGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-    <Import Project="$(CUDAPropsPath)\CUDA 10.1.targets" />
-  </ImportGroup>
-</Project>

Samples/bandwidthTest/bandwidthTest_vs2013.sln

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

Samples/bandwidthTest/bandwidthTest_vs2013.vcxproj

@@ -1,107 +0,0 @@
-<?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>bandwidthTest_vs2013</RootNamespace>
-    <ProjectName>bandwidthTest</ProjectName>
-    <CudaToolkitCustomDir />
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup>
-    <ConfigurationType>Application</ConfigurationType>
-    <CharacterSet>MultiByte</CharacterSet>
-    <PlatformToolset>v120</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 10.1.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)/bandwidthTest.exe</OutputFile>
-    </Link>
-    <CudaCompile>
-      <CodeGeneration>compute_30,sm_30;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;</CodeGeneration>
-      <AdditionalOptions>-Xcompiler "/wd 4819" %(AdditionalOptions)</AdditionalOptions>
-      <Include>./;../../Common</Include>
-      <Defines>WIN32</Defines>
-    </CudaCompile>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)'=='Debug'">
-    <ClCompile>
-      <Optimization>Disabled</Optimization>
-      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
-    </ClCompile>
-    <Link>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
-    </Link>
-    <CudaCompile>
-      <Runtime>MTd</Runtime>
-      <TargetMachinePlatform>64</TargetMachinePlatform>
-    </CudaCompile>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)'=='Release'">
-    <ClCompile>
-      <Optimization>MaxSpeed</Optimization>
-      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
-    </ClCompile>
-    <Link>
-      <GenerateDebugInformation>false</GenerateDebugInformation>
-      <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
-    </Link>
-    <CudaCompile>
-      <Runtime>MT</Runtime>
-      <TargetMachinePlatform>64</TargetMachinePlatform>
-    </CudaCompile>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <CudaCompile Include="bandwidthTest.cu" />
-
-  </ItemGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-    <Import Project="$(CUDAPropsPath)\CUDA 10.1.targets" />
-  </ImportGroup>
-</Project>

Samples/bandwidthTest/bandwidthTest_vs2015.sln

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

Samples/bandwidthTest/bandwidthTest_vs2015.vcxproj

@@ -1,107 +0,0 @@
-<?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>bandwidthTest_vs2015</RootNamespace>
-    <ProjectName>bandwidthTest</ProjectName>
-    <CudaToolkitCustomDir />
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup>
-    <ConfigurationType>Application</ConfigurationType>
-    <CharacterSet>MultiByte</CharacterSet>
-    <PlatformToolset>v140</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 10.1.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)/bandwidthTest.exe</OutputFile>
-    </Link>
-    <CudaCompile>
-      <CodeGeneration>compute_30,sm_30;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;</CodeGeneration>
-      <AdditionalOptions>-Xcompiler "/wd 4819" %(AdditionalOptions)</AdditionalOptions>
-      <Include>./;../../Common</Include>
-      <Defines>WIN32</Defines>
-    </CudaCompile>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)'=='Debug'">
-    <ClCompile>
-      <Optimization>Disabled</Optimization>
-      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
-    </ClCompile>
-    <Link>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
-    </Link>
-    <CudaCompile>
-      <Runtime>MTd</Runtime>
-      <TargetMachinePlatform>64</TargetMachinePlatform>
-    </CudaCompile>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)'=='Release'">
-    <ClCompile>
-      <Optimization>MaxSpeed</Optimization>
-      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
-    </ClCompile>
-    <Link>
-      <GenerateDebugInformation>false</GenerateDebugInformation>
-      <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
-    </Link>
-    <CudaCompile>
-      <Runtime>MT</Runtime>
-      <TargetMachinePlatform>64</TargetMachinePlatform>
-    </CudaCompile>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <CudaCompile Include="bandwidthTest.cu" />
-
-  </ItemGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-    <Import Project="$(CUDAPropsPath)\CUDA 10.1.targets" />
-  </ImportGroup>
-</Project>

Samples/bandwidthTest/bandwidthTest_vs2017.sln

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

Samples/bandwidthTest/bandwidthTest_vs2017.vcxproj

@@ -1,108 +0,0 @@
-<?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>bandwidthTest_vs2017</RootNamespace>
-    <ProjectName>bandwidthTest</ProjectName>
-    <CudaToolkitCustomDir />
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup>
-    <ConfigurationType>Application</ConfigurationType>
-    <CharacterSet>MultiByte</CharacterSet>
-    <PlatformToolset>v141</PlatformToolset>
-	<WindowsTargetPlatformVersion>10.0.15063.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 10.1.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)/bandwidthTest.exe</OutputFile>
-    </Link>
-    <CudaCompile>
-      <CodeGeneration>compute_30,sm_30;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;</CodeGeneration>
-      <AdditionalOptions>-Xcompiler "/wd 4819" %(AdditionalOptions)</AdditionalOptions>
-      <Include>./;../../Common</Include>
-      <Defines>WIN32</Defines>
-    </CudaCompile>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)'=='Debug'">
-    <ClCompile>
-      <Optimization>Disabled</Optimization>
-      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
-    </ClCompile>
-    <Link>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
-    </Link>
-    <CudaCompile>
-      <Runtime>MTd</Runtime>
-      <TargetMachinePlatform>64</TargetMachinePlatform>
-    </CudaCompile>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)'=='Release'">
-    <ClCompile>
-      <Optimization>MaxSpeed</Optimization>
-      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
-    </ClCompile>
-    <Link>
-      <GenerateDebugInformation>false</GenerateDebugInformation>
-      <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
-    </Link>
-    <CudaCompile>
-      <Runtime>MT</Runtime>
-      <TargetMachinePlatform>64</TargetMachinePlatform>
-    </CudaCompile>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <CudaCompile Include="bandwidthTest.cu" />
-
-  </ItemGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-    <Import Project="$(CUDAPropsPath)\CUDA 10.1.targets" />
-  </ImportGroup>
-</Project>

Samples/conjugateGradientCudaGraphs/Makefile

@@ -1,306 +0,0 @@
-################################################################################
-# Copyright (c) 2018, 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 ppc64le armv7l))
-    ifneq ($(TARGET_ARCH),$(HOST_ARCH))
-        ifneq (,$(filter $(TARGET_ARCH),x86_64 aarch64 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
-ifneq ($(TARGET_ARCH),$(HOST_ARCH))
-    ifeq (,$(filter $(HOST_ARCH)-$(TARGET_ARCH),aarch64-armv7l x86_64-armv7l x86_64-aarch64 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/aarch64-unknown-nto-qnx7.0.0-g++
-        else ifeq ($(TARGET_OS), android)
-            HOST_COMPILER ?= aarch64-linux-android-clang++
-        endif
-    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)/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
-            CCFLAGS += -isystem=$(TARGET_FS)/usr/include/aarch64-linux-gnu
-        endif
-    endif
-endif
-
-ifeq ($(TARGET_OS),qnx)
-    CCFLAGS += -DWIN_INTERFACE_CUSTOM
-    LDFLAGS += -lsocket
-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),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 :=
-
-################################################################################
-
-# Gencode arguments
-ifeq ($(TARGET_ARCH),$(filter $(TARGET_ARCH),armv7l aarch64))
-SMS ?= 30 35 37 50 52 60 61 70 72 75
-else
-SMS ?= 30 35 37 50 52 60 61 70 75
-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
-
-LIBRARIES += -lcublas_static -lcublasLt_static -lcusparse_static -lculibos
-
-ifeq ($(SAMPLE_ENABLED),0)
-EXEC ?= @echo "[@]"
-endif
-
-################################################################################
-
-# Target rules
-all: build
-
-build: conjugateGradientCudaGraphs
-
-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
-
-conjugateGradientCudaGraphs.o:conjugateGradientCudaGraphs.cu
-	$(EXEC) $(NVCC) $(INCLUDES) $(ALL_CCFLAGS) $(GENCODE_FLAGS) -o $@ -c $<
-
-conjugateGradientCudaGraphs: conjugateGradientCudaGraphs.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) ./conjugateGradientCudaGraphs
-
-clean:
-	rm -f conjugateGradientCudaGraphs conjugateGradientCudaGraphs.o
-	rm -rf ../../bin/$(TARGET_ARCH)/$(TARGET_OS)/$(BUILD_TYPE)/conjugateGradientCudaGraphs
-
-clobber: clean

Samples/conjugateGradientCudaGraphs/NsightEclipse.xml

@@ -1,86 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?> 
-<!DOCTYPE entry SYSTEM "SamplesInfo.dtd">
-<entry>
-  <name>conjugateGradientCudaGraphs</name>
-  <cuda_api_list>
-    <toolkit>cudaStreamBeginCapture</toolkit>
-    <toolkit>cudaStreamEndCapture</toolkit>
-    <toolkit>cudaGraphCreate</toolkit>
-    <toolkit>cudaGraphLaunch</toolkit>
-    <toolkit>cudaGraphInstantiate</toolkit>
-    <toolkit>cudaGraphExecDestroy</toolkit>
-    <toolkit>cudaGraphDestroy</toolkit>
-  </cuda_api_list>
-  <description><![CDATA[This sample implements a conjugate gradient solver on GPU using CUBLAS and CUSPARSE library calls captured and called using CUDA Graph APIs.]]></description>
-  <devicecompilation>whole</devicecompilation>
-  <includepaths>
-    <path>./</path>
-    <path>../</path>
-    <path>../../common/inc</path>
-  </includepaths>
-  <keyconcepts>
-    <concept level="advanced">Linear Algebra</concept>
-    <concept level="advanced">CUBLAS Library</concept>
-    <concept level="advanced">CUSPARSE Library</concept>
-  </keyconcepts>
-  <keywords>
-    <keyword>CUDA</keyword>
-    <keyword>CUBLAS</keyword>
-    <keyword>CUSPARSE</keyword>
-    <keyword>Sparse Matrix</keyword>
-  </keywords>
-  <libraries>
-    <library>cublas_static</library>
-    <library>cublasLt_static</library>
-    <library>cusparse_static</library>
-    <library>culibos</library>
-  </libraries>
-  <librarypaths>
-  </librarypaths>
-  <nsight_eclipse>true</nsight_eclipse>
-  <primary_file>conjugateGradientCudaGraphs.cu</primary_file>
-  <required_dependencies>
-    <dependency>CUBLAS</dependency>
-    <dependency>CUSPARSE</dependency>
-  </required_dependencies>
-  <scopes>
-    <scope>1:CUDA Advanced Topics</scope>
-    <scope>3:Linear Algebra</scope>
-    <scope>1:CUDA Graphs</scope>
-  </scopes>
-  <sm-arch>sm30</sm-arch>
-  <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>
-  <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>Conjugate Gradient using Cuda Graphs</title>
-  <type>exe</type>
-</entry>

Samples/conjugateGradientCudaGraphs/README.md

@@ -1,98 +0,0 @@
-# conjugateGradientCudaGraphs - Conjugate Gradient using Cuda Graphs
-
-## Description
-
-This sample implements a conjugate gradient solver on GPU using CUBLAS and CUSPARSE library calls captured and called using CUDA Graph APIs.
-
-## Key Concepts
-
-Linear Algebra, CUBLAS Library, CUSPARSE Library
-
-## Supported SM Architectures
-
-[SM 3.0 ](https://developer.nvidia.com/cuda-gpus)  [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)
-
-## Supported OSes
-
-Linux, Windows, MacOSX
-
-## Supported CPU Architecture
-
-x86_64, ppc64le, armv7l
-
-## CUDA APIs involved
-
-### [CUDA Runtime API](http://docs.nvidia.com/cuda/cuda-runtime-api/index.html)
-cudaStreamBeginCapture, cudaStreamEndCapture, cudaGraphCreate, cudaGraphLaunch, cudaGraphInstantiate, cudaGraphExecDestroy, cudaGraphDestroy
-
-## Dependencies needed to build/run
-[CUBLAS](../../README.md#cublas), [CUSPARSE](../../README.md#cusparse)
-
-## Prerequisites
-
-Download and install the [CUDA Toolkit 10.1](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++
-```
-
-### Mac
-The Mac samples are built using makefiles. To use the makefiles, change directory into the sample directory you wish to build, and run make:
-```
-$ cd <sample_dir>
-$ make
-```
-
-The samples makefiles can take advantage of certain options:
-
-*  **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="A B ..."
-    ```
-
-*  **HOST_COMPILER=<host_compiler>** - override the default clang host compiler. See the [Mac Installation Guide](http://docs.nvidia.com/cuda/cuda-installation-guide-mac-os-x/index.html#system-requirements) for a list of supported host compilers.
-    ```
-    $ make HOST_COMPILER=clang
-    ```
-
-## References (for more details)
-

Samples/conjugateGradientCudaGraphs/conjugateGradientCudaGraphs.cu

@@ -1,466 +0,0 @@
-/* Copyright (c) 2018, 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 implements a conjugate gradient solver on GPU
- * using CUBLAS and CUSPARSE with CUDA Graphs
- *
- */
-
-// includes, system
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-/* Using updated (v2) interfaces to cublas */
-#include <cublas_v2.h>
-#include <cuda_runtime.h>
-#include <cusparse.h>
-
-#include <cooperative_groups.h>
-
-// Utilities and system includes
-#include <helper_cuda.h>  // helper function CUDA error checking and initialization
-#include <helper_functions.h>  // helper for shared functions common to CUDA Samples
-
-namespace cg = cooperative_groups;
-
-const char *sSDKname = "conjugateGradientCudaGraphs";
-
-#ifndef WITH_GRAPH
-#define WITH_GRAPH 1
-#endif
-
-/* genTridiag: generate a random tridiagonal symmetric matrix */
-void genTridiag(int *I, int *J, float *val, int N, int nz) {
-  I[0] = 0, J[0] = 0, J[1] = 1;
-  val[0] = (float)rand() / RAND_MAX + 10.0f;
-  val[1] = (float)rand() / RAND_MAX;
-  int start;
-
-  for (int i = 1; i < N; i++) {
-    if (i > 1) {
-      I[i] = I[i - 1] + 3;
-    } else {
-      I[1] = 2;
-    }
-
-    start = (i - 1) * 3 + 2;
-    J[start] = i - 1;
-    J[start + 1] = i;
-
-    if (i < N - 1) {
-      J[start + 2] = i + 1;
-    }
-
-    val[start] = val[start - 1];
-    val[start + 1] = (float)rand() / RAND_MAX + 10.0f;
-
-    if (i < N - 1) {
-      val[start + 2] = (float)rand() / RAND_MAX;
-    }
-  }
-
-  I[N] = nz;
-}
-
-__global__ void initVectors(float *rhs, float *x, int N) {
-  size_t gid = blockIdx.x * blockDim.x + threadIdx.x;
-
-  for (size_t i = gid; i < N; i += gridDim.x * blockDim.x) {
-    rhs[i] = 1.0;
-    x[i] = 0.0;
-  }
-}
-
-__global__ void gpuDotProduct(float *vecA, float *vecB, float *result,
-                              int size) {
-  cg::thread_block cta = cg::this_thread_block();
-
-  int gid = blockIdx.x * blockDim.x + threadIdx.x;
-  extern __shared__ double tmp[];
-
-  double temp_sum = 0.0;
-  for (int i = gid; i < size; i += gridDim.x * blockDim.x) {
-    temp_sum += (double)(vecA[i] * vecB[i]);
-  }
-  tmp[cta.thread_rank()] = temp_sum;
-
-  cg::sync(cta);
-
-  cg::thread_block_tile<32> tile32 = cg::tiled_partition<32>(cta);
-
-  double beta = temp_sum;
-  double temp;
-
-  for (int i = tile32.size() / 2; i > 0; i >>= 1) {
-    if (tile32.thread_rank() < i) {
-      temp = tmp[cta.thread_rank() + i];
-      beta += temp;
-      tmp[cta.thread_rank()] = beta;
-    }
-    cg::sync(tile32);
-  }
-  cg::sync(cta);
-
-  if (cta.thread_rank() == 0) {
-    beta = 0.0;
-    for (int i = 0; i < cta.size(); i += tile32.size()) {
-      beta += tmp[i];
-    }
-    atomicAdd(result, (float)beta);
-  }
-}
-
-__global__ void gpuSpMV(int *I, int *J, float *val, int nnz, int num_rows,
-                        float alpha, float *inputVecX, float *outputVecY) {
-  size_t gid = blockIdx.x * blockDim.x + threadIdx.x;
-  for (size_t i = gid; i < num_rows; i += blockDim.x * gridDim.x) {
-    int row_elem = I[i];
-    int next_row_elem = I[i + 1];
-    int num_elems_this_row = next_row_elem - row_elem;
-
-    float output = 0.0;
-    for (int j = 0; j < num_elems_this_row; j++) {
-      output += alpha * val[row_elem + j] * inputVecX[J[row_elem + j]];
-    }
-
-    outputVecY[i] = output;
-  }
-}
-
-__global__ void r1_div_x(float *r1, float *r0, float *b) {
-  int gid = blockIdx.x * blockDim.x + threadIdx.x;
-  if (gid == 0) {
-    b[0] = r1[0] / r0[0];
-  }
-}
-
-__global__ void a_minus(float *a, float *na) {
-  int gid = blockIdx.x * blockDim.x + threadIdx.x;
-  if (gid == 0) {
-    na[0] = -(a[0]);
-  }
-}
-
-int main(int argc, char **argv) {
-  int N = 0, nz = 0, *I = NULL, *J = NULL;
-  float *val = NULL;
-  const float tol = 1e-5f;
-  const int max_iter = 10000;
-  float *x;
-  float *rhs;
-  float r1;
-
-  int *d_col, *d_row;
-  float *d_val, *d_x;
-  float *d_r, *d_p, *d_Ax;
-  int k;
-  float alpha, beta, alpham1;
-
-  cudaStream_t stream1, streamForGraph;
-
-  // This will pick the best possible CUDA capable device
-  cudaDeviceProp deviceProp;
-  int devID = findCudaDevice(argc, (const char **)argv);
-
-  if (devID < 0) {
-    printf("exiting...\n");
-    exit(EXIT_SUCCESS);
-  }
-
-  checkCudaErrors(cudaGetDeviceProperties(&deviceProp, devID));
-
-  // Statistics about the GPU device
-  printf(
-      "> GPU device has %d Multi-Processors, SM %d.%d compute capabilities\n\n",
-      deviceProp.multiProcessorCount, deviceProp.major, deviceProp.minor);
-
-  /* Generate a random tridiagonal symmetric matrix in CSR format */
-  N = 1048576;
-  nz = (N - 2) * 3 + 4;
-  I = (int *)malloc(sizeof(int) * (N + 1));
-  J = (int *)malloc(sizeof(int) * nz);
-  val = (float *)malloc(sizeof(float) * nz);
-  genTridiag(I, J, val, N, nz);
-
-  x = (float *)malloc(sizeof(float) * N);
-  rhs = (float *)malloc(sizeof(float) * N);
-
-  for (int i = 0; i < N; i++) {
-    rhs[i] = 1.0;
-    x[i] = 0.0;
-  }
-
-  /* Get handle to the CUBLAS context */
-  cublasHandle_t cublasHandle = 0;
-  cublasStatus_t cublasStatus;
-  cublasStatus = cublasCreate(&cublasHandle);
-
-  checkCudaErrors(cublasStatus);
-
-  /* Get handle to the CUSPARSE context */
-  cusparseHandle_t cusparseHandle = 0;
-  cusparseStatus_t cusparseStatus;
-  cusparseStatus = cusparseCreate(&cusparseHandle);
-
-  checkCudaErrors(cusparseStatus);
-
-  checkCudaErrors(cudaStreamCreate(&stream1));
-
-  checkCudaErrors(cudaMalloc((void **)&d_col, nz * sizeof(int)));
-  checkCudaErrors(cudaMalloc((void **)&d_row, (N + 1) * sizeof(int)));
-  checkCudaErrors(cudaMalloc((void **)&d_val, nz * sizeof(float)));
-  checkCudaErrors(cudaMalloc((void **)&d_x, N * sizeof(float)));
-  checkCudaErrors(cudaMalloc((void **)&d_r, N * sizeof(float)));
-  checkCudaErrors(cudaMalloc((void **)&d_p, N * sizeof(float)));
-  checkCudaErrors(cudaMalloc((void **)&d_Ax, N * sizeof(float)));
-
-  float *d_r1, *d_r0, *d_dot, *d_a, *d_na, *d_b;
-  checkCudaErrors(cudaMalloc((void **)&d_r1, sizeof(float)));
-  checkCudaErrors(cudaMalloc((void **)&d_r0, sizeof(float)));
-  checkCudaErrors(cudaMalloc((void **)&d_dot, sizeof(float)));
-  checkCudaErrors(cudaMalloc((void **)&d_a, sizeof(float)));
-  checkCudaErrors(cudaMalloc((void **)&d_na, sizeof(float)));
-  checkCudaErrors(cudaMalloc((void **)&d_b, sizeof(float)));
-
-  cusparseMatDescr_t descr = 0;
-  checkCudaErrors(cusparseCreateMatDescr(&descr));
-
-  checkCudaErrors(cusparseSetMatType(descr, CUSPARSE_MATRIX_TYPE_GENERAL));
-  checkCudaErrors(cusparseSetMatIndexBase(descr, CUSPARSE_INDEX_BASE_ZERO));
-
-  int numBlocks = 0, blockSize = 0, numBlocks2 = 0, blockSize2 = 0;
-  checkCudaErrors(
-      cudaOccupancyMaxPotentialBlockSize(&numBlocks, &blockSize, initVectors));
-
-  checkCudaErrors(cudaMemcpyAsync(d_col, J, nz * sizeof(int),
-                                  cudaMemcpyHostToDevice, stream1));
-  checkCudaErrors(cudaMemcpyAsync(d_row, I, (N + 1) * sizeof(int),
-                                  cudaMemcpyHostToDevice, stream1));
-  checkCudaErrors(cudaMemcpyAsync(d_val, val, nz * sizeof(float),
-                                  cudaMemcpyHostToDevice, stream1));
-
-  initVectors<<<numBlocks, blockSize, 0, stream1>>>(d_r, d_x, N);
-
-  checkCudaErrors(cudaOccupancyMaxPotentialBlockSize(&numBlocks2, &blockSize2,
-                                                     gpuSpMV));
-  checkCudaErrors(cudaOccupancyMaxPotentialBlockSize(&numBlocks, &blockSize,
-                                                     gpuDotProduct));
-
-  alpha = 1.0;
-  alpham1 = -1.0;
-  beta = 0.0;
-
-  checkCudaErrors(cusparseSetStream(cusparseHandle, stream1));
-  checkCudaErrors(
-      cusparseScsrmv(cusparseHandle, CUSPARSE_OPERATION_NON_TRANSPOSE, N, N, nz,
-                     &alpha, descr, d_val, d_row, d_col, d_x, &beta, d_Ax));
-
-  checkCudaErrors(cublasSetStream(cublasHandle, stream1));
-  checkCudaErrors(cublasSaxpy(cublasHandle, N, &alpham1, d_Ax, 1, d_r, 1));
-
-  checkCudaErrors(
-      cublasSetPointerMode(cublasHandle, CUBLAS_POINTER_MODE_DEVICE));
-  checkCudaErrors(cublasSdot(cublasHandle, N, d_r, 1, d_r, 1, d_r1));
-
-  k = 1;
-  // First Iteration when k=1 starts
-  checkCudaErrors(cublasScopy(cublasHandle, N, d_r, 1, d_p, 1));
-  checkCudaErrors(
-      cusparseScsrmv(cusparseHandle, CUSPARSE_OPERATION_NON_TRANSPOSE, N, N, nz,
-                     &alpha, descr, d_val, d_row, d_col, d_p, &beta, d_Ax));
-
-  checkCudaErrors(cublasSdot(cublasHandle, N, d_p, 1, d_Ax, 1, d_dot));
-
-  r1_div_x<<<1, 1, 0, stream1>>>(d_r1, d_dot, d_a);
-
-  checkCudaErrors(cublasSaxpy(cublasHandle, N, d_a, d_p, 1, d_x, 1));
-
-  a_minus<<<1, 1, 0, stream1>>>(d_a, d_na);
-
-  checkCudaErrors(cublasSaxpy(cublasHandle, N, d_na, d_Ax, 1, d_r, 1));
-
-  checkCudaErrors(cudaMemcpyAsync(d_r0, d_r1, sizeof(float),
-                                  cudaMemcpyDeviceToDevice, stream1));
-
-  checkCudaErrors(cublasSdot(cublasHandle, N, d_r, 1, d_r, 1, d_r1));
-
-  checkCudaErrors(cudaMemcpyAsync(&r1, d_r1, sizeof(float),
-                                  cudaMemcpyDeviceToHost, stream1));
-  checkCudaErrors(cudaStreamSynchronize(stream1));
-  printf("iteration = %3d, residual = %e\n", k, sqrt(r1));
-  // First Iteration when k=1 ends
-  k++;
-
-#if WITH_GRAPH
-  cudaGraph_t initGraph;
-  checkCudaErrors(cudaStreamCreate(&streamForGraph));
-  checkCudaErrors(cublasSetStream(cublasHandle, stream1));
-  checkCudaErrors(cusparseSetStream(cusparseHandle, stream1));
-  checkCudaErrors(cudaStreamBeginCapture(stream1, cudaStreamCaptureModeGlobal));
-
-  r1_div_x<<<1, 1, 0, stream1>>>(d_r1, d_r0, d_b);
-  cublasSetPointerMode(cublasHandle, CUBLAS_POINTER_MODE_DEVICE);
-  checkCudaErrors(cublasSscal(cublasHandle, N, d_b, d_p, 1));
-  cublasSetPointerMode(cublasHandle, CUBLAS_POINTER_MODE_HOST);
-  checkCudaErrors(cublasSaxpy(cublasHandle, N, &alpha, d_r, 1, d_p, 1));
-  cublasSetPointerMode(cublasHandle, CUBLAS_POINTER_MODE_DEVICE);
-
-#if 0 // Use cusparseScsrmv API when it is cuda graph compliant
-  checkCudaErrors(
-      cusparseSetPointerMode(cusparseHandle, CUSPARSE_POINTER_MODE_HOST));
-  checkCudaErrors(
-      cusparseScsrmv(cusparseHandle, CUSPARSE_OPERATION_NON_TRANSPOSE, N, N, nz,
-                     &alpha, descr, d_val, d_row, d_col, d_p, &beta, d_Ax));
-#else
-  gpuSpMV<<<numBlocks2, blockSize2, 0, stream1>>>(d_row, d_col, d_val, nz,
-                                                        N, alpha, d_p, d_Ax);
-#endif
-
-  checkCudaErrors(cudaMemsetAsync(d_dot, 0, sizeof(float), stream1));
-  // Use cublasSdot API when it is cuda graph compliant.
-  // checkCudaErrors(cublasSdot(cublasHandle, N, d_p, 1, d_Ax, 1, d_dot));
-  gpuDotProduct<<<numBlocks, blockSize, blockSize * sizeof(double), stream1>>>(
-      d_p, d_Ax, d_dot, N);
-
-  r1_div_x<<<1, 1, 0, stream1>>>(d_r1, d_dot, d_a);
-
-  checkCudaErrors(cublasSaxpy(cublasHandle, N, d_a, d_p, 1, d_x, 1));
-
-  a_minus<<<1, 1, 0, stream1>>>(d_a, d_na);
-
-  checkCudaErrors(cublasSaxpy(cublasHandle, N, d_na, d_Ax, 1, d_r, 1));
-
-  checkCudaErrors(cudaMemcpyAsync(d_r0, d_r1, sizeof(float),
-                                  cudaMemcpyDeviceToDevice, stream1));
-  checkCudaErrors(cudaMemsetAsync(d_r1, 0, sizeof(float), stream1));
-  // Use cublasSdot API when it is cuda graph compliant.
-  // checkCudaErrors(cublasSdot(cublasHandle, N, d_r, 1, d_r, 1, d_r1));
-  gpuDotProduct<<<numBlocks, blockSize, blockSize * sizeof(double), stream1>>>(
-      d_r, d_r, d_r1, N);
-  checkCudaErrors(cudaMemcpyAsync((float *)&r1, d_r1, sizeof(float),
-                                  cudaMemcpyDeviceToHost, stream1));
-
-  checkCudaErrors(cudaStreamEndCapture(stream1, &initGraph));
-  cudaGraphExec_t graphExec;
-  checkCudaErrors(cudaGraphInstantiate(&graphExec, initGraph, NULL, NULL, 0));
-#endif
-
-  checkCudaErrors(cublasSetStream(cublasHandle, stream1));
-  checkCudaErrors(cusparseSetStream(cusparseHandle, stream1));
-
-  while (r1 > tol * tol && k <= max_iter) {
-#if WITH_GRAPH
-    checkCudaErrors(cudaGraphLaunch(graphExec, streamForGraph));
-    checkCudaErrors(cudaStreamSynchronize(streamForGraph));
-#else
-    r1_div_x<<<1, 1, 0, stream1>>>(d_r1, d_r0, d_b);
-    cublasSetPointerMode(cublasHandle, CUBLAS_POINTER_MODE_DEVICE);
-    checkCudaErrors(cublasSscal(cublasHandle, N, d_b, d_p, 1));
-
-    cublasSetPointerMode(cublasHandle, CUBLAS_POINTER_MODE_HOST);
-    checkCudaErrors(cublasSaxpy(cublasHandle, N, &alpha, d_r, 1, d_p, 1));
-
-    checkCudaErrors(cusparseScsrmv(
-        cusparseHandle, CUSPARSE_OPERATION_NON_TRANSPOSE, N, N, nz, &alpha,
-        descr, d_val, d_row, d_col, d_p, &beta, d_Ax));
-
-    cublasSetPointerMode(cublasHandle, CUBLAS_POINTER_MODE_DEVICE);
-    checkCudaErrors(cublasSdot(cublasHandle, N, d_p, 1, d_Ax, 1, d_dot));
-
-    r1_div_x<<<1, 1, 0, stream1>>>(d_r1, d_dot, d_a);
-
-    checkCudaErrors(cublasSaxpy(cublasHandle, N, d_a, d_p, 1, d_x, 1));
-
-    a_minus<<<1, 1, 0, stream1>>>(d_a, d_na);
-    checkCudaErrors(cublasSaxpy(cublasHandle, N, d_na, d_Ax, 1, d_r, 1));
-
-    checkCudaErrors(cudaMemcpyAsync(d_r0, d_r1, sizeof(float),
-                                    cudaMemcpyDeviceToDevice, stream1));
-
-    checkCudaErrors(cublasSdot(cublasHandle, N, d_r, 1, d_r, 1, d_r1));
-    checkCudaErrors(cudaMemcpyAsync((float *)&r1, d_r1, sizeof(float),
-                                    cudaMemcpyDeviceToHost, stream1));
-    checkCudaErrors(cudaStreamSynchronize(stream1));
-#endif
-    printf("iteration = %3d, residual = %e\n", k, sqrt(r1));
-    k++;
-  }
-
-#if WITH_GRAPH
-  checkCudaErrors(cudaMemcpyAsync(x, d_x, N * sizeof(float),
-                                  cudaMemcpyDeviceToHost, streamForGraph));
-  checkCudaErrors(cudaStreamSynchronize(streamForGraph));
-#else
-  checkCudaErrors(cudaMemcpyAsync(x, d_x, N * sizeof(float),
-                                  cudaMemcpyDeviceToHost, stream1));
-  checkCudaErrors(cudaStreamSynchronize(stream1));
-#endif
-
-  float rsum, diff, err = 0.0;
-
-  for (int i = 0; i < N; i++) {
-    rsum = 0.0;
-
-    for (int j = I[i]; j < I[i + 1]; j++) {
-      rsum += val[j] * x[J[j]];
-    }
-
-    diff = fabs(rsum - rhs[i]);
-
-    if (diff > err) {
-      err = diff;
-    }
-  }
-
-#if WITH_GRAPH
-  checkCudaErrors(cudaGraphExecDestroy(graphExec));
-  checkCudaErrors(cudaGraphDestroy(initGraph));
-  checkCudaErrors(cudaStreamDestroy(streamForGraph));
-#endif
-  checkCudaErrors(cudaStreamDestroy(stream1));
-  cusparseDestroy(cusparseHandle);
-  cublasDestroy(cublasHandle);
-
-  free(I);
-  free(J);
-  free(val);
-  free(x);
-  free(rhs);
-  cudaFree(d_col);
-  cudaFree(d_row);
-  cudaFree(d_val);
-  cudaFree(d_x);
-  cudaFree(d_r);
-  cudaFree(d_p);
-  cudaFree(d_Ax);
-
-  printf("Test Summary:  Error amount = %f\n", err);
-  exit((k <= max_iter) ? 0 : 1);
-}

Samples/conjugateGradientCudaGraphs/conjugateGradientCudaGraphs_vs2012.sln

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

Samples/conjugateGradientCudaGraphs/conjugateGradientCudaGraphs_vs2012.vcxproj

@@ -1,107 +0,0 @@
-<?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>conjugateGradientCudaGraphs_vs2012</RootNamespace>
-    <ProjectName>conjugateGradientCudaGraphs</ProjectName>
-    <CudaToolkitCustomDir />
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup>
-    <ConfigurationType>Application</ConfigurationType>
-    <CharacterSet>MultiByte</CharacterSet>
-    <PlatformToolset>v110</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 10.1.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>cublas.lib;cusparse.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)/conjugateGradientCudaGraphs.exe</OutputFile>
-    </Link>
-    <CudaCompile>
-      <CodeGeneration>compute_30,sm_30;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;</CodeGeneration>
-      <AdditionalOptions>-Xcompiler "/wd 4819" %(AdditionalOptions)</AdditionalOptions>
-      <Include>./;../../Common</Include>
-      <Defines>WIN32</Defines>
-    </CudaCompile>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)'=='Debug'">
-    <ClCompile>
-      <Optimization>Disabled</Optimization>
-      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
-    </ClCompile>
-    <Link>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
-    </Link>
-    <CudaCompile>
-      <Runtime>MTd</Runtime>
-      <TargetMachinePlatform>64</TargetMachinePlatform>
-    </CudaCompile>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)'=='Release'">
-    <ClCompile>
-      <Optimization>MaxSpeed</Optimization>
-      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
-    </ClCompile>
-    <Link>
-      <GenerateDebugInformation>false</GenerateDebugInformation>
-      <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
-    </Link>
-    <CudaCompile>
-      <Runtime>MT</Runtime>
-      <TargetMachinePlatform>64</TargetMachinePlatform>
-    </CudaCompile>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <CudaCompile Include="conjugateGradientCudaGraphs.cu" />
-
-  </ItemGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-    <Import Project="$(CUDAPropsPath)\CUDA 10.1.targets" />
-  </ImportGroup>
-</Project>

Samples/conjugateGradientCudaGraphs/conjugateGradientCudaGraphs_vs2013.sln

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

Samples/conjugateGradientCudaGraphs/conjugateGradientCudaGraphs_vs2013.vcxproj

@@ -1,107 +0,0 @@
-<?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>conjugateGradientCudaGraphs_vs2013</RootNamespace>
-    <ProjectName>conjugateGradientCudaGraphs</ProjectName>
-    <CudaToolkitCustomDir />
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup>
-    <ConfigurationType>Application</ConfigurationType>
-    <CharacterSet>MultiByte</CharacterSet>
-    <PlatformToolset>v120</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 10.1.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>cublas.lib;cusparse.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)/conjugateGradientCudaGraphs.exe</OutputFile>
-    </Link>
-    <CudaCompile>
-      <CodeGeneration>compute_30,sm_30;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;</CodeGeneration>
-      <AdditionalOptions>-Xcompiler "/wd 4819" %(AdditionalOptions)</AdditionalOptions>
-      <Include>./;../../Common</Include>
-      <Defines>WIN32</Defines>
-    </CudaCompile>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)'=='Debug'">
-    <ClCompile>
-      <Optimization>Disabled</Optimization>
-      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
-    </ClCompile>
-    <Link>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
-    </Link>
-    <CudaCompile>
-      <Runtime>MTd</Runtime>
-      <TargetMachinePlatform>64</TargetMachinePlatform>
-    </CudaCompile>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)'=='Release'">
-    <ClCompile>
-      <Optimization>MaxSpeed</Optimization>
-      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
-    </ClCompile>
-    <Link>
-      <GenerateDebugInformation>false</GenerateDebugInformation>
-      <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
-    </Link>
-    <CudaCompile>
-      <Runtime>MT</Runtime>
-      <TargetMachinePlatform>64</TargetMachinePlatform>
-    </CudaCompile>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <CudaCompile Include="conjugateGradientCudaGraphs.cu" />
-
-  </ItemGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-    <Import Project="$(CUDAPropsPath)\CUDA 10.1.targets" />
-  </ImportGroup>
-</Project>

Samples/conjugateGradientCudaGraphs/conjugateGradientCudaGraphs_vs2015.sln

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

Samples/conjugateGradientCudaGraphs/conjugateGradientCudaGraphs_vs2015.vcxproj

@@ -1,107 +0,0 @@
-<?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>conjugateGradientCudaGraphs_vs2015</RootNamespace>
-    <ProjectName>conjugateGradientCudaGraphs</ProjectName>
-    <CudaToolkitCustomDir />
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup>
-    <ConfigurationType>Application</ConfigurationType>
-    <CharacterSet>MultiByte</CharacterSet>
-    <PlatformToolset>v140</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 10.1.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>cublas.lib;cusparse.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)/conjugateGradientCudaGraphs.exe</OutputFile>
-    </Link>
-    <CudaCompile>
-      <CodeGeneration>compute_30,sm_30;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;</CodeGeneration>
-      <AdditionalOptions>-Xcompiler "/wd 4819" %(AdditionalOptions)</AdditionalOptions>
-      <Include>./;../../Common</Include>
-      <Defines>WIN32</Defines>
-    </CudaCompile>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)'=='Debug'">
-    <ClCompile>
-      <Optimization>Disabled</Optimization>
-      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
-    </ClCompile>
-    <Link>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
-    </Link>
-    <CudaCompile>
-      <Runtime>MTd</Runtime>
-      <TargetMachinePlatform>64</TargetMachinePlatform>
-    </CudaCompile>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)'=='Release'">
-    <ClCompile>
-      <Optimization>MaxSpeed</Optimization>
-      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
-    </ClCompile>
-    <Link>
-      <GenerateDebugInformation>false</GenerateDebugInformation>
-      <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
-    </Link>
-    <CudaCompile>
-      <Runtime>MT</Runtime>
-      <TargetMachinePlatform>64</TargetMachinePlatform>
-    </CudaCompile>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <CudaCompile Include="conjugateGradientCudaGraphs.cu" />
-
-  </ItemGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-    <Import Project="$(CUDAPropsPath)\CUDA 10.1.targets" />
-  </ImportGroup>
-</Project>

Samples/conjugateGradientCudaGraphs/conjugateGradientCudaGraphs_vs2017.sln

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

Samples/conjugateGradientCudaGraphs/conjugateGradientCudaGraphs_vs2017.vcxproj

@@ -1,108 +0,0 @@
-<?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>conjugateGradientCudaGraphs_vs2017</RootNamespace>
-    <ProjectName>conjugateGradientCudaGraphs</ProjectName>
-    <CudaToolkitCustomDir />
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup>
-    <ConfigurationType>Application</ConfigurationType>
-    <CharacterSet>MultiByte</CharacterSet>
-    <PlatformToolset>v141</PlatformToolset>
-	<WindowsTargetPlatformVersion>10.0.15063.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 10.1.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>cublas.lib;cusparse.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)/conjugateGradientCudaGraphs.exe</OutputFile>
-    </Link>
-    <CudaCompile>
-      <CodeGeneration>compute_30,sm_30;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;</CodeGeneration>
-      <AdditionalOptions>-Xcompiler "/wd 4819" %(AdditionalOptions)</AdditionalOptions>
-      <Include>./;../../Common</Include>
-      <Defines>WIN32</Defines>
-    </CudaCompile>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)'=='Debug'">
-    <ClCompile>
-      <Optimization>Disabled</Optimization>
-      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
-    </ClCompile>
-    <Link>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
-    </Link>
-    <CudaCompile>
-      <Runtime>MTd</Runtime>
-      <TargetMachinePlatform>64</TargetMachinePlatform>
-    </CudaCompile>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)'=='Release'">
-    <ClCompile>
-      <Optimization>MaxSpeed</Optimization>
-      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
-    </ClCompile>
-    <Link>
-      <GenerateDebugInformation>false</GenerateDebugInformation>
-      <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
-    </Link>
-    <CudaCompile>
-      <Runtime>MT</Runtime>
-      <TargetMachinePlatform>64</TargetMachinePlatform>
-    </CudaCompile>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <CudaCompile Include="conjugateGradientCudaGraphs.cu" />
-
-  </ItemGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-    <Import Project="$(CUDAPropsPath)\CUDA 10.1.targets" />
-  </ImportGroup>
-</Project>

Samples/conjugateGradientMultiBlockCG/Makefile

@@ -1,326 +0,0 @@
-################################################################################
-# Copyright (c) 2018, 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 ppc64le armv7l))
-    ifneq ($(TARGET_ARCH),$(HOST_ARCH))
-        ifneq (,$(filter $(TARGET_ARCH),x86_64 aarch64 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
-ifneq ($(TARGET_ARCH),$(HOST_ARCH))
-    ifeq (,$(filter $(HOST_ARCH)-$(TARGET_ARCH),aarch64-armv7l x86_64-armv7l x86_64-aarch64 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/aarch64-unknown-nto-qnx7.0.0-g++
-        else ifeq ($(TARGET_OS), android)
-            HOST_COMPILER ?= aarch64-linux-android-clang++
-        endif
-    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)/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
-            CCFLAGS += -isystem=$(TARGET_FS)/usr/include/aarch64-linux-gnu
-        endif
-    endif
-endif
-
-ifeq ($(TARGET_OS),qnx)
-    CCFLAGS += -DWIN_INTERFACE_CUSTOM
-    LDFLAGS += -lsocket
-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),armv7l-android)
-    CUDA_INSTALL_TARGET_DIR = targets/armv7-linux-androideabi/
-else ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-android)
-    CUDA_INSTALL_TARGET_DIR = targets/aarch64-linux-androideabi/
-else ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-qnx)
-    CUDA_INSTALL_TARGET_DIR = targets/ARMv7-linux-QNX/
-else ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-qnx)
-    CUDA_INSTALL_TARGET_DIR = targets/aarch64-qnx/
-else ifeq ($(TARGET_ARCH),ppc64le)
-    CUDA_INSTALL_TARGET_DIR = targets/ppc64le-linux/
-endif
-
-# Debug build flags
-ifeq ($(dbg),1)
-      NVCCFLAGS += -g -G
-      BUILD_TYPE := debug
-else
-      BUILD_TYPE := release
-endif
-
-ALL_CCFLAGS :=
-ALL_CCFLAGS += $(NVCCFLAGS)
-ALL_CCFLAGS += $(EXTRA_NVCCFLAGS)
-ALL_CCFLAGS += $(addprefix -Xcompiler ,$(CCFLAGS))
-ALL_CCFLAGS += $(addprefix -Xcompiler ,$(EXTRA_CCFLAGS))
-
-SAMPLE_ENABLED := 1
-
-# This sample is not supported on Mac OSX
-ifeq ($(TARGET_OS),darwin)
-  $(info >>> WARNING - conjugateGradientMultiBlockCG is not supported on Mac OSX - waiving sample <<<)
-  SAMPLE_ENABLED := 0
-endif
-
-# This sample is not supported on ARMv7
-ifeq ($(TARGET_ARCH),armv7l)
-  $(info >>> WARNING - conjugateGradientMultiBlockCG is not supported on ARMv7 - waiving sample <<<)
-  SAMPLE_ENABLED := 0
-endif
-
-# This sample is not supported on aarch64
-ifeq ($(TARGET_ARCH),aarch64)
-  $(info >>> WARNING - conjugateGradientMultiBlockCG is not supported on aarch64 - waiving sample <<<)
-  SAMPLE_ENABLED := 0
-endif
-
-ALL_LDFLAGS :=
-ALL_LDFLAGS += $(ALL_CCFLAGS)
-ALL_LDFLAGS += $(addprefix -Xlinker ,$(LDFLAGS))
-ALL_LDFLAGS += $(addprefix -Xlinker ,$(EXTRA_LDFLAGS))
-
-# Common includes and paths for CUDA
-INCLUDES  := -I../../Common
-LIBRARIES :=
-
-################################################################################
-
-# Gencode arguments
-ifeq ($(TARGET_ARCH),$(filter $(TARGET_ARCH),armv7l aarch64))
-SMS ?= 60 61 70 72 75
-else
-SMS ?= 60 61 70 75
-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 += -dc
-
-LIBRARIES += -lcudadevrt
-
-ifeq ($(SAMPLE_ENABLED),0)
-EXEC ?= @echo "[@]"
-endif
-
-################################################################################
-
-# Target rules
-all: build
-
-build: conjugateGradientMultiBlockCG
-
-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
-
-conjugateGradientMultiBlockCG.o:conjugateGradientMultiBlockCG.cu
-	$(EXEC) $(NVCC) $(INCLUDES) $(ALL_CCFLAGS) $(GENCODE_FLAGS) -o $@ -c $<
-
-conjugateGradientMultiBlockCG: conjugateGradientMultiBlockCG.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) ./conjugateGradientMultiBlockCG
-
-clean:
-	rm -f conjugateGradientMultiBlockCG conjugateGradientMultiBlockCG.o
-	rm -rf ../../bin/$(TARGET_ARCH)/$(TARGET_OS)/$(BUILD_TYPE)/conjugateGradientMultiBlockCG
-
-clobber: clean

Samples/conjugateGradientMultiBlockCG/NsightEclipse.xml

@@ -1,65 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?> 
-<!DOCTYPE entry SYSTEM "SamplesInfo.dtd">
-<entry>
-  <name>conjugateGradientMultiBlockCG</name>
-  <cflags>
-    <flag>-dc</flag>
-  </cflags>
-  <description><![CDATA[This sample implements a conjugate gradient solver on GPU using Multi Block Cooperative Groups, also uses Unified Memory.]]></description>
-  <devicecompilation>whole</devicecompilation>
-  <includepaths>
-    <path>./</path>
-    <path>../</path>
-    <path>../../common/inc</path>
-  </includepaths>
-  <keyconcepts>
-    <concept level="basic">Unified Memory</concept>
-    <concept level="advanced">Linear Algebra</concept>
-    <concept level="basic">Cooperative Groups</concept>
-    <concept level="advanced">MultiBlock Cooperative Groups</concept>
-  </keyconcepts>
-  <keywords>
-    <keyword>CUDA</keyword>
-    <keyword>Sparse Matrix</keyword>
-    <keyword>Unified Memory</keyword>
-    <keyword>GPGPU</keyword>
-  </keywords>
-  <libraries>
-    <library>cudadevrt</library>
-  </libraries>
-  <librarypaths>
-  </librarypaths>
-  <nsight_eclipse>true</nsight_eclipse>
-  <primary_file>conjugateGradientMultiBlockCG.cu</primary_file>
-  <required_dependencies>
-    <dependency>UVM</dependency>
-    <dependency>MBCG</dependency>
-  </required_dependencies>
-  <scopes>
-    <scope>1:CUDA Advanced Topics</scope>
-    <scope>3:Linear Algebra</scope>
-  </scopes>
-  <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>
-  <supported_envs>
-    <env>
-      <arch>x86_64</arch>
-      <platform>linux</platform>
-    </env>
-    <env>
-      <arch>ppc64le</arch>
-      <platform>linux</platform>
-    </env>
-    <env>
-      <platform>windows7</platform>
-    </env>
-  </supported_envs>
-  <supported_sm_architectures>
-    <from>6.0</from>
-  </supported_sm_architectures>
-  <title>conjugateGradient using MultiBlock Cooperative Groups</title>
-  <type>exe</type>
-</entry>

Samples/conjugateGradientMultiBlockCG/README.md

@@ -1,71 +0,0 @@
-# conjugateGradientMultiBlockCG - conjugateGradient using MultiBlock Cooperative Groups
-
-## Description
-
-This sample implements a conjugate gradient solver on GPU using Multi Block Cooperative Groups, also uses Unified Memory.
-
-## Key Concepts
-
-Unified Memory, Linear Algebra, Cooperative Groups, MultiBlock Cooperative Groups
-
-## Supported SM Architectures
-
-[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)
-
-## Supported OSes
-
-Linux, Windows
-
-## Supported CPU Architecture
-
-x86_64, ppc64le
-
-## CUDA APIs involved
-
-## Dependencies needed to build/run
-[UVM](../../README.md#uvm), [MBCG](../../README.md#mbcg)
-
-## Prerequisites
-
-Download and install the [CUDA Toolkit 10.1](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.
-    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/>
-    See [here](http://docs.nvidia.com/cuda/cuda-samples/index.html#cross-samples) for more details.
-*   **dbg=1** - build with debug symbols
-    ```
-    $ make dbg=1
-    ```
-*   **SMS="A B ..."** - override the SM architectures for which the sample will be built, where `"A B ..."` is a space-delimited list of SM architectures. For example, to generate SASS for SM 50 and SM 60, use `SMS="50 60"`.
-    ```
-    $ make SMS="50 60"
-    ```
-
-*  **HOST_COMPILER=<host_compiler>** - override the default g++ host compiler. See the [Linux Installation Guide](http://docs.nvidia.com/cuda/cuda-installation-guide-linux/index.html#system-requirements) for a list of supported host compilers.
-```
-    $ make HOST_COMPILER=g++
-```
-
-## References (for more details)
-

Samples/conjugateGradientMultiBlockCG/conjugateGradientMultiBlockCG.cu

@@ -1,500 +0,0 @@
-/* Copyright (c) 2018, 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 implements a conjugate gradient solver on GPU using
- * Multi Block Cooperative Groups, also uses Unified Memory.
- *
- */
-
-// includes, system
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include <cuda_runtime.h>
-
-// Utilities and system includes
-#include <helper_cuda.h>  // helper function CUDA error checking and initialization
-#include <helper_functions.h>  // helper for shared functions common to CUDA Samples
-
-#include <cooperative_groups.h>
-
-namespace cg = cooperative_groups;
-
-const char *sSDKname = "conjugateGradientMultiBlockCG";
-
-#define ENABLE_CPU_DEBUG_CODE 0
-#define THREADS_PER_BLOCK 512
-
-/* genTridiag: generate a random tridiagonal symmetric matrix */
-void genTridiag(int *I, int *J, float *val, int N, int nz) {
-  I[0] = 0, J[0] = 0, J[1] = 1;
-  val[0] = static_cast<float>(rand()) / RAND_MAX + 10.0f;
-  val[1] = static_cast<float>(rand()) / RAND_MAX;
-  int start;
-
-  for (int i = 1; i < N; i++) {
-    if (i > 1) {
-      I[i] = I[i - 1] + 3;
-    } else {
-      I[1] = 2;
-    }
-
-    start = (i - 1) * 3 + 2;
-    J[start] = i - 1;
-    J[start + 1] = i;
-
-    if (i < N - 1) {
-      J[start + 2] = i + 1;
-    }
-
-    val[start] = val[start - 1];
-    val[start + 1] = static_cast<float>(rand()) / RAND_MAX + 10.0f;
-
-    if (i < N - 1) {
-      val[start + 2] = static_cast<float>(rand()) / RAND_MAX;
-    }
-  }
-
-  I[N] = nz;
-}
-
-// I - contains location of the given non-zero element in the row of the matrix
-// J - contains location of the given non-zero element in the column of the
-// matrix val - contains values of the given non-zero elements of the matrix
-// inputVecX - input vector to be multiplied
-// outputVecY - resultant vector
-void cpuSpMV(int *I, int *J, float *val, int nnz, int num_rows, float alpha,
-             float *inputVecX, float *outputVecY) {
-  for (int i = 0; i < num_rows; i++) {
-    int num_elems_this_row = I[i + 1] - I[i];
-
-    float output = 0.0;
-    for (int j = 0; j < num_elems_this_row; j++) {
-      output += alpha * val[I[i] + j] * inputVecX[J[I[i] + j]];
-    }
-    outputVecY[i] = output;
-  }
-
-  return;
-}
-
-double dotProduct(float *vecA, float *vecB, int size) {
-  double result = 0.0;
-
-  for (int i = 0; i < size; i++) {
-    result = result + (vecA[i] * vecB[i]);
-  }
-
-  return result;
-}
-
-void scaleVector(float *vec, float alpha, int size) {
-  for (int i = 0; i < size; i++) {
-    vec[i] = alpha * vec[i];
-  }
-}
-
-void saxpy(float *x, float *y, float a, int size) {
-  for (int i = 0; i < size; i++) {
-    y[i] = a * x[i] + y[i];
-  }
-}
-
-void cpuConjugateGrad(int *I, int *J, float *val, float *x, float *Ax, float *p,
-                      float *r, int nnz, int N, float tol) {
-  int max_iter = 10000;
-
-  float alpha = 1.0;
-  float alpham1 = -1.0;
-  float r0 = 0.0, b, a, na;
-
-  cpuSpMV(I, J, val, nnz, N, alpha, x, Ax);
-  saxpy(Ax, r, alpham1, N);
-
-  float r1 = dotProduct(r, r, N);
-
-  int k = 1;
-
-  while (r1 > tol * tol && k <= max_iter) {
-    if (k > 1) {
-      b = r1 / r0;
-      scaleVector(p, b, N);
-
-      saxpy(r, p, alpha, N);
-    } else {
-      for (int i = 0; i < N; i++) p[i] = r[i];
-    }
-
-    cpuSpMV(I, J, val, nnz, N, alpha, p, Ax);
-
-    float dot = dotProduct(p, Ax, N);
-    a = r1 / dot;
-
-    saxpy(p, x, a, N);
-    na = -a;
-    saxpy(Ax, r, na, N);
-
-    r0 = r1;
-    r1 = dotProduct(r, r, N);
-
-    printf("\nCPU code iteration = %3d, residual = %e\n", k, sqrt(r1));
-    k++;
-  }
-}
-
-__device__ void gpuSpMV(int *I, int *J, float *val, int nnz, int num_rows,
-                        float alpha, float *inputVecX, float *outputVecY,
-                        cg::thread_block &cta, const cg::grid_group &grid) {
-  for (int i = grid.thread_rank(); i < num_rows; i += grid.size()) {
-    int row_elem = I[i];
-    int next_row_elem = I[i + 1];
-    int num_elems_this_row = next_row_elem - row_elem;
-
-    float output = 0.0;
-    for (int j = 0; j < num_elems_this_row; j++) {
-      // I or J or val arrays - can be put in shared memory
-      // as the access is random and reused in next calls of gpuSpMV function.
-      output += alpha * val[row_elem + j] * inputVecX[J[row_elem + j]];
-    }
-
-    outputVecY[i] = output;
-  }
-}
-
-__device__ void gpuSaxpy(float *x, float *y, float a, int size,
-                         const cg::grid_group &grid) {
-  for (int i = grid.thread_rank(); i < size; i += grid.size()) {
-    y[i] = a * x[i] + y[i];
-  }
-}
-
-__device__ void gpuDotProduct(float *vecA, float *vecB, double *result,
-                              int size, const cg::thread_block &cta,
-                              const cg::grid_group &grid) {
-  __shared__ double tmp[THREADS_PER_BLOCK];
-
-  double temp_sum = 0.0;
-  for (int i = grid.thread_rank(); i < size; i += grid.size()) {
-    temp_sum += static_cast<double>(vecA[i] * vecB[i]);
-  }
-  tmp[cta.thread_rank()] = temp_sum;
-
-  cg::sync(cta);
-
-  cg::thread_block_tile<32> tile32 = cg::tiled_partition<32>(cta);
-
-  double beta = temp_sum;
-  double temp;
-
-  for (int i = tile32.size() / 2; i > 0; i >>= 1) {
-    if (tile32.thread_rank() < i) {
-      temp = tmp[cta.thread_rank() + i];
-      beta += temp;
-      tmp[cta.thread_rank()] = beta;
-    }
-    cg::sync(tile32);
-  }
-  cg::sync(cta);
-
-  if (cta.thread_rank() == 0) {
-    beta = 0.0;
-    for (int i = 0; i < cta.size(); i += tile32.size()) {
-      beta += tmp[i];
-    }
-    atomicAdd(result, beta);
-  }
-}
-
-__device__ void gpuCopyVector(float *srcA, float *destB, int size,
-                              const cg::grid_group &grid) {
-  for (int i = grid.thread_rank(); i < size; i += grid.size()) {
-    destB[i] = srcA[i];
-  }
-}
-
-__device__ void gpuScaleVector(float *vec, float alpha, int size,
-                               const cg::grid_group &grid) {
-  for (int i = grid.thread_rank(); i < size; i += grid.size()) {
-    vec[i] = alpha * vec[i];
-  }
-}
-
-extern "C" __global__ void gpuConjugateGradient(int *I, int *J, float *val,
-                                                float *x, float *Ax, float *p,
-                                                float *r, double *dot_result,
-                                                int nnz, int N, float tol) {
-  cg::thread_block cta = cg::this_thread_block();
-  cg::grid_group grid = cg::this_grid();
-
-  int max_iter = 10000;
-
-  float alpha = 1.0;
-  float alpham1 = -1.0;
-  float r0 = 0.0, r1, b, a, na;
-
-  gpuSpMV(I, J, val, nnz, N, alpha, x, Ax, cta, grid);
-
-  cg::sync(grid);
-
-  gpuSaxpy(Ax, r, alpham1, N, grid);
-
-  cg::sync(grid);
-
-  gpuDotProduct(r, r, dot_result, N, cta, grid);
-
-  cg::sync(grid);
-
-  r1 = *dot_result;
-
-  int k = 1;
-  while (r1 > tol * tol && k <= max_iter) {
-    if (k > 1) {
-      b = r1 / r0;
-      gpuScaleVector(p, b, N, grid);
-
-      cg::sync(grid);
-      gpuSaxpy(r, p, alpha, N, grid);
-    } else {
-      gpuCopyVector(r, p, N, grid);
-    }
-
-    cg::sync(grid);
-
-    gpuSpMV(I, J, val, nnz, N, alpha, p, Ax, cta, grid);
-
-    if (threadIdx.x == 0 && blockIdx.x == 0) *dot_result = 0.0;
-
-    cg::sync(grid);
-
-    gpuDotProduct(p, Ax, dot_result, N, cta, grid);
-
-    cg::sync(grid);
-
-    a = r1 / *dot_result;
-
-    gpuSaxpy(p, x, a, N, grid);
-    na = -a;
-    gpuSaxpy(Ax, r, na, N, grid);
-
-    r0 = r1;
-
-    if (threadIdx.x == 0 && blockIdx.x == 0) *dot_result = 0.0;
-
-    cg::sync(grid);
-
-    gpuDotProduct(r, r, dot_result, N, cta, grid);
-
-    cg::sync(grid);
-
-    r1 = *dot_result;
-    k++;
-  }
-}
-
-bool areAlmostEqual(float a, float b, float maxRelDiff) {
-  float diff = fabsf(a - b);
-  float abs_a = fabsf(a);
-  float abs_b = fabsf(b);
-  float largest = abs_a > abs_b ? abs_a : abs_b;
-
-  if (diff <= largest * maxRelDiff) {
-    return true;
-  } else {
-    printf("maxRelDiff = %.8e\n", maxRelDiff);
-    printf(
-        "diff %.8e > largest * maxRelDiff %.8e therefore %.8e and %.8e are not "
-        "same\n",
-        diff, largest * maxRelDiff, a, b);
-    return false;
-  }
-}
-
-int main(int argc, char **argv) {
-  int N = 0, nz = 0, *I = NULL, *J = NULL;
-  float *val = NULL;
-  const float tol = 1e-5f;
-  float *x;
-  float *rhs;
-  float r1;
-  float *r, *p, *Ax;
-  cudaEvent_t start, stop;
-
-  printf("Starting [%s]...\n", sSDKname);
-
-  // This will pick the best possible CUDA capable device
-  cudaDeviceProp deviceProp;
-  int devID = findCudaDevice(argc, (const char **)argv);
-  checkCudaErrors(cudaGetDeviceProperties(&deviceProp, devID));
-
-  if (!deviceProp.managedMemory) {
-    // This sample requires being run on a device that supports Unified Memory
-    fprintf(stderr, "Unified Memory not supported on this device\n");
-    exit(EXIT_WAIVED);
-  }
-
-  // This sample requires being run on a device that supports Cooperative Kernel
-  // Launch
-  if (!deviceProp.cooperativeLaunch) {
-    printf(
-        "\nSelected GPU (%d) does not support Cooperative Kernel Launch, "
-        "Waiving the run\n",
-        devID);
-    exit(EXIT_WAIVED);
-  }
-
-  // Statistics about the GPU device
-  printf(
-      "> GPU device has %d Multi-Processors, SM %d.%d compute capabilities\n\n",
-      deviceProp.multiProcessorCount, deviceProp.major, deviceProp.minor);
-
-  /* Generate a random tridiagonal symmetric matrix in CSR format */
-  N = 1048576;
-  nz = (N - 2) * 3 + 4;
-
-  cudaMallocManaged(reinterpret_cast<void **>(&I), sizeof(int) * (N + 1));
-  cudaMallocManaged(reinterpret_cast<void **>(&J), sizeof(int) * nz);
-  cudaMallocManaged(reinterpret_cast<void **>(&val), sizeof(float) * nz);
-
-  genTridiag(I, J, val, N, nz);
-
-  cudaMallocManaged(reinterpret_cast<void **>(&x), sizeof(float) * N);
-  cudaMallocManaged(reinterpret_cast<void **>(&rhs), sizeof(float) * N);
-
-  double *dot_result;
-
-  cudaMallocManaged(reinterpret_cast<void **>(&dot_result), sizeof(double));
-
-  *dot_result = 0.0;
-
-  // temp memory for CG
-  checkCudaErrors(
-      cudaMallocManaged(reinterpret_cast<void **>(&r), N * sizeof(float)));
-  checkCudaErrors(
-      cudaMallocManaged(reinterpret_cast<void **>(&p), N * sizeof(float)));
-  checkCudaErrors(
-      cudaMallocManaged(reinterpret_cast<void **>(&Ax), N * sizeof(float)));
-
-  cudaDeviceSynchronize();
-
-  checkCudaErrors(cudaEventCreate(&start));
-  checkCudaErrors(cudaEventCreate(&stop));
-
-#if ENABLE_CPU_DEBUG_CODE
-  float *Ax_cpu = reinterpret_cast<float *>(malloc(sizeof(float) * N));
-  float *r_cpu = reinterpret_cast<float *>(malloc(sizeof(float) * N));
-  float *p_cpu = reinterpret_cast<float *>(malloc(sizeof(float) * N));
-  float *x_cpu = reinterpret_cast<float *>(malloc(sizeof(float) * N));
-
-  for (int i = 0; i < N; i++) {
-    r_cpu[i] = 1.0;
-    Ax_cpu[i] = x_cpu[i] = 0.0;
-  }
-
-#endif
-
-  for (int i = 0; i < N; i++) {
-    r[i] = rhs[i] = 1.0;
-    x[i] = 0.0;
-  }
-
-  void *kernelArgs[] = {
-      (void *)&I,  (void *)&J, (void *)&val, (void *)&x,
-      (void *)&Ax, (void *)&p, (void *)&r,   (void *)&dot_result,
-      (void *)&nz, (void *)&N, (void *)&tol,
-  };
-
-  int sMemSize = sizeof(double) * THREADS_PER_BLOCK;
-  int numBlocksPerSm = 0;
-  int numThreads = THREADS_PER_BLOCK;
-
-  checkCudaErrors(cudaOccupancyMaxActiveBlocksPerMultiprocessor(
-      &numBlocksPerSm, gpuConjugateGradient, numThreads, sMemSize));
-
-  int numSms = deviceProp.multiProcessorCount;
-  dim3 dimGrid(numSms * numBlocksPerSm, 1, 1),
-      dimBlock(THREADS_PER_BLOCK, 1, 1);
-  checkCudaErrors(cudaEventRecord(start, 0));
-  checkCudaErrors(cudaLaunchCooperativeKernel((void *)gpuConjugateGradient,
-                                              dimGrid, dimBlock, kernelArgs,
-                                              sMemSize, NULL));
-  checkCudaErrors(cudaEventRecord(stop, 0));
-  checkCudaErrors(cudaDeviceSynchronize());
-
-  float time;
-  checkCudaErrors(cudaEventElapsedTime(&time, start, stop));
-
-  r1 = *dot_result;
-
-  printf("GPU Final, residual = %e, kernel execution time = %f ms\n", sqrt(r1),
-         time);
-
-#if ENABLE_CPU_DEBUG_CODE
-  cpuConjugateGrad(I, J, val, x_cpu, Ax_cpu, p_cpu, r_cpu, nz, N, tol);
-#endif
-
-  float rsum, diff, err = 0.0;
-
-  for (int i = 0; i < N; i++) {
-    rsum = 0.0;
-
-    for (int j = I[i]; j < I[i + 1]; j++) {
-      rsum += val[j] * x[J[j]];
-    }
-
-    diff = fabs(rsum - rhs[i]);
-
-    if (diff > err) {
-      err = diff;
-    }
-  }
-
-  checkCudaErrors(cudaFree(I));
-  checkCudaErrors(cudaFree(J));
-  checkCudaErrors(cudaFree(val));
-  checkCudaErrors(cudaFree(x));
-  checkCudaErrors(cudaFree(rhs));
-  checkCudaErrors(cudaFree(r));
-  checkCudaErrors(cudaFree(p));
-  checkCudaErrors(cudaFree(Ax));
-  checkCudaErrors(cudaFree(dot_result));
-  checkCudaErrors(cudaEventDestroy(start));
-  checkCudaErrors(cudaEventDestroy(stop));
-
-#if ENABLE_CPU_DEBUG_CODE
-  free(Ax_cpu);
-  free(r_cpu);
-  free(p_cpu);
-  free(x_cpu);
-#endif
-
-  printf("Test Summary:  Error amount = %f \n", err);
-  fprintf(stdout, "&&&& conjugateGradientMultiBlockCG %s\n",
-          (sqrt(r1) < tol) ? "PASSED" : "FAILED");
-  exit((sqrt(r1) < tol) ? EXIT_SUCCESS : EXIT_FAILURE);
-}

Samples/conjugateGradientMultiBlockCG/conjugateGradientMultiBlockCG_vs2012.sln

@@ -1,20 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 2012
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "conjugateGradientMultiBlockCG", "conjugateGradientMultiBlockCG_vs2012.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