• Improved performance for Hopper by adding Hopper specific kernel.
• Extended API to support FP8 (8-bit floating point) mixed-precision tensor core accelerated matrix multiplication for compute capability 9.0 (Hopper) and higher (refer to https://docs.nvidia.com/cuda/cublas/index.htmlindex.html#fp8-usage for more details). This includes:
  • Support for two new FP8 data types (CUDA_R_8F_E4M3 and CUDA_R_8F_E5M2) with different dynamic ranges and precisions.
  • New FP8 specific matmul description attributes that allow more control over the computation by allowing configuration of non-default bias types, scaling factors, auxiliary storage data types, and an additional output to store the maximum of absolute values of the output matrix or epilogue output.
• Allow a new configuration, inner shape, for cublasLtMatmul which impacts non-grid size internal kernel design. This is only supported for compute capability 9.0 and higher.
• Allow configuration of thread block cluster dimensions for cublasLtMatmul. This is only supported for compute capability 9.0 and higher.
• Introduced cuBlasLt heuristics cache that stores the mapping of matmul problems to kernels previously selected by heuristics. That helps reduce the host-side overhead for repeating matmul problems. Refer to https://docs.nvidia.com/cuda/cublas/index.html#cublasLt-heuristics-cache.

• Some H100 specific kernels, including FP8 matrix multiplication, are only supported on the x86 architecture for Windows and Linux.
• H100 kernels have increased need for workspace size, when running on H100 it’s recommended to provide at least 32 MiB (33554432 B) of workspace (for cuBLASLt calls or if using cublasSetWorkspace()).

• CUBLASLT_MATMUL_PREF_POINTER_MODE_MASK, CUBLASLT_MATMUL_PREF_EPILOGUE_MASK and cublasLt3mMode_t will be removed in the next major version of the library, along with the already deprecated elements of cuBLASLt API. In the case of both _MASK properties, the filtering functionality is removed and heuristics query will only be restricted by currently requested options as specified within cublasLtMatmulDesc_t.

• Performance improvements for batched GEMV.
• Performance improvements for the following BLAS Level 3 routines on NVIDIA Ampere GPU architecture (SM80): {D,Z}{SYRK,SYMM,TRMM}, Z{HERK,HEMM}.

• The cublasGetVersion() API return value was updated due to cuBLAS minor version >= 10 and therefore, depending on how the API is used, version checks based on this API can lead to warnings or errors. Use cases such as cublasGetVersion() >= CUBLAS_VERSION will not break based on how the API was updated. The cublasGetProperty() API still returns correct values.

• Fixed incorrect bias gradient computations for CUBLASLT_EPILOGUE_BGRAD{A,B} when the corresponding matrix (A or B) size is greater than 2³¹.
• Fixed a potential cuBLAS hang when cuBLAS API is called with different CUDA streams but which are the same value-wise (e.g. this could happen in a loop that creates CUDA stream, calls cuBLAS with it, and then deletes the stream).
• If cuBLAS uses internal CUDA streams, their priority now matches the priority of the stream with which cuBLAS API was called.

• New epilogue options have been added to support fusion in DLtraining: CUBLASLT_EPILOGUE_{DRELU,DGELU} which are similar to CUBLASLT_EPILOGUE_{DRELU,DGELU}_BGRAD but don’t compute bias gradient.

• Some syrk-related functions (cublas{D,Z}syrk, cublas{D,Z}syr2k, cublas{D,Z}syrkx) may fail for matrices which size is greater than 2^31.

• Some cublas and cublasLt functions sometimes returned CUBLAS_STATUS_EXECUTION_FAILED if the dynamic library was loaded and unloaded several times during application lifetime within the same CUDA context. This issue has been resolved.

• Vector (and batched) alpha support for per-row scaling in TN int32 math Matmul with int8 output. See CUBLASLT_POINTER_MODE_ALPHA_DEVICE_VECTOR_BETA_HOST and CUBLASLT_MATMUL_DESC_ALPHA_VECTOR_BATCH_STRIDE.
• New epilogue options have been added to support fusion in DLtraining: CUBLASLT_EPILOGUE_BGRADA and CUBLASLT_EPILOGUE_BGRADB which compute bias gradients based on matrices A and B respectively.
• New auxiliary functions cublasGetStatusName(), cublasGetStatusString() have been added to cuBLAS that return the string representation and the description of the cuBLAS status (cublasStatus_t) respectively. Similarly, cublasLtGetStatusName(), cublasLtGetStatusString() have been added to cuBlasLt.

• cublasGemmBatchedEx() and cublas<t>gemmBatched() check the alignment of the input/output arrays of the pointers like they were the pointers to the actual matrices. These checks are irrelevant and will be disabled in future releases. This mostly affects half-precision inputGEMMs which might require 16-byte alignment, and array of pointers could only be aligned by 8-byte boundary.

• cublasLtMatrixTransform can now operate on matrices with dimensions greater than 65535.
• Fixed out-of-bound access in GEMM and Matmul functions, when split K or non-default epilogue is used and leading dimension of the output matrix exceeds int32_t limit.
• NVBLAS now uses lazy loading of the CPU BLAS library on Linux to avoid issues caused by preloading libnvblas.so in complex applications that use fork and similar APIs.
• Resolved symbols name conflict when using cuBlasLt static library with static TensorRT or cuDNN libraries.

• Some gemv cases were producing incorrect results if the matrix dimension (n or m) was large, for example 2^20.

• Some new kernels have been added for improved performance but have the limitation that only host pointers are supported for scalars (for example, alpha and beta parameters). This limitation is expected to be resolved in a future release.
• New epilogues have been added to support fusion in ML training. These include:
  • ReLuBias and GeluBias epilogues that produce an auxiliary output which is used on backward propagation to compute the corresponding gradients.
  • DReLuBGrad and DGeluBGrad epilogues that compute the backpropagation of the corresponding activation function on matrix C, and produce bias gradient as a separate output. These epilogues require auxiliary input mentioned in the bullet above.

• Some tensor core accelerated strided batched GEMM routines would result in misaligned memory access exceptions when batch stride wasn't a multiple of 8.
• Tensor core accelerated cublasGemmBatchedEx (pointer-array) routines would use slower variants of kernels assuming bad alignment of the pointers in the pointer array. Now it assumes that pointers are well aligned, as noted in the documentation.

• To be able to access the fastest possible kernels through cublasLtMatmulAlgoGetHeuristic() you need to set CUBLASLT_MATMUL_PREF_POINTER_MODE_MASK in search preferences to CUBLASLT_POINTER_MODE_MASK_HOST or CUBLASLT_POINTER_MODE_MASK_NO_FILTERING. By default, heuristics query assumes the pointer mode may change later and only returns algo configurations that support both _HOST and _DEVICE modes. Without this, newly added kernels will be excluded and it will likely lead to a performance penalty on some problem sizes.

• Linking with static cublas and cublasLt libraries on Linux now requires using gcc-5.2 and compatible or higher due to C++11 requirements in these libraries.

• cublas<s/d/c/z>Gemm() with very large n and m=k=1 may fail on Pascal devices.

• cuBLASLt Logging is officially stable and no longer experimental. cuBLASLt Logging APIs are still experimental and may change in future releases.

• cublasLt Matmul fails on Volta architecture GPUs with CUBLAS_STATUS_EXECUTION_FAILED when n dimension > 262,137 and epilogue bias feature is being used. This issue exists in 11.0 and 11.1 releases but has been corrected in 11.1 Update 1

• The cuBLAS API was extended with a new function, cublasSetWorkspace(), which allows the user to set the cuBLAS library workspace to a user-owned device buffer, which will be used by cuBLAS to execute all subsequent calls to the library on the currently set stream.
• cuBLASLt experimental logging mechanism can be enabled in two ways:
  • By setting the following environment variables before launching the target application:
    • CUBLASLT_LOG_LEVEL=<level> -- where level is one of the following levels:
      • "0" - Off - logging is disabled (default)
      • "1" - Error - only errors will be logged
      • "2" - Trace - API calls that launch CUDA kernels will log their parameters and important information
      • "3" - Hints - hints that can potentially improve the application's performance
      • "4" - Heuristics - heuristics log that may help users to tune their parameters
      • "5" - API Trace - API calls will log their parameter and important information
    • CUBLASLT_LOG_MASK=<mask> -- where mask is a combination of the following masks:
      • "0" - Off
      • "1" - Error
      • "2" - Trace
      • "4" - Hints
      • "8" - Heuristics
      • "16" - API Trace
    • CUBLASLT_LOG_FILE=<value> -- where value is a file name in the format of "<file_name>.%i", %i will be replaced with process id.If CUBLASLT_LOG_FILE is not defined, the log messages are printed to stdout.
  • By using the runtime API functions defined in the cublasLt header:
    • typedef void(*cublasLtLoggerCallback_t)(int logLevel, const char* functionName, const char* message) -- A type of callback function pointer.
    • cublasStatus_t cublasLtLoggerSetCallback(cublasLtLoggerCallback_t callback) -- Allows to set a call back functions that will be called for every message that is logged by the library.
    • cublasStatus_t cublasLtLoggerSetFile(FILE* file) -- Allows to set the output file for the logger. The file must be open and have write permissions.
    • cublasStatus_t cublasLtLoggerOpenFile(const char* logFile) -- Allows to give a path in which the logger should create the log file.
    • cublasStatus_t cublasLtLoggerSetLevel(int level) -- Allows to set the log level to one of the above mentioned levels.
    • cublasStatus_t cublasLtLoggerSetMask(int mask) -- Allows to set the log mask to a combination of the above mentioned masks.
    • cublasStatus_t cublasLtLoggerForceDisable() -- Allows to disable to logger for the entire session. Once this API is being called, the logger cannot be reactivated in the current session.

• cuBLASLt Matrix Multiplication adds support for fused ReLU and bias operations for all floating point types except double precision (FP64).
• Improved batched TRSM performance for matrices larger than 256.

• Many performance improvements have been implemented for NVIDIA Ampere, Volta, and Turing Architecture based GPUs.
• The cuBLASLt logging mechanism can be enabled by setting the following environment variables before launching the target application:
  • CUBLASLT_LOG_LEVEL=<level> - while level is one of the following levels:
    • "0" - Off - logging is disabled (default)
    • "1" - Error - only errors will be logged
    • "2" - Trace - API calls will be logged with their parameters and important information
  • CUBLASLT_LOG_FILE=<value> - while value is a file name in the format of "<file_name>.%i", %i will be replaced with process id. If CUBLASLT_LOG_FILE is not defined, the log messages are printed to stdout.
• For matrix multiplication APIs:
  • cublasGemmEx, cublasGemmBatchedEx, cublasGemmStridedBatchedEx and cublasLtMatmul added new data type support for __nv_bfloat16 (CUDA_R_16BF).
  • A new compute type TensorFloat32 (TF32) has been added to provide tensor core acceleration for FP32 matrix multiplication routines with full dynamic range and increased precision compared to BFLOAT16.
  • New compute modes Default, Pedantic, and Fast have been introduced to offer more control over compute precision used.
  • Tensor cores are now enabled by default for half-, and mixed-precision- matrix multiplications.
  • Double precision tensor cores (DMMA) are used automatically.
  • Tensor cores can now be used for all sizes and data alignments and for all GPU architectures:
    • Selection of these kernels through cuBLAS heuristics is automatic and will depend on factors such as math mode setting as well as whether it will run faster than the non-tensor core kernels.
    • Users should note that while these new kernels that use tensor cores for all unaligned cases are expected to perform faster than non-tensor core based kernels but slower than kernels that can be run when all buffers are well aligned.

• Algorithm selection in cublasGemmEx APIs (including batched variants) is non-functional for NVIDIA Ampere Architecture GPUs. Regardless of selection it will default to a heuristics selection. Users are encouraged to use the cublasLt APIs for algorithm selection functionality.
• The matrix multiply math mode CUBLAS_TENSOR_OP_MATH is being deprecated and will be removed in a future release. Users are encouraged to use the new cublasComputeType_t enumeration to define compute precision.

• cuFFTXt (single-process, multi-GPU API) now supports more use cases for 2D and 3D distributed transforms. Complex-to-complex transforms support all sizes greater than 32 and all descriptor types. Real-to-complex and complex-to-real transforms support all sizes greater than 32 and all descriptor types, except for CUFFT_XT_FORMAT_INPLACE_SHUFFLED when used in 2D real-to-complex ) and CUFFT_XT_FORMAT_INPLACE when used in 2D complex-to-real.

• CUFFT_WORKAREA_MINIMAL handles FFT of size 6 correctly for outer dimensions of 2D and 3D FFTs.
• Some R2C and C2R transforms with inner inner strides equal to 1 and more than 2^31 elements were returning invalid results. This has been fixed.

• cuFFT plans have an unintentional small memory overhead (of a few kB) per plan. This overhead will be fixed in an upcoming release.
• cuFFT fails to deallocate some internal structures if the active CUDA context at program finalization is not the same used to create the cuFFT plan. This memory leak is constant per context, and will be fixed in an upcoming release.
• Performance of cuFFT callback functionality was changed across all plan types and FFT sizes. Performance of a small set of cases regressed up to 0.5x, while most of the cases didn’t change performance significantly, or improved up to 2x. In addition to these performance changes, using cuFFT callbacks for loading data in out-of-place transforms might exhibit performance and memory footprint overhead for all cuFFT plan types and FFT sizes. An upcoming release will update the cuFFT callback implementation, removing the overheads and performance drops. cuFFT deprecated callback functionality based on separate compiled device code in cuFFT 11.4.

• cuFFT fails to deallocate some internal structures if the active CUDA context at program finalization is not the same used to create the cuFFT plan. This memory leak is constant per context, and will be fixed in an upcoming release.

• FFTs of certain sizes in single and double precision (multiples of size 6) could fail on future devices. This issue will be fixed in an upcoming release.

• Since cuFFT 10.3.0 (CUDA Toolkit 11.1), cuFFT may require user to make sure that all operations on input and output buffers are complete before calling cufft[Xt]Exec* if:
  • sm70 or later, 3D FFT, batch > 1, total size of transform is greater than 4.5MB
  • FFT size for all dimensions is in the set of the following sizes: {2, 4, 8, 16, 32, 64, 128, 3, 9, 81, 243, 729, 2187, 6561, 5, 25, 125, 625, 3125, 6, 36, 216, 1296, 7776, 7, 49, 343, 2401, 11, 121}
• Some V100 FFTs were slower than expected. This issue is resolved.

• Some T4 FFTs are slower than expected.
• Plans for FFTs of certain sizes in single precision (including some multiples of 1024 sizes, and some large prime numbers) could fail on future devices with less than 64 kB of shared memory. This issue will be fixed in an upcoming release.

• Some cuFFT multi-GPU plans exhibited very long creation times.
• cuFFT sometimes produced incorrect results for real-to-complex and complex-to-real transforms when the total number of elements across all batches in a single execution exceeded 2147483647.

• Some V100 FFTs are slower than expected.
• Some T4 FFTs are slower than expected.

• Performance improvements.

• Some T4 FFTs are slower than expected.
• cuFFT may produce incorrect results for real-to-complex and complex-to-real transforms when the total number of elements across all batches in a single execution exceeds 2147483647.
• Some cuFFT multi-GPU plans may exhibit very long creation time. Issue will be fixed in the next update.
• cuFFT may produce incorrect results for transforms with strides when the index of the last element across all batches exceeds 2147483647 (see Advanced Data Layout).

• Support for callback functionality using separately compiled device code is deprecated on all GPU architectures. Callback functionality will continue to be supported for all GPU architectures.

• cuFFT shared libraries are now linked statically against libstdc++ on Linux platforms.
• Improved performance of certain sizes (multiples of large powers of 3, powers of 11) in SM86.

• cuFFT planning and plan estimation functions may not restore correct context affecting CUDA driver API applications.
• Plans with strides, primes larger than 127 in FFT size decomposition and total size of transform including strides bigger than 32GB produce incorrect results.

• cuFFT planning and plan estimation functions may not restore correct context affecting CUDA driver API applications.

• cuFFT now accepts __nv_bfloat16 input and output data type for power-of-two sizes with single precision computations within the kernels.
• Reoptimized power of 2 FFT kernels on Volta and Turing architectures.

• Reduced R2C/C2R plan memory usage to previous levels.
• Resolved bug introduced in 10.1 update 1 that caused incorrect results when using custom strides, batched 2D plans and certain sizes on Volta and later.

• Fixed illegal memory access errors when using Sobol32 random number generator.

• Improved performance of CURAND_RNG_PSEUDO_MRG32K3A pseudorandom number generator when using ordering CURAND_ORDERING_PSEUDO_BEST or CURAND_ORDERING_PSEUDO_DEFAULT.
• Added a new type of order parameter: CURAND_ORDERING_PSEUDO_DYNAMIC.
  • Supported PRNGs:
    • CURAND_RNG_PSEUDO_XORWOW
    • CURAND_RNG_PSEUDO_MRG32K3A
    • CURAND_RNG_PSEUDO_MTGP32
    • CURAND_RNG_PSEUDO_PHILOX4_32_10
  • Improved performance compared to CURAND_ORDERING_PSEUDO_DEFAULT, especially on NVIDIA Ampere architecture GPUs.
  • The output ordering of generated random numbers for CURAND_ORDERING_PSEUDO_DYNAMIC depends on the number of SMs on a GPU, and thus can be different on different GPUs.
  • The CURAND_ORDERING_PSEUDO_DYNAMIC ordering can't be used with a host generator created using curandCreateGeneratorHost().

• Added information about cuRAND thread safety.

• CURAND_RNG_PSEUDO_XORWOW with ordering CURAND_ORDERING_PSEUDO_DYNAMIC can produce incorrect results on architectures newer than SM86.

• Fixed inconsistency between random numbers generated by GPU and host generators when CURAND_ORDERING_PSEUDO_LEGACY ordering is selected for certain generator types.

• Fixed an issue that caused linker errors about the multiple definitions of mtgp32dc_params_fast_11213 and mtgpdc_params_11213_num when including curand_mtgp32dc_p_11213.h in different compilation units.

• Fixed an issue that caused linker errors about the multiple definitions of mtgp32dc_params_fast_11213 and mtgpdc_params_11213_num when including curand_mtgp32dc_p_11213.h in different compilation units.

• Introduced CURAND_ORDERING_PSEUDO_LEGACY ordering. Starting with CUDA 10.0, the ordering of random numbers returned by MTGP32 and MRG32k3a generators are no longer the same as previous releases despite being guaranteed by the documentation for the CURAND_ORDERING_PSEUDO_DEFAULT setting. The CURAND_ORDERING_PSEUDO_LEGACY provides pre-CUDA 10.0 ordering for MTGP32 and MRG32k3a generators.
• Starting with CUDA 11.0 CURAND_ORDERING_PSEUDO_DEFAULT is the same as CURAND_ORDERING_PSEUDO_BEST for all generators except MT19937. Only CURAND_ORDERING_PSEUDO_LEGACY is guaranteed to provide the same for all future cuRAND releases.

• Added support for Hopper (SM90 architeciture build and runs.)

• Introducing cusolverDnXtrtri, a new generic API for triangular matrix inversion (trtri).
• Introducing cusolverDnXsytrs, a new generic API for solving systems of linear equations using a given factorized symmetric matrix from SYTRF.

• For values N<=16, cusolverDn[S|D|C|Z]syevjBatched hits out-of-bound access and may deliver the wrong result. The workaround is to pad the matrix A with a diagonal matrix D such that the dimension of [A 0 ; 0 D] is bigger than 16. The diagonal entry D(j,j) must be bigger than maximum eigenvalue of A, for example, norm(A, ‘fro’). After the syevj, W(0:n-1) contains the eigenvalues and A(0:n-1,0:n-1) contains the eigenvectors.

• cusolverDnIRSXgels may return CUSOLVER_STATUS_INTERNAL_ERROR. when the precision is ‘z’ due to insufficient workspace which causes illegal memory access.

  The cusolverDnIRSXgels_bufferSize() does not report the correct size of workspace. To workaround the issue, the user has to add more workspace than what is reported by cusolverDnIRSXgels_bufferSize(). For example, if x is the size of workspace returned by cusolverDnIRSXgels_bufferSize(), then the user has to allocate (x + min(m,n)*sizeof(cuDoubleComplex)) bytes.

• Add 64-bit API of GESVD. The new routine cusolverDnGesvd_bufferSize() fills the missing parameters in 32-bit API cusolverDn[S|D|C|Z]gesvd_bufferSize() such that it can estimate the size of the workspace accurately.
• Added the single process multi-GPU Cholesky factorization capabilities POTRF, POTRS and POTRI in cusolverMG library.

• Fixed an issue where SYEVD/SYGVD would fail and return error code 7 if the matrix is zero and the dimension is bigger than 25.

• cusparseXcsrsm2_zeroPivot, cusparseXcsrsm2_solve, cusparseXcsrsm2_analysis, and cusparseScsrsm2_bufferSizeExt have been deprecated in favor of cusparseSpSM Generic APIs

• cusparseDestroy(NULL) no longer crashes on Windows.

cusparseDestroySpVec, cusparseDestroyDnVec, cusparseDestroySpMat, cusparseDestroyDnMat, cusparseDestroy with NULL argument could cause segmentation fault on Windows.

• cusparseXdense2csr provides incorrect results for some matrix sizes.

• cusparseXdense2csr provides incorrect results for some matrix sizes.

• Legacy conversion routines: cusparseXcsc2dense, cusparseXcsr2dense, cusparseXdense2csc, cusparseXdense2csr

• Added new Generic APIs for Axpby (cusparseAxpby), Scatter (cusparseScatter), Gather (cusparseGather), Givens rotation (cusparseRot). __nv_bfloat16/ __nv_bfloat162 data types and 64-bit indices are also supported.

• This release adds the following features for cusparseSpMM:

  • Support for row-major layout for cusparseSpMM for both CSR and COO format
  • Support for 64-bit indices
  • Support for __nv_bfloat16 and __nv_bfloat162 data types
  • Support for the following strided batch mode:

    • Ci=A⋅Bi

    • Ci=Ai⋅B

    • Ci=Ai⋅Bi

• Added new Generic APIs for Axpby (cusparseAxpby), Scatter (cusparseScatter), Gather (cusparseGather), Givens rotation (cusparseRot). __nv_bfloat16/ __nv_bfloat162 data types and 64-bit indices are also supported.

• This release adds the following features for cusparseSpMM:

  • Support for row-major layout for cusparseSpMM for both CSR and COO format
  • Support for 64-bit indices
  • Support for __nv_bfloat16 and __nv_bfloat162 data types
  • Support for the following strided batch mode:

    • Ci=A⋅Bi

    • Ci=Ai⋅B

    • Ci=Ai⋅Bi

• Added new generic APIs and improved performance for sparse matrix-sparse matrix multiplication (SpGEMM): cusparseSpGEMM_workEstimation, cusparseSpGEMM_compute, and cusparseSpGEMM_copy.
• SpVV: added support for __nv_bfloat16.

• The following undocumented CUDA Math APIs are deprecated and will be removed in a future release. Please consider switching to similar intrinsic APIs documented here: https://docs.nvidia.com/cuda/cuda-math-api/index.html
  • __device__ int mulhi(const int a, const int b)
  • __device__ unsigned int mulhi(const unsigned int a, const unsigned int b)
  • __device__ unsigned int mulhi(const int a, const unsigned int b)
  • __device__ unsigned int mulhi(const unsigned int a, const int b)
  • __device__ long long int mul64hi(const long long int a, const long long int b)
  • __device__ unsigned long long int mul64hi(const unsigned long long int a, const unsigned long long int b)
  • __device__ unsigned long long int mul64hi(const long long int a, const unsigned long long int b)
  • __device__ unsigned long long int mul64hi(const unsigned long long int a, const long long int b)
  • __device__ int float_as_int(const float a)
  • __device__ float int_as_float(const int a)
  • __device__ unsigned int float_as_uint(const float a)
  • __device__ float uint_as_float(const unsigned int a)
  • __device__ float saturate(const float a)
  • __device__ int mul24(const int a, const int b)
  • __device__ unsigned int umul24(const unsigned int a, const unsigned int b)
  • __device__ int float2int(const float a, const enum cudaRoundMode mode = cudaRoundZero)
  • __device__ unsigned int float2uint(const float a, const enum cudaRoundMode mode = cudaRoundZero)
  • __device__ float int2float(const int a, const enum cudaRoundMode mode = cudaRoundNearest)
  • __device__ float uint2float(const unsigned int a, const enum cudaRoundMode mode = cudaRoundNearest)

• Previous releases of CUDA were potentially delivering incorrect results in some Linux distributions for the following host Math APIs: sinpi, cospi, sincospi, sinpif, cospif, sincospif. If passed huge inputs like 7.3748776e+15 or 8258177.5 the results were not equal to 0 or 1. These have been corrected with this release.

• nv_bfloat16 comparison functions could trigger a fault with misaligned addresses.
• Performance improvements in half and nv_bfloat16 basic arithmetic implementations.

• Add arithmetic support for __nv_bfloat16 floating-point data type with 8 bits of exponent, 7 explicit bits of mantissa.
• Performance and accuracy improvements in single precision math functions: fmodf, expf, exp10f, sinhf, and coshf.

• Corrected documented maximum ulp error thresholds in erfcinvf and powf.

• Improved cuda_fp16.h interoperability with Visual Studio C++ compiler.
• Updated libdevice user guide and CUDA math API definitions for j1, j1f, fmod, fmodf, ilogb, and ilogbf math functions.

• Added border support to the Median filter.

• Wiener Border fixes for customer image.
• nppsIntegral_32s failed cuda-memcheck for certain input sizes.

• Constant arithmetic functions that use a constant that is in device memory.

• Bilinear interpolation results for floating point values do not match with CPU results.
• NPP remap for 64-bit float does not match expected values from manual calculation, nor does it match IPP result.
• Compressed Marker Labels Info returns -1000 (NPP_CUDA_KERNEL_EXECUTION_ERROR); resulting rectangles contains corrupt data.
• LabelMarkers 8Way function can occasionally incorrectly connect contours that should remain separate.
• Wiener Border fixes for customer image.
• nppsIntegral_32s fails cuda-memcheck for certain input sizes.

• Improved Wiener filter to produce output similar to the IPP version.
• Enhanced Boxfilter improved performance for large kernel sizes.
• An issue that caused the FilterUnsharpNew() function to blur images is resolved.
• Modified the correlation coefficient calculation to support double precision and aligned the results with OpenCV/IPP.
• Added double precision support for Normalized correlation coefficients.

• New APIs added to compute Signed Anti-aliased Distance Transform using PBA, the anti-aliased Euclidean distance between pixel sites in images. This will improve the accuracy of distance transform.
  • nppiSignedDistanceTransformAbsPBA_xxxxx_C1R_Ctx() – Input and output combination supports (xxxxxx) - 32f, 32f64f, 64f
• New API for Absolute Manhattan distance transform; another method to improve the accuracy of distance transform using Manhattan distance transform between pixels.
  • nppiDistanceTransformAbsPBA_xxxxx_C1R_Ctx() – Input and output combination supports (xxxxxx) - 8u16u, 8s16u, 16u16u, 16s16u, 8u32f, 8s32f, 16u32f, 16s32f, 8u64f, 8s64f, 16u64f, 16s64f, 32f64f, 64f

• Fixed an issue in FilterMedian() API with add interpolation when mask even size.
• Improved Contour function performance by parallelizing more of it and also improving quality.
• Resolved an issue with Alpha composition used to accumulate output buffers multiple times.
• Resolved an issue with nppiLabelMarkersUF_8u32u_C1R column processing incorrect results.

• New API FindContours .FindContours can be explained simply as a curve joining all the continuous points (along the boundary), having the same color or intensity. The contours are a useful tool for shape analysis and object detection and recognition.

• Added nppiDistanceTransformPBA functions.

• Added nppiDistanceTransformPBA functions.

• Fixed the issue in which Label Markers adds zero pixel as object region.

• Batched Image Label Markers Compression that removes sparseness between marker label IDs output from LabelMarkers call.
• Image Flood Fill functionality fills a connected region of an image with a specified new value.
• Stability and performance fixes to Image Label Markers and Image Label Markers Compression.

• Batched Image Label Markers Compression that removes sparseness between marker label IDs output from LabelMarkers call.
• Image Flood Fill functionality fills a connected region of an image with a specified new value.
• Added batching support for nppiLabelMarkersUF functions.
• Added the nppiCompressMarkerLabelsUF_32u_C1IR function.

• Added nppiSegmentWatershed functions.

• Added sample apps on GitHub demonstrating the use of NPP application managed stream contexts along with watershed segmentation and batched and compressed UF image label markers functions.
• Added support for non-blocking streams.

• The nppiCopy API is limited by CUDA thread for large image size. Maximum image limits is a minimum of 16 * 65,535 = 1,048,560 horizontal pixels of any data type and number of channels and 8 * 65,535 = 524,280 vertical pixels for a maximum total of 549,739,036,800 pixels.

• Added Hopper nvJPEG support through the nvJPEG API.

• Fallback to cudaMalloc/cudaFree when stream ordered allocators are unavailable.

• Enhanced the encoder to work asynchronously.
• Fixed a minor issue in EXIF parser in which it was unable to decode one of the ImageNet bitstreams.

• Fixed the issue in which nvcuvid() released uncompressed frames causing a memory leak.

• Additional subsampling added to solve the NVJPEG_CSS_2x4.

• Added error handling capabilities for nonstandard JPEG images.

• NVJPEG_BACKEND_GPU_HYBRID has an issue when handling bit-streams which have corruption in the scan.

• nvJPEG allows the user to allocate separate memory pools for each chroma subsampling format. This helps avoid memory re-allocation overhead. This can be controlled by passing the newly added flag NVJPEG_FLAGS_ENABLE_MEMORY_POOLS to the nvjpegCreateEx API.
• nvJPEG encoder now allow compressed bitstream on the GPU Memory.

• nvJPEG allows the user to allocate separate memory pools for each chroma subsampling format. This helps avoid memory re-allocation overhead. This can be controlled by passing the newly added flag NVJPEG_FLAGS_ENABLE_MEMORY_POOLS to the nvjpegCreateEx API.
• nvJPEG encoder now allow compressed bitstream on the GPU Memory.
• Hardware accelerated decode is now supported on NVIDIA A100.
• The nvJPEG decode API (nvjpegDecodeJpeg()) now has the flexibility to select the backend when creating nvjpegJpegDecoder_t object. The user has the option to call this API instead of making three separate calls to nvjpegDecodeJpegHost(), nvjpegDecodeJpegTransferToDevice(), and nvjpegDecodeJpegDevice().

The following multiphase APIs have been removed:

• nvjpegStatus_t NVJPEGAPI nvjpegDecodePhaseOne

• nvjpegStatus_t NVJPEGAPI nvjpegDecodePhaseTwo

• nvjpegStatus_t NVJPEGAPI nvjpegDecodePhaseThree

• nvjpegStatus_t NVJPEGAPI nvjpegDecodeBatchedPhaseOne

• nvjpegStatus_t NVJPEGAPI nvjpegDecodeBatchedPhaseTwo