NVIDIA Fortran CUDA 接口

前言

本文档描述了 NVIDIA Fortran 接口，用于 cuBLAS、cuFFT、cuRAND、cuSPARSE 和其他 CUDA 库，这些库用于构建在 CUDA 计算架构之上的科学和工程应用程序。

目标读者

本指南适用于精通 Fortran 语言编程的应用程序员、科学家和工程师。本指南假定读者对 CUDA Fortran 或 OpenACC 有一定的了解。

组织结构

本文档的组织结构如下：

简介

包含 Fortran 接口、OpenACC、CUDA Fortran 和 CUDA 库函数的总体介绍

BLAS 运行时库

描述了各种 cuBLAS 库的 Fortran 接口

FFT 运行时库 API

描述了 cuFFT 库的模块类型、定义和 Fortran 接口

随机数运行时 API

描述了主机和设备 cuRAND 库的 Fortran 接口

稀疏矩阵运行时 API

描述了 cuSPARSE 库的模块类型、定义和 Fortran 接口

矩阵求解器运行时 API

描述了 cuSOLVER 库的模块类型、定义和 Fortran 接口

张量原语运行时 API

描述了 cuTENSOR 库的模块类型、定义和 Fortran 接口

NVIDIA 集体通信库 API

描述了 NCCL 库的模块类型、定义和 Fortran 接口

NVSHMEM 通信库 API

描述了 NVSHMEM 库的模块类型、定义和 Fortran 接口

NVTX 性能分析库 API

描述了 NVTX API 和库的模块类型、定义和 Fortran 接口

示例

提供了示例代码和每个简单示例的解释。

约定

本指南使用以下约定：

斜体

用于强调。

等宽字体

用于文件名、目录、参数、选项、示例以及文本中的语言语句，包括汇编语言语句。

粗体

用于命令。

[ item1 ]

通常，方括号表示可选项目。在本例中，item1 是可选的。在 p/t 集的上下文中，方括号是指定 p/t 集所必需的。

{ item2 | item 3 }

花括号表示需要选择。在本例中，您必须选择 item2 或 item3。

filename …

省略号表示重复。可以出现零个或多个前面的项目。在本例中，允许多个文件名。

FORTRAN

Fortran 语言语句在本指南的文本中使用缩小的固定点大小显示。

C++ 和 C

C++ 和 C 语言语句在本指南的测试中使用缩小的固定点大小显示。

术语

如果本指南中有您不熟悉的术语，请参阅 NVIDIA HPC 词汇表。

相关出版物

以下文档包含与 OpenACC 和 CUDA Fortran 编程、CUDA 和 CUDA 库相关的其他信息。

• ISO/IEC 1539-1:1997，信息技术 – 编程语言 – FORTRAN，日内瓦，1997 年（Fortran 95）。

• NVIDIA CUDA 编程指南，NVIDIA。在线提供，网址为 docs.nvidia.com/cuda。

• NVIDIA HPC 编译器用户指南，2024 年发行版。在线提供，网址为 docs.nvidia.com/hpc-sdk。

1. 简介

本文档为从 NVIDIA Fortran 调用 CUDA 库函数提供了参考。它可以从使用 OpenACC 或 OpenMP 编程模型的 Fortran 代码中使用，也可以从 NVIDIA CUDA Fortran 中使用。目前，NVIDIA 为其提供了预构建接口模块的 CUDA 库，并在本文档中进行了记录，包括：

• cuBLAS，BLAS 的实现。

• cuFFT，快速傅里叶变换 (FFT) 例程库。

• cuRAND，用于随机数生成的库。

• cuSPARSE，用于稀疏矩阵的线性代数例程库。

• cuSOLVER，用于密集矩阵或其他矩阵的方程求解器库。

• cuTENSOR，用于张量原语操作的库。

• NCCL，一个集体通信库。

• NVSHMEM，OpenSHMEM 在 GPU 上的库实现。

• NVTX，用于注释应用程序事件、代码范围和资源的 API。

OpenACC 应用程序编程接口是编译器指令和运行时例程的集合，允许程序员指定循环和代码区域，以便从主机 CPU 卸载到附加的加速器，例如 GPU。OpenACC API 由行业联盟设计和维护。有关 OpenACC API 的更多信息，请参阅 OpenACC 网站。

OpenMP 是一组编译器指令、应用程序编程接口 (API) 和一组环境变量的规范，可用于指定来自 Fortran（和其他语言）的并行执行。OpenMP 目标卸载功能在许多方面与 OpenACC 相似。与 OpenACC 中使用的方法相比，从主机代码将设备数组传递给库函数的方法仅在语法上有所不同。有关使用 OpenMP 的一般信息以及获取 OpenMP 规范副本，请参阅 OpenMP 组织的网站。

CUDA Fortran 是 Fortran 的一小组扩展，它支持 CUDA 计算架构并在其基础上构建。CUDA Fortran 包括 Fortran 2003 编译器和工具链，用于使用 Fortran 编程 NVIDIA GPU，并且是 NVIDIA CUDA C 编译器的类似物。与 NVIDIA Accelerator 和基于 OpenACC 指令的模型和编译器相比，CUDA Fortran 是一种较低级别的显式编程模型，具有大量的运行时库组件，使专业程序员可以直接控制 GPGPU 编程的各个方面。

本文档不包含库函数的解释或用途，也不包含 CUDA 实现中用于定位 GPU 的方法的详细信息。有关该信息，请参阅 NVIDIA CUDA 工具包附带的相应库文档。本文档确实提供了 Fortran 模块内容：派生类型、枚举和接口，以便从 Fortran 而不是从 C 或 C++ 中使用库。

本文档中使用的许多示例都随 HPC 编译器和工具发行版一起提供，以及 Makefiles，并存储在年度目录中，例如 2020/examples/CUDA-Libraries。

1.1. Fortran 接口和封装器

本文档中显示的几乎所有函数接口都使用了来自 Fortran 2003 iso_c_binding 内在模块的功能。该模块提供了一种处理诸如跨语言数据类型、大小写、向符号名称添加下划线或按值传递参数等问题的标准方法。

通常，iso_c_binding 模块使包含正确编写的接口的 Fortran 程序能够直接调用 C 库函数。在某些情况下，NVIDIA 编写了 C 库函数周围的小型封装器，以使 Fortran 调用站点更“类 Fortran”，隐藏 C 接口中暴露的一些问题，如句柄管理、主机与设备指针管理或字符和复数数据类型问题。

在少数情况下，C 库可能包含多个入口点来处理不同的数据类型，可能在一个函数中使用 int，而在另一个函数中使用 size_t，否则这些函数是相同的。在这些情况下，NVIDIA 可能只提供一个通用 Fortran 接口，并在底层调用适当的 C 函数。

1.2. 从 OpenACC 主机代码中使用 CUDA 库

本文档涵盖的所有库都包含可从 OpenACC 主机代码调用的函数。大多数函数都接受一些预期为设备指针（设备全局内存中变量的地址）的参数。在 OpenACC 中有几种方法可以做到这一点。

如果调用在词法上嵌套在 OpenACC data 指令中，则在存在显式接口（例如 NVIDIA 库模块提供的接口）的情况下，NVIDIA Fortran 编译器将默认在需要时传递设备指针。

subroutine hostcall(a, b, n)
use cublas
real a(n), b(n)
!$acc data copy(a, b)
call cublasSswap(n, a, 1, b, 1)
!$acc end data

return
end

当您使用包含 Fortran 接口的模块时（如上面的示例中的 use cublas 行），Fortran 接口是显式的。如果您查看 cublasSswap 的实际接口，您将看到数组 a 和 b 使用 CUDA Fortran device 属性声明，因此它们仅将设备地址作为参数。

当使用 OpenACC 时，通过使用 host_data 子句将设备指针传递给子程序是更可接受和通用的方法，因为大多数实现都没有办法将参数标记为设备指针。带有 use_device 子句的 host_data 构造使设备地址在主机代码中可用，以便传递给子程序。

use cufft
use openacc
. . .
!$acc data copyin(a), copyout(b,c)
ierr = cufftPlan2D(iplan1,m,n,CUFFT_C2C)
ierr = ierr + cufftSetStream(iplan1,acc_get_cuda_stream(acc_async_sync))
!$acc host_data use_device(a,b,c)
ierr = ierr + cufftExecC2C(iplan1,a,b,CUFFT_FORWARD)
ierr = ierr + cufftExecC2C(iplan1,b,c,CUFFT_INVERSE)
!$acc end host_data

! scale c
!$acc kernels
c = c / (m*n)
!$acc end kernels
!$acc end data

此代码片段还显示了共享 OpenACC 和 cuFFT 库使用的流的示例。本文档中的每个库都有一个用于设置库在其上运行的 CUDA 流的函数。通常，当使用 OpenACC 时，您希望 OpenACC 内核与库函数在同一流上运行。在上面的例子中，这保证了内核 c = c / (m*n) 在 FFT 操作完成之前不会启动。函数 acc_get_cuda_stream 和 acc_async_sync 的定义在 openacc 模块中。

1.3. 从 OpenACC 设备代码中使用 CUDA 库

目前，有两个库可以从 OpenACC 计算区域内使用。openacc_curand 模块和 nvshmem 模块中的某些函数被标记为 acc routine seq。

cuRAND 设备库全部包含在 CUDA 头文件中。在设备代码中，它旨在为每个线程返回一个或少量随机数。线程的随机数生成器彼此独立运行，并且通常建议出于性能原因为每个线程提供不同的种子，而不是不同的偏移量。

program t
use openacc_curand
integer, parameter :: n = 500
real a(n,n,4)
type(curandStateXORWOW) :: h
integer(8) :: seed, seq, offset
a = 0.0
!$acc parallel num_gangs(n) vector_length(n) copy(a)
!$acc loop gang
do j = 1, n
!$acc loop vector private(h)
  do i = 1, n
    seed = 12345_8 + j*n*n + i*2
    seq = 0_8
    offset = 0_8
    call curand_init(seed, seq, offset, h)
!$acc loop seq
    do k = 1, 4
      a(i,j,k) = curand_uniform(h)
    end do
  end do
end do
!$acc end parallel
print *,maxval(a),minval(a),sum(a)/(n*n*4)
end

当使用 openacc_curand 模块时，由于所有代码都包含在 CUDA 头文件中，因此您不需要链接行上的任何其他库。

1.4. 从 CUDA Fortran 主机代码中使用 CUDA 库

本文档中列出的库函数的主要使用模型是从 CUDA 主机代码调用它们。CUDA Fortran 允许一些特殊功能，因为编译器能够在解析通用接口时识别 device 和 managed 属性。设备实参只能匹配接口的设备哑元；托管实参优先匹配托管哑元，然后是设备哑元，然后是主机哑元。

program testisamax  ! link with -cudalib=cublas -lblas
use cublas
real*4              x(1000)
real*4, device  :: xd(1000)
real*4, managed :: xm(1000)

call random_number(x)

! Call host BLAS
j = isamax(1000,x,1)

xd = x
! Call cuBLAS
k = isamax(1000,xd,1)
print *,j.eq.k

xm = x
! Also calls cuBLAS
k = isamax(1000,xm,1)
print *,j.eq.k
end

使用 cudafor 模块，程序员可以使用全套 CUDA 功能来管理 CUDA 事件、流、同步和异步行为。CUDA Fortran 可用于 OpenMP 程序，并且本文档中的 CUDA 库对于主机 CPU 线程是线程安全的。更多示例包含在 示例 章节中。

1.5. 从 CUDA Fortran 设备代码中使用 CUDA 库

curAND 和 NVSHMEM 库具有可从 CUDA Fortran 设备代码调用的函数，它们的接口分别通过 curand_device 和 nvshmem 模块访问。模块接口与 OpenACC 设备代码中使用的模块非常相似，但对于 CUDA Fortran，每个子例程和函数都声明了 attributes([host,]device)，并且子例程和函数不需要标记为 acc routine seq。

module mrand
    use curand_device
    integer, parameter :: n = 500
    contains
    attributes(global) subroutine randsub(a)
    real, device :: a(n,n,4)
    type(curandStateXORWOW) :: h
    integer(8) :: seed, seq, offset
    j = blockIdx%x; i = threadIdx%x
    seed = 12345_8 + j*n*n + i*2
    seq = 0_8
    offset = 0_8
    call curand_init(seed, seq, offset, h)
    do k = 1, 4
        a(i,j,k) = curand_uniform(h)
    end do
    end subroutine
end module

program t   ! nvfortran t.cuf
use mrand
use cudafor ! recognize maxval, minval, sum w/managed
real, managed :: a(n,n,4)
a = 0.0
call randsub<<<n,n>>>(a)
print *,maxval(a),minval(a),sum(a)/(n*n*4)
end program

1.6. cuBLAS 和 cuSPARSE 中的指针模式

由于 NVIDIA Fortran 编译器可以区分主机和设备参数，因此用于连接 cuBLAS 和 cuSPARSE 的 NVIDIA 模块处理指针模式的方式与 CUDA C 不同，后者需要为标量参数显式设置模式。可以驻留在主机或设备上的标量参数示例是 *gemm 函数的 alpha 和 beta 比例因子。

通常，当在 cuBLAS 和 cuSPARSE 模块中使用正常的 “non-_v2” 接口时，运行时包装器将在幕后隐式添加库指针模式的设置和恢复。这会给调用增加一些可忽略但不为零的开销。

要避免在每次调用库函数时隐式获取和设置指针模式，请执行以下操作

• 对于 BLAS，请使用 cublas_v2 模块和 v2 入口点，例如 cublasIsamax_v2。程序员有责任在需要时正确设置指针模式。需要设置指针模式的标量参数示例是传递给 *gemm 例程的 alpha 和 beta 比例因子，以及从 *amax()、*amin()、*asum()、*rotg()、*rotmg()、*nrm2() 和 *dot() 函数的 v2 版本返回的标量结果。在第 2 章中显示的 v2 接口中，这些标量参数将带有注释 ! device or host variable。不需要设置指针模式的标量参数示例是增量、范围和长度，例如 incx、incy、n、lda、ldb 和 ldc。

• 对于 cuSPARSE 库，第 5 章中列出的每个包含注释 ! device or host variable 的标量参数的函数都有一个对应的 v2 接口，尽管此处未记录。例如，除了名为 cusparseSaxpyi 的接口之外，还有另一个名为 cusparseSaxpyi_v2 的接口，其参数列表完全相同，它直接调用 cuSPARSE 库，并且不会隐式获取或设置库指针模式。

CUDA 默认指针模式是标量参数驻留在主机上。NVIDIA 运行时不会更改该设置。

1.7. 编写您自己的 CUDA 接口

尽管本文档中描述的模块中包含了大量的接口，但用户有时仍然需要编写自己的接口来连接新的库或他们自己调整的 CUDA，可能用 C/C++ 编写。有一些标准技术可以使用，以及一些非标准的 NVIDIA 扩展，这些扩展可以使创建工作接口更容易。

! cufftExecC2C
interface cufftExecC2C
    integer function cufftExecC2C( plan, idata, odata, direction ) &
        bind(C,name='cufftExecC2C')
        integer, value :: plan
        complex, device, dimension(*) :: idata, odata
        integer, value :: direction
    end function cufftExecC2C
end interface cufftExecC2C

此接口直接调用 C 库函数。您可以通过将正确大写的 C 函数放在 bind(C) 属性中来处理 Fortran 的大小写问题。如果 C 函数期望按值传递输入参数，您也可以将 value 属性添加到虚拟声明中。Fortran 的一个优点是接口可以更改，但调用站点的代码可能不必更改。编译器会更改调用的细节以适应接口。

现在假设此接口的用户想要使用 REAL 数据调用此函数（F77 代码以混合 REAL 和 COMPLEX 声明而闻名）。有两种方法可以做到这一点

! cufftExecC2C
interface cufftExecC2C
    integer function cufftExecC2C( plan, idata, odata, direction ) &
        bind(C,name='cufftExecC2C')
        integer, value :: plan
        complex, device, dimension(*) :: idata, odata
        integer, value :: direction
    end function cufftExecC2C
    integer function cufftExecR2R( plan, idata, odata, direction ) &
        bind(C,name='cufftExecC2C')
        integer, value :: plan
        real, device, dimension(*) :: idata, odata
        integer, value :: direction
    end function cufftExecR2R
end interface cufftExecC2C

这里 C 名称没有改变。编译器现在将接受与声明为 REAL 的 idata 和 odata 相对应的实际参数。创建了一个名为 cufftExecC2C 的通用接口。如果您在调试通用接口时遇到问题，作为调试辅助，您可以尝试调用特定名称，在本例中为 cufftExecR2R，以帮助诊断问题。

NVIDIA 支持的常用扩展是 ignore_tkr。程序员可以在接口中使用它来指示编译器在接口匹配过程中忽略类型、种类和秩的任何组合。使用 ignore_tkr 的先前示例看起来像这样

! cufftExecC2C
interface cufftExecC2C
    integer function cufftExecC2C( plan, idata, odata, direction ) &
        bind(C,name='cufftExecC2C')
        integer, value :: plan
        !dir$ ignore_tkr(tr) idata, (tr) odata
        complex, device, dimension(*) :: idata, odata
        integer, value :: direction
    end function cufftExecC2C
end interface cufftExecC2C

现在，当将调用站点与接口匹配时，编译器将忽略 idata 和 odata 的类型和秩（F77 在处理数组维度方面也可能很草率）。一个不幸的副作用是，该接口现在将允许 idata 和 odata 的整数、逻辑和字符数据。是否可以接受取决于实施者。

最后一个特定于 NVIDIA 的辅助方法，值得在此处提及的是 ignore_tkr (d)，它在接口匹配期间忽略实际参数的 device 属性。

当然，如果您编写一个包装器，即 Fortran 调用和您的库函数之间的一小段代码，您将不受编译器可以执行的简单转换的限制，例如此处列出的那些。如前所述，cuBLAS 和 cuSPARSE 模块中提供的许多接口都使用包装器。

一个常见的请求是 Fortran 程序员如何利用 thrust 库。解释 thrust 和 C++ 编程超出了本文档的范围，但这个简单的示例可以展示如何利用 thrust 中出色的排序功能

// Filename: csort.cu
// nvcc -c -arch sm_35 csort.cu
#include <thrust/device_vector.h>
#include <thrust/copy.h>
#include <thrust/sort.h>

extern "C" {

    //Sort for integer arrays
    void thrust_int_sort_wrapper( int *data, int N)
    {
    thrust::device_ptr <int> dev_ptr(data);
    thrust::sort(dev_ptr, dev_ptr+N);
    }

    //Sort for float arrays
    void thrust_float_sort_wrapper( float *data, int N)
    {
    thrust::device_ptr <float> dev_ptr(data);
    thrust::sort(dev_ptr, dev_ptr+N);
    }

    //Sort for double arrays
    void thrust_double_sort_wrapper( double *data, int N)
    {
    thrust::device_ptr <double> dev_ptr(data);
    thrust::sort(dev_ptr, dev_ptr+N);
    }
}

在 Fortran 中设置排序子例程的接口，调用很简单

program t
interface sort
   subroutine sort_int(array, n) &
        bind(C,name='thrust_int_sort_wrapper')
        integer(4), device, dimension(*) :: array
        integer(4), value :: n
    end subroutine
end interface
integer(4), parameter :: n = 100
integer(4), device :: a_d(n)
integer(4) :: a_h(n)
!$cuf kernel do
do i = 1, n
    a_d(i) = 1 + mod(47*i,n)
end do
call sort(a_d, n)
a_h = a_d
nres  = count(a_h .eq. (/(i,i=1,n)/))
if (nres.eq.n) then
    print *,"test PASSED"
else
    print *,"test FAILED"
endif
end

1.8. NVIDIA Fortran 编译器选项

NVIDIA Fortran 编译器驱动程序称为 nvfortran。可以通过键入 nvfortran -help 来获取有关可以传递给 nvfortran 的编译器选项的常规信息。要使用 OpenACC 启用 NVIDIA GPU 目标，请使用 nvfortran -acc=gpu。要使用 CUDA Fortran 启用 NVIDIA GPU 目标，请使用 nvfortran -cuda。当文件名使用 .cuf 扩展名时，NVIDIA Fortran 编译器也支持 CUDA Fortran。大写文件扩展名，例如 .F90 或 .CUF，也可以使用，在这种情况下，程序在编译之前由预处理器处理。

与本文档中的示例相关的其他选项包括

• -⁠cudalib[=cublas|cufft|cufftw|curand|cusolver|cusparse|cutensor|nvblas|nccl|nvshmem|nvlamath|nvtx]：此选项将 CUDA 优化的库的相应版本添加到链接行。它可以不引人注目地处理静态和动态链接以及平台（Linux、Windows）差异。

• -⁠gpu=cc70：此选项编译为计算能力 7.0。某些库功能可能需要最低计算能力为 6.0、7.0 或更高。

• -⁠gpu=cudaX.Y：此选项使用特定的 CUDA 工具包版本进行编译和链接。某些库功能可能需要较新（或较旧，对于已弃用的函数）的 CUDA 运行时版本。

2. BLAS 运行时 API

本节介绍 CUDA BLAS 库的 Fortran 接口。目前有四个独立的函数入口点集合，通常称为 cuBLAS

• BLAS 例程的原始 CUDA 实现，称为旧版 API，可以从主机调用，并期望和操作设备数据。

• BLAS 例程的较新的 “v2” CUDA 实现，以及一些用于批量操作的扩展。这些也可以从主机调用，并操作设备数据。在 Fortran 术语中，这些入口点已从子例程更改为返回状态的函数。

• cuBLAS XT 库，它可以使用仅驻留在主机上的数据来定位多个 GPU。

• cuBLAS MP 库，它可以使用分布式设备数据来定位多个 GPU，类似于 ScaLAPACK PBLAS 函数。cublasMp 和 cusolverMp 库部分构建在名为 CAL 的通信库之上，该库在本文档的另一节中进行了记录。

NVIDIA 当前附带四个 Fortran 模块，程序员可以使用这些模块来调用此 cuBLAS 功能

• cublas，它提供到主 cublas 库的接口。支持旧版和 v2 名称。在此模块中，cublas 名称（例如 cublasSaxpy）使用旧版调用约定。主机 BLAS 库（例如 NVIDIA 发行版中的 libblas.a）的接口也包含在 cublas 模块中。通过添加以下行来公开这些接口

  use cublas
  

  到您的程序单元。

• cublas_v2，它在大多数方面与 cublas 模块相似，但 cublas 名称（例如 cublasSaxpy）使用 v2 调用约定。例如，cublasSaxpy 不是子例程，而是一个函数，它将句柄作为第一个参数，并返回一个整数，其中包含调用的状态。通过添加以下行来公开这些接口

  use cublas_v2
  

  到您的程序单元。

• cublasxt，它直接接口到 cublasXT API。通过添加以下行来公开这些接口

  use cublasxt
  

  到您的程序单元。

• cublasmp，它提供到 cublasMp API 的接口。通过添加以下行来公开这些接口

  use cublasMp
  

  到您的程序单元。

v2 例程是返回错误状态代码的整数函数；如果调用成功，它们将返回值 CUBLAS_STATUS_SUCCESS，如果发生错误，则返回其他 cuBLAS 状态返回值。

在后续部分中记录的传统 BLAS 名称的接口，其中包含注释 ! device or host variable 不应与第 1.6 节中的指针模式问题混淆。传统的 BLAS 名称是 cublas 模块中的重载通用名称。例如，在此接口中

subroutine scopy(n, x, incx, y, incy)
  integer :: n
  real(4), device, dimension(*) :: x, y ! device or host variable
  integer :: incx, incy

数组 x 和 y 可以都是设备数组，在这种情况下，通过通用接口调用 cublasScopy，或者它们都可以是主机数组，在这种情况下，调用主机 BLAS 库中的 scopy。将 CUDA Fortran 托管数据用作 scopy 的实际参数会产生一个有趣的案例，默认情况下选择调用 cublasScopy。如果您希望使用托管数据调用 scopy 的主机库版本，请不要在调用站点公开通用 scopy 接口。

除非提供特定种类，否则在以下接口中，普通整数类型表示 integer(4)，普通实数类型表示 real(4)。

2.1. CUBLAS 定义和辅助函数

本节包含 cuBLAS 库中使用的定义和数据类型，以及到 cuBLAS 辅助函数的接口。

cublas 模块包含以下派生类型定义

TYPE cublasHandle
  TYPE(C_PTR)  :: handle
END TYPE

cuBLAS 模块包含以下枚举

enum, bind(c)
    enumerator :: CUBLAS_STATUS_SUCCESS         =0
    enumerator :: CUBLAS_STATUS_NOT_INITIALIZED =1
    enumerator :: CUBLAS_STATUS_ALLOC_FAILED    =3
    enumerator :: CUBLAS_STATUS_INVALID_VALUE   =7
    enumerator :: CUBLAS_STATUS_ARCH_MISMATCH   =8
    enumerator :: CUBLAS_STATUS_MAPPING_ERROR   =11
    enumerator :: CUBLAS_STATUS_EXECUTION_FAILED=13
    enumerator :: CUBLAS_STATUS_INTERNAL_ERROR  =14
end enum

enum, bind(c)
    enumerator :: CUBLAS_FILL_MODE_LOWER=0
    enumerator :: CUBLAS_FILL_MODE_UPPER=1
end enum

enum, bind(c)
    enumerator :: CUBLAS_DIAG_NON_UNIT=0
    enumerator :: CUBLAS_DIAG_UNIT=1
end enum

enum, bind(c)
    enumerator :: CUBLAS_SIDE_LEFT =0
    enumerator :: CUBLAS_SIDE_RIGHT=1
end enum

enum, bind(c)
    enumerator :: CUBLAS_OP_N=0
    enumerator :: CUBLAS_OP_T=1
    enumerator :: CUBLAS_OP_C=2
end enum

enum, bind(c)
    enumerator :: CUBLAS_POINTER_MODE_HOST   = 0
    enumerator :: CUBLAS_POINTER_MODE_DEVICE = 1
end enum

2.1.1. cublasCreate

此函数初始化 CUBLAS 库并创建一个句柄，指向保存 CUBLAS 库上下文的不透明结构。它在主机和设备上分配硬件资源，必须在进行任何其他 CUBLAS 库调用之前调用。CUBLAS 库上下文与当前的 CUDA 设备相关联。要在多个设备上使用该库，需要为每个设备创建一个 CUBLAS 句柄。此外，对于给定的设备，可以创建具有不同配置的多个 CUBLAS 句柄。由于 cublasCreate 分配了一些内部资源，并且通过调用 cublasDestroy 释放这些资源将隐式调用 cublasDeviceSynchronize，因此建议尽量减少 cublasCreate/cublasDestroy 的出现次数。对于从不同线程使用同一设备的多线程应用程序，建议的编程模型是为每个线程创建一个 CUBLAS 句柄，并在线程的整个生命周期中使用该 CUBLAS 句柄。

integer(4) function cublasCreate(handle)
  type(cublasHandle) :: handle

2.1.2. cublasDestroy

此函数释放 CUBLAS 库使用的硬件资源。此函数通常是使用特定句柄对 CUBLAS 库的最后一次调用。由于 cublasCreate 分配了一些内部资源，并且通过调用 cublasDestroy 释放这些资源将隐式调用 cublasDeviceSynchronize，因此建议尽量减少 cublasCreate/cublasDestroy 的出现次数。

integer(4) function cublasDestroy(handle)
  type(cublasHandle) :: handle

2.1.3. cublasGetVersion

此函数返回 cuBLAS 库的版本号。

integer(4) function cublasGetVersion(handle, version)
  type(cublasHandle) :: handle
  integer(4) :: version

2.1.4. cublasSetStream

此函数设置 cuBLAS 库流，该流将用于执行对 cuBLAS 库函数的所有后续调用。如果未设置 cuBLAS 库流，则所有内核都使用默认的 NULL 流。特别是，此例程可用于在内核启动之间更改流，然后将 cuBLAS 库流重置为 NULL。

integer(4) function cublasSetStream(handle, stream)
  type(cublasHandle) :: handle
  integer(kind=cuda_stream_kind()) :: stream

2.1.5. cublasGetStream

此函数获取 cuBLAS 库流，该流正用于执行对 cuBLAS 库函数的所有调用。如果未设置 cuBLAS 库流，则所有内核都使用默认的 NULL 流。

integer(4) function cublasGetStream(handle, stream)
  type(cublasHandle) :: handle
  integer(kind=cuda_stream_kind()) :: stream

2.1.6. cublasGetStatusName

此函数返回与给定状态值关联的 cuBLAS 状态名称。

character(128) function cublasGetStatusName(ierr)
  integer(4) :: ierr

2.1.7. cublasGetStatusString

此函数返回与给定状态值关联的 cuBLAS 状态字符串。

character(128) function cublasGetStatusString(ierr)
  integer(4) :: ierr

2.1.8. cublasGetPointerMode

此函数获取 cuBLAS 库使用的指针模式。在 cublas 模块中，指针模式根据是否在标量实际参数上设置了 device 属性，在每次调用的基础上设置和重置。有关指针模式的讨论，请参见第 1.6 节。

integer(4) function cublasGetPointerMode(handle, mode)
  type(cublasHandle) :: handle
  integer(4) :: mode

2.1.9. cublasSetPointerMode

此函数设置 cuBLAS 库使用的指针模式。当使用 cublas 模块时，指针模式根据是否在标量实际参数上设置了 device 属性，在每次调用的基础上设置。当将 cublas_v2 模块与 v2 接口一起使用时，程序员有责任调用 cublasSetPointerMode，以便库正确处理标量参数。有关指针模式的讨论，请参见第 1.6 节。

integer(4) function cublasSetPointerMode(handle, mode)
  type(cublasHandle) :: handle
  integer(4) :: mode

2.1.10. cublasGetAtomicsMode

此函数获取 cuBLAS 库使用的原子模式。

integer(4) function cublasGetAtomicsMode(handle, mode)
  type(cublasHandle) :: handle
  integer(4) :: mode

2.1.11. cublasSetAtomicsMode

此函数设置 cuBLAS 库使用的原子模式。cuBLAS 库中的某些例程具有使用原子操作累积结果的替代实现。这些替代实现可能会运行得更快，但也可能会生成每次运行结果不完全相同的结果。默认设置是不允许在 cuBLAS 函数中使用原子操作。

integer(4) function cublasSetAtomicsMode(handle, mode)
  type(cublasHandle) :: handle
  integer(4) :: mode

2.1.12. cublasGetMathMode

此函数获取 cuBLAS 库使用的数学模式。

integer(4) function cublasGetMathMode(handle, mode)
  type(cublasHandle) :: handle
  integer(4) :: mode

2.1.13. cublasSetMathMode

此函数设置 cuBLAS 库使用的数学模式。cuBLAS 库中的某些例程允许您选择用于生成结果的计算精度。这些替代方法可能会运行得更快，但也可能会生成不同的、不太准确的结果。

integer(4) function cublasSetMathMode(handle, mode)
  type(cublasHandle) :: handle
  integer(4) :: mode

2.1.14. cublasGetSmCountTarget

此函数获取 cuBLAS 库使用的 SM 计数目标。

integer(4) function cublasGetSmCountTarget(handle, counttarget)
  type(cublasHandle) :: handle
  integer(4) :: counttarget

2.1.15. cublasSetSmCountTarget

此函数设置 cuBLAS 库使用的 SM 计数目标。

integer(4) function cublasSetSmCountTarget(handle, counttarget)
  type(cublasHandle) :: handle
  integer(4) :: counttarget

2.1.16. cublasGetHandle

此函数获取线程当前正在使用的 cuBLAS 句柄。如果您正在使用旧版 BLAS API，或者不希望手动将句柄传递给底层函数或子例程，则 CUDA Fortran 运行时会跟踪 CPU 线程的当前句柄。

type(cublashandle) function cublasGetHandle()

integer(4) function cublasGetHandle(handle)
  type(cublasHandle) :: handle

2.1.17. cublasSetVector

此函数将主机内存空间中向量 x 的 n 个元素复制到 GPU 内存空间中向量 y。假定每个元素需要 elemSize 字节的存储空间。在 CUDA Fortran 中，向量 x 和 y 的类型被重载为接受任何数据类型，但数据类型的大小仍必须以字节为单位指定。此功能也可以使用 cudaMemcpy 或数组赋值语句来实现。

integer(4) function cublassetvector(n, elemsize, x, incx, y, incy)
  integer :: n, elemsize, incx, incy
  integer*1, dimension(*) :: x
  integer*1, device, dimension(*) :: y

2.1.18. cublasGetVector

此函数将 GPU 内存空间中向量 x 的 n 个元素复制到主机内存空间中向量 y。假定每个元素需要 elemSize 字节的存储空间。在 CUDA Fortran 中，向量 x 和 y 的类型被重载为接受任何数据类型，但数据类型的大小仍必须以字节为单位指定。此功能也可以使用 cudaMemcpy 或数组赋值语句来实现。

integer(4) function cublasgetvector(n, elemsize, x, incx, y, incy)
  integer :: n, elemsize, incx, incy
  integer*1, device, dimension(*) :: x
  integer*1, dimension(*) :: y

2.1.19. cublasSetMatrix

此函数将主机内存空间中矩阵 A 的 rows x cols 个元素的图块复制到 GPU 内存空间中矩阵 B。假定每个元素需要 elemSize 字节的存储空间。在 CUDA Fortran 中，矩阵 A 和 B 的类型被重载为接受任何数据类型，但数据类型的大小仍必须以字节为单位指定。此功能也可以使用 cudaMemcpy、cudaMemcpy2D 或数组赋值语句来实现。

integer(4) function cublassetmatrix(rows, cols, elemsize, a, lda, b, ldb)
  integer :: rows, cols, elemsize, lda, ldb
  integer*1, dimension(lda, *) :: a
  integer*1, device, dimension(ldb, *) :: b

2.1.20. cublasGetMatrix

此函数将 GPU 内存空间中矩阵 A 的 rows x cols 个元素的图块复制到主机内存空间中矩阵 B。假定每个元素需要 elemSize 字节的存储空间。在 CUDA Fortran 中，矩阵 A 和 B 的类型被重载为接受任何数据类型，但数据类型的大小仍必须以字节为单位指定。此功能也可以使用 cudaMemcpy、cudaMemcpy2D 或数组赋值语句来实现。

integer(4) function cublasgetmatrix(rows, cols, elemsize, a, lda, b, ldb)
  integer :: rows, cols, elemsize, lda, ldb
  integer*1, device, dimension(lda, *) :: a
  integer*1, dimension(ldb, *) :: b

2.1.21. cublasSetVectorAsync

此函数在给定的 CUDA 流上异步地将主机内存空间中向量 x 的 n 个元素复制到 GPU 内存空间中向量 y。假定每个元素需要 elemSize 字节的存储空间。在 CUDA Fortran 中，向量 x 和 y 的类型被重载为接受任何数据类型，但数据类型的大小仍必须以字节为单位指定。此功能也可以使用 cudaMemcpyAsync 来实现。

integer(4) function cublassetvectorasync(n, elemsize, x, incx, y, incy, stream)
  integer :: n, elemsize, incx, incy
  integer*1, dimension(*) :: x
  integer*1, device, dimension(*) :: y
  integer(kind=cuda_stream_kind()) :: stream

2.1.22. cublasGetVectorAsync

此函数在给定的 CUDA 流上异步地将主机内存空间中向量 x 的 n 个元素复制到 GPU 内存空间中向量 y。假定每个元素需要 elemSize 字节的存储空间。在 CUDA Fortran 中，向量 x 和 y 的类型被重载为接受任何数据类型，但数据类型的大小仍必须以字节为单位指定。此功能也可以使用 cudaMemcpyAsync 来实现。

integer(4) function cublasgetvectorasync(n, elemsize, x, incx, y, incy, stream)
  integer :: n, elemsize, incx, incy
  integer*1, device, dimension(*) :: x
  integer*1, dimension(*) :: y
  integer(kind=cuda_stream_kind()) :: stream

2.1.23. cublasSetMatrixAsync

此函数使用指定的流异步地将主机内存空间中矩阵 A 的 rows x cols 个元素的图块复制到 GPU 内存空间中矩阵 B。假定每个元素需要 elemSize 字节的存储空间。在 CUDA Fortran 中，矩阵 A 和 B 的类型被重载为接受任何数据类型，但数据类型的大小仍必须以字节为单位指定。此功能也可以使用 cudaMemcpyAsync 或 cudaMemcpy2DAsync 来实现。

integer(4) function cublassetmatrixasync(rows, cols, elemsize, a, lda, b, ldb, stream)
  integer :: rows, cols, elemsize, lda, ldb
  integer*1, dimension(lda, *) :: a
  integer*1, device, dimension(ldb, *) :: b
  integer(kind=cuda_stream_kind()) :: stream

2.1.24. cublasGetMatrixAsync

此函数使用指定的流异步地将 GPU 内存空间中矩阵 A 的 rows x cols 个元素的图块复制到主机内存空间中矩阵 B。假定每个元素需要 elemSize 字节的存储空间。在 CUDA Fortran 中，矩阵 A 和 B 的类型被重载为接受任何数据类型，但数据类型的大小仍必须以字节为单位指定。此功能也可以使用 cudaMemcpyAsync 或 cudaMemcpy2DAsync 来实现。

integer(4) function cublasgetmatrixasync(rows, cols, elemsize, a, lda, b, ldb, stream)
  integer :: rows, cols, elemsize, lda, ldb
  integer*1, device, dimension(lda, *) :: a
  integer*1, dimension(ldb, *) :: b
  integer(kind=cuda_stream_kind()) :: stream

2.2. 单精度函数和子例程

本节包含到单精度 BLAS 和 cuBLAS 函数和子例程的接口。

2.2.1. isamax

ISAMAX 查找具有最大绝对值的元素的索引。

integer(4) function isamax(n, x, incx)
  integer :: n
  real(4), device, dimension(*) :: x ! device or host variable
  integer :: incx

integer(4) function cublasIsamax(n, x, incx)
  integer :: n
  real(4), device, dimension(*) :: x
  integer :: incx

integer(4) function cublasIsamax_v2(h, n, x, incx, res)
  type(cublasHandle) :: h
  integer :: n
  real(4), device, dimension(*) :: x
  integer :: incx
  integer, device :: res ! device or host variable

2.2.2. isamin

ISAMIN 查找具有最小绝对值的元素的索引。

integer(4) function isamin(n, x, incx)
  integer :: n
  real(4), device, dimension(*) :: x ! device or host variable
  integer :: incx

integer(4) function cublasIsamin(n, x, incx)
  integer :: n
  real(4), device, dimension(*) :: x
  integer :: incx

integer(4) function cublasIsamin_v2(h, n, x, incx, res)
  type(cublasHandle) :: h
  integer :: n
  real(4), device, dimension(*) :: x
  integer :: incx
  integer, device :: res ! device or host variable

2.2.3. sasum

SASUM 获取绝对值的总和。

real(4) function sasum(n, x, incx)
  integer :: n
  real(4), device, dimension(*) :: x ! device or host variable
  integer :: incx

real(4) function cublasSasum(n, x, incx)
  integer :: n
  real(4), device, dimension(*) :: x
  integer :: incx

integer(4) function cublasSasum_v2(h, n, x, incx, res)
  type(cublasHandle) :: h
  integer :: n
  real(4), device, dimension(*) :: x
  integer :: incx
  real(4), device :: res ! device or host variable

2.2.4. saxpy

SAXPY 常数乘以向量加上向量。

subroutine saxpy(n, a, x, incx, y, incy)
  integer :: n
  real(4), device :: a ! device or host variable
  real(4), device, dimension(*) :: x, y ! device or host variable
  integer :: incx, incy

subroutine cublasSaxpy(n, a, x, incx, y, incy)
  integer :: n
  real(4), device :: a ! device or host variable
  real(4), device, dimension(*) :: x, y
  integer :: incx, incy

integer(4) function cublasSaxpy_v2(h, n, a, x, incx, y, incy)
  type(cublasHandle) :: h
  integer :: n
  real(4), device :: a ! device or host variable
  real(4), device, dimension(*) :: x, y
  integer :: incx, incy

2.2.5. scopy

SCOPY 将向量 x 复制到向量 y。

subroutine scopy(n, x, incx, y, incy)
  integer :: n
  real(4), device, dimension(*) :: x, y ! device or host variable
  integer :: incx, incy

subroutine cublasScopy(n, x, incx, y, incy)
  integer :: n
  real(4), device, dimension(*) :: x, y
  integer :: incx, incy

integer(4) function cublasScopy_v2(h, n, x, incx, y, incy)
  type(cublasHandle) :: h
  integer :: n
  real(4), device, dimension(*) :: x, y
  integer :: incx, incy

2.2.6. sdot

SDOT 形成两个向量的点积。

real(4) function sdot(n, x, incx, y, incy)
  integer :: n
  real(4), device, dimension(*) :: x, y ! device or host variable
  integer :: incx, incy

real(4) function cublasSdot(n, x, incx, y, incy)
  integer :: n
  real(4), device, dimension(*) :: x, y
  integer :: incx, incy

integer(4) function cublasSdot_v2(h, n, x, incx, y, incy, res)
  type(cublasHandle) :: h
  integer :: n
  real(4), device, dimension(*) :: x, y
  integer :: incx, incy
  real(4), device :: res ! device or host variable

2.2.7. snrm2

SNRM2 通过函数名称返回向量的欧几里得范数，因此 SNRM2 := sqrt( x’*x )。

real(4) function snrm2(n, x, incx)
  integer :: n
  real(4), device, dimension(*) :: x ! device or host variable
  integer :: incx

real(4) function cublasSnrm2(n, x, incx)
  integer :: n
  real(4), device, dimension(*) :: x
  integer :: incx

integer(4) function cublasSnrm2_v2(h, n, x, incx, res)
  type(cublasHandle) :: h
  integer :: n
  real(4), device, dimension(*) :: x
  integer :: incx
  real(4), device :: res ! device or host variable

2.2.8. srot

SROT 应用平面旋转。

subroutine srot(n, x, incx, y, incy, sc, ss)
  integer :: n
  real(4), device :: sc, ss ! device or host variable
  real(4), device, dimension(*) :: x, y ! device or host variable
  integer :: incx, incy

subroutine cublasSrot(n, x, incx, y, incy, sc, ss)
  integer :: n
  real(4), device :: sc, ss ! device or host variable
  real(4), device, dimension(*) :: x, y
  integer :: incx, incy

integer(4) function cublasSrot_v2(h, n, x, incx, y, incy, sc, ss)
  type(cublasHandle) :: h
  integer :: n
  real(4), device :: sc, ss ! device or host variable
  real(4), device, dimension(*) :: x, y
  integer :: incx, incy

2.2.9. srotg

SROTG 构造 Givens 平面旋转。

subroutine srotg(sa, sb, sc, ss)
  real(4), device :: sa, sb, sc, ss ! device or host variable

subroutine cublasSrotg(sa, sb, sc, ss)
  real(4), device :: sa, sb, sc, ss ! device or host variable

integer(4) function cublasSrotg_v2(h, sa, sb, sc, ss)
  type(cublasHandle) :: h
  real(4), device :: sa, sb, sc, ss ! device or host variable

2.2.10. srotm

SROTM 将修改后的 Givens 变换 H 应用于 2 乘 N 矩阵 (SX**T)，其中 **T 表示转置。SX 的元素位于 (SX**T) SX(LX+I*INCX) 中，I = 0 到 N-1，其中 LX = 1 如果 INCX .GE. 0，否则 LX = (-INCX)*N，SY 使用 LY 和 INCY 的情况类似。对于 SPARAM(1)=SFLAG，H 具有以下形式之一。SFLAG=-1.E0 SFLAG=0.E0 SFLAG=1.E0 SFLAG=-2.E0 (SH11 SH12) (1.E0 SH12) (SH11 1.E0) (1.E0 0.E0) H=( ) ( ) ( ) ( ) (SH21 SH22), (SH21 1.E0), (-1.E0 SH22), (0.E0 1.E0)。有关 SPARAM 中数据存储的描述，请参见 SROTMG。

subroutine srotm(n, x, incx, y, incy, param)
  integer :: n
  real(4), device, dimension(*) :: x, y ! device or host variable
  integer :: incx, incy

subroutine cublasSrotm(n, x, incx, y, incy, param)
  integer :: n
  real(4), device, dimension(*) :: x, y
  integer :: incx, incy
  real(4), device :: param(*) ! device or host variable

integer(4) function cublasSrotm_v2(h, n, x, incx, y, incy, param)
  type(cublasHandle) :: h
  integer :: n
  real(4), device :: param(*) ! device or host variable
  real(4), device, dimension(*) :: x, y
  integer :: incx, incy

2.2.11. srotmg

SROTMG 构造修改后的 Givens 变换矩阵 H，该矩阵将 2 向量 (SQRT(SD1)*SX1,SQRT(SD2)*SY2)**T 的第二个分量归零。对于 SPARAM(1)=SFLAG，H 具有以下形式之一。SFLAG=-1.E0 SFLAG=0.E0 SFLAG=1.E0 SFLAG=-2.E0 (SH11 SH12) (1.E0 SH12) (SH11 1.E0) (1.E0 0.E0) H=( ) ( ) ( ) (SH21 SH22), (SH21 1.E0), (-1.E0 SH22), (0.E0 1.E0). SPARAM 的位置 2-4 分别包含 SH11、SH21、SH12 和 SH22。（SPARAM(1) 的值隐含的 1.E0、-1.E0 或 0.E0 不存储在 SPARAM 中。）

subroutine srotmg(d1, d2, x1, y1, param)
  real(4), device :: d1, d2, x1, y1, param(*) ! device or host variable

subroutine cublasSrotmg(d1, d2, x1, y1, param)
  real(4), device :: d1, d2, x1, y1, param(*) ! device or host variable

integer(4) function cublasSrotmg_v2(h, d1, d2, x1, y1, param)
  type(cublasHandle) :: h
  real(4), device :: d1, d2, x1, y1, param(*) ! device or host variable

2.2.12. sscal

SSCAL 按常数缩放向量。

subroutine sscal(n, a, x, incx)
  integer :: n
  real(4), device :: a ! device or host variable
  real(4), device, dimension(*) :: x ! device or host variable
  integer :: incx

subroutine cublasSscal(n, a, x, incx)
  integer :: n
  real(4), device :: a ! device or host variable
  real(4), device, dimension(*) :: x
  integer :: incx

integer(4) function cublasSscal_v2(h, n, a, x, incx)
  type(cublasHandle) :: h
  integer :: n
  real(4), device :: a ! device or host variable
  real(4), device, dimension(*) :: x
  integer :: incx

2.2.13. sswap

SSWAP 交换两个向量。

subroutine sswap(n, x, incx, y, incy)
  integer :: n
  real(4), device, dimension(*) :: x, y ! device or host variable
  integer :: incx, incy

subroutine cublasSswap(n, x, incx, y, incy)
  integer :: n
  real(4), device, dimension(*) :: x, y
  integer :: incx, incy

integer(4) function cublasSswap_v2(h, n, x, incx, y, incy)
  type(cublasHandle) :: h
  integer :: n
  real(4), device, dimension(*) :: x, y
  integer :: incx, incy

2.2.14. sgbmv

SGBMV 执行矩阵向量运算之一 y := alpha*A*x + beta*y 或 y := alpha*A**T*x + beta*y，其中 alpha 和 beta 是标量，x 和 y 是向量，A 是 m 乘 n 带状矩阵，具有 kl 个下对角线和 ku 个上对角线。

subroutine sgbmv(t, m, n, kl, ku, alpha, a, lda, x, incx, beta, y, incy)
  character*1 :: t
  integer :: m, n, kl, ku, lda, incx, incy
  real(4), device, dimension(lda, *) :: a ! device or host variable
  real(4), device, dimension(*) :: x, y ! device or host variable
  real(4), device :: alpha, beta ! device or host variable

subroutine cublasSgbmv(t, m, n, kl, ku, alpha, a, lda, x, incx, beta, y, incy)
  character*1 :: t
  integer :: m, n, kl, ku, lda, incx, incy
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(*) :: x, y
  real(4), device :: alpha, beta ! device or host variable

integer(4) function cublasSgbmv_v2(h, t, m, n, kl, ku, alpha, a, lda, x, incx, beta, y, incy)
  type(cublasHandle) :: h
  integer :: t
  integer :: m, n, kl, ku, lda, incx, incy
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(*) :: x, y
  real(4), device :: alpha, beta ! device or host variable

2.2.15. sgemv

SGEMV 执行矩阵向量运算之一 y := alpha*A*x + beta*y 或 y := alpha*A**T*x + beta*y，其中 alpha 和 beta 是标量，x 和 y 是向量，A 是 m 乘 n 矩阵。

subroutine sgemv(t, m, n, alpha, a, lda, x, incx, beta, y, incy)
  character*1 :: t
  integer :: m, n, lda, incx, incy
  real(4), device, dimension(lda, *) :: a ! device or host variable
  real(4), device, dimension(*) :: x, y ! device or host variable
  real(4), device :: alpha, beta ! device or host variable

subroutine cublasSgemv(t, m, n, alpha, a, lda, x, incx, beta, y, incy)
  character*1 :: t
  integer :: m, n, lda, incx, incy
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(*) :: x, y
  real(4), device :: alpha, beta ! device or host variable

integer(4) function cublasSgemv_v2(h, t, m, n, alpha, a, lda, x, incx, beta, y, incy)
  type(cublasHandle) :: h
  integer :: t
  integer :: m, n, lda, incx, incy
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(*) :: x, y
  real(4), device :: alpha, beta ! device or host variable

2.2.16. sger

SGER 执行秩 1 运算 A := alpha*x*y**T + A，其中 alpha 是标量，x 是 m 元素向量，y 是 n 元素向量，A 是 m 乘 n 矩阵。

subroutine sger(m, n, alpha, x, incx, y, incy, a, lda)
  integer :: m, n, lda, incx, incy
  real(4), device, dimension(lda, *) :: a ! device or host variable
  real(4), device, dimension(*) :: x, y ! device or host variable
  real(4), device :: alpha ! device or host variable

subroutine cublasSger(m, n, alpha, x, incx, y, incy, a, lda)
  integer :: m, n, lda, incx, incy
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(*) :: x, y
  real(4), device :: alpha ! device or host variable

integer(4) function cublasSger_v2(h, m, n, alpha, x, incx, y, incy, a, lda)
  type(cublasHandle) :: h
  integer :: m, n, lda, incx, incy
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(*) :: x, y
  real(4), device :: alpha ! device or host variable

2.2.17. ssbmv

SSBMV 执行矩阵向量运算 y := alpha*A*x + beta*y，其中 alpha 和 beta 是标量，x 和 y 是 n 元素向量，A 是 n 乘 n 对称带状矩阵，具有 k 个上对角线。

subroutine ssbmv(t, n, k, alpha, a, lda, x, incx, beta, y, incy)
  character*1 :: t
  integer :: k, n, lda, incx, incy
  real(4), device, dimension(lda, *) :: a ! device or host variable
  real(4), device, dimension(*) :: x, y ! device or host variable
  real(4), device :: alpha, beta ! device or host variable

subroutine cublasSsbmv(t, n, k, alpha, a, lda, x, incx, beta, y, incy)
  character*1 :: t
  integer :: k, n, lda, incx, incy
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(*) :: x, y
  real(4), device :: alpha, beta ! device or host variable

integer(4) function cublasSsbmv_v2(h, t, n, k, alpha, a, lda, x, incx, beta, y, incy)
  type(cublasHandle) :: h
  integer :: t
  integer :: k, n, lda, incx, incy
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(*) :: x, y
  real(4), device :: alpha, beta ! device or host variable

2.2.18. sspmv

SSPMV 执行矩阵-向量运算 y := alpha*A*x + beta*y，其中 alpha 和 beta 是标量，x 和 y 是 n 元素向量，A 是以压缩形式提供的 n x n 对称矩阵。

subroutine sspmv(t, n, alpha, a, x, incx, beta, y, incy)
  character*1 :: t
  integer :: n, incx, incy
  real(4), device, dimension(*) :: a, x, y ! device or host variable
  real(4), device :: alpha, beta ! device or host variable

subroutine cublasSspmv(t, n, alpha, a, x, incx, beta, y, incy)
  character*1 :: t
  integer :: n, incx, incy
  real(4), device, dimension(*) :: a, x, y
  real(4), device :: alpha, beta ! device or host variable

integer(4) function cublasSspmv_v2(h, t, n, alpha, a, x, incx, beta, y, incy)
  type(cublasHandle) :: h
  integer :: t
  integer :: n, incx, incy
  real(4), device, dimension(*) :: a, x, y
  real(4), device :: alpha, beta ! device or host variable

2.2.19. sspr

SSPR 执行对称秩 1 运算 A := alpha*x*x**T + A，其中 alpha 是实标量，x 是 n 元素向量，A 是以压缩形式提供的 n x n 对称矩阵。

subroutine sspr(t, n, alpha, x, incx, a)
  character*1 :: t
  integer :: n, incx
  real(4), device, dimension(*) :: a, x ! device or host variable
  real(4), device :: alpha ! device or host variable

subroutine cublasSspr(t, n, alpha, x, incx, a)
  character*1 :: t
  integer :: n, incx
  real(4), device, dimension(*) :: a, x
  real(4), device :: alpha ! device or host variable

integer(4) function cublasSspr_v2(h, t, n, alpha, x, incx, a)
  type(cublasHandle) :: h
  integer :: t
  integer :: n, incx
  real(4), device, dimension(*) :: a, x
  real(4), device :: alpha ! device or host variable

2.2.20. sspr2

SSPR2 执行对称秩 2 运算 A := alpha*x*y**T + alpha*y*x**T + A，其中 alpha 是标量，x 和 y 是 n 元素向量，A 是以压缩形式提供的 n x n 对称矩阵。

subroutine sspr2(t, n, alpha, x, incx, y, incy, a)
  character*1 :: t
  integer :: n, incx, incy
  real(4), device, dimension(*) :: a, x, y ! device or host variable
  real(4), device :: alpha ! device or host variable

subroutine cublasSspr2(t, n, alpha, x, incx, y, incy, a)
  character*1 :: t
  integer :: n, incx, incy
  real(4), device, dimension(*) :: a, x, y
  real(4), device :: alpha ! device or host variable

integer(4) function cublasSspr2_v2(h, t, n, alpha, x, incx, y, incy, a)
  type(cublasHandle) :: h
  integer :: t
  integer :: n, incx, incy
  real(4), device, dimension(*) :: a, x, y
  real(4), device :: alpha ! device or host variable

2.2.21. ssymv

SSYMV 执行矩阵-向量运算 y := alpha*A*x + beta*y，其中 alpha 和 beta 是标量，x 和 y 是 n 元素向量，A 是 n x n 对称矩阵。

subroutine ssymv(uplo, n, alpha, a, lda, x, incx, beta, y, incy)
  character*1 :: uplo
  integer :: n, lda, incx, incy
  real(4), device, dimension(lda, *) :: a ! device or host variable
  real(4), device, dimension(*) :: x, y ! device or host variable
  real(4), device :: alpha, beta ! device or host variable

subroutine cublasSsymv(uplo, n, alpha, a, lda, x, incx, beta, y, incy)
  character*1 :: uplo
  integer :: n, lda, incx, incy
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(*) :: x, y
  real(4), device :: alpha, beta ! device or host variable

integer(4) function cublasSsymv_v2(h, uplo, n, alpha, a, lda, x, incx, beta, y, incy)
  type(cublasHandle) :: h
  integer :: uplo
  integer :: n, lda, incx, incy
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(*) :: x, y
  real(4), device :: alpha, beta ! device or host variable

2.2.22. ssyr

SSYR 执行对称秩 1 运算 A := alpha*x*x**T + A，其中 alpha 是实标量，x 是 n 元素向量，A 是 n x n 对称矩阵。

subroutine ssyr(t, n, alpha, x, incx, a, lda)
  character*1 :: t
  integer :: n, incx, lda
  real(4), device, dimension(lda, *) :: a ! device or host variable
  real(4), device, dimension(*) :: x ! device or host variable
  real(4), device :: alpha ! device or host variable

subroutine cublasSsyr(t, n, alpha, x, incx, a, lda)
  character*1 :: t
  integer :: n, incx, lda
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(*) :: x
  real(4), device :: alpha ! device or host variable

integer(4) function cublasSsyr_v2(h, t, n, alpha, x, incx, a, lda)
  type(cublasHandle) :: h
  integer :: t
  integer :: n, incx, lda
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(*) :: x
  real(4), device :: alpha ! device or host variable

2.2.23. ssyr2

SSYR2 执行对称秩 2 运算 A := alpha*x*y**T + alpha*y*x**T + A，其中 alpha 是标量，x 和 y 是 n 元素向量，A 是 n x n 对称矩阵。

subroutine ssyr2(t, n, alpha, x, incx, y, incy, a, lda)
  character*1 :: t
  integer :: n, incx, incy, lda
  real(4), device, dimension(lda, *) :: a ! device or host variable
  real(4), device, dimension(*) :: x, y ! device or host variable
  real(4), device :: alpha ! device or host variable

subroutine cublasSsyr2(t, n, alpha, x, incx, y, incy, a, lda)
  character*1 :: t
  integer :: n, incx, incy, lda
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(*) :: x, y
  real(4), device :: alpha ! device or host variable

integer(4) function cublasSsyr2_v2(h, t, n, alpha, x, incx, y, incy, a, lda)
  type(cublasHandle) :: h
  integer :: t
  integer :: n, incx, incy, lda
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(*) :: x, y
  real(4), device :: alpha ! device or host variable

2.2.24. stbmv

STBMV 执行矩阵-向量运算 x := A*x 或 x := A**T*x 之一，其中 x 是 n 元素向量，A 是具有 ( k + 1 ) 条对角线的 n x n 单位或非单位上或下三角带状矩阵。

subroutine stbmv(u, t, d, n, k, a, lda, x, incx)
  character*1 :: u, t, d
  integer :: n, k, incx, lda
  real(4), device, dimension(lda, *) :: a ! device or host variable
  real(4), device, dimension(*) :: x ! device or host variable

subroutine cublasStbmv(u, t, d, n, k, a, lda, x, incx)
  character*1 :: u, t, d
  integer :: n, k, incx, lda
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(*) :: x

integer(4) function cublasStbmv_v2(h, u, t, d, n, k, a, lda, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, k, incx, lda
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(*) :: x

2.2.25. stbsv

STBSV 求解方程组 A*x = b 或 A**T*x = b 之一，其中 b 和 x 是 n 元素向量，A 是具有 ( k + 1 ) 条对角线的 n x n 单位或非单位上或下三角带状矩阵。此例程中不包含奇异性或接近奇异性的测试。此类测试必须在此例程调用之前执行。

subroutine stbsv(u, t, d, n, k, a, lda, x, incx)
  character*1 :: u, t, d
  integer :: n, k, incx, lda
  real(4), device, dimension(lda, *) :: a ! device or host variable
  real(4), device, dimension(*) :: x ! device or host variable

subroutine cublasStbsv(u, t, d, n, k, a, lda, x, incx)
  character*1 :: u, t, d
  integer :: n, k, incx, lda
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(*) :: x

integer(4) function cublasStbsv_v2(h, u, t, d, n, k, a, lda, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, k, incx, lda
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(*) :: x

2.2.26. stpmv

STPMV 执行矩阵-向量运算 x := A*x 或 x := A**T*x 之一，其中 x 是 n 元素向量，A 是以压缩形式提供的 n x n 单位或非单位上或下三角矩阵。

subroutine stpmv(u, t, d, n, a, x, incx)
  character*1 :: u, t, d
  integer :: n, incx
  real(4), device, dimension(*) :: a, x ! device or host variable

subroutine cublasStpmv(u, t, d, n, a, x, incx)
  character*1 :: u, t, d
  integer :: n, incx
  real(4), device, dimension(*) :: a, x

integer(4) function cublasStpmv_v2(h, u, t, d, n, a, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, incx
  real(4), device, dimension(*) :: a, x

2.2.27. stpsv

STPSV 求解方程组 A*x = b 或 A**T*x = b 之一，其中 b 和 x 是 n 元素向量，A 是以压缩形式提供的 n x n 单位或非单位上或下三角矩阵。此例程中不包含奇异性或接近奇异性的测试。此类测试必须在此例程调用之前执行。

subroutine stpsv(u, t, d, n, a, x, incx)
  character*1 :: u, t, d
  integer :: n, incx
  real(4), device, dimension(*) :: a, x ! device or host variable

subroutine cublasStpsv(u, t, d, n, a, x, incx)
  character*1 :: u, t, d
  integer :: n, incx
  real(4), device, dimension(*) :: a, x

integer(4) function cublasStpsv_v2(h, u, t, d, n, a, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, incx
  real(4), device, dimension(*) :: a, x

2.2.28. strmv

STRMV 执行矩阵-向量运算 x := A*x 或 x := A**T*x 之一，其中 x 是 n 元素向量，A 是 n x n 单位或非单位上或下三角矩阵。

subroutine strmv(u, t, d, n, a, lda, x, incx)
  character*1 :: u, t, d
  integer :: n, incx, lda
  real(4), device, dimension(lda, *) :: a ! device or host variable
  real(4), device, dimension(*) :: x ! device or host variable

subroutine cublasStrmv(u, t, d, n, a, lda, x, incx)
  character*1 :: u, t, d
  integer :: n, incx, lda
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(*) :: x

integer(4) function cublasStrmv_v2(h, u, t, d, n, a, lda, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, incx, lda
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(*) :: x

2.2.29. strsv

STRSV 求解方程组 A*x = b 或 A**T*x = b 之一，其中 b 和 x 是 n 元素向量，A 是 n x n 单位或非单位上或下三角矩阵。此例程中不包含奇异性或接近奇异性的测试。此类测试必须在此例程调用之前执行。

subroutine strsv(u, t, d, n, a, lda, x, incx)
  character*1 :: u, t, d
  integer :: n, incx, lda
  real(4), device, dimension(lda, *) :: a ! device or host variable
  real(4), device, dimension(*) :: x ! device or host variable

subroutine cublasStrsv(u, t, d, n, a, lda, x, incx)
  character*1 :: u, t, d
  integer :: n, incx, lda
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(*) :: x

integer(4) function cublasStrsv_v2(h, u, t, d, n, a, lda, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, incx, lda
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(*) :: x

2.2.30. sgemm

SGEMM 执行矩阵-矩阵运算 C := alpha*op( A )*op( B ) + beta*C 之一，其中 op( X ) 是 op( X ) = X 或 op( X ) = X**T 之一，alpha 和 beta 是标量，A、B 和 C 是矩阵，其中 op( A ) 是 m x k 矩阵，op( B ) 是 k x n 矩阵，C 是 m x n 矩阵。

subroutine sgemm(transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  character*1 :: transa, transb
  integer :: m, n, k, lda, ldb, ldc
  real(4), device, dimension(lda, *) :: a ! device or host variable
  real(4), device, dimension(ldb, *) :: b ! device or host variable
  real(4), device, dimension(ldc, *) :: c ! device or host variable
  real(4), device :: alpha, beta ! device or host variable

subroutine cublasSgemm(transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  character*1 :: transa, transb
  integer :: m, n, k, lda, ldb, ldc
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(ldb, *) :: b
  real(4), device, dimension(ldc, *) :: c
  real(4), device :: alpha, beta ! device or host variable

integer(4) function cublasSgemm_v2(h, transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: transa, transb
  integer :: m, n, k, lda, ldb, ldc
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(ldb, *) :: b
  real(4), device, dimension(ldc, *) :: c
  real(4), device :: alpha, beta ! device or host variable

2.2.31. ssymm

SSYMM 执行矩阵-矩阵运算 C := alpha*A*B + beta*C 或 C := alpha*B*A + beta*C 之一，其中 alpha 和 beta 是标量，A 是对称矩阵，B 和 C 是 m x n 矩阵。

subroutine ssymm(side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc)
  character*1 :: side, uplo
  integer :: m, n, lda, ldb, ldc
  real(4), device, dimension(lda, *) :: a ! device or host variable
  real(4), device, dimension(ldb, *) :: b ! device or host variable
  real(4), device, dimension(ldc, *) :: c ! device or host variable
  real(4), device :: alpha, beta ! device or host variable

subroutine cublasSsymm(side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc)
  character*1 :: side, uplo
  integer :: m, n, lda, ldb, ldc
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(ldb, *) :: b
  real(4), device, dimension(ldc, *) :: c
  real(4), device :: alpha, beta ! device or host variable

integer(4) function cublasSsymm_v2(h, side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: side, uplo
  integer :: m, n, lda, ldb, ldc
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(ldb, *) :: b
  real(4), device, dimension(ldc, *) :: c
  real(4), device :: alpha, beta ! device or host variable

2.2.32. ssyrk

SSYRK 执行对称秩 k 运算 C := alpha*A*A**T + beta*C 或 C := alpha*A**T*A + beta*C 之一，其中 alpha 和 beta 是标量，C 是 n x n 对称矩阵，A 在第一种情况下是 n x k 矩阵，在第二种情况下是 k x n 矩阵。

subroutine ssyrk(uplo, trans, n, k, alpha, a, lda, beta, c, ldc)
  character*1 :: uplo, trans
  integer :: n, k, lda, ldc
  real(4), device, dimension(lda, *) :: a ! device or host variable
  real(4), device, dimension(ldc, *) :: c ! device or host variable
  real(4), device :: alpha, beta ! device or host variable

subroutine cublasSsyrk(uplo, trans, n, k, alpha, a, lda, beta, c, ldc)
  character*1 :: uplo, trans
  integer :: n, k, lda, ldc
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(ldc, *) :: c
  real(4), device :: alpha, beta ! device or host variable

integer(4) function cublasSsyrk_v2(h, uplo, trans, n, k, alpha, a, lda, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: uplo, trans
  integer :: n, k, lda, ldc
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(ldc, *) :: c
  real(4), device :: alpha, beta ! device or host variable

2.2.33. ssyr2k

SSYR2K 执行对称秩 2k 运算 C := alpha*A*B**T + alpha*B*A**T + beta*C 或 C := alpha*A**T*B + alpha*B**T*A + beta*C 之一，其中 alpha 和 beta 是标量，C 是 n x n 对称矩阵，A 和 B 在第一种情况下是 n x k 矩阵，在第二种情况下是 k x n 矩阵。

subroutine ssyr2k(uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  character*1 :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  real(4), device, dimension(lda, *) :: a ! device or host variable
  real(4), device, dimension(ldb, *) :: b ! device or host variable
  real(4), device, dimension(ldc, *) :: c ! device or host variable
  real(4), device :: alpha, beta ! device or host variable

subroutine cublasSsyr2k(uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  character*1 :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(ldb, *) :: b
  real(4), device, dimension(ldc, *) :: c
  real(4), device :: alpha, beta ! device or host variable

integer(4) function cublasSsyr2k_v2(h, uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(ldb, *) :: b
  real(4), device, dimension(ldc, *) :: c
  real(4), device :: alpha, beta ! device or host variable

2.2.34. ssyrkx

SSYRKX 执行对称秩 k 更新 C := alpha*A*B**T + beta*C 的变体，其中 alpha 和 beta 是标量，C 是以下三角或上三角模式存储的 n x n 对称矩阵，A 和 B 是 n x k 矩阵。当 B 以某种方式使得结果保证对称时，可以使用此例程。有关更多详细信息，请参阅 CUBLAS 文档。

subroutine ssyrkx(uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  character*1 :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  real(4), device, dimension(lda, *) :: a ! device or host variable
  real(4), device, dimension(ldb, *) :: b ! device or host variable
  real(4), device, dimension(ldc, *) :: c ! device or host variable
  real(4), device :: alpha, beta ! device or host variable

subroutine cublasSsyrkx(uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  character*1 :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(ldb, *) :: b
  real(4), device, dimension(ldc, *) :: c

  real(4), device :: alpha, beta ! device or host variable

integer(4) function cublasSsyrkx_v2(h, uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(ldb, *) :: b
  real(4), device, dimension(ldc, *) :: c
  real(4), device :: alpha, beta ! device or host variable

2.2.35. strmm

STRMM 执行矩阵-矩阵运算 B := alpha*op( A )*B 或 B := alpha*B*op( A ) 之一，其中 alpha 是标量，B 是 m x n 矩阵，A 是单位或非单位上或下三角矩阵，op( A ) 是 op( A ) = A 或 op( A ) = A**T 之一。

subroutine strmm(side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)
  character*1 :: side, uplo, transa, diag
  integer :: m, n, lda, ldb
  real(4), device, dimension(lda, *) :: a ! device or host variable
  real(4), device, dimension(ldb, *) :: b ! device or host variable
  real(4), device :: alpha ! device or host variable

subroutine cublasStrmm(side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)
  character*1 :: side, uplo, transa, diag
  integer :: m, n, lda, ldb
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(ldb, *) :: b
  real(4), device :: alpha ! device or host variable

integer(4) function cublasStrmm_v2(h, side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb, c, ldc)
  type(cublasHandle) :: h
  integer :: side, uplo, transa, diag
  integer :: m, n, lda, ldb, ldc
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(ldb, *) :: b
  real(4), device, dimension(ldc, *) :: c
  real(4), device :: alpha ! device or host variable

2.2.36. strsm

STRSM 求解矩阵方程 op( A )*X = alpha*B 或 X*op( A ) = alpha*B 之一，其中 alpha 是标量，X 和 B 是 m x n 矩阵，A 是单位或非单位上或下三角矩阵，op( A ) 是 op( A ) = A 或 op( A ) = A**T 之一。矩阵 X 在 B 上被覆盖。

subroutine strsm(side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)
  character*1 :: side, uplo, transa, diag
  integer :: m, n, lda, ldb
  real(4), device, dimension(lda, *) :: a ! device or host variable
  real(4), device, dimension(ldb, *) :: b ! device or host variable
  real(4), device :: alpha ! device or host variable

subroutine cublasStrsm(side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)
  character*1 :: side, uplo, transa, diag
  integer :: m, n, lda, ldb
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(ldb, *) :: b
  real(4), device :: alpha ! device or host variable

integer(4) function cublasStrsm_v2(h, side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)
  type(cublasHandle) :: h
  integer :: side, uplo, transa, diag
  integer :: m, n, lda, ldb
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(ldb, *) :: b
  real(4), device :: alpha ! device or host variable

2.2.37. cublasSgemvBatched

SGEMV 执行批量矩阵-向量运算 Y := alpha*op( A ) * X + beta*Y，其中 op( A ) 是 op( A ) = A 或 op( A ) = A**T 之一，alpha 和 beta 是标量，A 是 m x n 矩阵，X 和 Y 是向量。

integer(4) function cublasSgemvBatched(h, trans, m, n, alpha, &
      Aarray, lda, xarray, incx, beta, yarray, incy, batchCount)
  type(cublasHandle) :: h
  integer :: trans ! integer or character(1) variable
  integer :: m, n
  real(4), device :: alpha ! device or host variable
  type(c_devptr), device :: Aarray(*)
  integer :: lda
  type(c_devptr), device :: xarray(*)
  integer :: incx
  real(4), device :: beta ! device or host variable
  type(c_devptr), device :: yarray(*)
  integer :: incy
  integer :: batchCount

integer(4) function cublasSgemvBatched_v2(h, trans, m, n, alpha, &
      Aarray, lda, xarray, incx, beta, yarray, incy, batchCount)
  type(cublasHandle) :: h
  integer :: trans
  integer :: m, n
  real(4), device :: alpha ! device or host variable
  type(c_devptr), device :: Aarray(*)
  integer :: lda
  type(c_devptr), device :: xarray(*)
  integer :: incx
  real(4), device :: beta ! device or host variable
  type(c_devptr), device :: yarray(*)
  integer :: incy
  integer :: batchCount

2.2.38. cublasSgemmBatched

SGEMM 执行矩阵-矩阵运算 C := alpha*op( A )*op( B ) + beta*C 之一，其中 op( X ) 是 op( X ) = X 或 op( X ) = X**T 之一，alpha 和 beta 是标量，A、B 和 C 是矩阵，其中 op( A ) 是 m x k 矩阵，op( B ) 是 k x n 矩阵，C 是 m x n 矩阵。

integer(4) function cublasSgemmBatched(h, transa, transb, m, n, k, alpha, Aarray, lda, Barray, ldb, beta, Carray, ldc, batchCount)
  type(cublasHandle) :: h
  integer :: transa ! integer or character(1) variable
  integer :: transb ! integer or character(1) variable
  integer :: m, n, k
  real(4), device :: alpha ! device or host variable
  type(c_devptr), device :: Aarray(*)
  integer :: lda
  type(c_devptr), device :: Barray(*)
  integer :: ldb
  real(4), device :: beta ! device or host variable
  type(c_devptr), device :: Carray(*)
  integer :: ldc
  integer :: batchCount

integer(4) function cublasSgemmBatched_v2(h, transa, transb, m, n, k, alpha, &
           Aarray, lda, Barray, ldb, beta, Carray, ldc, batchCount)
  type(cublasHandle) :: h
  integer :: transa
  integer :: transb
  integer :: m, n, k
  real(4), device :: alpha ! device or host variable
  type(c_devptr), device :: Aarray(*)
  integer :: lda
  type(c_devptr), device :: Barray(*)
  integer :: ldb
  real(4), device :: beta ! device or host variable
  type(c_devptr), device :: Carray(*)
  integer :: ldc
  integer :: batchCount

2.2.39. cublasSgelsBatched

SGELS 使用 A 的 QR 或 LQ 分解求解涉及 M×N 矩阵 A 或其转置的超定或欠定实线性系统。假设 A 具有满秩。提供以下选项：1. 如果 TRANS = ‘N’ 且 m >= n：找到超定系统的最小二乘解，即求解最小二乘问题 minimize || B - A*X ||。2. 如果 TRANS = ‘N’ 且 m < n：找到欠定系统 A * X = B 的最小范数解。3. 如果 TRANS = ‘T’ 且 m >= n：找到欠定系统 A**T * X = B 的最小范数解。4. 如果 TRANS = ‘T’ 且 m < n：找到超定系统的最小二乘解，即求解最小二乘问题 minimize || B - A**T * X ||。可以在单个调用中处理多个右手边向量 b 和解向量 x；它们存储为 M×NRHS 右手边矩阵 B 和 N×NRHS 解矩阵 X 的列。

integer(4) function cublasSgelsBatched(h, trans, m, n, nrhs, Aarray, lda, Carray, ldc, info, devinfo, batchCount)
  type(cublasHandle) :: h
  integer :: trans ! integer or character(1) variable
  integer :: m, n, nrhs
  type(c_devptr), device :: Aarray(*)
  integer :: lda
  type(c_devptr), device :: Carray(*)
  integer :: ldc
  integer :: info(*)
  integer, device :: devinfo(*)
  integer :: batchCount

2.2.40. cublasSgeqrfBatched

SGEQRF 计算实数 M×N 矩阵 A 的 QR 分解：A = Q * R。

integer(4) function cublasSgeqrfBatched(h, m, n, Aarray, lda, Tau, info, batchCount)
  type(cublasHandle) :: h
  integer :: m, n
  type(c_devptr), device :: Aarray(*)
  integer :: lda
  type(c_devptr), device :: Tau(*)
  integer :: info(*)
  integer :: batchCount

2.2.41. cublasSgetrfBatched

SGETRF 使用带行交换的部分主元法计算一般 M×N 矩阵 A 的 LU 分解。分解形式为 A = P * L * U，其中 P 是置换矩阵，L 是具有单位对角线元素的下三角矩阵（如果 m > n，则为下梯形），U 是上三角矩阵（如果 m < n，则为上梯形）。这是算法的右视 Level 3 BLAS 版本。

integer(4) function cublasSgetrfBatched(h, n, Aarray, lda, ipvt, info, batchCount)
  type(cublasHandle) :: h
  integer :: n
  type(c_devptr), device :: Aarray(*)
  integer :: lda
  integer, device :: ipvt(*)
  integer, device :: info(*)
  integer :: batchCount

2.2.42. cublasSgetriBatched

SGETRI 使用 SGETRF 计算的 LU 分解计算矩阵的逆。此方法反转 U，然后通过求解系统 inv(A)*L = inv(U) 来计算 inv(A)。

integer(4) function cublasSgetriBatched(h, n, Aarray, lda, ipvt, Carray, ldc, info, batchCount)
  type(cublasHandle) :: h
  integer :: n
  type(c_devptr), device :: Aarray(*)
  integer :: lda
  integer, device :: ipvt(*)
  type(c_devptr), device :: Carray(*)
  integer :: ldc
  integer, device :: info(*)
  integer :: batchCount

2.2.43. cublasSgetrsBatched

SGETRS 使用 SGETRF 计算的 LU 分解求解具有一般 N×N 矩阵 A 的线性方程组 A * X = B 或 A**T * X = B。

integer(4) function cublasSgetrsBatched(h, trans, n, nrhs, Aarray, lda, ipvt, Barray, ldb, info, batchCount)
  type(cublasHandle) :: h
  integer :: trans ! integer or character(1) variable
  integer :: n, nrhs
  type(c_devptr), device :: Aarray(*)
  integer :: lda
  integer, device :: ipvt(*)
  type(c_devptr), device :: Barray(*)
  integer :: ldb
  integer :: info(*)
  integer :: batchCount

2.2.44. cublasSmatinvBatched

cublasSmatinvBatched 是 cublasSgetrfBatched 加 cublasSgetriBatched 的快捷方式。但是，它仅在 n 小于 32 时有效。否则，用户必须通过 cublasSgetrfBatched 和 cublasSgetriBatched。

integer(4) function cublasSmatinvBatched(h, n, Aarray, lda, Ainv, lda_inv, info, batchCount)
  type(cublasHandle) :: h
  integer :: n
  type(c_devptr), device :: Aarray(*)
  integer :: lda
  type(c_devptr), device :: Ainv(*)
  integer :: lda_inv
  integer, device :: info(*)
  integer :: batchCount

2.2.45. cublasStrsmBatched

STRSM 求解矩阵方程 op( A )*X = alpha*B 或 X*op( A ) = alpha*B 之一，其中 alpha 是标量，X 和 B 是 m x n 矩阵，A 是单位或非单位上或下三角矩阵，op( A ) 是 op( A ) = A 或 op( A ) = A**T 之一。矩阵 X 在 B 上被覆盖。

integer(4) function cublasStrsmBatched( h, side, uplo, trans, diag, m, n, alpha, A, lda, B, ldb, batchCount)
  type(cublasHandle) :: h
  integer :: side ! integer or character(1) variable
  integer :: uplo ! integer or character(1) variable
  integer :: trans ! integer or character(1) variable
  integer :: diag ! integer or character(1) variable
  integer :: m, n
  real(4), device :: alpha ! device or host variable
  type(c_devptr), device :: A(*)
  integer :: lda
  type(c_devptr), device :: B(*)
  integer :: ldb
  integer :: batchCount

integer(4) function cublasStrsmBatched_v2( h, side, uplo, trans, diag, m, n, alpha, A, lda, B, ldb, batchCount)
  type(cublasHandle) :: h
  integer :: side
  integer :: uplo
  integer :: trans
  integer :: diag
  integer :: m, n
  real(4), device :: alpha ! device or host variable
  type(c_devptr), device :: A(*)
  integer :: lda
  type(c_devptr), device :: B(*)
  integer :: ldb
  integer :: batchCount

2.2.46. cublasSgemvStridedBatched

SGEMV 执行批量矩阵-向量运算 Y := alpha*op( A ) * X + beta*Y，其中 op( A ) 是 op( A ) = A 或 op( A ) = A**T 之一，alpha 和 beta 是标量，A 是 m x n 矩阵，X 和 Y 是向量。

integer(4) function cublasSgemvStridedBatched(h, trans, m, n, alpha, &
      A, lda, strideA, X, incx, strideX, beta, Y, incy, strideY, batchCount)
  type(cublasHandle) :: h
  integer :: trans ! integer or character(1) variable
  integer :: m, n
  real(4), device :: alpha ! device or host variable
  real(4), device :: A(lda,*)
  integer :: lda
  integer(8) :: strideA
  real(4), device :: X(*)
  integer :: incx
  integer(8) :: strideX
  real(4), device :: beta ! device or host variable
  real(4), device :: Y(*)
  integer :: incy
  integer(8) :: strideY
  integer :: batchCount

integer(4) function cublasSgemvStridedBatched_v2(h, trans, m, n, alpha, &
      A, lda, strideA, X, incx, strideX, beta, Y, incy, strideY, batchCount)
  type(cublasHandle) :: h
  integer :: trans
  integer :: m, n
  real(4), device :: alpha ! device or host variable
  real(4), device :: A(lda,*)
  integer :: lda
  integer(8) :: strideA
  real(4), device :: X(*)
  integer :: incx
  integer(8) :: strideX
  real(4), device :: beta ! device or host variable
  real(4), device :: Y(*)
  integer :: incy
  integer(8) :: strideY
  integer :: batchCount

2.2.47. cublasSgemmStridedBatched

SGEMM 执行矩阵-矩阵运算 C := alpha*op( A )*op( B ) + beta*C 之一，其中 op( X ) 是 op( X ) = X 或 op( X ) = X**T 之一，alpha 和 beta 是标量，A、B 和 C 是矩阵，其中 op( A ) 是 m x k 矩阵，op( B ) 是 k x n 矩阵，C 是 m x n 矩阵。

integer(4) function cublasSgemmStridedBatched(h, transa, transb, m, n, k, alpha, Aarray, lda, strideA, Barray, ldb, strideB, beta, Carray, ldc, strideC, batchCount)
  type(cublasHandle) :: h
  integer :: transa ! integer or character(1) variable
  integer :: transb ! integer or character(1) variable
  integer :: m, n, k
  real(4), device :: alpha ! device or host variable
  real(4), device :: Aarray(*)
  integer :: lda
  integer :: strideA
  real(4), device :: Barray(*)
  integer :: ldb
  integer :: strideB
  real(4), device :: beta ! device or host variable
  real(4), device :: Carray(*)
  integer :: ldc
  integer :: strideC
  integer :: batchCount

integer(4) function cublasSgemmStridedBatched_v2(h, transa, transb, m, n, k, alpha, &
           Aarray, lda, strideA, Barray, ldb, strideB, beta, Carray, ldc, strideC, batchCount)
  type(cublasHandle) :: h
  integer :: transa
  integer :: transb
  integer :: m, n, k
  real(4), device :: alpha ! device or host variable
  real(4), device :: Aarray(*)
  integer :: lda
  integer :: strideA
  real(4), device :: Barray(*)
  integer :: ldb
  integer :: strideB
  real(4), device :: beta ! device or host variable
  real(4), device :: Carray(*)
  integer :: ldc
  integer :: strideC
  integer :: batchCount

2.3. 双精度函数和子例程

本节包含双精度 BLAS 和 cuBLAS 函数和子例程的接口。

2.3.1. idamax

IDAMAX 查找具有最大绝对值的元素的索引。

integer(4) function idamax(n, x, incx)
  integer :: n
  real(8), device, dimension(*) :: x ! device or host variable
  integer :: incx

integer(4) function cublasIdamax(n, x, incx)
  integer :: n
  real(8), device, dimension(*) :: x
  integer :: incx

integer(4) function cublasIdamax_v2(h, n, x, incx, res)
  type(cublasHandle) :: h
  integer :: n
  real(8), device, dimension(*) :: x
  integer :: incx
  integer, device :: res ! device or host variable

2.3.2. idamin

IDAMIN 查找具有最小绝对值的元素的索引。

integer(4) function idamin(n, x, incx)
  integer :: n
  real(8), device, dimension(*) :: x ! device or host variable
  integer :: incx

integer(4) function cublasIdamin(n, x, incx)
  integer :: n
  real(8), device, dimension(*) :: x
  integer :: incx

integer(4) function cublasIdamin_v2(h, n, x, incx, res)
  type(cublasHandle) :: h
  integer :: n
  real(8), device, dimension(*) :: x
  integer :: incx
  integer, device :: res ! device or host variable

2.3.3. dasum

DASUM 计算绝对值之和。

real(8) function dasum(n, x, incx)
  integer :: n
  real(8), device, dimension(*) :: x ! device or host variable
  integer :: incx

real(8) function cublasDasum(n, x, incx)
  integer :: n
  real(8), device, dimension(*) :: x
  integer :: incx

integer(4) function cublasDasum_v2(h, n, x, incx, res)
  type(cublasHandle) :: h
  integer :: n
  real(8), device, dimension(*) :: x
  integer :: incx
  real(8), device :: res ! device or host variable

2.3.4. daxpy

DAXPY 常数乘以向量加上向量。

subroutine daxpy(n, a, x, incx, y, incy)
  integer :: n
  real(8), device :: a ! device or host variable
  real(8), device, dimension(*) :: x, y ! device or host variable
  integer :: incx, incy

subroutine cublasDaxpy(n, a, x, incx, y, incy)
  integer :: n
  real(8), device :: a ! device or host variable
  real(8), device, dimension(*) :: x, y
  integer :: incx, incy

integer(4) function cublasDaxpy_v2(h, n, a, x, incx, y, incy)
  type(cublasHandle) :: h
  integer :: n
  real(8), device :: a ! device or host variable
  real(8), device, dimension(*) :: x, y
  integer :: incx, incy

2.3.5. dcopy

DCOPY 将向量 x 复制到向量 y。

subroutine dcopy(n, x, incx, y, incy)
  integer :: n
  real(8), device, dimension(*) :: x, y ! device or host variable
  integer :: incx, incy

subroutine cublasDcopy(n, x, incx, y, incy)
  integer :: n
  real(8), device, dimension(*) :: x, y
  integer :: incx, incy

integer(4) function cublasDcopy_v2(h, n, x, incx, y, incy)
  type(cublasHandle) :: h
  integer :: n
  real(8), device, dimension(*) :: x, y
  integer :: incx, incy

2.3.6. ddot

DDOT 形成两个向量的点积。

real(8) function ddot(n, x, incx, y, incy)
  integer :: n
  real(8), device, dimension(*) :: x, y ! device or host variable
  integer :: incx, incy

real(8) function cublasDdot(n, x, incx, y, incy)
  integer :: n
  real(8), device, dimension(*) :: x, y
  integer :: incx, incy

integer(4) function cublasDdot_v2(h, n, x, incx, y, incy, res)
  type(cublasHandle) :: h
  integer :: n
  real(8), device, dimension(*) :: x, y
  integer :: incx, incy
  real(8), device :: res ! device or host variable

2.3.7. dnrm2

DNRM2 通过函数名称返回向量的欧几里得范数，因此 DNRM2 := sqrt( x’*x )

real(8) function dnrm2(n, x, incx)
  integer :: n
  real(8), device, dimension(*) :: x ! device or host variable
  integer :: incx

real(8) function cublasDnrm2(n, x, incx)
  integer :: n
  real(8), device, dimension(*) :: x
  integer :: incx

integer(4) function cublasDnrm2_v2(h, n, x, incx, res)
  type(cublasHandle) :: h
  integer :: n
  real(8), device, dimension(*) :: x
  integer :: incx
  real(8), device :: res ! device or host variable

2.3.8. drot

DROT 应用平面旋转。

subroutine drot(n, x, incx, y, incy, sc, ss)
  integer :: n
  real(8), device :: sc, ss ! device or host variable
  real(8), device, dimension(*) :: x, y ! device or host variable
  integer :: incx, incy

subroutine cublasDrot(n, x, incx, y, incy, sc, ss)
  integer :: n
  real(8), device :: sc, ss ! device or host variable
  real(8), device, dimension(*) :: x, y
  integer :: incx, incy

integer(4) function cublasDrot_v2(h, n, x, incx, y, incy, sc, ss)
  type(cublasHandle) :: h
  integer :: n
  real(8), device :: sc, ss ! device or host variable
  real(8), device, dimension(*) :: x, y
  integer :: incx, incy

2.3.9. drotg

DROTG 构造 Givens 平面旋转。

subroutine drotg(sa, sb, sc, ss)
  real(8), device :: sa, sb, sc, ss ! device or host variable

subroutine cublasDrotg(sa, sb, sc, ss)
  real(8), device :: sa, sb, sc, ss ! device or host variable

integer(4) function cublasDrotg_v2(h, sa, sb, sc, ss)
  type(cublasHandle) :: h
  real(8), device :: sa, sb, sc, ss ! device or host variable

2.3.10. drotm

DROTM 将修改后的 Givens 变换 H 应用于 2 x N 矩阵 (DX**T) ，其中 **T 表示转置。DX 的元素在 (DX**T) DX(LX+I*INCX) 中，I = 0 到 N-1，其中如果 INCX .GE. 0，则 LX = 1，否则 LX = (-INCX)*N，DY 使用 LY 和 INCY 的情况类似。对于 DPARAM(1)=DFLAG，H 具有以下形式之一。DFLAG=-1.D0 DFLAG=0.D0 DFLAG=1.D0 DFLAG=-2.D0 (DH11 DH12) (1.D0 DH12) (DH11 1.D0) (1.D0 0.D0) H=( ) ( ) ( ) ( ) (DH21 DH22), (DH21 1.D0), (-1.D0 DH22), (0.D0 1.D0)。有关 DPARAM 中数据存储的描述，请参阅 DROTMG。

subroutine drotm(n, x, incx, y, incy, param)
  integer :: n
  real(8), device, dimension(*) :: x, y ! device or host variable
  integer :: incx, incy

subroutine cublasDrotm(n, x, incx, y, incy, param)
  integer :: n
  real(8), device, dimension(*) :: x, y
  integer :: incx, incy
  real(8), device :: param(*) ! device or host variable

integer(4) function cublasDrotm_v2(h, n, x, incx, y, incy, param)
  type(cublasHandle) :: h
  integer :: n
  real(8), device :: param(*) ! device or host variable
  real(8), device, dimension(*) :: x, y
  integer :: incx, incy

2.3.11. drotmg

DROTMG 构造修改后的 Givens 变换矩阵 H，该矩阵将 2 向量 (SQRT(DD1)*DX1,SQRT(DD2)*DY2)**T 的第二个分量置零。对于 DPARAM(1)=DFLAG，H 具有以下形式之一。DFLAG=-1.D0 DFLAG=0.D0 DFLAG=1.D0 DFLAG=-2.D0 (DH11 DH12) (1.D0 DH12) (DH11 1.D0) (1.D0 0.D0) H=( ) ( ) ( ) ( ) (DH21 DH22), (DH21 1.D0), (-1.D0 DH22), (0.D0 1.D0)。DPARAM 的位置 2-4 分别包含 DH11、DH21、DH12 和 DH22。（DPARAM(1) 的值隐含的 1.D0、-1.D0、0.D0 值不存储在 DPARAM 中。）

subroutine drotmg(d1, d2, x1, y1, param)
  real(8), device :: d1, d2, x1, y1, param(*) ! device or host variable

subroutine cublasDrotmg(d1, d2, x1, y1, param)
  real(8), device :: d1, d2, x1, y1, param(*) ! device or host variable

integer(4) function cublasDrotmg_v2(h, d1, d2, x1, y1, param)
  type(cublasHandle) :: h
  real(8), device :: d1, d2, x1, y1, param(*) ! device or host variable

2.3.12. dscal

DSCAL 用常数缩放向量。

subroutine dscal(n, a, x, incx)
  integer :: n
  real(8), device :: a ! device or host variable
  real(8), device, dimension(*) :: x ! device or host variable
  integer :: incx

subroutine cublasDscal(n, a, x, incx)
  integer :: n
  real(8), device :: a ! device or host variable
  real(8), device, dimension(*) :: x
  integer :: incx

integer(4) function cublasDscal_v2(h, n, a, x, incx)
  type(cublasHandle) :: h
  integer :: n
  real(8), device :: a ! device or host variable
  real(8), device, dimension(*) :: x
  integer :: incx

2.3.13. dswap

交换两个向量。

subroutine dswap(n, x, incx, y, incy)
  integer :: n
  real(8), device, dimension(*) :: x, y ! device or host variable
  integer :: incx, incy

subroutine cublasDswap(n, x, incx, y, incy)
  integer :: n
  real(8), device, dimension(*) :: x, y
  integer :: incx, incy

integer(4) function cublasDswap_v2(h, n, x, incx, y, incy)
  type(cublasHandle) :: h
  integer :: n
  real(8), device, dimension(*) :: x, y
  integer :: incx, incy

2.3.14. dgbmv

DGBMV 执行矩阵-向量运算 y := alpha*A*x + beta*y 或 y := alpha*A**T*x + beta*y 之一，其中 alpha 和 beta 是标量，x 和 y 是向量，A 是具有 kl 条子对角线和 ku 条超对角线的 m x n 带状矩阵。

subroutine dgbmv(t, m, n, kl, ku, alpha, a, lda, x, incx, beta, y, incy)
  character*1 :: t
  integer :: m, n, kl, ku, lda, incx, incy
  real(8), device, dimension(lda, *) :: a ! device or host variable
  real(8), device, dimension(*) :: x, y ! device or host variable
  real(8), device :: alpha, beta ! device or host variable

subroutine cublasDgbmv(t, m, n, kl, ku, alpha, a, lda, x, incx, beta, y, incy)
  character*1 :: t
  integer :: m, n, kl, ku, lda, incx, incy
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(*) :: x, y
  real(8), device :: alpha, beta ! device or host variable

integer(4) function cublasDgbmv_v2(h, t, m, n, kl, ku, alpha, a, lda, x, incx, beta, y, incy)
  type(cublasHandle) :: h
  integer :: t
  integer :: m, n, kl, ku, lda, incx, incy
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(*) :: x, y
  real(8), device :: alpha, beta ! device or host variable

2.3.15. dgemv

DGEMV 执行矩阵-向量运算 y := alpha*A*x + beta*y 或 y := alpha*A**T*x + beta*y 之一，其中 alpha 和 beta 是标量，x 和 y 是向量，A 是 m x n 矩阵。

subroutine dgemv(t, m, n, alpha, a, lda, x, incx, beta, y, incy)
  character*1 :: t
  integer :: m, n, lda, incx, incy
  real(8), device, dimension(lda, *) :: a ! device or host variable
  real(8), device, dimension(*) :: x, y ! device or host variable
  real(8), device :: alpha, beta ! device or host variable

subroutine cublasDgemv(t, m, n, alpha, a, lda, x, incx, beta, y, incy)
  character*1 :: t
  integer :: m, n, lda, incx, incy
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(*) :: x, y
  real(8), device :: alpha, beta ! device or host variable

integer(4) function cublasDgemv_v2(h, t, m, n, alpha, a, lda, x, incx, beta, y, incy)
  type(cublasHandle) :: h
  integer :: t
  integer :: m, n, lda, incx, incy
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(*) :: x, y
  real(8), device :: alpha, beta ! device or host variable

2.3.16. dger

DGER 执行秩 1 运算 A := alpha*x*y**T + A，其中 alpha 是标量，x 是 m 元素向量，y 是 n 元素向量，A 是 m x n 矩阵。

subroutine dger(m, n, alpha, x, incx, y, incy, a, lda)
  integer :: m, n, lda, incx, incy
  real(8), device, dimension(lda, *) :: a ! device or host variable
  real(8), device, dimension(*) :: x, y ! device or host variable
  real(8), device :: alpha ! device or host variable

subroutine cublasDger(m, n, alpha, x, incx, y, incy, a, lda)
  integer :: m, n, lda, incx, incy
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(*) :: x, y
  real(8), device :: alpha ! device or host variable

integer(4) function cublasDger_v2(h, m, n, alpha, x, incx, y, incy, a, lda)
  type(cublasHandle) :: h
  integer :: m, n, lda, incx, incy
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(*) :: x, y
  real(8), device :: alpha ! device or host variable

2.3.17. dsbmv

DSBMV 执行矩阵-向量运算 y := alpha*A*x + beta*y，其中 alpha 和 beta 是标量，x 和 y 是 n 元素向量，A 是具有 k 条超对角线的 n x n 对称带状矩阵。

subroutine dsbmv(t, n, k, alpha, a, lda, x, incx, beta, y, incy)
  character*1 :: t
  integer :: k, n, lda, incx, incy
  real(8), device, dimension(lda, *) :: a ! device or host variable
  real(8), device, dimension(*) :: x, y ! device or host variable
  real(8), device :: alpha, beta ! device or host variable

subroutine cublasDsbmv(t, n, k, alpha, a, lda, x, incx, beta, y, incy)
  character*1 :: t
  integer :: k, n, lda, incx, incy
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(*) :: x, y
  real(8), device :: alpha, beta ! device or host variable

integer(4) function cublasDsbmv_v2(h, t, n, k, alpha, a, lda, x, incx, beta, y, incy)
  type(cublasHandle) :: h
  integer :: t
  integer :: k, n, lda, incx, incy
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(*) :: x, y
  real(8), device :: alpha, beta ! device or host variable

2.3.18. dspmv

DSPMV 执行矩阵-向量运算 y := alpha*A*x + beta*y，其中 alpha 和 beta 是标量，x 和 y 是 n 元素向量，A 是以压缩形式提供的 n x n 对称矩阵。

subroutine dspmv(t, n, alpha, a, x, incx, beta, y, incy)
  character*1 :: t
  integer :: n, incx, incy
  real(8), device, dimension(*) :: a, x, y ! device or host variable
  real(8), device :: alpha, beta ! device or host variable

subroutine cublasDspmv(t, n, alpha, a, x, incx, beta, y, incy)
  character*1 :: t
  integer :: n, incx, incy
  real(8), device, dimension(*) :: a, x, y
  real(8), device :: alpha, beta ! device or host variable

integer(4) function cublasDspmv_v2(h, t, n, alpha, a, x, incx, beta, y, incy)
  type(cublasHandle) :: h
  integer :: t
  integer :: n, incx, incy
  real(8), device, dimension(*) :: a, x, y
  real(8), device :: alpha, beta ! device or host variable

2.3.19. dspr

DSPR 执行对称秩 1 运算 A := alpha*x*x**T + A，其中 alpha 是实标量，x 是 n 元素向量，A 是以压缩形式提供的 n x n 对称矩阵。

subroutine dspr(t, n, alpha, x, incx, a)
  character*1 :: t
  integer :: n, incx
  real(8), device, dimension(*) :: a, x ! device or host variable
  real(8), device :: alpha ! device or host variable

subroutine cublasDspr(t, n, alpha, x, incx, a)
  character*1 :: t
  integer :: n, incx
  real(8), device, dimension(*) :: a, x
  real(8), device :: alpha ! device or host variable

integer(4) function cublasDspr_v2(h, t, n, alpha, x, incx, a)
  type(cublasHandle) :: h
  integer :: t
  integer :: n, incx
  real(8), device, dimension(*) :: a, x
  real(8), device :: alpha ! device or host variable

2.3.20. dspr2

DSPR2 执行对称秩 2 运算 A := alpha*x*y**T + alpha*y*x**T + A，其中 alpha 是标量，x 和 y 是 n 元素向量，A 是以压缩形式提供的 n x n 对称矩阵。

subroutine dspr2(t, n, alpha, x, incx, y, incy, a)
  character*1 :: t
  integer :: n, incx, incy
  real(8), device, dimension(*) :: a, x, y ! device or host variable
  real(8), device :: alpha ! device or host variable

subroutine cublasDspr2(t, n, alpha, x, incx, y, incy, a)
  character*1 :: t
  integer :: n, incx, incy
  real(8), device, dimension(*) :: a, x, y
  real(8), device :: alpha ! device or host variable

integer(4) function cublasDspr2_v2(h, t, n, alpha, x, incx, y, incy, a)
  type(cublasHandle) :: h
  integer :: t
  integer :: n, incx, incy
  real(8), device, dimension(*) :: a, x, y
  real(8), device :: alpha ! device or host variable

2.3.21. dsymv

DSYMV 执行矩阵-向量运算 y := alpha*A*x + beta*y，其中 alpha 和 beta 是标量，x 和 y 是 n 元素向量，A 是 n x n 对称矩阵。

subroutine dsymv(uplo, n, alpha, a, lda, x, incx, beta, y, incy)
  character*1 :: uplo
  integer :: n, lda, incx, incy
  real(8), device, dimension(lda, *) :: a ! device or host variable
  real(8), device, dimension(*) :: x, y ! device or host variable
  real(8), device :: alpha, beta ! device or host variable

subroutine cublasDsymv(uplo, n, alpha, a, lda, x, incx, beta, y, incy)
  character*1 :: uplo
  integer :: n, lda, incx, incy
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(*) :: x, y
  real(8), device :: alpha, beta ! device or host variable

integer(4) function cublasDsymv_v2(h, uplo, n, alpha, a, lda, x, incx, beta, y, incy)
  type(cublasHandle) :: h
  integer :: uplo
  integer :: n, lda, incx, incy
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(*) :: x, y
  real(8), device :: alpha, beta ! device or host variable

2.3.22. dsyr

DSYR 执行对称秩 1 运算 A := alpha*x*x**T + A，其中 alpha 是实标量，x 是 n 元素向量，A 是 n x n 对称矩阵。

subroutine dsyr(t, n, alpha, x, incx, a, lda)
  character*1 :: t
  integer :: n, incx, lda
  real(8), device, dimension(lda, *) :: a ! device or host variable
  real(8), device, dimension(*) :: x ! device or host variable
  real(8), device :: alpha ! device or host variable

subroutine cublasDsyr(t, n, alpha, x, incx, a, lda)
  character*1 :: t
  integer :: n, incx, lda
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(*) :: x
  real(8), device :: alpha ! device or host variable

integer(4) function cublasDsyr_v2(h, t, n, alpha, x, incx, a, lda)
  type(cublasHandle) :: h
  integer :: t
  integer :: n, incx, lda
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(*) :: x
  real(8), device :: alpha ! device or host variable

2.3.23. dsyr2

DSYR2 执行对称秩 2 运算 A := alpha*x*y**T + alpha*y*x**T + A，其中 alpha 是标量，x 和 y 是 n 元素向量，A 是 n x n 对称矩阵。

subroutine dsyr2(t, n, alpha, x, incx, y, incy, a, lda)
  character*1 :: t
  integer :: n, incx, incy, lda
  real(8), device, dimension(lda, *) :: a ! device or host variable
  real(8), device, dimension(*) :: x, y ! device or host variable
  real(8), device :: alpha ! device or host variable

subroutine cublasDsyr2(t, n, alpha, x, incx, y, incy, a, lda)
  character*1 :: t
  integer :: n, incx, incy, lda
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(*) :: x, y
  real(8), device :: alpha ! device or host variable

integer(4) function cublasDsyr2_v2(h, t, n, alpha, x, incx, y, incy, a, lda)
  type(cublasHandle) :: h
  integer :: t
  integer :: n, incx, incy, lda
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(*) :: x, y
  real(8), device :: alpha ! device or host variable

2.3.24. dtbmv

DTBMV 执行矩阵-向量运算 x := A*x 或 x := A**T*x 之一，其中 x 是 n 元素向量，A 是具有 ( k + 1 ) 条对角线的 n x n 单位或非单位上或下三角带状矩阵。

subroutine dtbmv(u, t, d, n, k, a, lda, x, incx)
  character*1 :: u, t, d
  integer :: n, k, incx, lda
  real(8), device, dimension(lda, *) :: a ! device or host variable
  real(8), device, dimension(*) :: x ! device or host variable

subroutine cublasDtbmv(u, t, d, n, k, a, lda, x, incx)
  character*1 :: u, t, d
  integer :: n, k, incx, lda
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(*) :: x

integer(4) function cublasDtbmv_v2(h, u, t, d, n, k, a, lda, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, k, incx, lda
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(*) :: x

2.3.25. dtbsv

DTBSV 求解方程组 A*x = b 或 A**T*x = b 之一，其中 b 和 x 是 n 元素向量，A 是具有 ( k + 1 ) 条对角线的 n x n 单位或非单位上或下三角带状矩阵。此例程中不包含奇异性或接近奇异性的测试。此类测试必须在此例程调用之前执行。

subroutine dtbsv(u, t, d, n, k, a, lda, x, incx)
  character*1 :: u, t, d
  integer :: n, k, incx, lda
  real(8), device, dimension(lda, *) :: a ! device or host variable
  real(8), device, dimension(*) :: x ! device or host variable

subroutine cublasDtbsv(u, t, d, n, k, a, lda, x, incx)
  character*1 :: u, t, d
  integer :: n, k, incx, lda
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(*) :: x

integer(4) function cublasDtbsv_v2(h, u, t, d, n, k, a, lda, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, k, incx, lda
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(*) :: x

2.3.26. dtpmv

DTPMV 执行矩阵-向量运算 x := A*x 或 x := A**T*x 之一，其中 x 是 n 元素向量，A 是以压缩形式提供的 n x n 单位或非单位上或下三角矩阵。

subroutine dtpmv(u, t, d, n, a, x, incx)
  character*1 :: u, t, d
  integer :: n, incx
  real(8), device, dimension(*) :: a, x ! device or host variable

subroutine cublasDtpmv(u, t, d, n, a, x, incx)
  character*1 :: u, t, d
  integer :: n, incx
  real(8), device, dimension(*) :: a, x

integer(4) function cublasDtpmv_v2(h, u, t, d, n, a, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, incx
  real(8), device, dimension(*) :: a, x

2.3.27. dtpsv

DTPSV 求解方程组 A*x = b 或 A**T*x = b 之一，其中 b 和 x 是 n 元素向量，A 是以压缩形式提供的 n x n 单位或非单位上或下三角矩阵。此例程中不包含奇异性或接近奇异性的测试。此类测试必须在此例程调用之前执行。

subroutine dtpsv(u, t, d, n, a, x, incx)
  character*1 :: u, t, d
  integer :: n, incx
  real(8), device, dimension(*) :: a, x ! device or host variable

subroutine cublasDtpsv(u, t, d, n, a, x, incx)
  character*1 :: u, t, d
  integer :: n, incx
  real(8), device, dimension(*) :: a, x

integer(4) function cublasDtpsv_v2(h, u, t, d, n, a, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, incx
  real(8), device, dimension(*) :: a, x

2.3.28. dtrmv

DTRMV 执行矩阵-向量运算 x := A*x 或 x := A**T*x 之一，其中 x 是 n 元素向量，A 是 n x n 单位或非单位上或下三角矩阵。

subroutine dtrmv(u, t, d, n, a, lda, x, incx)
  character*1 :: u, t, d
  integer :: n, incx, lda
  real(8), device, dimension(lda, *) :: a ! device or host variable
  real(8), device, dimension(*) :: x ! device or host variable

subroutine cublasDtrmv(u, t, d, n, a, lda, x, incx)
  character*1 :: u, t, d
  integer :: n, incx, lda
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(*) :: x

integer(4) function cublasDtrmv_v2(h, u, t, d, n, a, lda, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, incx, lda
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(*) :: x

2.3.29. dtrsv

DTRSV 求解方程组 A*x = b 或 A**T*x = b 之一，其中 b 和 x 是 n 元素向量，A 是 n x n 单位或非单位上或下三角矩阵。此例程中不包含奇异性或接近奇异性的测试。此类测试必须在此例程调用之前执行。

subroutine dtrsv(u, t, d, n, a, lda, x, incx)
  character*1 :: u, t, d
  integer :: n, incx, lda
  real(8), device, dimension(lda, *) :: a ! device or host variable
  real(8), device, dimension(*) :: x ! device or host variable

subroutine cublasDtrsv(u, t, d, n, a, lda, x, incx)
  character*1 :: u, t, d
  integer :: n, incx, lda
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(*) :: x

integer(4) function cublasDtrsv_v2(h, u, t, d, n, a, lda, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, incx, lda
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(*) :: x

2.3.30. dgemm

DGEMM 执行矩阵-矩阵运算 C := alpha*op( A )*op( B ) + beta*C 之一，其中 op( X ) 是 op( X ) = X 或 op( X ) = X**T 之一，alpha 和 beta 是标量，A、B 和 C 是矩阵，其中 op( A ) 是 m x k 矩阵，op( B ) 是 k x n 矩阵，C 是 m x n 矩阵。

subroutine dgemm(transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  character*1 :: transa, transb
  integer :: m, n, k, lda, ldb, ldc
  real(8), device, dimension(lda, *) :: a ! device or host variable
  real(8), device, dimension(ldb, *) :: b ! device or host variable
  real(8), device, dimension(ldc, *) :: c ! device or host variable
  real(8), device :: alpha, beta ! device or host variable

subroutine cublasDgemm(transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  character*1 :: transa, transb
  integer :: m, n, k, lda, ldb, ldc
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(ldb, *) :: b
  real(8), device, dimension(ldc, *) :: c
  real(8), device :: alpha, beta ! device or host variable

integer(4) function cublasDgemm_v2(h, transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: transa, transb
  integer :: m, n, k, lda, ldb, ldc
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(ldb, *) :: b
  real(8), device, dimension(ldc, *) :: c
  real(8), device :: alpha, beta ! device or host variable

2.3.31. dsymm

DSYMM 执行矩阵-矩阵运算 C := alpha*A*B + beta*C 或 C := alpha*B*A + beta*C 之一，其中 alpha 和 beta 是标量，A 是对称矩阵，B 和 C 是 m x n 矩阵。

subroutine dsymm(side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc)
  character*1 :: side, uplo
  integer :: m, n, lda, ldb, ldc
  real(8), device, dimension(lda, *) :: a ! device or host variable
  real(8), device, dimension(ldb, *) :: b ! device or host variable
  real(8), device, dimension(ldc, *) :: c ! device or host variable
  real(8), device :: alpha, beta ! device or host variable

subroutine cublasDsymm(side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc)
  character*1 :: side, uplo
  integer :: m, n, lda, ldb, ldc
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(ldb, *) :: b
  real(8), device, dimension(ldc, *) :: c
  real(8), device :: alpha, beta ! device or host variable

integer(4) function cublasDsymm_v2(h, side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: side, uplo
  integer :: m, n, lda, ldb, ldc
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(ldb, *) :: b
  real(8), device, dimension(ldc, *) :: c
  real(8), device :: alpha, beta ! device or host variable

2.3.32. dsyrk

DSYRK 执行对称秩 k 运算 C := alpha*A*A**T + beta*C 或 C := alpha*A**T*A + beta*C 之一，其中 alpha 和 beta 是标量，C 是 n x n 对称矩阵，A 在第一种情况下是 n x k 矩阵，在第二种情况下是 k x n 矩阵。

subroutine dsyrk(uplo, trans, n, k, alpha, a, lda, beta, c, ldc)
  character*1 :: uplo, trans
  integer :: n, k, lda, ldc
  real(8), device, dimension(lda, *) :: a ! device or host variable
  real(8), device, dimension(ldc, *) :: c ! device or host variable
  real(8), device :: alpha, beta ! device or host variable

subroutine cublasDsyrk(uplo, trans, n, k, alpha, a, lda, beta, c, ldc)
  character*1 :: uplo, trans
  integer :: n, k, lda, ldc
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(ldc, *) :: c
  real(8), device :: alpha, beta ! device or host variable

integer(4) function cublasDsyrk_v2(h, uplo, trans, n, k, alpha, a, lda, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: uplo, trans
  integer :: n, k, lda, ldc
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(ldc, *) :: c
  real(8), device :: alpha, beta ! device or host variable

2.3.33. dsyr2k

DSYR2K 执行对称秩 2k 运算 C := alpha*A*B**T + alpha*B*A**T + beta*C 或 C := alpha*A**T*B + alpha*B**T*A + beta*C 之一，其中 alpha 和 beta 是标量，C 是 n x n 对称矩阵，A 和 B 在第一种情况下是 n x k 矩阵，在第二种情况下是 k x n 矩阵。

subroutine dsyr2k(uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  character*1 :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  real(8), device, dimension(lda, *) :: a ! device or host variable
  real(8), device, dimension(ldb, *) :: b ! device or host variable
  real(8), device, dimension(ldc, *) :: c ! device or host variable
  real(8), device :: alpha, beta ! device or host variable

subroutine cublasDsyr2k(uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  character*1 :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(ldb, *) :: b
  real(8), device, dimension(ldc, *) :: c
  real(8), device :: alpha, beta ! device or host variable

integer(4) function cublasDsyr2k_v2(h, uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(ldb, *) :: b
  real(8), device, dimension(ldc, *) :: c
  real(8), device :: alpha, beta ! device or host variable

2.3.34. dsyrkx

DSYRKX 执行对称秩 k 更新 C := alpha*A*B**T + beta*C 的变体，其中 alpha 和 beta 是标量，C 是以三角下或上三角模式存储的 n x n 对称矩阵，A 和 B 是 n x k 矩阵。当 B 以某种方式使得结果保证对称时，可以使用此例程。有关更多详细信息，请参阅 CUBLAS 文档。

subroutine dsyrkx(uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  character*1 :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  real(8), device, dimension(lda, *) :: a ! device or host variable
  real(8), device, dimension(ldb, *) :: b ! device or host variable
  real(8), device, dimension(ldc, *) :: c ! device or host variable
  real(8), device :: alpha, beta ! device or host variable

subroutine cublasDsyrkx(uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  character*1 :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(ldb, *) :: b
  real(8), device, dimension(ldc, *) :: c
  real(8), device :: alpha, beta ! device or host variable

integer(4) function cublasDsyrkx_v2(h, uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(ldb, *) :: b
  real(8), device, dimension(ldc, *) :: c
  real(8), device :: alpha, beta ! device or host variable

2.3.35. dtrmm

DTRMM 执行矩阵-矩阵运算 B := alpha*op( A )*B 或 B := alpha*B*op( A ) 之一，其中 alpha 是标量，B 是 m x n 矩阵，A 是单位或非单位上或下三角矩阵，op( A ) 是 op( A ) = A 或 op( A ) = A**T 之一。

subroutine dtrmm(side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)
  character*1 :: side, uplo, transa, diag
  integer :: m, n, lda, ldb
  real(8), device, dimension(lda, *) :: a ! device or host variable
  real(8), device, dimension(ldb, *) :: b ! device or host variable
  real(8), device :: alpha ! device or host variable

subroutine cublasDtrmm(side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)
  character*1 :: side, uplo, transa, diag
  integer :: m, n, lda, ldb
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(ldb, *) :: b
  real(8), device :: alpha ! device or host variable

integer(4) function cublasDtrmm_v2(h, side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb, c, ldc)
  type(cublasHandle) :: h
  integer :: side, uplo, transa, diag
  integer :: m, n, lda, ldb, ldc
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(ldb, *) :: b
  real(8), device, dimension(ldc, *) :: c
  real(8), device :: alpha ! device or host variable

2.3.36. dtrsm

DTRSM 求解矩阵方程 op( A )*X = alpha*B 或 X*op( A ) = alpha*B 之一，其中 alpha 是标量，X 和 B 是 m x n 矩阵，A 是单位或非单位上或下三角矩阵，op( A ) 是 op( A ) = A 或 op( A ) = A**T 之一。矩阵 X 在 B 上被覆盖。

subroutine dtrsm(side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)
  character*1 :: side, uplo, transa, diag
  integer :: m, n, lda, ldb
  real(8), device, dimension(lda, *) :: a ! device or host variable
  real(8), device, dimension(ldb, *) :: b ! device or host variable
  real(8), device :: alpha ! device or host variable

subroutine cublasDtrsm(side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)
  character*1 :: side, uplo, transa, diag
  integer :: m, n, lda, ldb
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(ldb, *) :: b
  real(8), device :: alpha ! device or host variable

integer(4) function cublasDtrsm_v2(h, side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)
  type(cublasHandle) :: h
  integer :: side, uplo, transa, diag
  integer :: m, n, lda, ldb
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(ldb, *) :: b
  real(8), device :: alpha ! device or host variable

2.3.37. cublasDgemvBatched

DGEMV 执行批量矩阵-向量运算 Y := alpha*op( A ) * X + beta*Y，其中 op( A ) 是 op( A ) = A 或 op( A ) = A**T 之一，alpha 和 beta 是标量，A 是 m x n 矩阵，X 和 Y 是向量。

integer(4) function cublasDgemvBatched(h, trans, m, n, alpha, &
      Aarray, lda, xarray, incx, beta, yarray, incy, batchCount)
  type(cublasHandle) :: h
  integer :: trans ! integer or character(1) variable
  integer :: m, n
  real(8), device :: alpha ! device or host variable
  type(c_devptr), device :: Aarray(*)
  integer :: lda
  type(c_devptr), device :: xarray(*)
  integer :: incx
  real(8), device :: beta ! device or host variable
  type(c_devptr), device :: yarray(*)
  integer :: incy
  integer :: batchCount

integer(4) function cublasDgemvBatched_v2(h, trans, m, n, alpha, &
      Aarray, lda, xarray, incx, beta, yarray, incy, batchCount)
  type(cublasHandle) :: h
  integer :: trans
  integer :: m, n
  real(8), device :: alpha ! device or host variable
  type(c_devptr), device :: Aarray(*)
  integer :: lda
  type(c_devptr), device :: xarray(*)
  integer :: incx
  real(8), device :: beta ! device or host variable
  type(c_devptr), device :: yarray(*)
  integer :: incy
  integer :: batchCount

2.3.38. cublasDgemmBatched

DGEMM 执行矩阵-矩阵运算 C := alpha*op( A )*op( B ) + beta*C 之一，其中 op( X ) 是 op( X ) = X 或 op( X ) = X**T 之一，alpha 和 beta 是标量，A、B 和 C 是矩阵，其中 op( A ) 是 m x k 矩阵，op( B ) 是 k x n 矩阵，C 是 m x n 矩阵。

integer(4) function cublasDgemmBatched(h, transa, transb, m, n, k, alpha, Aarray, lda, Barray, ldb, beta, Carray, ldc, batchCount)
  type(cublasHandle) :: h
  integer :: transa ! integer or character(1) variable
  integer :: transb ! integer or character(1) variable
  integer :: m, n, k
  real(8), device :: alpha ! device or host variable
  type(c_devptr), device :: Aarray(*)
  integer :: lda
  type(c_devptr), device :: Barray(*)
  integer :: ldb
  real(8), device :: beta ! device or host variable
  type(c_devptr), device :: Carray(*)
  integer :: ldc
  integer :: batchCount

integer(4) function cublasDgemmBatched_v2(h, transa, transb, m, n, k, alpha, &
           Aarray, lda, Barray, ldb, beta, Carray, ldc, batchCount)
  type(cublasHandle) :: h
  integer :: transa
  integer :: transb
  integer :: m, n, k
  real(8), device :: alpha ! device or host variable
  type(c_devptr), device :: Aarray(*)
  integer :: lda
  type(c_devptr), device :: Barray(*)
  integer :: ldb
  real(8), device :: beta ! device or host variable
  type(c_devptr), device :: Carray(*)
  integer :: ldc
  integer :: batchCount

2.3.39. cublasDgelsBatched

DGELS 使用 A 的 QR 或 LQ 分解求解涉及 M×N 矩阵 A 或其转置的超定或欠定实线性系统。假设 A 具有满秩。提供以下选项：1. 如果 TRANS = ‘N’ 且 m >= n：找到超定系统的最小二乘解，即求解最小二乘问题 minimize || B - A*X ||。2. 如果 TRANS = ‘N’ 且 m < n：找到欠定系统 A * X = B 的最小范数解。3. 如果 TRANS = ‘T’ 且 m >= n：找到欠定系统 A**T * X = B 的最小范数解。4. 如果 TRANS = ‘T’ 且 m < n：找到超定系统的最小二乘解，即求解最小二乘问题 minimize || B - A**T * X ||。可以在单个调用中处理多个右手边向量 b 和解向量 x；它们存储为 M×NRHS 右手边矩阵 B 和 N×NRHS 解矩阵 X 的列。

integer(4) function cublasDgelsBatched(h, trans, m, n, nrhs, Aarray, lda, Carray, ldc, info, devinfo, batchCount)
  type(cublasHandle) :: h
  integer :: trans ! integer or character(1) variable
  integer :: m, n, nrhs
  type(c_devptr), device :: Aarray(*)
  integer :: lda
  type(c_devptr), device :: Carray(*)
  integer :: ldc
  integer :: info(*)
  integer, device :: devinfo(*)
  integer :: batchCount

2.3.40. cublasDgeqrfBatched

DGEQRF 计算实数 M×N 矩阵 A 的 QR 分解：A = Q * R。

integer(4) function cublasDgeqrfBatched(h, m, n, Aarray, lda, Tau, info, batchCount)
  type(cublasHandle) :: h
  integer :: m, n
  type(c_devptr), device :: Aarray(*)
  integer :: lda
  type(c_devptr), device :: Tau(*)
  integer :: info(*)
  integer :: batchCount

2.3.41. cublasDgetrfBatched

DGETRF 使用带行交换的部分主元法计算一般 M×N 矩阵 A 的 LU 分解。分解形式为 A = P * L * U，其中 P 是置换矩阵，L 是具有单位对角线元素的下三角矩阵（如果 m > n，则为下梯形），U 是上三角矩阵（如果 m < n，则为上梯形）。这是算法的右视 Level 3 BLAS 版本。

integer(4) function cublasDgetrfBatched(h, n, Aarray, lda, ipvt, info, batchCount)
  type(cublasHandle) :: h
  integer :: n
  type(c_devptr), device :: Aarray(*)
  integer :: lda
  integer, device :: ipvt(*)
  integer, device :: info(*)
  integer :: batchCount

2.3.42. cublasDgetriBatched

DGETRI 使用 DGETRF 计算的 LU 分解计算矩阵的逆。此方法反转 U，然后通过求解系统 inv(A)*L = inv(U) 来计算 inv(A)。

integer(4) function cublasDgetriBatched(h, n, Aarray, lda, ipvt, Carray, ldc, info, batchCount)
  type(cublasHandle) :: h
  integer :: n
  type(c_devptr), device :: Aarray(*)
  integer :: lda
  integer, device :: ipvt(*)
  type(c_devptr), device :: Carray(*)
  integer :: ldc
  integer, device :: info(*)
  integer :: batchCount

2.3.43. cublasDgetrsBatched

DGETRS 使用 DGETRF 计算的 LU 分解求解具有一般 N×N 矩阵 A 的线性方程组 A * X = B 或 A**T * X = B。

integer(4) function cublasDgetrsBatched(h, trans, n, nrhs, Aarray, lda, ipvt, Barray, ldb, info, batchCount)
  type(cublasHandle) :: h
  integer :: trans ! integer or character(1) variable
  integer :: n, nrhs
  type(c_devptr), device :: Aarray(*)
  integer :: lda
  integer, device :: ipvt(*)
  type(c_devptr), device :: Barray(*)
  integer :: ldb
  integer :: info(*)
  integer :: batchCount

2.3.44. cublasDmatinvBatched

cublasDmatinvBatched 是 cublasDgetrfBatched 加 cublasDgetriBatched 的快捷方式。但是，它仅在 n 小于 32 时有效。否则，用户必须通过 cublasDgetrfBatched 和 cublasDgetriBatched。

integer(4) function cublasDmatinvBatched(h, n, Aarray, lda, Ainv, lda_inv, info, batchCount)
  type(cublasHandle) :: h
  integer :: n
  type(c_devptr), device :: Aarray(*)
  integer :: lda
  type(c_devptr), device :: Ainv(*)
  integer :: lda_inv
  integer, device :: info(*)
  integer :: batchCount

2.3.45. cublasDtrsmBatched

DTRSM 求解矩阵方程 op( A )*X = alpha*B 或 X*op( A ) = alpha*B 之一，其中 alpha 是标量，X 和 B 是 m x n 矩阵，A 是单位或非单位上或下三角矩阵，op( A ) 是 op( A ) = A 或 op( A ) = A**T 之一。矩阵 X 在 B 上被覆盖。

integer(4) function cublasDtrsmBatched( h, side, uplo, trans, diag, m, n, alpha, A, lda, B, ldb, batchCount)
  type(cublasHandle) :: h
  integer :: side ! integer or character(1) variable
  integer :: uplo ! integer or character(1) variable
  integer :: trans ! integer or character(1) variable
  integer :: diag ! integer or character(1) variable
  integer :: m, n
  real(8), device :: alpha ! device or host variable
  type(c_devptr), device :: A(*)
  integer :: lda
  type(c_devptr), device :: B(*)
  integer :: ldb
  integer :: batchCount

integer(4) function cublasDtrsmBatched_v2( h, side, uplo, trans, diag, m, n, alpha, A, lda, B, ldb, batchCount)
  type(cublasHandle) :: h
  integer :: side
  integer :: uplo
  integer :: trans
  integer :: diag
  integer :: m, n
  real(8), device :: alpha ! device or host variable
  type(c_devptr), device :: A(*)
  integer :: lda
  type(c_devptr), device :: B(*)
  integer :: ldb
  integer :: batchCount

2.3.46. cublasDgemvStridedBatched

DGEMV 执行批量矩阵-向量运算 Y := alpha*op( A ) * X + beta*Y，其中 op( A ) 是 op( A ) = A 或 op( A ) = A**T 之一，alpha 和 beta 是标量，A 是 m x n 矩阵，X 和 Y 是向量。

integer(4) function cublasDgemvStridedBatched(h, trans, m, n, alpha, &
      A, lda, strideA, X, incx, strideX, beta, Y, incy, strideY, batchCount)
  type(cublasHandle) :: h
  integer :: trans ! integer or character(1) variable
  integer :: m, n
  real(8), device :: alpha ! device or host variable
  real(8), device :: A(lda,*)
  integer :: lda
  integer(8) :: strideA
  real(8), device :: X(*)
  integer :: incx
  integer(8) :: strideX
  real(8), device :: beta ! device or host variable
  real(8), device :: Y(*)
  integer :: incy
  integer(8) :: strideY
  integer :: batchCount

integer(4) function cublasDgemvStridedBatched_v2(h, trans, m, n, alpha, &
      A, lda, strideA, X, incx, strideX, beta, Y, incy, strideY, batchCount)
  type(cublasHandle) :: h
  integer :: trans
  integer :: m, n
  real(8), device :: alpha ! device or host variable
  real(8), device :: A(lda,*)
  integer :: lda
  integer(8) :: strideA
  real(8), device :: X(*)
  integer :: incx
  integer(8) :: strideX
  real(8), device :: beta ! device or host variable
  real(8), device :: Y(*)
  integer :: incy
  integer(8) :: strideY
  integer :: batchCount

2.3.47. cublasDgemmStridedBatched

DGEMM 执行矩阵-矩阵运算 C := alpha*op( A )*op( B ) + beta*C 之一，其中 op( X ) 是 op( X ) = X 或 op( X ) = X**T 之一，alpha 和 beta 是标量，A、B 和 C 是矩阵，其中 op( A ) 是 m x k 矩阵，op( B ) 是 k x n 矩阵，C 是 m x n 矩阵。

integer(4) function cublasDgemmStridedBatched(h, transa, transb, m, n, k, alpha, Aarray, lda, strideA, Barray, ldb, strideB, beta, Carray, ldc, strideC, batchCount)
  type(cublasHandle) :: h
  integer :: transa ! integer or character(1) variable
  integer :: transb ! integer or character(1) variable
  integer :: m, n, k
  real(8), device :: alpha ! device or host variable
  real(8), device :: Aarray(*)
  integer :: lda
  integer :: strideA
  real(8), device :: Barray(*)
  integer :: ldb
  integer :: strideB
  real(8), device :: beta ! device or host variable
  real(8), device :: Carray(*)
  integer :: ldc
  integer :: strideC
  integer :: batchCount

integer(4) function cublasDgemmStridedBatched_v2(h, transa, transb, m, n, k, alpha, &
           Aarray, lda, strideA, Barray, ldb, strideB, beta, Carray, ldc, strideC, batchCount)
  type(cublasHandle) :: h
  integer :: transa
  integer :: transb
  integer :: m, n, k
  real(8), device :: alpha ! device or host variable
  real(8), device :: Aarray(*)
  integer :: lda
  integer :: strideA
  real(8), device :: Barray(*)
  integer :: ldb
  integer :: strideB
  real(8), device :: beta ! device or host variable
  real(8), device :: Carray(*)
  integer :: ldc
  integer :: strideC
  integer :: batchCount

2.4. 单精度复数函数和子例程

本节包含单精度复数 BLAS 和 cuBLAS 函数和子例程的接口。

2.4.1. icamax

ICAMAX 查找具有最大绝对值的元素的索引。

integer(4) function icamax(n, x, incx)
  integer :: n
  complex(4), device, dimension(*) :: x ! device or host variable
  integer :: incx

integer(4) function cublasIcamax(n, x, incx)
  integer :: n
  complex(4), device, dimension(*) :: x
  integer :: incx

integer(4) function cublasIcamax_v2(h, n, x, incx, res)
  type(cublasHandle) :: h
  integer :: n
  complex(4), device, dimension(*) :: x
  integer :: incx
  integer, device :: res ! device or host variable

2.4.2. icamin

ICAMIN 查找具有最小绝对值的元素的索引。

integer(4) function icamin(n, x, incx)
  integer :: n
  complex(4), device, dimension(*) :: x ! device or host variable
  integer :: incx

integer(4) function cublasIcamin(n, x, incx)
  integer :: n
  complex(4), device, dimension(*) :: x
  integer :: incx

integer(4) function cublasIcamin_v2(h, n, x, incx, res)
  type(cublasHandle) :: h
  integer :: n
  complex(4), device, dimension(*) :: x
  integer :: incx
  integer, device :: res ! device or host variable

2.4.3. scasum

SCASUM 计算复数向量的绝对值之和，并返回单精度结果。

real(4) function scasum(n, x, incx)
  integer :: n
  complex(4), device, dimension(*) :: x ! device or host variable
  integer :: incx

real(4) function cublasScasum(n, x, incx)
  integer :: n
  complex(4), device, dimension(*) :: x
  integer :: incx

integer(4) function cublasScasum_v2(h, n, x, incx, res)
  type(cublasHandle) :: h
  integer :: n
  complex(4), device, dimension(*) :: x
  integer :: incx
  real(4), device :: res ! device or host variable

2.4.4. caxpy

CAXPY 常数乘以向量加上向量。

subroutine caxpy(n, a, x, incx, y, incy)
  integer :: n
  complex(4), device :: a ! device or host variable
  complex(4), device, dimension(*) :: x, y ! device or host variable
  integer :: incx, incy

subroutine cublasCaxpy(n, a, x, incx, y, incy)
  integer :: n
  complex(4), device :: a ! device or host variable
  complex(4), device, dimension(*) :: x, y
  integer :: incx, incy

integer(4) function cublasCaxpy_v2(h, n, a, x, incx, y, incy)
  type(cublasHandle) :: h
  integer :: n
  complex(4), device :: a ! device or host variable
  complex(4), device, dimension(*) :: x, y
  integer :: incx, incy

2.4.5. ccopy

CCOPY 将向量 x 复制到向量 y。

subroutine ccopy(n, x, incx, y, incy)
  integer :: n
  complex(4), device, dimension(*) :: x, y ! device or host variable
  integer :: incx, incy

subroutine cublasCcopy(n, x, incx, y, incy)
  integer :: n
  complex(4), device, dimension(*) :: x, y
  integer :: incx, incy

integer(4) function cublasCcopy_v2(h, n, x, incx, y, incy)
  type(cublasHandle) :: h
  integer :: n
  complex(4), device, dimension(*) :: x, y
  integer :: incx, incy

2.4.6. cdotc

形成两个向量的点积，共轭第一个向量。

complex(4) function cdotc(n, x, incx, y, incy)
  integer :: n
  complex(4), device, dimension(*) :: x, y ! device or host variable
  integer :: incx, incy

complex(4) function cublasCdotc(n, x, incx, y, incy)
  integer :: n
  complex(4), device, dimension(*) :: x, y
  integer :: incx, incy

integer(4) function cublasCdotc_v2(h, n, x, incx, y, incy, res)
  type(cublasHandle) :: h
  integer :: n
  complex(4), device, dimension(*) :: x, y
  integer :: incx, incy
  complex(4), device :: res ! device or host variable

2.4.7. cdotu

CDOTU 形成两个向量的点积。

complex(4) function cdotu(n, x, incx, y, incy)
  integer :: n
  complex(4), device, dimension(*) :: x, y ! device or host variable
  integer :: incx, incy

complex(4) function cublasCdotu(n, x, incx, y, incy)
  integer :: n
  complex(4), device, dimension(*) :: x, y
  integer :: incx, incy

integer(4) function cublasCdotu_v2(h, n, x, incx, y, incy, res)
  type(cublasHandle) :: h
  integer :: n
  complex(4), device, dimension(*) :: x, y
  integer :: incx, incy
  complex(4), device :: res ! device or host variable

2.4.8. scnrm2

SCNRM2 通过函数名称返回向量的欧几里得范数，因此 SCNRM2 := sqrt( x**H*x )

real(4) function scnrm2(n, x, incx)
  integer :: n
  complex(4), device, dimension(*) :: x ! device or host variable
  integer :: incx

real(4) function cublasScnrm2(n, x, incx)
  integer :: n
  complex(4), device, dimension(*) :: x
  integer :: incx

integer(4) function cublasScnrm2_v2(h, n, x, incx, res)
  type(cublasHandle) :: h
  integer :: n
  complex(4), device, dimension(*) :: x
  integer :: incx
  real(4), device :: res ! device or host variable

2.4.9. crot

CROT 应用平面旋转，其中余弦 (C) 为实数，正弦 (S) 为复数，向量 CX 和 CY 为复数。

subroutine crot(n, x, incx, y, incy, sc, ss)
  integer :: n
  real(4), device :: sc ! device or host variable
  complex(4), device :: ss ! device or host variable
  complex(4), device, dimension(*) :: x, y ! device or host variable
  integer :: incx, incy

subroutine cublasCrot(n, x, incx, y, incy, sc, ss)
  integer :: n
  real(4), device :: sc ! device or host variable
  complex(4), device :: ss ! device or host variable
  complex(4), device, dimension(*) :: x, y
  integer :: incx, incy

integer(4) function cublasCrot_v2(h, n, x, incx, y, incy, sc, ss)
  type(cublasHandle) :: h
  integer :: n
  real(4), device :: sc ! device or host variable
  complex(4), device :: ss ! device or host variable
  complex(4), device, dimension(*) :: x, y
  integer :: incx, incy

2.4.10. csrot

CSROT 应用平面旋转，其中余弦和正弦（c 和 s）为实数，向量 cx 和 cy 为复数。

subroutine csrot(n, x, incx, y, incy, sc, ss)
  integer :: n
  real(4), device :: sc, ss ! device or host variable
  complex(4), device, dimension(*) :: x, y ! device or host variable
  integer :: incx, incy

subroutine cublasCsrot(n, x, incx, y, incy, sc, ss)
  integer :: n
  real(4), device :: sc, ss ! device or host variable
  complex(4), device, dimension(*) :: x, y
  integer :: incx, incy

integer(4) function cublasCsrot_v2(h, n, x, incx, y, incy, sc, ss)
  type(cublasHandle) :: h
  integer :: n
  real(4), device :: sc, ss ! device or host variable
  complex(4), device, dimension(*) :: x, y
  integer :: incx, incy

2.4.11. crotg

CROTG 确定复数 Givens 旋转。

subroutine crotg(sa, sb, sc, ss)
  complex(4), device :: sa, sb, ss ! device or host variable
  real(4), device :: sc ! device or host variable

subroutine cublasCrotg(sa, sb, sc, ss)
  complex(4), device :: sa, sb, ss ! device or host variable
  real(4), device :: sc ! device or host variable

integer(4) function cublasCrotg_v2(h, sa, sb, sc, ss)
  type(cublasHandle) :: h
  complex(4), device :: sa, sb, ss ! device or host variable
  real(4), device :: sc ! device or host variable

2.4.12. cscal

CSCAL 用常数缩放向量。

subroutine cscal(n, a, x, incx)
  integer :: n
  complex(4), device :: a ! device or host variable
  complex(4), device, dimension(*) :: x ! device or host variable
  integer :: incx

subroutine cublasCscal(n, a, x, incx)
  integer :: n
  complex(4), device :: a ! device or host variable
  complex(4), device, dimension(*) :: x
  integer :: incx

integer(4) function cublasCscal_v2(h, n, a, x, incx)
  type(cublasHandle) :: h
  integer :: n
  complex(4), device :: a ! device or host variable
  complex(4), device, dimension(*) :: x
  integer :: incx

2.4.13. csscal

CSSCAL 用实数常数缩放复数向量。

subroutine csscal(n, a, x, incx)
  integer :: n
  real(4), device :: a ! device or host variable
  complex(4), device, dimension(*) :: x ! device or host variable
  integer :: incx

subroutine cublasCsscal(n, a, x, incx)
  integer :: n
  real(4), device :: a ! device or host variable
  complex(4), device, dimension(*) :: x
  integer :: incx

integer(4) function cublasCsscal_v2(h, n, a, x, incx)
  type(cublasHandle) :: h
  integer :: n
  real(4), device :: a ! device or host variable
  complex(4), device, dimension(*) :: x
  integer :: incx

2.4.14. cswap

CSWAP 交换两个向量。

subroutine cswap(n, x, incx, y, incy)
  integer :: n
  complex(4), device, dimension(*) :: x, y ! device or host variable
  integer :: incx, incy

subroutine cublasCswap(n, x, incx, y, incy)
  integer :: n
  complex(4), device, dimension(*) :: x, y
  integer :: incx, incy

integer(4) function cublasCswap_v2(h, n, x, incx, y, incy)
  type(cublasHandle) :: h
  integer :: n
  complex(4), device, dimension(*) :: x, y
  integer :: incx, incy

2.4.15. cgbmv

CGBMV 执行矩阵-向量运算 y := alpha*A*x + beta*y 或 y := alpha*A**T*x + beta*y 或 y := alpha*A**H*x + beta*y 之一，其中 alpha 和 beta 是标量，x 和 y 是向量，A 是具有 kl 条子对角线和 ku 条超对角线的 m x n 带状矩阵。

subroutine cgbmv(t, m, n, kl, ku, alpha, a, lda, x, incx, beta, y, incy)
  character*1 :: t
  integer :: m, n, kl, ku, lda, incx, incy
  complex(4), device, dimension(lda, *) :: a ! device or host variable
  complex(4), device, dimension(*) :: x, y ! device or host variable
  complex(4), device :: alpha, beta ! device or host variable

subroutine cublasCgbmv(t, m, n, kl, ku, alpha, a, lda, x, incx, beta, y, incy)
  character*1 :: t
  integer :: m, n, kl, ku, lda, incx, incy
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(*) :: x, y
  complex(4), device :: alpha, beta ! device or host variable

integer(4) function cublasCgbmv_v2(h, t, m, n, kl, ku, alpha, a, lda, x, incx, beta, y, incy)
  type(cublasHandle) :: h
  integer :: t
  integer :: m, n, kl, ku, lda, incx, incy
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(*) :: x, y
  complex(4), device :: alpha, beta ! device or host variable

2.4.16. cgemv

CGEMV 执行矩阵-向量运算 y := alpha*A*x + beta*y 或 y := alpha*A**T*x + beta*y 或 y := alpha*A**H*x + beta*y 之一，其中 alpha 和 beta 是标量，x 和 y 是向量，A 是 m x n 矩阵。

subroutine cgemv(t, m, n, alpha, a, lda, x, incx, beta, y, incy)
  character*1 :: t
  integer :: m, n, lda, incx, incy
  complex(4), device, dimension(lda, *) :: a ! device or host variable
  complex(4), device, dimension(*) :: x, y ! device or host variable
  complex(4), device :: alpha, beta ! device or host variable

subroutine cublasCgemv(t, m, n, alpha, a, lda, x, incx, beta, y, incy)
  character*1 :: t
  integer :: m, n, lda, incx, incy
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(*) :: x, y
  complex(4), device :: alpha, beta ! device or host variable

integer(4) function cublasCgemv_v2(h, t, m, n, alpha, a, lda, x, incx, beta, y, incy)
  type(cublasHandle) :: h
  integer :: t
  integer :: m, n, lda, incx, incy
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(*) :: x, y
  complex(4), device :: alpha, beta ! device or host variable

2.4.17. cgerc

CGERC 执行秩 1 运算 A := alpha*x*y**H + A，其中 alpha 是标量，x 是 m 元素向量，y 是 n 元素向量，A 是 m x n 矩阵。

subroutine cgerc(m, n, alpha, x, incx, y, incy, a, lda)
  integer :: m, n, lda, incx, incy
  complex(4), device, dimension(lda, *) :: a ! device or host variable
  complex(4), device, dimension(*) :: x, y ! device or host variable
  complex(4), device :: alpha ! device or host variable

subroutine cublasCgerc(m, n, alpha, x, incx, y, incy, a, lda)
  integer :: m, n, lda, incx, incy
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(*) :: x, y
  complex(4), device :: alpha ! device or host variable

integer(4) function cublasCgerc_v2(h, m, n, alpha, x, incx, y, incy, a, lda)
  type(cublasHandle) :: h
  integer :: m, n, lda, incx, incy
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(*) :: x, y
  complex(4), device :: alpha ! device or host variable

2.4.18. cgeru

CGERU 执行秩 1 运算 A := alpha*x*y**T + A，其中 alpha 是标量，x 是 m 元素向量，y 是 n 元素向量，A 是 m x n 矩阵。

subroutine cgeru(m, n, alpha, x, incx, y, incy, a, lda)
  integer :: m, n, lda, incx, incy
  complex(4), device, dimension(lda, *) :: a ! device or host variable
  complex(4), device, dimension(*) :: x, y ! device or host variable
  complex(4), device :: alpha ! device or host variable

subroutine cublasCgeru(m, n, alpha, x, incx, y, incy, a, lda)
  integer :: m, n, lda, incx, incy
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(*) :: x, y
  complex(4), device :: alpha ! device or host variable

integer(4) function cublasCgeru_v2(h, m, n, alpha, x, incx, y, incy, a, lda)
  type(cublasHandle) :: h
  integer :: m, n, lda, incx, incy
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(*) :: x, y
  complex(4), device :: alpha ! device or host variable

2.4.19. csymv

CSYMV 执行矩阵-向量运算 y := alpha*A*x + beta*y，其中 alpha 和 beta 是标量，x 和 y 是 n 元素向量，A 是 n x n 对称矩阵。

subroutine csymv(uplo, n, alpha, a, lda, x, incx, beta, y, incy)
  character*1 :: uplo
  integer :: n, lda, incx, incy
  complex(4), device, dimension(lda, *) :: a ! device or host variable
  complex(4), device, dimension(*) :: x, y ! device or host variable
  complex(4), device :: alpha, beta ! device or host variable

subroutine cublasCsymv(uplo, n, alpha, a, lda, x, incx, beta, y, incy)
  character*1 :: uplo
  integer :: n, lda, incx, incy
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(*) :: x, y
  complex(4), device :: alpha, beta ! device or host variable

integer(4) function cublasCsymv_v2(h, uplo, n, alpha, a, lda, x, incx, beta, y, incy)
  type(cublasHandle) :: h
  integer :: uplo
  integer :: n, lda, incx, incy
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(*) :: x, y
  complex(4), device :: alpha, beta ! device or host variable

2.4.20. csyr

CSYR 执行对称秩 1 运算 A := alpha*x*x**H + A，其中 alpha 是复数标量，x 是 n 元素向量，A 是 n x n 对称矩阵。

subroutine csyr(t, n, alpha, x, incx, a, lda)
  character*1 :: t
  integer :: n, incx, lda
  complex(4), device, dimension(lda, *) :: a ! device or host variable
  complex(4), device, dimension(*) :: x ! device or host variable
  complex(4), device :: alpha ! device or host variable

subroutine cublasCsyr(t, n, alpha, x, incx, a, lda)
  character*1 :: t
  integer :: n, incx, lda
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(*) :: x
  complex(4), device :: alpha ! device or host variable

integer(4) function cublasCsyr_v2(h, t, n, alpha, x, incx, a, lda)
  type(cublasHandle) :: h
  integer :: t
  integer :: n, incx, lda
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(*) :: x
  complex(4), device :: alpha ! device or host variable

2.4.21. csyr2

CSYR2 执行对称秩 2 运算 A := alpha*x*y’ + alpha*y*x’ + A，其中 alpha 是复数标量，x 和 y 是 n 元素向量，A 是 n x n SY 矩阵。

subroutine csyr2(t, n, alpha, x, incx, y, incy, a, lda)
  character*1 :: t
  integer :: n, incx, incy, lda
  complex(4), device, dimension(lda, *) :: a ! device or host variable
  complex(4), device, dimension(*) :: x, y ! device or host variable
  complex(4), device :: alpha ! device or host variable

subroutine cublasCsyr2(t, n, alpha, x, incx, y, incy, a, lda)
  character*1 :: t
  integer :: n, incx, incy, lda
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(*) :: x, y
  complex(4), device :: alpha ! device or host variable

integer(4) function cublasCsyr2_v2(h, t, n, alpha, x, incx, y, incy, a, lda)
  type(cublasHandle) :: h
  integer :: t
  integer :: n, incx, incy, lda
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(*) :: x, y
  complex(4), device :: alpha ! device or host variable

2.4.22. ctbmv

CTBMV 执行矩阵-向量运算 x := A*x, 或 x := A**T*x, 或 x := A**H*x 之一，其中 x 是一个 n 元素向量，A 是一个 n 乘 n 单位或非单位上或下三角带状矩阵，具有 ( k + 1 ) 条对角线。

subroutine ctbmv(u, t, d, n, k, a, lda, x, incx)
  character*1 :: u, t, d
  integer :: n, k, incx, lda
  complex(4), device, dimension(lda, *) :: a ! device or host variable
  complex(4), device, dimension(*) :: x ! device or host variable

subroutine cublasCtbmv(u, t, d, n, k, a, lda, x, incx)
  character*1 :: u, t, d
  integer :: n, k, incx, lda
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(*) :: x

integer(4) function cublasCtbmv_v2(h, u, t, d, n, k, a, lda, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, k, incx, lda
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(*) :: x

2.4.23. ctbsv

CTBSV 求解线性方程组 A*x = b, 或 A**T*x = b, 或 A**H*x = b 之一，其中 b 和 x 是 n 元素向量，A 是一个 n 乘 n 单位或非单位上或下三角带状矩阵，具有 ( k + 1 ) 条对角线。此例程中不包含奇异性或近奇异性测试。此类测试必须在调用此例程之前执行。

subroutine ctbsv(u, t, d, n, k, a, lda, x, incx)
  character*1 :: u, t, d
  integer :: n, k, incx, lda
  complex(4), device, dimension(lda, *) :: a ! device or host variable
  complex(4), device, dimension(*) :: x ! device or host variable

subroutine cublasCtbsv(u, t, d, n, k, a, lda, x, incx)
  character*1 :: u, t, d
  integer :: n, k, incx, lda
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(*) :: x

integer(4) function cublasCtbsv_v2(h, u, t, d, n, k, a, lda, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, k, incx, lda
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(*) :: x

2.4.24. ctpmv

CTPMV 执行矩阵-向量运算 x := A*x, 或 x := A**T*x, 或 x := A**H*x 之一，其中 x 是一个 n 元素向量，A 是一个 n 乘 n 单位或非单位上或下三角矩阵，以压缩形式提供。

subroutine ctpmv(u, t, d, n, a, x, incx)
  character*1 :: u, t, d
  integer :: n, incx
  complex(4), device, dimension(*) :: a, x ! device or host variable

subroutine cublasCtpmv(u, t, d, n, a, x, incx)
  character*1 :: u, t, d
  integer :: n, incx
  complex(4), device, dimension(*) :: a, x

integer(4) function cublasCtpmv_v2(h, u, t, d, n, a, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, incx
  complex(4), device, dimension(*) :: a, x

2.4.25. ctpsv

CTPSV 求解线性方程组 A*x = b, 或 A**T*x = b, 或 A**H*x = b 之一，其中 b 和 x 是 n 元素向量，A 是一个 n 乘 n 单位或非单位上或下三角矩阵，以压缩形式提供。此例程中不包含奇异性或近奇异性测试。此类测试必须在调用此例程之前执行。

subroutine ctpsv(u, t, d, n, a, x, incx)
  character*1 :: u, t, d
  integer :: n, incx
  complex(4), device, dimension(*) :: a, x ! device or host variable

subroutine cublasCtpsv(u, t, d, n, a, x, incx)
  character*1 :: u, t, d
  integer :: n, incx
  complex(4), device, dimension(*) :: a, x

integer(4) function cublasCtpsv_v2(h, u, t, d, n, a, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, incx
  complex(4), device, dimension(*) :: a, x

2.4.26. ctrmv

CTRMV 执行矩阵-向量运算 x := A*x, 或 x := A**T*x, 或 x := A**H*x 之一，其中 x 是一个 n 元素向量，A 是一个 n 乘 n 单位或非单位上或下三角矩阵。

subroutine ctrmv(u, t, d, n, a, lda, x, incx)
  character*1 :: u, t, d
  integer :: n, incx, lda
  complex(4), device, dimension(lda, *) :: a ! device or host variable
  complex(4), device, dimension(*) :: x ! device or host variable

subroutine cublasCtrmv(u, t, d, n, a, lda, x, incx)
  character*1 :: u, t, d
  integer :: n, incx, lda
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(*) :: x

integer(4) function cublasCtrmv_v2(h, u, t, d, n, a, lda, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, incx, lda
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(*) :: x

2.4.27. ctrsv

CTRSV 求解线性方程组 A*x = b, 或 A**T*x = b, 或 A**H*x = b 之一，其中 b 和 x 是 n 元素向量，A 是一个 n 乘 n 单位或非单位上或下三角矩阵。此例程中不包含奇异性或近奇异性测试。此类测试必须在调用此例程之前执行。

subroutine ctrsv(u, t, d, n, a, lda, x, incx)
  character*1 :: u, t, d
  integer :: n, incx, lda
  complex(4), device, dimension(lda, *) :: a ! device or host variable
  complex(4), device, dimension(*) :: x ! device or host variable

subroutine cublasCtrsv(u, t, d, n, a, lda, x, incx)
  character*1 :: u, t, d
  integer :: n, incx, lda
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(*) :: x

integer(4) function cublasCtrsv_v2(h, u, t, d, n, a, lda, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, incx, lda
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(*) :: x

2.4.28. chbmv

CHBMV 执行矩阵-向量运算 y := alpha*A*x + beta*y，其中 alpha 和 beta 是标量，x 和 y 是 n 元素向量，A 是一个 n 乘 n 埃尔米特带状矩阵，具有 k 条超对角线。

subroutine chbmv(uplo, n, k, alpha, a, lda, x, incx, beta, y, incy)
  character*1 :: uplo
  integer :: k, n, lda, incx, incy
  complex(4), device, dimension(lda, *) :: a ! device or host variable
  complex(4), device, dimension(*) :: x, y ! device or host variable
  complex(4), device :: alpha, beta ! device or host variable

subroutine cublasChbmv(uplo, n, k, alpha, a, lda, x, incx, beta, y, incy)
  character*1 :: uplo
  integer :: k, n, lda, incx, incy
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(*) :: x, y
  complex(4), device :: alpha, beta ! device or host variable

integer(4) function cublasChbmv_v2(h, uplo, n, k, alpha, a, lda, x, incx, beta, y, incy)
  type(cublasHandle) :: h
  integer :: uplo
  integer :: k, n, lda, incx, incy
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(*) :: x, y
  complex(4), device :: alpha, beta ! device or host variable

2.4.29. chemv

CHEMV 执行矩阵-向量运算 y := alpha*A*x + beta*y，其中 alpha 和 beta 是标量，x 和 y 是 n 元素向量，A 是一个 n 乘 n 埃尔米特矩阵。

subroutine chemv(uplo, n, alpha, a, lda, x, incx, beta, y, incy)
  character*1 :: uplo
  integer :: n, lda, incx, incy
  complex(4), device, dimension(lda, *) :: a ! device or host variable
  complex(4), device, dimension(*) :: x, y ! device or host variable
  complex(4), device :: alpha, beta ! device or host variable

subroutine cublasChemv(uplo, n, alpha, a, lda, x, incx, beta, y, incy)
  character*1 :: uplo
  integer :: n, lda, incx, incy
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(*) :: x, y
  complex(4), device :: alpha, beta ! device or host variable

integer(4) function cublasChemv_v2(h, uplo, n, alpha, a, lda, x, incx, beta, y, incy)
  type(cublasHandle) :: h
  integer :: uplo
  integer :: n, lda, incx, incy
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(*) :: x, y
  complex(4), device :: alpha, beta ! device or host variable

2.4.30. chpmv

CHPMV 执行矩阵-向量运算 y := alpha*A*x + beta*y，其中 alpha 和 beta 是标量，x 和 y 是 n 元素向量，A 是一个 n 乘 n 埃尔米特矩阵，以压缩形式提供。

subroutine chpmv(uplo, n, alpha, a, x, incx, beta, y, incy)
  character*1 :: uplo
  integer :: n, incx, incy
  complex(4), device, dimension(*) :: a, x, y ! device or host variable
  complex(4), device :: alpha, beta ! device or host variable

subroutine cublasChpmv(uplo, n, alpha, a, x, incx, beta, y, incy)
  character*1 :: uplo
  integer :: n, incx, incy
  complex(4), device, dimension(*) :: a, x, y
  complex(4), device :: alpha, beta ! device or host variable

integer(4) function cublasChpmv_v2(h, uplo, n, alpha, a, x, incx, beta, y, incy)
  type(cublasHandle) :: h
  integer :: uplo
  integer :: n, incx, incy
  complex(4), device, dimension(*) :: a, x, y
  complex(4), device :: alpha, beta ! device or host variable

2.4.31. cher

CHER 执行埃尔米特秩 1 运算 A := alpha*x*x**H + A，其中 alpha 是一个实标量，x 是一个 n 元素向量，A 是一个 n 乘 n 埃尔米特矩阵。

subroutine cher(t, n, alpha, x, incx, a, lda)
  character*1 :: t
  integer :: n, incx, lda
  complex(4), device, dimension(*) :: a, x ! device or host variable
  real(4), device :: alpha ! device or host variable

subroutine cublasCher(t, n, alpha, x, incx, a, lda)
  character*1 :: t
  integer :: n, incx, lda
  complex(4), device, dimension(*) :: a, x
  real(4), device :: alpha ! device or host variable

integer(4) function cublasCher_v2(h, t, n, alpha, x, incx, a, lda)
  type(cublasHandle) :: h
  integer :: t
  integer :: n, incx, lda
  complex(4), device, dimension(*) :: a, x
  real(4), device :: alpha ! device or host variable

2.4.32. cher2

CHER2 执行埃尔米特秩 2 运算 A := alpha*x*y**H + conjg( alpha )*y*x**H + A，其中 alpha 是一个标量，x 和 y 是 n 元素向量，A 是一个 n 乘 n 埃尔米特矩阵。

subroutine cher2(t, n, alpha, x, incx, y, incy, a, lda)
  character*1 :: t
  integer :: n, incx, incy, lda
  complex(4), device, dimension(*) :: a, x, y ! device or host variable
  complex(4), device :: alpha ! device or host variable

subroutine cublasCher2(t, n, alpha, x, incx, y, incy, a, lda)
  character*1 :: t
  integer :: n, incx, incy, lda
  complex(4), device, dimension(*) :: a, x, y
  complex(4), device :: alpha ! device or host variable

integer(4) function cublasCher2_v2(h, t, n, alpha, x, incx, y, incy, a, lda)
  type(cublasHandle) :: h
  integer :: t
  integer :: n, incx, incy, lda
  complex(4), device, dimension(*) :: a, x, y
  complex(4), device :: alpha ! device or host variable

2.4.33. chpr

CHPR 执行埃尔米特秩 1 运算 A := alpha*x*x**H + A，其中 alpha 是一个实标量，x 是一个 n 元素向量，A 是一个 n 乘 n 埃尔米特矩阵，以压缩形式提供。

subroutine chpr(t, n, alpha, x, incx, a)
  character*1 :: t
  integer :: n, incx
  complex(4), device, dimension(*) :: a, x ! device or host variable
  real(4), device :: alpha ! device or host variable

subroutine cublasChpr(t, n, alpha, x, incx, a)
  character*1 :: t
  integer :: n, incx
  complex(4), device, dimension(*) :: a, x
  real(4), device :: alpha ! device or host variable

integer(4) function cublasChpr_v2(h, t, n, alpha, x, incx, a)
  type(cublasHandle) :: h
  integer :: t
  integer :: n, incx
  complex(4), device, dimension(*) :: a, x
  real(4), device :: alpha ! device or host variable

2.4.34. chpr2

CHPR2 执行埃尔米特秩 2 运算 A := alpha*x*y**H + conjg( alpha )*y*x**H + A，其中 alpha 是一个标量，x 和 y 是 n 元素向量，A 是一个 n 乘 n 埃尔米特矩阵，以压缩形式提供。

subroutine chpr2(t, n, alpha, x, incx, y, incy, a)
  character*1 :: t
  integer :: n, incx, incy
  complex(4), device, dimension(*) :: a, x, y ! device or host variable
  complex(4), device :: alpha ! device or host variable

subroutine cublasChpr2(t, n, alpha, x, incx, y, incy, a)
  character*1 :: t
  integer :: n, incx, incy
  complex(4), device, dimension(*) :: a, x, y
  complex(4), device :: alpha ! device or host variable

integer(4) function cublasChpr2_v2(h, t, n, alpha, x, incx, y, incy, a)
  type(cublasHandle) :: h
  integer :: t
  integer :: n, incx, incy
  complex(4), device, dimension(*) :: a, x, y
  complex(4), device :: alpha ! device or host variable

2.4.35. cgemm

CGEMM 执行矩阵-矩阵运算 C := alpha*op( A )*op( B ) + beta*C 之一，其中 op( X ) 是 op( X ) = X 或 op( X ) = X**T 或 op( X ) = X**H 之一，alpha 和 beta 是标量，A、B 和 C 是矩阵，其中 op( A ) 是一个 m 乘 k 矩阵，op( B ) 是一个 k 乘 n 矩阵，C 是一个 m 乘 n 矩阵。

subroutine cgemm(transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  character*1 :: transa, transb
  integer :: m, n, k, lda, ldb, ldc
  complex(4), device, dimension(lda, *) :: a ! device or host variable
  complex(4), device, dimension(ldb, *) :: b ! device or host variable
  complex(4), device, dimension(ldc, *) :: c ! device or host variable
  complex(4), device :: alpha, beta ! device or host variable

subroutine cublasCgemm(transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  character*1 :: transa, transb
  integer :: m, n, k, lda, ldb, ldc
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(ldb, *) :: b
  complex(4), device, dimension(ldc, *) :: c
  complex(4), device :: alpha, beta ! device or host variable

integer(4) function cublasCgemm_v2(h, transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: transa, transb
  integer :: m, n, k, lda, ldb, ldc
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(ldb, *) :: b
  complex(4), device, dimension(ldc, *) :: c
  complex(4), device :: alpha, beta ! device or host variable

2.4.36. csymm

CSYMM 执行矩阵-矩阵运算 C := alpha*A*B + beta*C 或 C := alpha*B*A + beta*C 之一，其中 alpha 和 beta 是标量，A 是一个对称矩阵，B 和 C 是 m 乘 n 矩阵。

subroutine csymm(side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc)
  character*1 :: side, uplo
  integer :: m, n, lda, ldb, ldc
  complex(4), device, dimension(lda, *) :: a ! device or host variable
  complex(4), device, dimension(ldb, *) :: b ! device or host variable
  complex(4), device, dimension(ldc, *) :: c ! device or host variable
  complex(4), device :: alpha, beta ! device or host variable

subroutine cublasCsymm(side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc)
  character*1 :: side, uplo
  integer :: m, n, lda, ldb, ldc
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(ldb, *) :: b
  complex(4), device, dimension(ldc, *) :: c
  complex(4), device :: alpha, beta ! device or host variable

integer(4) function cublasCsymm_v2(h, side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: side, uplo
  integer :: m, n, lda, ldb, ldc
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(ldb, *) :: b
  complex(4), device, dimension(ldc, *) :: c
  complex(4), device :: alpha, beta ! device or host variable

2.4.37. csyrk

CSYRK 执行对称秩 k 运算 C := alpha*A*A**T + beta*C 或 C := alpha*A**T*A + beta*C 之一，其中 alpha 和 beta 是标量，C 是一个 n 乘 n 对称矩阵，A 在第一种情况下是一个 n 乘 k 矩阵，在第二种情况下是一个 k 乘 n 矩阵。

subroutine csyrk(uplo, trans, n, k, alpha, a, lda, beta, c, ldc)
  character*1 :: uplo, trans
  integer :: n, k, lda, ldc
  complex(4), device, dimension(lda, *) :: a ! device or host variable
  complex(4), device, dimension(ldc, *) :: c ! device or host variable
  complex(4), device :: alpha, beta ! device or host variable

subroutine cublasCsyrk(uplo, trans, n, k, alpha, a, lda, beta, c, ldc)
  character*1 :: uplo, trans
  integer :: n, k, lda, ldc
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(ldc, *) :: c
  complex(4), device :: alpha, beta ! device or host variable

integer(4) function cublasCsyrk_v2(h, uplo, trans, n, k, alpha, a, lda, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: uplo, trans
  integer :: n, k, lda, ldc
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(ldc, *) :: c
  complex(4), device :: alpha, beta ! device or host variable

2.4.38. csyr2k

CSYR2K 执行对称秩 2k 运算 C := alpha*A*B**T + alpha*B*A**T + beta*C 或 C := alpha*A**T*B + alpha*B**T*A + beta*C 之一，其中 alpha 和 beta 是标量，C 是一个 n 乘 n 对称矩阵，A 和 B 在第一种情况下是 n 乘 k 矩阵，在第二种情况下是 k 乘 n 矩阵。

subroutine csyr2k(uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  character*1 :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  complex(4), device, dimension(lda, *) :: a ! device or host variable
  complex(4), device, dimension(ldb, *) :: b ! device or host variable
  complex(4), device, dimension(ldc, *) :: c ! device or host variable
  complex(4), device :: alpha, beta ! device or host variable

subroutine cublasCsyr2k(uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  character*1 :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(ldb, *) :: b
  complex(4), device, dimension(ldc, *) :: c
  complex(4), device :: alpha, beta ! device or host variable

integer(4) function cublasCsyr2k_v2(h, uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(ldb, *) :: b
  complex(4), device, dimension(ldc, *) :: c
  complex(4), device :: alpha, beta ! device or host variable

2.4.39. csyrkx

CSYRKX 执行对称秩 k 更新 C := alpha*A*B**T + beta*C 的变体，其中 alpha 和 beta 是标量，C 是一个以 lower 或 upper 模式存储的 n 乘 n 对称矩阵，A 和 B 是 n 乘 k 矩阵。当 B 以某种方式使得结果保证对称时，可以使用此例程。有关更多详细信息，请参阅 CUBLAS 文档。

subroutine csyrkx(uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  character*1 :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  complex(4), device, dimension(lda, *) :: a ! device or host variable
  complex(4), device, dimension(ldb, *) :: b ! device or host variable
  complex(4), device, dimension(ldc, *) :: c ! device or host variable
  complex(4), device :: alpha, beta ! device or host variable

subroutine cublasCsyrkx(uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  character*1 :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(ldb, *) :: b
  complex(4), device, dimension(ldc, *) :: c
  complex(4), device :: alpha, beta ! device or host variable

integer(4) function cublasCsyrkx_v2(h, uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(ldb, *) :: b
  complex(4), device, dimension(ldc, *) :: c
  complex(4), device :: alpha, beta ! device or host variable

2.4.40. ctrmm

CTRMM 执行矩阵-矩阵运算 B := alpha*op( A )*B 或 B := alpha*B*op( A ) 之一，其中 alpha 是一个标量，B 是一个 m 乘 n 矩阵，A 是一个单位或非单位上或下三角矩阵，op( A ) 是 op( A ) = A 或 op( A ) = A**T 或 op( A ) = A**H 之一。

subroutine ctrmm(side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)
  character*1 :: side, uplo, transa, diag
  integer :: m, n, lda, ldb
  complex(4), device, dimension(lda, *) :: a ! device or host variable
  complex(4), device, dimension(ldb, *) :: b ! device or host variable
  complex(4), device :: alpha ! device or host variable

subroutine cublasCtrmm(side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)
  character*1 :: side, uplo, transa, diag
  integer :: m, n, lda, ldb
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(ldb, *) :: b
  complex(4), device :: alpha ! device or host variable

integer(4) function cublasCtrmm_v2(h, side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb, c, ldc)
  type(cublasHandle) :: h
  integer :: side, uplo, transa, diag
  integer :: m, n, lda, ldb, ldc
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(ldb, *) :: b
  complex(4), device, dimension(ldc, *) :: c
  complex(4), device :: alpha ! device or host variable

2.4.41. ctrsm

CTRSM 求解矩阵方程 op( A )*X = alpha*B 或 X*op( A ) = alpha*B 之一，其中 alpha 是一个标量，X 和 B 是 m 乘 n 矩阵，A 是一个单位或非单位上或下三角矩阵，op( A ) 是 op( A ) = A 或 op( A ) = A**T 或 op( A ) = A**H 之一。矩阵 X 在 B 上被覆盖。

subroutine ctrsm(side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)
  character*1 :: side, uplo, transa, diag
  integer :: m, n, lda, ldb
  complex(4), device, dimension(lda, *) :: a ! device or host variable
  complex(4), device, dimension(ldb, *) :: b ! device or host variable
  complex(4), device :: alpha ! device or host variable

subroutine cublasCtrsm(side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)
  character*1 :: side, uplo, transa, diag
  integer :: m, n, lda, ldb
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(ldb, *) :: b
  complex(4), device :: alpha ! device or host variable

integer(4) function cublasCtrsm_v2(h, side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)
  type(cublasHandle) :: h
  integer :: side, uplo, transa, diag
  integer :: m, n, lda, ldb
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(ldb, *) :: b
  complex(4), device :: alpha ! device or host variable

2.4.42. chemm

CHEMM 执行矩阵-矩阵运算 C := alpha*A*B + beta*C 或 C := alpha*B*A + beta*C 之一，其中 alpha 和 beta 是标量，A 是一个埃尔米特矩阵，B 和 C 是 m 乘 n 矩阵。

subroutine chemm(side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc)
  character*1 :: side, uplo
  integer :: m, n, lda, ldb, ldc
  complex(4), device, dimension(lda, *) :: a ! device or host variable
  complex(4), device, dimension(ldb, *) :: b ! device or host variable
  complex(4), device, dimension(ldc, *) :: c ! device or host variable
  complex(4), device :: alpha, beta ! device or host variable

subroutine cublasChemm(side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc)
  character*1 :: side, uplo
  integer :: m, n, lda, ldb, ldc
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(ldb, *) :: b
  complex(4), device, dimension(ldc, *) :: c
  complex(4), device :: alpha, beta ! device or host variable

integer(4) function cublasChemm_v2(h, side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: side, uplo
  integer :: m, n, lda, ldb, ldc
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(ldb, *) :: b
  complex(4), device, dimension(ldc, *) :: c
  complex(4), device :: alpha, beta ! device or host variable

2.4.43. cherk

CHERK 执行埃尔米特秩 k 运算 C := alpha*A*A**H + beta*C 或 C := alpha*A**H*A + beta*C 之一，其中 alpha 和 beta 是实标量，C 是一个 n 乘 n 埃尔米特矩阵，A 在第一种情况下是一个 n 乘 k 矩阵，在第二种情况下是一个 k 乘 n 矩阵。

subroutine cherk(uplo, trans, n, k, alpha, a, lda, beta, c, ldc)
  character*1 :: uplo, trans
  integer :: n, k, lda, ldc
  complex(4), device, dimension(lda, *) :: a ! device or host variable
  complex(4), device, dimension(ldc, *) :: c ! device or host variable
  real(4), device :: alpha, beta ! device or host variable

subroutine cublasCherk(uplo, trans, n, k, alpha, a, lda, beta, c, ldc)
  character*1 :: uplo, trans
  integer :: n, k, lda, ldc
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(ldc, *) :: c
  real(4), device :: alpha, beta ! device or host variable

integer(4) function cublasCherk_v2(h, uplo, trans, n, k, alpha, a, lda, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: uplo, trans
  integer :: n, k, lda, ldc
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(ldc, *) :: c
  real(4), device :: alpha, beta ! device or host variable

2.4.44. cher2k

CHER2K 执行埃尔米特秩 2k 运算 C := alpha*A*B**H + conjg( alpha )*B*A**H + beta*C 或 C := alpha*A**H*B + conjg( alpha )*B**H*A + beta*C 之一，其中 alpha 和 beta 是标量，beta 是实数，C 是一个 n 乘 n 埃尔米特矩阵，A 和 B 在第一种情况下是 n 乘 k 矩阵，在第二种情况下是 k 乘 n 矩阵。

subroutine cher2k(uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  character*1 :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  complex(4), device, dimension(lda, *) :: a ! device or host variable
  complex(4), device, dimension(ldb, *) :: b ! device or host variable
  complex(4), device, dimension(ldc, *) :: c ! device or host variable
  complex(4), device :: alpha ! device or host variable
  real(4), device :: beta ! device or host variable

subroutine cublasCher2k(uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  character*1 :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(ldb, *) :: b
  complex(4), device, dimension(ldc, *) :: c
  complex(4), device :: alpha ! device or host variable
  real(4), device :: beta ! device or host variable

integer(4) function cublasCher2k_v2(h, uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(ldb, *) :: b
  complex(4), device, dimension(ldc, *) :: c
  complex(4), device :: alpha ! device or host variable
  real(4), device :: beta ! device or host variable

2.4.45. cherkx

CHERKX 执行埃尔米特秩 k 运算 C := alpha*A*B**H + beta*C 的变体，其中 alpha 和 beta 是实标量，C 是一个以 lower 或 upper 模式存储的 n 乘 n 埃尔米特矩阵，A 和 B 是 n 乘 k 矩阵。有关更多详细信息，请参阅 CUBLAS 文档。

subroutine cherkx(uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  character*1 :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  complex(4), device, dimension(lda, *) :: a ! device or host variable
  complex(4), device, dimension(ldb, *) :: b ! device or host variable
  complex(4), device, dimension(ldc, *) :: c ! device or host variable
  complex(4), device :: alpha ! device or host variable
  real(4), device :: beta ! device or host variable

subroutine cublasCherkx(uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  character*1 :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(ldb, *) :: b
  complex(4), device, dimension(ldc, *) :: c
  complex(4), device :: alpha ! device or host variable
  real(4), device :: beta ! device or host variable

integer(4) function cublasCherkx_v2(h, uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(ldb, *) :: b
  complex(4), device, dimension(ldc, *) :: c
  complex(4), device :: alpha ! device or host variable
  real(4), device :: beta ! device or host variable

2.4.46. cublasCgemvBatched

CGEMV 执行批量矩阵-向量运算 Y := alpha*op( A ) * X + beta*Y，其中 op( A ) 是 op( A ) = A 或 op( A ) = A**T 之一，alpha 和 beta 是标量，A 是一个 m 乘 n 矩阵，X 和 Y 是向量。

integer(4) function cublasCgemvBatched(h, trans, m, n, alpha, &
      Aarray, lda, xarray, incx, beta, yarray, incy, batchCount)
  type(cublasHandle) :: h
  integer :: trans ! integer or character(1) variable
  integer :: m, n
  complex(4), device :: alpha ! device or host variable
  type(c_devptr), device :: Aarray(*)
  integer :: lda
  type(c_devptr), device :: xarray(*)
  integer :: incx
  complex(4), device :: beta ! device or host variable
  type(c_devptr), device :: yarray(*)
  integer :: incy
  integer :: batchCount

integer(4) function cublasCgemvBatched_v2(h, trans, m, n, alpha, &
      Aarray, lda, xarray, incx, beta, yarray, incy, batchCount)
  type(cublasHandle) :: h
  integer :: trans
  integer :: m, n
  complex(4), device :: alpha ! device or host variable
  type(c_devptr), device :: Aarray(*)
  integer :: lda
  type(c_devptr), device :: xarray(*)
  integer :: incx
  complex(4), device :: beta ! device or host variable
  type(c_devptr), device :: yarray(*)
  integer :: incy
  integer :: batchCount

2.4.47. cublasCgemmBatched

CGEMM 执行矩阵-矩阵运算 C := alpha*op( A )*op( B ) + beta*C 之一，其中 op( X ) 是 op( X ) = X 或 op( X ) = X**T 或 op( X ) = X**H 之一，alpha 和 beta 是标量，A、B 和 C 是矩阵，其中 op( A ) 是一个 m 乘 k 矩阵，op( B ) 是一个 k 乘 n 矩阵，C 是一个 m 乘 n 矩阵。

integer(4) function cublasCgemmBatched(h, transa, transb, m, n, k, alpha, Aarray, lda, Barray, ldb, beta, Carray, ldc, batchCount)
  type(cublasHandle) :: h
  integer :: transa ! integer or character(1) variable
  integer :: transb ! integer or character(1) variable
  integer :: m, n, k
  complex(4), device :: alpha ! device or host variable
  type(c_devptr), device :: Aarray(*)
  integer :: lda
  type(c_devptr), device :: Barray(*)
  integer :: ldb
  complex(4), device :: beta ! device or host variable
  type(c_devptr), device :: Carray(*)
  integer :: ldc
  integer :: batchCount

integer(4) function cublasCgemmBatched_v2(h, transa, transb, m, n, k, alpha, &
           Aarray, lda, Barray, ldb, beta, Carray, ldc, batchCount)
  type(cublasHandle) :: h
  integer :: transa
  integer :: transb
  integer :: m, n, k
  complex(4), device :: alpha ! device or host variable
  type(c_devptr), device :: Aarray(*)
  integer :: lda
  type(c_devptr), device :: Barray(*)
  integer :: ldb
  complex(4), device :: beta ! device or host variable
  type(c_devptr), device :: Carray(*)
  integer :: ldc
  integer :: batchCount

2.4.48. cublasCgelsBatched

CGELS 使用 A 的 QR 或 LQ 分解，求解涉及 M 乘 N 矩阵 A 或其共轭转置的超定或欠定复线性系统。假设 A 具有满秩。提供以下选项：1. 如果 TRANS = ‘N’ 且 m >= n：找到超定系统的最小二乘解，即，求解最小二乘问题 minimize || B - A*X ||。2. 如果 TRANS = ‘N’ 且 m < n：找到欠定系统 A * X = B 的最小范数解。3. 如果 TRANS = ‘C’ 且 m >= n：找到欠定系统 A**H * X = B 的最小范数解。4. 如果 TRANS = ‘C’ 且 m < n：找到超定系统的最小二乘解，即，求解最小二乘问题 minimize || B - A**H * X ||。可以在单个调用中处理多个右手边向量 b 和解向量 x；它们存储为 M 乘 NRHS 右手边矩阵 B 和 N 乘 NRHS 解矩阵 X 的列。

integer(4) function cublasCgelsBatched(h, trans, m, n, nrhs, Aarray, lda, Carray, ldc, info, devinfo, batchCount)
  type(cublasHandle) :: h
  integer :: trans ! integer or character(1) variable
  integer :: m, n, nrhs
  type(c_devptr), device :: Aarray(*)
  integer :: lda
  type(c_devptr), device :: Carray(*)
  integer :: ldc
  integer :: info(*)
  integer, device :: devinfo(*)
  integer :: batchCount

2.4.49. cublasCgeqrfBatched

CGEQRF 计算复数 M 乘 N 矩阵 A 的 QR 分解：A = Q * R。

integer(4) function cublasCgeqrfBatched(h, m, n, Aarray, lda, Tau, info, batchCount)
  type(cublasHandle) :: h
  integer :: m, n
  type(c_devptr), device :: Aarray(*)
  integer :: lda
  type(c_devptr), device :: Tau(*)
  integer :: info(*)
  integer :: batchCount

2.4.50. cublasCgetrfBatched

CGETRF 使用行交换的部分主元法计算一般 M 乘 N 矩阵 A 的 LU 分解。分解形式为 A = P * L * U，其中 P 是置换矩阵，L 是具有单位对角线元素的下三角矩阵（如果 m > n，则为下梯形矩阵），U 是上三角矩阵（如果 m < n，则为上梯形矩阵）。这是算法的 right-looking Level 3 BLAS 版本。

integer(4) function cublasCgetrfBatched(h, n, Aarray, lda, ipvt, info, batchCount)
  type(cublasHandle) :: h
  integer :: n
  type(c_devptr), device :: Aarray(*)
  integer :: lda
  integer, device :: ipvt(*)
  integer, device :: info(*)
  integer :: batchCount

2.4.51. cublasCgetriBatched

CGETRI 使用 CGETRF 计算的 LU 分解来计算矩阵的逆矩阵。此方法反转 U，然后通过求解方程组 inv(A)*L = inv(U) 来计算 inv(A)。

integer(4) function cublasCgetriBatched(h, n, Aarray, lda, ipvt, Carray, ldc, info, batchCount)
  type(cublasHandle) :: h
  integer :: n
  type(c_devptr), device :: Aarray(*)
  integer :: lda
  integer, device :: ipvt(*)
  type(c_devptr), device :: Carray(*)
  integer :: ldc
  integer, device :: info(*)
  integer :: batchCount

2.4.52. cublasCgetrsBatched

CGETRS 使用 CGETRF 计算的 LU 分解，求解具有一般 N 乘 N 矩阵 A 的线性方程组 A * X = B、A**T * X = B 或 A**H * X = B。

integer(4) function cublasCgetrsBatched(h, trans, n, nrhs, Aarray, lda, ipvt, Barray, ldb, info, batchCount)
  type(cublasHandle) :: h
  integer :: trans ! integer or character(1) variable
  integer :: n, nrhs
  type(c_devptr), device :: Aarray(*)
  integer :: lda
  integer, device :: ipvt(*)
  type(c_devptr), device :: Barray(*)
  integer :: ldb
  integer :: info(*)
  integer :: batchCount

2.4.53. cublasCmatinvBatched

cublasCmatinvBatched 是 cublasCgetrfBatched 加 cublasCgetriBatched 的快捷方式。但是，它仅在 n 小于 32 时有效。否则，用户必须使用 cublasCgetrfBatched 和 cublasCgetriBatched。

integer(4) function cublasCmatinvBatched(h, n, Aarray, lda, Ainv, lda_inv, info, batchCount)
  type(cublasHandle) :: h
  integer :: n
  type(c_devptr), device :: Aarray(*)
  integer :: lda
  type(c_devptr), device :: Ainv(*)
  integer :: lda_inv
  integer, device :: info(*)
  integer :: batchCount

2.4.54. cublasCtrsmBatched

CTRSM 求解矩阵方程 op( A )*X = alpha*B 或 X*op( A ) = alpha*B 之一，其中 alpha 是一个标量，X 和 B 是 m 乘 n 矩阵，A 是一个单位或非单位上或下三角矩阵，op( A ) 是 op( A ) = A 或 op( A ) = A**T 或 op( A ) = A**H 之一。矩阵 X 在 B 上被覆盖。

integer(4) function cublasCtrsmBatched( h, side, uplo, trans, diag, m, n, alpha, A, lda, B, ldb, batchCount)
  type(cublasHandle) :: h
  integer :: side ! integer or character(1) variable
  integer :: uplo ! integer or character(1) variable
  integer :: trans ! integer or character(1) variable
  integer :: diag ! integer or character(1) variable
  integer :: m, n
  complex(4), device :: alpha ! device or host variable
  type(c_devptr), device :: A(*)
  integer :: lda
  type(c_devptr), device :: B(*)
  integer :: ldb
  integer :: batchCount

integer(4) function cublasCtrsmBatched_v2( h, side, uplo, trans, diag, m, n, alpha, A, lda, B, ldb, batchCount)
  type(cublasHandle) :: h
  integer :: side
  integer :: uplo
  integer :: trans
  integer :: diag
  integer :: m, n
  complex(4), device :: alpha ! device or host variable
  type(c_devptr), device :: A(*)
  integer :: lda
  type(c_devptr), device :: B(*)
  integer :: ldb
  integer :: batchCount

2.4.55. cublasCgemvStridedBatched

CGEMV 执行批量矩阵-向量运算 Y := alpha*op( A ) * X + beta*Y，其中 op( A ) 是 op( A ) = A 或 op( A ) = A**T 之一，alpha 和 beta 是标量，A 是一个 m 乘 n 矩阵，X 和 Y 是向量。

integer(4) function cublasCgemvStridedBatched(h, trans, m, n, alpha, &
      A, lda, strideA, X, incx, strideX, beta, Y, incy, strideY, batchCount)
  type(cublasHandle) :: h
  integer :: trans ! integer or character(1) variable
  integer :: m, n
  complex(4), device :: alpha ! device or host variable
  complex(4), device :: A(lda,*)
  integer :: lda
  integer(8) :: strideA
  complex(4), device :: X(*)
  integer :: incx
  integer(8) :: strideX
  complex(4), device :: beta ! device or host variable
  complex(4), device :: Y(*)
  integer :: incy
  integer(8) :: strideY
  integer :: batchCount

integer(4) function cublasCgemvStridedBatched_v2(h, trans, m, n, alpha, &
      A, lda, strideA, X, incx, strideX, beta, Y, incy, strideY, batchCount)
  type(cublasHandle) :: h
  integer :: trans
  integer :: m, n
  complex(4), device :: alpha ! device or host variable
  complex(4), device :: A(lda,*)
  integer :: lda
  integer(8) :: strideA
  complex(4), device :: X(*)
  integer :: incx
  integer(8) :: strideX
  complex(4), device :: beta ! device or host variable
  complex(4), device :: Y(*)
  integer :: incy
  integer(8) :: strideY
  integer :: batchCount

2.4.56. cublasCgemmStridedBatched

CGEMM 执行矩阵-矩阵运算 C := alpha*op( A )*op( B ) + beta*C 之一，其中 op( X ) 是 op( X ) = X 或 op( X ) = X**T 之一，alpha 和 beta 是标量，A、B 和 C 是矩阵，其中 op( A ) 是一个 m 乘 k 矩阵，op( B ) 是一个 k 乘 n 矩阵，C 是一个 m 乘 n 矩阵。

integer(4) function cublasCgemmStridedBatched(h, transa, transb, m, n, k, alpha, Aarray, lda, strideA, Barray, ldb, strideB, beta, Carray, ldc, strideC, batchCount)
  type(cublasHandle) :: h
  integer :: transa ! integer or character(1) variable
  integer :: transb ! integer or character(1) variable
  integer :: m, n, k
  complex(4), device :: alpha ! device or host variable
  complex(4), device :: Aarray(*)
  integer :: lda
  integer :: strideA
  complex(4), device :: Barray(*)
  integer :: ldb
  integer :: strideB
  complex(4), device :: beta ! device or host variable
  complex(4), device :: Carray(*)
  integer :: ldc
  integer :: strideC
  integer :: batchCount

integer(4) function cublasCgemmStridedBatched_v2(h, transa, transb, m, n, k, alpha, &
           Aarray, lda, strideA, Barray, ldb, strideB, beta, Carray, ldc, strideC, batchCount)
  type(cublasHandle) :: h
  integer :: transa
  integer :: transb
  integer :: m, n, k
  complex(4), device :: alpha ! device or host variable
  complex(4), device :: Aarray(*)
  integer :: lda
  integer :: strideA
  complex(4), device :: Barray(*)
  integer :: ldb
  integer :: strideB
  complex(4), device :: beta ! device or host variable
  complex(4), device :: Carray(*)
  integer :: ldc
  integer :: strideC
  integer :: batchCount

2.5. 双精度复数函数和子程序

本节包含双精度复数 BLAS 和 cuBLAS 函数和子程序的接口。

2.5.1. izamax

IZAMAX 查找具有最大绝对值的元素的索引。

integer(4) function izamax(n, x, incx)
  integer :: n
  complex(8), device, dimension(*) :: x ! device or host variable
  integer :: incx

integer(4) function cublasIzamax(n, x, incx)
  integer :: n
  complex(8), device, dimension(*) :: x
  integer :: incx

integer(4) function cublasIzamax_v2(h, n, x, incx, res)
  type(cublasHandle) :: h
  integer :: n
  complex(8), device, dimension(*) :: x
  integer :: incx
  integer, device :: res ! device or host variable

2.5.2. izamin

IZAMIN 查找具有最小绝对值的元素的索引。

integer(4) function izamin(n, x, incx)
  integer :: n
  complex(8), device, dimension(*) :: x ! device or host variable
  integer :: incx

integer(4) function cublasIzamin(n, x, incx)
  integer :: n
  complex(8), device, dimension(*) :: x
  integer :: incx

integer(4) function cublasIzamin_v2(h, n, x, incx, res)
  type(cublasHandle) :: h
  integer :: n
  complex(8), device, dimension(*) :: x
  integer :: incx
  integer, device :: res ! device or host variable

2.5.3. dzasum

DZASUM 计算绝对值之和。

real(8) function dzasum(n, x, incx)
  integer :: n
  complex(8), device, dimension(*) :: x ! device or host variable
  integer :: incx

real(8) function cublasDzasum(n, x, incx)
  integer :: n
  complex(8), device, dimension(*) :: x
  integer :: incx

integer(4) function cublasDzasum_v2(h, n, x, incx, res)
  type(cublasHandle) :: h
  integer :: n
  complex(8), device, dimension(*) :: x
  integer :: incx
  real(8), device :: res ! device or host variable

2.5.4. zaxpy

ZAXPY 常数乘以向量加上向量。

subroutine zaxpy(n, a, x, incx, y, incy)
  integer :: n
  complex(8), device :: a ! device or host variable
  complex(8), device, dimension(*) :: x, y ! device or host variable
  integer :: incx, incy

subroutine cublasZaxpy(n, a, x, incx, y, incy)
  integer :: n
  complex(8), device :: a ! device or host variable
  complex(8), device, dimension(*) :: x, y
  integer :: incx, incy

integer(4) function cublasZaxpy_v2(h, n, a, x, incx, y, incy)
  type(cublasHandle) :: h
  integer :: n
  complex(8), device :: a ! device or host variable
  complex(8), device, dimension(*) :: x, y
  integer :: incx, incy

2.5.5. zcopy

ZCOPY 将向量 x 复制到向量 y。

subroutine zcopy(n, x, incx, y, incy)
  integer :: n
  complex(8), device, dimension(*) :: x, y ! device or host variable
  integer :: incx, incy

subroutine cublasZcopy(n, x, incx, y, incy)
  integer :: n
  complex(8), device, dimension(*) :: x, y
  integer :: incx, incy

integer(4) function cublasZcopy_v2(h, n, x, incx, y, incy)
  type(cublasHandle) :: h
  integer :: n
  complex(8), device, dimension(*) :: x, y
  integer :: incx, incy

2.5.6. zdotc

ZDOTC 形成向量的点积。

complex(8) function zdotc(n, x, incx, y, incy)
  integer :: n
  complex(8), device, dimension(*) :: x, y ! device or host variable
  integer :: incx, incy

complex(8) function cublasZdotc(n, x, incx, y, incy)
  integer :: n
  complex(8), device, dimension(*) :: x, y
  integer :: incx, incy

integer(4) function cublasZdotc_v2(h, n, x, incx, y, incy, res)
  type(cublasHandle) :: h
  integer :: n
  complex(8), device, dimension(*) :: x, y
  integer :: incx, incy
  complex(8), device :: res ! device or host variable

2.5.7. zdotu

ZDOTU 形成两个向量的点积。

complex(8) function zdotu(n, x, incx, y, incy)
  integer :: n
  complex(8), device, dimension(*) :: x, y ! device or host variable
  integer :: incx, incy

complex(8) function cublasZdotu(n, x, incx, y, incy)
  integer :: n
  complex(8), device, dimension(*) :: x, y
  integer :: incx, incy

integer(4) function cublasZdotu_v2(h, n, x, incx, y, incy, res)
  type(cublasHandle) :: h
  integer :: n
  complex(8), device, dimension(*) :: x, y
  integer :: incx, incy
  complex(8), device :: res ! device or host variable

2.5.8. dznrm2

DZNRM2 通过函数名返回向量的欧几里得范数，因此 DZNRM2 := sqrt( x**H*x )

real(8) function dznrm2(n, x, incx)
  integer :: n
  complex(8), device, dimension(*) :: x ! device or host variable
  integer :: incx

real(8) function cublasDznrm2(n, x, incx)
  integer :: n
  complex(8), device, dimension(*) :: x
  integer :: incx

integer(4) function cublasDznrm2_v2(h, n, x, incx, res)
  type(cublasHandle) :: h
  integer :: n
  complex(8), device, dimension(*) :: x
  integer :: incx
  real(8), device :: res ! device or host variable

2.5.9. zrot

ZROT 应用平面旋转，其中 cos (C) 是实数，sin (S) 是复数，向量 CX 和 CY 是复数。

subroutine zrot(n, x, incx, y, incy, sc, ss)
  integer :: n
  real(8), device :: sc ! device or host variable
  complex(8), device :: ss ! device or host variable
  complex(8), device, dimension(*) :: x, y ! device or host variable
  integer :: incx, incy

subroutine cublasZrot(n, x, incx, y, incy, sc, ss)
  integer :: n
  real(8), device :: sc ! device or host variable
  complex(8), device :: ss ! device or host variable
  complex(8), device, dimension(*) :: x, y
  integer :: incx, incy

integer(4) function cublasZrot_v2(h, n, x, incx, y, incy, sc, ss)
  type(cublasHandle) :: h
  integer :: n
  real(8), device :: sc ! device or host variable
  complex(8), device :: ss ! device or host variable
  complex(8), device, dimension(*) :: x, y
  integer :: incx, incy

2.5.10. zsrot

ZSROT 应用平面旋转，其中 cos 和 sin (c 和 s) 是实数，向量 cx 和 cy 是复数。

subroutine zsrot(n, x, incx, y, incy, sc, ss)
  integer :: n
  real(8), device :: sc, ss ! device or host variable
  complex(8), device, dimension(*) :: x, y ! device or host variable
  integer :: incx, incy

subroutine cublasZsrot(n, x, incx, y, incy, sc, ss)
  integer :: n
  real(8), device :: sc, ss ! device or host variable
  complex(8), device, dimension(*) :: x, y
  integer :: incx, incy

integer(4) function cublasZsrot_v2(h, n, x, incx, y, incy, sc, ss)
  type(cublasHandle) :: h
  integer :: n
  real(8), device :: sc, ss ! device or host variable
  complex(8), device, dimension(*) :: x, y
  integer :: incx, incy

2.5.11. zrotg

ZROTG 确定双精度复数吉文斯旋转。

subroutine zrotg(sa, sb, sc, ss)
  complex(8), device :: sa, sb, ss ! device or host variable
  real(8), device :: sc ! device or host variable

subroutine cublasZrotg(sa, sb, sc, ss)
  complex(8), device :: sa, sb, ss ! device or host variable
  real(8), device :: sc ! device or host variable

integer(4) function cublasZrotg_v2(h, sa, sb, sc, ss)
  type(cublasHandle) :: h
  complex(8), device :: sa, sb, ss ! device or host variable
  real(8), device :: sc ! device or host variable

2.5.12. zscal

ZSCAL 用常数缩放向量。

subroutine zscal(n, a, x, incx)
  integer :: n
  complex(8), device :: a ! device or host variable
  complex(8), device, dimension(*) :: x ! device or host variable
  integer :: incx

subroutine cublasZscal(n, a, x, incx)
  integer :: n
  complex(8), device :: a ! device or host variable
  complex(8), device, dimension(*) :: x
  integer :: incx

integer(4) function cublasZscal_v2(h, n, a, x, incx)
  type(cublasHandle) :: h
  integer :: n
  complex(8), device :: a ! device or host variable
  complex(8), device, dimension(*) :: x
  integer :: incx

2.5.13. zdscal

ZDSCAL 用常数缩放向量。

subroutine zdscal(n, a, x, incx)
  integer :: n
  real(8), device :: a ! device or host variable
  complex(8), device, dimension(*) :: x ! device or host variable
  integer :: incx

subroutine cublasZdscal(n, a, x, incx)
  integer :: n
  real(8), device :: a ! device or host variable
  complex(8), device, dimension(*) :: x
  integer :: incx

integer(4) function cublasZdscal_v2(h, n, a, x, incx)
  type(cublasHandle) :: h
  integer :: n
  real(8), device :: a ! device or host variable
  complex(8), device, dimension(*) :: x
  integer :: incx

2.5.14. zswap

ZSWAP 交换两个向量。

subroutine zswap(n, x, incx, y, incy)
  integer :: n
  complex(8), device, dimension(*) :: x, y ! device or host variable
  integer :: incx, incy

subroutine cublasZswap(n, x, incx, y, incy)
  integer :: n
  complex(8), device, dimension(*) :: x, y
  integer :: incx, incy

integer(4) function cublasZswap_v2(h, n, x, incx, y, incy)
  type(cublasHandle) :: h
  integer :: n
  complex(8), device, dimension(*) :: x, y
  integer :: incx, incy

2.5.15. zgbmv

ZGBMV 执行矩阵-向量运算 y := alpha*A*x + beta*y, 或 y := alpha*A**T*x + beta*y, 或 y := alpha*A**H*x + beta*y 之一，其中 alpha 和 beta 是标量，x 和 y 是向量，A 是一个 m 乘 n 带状矩阵，具有 kl 条子对角线和 ku 条超对角线。

subroutine zgbmv(t, m, n, kl, ku, alpha, a, lda, x, incx, beta, y, incy)
  character*1 :: t
  integer :: m, n, kl, ku, lda, incx, incy
  complex(8), device, dimension(lda, *) :: a ! device or host variable
  complex(8), device, dimension(*) :: x, y ! device or host variable
  complex(8), device :: alpha, beta ! device or host variable

subroutine cublasZgbmv(t, m, n, kl, ku, alpha, a, lda, x, incx, beta, y, incy)
  character*1 :: t
  integer :: m, n, kl, ku, lda, incx, incy
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(*) :: x, y
  complex(8), device :: alpha, beta ! device or host variable

integer(4) function cublasZgbmv_v2(h, t, m, n, kl, ku, alpha, a, lda, x, incx, beta, y, incy)
  type(cublasHandle) :: h
  integer :: t
  integer :: m, n, kl, ku, lda, incx, incy
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(*) :: x, y
  complex(8), device :: alpha, beta ! device or host variable

2.5.16. zgemv

ZGEMV 执行矩阵-向量运算 y := alpha*A*x + beta*y, 或 y := alpha*A**T*x + beta*y, 或 y := alpha*A**H*x + beta*y 之一，其中 alpha 和 beta 是标量，x 和 y 是向量，A 是一个 m 乘 n 矩阵。

subroutine zgemv(t, m, n, alpha, a, lda, x, incx, beta, y, incy)
  character*1 :: t
  integer :: m, n, lda, incx, incy
  complex(8), device, dimension(lda, *) :: a ! device or host variable
  complex(8), device, dimension(*) :: x, y ! device or host variable
  complex(8), device :: alpha, beta ! device or host variable

subroutine cublasZgemv(t, m, n, alpha, a, lda, x, incx, beta, y, incy)
  character*1 :: t
  integer :: m, n, lda, incx, incy
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(*) :: x, y
  complex(8), device :: alpha, beta ! device or host variable

integer(4) function cublasZgemv_v2(h, t, m, n, alpha, a, lda, x, incx, beta, y, incy)
  type(cublasHandle) :: h
  integer :: t
  integer :: m, n, lda, incx, incy
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(*) :: x, y
  complex(8), device :: alpha, beta ! device or host variable

2.5.17. zgerc

ZGERC 执行秩 1 运算 A := alpha*x*y**H + A，其中 alpha 是一个标量，x 是一个 m 元素向量，y 是一个 n 元素向量，A 是一个 m 乘 n 矩阵。

subroutine zgerc(m, n, alpha, x, incx, y, incy, a, lda)
  integer :: m, n, lda, incx, incy
  complex(8), device, dimension(lda, *) :: a ! device or host variable
  complex(8), device, dimension(*) :: x, y ! device or host variable
  complex(8), device :: alpha ! device or host variable

subroutine cublasZgerc(m, n, alpha, x, incx, y, incy, a, lda)
  integer :: m, n, lda, incx, incy
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(*) :: x, y
  complex(8), device :: alpha ! device or host variable

integer(4) function cublasZgerc_v2(h, m, n, alpha, x, incx, y, incy, a, lda)
  type(cublasHandle) :: h
  integer :: m, n, lda, incx, incy
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(*) :: x, y
  complex(8), device :: alpha ! device or host variable

2.5.18. zgeru

ZGERU 执行秩 1 运算 A := alpha*x*y**T + A，其中 alpha 是一个标量，x 是一个 m 元素向量，y 是一个 n 元素向量，A 是一个 m 乘 n 矩阵。

subroutine zgeru(m, n, alpha, x, incx, y, incy, a, lda)
  integer :: m, n, lda, incx, incy
  complex(8), device, dimension(lda, *) :: a ! device or host variable
  complex(8), device, dimension(*) :: x, y ! device or host variable
  complex(8), device :: alpha ! device or host variable

subroutine cublasZgeru(m, n, alpha, x, incx, y, incy, a, lda)
  integer :: m, n, lda, incx, incy
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(*) :: x, y
  complex(8), device :: alpha ! device or host variable

integer(4) function cublasZgeru_v2(h, m, n, alpha, x, incx, y, incy, a, lda)
  type(cublasHandle) :: h
  integer :: m, n, lda, incx, incy
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(*) :: x, y
  complex(8), device :: alpha ! device or host variable

2.5.19. zsymv

ZSYMV 执行矩阵-向量运算 y := alpha*A*x + beta*y，其中 alpha 和 beta 是标量，x 和 y 是 n 元素向量，A 是一个 n 乘 n 对称矩阵。

subroutine zsymv(uplo, n, alpha, a, lda, x, incx, beta, y, incy)
  character*1 :: uplo
  integer :: n, lda, incx, incy
  complex(8), device, dimension(lda, *) :: a ! device or host variable
  complex(8), device, dimension(*) :: x, y ! device or host variable
  complex(8), device :: alpha, beta ! device or host variable

subroutine cublasZsymv(uplo, n, alpha, a, lda, x, incx, beta, y, incy)
  character*1 :: uplo
  integer :: n, lda, incx, incy
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(*) :: x, y
  complex(8), device :: alpha, beta ! device or host variable

integer(4) function cublasZsymv_v2(h, uplo, n, alpha, a, lda, x, incx, beta, y, incy)
  type(cublasHandle) :: h
  integer :: uplo
  integer :: n, lda, incx, incy
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(*) :: x, y
  complex(8), device :: alpha, beta ! device or host variable

2.5.20. zsyr

ZSYR 执行对称秩 1 运算 A := alpha*x*x**H + A，其中 alpha 是一个复数标量，x 是一个 n 元素向量，A 是一个 n 乘 n 对称矩阵。

subroutine zsyr(t, n, alpha, x, incx, a, lda)
  character*1 :: t
  integer :: n, incx, lda
  complex(8), device, dimension(lda, *) :: a ! device or host variable
  complex(8), device, dimension(*) :: x ! device or host variable
  complex(8), device :: alpha ! device or host variable

subroutine cublasZsyr(t, n, alpha, x, incx, a, lda)
  character*1 :: t
  integer :: n, incx, lda
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(*) :: x
  complex(8), device :: alpha ! device or host variable

integer(4) function cublasZsyr_v2(h, t, n, alpha, x, incx, a, lda)
  type(cublasHandle) :: h
  integer :: t
  integer :: n, incx, lda
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(*) :: x
  complex(8), device :: alpha ! device or host variable

2.5.21. zsyr2

ZSYR2 执行对称秩 2 运算 A := alpha*x*y’ + alpha*y*x’ + A，其中 alpha 是一个复数标量，x 和 y 是 n 元素向量，A 是一个 n 乘 n SY 矩阵。

subroutine zsyr2(t, n, alpha, x, incx, y, incy, a, lda)
  character*1 :: t
  integer :: n, incx, incy, lda
  complex(8), device, dimension(lda, *) :: a ! device or host variable
  complex(8), device, dimension(*) :: x, y ! device or host variable
  complex(8), device :: alpha ! device or host variable

subroutine cublasZsyr2(t, n, alpha, x, incx, y, incy, a, lda)
  character*1 :: t
  integer :: n, incx, incy, lda
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(*) :: x, y
  complex(8), device :: alpha ! device or host variable

integer(4) function cublasZsyr2_v2(h, t, n, alpha, x, incx, y, incy, a, lda)
  type(cublasHandle) :: h
  integer :: t
  integer :: n, incx, incy, lda
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(*) :: x, y
  complex(8), device :: alpha ! device or host variable

2.5.22. ztbmv

ZTBMV 执行矩阵-向量运算 x := A*x, 或 x := A**T*x, 或 x := A**H*x 之一，其中 x 是一个 n 元素向量，A 是一个 n 乘 n 单位或非单位上或下三角带状矩阵，具有 ( k + 1 ) 条对角线。

subroutine ztbmv(u, t, d, n, k, a, lda, x, incx)
  character*1 :: u, t, d
  integer :: n, k, incx, lda
  complex(8), device, dimension(lda, *) :: a ! device or host variable
  complex(8), device, dimension(*) :: x ! device or host variable

subroutine cublasZtbmv(u, t, d, n, k, a, lda, x, incx)
  character*1 :: u, t, d
  integer :: n, k, incx, lda
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(*) :: x

integer(4) function cublasZtbmv_v2(h, u, t, d, n, k, a, lda, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, k, incx, lda
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(*) :: x

2.5.23. ztbsv

ZTBSV 求解线性方程组 A*x = b, 或 A**T*x = b, 或 A**H*x = b 之一，其中 b 和 x 是 n 元素向量，A 是一个 n 乘 n 单位或非单位上或下三角带状矩阵，具有 ( k + 1 ) 条对角线。此例程中不包含奇异性或近奇异性测试。此类测试必须在调用此例程之前执行。

subroutine ztbsv(u, t, d, n, k, a, lda, x, incx)
  character*1 :: u, t, d
  integer :: n, k, incx, lda
  complex(8), device, dimension(lda, *) :: a ! device or host variable
  complex(8), device, dimension(*) :: x ! device or host variable

subroutine cublasZtbsv(u, t, d, n, k, a, lda, x, incx)
  character*1 :: u, t, d
  integer :: n, k, incx, lda
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(*) :: x

integer(4) function cublasZtbsv_v2(h, u, t, d, n, k, a, lda, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, k, incx, lda
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(*) :: x

2.5.24. ztpmv

ZTPMV 执行矩阵-向量运算 x := A*x, 或 x := A**T*x, 或 x := A**H*x 之一，其中 x 是一个 n 元素向量，A 是一个 n 乘 n 单位或非单位上或下三角矩阵，以压缩形式提供。

subroutine ztpmv(u, t, d, n, a, x, incx)
  character*1 :: u, t, d
  integer :: n, incx
  complex(8), device, dimension(*) :: a, x ! device or host variable

subroutine cublasZtpmv(u, t, d, n, a, x, incx)
  character*1 :: u, t, d
  integer :: n, incx
  complex(8), device, dimension(*) :: a, x

integer(4) function cublasZtpmv_v2(h, u, t, d, n, a, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, incx
  complex(8), device, dimension(*) :: a, x

2.5.25. ztpsv

ZTPSV 求解线性方程组 A*x = b, 或 A**T*x = b, 或 A**H*x = b 之一，其中 b 和 x 是 n 元素向量，A 是一个 n 乘 n 单位或非单位上或下三角矩阵，以压缩形式提供。此例程中不包含奇异性或近奇异性测试。此类测试必须在调用此例程之前执行。

subroutine ztpsv(u, t, d, n, a, x, incx)
  character*1 :: u, t, d
  integer :: n, incx
  complex(8), device, dimension(*) :: a, x ! device or host variable

subroutine cublasZtpsv(u, t, d, n, a, x, incx)
  character*1 :: u, t, d
  integer :: n, incx
  complex(8), device, dimension(*) :: a, x

integer(4) function cublasZtpsv_v2(h, u, t, d, n, a, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, incx
  complex(8), device, dimension(*) :: a, x

2.5.26. ztrmv

ZTRMV 执行矩阵-向量运算 x := A*x, 或 x := A**T*x, 或 x := A**H*x 之一，其中 x 是一个 n 元素向量，A 是一个 n 乘 n 单位或非单位上或下三角矩阵。

subroutine ztrmv(u, t, d, n, a, lda, x, incx)
  character*1 :: u, t, d
  integer :: n, incx, lda
  complex(8), device, dimension(lda, *) :: a ! device or host variable
  complex(8), device, dimension(*) :: x ! device or host variable

subroutine cublasZtrmv(u, t, d, n, a, lda, x, incx)
  character*1 :: u, t, d
  integer :: n, incx, lda
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(*) :: x

integer(4) function cublasZtrmv_v2(h, u, t, d, n, a, lda, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, incx, lda
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(*) :: x

2.5.27. ztrsv

ZTRSV 求解线性方程组 A*x = b, 或 A**T*x = b, 或 A**H*x = b 之一，其中 b 和 x 是 n 元素向量，A 是一个 n 乘 n 单位或非单位上或下三角矩阵。此例程中不包含奇异性或近奇异性测试。此类测试必须在调用此例程之前执行。

subroutine ztrsv(u, t, d, n, a, lda, x, incx)
  character*1 :: u, t, d
  integer :: n, incx, lda
  complex(8), device, dimension(lda, *) :: a ! device or host variable
  complex(8), device, dimension(*) :: x ! device or host variable

subroutine cublasZtrsv(u, t, d, n, a, lda, x, incx)
  character*1 :: u, t, d
  integer :: n, incx, lda
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(*) :: x

integer(4) function cublasZtrsv_v2(h, u, t, d, n, a, lda, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, incx, lda
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(*) :: x

2.5.28. zhbmv

ZHBMV 执行矩阵-向量运算 y := alpha*A*x + beta*y，其中 alpha 和 beta 是标量，x 和 y 是 n 元素向量，A 是一个 n 乘 n 埃尔米特带状矩阵，具有 k 条超对角线。

subroutine zhbmv(uplo, n, k, alpha, a, lda, x, incx, beta, y, incy)
  character*1 :: uplo
  integer :: k, n, lda, incx, incy
  complex(8), device, dimension(lda, *) :: a ! device or host variable
  complex(8), device, dimension(*) :: x, y ! device or host variable
  complex(8), device :: alpha, beta ! device or host variable

subroutine cublasZhbmv(uplo, n, k, alpha, a, lda, x, incx, beta, y, incy)
  character*1 :: uplo
  integer :: k, n, lda, incx, incy
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(*) :: x, y
  complex(8), device :: alpha, beta ! device or host variable

integer(4) function cublasZhbmv_v2(h, uplo, n, k, alpha, a, lda, x, incx, beta, y, incy)
  type(cublasHandle) :: h
  integer :: uplo
  integer :: k, n, lda, incx, incy
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(*) :: x, y
  complex(8), device :: alpha, beta ! device or host variable

2.5.29. zhemv

ZHEMV 执行矩阵-向量运算 y := alpha*A*x + beta*y，其中 alpha 和 beta 是标量，x 和 y 是 n 元素向量，A 是一个 n 乘 n 埃尔米特矩阵。

subroutine zhemv(uplo, n, alpha, a, lda, x, incx, beta, y, incy)
  character*1 :: uplo
  integer :: n, lda, incx, incy
  complex(8), device, dimension(lda, *) :: a ! device or host variable
  complex(8), device, dimension(*) :: x, y ! device or host variable
  complex(8), device :: alpha, beta ! device or host variable

subroutine cublasZhemv(uplo, n, alpha, a, lda, x, incx, beta, y, incy)
  character*1 :: uplo
  integer :: n, lda, incx, incy
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(*) :: x, y
  complex(8), device :: alpha, beta ! device or host variable

integer(4) function cublasZhemv_v2(h, uplo, n, alpha, a, lda, x, incx, beta, y, incy)
  type(cublasHandle) :: h
  integer :: uplo
  integer :: n, lda, incx, incy
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(*) :: x, y
  complex(8), device :: alpha, beta ! device or host variable

2.5.30. zhpmv

ZHPMV 执行矩阵-向量运算 y := alpha*A*x + beta*y，其中 alpha 和 beta 是标量，x 和 y 是 n 元素向量，A 是一个 n 乘 n 埃尔米特矩阵，以压缩形式提供。

subroutine zhpmv(uplo, n, alpha, a, x, incx, beta, y, incy)
  character*1 :: uplo
  integer :: n, incx, incy
  complex(8), device, dimension(*) :: a, x, y ! device or host variable
  complex(8), device :: alpha, beta ! device or host variable

subroutine cublasZhpmv(uplo, n, alpha, a, x, incx, beta, y, incy)
  character*1 :: uplo
  integer :: n, incx, incy
  complex(8), device, dimension(*) :: a, x, y
  complex(8), device :: alpha, beta ! device or host variable

integer(4) function cublasZhpmv_v2(h, uplo, n, alpha, a, x, incx, beta, y, incy)
  type(cublasHandle) :: h
  integer :: uplo
  integer :: n, incx, incy
  complex(8), device, dimension(*) :: a, x, y
  complex(8), device :: alpha, beta ! device or host variable

2.5.31. zher

ZHER 执行埃尔米特秩 1 运算 A := alpha*x*x**H + A，其中 alpha 是一个实标量，x 是一个 n 元素向量，A 是一个 n 乘 n 埃尔米特矩阵。

subroutine zher(t, n, alpha, x, incx, a, lda)
  character*1 :: t
  integer :: n, incx, lda
  complex(8), device, dimension(*) :: a, x ! device or host variable
  real(8), device :: alpha ! device or host variable

subroutine cublasZher(t, n, alpha, x, incx, a, lda)
  character*1 :: t
  integer :: n, incx, lda
  complex(8), device, dimension(*) :: a, x
  real(8), device :: alpha ! device or host variable

integer(4) function cublasZher_v2(h, t, n, alpha, x, incx, a, lda)
  type(cublasHandle) :: h
  integer :: t
  integer :: n, incx, lda
  complex(8), device, dimension(*) :: a, x
  real(8), device :: alpha ! device or host variable

2.5.32. zher2

ZHER2 执行埃尔米特秩 2 运算 A := alpha*x*y**H + conjg( alpha )*y*x**H + A，其中 alpha 是一个标量，x 和 y 是 n 元素向量，A 是一个 n 乘 n 埃尔米特矩阵。

subroutine zher2(t, n, alpha, x, incx, y, incy, a, lda)
  character*1 :: t
  integer :: n, incx, incy
  complex(8), device, dimension(*) :: a, x, y ! device or host variable
  complex(8), device :: alpha ! device or host variable

subroutine cublasZher2(t, n, alpha, x, incx, y, incy, a, lda)
  character*1 :: t
  integer :: n, incx, incy, lda
  complex(8), device, dimension(*) :: a, x, y
  complex(8), device :: alpha ! device or host variable

integer(4) function cublasZher2_v2(h, t, n, alpha, x, incx, y, incy, a, lda)
  type(cublasHandle) :: h
  integer :: t
  integer :: n, incx, incy, lda
  complex(8), device, dimension(*) :: a, x, y
  complex(8), device :: alpha ! device or host variable

2.5.33. zhpr

ZHPR 执行埃尔米特秩 1 运算 A := alpha*x*x**H + A，其中 alpha 是一个实标量，x 是一个 n 元素向量，A 是一个 n 乘 n 埃尔米特矩阵，以压缩形式提供。

subroutine zhpr(t, n, alpha, x, incx, a)
  character*1 :: t
  integer :: n, incx
  complex(8), device, dimension(*) :: a, x ! device or host variable
  real(8), device :: alpha ! device or host variable

subroutine cublasZhpr(t, n, alpha, x, incx, a)
  character*1 :: t
  integer :: n, incx
  complex(8), device, dimension(*) :: a, x
  real(8), device :: alpha ! device or host variable

integer(4) function cublasZhpr_v2(h, t, n, alpha, x, incx, a)
  type(cublasHandle) :: h
  integer :: t
  integer :: n, incx
  complex(8), device, dimension(*) :: a, x
  real(8), device :: alpha ! device or host variable

2.5.34. zhpr2

ZHPR2 执行埃尔米特秩 2 运算 A := alpha*x*y**H + conjg( alpha )*y*x**H + A，其中 alpha 是一个标量，x 和 y 是 n 元素向量，A 是一个 n 乘 n 埃尔米特矩阵，以压缩形式提供。

subroutine zhpr2(t, n, alpha, x, incx, y, incy, a)
  character*1 :: t
  integer :: n, incx, incy
  complex(8), device, dimension(*) :: a, x, y ! device or host variable
  complex(8), device :: alpha ! device or host variable

subroutine cublasZhpr2(t, n, alpha, x, incx, y, incy, a)
  character*1 :: t
  integer :: n, incx, incy
  complex(8), device, dimension(*) :: a, x, y
  complex(8), device :: alpha ! device or host variable

integer(4) function cublasZhpr2_v2(h, t, n, alpha, x, incx, y, incy, a)
  type(cublasHandle) :: h
  integer :: t
  integer :: n, incx, incy
  complex(8), device, dimension(*) :: a, x, y
  complex(8), device :: alpha ! device or host variable

2.5.35. zgemm

ZGEMM 执行矩阵-矩阵运算 C := alpha*op( A )*op( B ) + beta*C 之一，其中 op( X ) 是 op( X ) = X 或 op( X ) = X**T 或 op( X ) = X**H 之一，alpha 和 beta 是标量，A、B 和 C 是矩阵，其中 op( A ) 是一个 m 乘 k 矩阵，op( B ) 是一个 k 乘 n 矩阵，C 是一个 m 乘 n 矩阵。

subroutine zgemm(transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  character*1 :: transa, transb
  integer :: m, n, k, lda, ldb, ldc
  complex(8), device, dimension(lda, *) :: a ! device or host variable
  complex(8), device, dimension(ldb, *) :: b ! device or host variable
  complex(8), device, dimension(ldc, *) :: c ! device or host variable
  complex(8), device :: alpha, beta ! device or host variable

subroutine cublasZgemm(transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  character*1 :: transa, transb
  integer :: m, n, k, lda, ldb, ldc
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(ldb, *) :: b
  complex(8), device, dimension(ldc, *) :: c
  complex(8), device :: alpha, beta ! device or host variable

integer(4) function cublasZgemm_v2(h, transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: transa, transb
  integer :: m, n, k, lda, ldb, ldc
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(ldb, *) :: b
  complex(8), device, dimension(ldc, *) :: c
  complex(8), device :: alpha, beta ! device or host variable

2.5.36. zsymm

ZSYMM 执行矩阵-矩阵运算 C := alpha*A*B + beta*C 或 C := alpha*B*A + beta*C 之一，其中 alpha 和 beta 是标量，A 是一个对称矩阵，B 和 C 是 m 乘 n 矩阵。

subroutine zsymm(side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc)
  character*1 :: side, uplo
  integer :: m, n, lda, ldb, ldc
  complex(8), device, dimension(lda, *) :: a ! device or host variable
  complex(8), device, dimension(ldb, *) :: b ! device or host variable
  complex(8), device, dimension(ldc, *) :: c ! device or host variable
  complex(8), device :: alpha, beta ! device or host variable

subroutine cublasZsymm(side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc)
  character*1 :: side, uplo
  integer :: m, n, lda, ldb, ldc
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(ldb, *) :: b
  complex(8), device, dimension(ldc, *) :: c
  complex(8), device :: alpha, beta ! device or host variable

integer(4) function cublasZsymm_v2(h, side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: side, uplo
  integer :: m, n, lda, ldb, ldc
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(ldb, *) :: b
  complex(8), device, dimension(ldc, *) :: c
  complex(8), device :: alpha, beta ! device or host variable

2.5.37. zsyrk

ZSYRK 执行对称秩 k 运算 C := alpha*A*A**T + beta*C 或 C := alpha*A**T*A + beta*C 之一，其中 alpha 和 beta 是标量，C 是一个 n 乘 n 对称矩阵，A 在第一种情况下是一个 n 乘 k 矩阵，在第二种情况下是一个 k 乘 n 矩阵。

subroutine zsyrk(uplo, trans, n, k, alpha, a, lda, beta, c, ldc)
  character*1 :: uplo, trans
  integer :: n, k, lda, ldc
  complex(8), device, dimension(lda, *) :: a ! device or host variable
  complex(8), device, dimension(ldc, *) :: c ! device or host variable
  complex(8), device :: alpha, beta ! device or host variable

subroutine cublasZsyrk(uplo, trans, n, k, alpha, a, lda, beta, c, ldc)
  character*1 :: uplo, trans
  integer :: n, k, lda, ldc
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(ldc, *) :: c
  complex(8), device :: alpha, beta ! device or host variable

integer(4) function cublasZsyrk_v2(h, uplo, trans, n, k, alpha, a, lda, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: uplo, trans
  integer :: n, k, lda, ldc
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(ldc, *) :: c
  complex(8), device :: alpha, beta ! device or host variable

2.5.38. zsyr2k

ZSYR2K 执行对称秩 2k 运算 C := alpha*A*B**T + alpha*B*A**T + beta*C 或 C := alpha*A**T*B + alpha*B**T*A + beta*C 之一，其中 alpha 和 beta 是标量，C 是一个 n 乘 n 对称矩阵，A 和 B 在第一种情况下是 n 乘 k 矩阵，在第二种情况下是 k 乘 n 矩阵。

subroutine zsyr2k(uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  character*1 :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  complex(8), device, dimension(lda, *) :: a ! device or host variable
  complex(8), device, dimension(ldb, *) :: b ! device or host variable
  complex(8), device, dimension(ldc, *) :: c ! device or host variable
  complex(8), device :: alpha, beta ! device or host variable

subroutine cublasZsyr2k(uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  character*1 :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(ldb, *) :: b
  complex(8), device, dimension(ldc, *) :: c
  complex(8), device :: alpha, beta ! device or host variable

integer(4) function cublasZsyr2k_v2(h, uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(ldb, *) :: b
  complex(8), device, dimension(ldc, *) :: c
  complex(8), device :: alpha, beta ! device or host variable

2.5.39. zsyrkx

ZSYRKX 执行对称秩 k 更新 C := alpha*A*B**T + beta*C 的变体，其中 alpha 和 beta 是标量，C 是一个以 lower 或 upper 模式存储的 n 乘 n 对称矩阵，A 和 B 是 n 乘 k 矩阵。当 B 以某种方式使得结果保证对称时，可以使用此例程。有关更多详细信息，请参阅 CUBLAS 文档。

subroutine zsyrkx(uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  character*1 :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  complex(8), device, dimension(lda, *) :: a ! device or host variable
  complex(8), device, dimension(ldb, *) :: b ! device or host variable
  complex(8), device, dimension(ldc, *) :: c ! device or host variable
  complex(8), device :: alpha, beta ! device or host variable

subroutine cublasZsyrkx(uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  character*1 :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(ldb, *) :: b
  complex(8), device, dimension(ldc, *) :: c
  complex(8), device :: alpha, beta ! device or host variable

integer(4) function cublasZsyrkx_v2(h, uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(ldb, *) :: b
  complex(8), device, dimension(ldc, *) :: c
  complex(8), device :: alpha, beta ! device or host variable

2.5.40. ztrmm

ZTRMM 执行矩阵-矩阵运算 B := alpha*op( A )*B 或 B := alpha*B*op( A ) 之一，其中 alpha 是一个标量，B 是一个 m 乘 n 矩阵，A 是一个单位或非单位上或下三角矩阵，op( A ) 是 op( A ) = A 或 op( A ) = A**T 或 op( A ) = A**H 之一。

subroutine ztrmm(side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)
  character*1 :: side, uplo, transa, diag
  integer :: m, n, lda, ldb
  complex(8), device, dimension(lda, *) :: a ! device or host variable
  complex(8), device, dimension(ldb, *) :: b ! device or host variable
  complex(8), device :: alpha ! device or host variable

subroutine cublasZtrmm(side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)
  character*1 :: side, uplo, transa, diag
  integer :: m, n, lda, ldb
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(ldb, *) :: b
  complex(8), device :: alpha ! device or host variable

integer(4) function cublasZtrmm_v2(h, side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb, c, ldc)
  type(cublasHandle) :: h
  integer :: side, uplo, transa, diag
  integer :: m, n, lda, ldb, ldc
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(ldb, *) :: b
  complex(8), device, dimension(ldc, *) :: c
  complex(8), device :: alpha ! device or host variable

2.5.41. ztrsm

ZTRSM 求解矩阵方程 op( A )*X = alpha*B 或 X*op( A ) = alpha*B 之一，其中 alpha 是一个标量，X 和 B 是 m 乘 n 矩阵，A 是一个单位或非单位上或下三角矩阵，op( A ) 是 op( A ) = A 或 op( A ) = A**T 或 op( A ) = A**H 之一。矩阵 X 在 B 上被覆盖。

subroutine ztrsm(side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)
  character*1 :: side, uplo, transa, diag
  integer :: m, n, lda, ldb
  complex(8), device, dimension(lda, *) :: a ! device or host variable
  complex(8), device, dimension(ldb, *) :: b ! device or host variable
  complex(8), device :: alpha ! device or host variable

subroutine cublasZtrsm(side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)
  character*1 :: side, uplo, transa, diag
  integer :: m, n, lda, ldb
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(ldb, *) :: b
  complex(8), device :: alpha ! device or host variable

integer(4) function cublasZtrsm_v2(h, side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)
  type(cublasHandle) :: h
  integer :: side, uplo, transa, diag
  integer :: m, n, lda, ldb
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(ldb, *) :: b
  complex(8), device :: alpha ! device or host variable

2.5.42. zhemm

ZHEMM 执行矩阵-矩阵运算 C := alpha*A*B + beta*C 或 C := alpha*B*A + beta*C 之一，其中 alpha 和 beta 是标量，A 是一个埃尔米特矩阵，B 和 C 是 m 乘 n 矩阵。

subroutine zhemm(side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc)
  character*1 :: side, uplo
  integer :: m, n, lda, ldb, ldc
  complex(8), device, dimension(lda, *) :: a ! device or host variable
  complex(8), device, dimension(ldb, *) :: b ! device or host variable
  complex(8), device, dimension(ldc, *) :: c ! device or host variable
  complex(8), device :: alpha, beta ! device or host variable

subroutine cublasZhemm(side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc)
  character*1 :: side, uplo
  integer :: m, n, lda, ldb, ldc
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(ldb, *) :: b
  complex(8), device, dimension(ldc, *) :: c
  complex(8), device :: alpha, beta ! device or host variable

integer(4) function cublasZhemm_v2(h, side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: side, uplo
  integer :: m, n, lda, ldb, ldc
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(ldb, *) :: b
  complex(8), device, dimension(ldc, *) :: c
  complex(8), device :: alpha, beta ! device or host variable

2.5.43. zherk

ZHERK 执行埃尔米特秩 k 运算 C := alpha*A*A**H + beta*C 或 C := alpha*A**H*A + beta*C 之一，其中 alpha 和 beta 是实标量，C 是一个 n 乘 n 埃尔米特矩阵，A 在第一种情况下是一个 n 乘 k 矩阵，在第二种情况下是一个 k 乘 n 矩阵。

subroutine zherk(uplo, trans, n, k, alpha, a, lda, beta, c, ldc)
  character*1 :: uplo, trans
  integer :: n, k, lda, ldc
  complex(8), device, dimension(lda, *) :: a ! device or host variable
  complex(8), device, dimension(ldc, *) :: c ! device or host variable
  real(8), device :: alpha, beta ! device or host variable

subroutine cublasZherk(uplo, trans, n, k, alpha, a, lda, beta, c, ldc)
  character*1 :: uplo, trans
  integer :: n, k, lda, ldc
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(ldc, *) :: c
  real(8), device :: alpha, beta ! device or host variable

integer(4) function cublasZherk_v2(h, uplo, trans, n, k, alpha, a, lda, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: uplo, trans
  integer :: n, k, lda, ldc
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(ldc, *) :: c
  real(8), device :: alpha, beta ! device or host variable

2.5.44. zher2k

ZHER2K 执行埃尔米特秩 2k 运算 C := alpha*A*B**H + conjg( alpha )*B*A**H + beta*C 或 C := alpha*A**H*B + conjg( alpha )*B**H*A + beta*C 之一，其中 alpha 和 beta 是标量，beta 是实数，C 是一个 n 乘 n 埃尔米特矩阵，A 和 B 在第一种情况下是 n 乘 k 矩阵，在第二种情况下是 k 乘 n 矩阵。

subroutine zher2k(uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  character*1 :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  complex(8), device, dimension(lda, *) :: a ! device or host variable
  complex(8), device, dimension(ldb, *) :: b ! device or host variable
  complex(8), device, dimension(ldc, *) :: c ! device or host variable
  complex(8), device :: alpha ! device or host variable
  real(8), device :: beta ! device or host variable

subroutine cublasZher2k(uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  character*1 :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(ldb, *) :: b
  complex(8), device, dimension(ldc, *) :: c
  complex(8), device :: alpha ! device or host variable
  real(8), device :: beta ! device or host variable

integer(4) function cublasZher2k_v2(h, uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(ldb, *) :: b
  complex(8), device, dimension(ldc, *) :: c
  complex(8), device :: alpha ! device or host variable
  real(8), device :: beta ! device or host variable

2.5.45. zherkx

ZHERKX 执行埃尔米特秩 k 运算 C := alpha*A*B**H + beta*C 的变体，其中 alpha 和 beta 是实标量，C 是一个以 lower 或 upper 模式存储的 n 乘 n 埃尔米特矩阵，A 和 B 是 n 乘 k 矩阵。有关更多详细信息，请参阅 CUBLAS 文档。

subroutine zherkx(uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  character*1 :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  complex(8), device, dimension(lda, *) :: a ! device or host variable
  complex(8), device, dimension(ldb, *) :: b ! device or host variable
  complex(8), device, dimension(ldc, *) :: c ! device or host variable
  complex(8), device :: alpha ! device or host variable
  real(8), device :: beta ! device or host variable

subroutine cublasZherkx(uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  character*1 :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(ldb, *) :: b
  complex(8), device, dimension(ldc, *) :: c
  complex(8), device :: alpha ! device or host variable
  real(8), device :: beta ! device or host variable

integer(4) function cublasZherkx_v2(h, uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(ldb, *) :: b
  complex(8), device, dimension(ldc, *) :: c
  complex(8), device :: alpha ! device or host variable
  real(8), device :: beta ! device or host variable

2.5.46. cublasZgemvBatched

ZGEMV 执行批量矩阵-向量运算 Y := alpha*op( A ) * X + beta*Y，其中 op( A ) 是 op( A ) = A 或 op( A ) = A**T 之一，alpha 和 beta 是标量，A 是一个 m 乘 n 矩阵，X 和 Y 是向量。

integer(4) function cublasZgemvBatched(h, trans, m, n, alpha, &
      Aarray, lda, xarray, incx, beta, yarray, incy, batchCount)
  type(cublasHandle) :: h
  integer :: trans ! integer or character(1) variable
  integer :: m, n
  complex(8), device :: alpha ! device or host variable
  type(c_devptr), device :: Aarray(*)
  integer :: lda
  type(c_devptr), device :: xarray(*)
  integer :: incx
  complex(8), device :: beta ! device or host variable
  type(c_devptr), device :: yarray(*)
  integer :: incy
  integer :: batchCount

integer(4) function cublasZgemvBatched_v2(h, trans, m, n, alpha, &
      Aarray, lda, xarray, incx, beta, yarray, incy, batchCount)
  type(cublasHandle) :: h
  integer :: trans
  integer :: m, n
  complex(8), device :: alpha ! device or host variable
  type(c_devptr), device :: Aarray(*)
  integer :: lda
  type(c_devptr), device :: xarray(*)
  integer :: incx
  complex(8), device :: beta ! device or host variable
  type(c_devptr), device :: yarray(*)
  integer :: incy
  integer :: batchCount

2.5.47. cublasZgemmBatched

ZGEMM 执行矩阵-矩阵运算 C := alpha*op( A )*op( B ) + beta*C 之一，其中 op( X ) 是 op( X ) = X 或 op( X ) = X**T 或 op( X ) = X**H 之一，alpha 和 beta 是标量，A、B 和 C 是矩阵，其中 op( A ) 是一个 m 乘 k 矩阵，op( B ) 是一个 k 乘 n 矩阵，C 是一个 m 乘 n 矩阵。

integer(4) function cublasZgemmBatched(h, transa, transb, m, n, k, alpha, Aarray, lda, Barray, ldb, beta, Carray, ldc, batchCount)
  type(cublasHandle) :: h
  integer :: transa ! integer or character(1) variable
  integer :: transb ! integer or character(1) variable
  integer :: m, n, k
  complex(8), device :: alpha ! device or host variable
  type(c_devptr), device :: Aarray(*)
  integer :: lda
  type(c_devptr), device :: Barray(*)
  integer :: ldb
  complex(8), device :: beta ! device or host variable
  type(c_devptr), device :: Carray(*)
  integer :: ldc
  integer :: batchCount

integer(4) function cublasZgemmBatched_v2(h, transa, transb, m, n, k, alpha, &
           Aarray, lda, Barray, ldb, beta, Carray, ldc, batchCount)
  type(cublasHandle) :: h
  integer :: transa
  integer :: transb
  integer :: m, n, k
  complex(8), device :: alpha ! device or host variable
  type(c_devptr), device :: Aarray(*)
  integer :: lda
  type(c_devptr), device :: Barray(*)
  integer :: ldb
  complex(8), device :: beta ! device or host variable
  type(c_devptr), device :: Carray(*)
  integer :: ldc
  integer :: batchCount

2.5.48. cublasZgelsBatched

ZGELS 使用 A 的 QR 或 LQ 分解，求解涉及 M 乘 N 矩阵 A 或其共轭转置的超定或欠定复线性系统。假设 A 具有满秩。提供以下选项：1. 如果 TRANS = ‘N’ 且 m >= n：找到超定系统的最小二乘解，即，求解最小二乘问题 minimize || B - A*X ||。2. 如果 TRANS = ‘N’ 且 m < n：找到欠定系统 A * X = B 的最小范数解。3. 如果 TRANS = ‘C’ 且 m >= n：找到欠定系统 A**H * X = B 的最小范数解。4. 如果 TRANS = ‘C’ 且 m < n：找到超定系统的最小二乘解，即，求解最小二乘问题 minimize || B - A**H * X ||。可以在单个调用中处理多个右手边向量 b 和解向量 x；它们存储为 M 乘 NRHS 右手边矩阵 B 和 N 乘 NRHS 解矩阵 X 的列。

integer(4) function cublasZgelsBatched(h, trans, m, n, nrhs, Aarray, lda, Carray, ldc, info, devinfo, batchCount)
  type(cublasHandle) :: h
  integer :: trans ! integer or character(1) variable
  integer :: m, n, nrhs
  type(c_devptr), device :: Aarray(*)
  integer :: lda
  type(c_devptr), device :: Carray(*)
  integer :: ldc
  integer :: info(*)
  integer, device :: devinfo(*)
  integer :: batchCount

2.5.49. cublasZgeqrfBatched

ZGEQRF 计算复数 M 乘 N 矩阵 A 的 QR 分解：A = Q * R。

integer(4) function cublasZgeqrfBatched(h, m, n, Aarray, lda, Tau, info, batchCount)
  type(cublasHandle) :: h
  integer :: m, n
  type(c_devptr), device :: Aarray(*)
  integer :: lda
  type(c_devptr), device :: Tau(*)
  integer :: info(*)
  integer :: batchCount

2.5.50. cublasZgetrfBatched

ZGETRF 使用行交换的部分主元法计算一般 M 乘 N 矩阵 A 的 LU 分解。分解形式为 A = P * L * U，其中 P 是置换矩阵，L 是具有单位对角线元素的下三角矩阵（如果 m > n，则为下梯形矩阵），U 是上三角矩阵（如果 m < n，则为上梯形矩阵）。这是算法的 right-looking Level 3 BLAS 版本。

integer(4) function cublasZgetrfBatched(h, n, Aarray, lda, ipvt, info, batchCount)
  type(cublasHandle) :: h
  integer :: n
  type(c_devptr), device :: Aarray(*)
  integer :: lda
  integer, device :: ipvt(*)
  integer, device :: info(*)
  integer :: batchCount

2.5.51. cublasZgetriBatched

ZGETRI 使用 ZGETRF 计算的 LU 分解来计算矩阵的逆矩阵。此方法反转 U，然后通过求解方程组 inv(A)*L = inv(U) 来计算 inv(A)。

integer(4) function cublasZgetriBatched(h, n, Aarray, lda, ipvt, Carray, ldc, info, batchCount)
  type(cublasHandle) :: h
  integer :: n
  type(c_devptr), device :: Aarray(*)
  integer :: lda
  integer, device :: ipvt(*)
  type(c_devptr), device :: Carray(*)
  integer :: ldc
  integer, device :: info(*)
  integer :: batchCount

2.5.52. cublasZgetrsBatched

ZGETRS 使用 ZGETRF 计算的 LU 分解，求解具有一般 N 乘 N 矩阵 A 的线性方程组 A * X = B、A**T * X = B 或 A**H * X = B。

integer(4) function cublasZgetrsBatched(h, trans, n, nrhs, Aarray, lda, ipvt, Barray, ldb, info, batchCount)
  type(cublasHandle) :: h
  integer :: trans ! integer or character(1) variable
  integer :: n, nrhs
  type(c_devptr), device :: Aarray(*)
  integer :: lda
  integer, device :: ipvt(*)
  type(c_devptr), device :: Barray(*)
  integer :: ldb
  integer :: info(*)
  integer :: batchCount

2.5.53. cublasZmatinvBatched

cublasZmatinvBatched 是 cublasZgetrfBatched 加 cublasZgetriBatched 的快捷方式。但是，它仅在 n 小于 32 时有效。否则，用户必须使用 cublasZgetrfBatched 和 cublasZgetriBatched。

integer(4) function cublasZmatinvBatched(h, n, Aarray, lda, Ainv, lda_inv, info, batchCount)
  type(cublasHandle) :: h
  integer :: n
  type(c_devptr), device :: Aarray(*)
  integer :: lda
  type(c_devptr), device :: Ainv(*)
  integer :: lda_inv
  integer, device :: info(*)
  integer :: batchCount

2.5.54. cublasZtrsmBatched

ZTRSM 求解矩阵方程 op( A )*X = alpha*B 或 X*op( A ) = alpha*B 之一，其中 alpha 是一个标量，X 和 B 是 m 乘 n 矩阵，A 是一个单位或非单位上或下三角矩阵，op( A ) 是 op( A ) = A 或 op( A ) = A**T 或 op( A ) = A**H 之一。矩阵 X 在 B 上被覆盖。

integer(4) function cublasZtrsmBatched( h, side, uplo, trans, diag, m, n, alpha, A, lda, B, ldb, batchCount)
  type(cublasHandle) :: h
  integer :: side ! integer or character(1) variable
  integer :: uplo ! integer or character(1) variable
  integer :: trans ! integer or character(1) variable
  integer :: diag ! integer or character(1) variable
  integer :: m, n
  complex(8), device :: alpha ! device or host variable
  type(c_devptr), device :: A(*)
  integer :: lda
  type(c_devptr), device :: B(*)
  integer :: ldb
  integer :: batchCount

integer(4) function cublasZtrsmBatched_v2( h, side, uplo, trans, diag, m, n, alpha, A, lda, B, ldb, batchCount)
  type(cublasHandle) :: h
  integer :: side
  integer :: uplo
  integer :: trans
  integer :: diag
  integer :: m, n
  complex(8), device :: alpha ! device or host variable
  type(c_devptr), device :: A(*)
  integer :: lda
  type(c_devptr), device :: B(*)
  integer :: ldb
  integer :: batchCount

2.5.55. cublasZgemvStridedBatched

ZGEMV 执行批量矩阵-向量运算 Y := alpha*op( A ) * X + beta*Y，其中 op( A ) 是 op( A ) = A 或 op( A ) = A**T 之一，alpha 和 beta 是标量，A 是一个 m 乘 n 矩阵，X 和 Y 是向量。

integer(4) function cublasZgemvStridedBatched(h, trans, m, n, alpha, &
      A, lda, strideA, X, incx, strideX, beta, Y, incy, strideY, batchCount)
  type(cublasHandle) :: h
  integer :: trans ! integer or character(1) variable
  integer :: m, n
  complex(8), device :: alpha ! device or host variable
  complex(8), device :: A(lda,*)
  integer :: lda
  integer(8) :: strideA
  complex(8), device :: X(*)
  integer :: incx
  integer(8) :: strideX
  complex(8), device :: beta ! device or host variable
  complex(8), device :: Y(*)
  integer :: incy
  integer(8) :: strideY
  integer :: batchCount

integer(4) function cublasZgemvStridedBatched_v2(h, trans, m, n, alpha, &
      A, lda, strideA, X, incx, strideX, beta, Y, incy, strideY, batchCount)
  type(cublasHandle) :: h
  integer :: trans
  integer :: m, n
  complex(8), device :: alpha ! device or host variable
  complex(8), device :: A(lda,*)
  integer :: lda
  integer(8) :: strideA
  complex(8), device :: X(*)
  integer :: incx
  integer(8) :: strideX
  complex(8), device :: beta ! device or host variable
  complex(8), device :: Y(*)
  integer :: incy
  integer(8) :: strideY
  integer :: batchCount

2.5.56. cublasZgemmStridedBatched

ZGEMM 执行矩阵-矩阵运算 C := alpha*op( A )*op( B ) + beta*C 之一，其中 op( X ) 是 op( X ) = X 或 op( X ) = X**T 之一，alpha 和 beta 是标量，而 A、B 和 C 是矩阵，其中 op( A ) 是 m 乘 k 矩阵，op( B ) 是 k 乘 n 矩阵，C 是 m 乘 n 矩阵。

integer(4) function cublasZgemmStridedBatched(h, transa, transb, m, n, k, alpha, Aarray, lda, strideA, Barray, ldb, strideB, beta, Carray, ldc, strideC, batchCount)
  type(cublasHandle) :: h
  integer :: transa ! integer or character(1) variable
  integer :: transb ! integer or character(1) variable
  integer :: m, n, k
  complex(8), device :: alpha ! device or host variable
  complex(8), device :: Aarray(*)
  integer :: lda
  integer :: strideA
  complex(8), device :: Barray(*)
  integer :: ldb
  integer :: strideB
  complex(8), device :: beta ! device or host variable
  complex(8), device :: Carray(*)
  integer :: ldc
  integer :: strideC
  integer :: batchCount

integer(4) function cublasZgemmStridedBatched_v2(h, transa, transb, m, n, k, alpha, &
           Aarray, lda, strideA, Barray, ldb, strideB, beta, Carray, ldc, strideC, batchCount)
  type(cublasHandle) :: h
  integer :: transa
  integer :: transb
  integer :: m, n, k
  complex(8), device :: alpha ! device or host variable
  complex(8), device :: Aarray(*)
  integer :: lda
  integer :: strideA
  complex(8), device :: Barray(*)
  integer :: ldb
  integer :: strideB
  complex(8), device :: beta ! device or host variable
  complex(8), device :: Carray(*)
  integer :: ldc
  integer :: strideC
  integer :: batchCount

2.6. 半精度函数和扩展函数

本节包含半精度 cuBLAS 函数和 BLAS 扩展函数的接口，这些接口允许用户单独指定数组和计算的类型（其中许多或全部支持半精度）。

扩展函数可以接受多种支持的数据类型之一。用户应始终查看最新的 cuBLAS 文档以了解支持的组合。在本文档中，我们将使用 real(2) 数据类型，因为这些函数不受库中 S, D, C, 和 Z 变体的其他支持。此外，用户有责任通过调用 cublasSetPointerMode 为所有扩展函数正确设置指针模式。

type(cudaDataType) 现在是本文档中介绍的几个较新的库函数通用的。尽管某些函数会接受适当值的整数，但现在建议将来使用 type(cudaDataType)。

2.6.1. cublasHgemvBatched

HGEMV 执行批量矩阵-向量运算 Y := alpha*op( A ) * X + beta*Y，其中 op( A ) 是 op( A ) = A 或 op( A ) = A**T 之一，alpha 和 beta 是标量，A 是 m 乘 n 矩阵，而 X 和 Y 是向量。

在 HSH 版本中，alpha, beta 是 real(4)，并且指向的数组都应包含 real(2) 数据。

integer(4) function cublasHSHgemvBatched(h, trans, m, n, alpha, &
      Aarray, lda, xarray, incx, beta, yarray, incy, batchCount)
  type(cublasHandle) :: h
  integer :: trans ! integer or character(1) variable
  integer :: m, n
  real(4), device :: alpha ! device or host variable
  type(c_devptr), device :: Aarray(*)
  integer :: lda
  type(c_devptr), device :: xarray(*)
  integer :: incx
  real(4), device :: beta ! device or host variable
  type(c_devptr), device :: yarray(*)
  integer :: incy
  integer :: batchCount

integer(4) function cublasHSHgemvBatched_v2(h, trans, m, n, alpha, &
      Aarray, lda, xarray, incx, beta, yarray, incy, batchCount)
  type(cublasHandle) :: h
  integer :: trans
  integer :: m, n
  real(4), device :: alpha ! device or host variable
  type(c_devptr), device :: Aarray(*)
  integer :: lda
  type(c_devptr), device :: xarray(*)
  integer :: incx
  real(4), device :: beta ! device or host variable
  type(c_devptr), device :: yarray(*)
  integer :: incy
  integer :: batchCount

在 HSS 版本中，alpha, beta 是 real(4)，指向的 Aarray, xarray 数组应包含 real(2) 数据，而 yarray 应包含 real(4) 数据。

integer(4) function cublasHSSgemvBatched(h, trans, m, n, alpha, &
      Aarray, lda, xarray, incx, beta, yarray, incy, batchCount)
  type(cublasHandle) :: h
  integer :: trans ! integer or character(1) variable
  integer :: m, n
  real(4), device :: alpha ! device or host variable
  type(c_devptr), device :: Aarray(*)
  integer :: lda
  type(c_devptr), device :: xarray(*)
  integer :: incx
  real(4), device :: beta ! device or host variable
  type(c_devptr), device :: yarray(*)
  integer :: incy
  integer :: batchCount

integer(4) function cublasHSSgemvBatched_v2(h, trans, m, n, alpha, &
      Aarray, lda, xarray, incx, beta, yarray, incy, batchCount)
  type(cublasHandle) :: h
  integer :: trans
  integer :: m, n
  real(4), device :: alpha ! device or host variable
  type(c_devptr), device :: Aarray(*)
  integer :: lda
  type(c_devptr), device :: xarray(*)
  integer :: incx
  real(4), device :: beta ! device or host variable
  type(c_devptr), device :: yarray(*)
  integer :: incy
  integer :: batchCount

2.6.2. cublasHgemvStridedBatched

HGEMV 执行批量矩阵-向量运算 Y := alpha*op( A ) * X + beta*Y，其中 op( A ) 是 op( A ) = A 或 op( A ) = A**T 之一，alpha 和 beta 是标量，A 是 m 乘 n 矩阵，而 X 和 Y 是向量。

在 HSH 版本中，alpha, beta 是 real(4)，并且数组 A, X, Y 都是 real(2) 数据。

integer(4) function cublasHSHgemvStridedBatched(h, trans, m, n, alpha, &
      A, lda, strideA, X, incx, strideX, beta, Y, incy, strideY, batchCount)
  type(cublasHandle) :: h
  integer :: trans ! integer or character(1) variable
  integer :: m, n
  real(4), device :: alpha ! device or host variable
  real(2), device :: A(lda,*)
  integer :: lda
  integer(8) :: strideA
  real(2), device :: X(*)
  integer :: incx
  integer(8) :: strideX
  real(4), device :: beta ! device or host variable
  real(2), device :: Y(*)
  integer :: incy
  integer(8) :: strideY
  integer :: batchCount

integer(4) function cublasHSHgemvStridedBatched_v2(h, trans, m, n, alpha, &
      A, lda, strideA, X, incx, strideX, beta, Y, incy, strideY, batchCount)
  type(cublasHandle) :: h
  integer :: trans
  integer :: m, n
  real(4), device :: alpha ! device or host variable
  real(2), device :: A(lda,*)
  integer :: lda
  integer(8) :: strideA
  real(2), device :: X(*)
  integer :: incx
  integer(8) :: strideX
  real(4), device :: beta ! device or host variable
  real(2), device :: Y(*)
  integer :: incy
  integer(8) :: strideY
  integer :: batchCount

在 HSS 版本中，alpha, beta 是 real(4)，A, X 数组包含 real(2) 数据，而 Y 数组包含 real(4) 数据。

integer(4) function cublasHSSgemvStridedBatched(h, trans, m, n, alpha, &
      A, lda, strideA, X, incx, strideX, beta, Y, incy, strideY, batchCount)
  type(cublasHandle) :: h
  integer :: trans ! integer or character(1) variable
  integer :: m, n
  real(4), device :: alpha ! device or host variable
  real(2), device :: A(lda,*)
  integer :: lda
  integer(8) :: strideA
  real(2), device :: X(*)
  integer :: incx
  integer(8) :: strideX
  real(4), device :: beta ! device or host variable
  real(4), device :: Y(*)
  integer :: incy
  integer(8) :: strideY
  integer :: batchCount

integer(4) function cublasHSSgemvStridedBatched_v2(h, trans, m, n, alpha, &
      A, lda, strideA, X, incx, strideX, beta, Y, incy, strideY, batchCount)
  type(cublasHandle) :: h
  integer :: trans
  integer :: m, n
  real(4), device :: alpha ! device or host variable
  real(2), device :: A(lda,*)
  integer :: lda
  integer(8) :: strideA
  real(2), device :: X(*)
  integer :: incx
  integer(8) :: strideX
  real(4), device :: beta ! device or host variable
  real(4), device :: Y(*)
  integer :: incy
  integer(8) :: strideY
  integer :: batchCount

2.6.3. cublasHgemm

HGEMM 执行矩阵-矩阵运算 C := alpha*op( A )*op( B ) + beta*C 之一，其中 op( X ) 是 op( X ) = X 或 op( X ) = X**T 之一，alpha 和 beta 是标量，而 A、B 和 C 是矩阵，其中 op( A ) 是 m 乘 k 矩阵，op( B ) 是 k 乘 n 矩阵，C 是 m 乘 n 矩阵。

subroutine cublasHgemm(transa, transb, m, n, k, alpha, a, lda, b, ldb, &
      beta, c, ldc)
  integer :: transa  ! integer or character(1) variable
  integer :: transb  ! integer or character(1) variable
  integer :: m, n, k, lda, ldb, ldc
  real(2), device, dimension(lda, *) :: a
  real(2), device, dimension(ldb, *) :: b
  real(2), device, dimension(ldc, *) :: c
  real(2), device :: alpha, beta ! device or host variable

在 v2 版本中，用户有责任为 alpha, beta 参数设置指针模式。

integer(4) function cublasHgemm_v2(h, transa, transb, m, n, k, alpha, &
      a, lda, b, ldb, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: transa, transb
  integer :: m, n, k, lda, ldb, ldc
  real(2), device, dimension(lda, *) :: a
  real(2), device, dimension(ldb, *) :: b
  real(2), device, dimension(ldc, *) :: c
  real(2), device :: alpha, beta ! device or host variable

2.6.4. cublasHgemmBatched

HGEMM 执行矩阵-矩阵运算 C := alpha*op( A )*op( B ) + beta*C 之一，其中 op( X ) 是 op( X ) = X 或 op( X ) = X**T 之一，alpha 和 beta 是标量，而 A、B 和 C 是矩阵，其中 op( A ) 是 m 乘 k 矩阵，op( B ) 是 k 乘 n 矩阵，C 是 m 乘 n 矩阵。

integer(4) function cublasHgemmBatched(h, transa, transb, m, n, k, &
      alpha, Aarray, lda, Barray, ldb, beta, Carray, ldc, batchCount)
  type(cublasHandle) :: h
  integer :: transa ! integer or character(1) variable
  integer :: transb ! integer or character(1) variable
  integer :: m, n, k
  real(2), device :: alpha ! device or host variable
  type(c_devptr), device :: Aarray(*)
  integer :: lda
  type(c_devptr), device :: Barray(*)
  integer :: ldb
  real(2), device :: beta ! device or host variable
  type(c_devptr), device :: Carray(*)
  integer :: ldc
  integer :: batchCount

integer(4) function cublasHgemmBatched_v2(h, transa, transb, m, n, k, &
      alpha, Aarray, lda, Barray, ldb, beta, Carray, ldc, batchCount)
  type(cublasHandle) :: h
  integer :: transa
  integer :: transb
  integer :: m, n, k
  real(2), device :: alpha ! device or host variable
  type(c_devptr), device :: Aarray(*)
  integer :: lda
  type(c_devptr), device :: Barray(*)
  integer :: ldb
  real(2), device :: beta ! device or host variable
  type(c_devptr), device :: Carray(*)
  integer :: ldc
  integer :: batchCount

2.6.5. cublasHgemmStridedBatched

HGEMM 执行一组矩阵-矩阵运算 C := alpha*op( A )*op( B ) + beta*C，其中 op( X ) 是 op( X ) = X 或 op( X ) = X**T 之一，alpha 和 beta 是标量，而 A、B 和 C 是矩阵，其中 op( A ) 是 m 乘 k 矩阵，op( B ) 是 k 乘 n 矩阵，C 是 m 乘 n 矩阵。

integer(4) function cublasHgemmStridedBatched(h, transa, transb, m, n, k, &
    alpha, A, lda, strideA, B, ldb, strideB, beta, C, ldc, strideC, batchCount)
  type(cublasHandle) :: h
  integer :: transa ! integer or character(1) variable
  integer :: transb ! integer or character(1) variable
  integer :: m, n, k
  real(2), device :: alpha ! device or host variable
  real(2), device :: A(lda,*)
  integer :: lda
  integer(8) :: strideA
  real(2), device :: B(ldb,*)
  integer :: ldb
  integer(8) :: strideB
  real(2), device :: beta ! device or host variable
  real(2), device :: C(ldc,*)
  integer :: ldc
  integer(8) :: strideC
  integer :: batchCount

integer(4) function cublasHgemmStridedBatched_v2(h, transa, transb, m, n, k, &
    alpha, A, lda, strideA, B, ldb, strideB, beta, C, ldc, strideC, batchCount)
  type(cublasHandle) :: h
  integer :: transa
  integer :: transb
  integer :: m, n, k
  real(2), device :: alpha ! device or host variable
  real(2), device :: A(lda,*)
  integer :: lda
  integer(8) :: strideA
  real(2), device :: B(ldb,*)
  integer :: ldb
  integer(8) :: strideB
  real(2), device :: beta ! device or host variable
  real(2), device :: C(ldc,*)
  integer :: ldc
  integer(8) :: strideC
  integer :: batchCount

2.6.6. cublasIamaxEx

IAMAX 查找具有最大绝对值的元素的索引。

integer(4) function cublasIamaxEx(h, n, x, xtype, incx, res)
  type(cublasHandle) :: h
  integer :: n
  real(2), device, dimension(*) :: x  ! Type and kind as specified by xtype
  type(cudaDataType) :: xtype
  integer :: incx
  integer, device :: res ! device or host variable

2.6.7. cublasIaminEx

IAMIN 查找具有最小绝对值的元素的索引。

integer(4) function cublasIaminEx(h, n, x, xtype, incx, res)
  type(cublasHandle) :: h
  integer :: n
  real(2), device, dimension(*) :: x  ! Type and kind as specified by xtype
  type(cudaDataType) :: xtype
  integer :: incx
  integer, device :: res ! device or host variable

2.6.8. cublasAsumEx

ASUM 计算绝对值的总和。

integer(4) function cublasAsumEx(h, n, x, xtype, incx, res, &
      restype, extype)
  type(cublasHandle) :: h
  integer :: n
  real(2), device, dimension(*) :: x  ! Type and kind as specified by xtype
  type(cudaDataType) :: xtype
  integer :: incx
  real(2), device :: res ! device or host variable
  type(cudaDataType) :: restype
  type(cudaDataType) :: extype

2.6.9. cublasAxpyEx

AXPY 计算常数乘以向量加上向量。

integer(4) function cublasAxpyEx(h, n, alpha, alphatype, &
      x, xtype, incx, y, ytype, incy, extype)
  type(cublasHandle) :: h
  integer :: n
  real(2), device :: alpha
  type(cudaDataType) :: alphatype
  real(2), device, dimension(*) :: x
  type(cudaDataType) :: xtype
  integer :: incx
  real(2), device, dimension(*) :: y
  type(cudaDataType) :: ytype
  integer :: incy
  type(cudaDataType) :: extype

2.6.10. cublasCopyEx

COPY 将向量 x 复制到向量 y。

integer(4) function cublasCopyEx(h, n, x, xtype, incx, &
      y, ytype, incy)
  type(cublasHandle) :: h
  integer :: n
  real(2), device, dimension(*) :: x
  type(cudaDataType) :: xtype
  integer :: incx
  real(2), device, dimension(*) :: y
  type(cudaDataType) :: ytype
  integer :: incy

2.6.11. cublasDotEx

DOT 形成两个向量的点积。

integer(4) function cublasDotEx(h, n, x, xtype, incx, &
      y, ytype, incy, res, restype, extype)
  type(cublasHandle) :: h
  integer :: n
  real(2), device, dimension(*) :: x  ! Type and kind as specified by xtype
  type(cudaDataType) :: xtype
  integer :: incx
  real(2), device, dimension(*) :: y  ! Type and kind as specified by ytype
  type(cudaDataType) :: ytype
  integer :: incy
  real(2), device :: res ! device or host variable
  type(cudaDataType) :: restype
  type(cudaDataType) :: extype

2.6.12. cublasDotcEx

DOTC 形成两个向量的共轭点积。

integer(4) function cublasDotcEx(h, n, x, xtype, incx, &
      y, ytype, incy, res, restype, extype)
  type(cublasHandle) :: h
  integer :: n
  real(2), device, dimension(*) :: x  ! Type and kind as specified by xtype
  type(cudaDataType) :: xtype
  integer :: incx
  real(2), device, dimension(*) :: y  ! Type and kind as specified by ytype
  type(cudaDataType) :: ytype
  integer :: incy
  real(2), device :: res ! device or host variable
  type(cudaDataType) :: restype
  type(cudaDataType) :: extype

2.6.13. cublasNrm2Ex

NRM2 生成向量的欧几里得范数。

integer(4) function cublasNrm2Ex(h, n, x, xtype, incx, res, &
      restype, extype)
  type(cublasHandle) :: h
  integer :: n
  real(2), device, dimension(*) :: x  ! Type and kind as specified by xtype
  type(cudaDataType) :: xtype
  integer :: incx
  real(2), device :: res ! device or host variable
  type(cudaDataType) :: restype
  type(cudaDataType) :: extype

2.6.14. cublasRotEx

ROT 应用平面旋转。

integer(4) function cublasRotEx(h, n, x, xtype, incx, &
      y, ytype, incy, c, s, cstype, extype)
  type(cublasHandle) :: h
  integer :: n
  real(2), device, dimension(*) :: x  ! Type and kind as specified by xtype
  type(cudaDataType) :: xtype
  integer :: incx
  real(2), device, dimension(*) :: y  ! Type and kind as specified by ytype
  type(cudaDataType) :: ytype
  integer :: incy
  real(2), device :: c, s ! device or host variable
  type(cudaDataType) :: cstype
  type(cudaDataType) :: extype

2.6.15. cublasRotgEx

ROTG 构建 Givens 平面旋转

integer(4) function cublasRotgEx(h, a, b, abtype, &
      c, s, cstype, extype)
  type(cublasHandle) :: h
  real(2), device :: a, b  ! Type and kind as specified by abtype
  type(cudaDataType) :: abtype
  real(2), device :: c, s ! device or host variable
  type(cudaDataType) :: cstype
  type(cudaDataType) :: extype

2.6.16. cublasRotmEx

ROTM 应用修改后的 Givens 变换。

integer(4) function cublasRotmEx(h, n, x, xtype, incx, &
      y, ytype, incy, param, paramtype, extype)
  type(cublasHandle) :: h
  integer :: n
  real(2), device, dimension(*) :: x  ! Type and kind as specified by xtype
  type(cudaDataType) :: xtype
  integer :: incx
  real(2), device, dimension(*) :: y  ! Type and kind as specified by ytype
  type(cudaDataType) :: ytype
  integer :: incy
  real(2), device, dimension(*) :: param
  type(cudaDataType) :: paramtype
  type(cudaDataType) :: extype

2.6.17. cublasRotmgEx

ROTMG 构建修改后的 Givens 变换矩阵。

integer(4) function cublasRotmgEx(h, d1, d1type, d2, d2type, &
      x1, x1type, y1, y1type, param, paramtype, extype)
  type(cublasHandle) :: h
  real(2), device :: d1  ! Type and kind as specified by d1type
  type(cudaDataType) :: d1type
  real(2), device :: d2  ! Type and kind as specified by d2type
  type(cudaDataType) :: d2type
  real(2), device :: x1  ! Type and kind as specified by x1type
  type(cudaDataType) :: x1type
  real(2), device :: y1  ! Type and kind as specified by y1type
  type(cudaDataType) :: y1type
  real(2), device, dimension(*) :: param
  type(cudaDataType) :: paramtype
  type(cudaDataType) :: extype

2.6.18. cublasScalEx

SCAL 按常数缩放向量。

integer(4) function cublasScalEx(h, n, alpha, alphatype, &
      x, xtype, incx, extype)
  type(cublasHandle) :: h
  integer :: n
  real(2), device :: alpha
  type(cudaDataType) :: alphatype
  real(2), device, dimension(*) :: x
  type(cudaDataType) :: xtype
  integer :: incx
  type(cudaDataType) :: extype

2.6.19. cublasSwapEx

SWAP 交换两个向量。

integer(4) function cublasSwapEx(h, n, x, xtype, incx, &
      y, ytype, incy)
  type(cublasHandle) :: h
  integer :: n
  real(2), device, dimension(*) :: x
  type(cudaDataType) :: xtype
  integer :: incx
  real(2), device, dimension(*) :: y
  type(cudaDataType) :: ytype
  integer :: incy

2.6.20. cublasGemmEx

GEMM 执行矩阵-矩阵乘法运算 C := alpha*op( A )*op( B ) + beta*C，其中 op( X ) 是 op( X ) = X 或 op( X ) = X**T 之一，alpha 和 beta 是标量，而 A、B 和 C 是矩阵，其中 op( A ) 是 m 乘 k 矩阵，op( B ) 是 k 乘 n 矩阵，C 是 m 乘 n 矩阵。

alpha, beta 的数据类型主要遵循 computeType 参数。有关当前支持的数据类型组合，请参阅 cuBLAS 文档。

integer(4) function cublasGemmEx(h, transa, transb, m, n, k, alpha, &
      A, atype, lda, B, btype, ldb, beta, C, ctype, ldc, computeType, algo)
  type(cublasHandle) :: h
  integer :: transa, transb
  integer :: m, n, k
  real(2), device :: alpha ! device or host variable
  real(2), device :: A(lda,*)
  type(cudaDataType) :: atype
  integer :: lda
  real(2), device :: B(ldb,*)
  type(cudaDataType) :: btype
  integer :: ldb
  real(2), device :: beta ! device or host variable
  real(2), device :: C(ldc,*)
  type(cudaDataType) :: ctype
  integer :: ldc
  type(cublasComputeType) :: computeType  ! also accept integer
  type(cublasGemmAlgoType) :: algo        ! also accept integer

2.6.21. cublasGemmBatchedEx

GEMM 执行批量矩阵-矩阵乘法运算 C := alpha*op( A )*op( B ) + beta*C，其中 op( X ) 是 op( X ) = X 或 op( X ) = X**T 之一，alpha 和 beta 是标量，而 A、B 和 C 是矩阵，其中 op( A ) 是 m 乘 k 矩阵，op( B ) 是 k 乘 n 矩阵，C 是 m 乘 n 矩阵。

alpha, beta 的数据类型主要遵循 computeType 参数。有关当前支持的数据类型组合，请参阅 cuBLAS 文档。

integer(4) function cublasGemmBatchedEx(h, transa, transb, m, n, k, &
      alpha, Aarray, atype, lda, Barray, btype, ldb, beta, &
      Carray, ctype, ldc, batchCount, computeType, algo)
  type(cublasHandle) :: h
  integer :: transa, transb
  integer :: m, n, k
  real(2), device :: alpha ! device or host variable
  type(c_devptr), device :: Aarray(*)
  type(cudaDataType) :: atype
  integer :: lda
  type(c_devptr), device :: Barray(*)
  type(cudaDataType) :: btype
  integer :: ldb
  real(2), device :: beta ! device or host variable
  type(c_devptr), device :: Carray(*)
  type(cudaDataType) :: ctype
  integer :: ldc
  integer :: batchCount
  type(cublasComputeType) :: computeType  ! also accept integer
  type(cublasGemmAlgoType) :: algo        ! also accept integer

2.6.22. cublasGemmStridedBatchedEx

GEMM 执行批量矩阵-矩阵乘法运算 C := alpha*op( A )*op( B ) + beta*C，其中 op( X ) 是 op( X ) = X 或 op( X ) = X**T 之一，alpha 和 beta 是标量，而 A、B 和 C 是矩阵，其中 op( A ) 是 m 乘 k 矩阵，op( B ) 是 k 乘 n 矩阵，C 是 m 乘 n 矩阵。

alpha, beta 的数据类型主要遵循 computeType 参数。有关当前支持的数据类型组合，请参阅 cuBLAS 文档。

integer(4) function cublasGemmStridedBatchedEx(h, transa, transb, m, n, k, &
      alpha, A, atype, lda, strideA, B, btype, ldb, strideB, beta, &
      C, ctype, ldc, strideC, batchCount, computeType, algo)
  type(cublasHandle) :: h
  integer :: transa, transb
  integer :: m, n, k
  real(2), device :: alpha ! device or host variable
  real(2), device :: A(lda,*)
  type(cudaDataType) :: atype
  integer :: lda
  integer(8) :: strideA
  real(2), device :: B(ldb,*)
  type(cudaDataType) :: btype
  integer :: ldb
  integer(8) :: strideB
  real(2), device :: beta ! device or host variable
  real(2), device :: C(ldc,*)
  type(cudaDataType) :: ctype
  integer :: ldc
  integer(8) :: strideC
  integer :: batchCount
  type(cublasComputeType) :: computeType  ! also accept integer
  type(cublasGemmAlgoType) :: algo        ! also accept integer

2.7. CUBLAS V2 模块函数

本节包含 cuBLAS V2 模块函数的接口。用户可以通过在程序单元中插入行 use cublas_v2 来访问此模块。cublas_v2 与 cublas 模块的主要区别之一是 cublas 入口点，例如 cublasIsamax 已更改为将句柄作为第一个参数。 cublas_v2 模块中的第二个区别是 v2 入口点，例如 cublasIsamax_v2 不会隐式处理用户的指针模式。程序员有责任调用 cublasSetPointerMode 来告知库标量参数是驻留在主机上还是设备上。v2 入口点的实际接口没有更改，并且未在本节中列出。

2.7.1. 单精度函数和子例程

本节包含单精度 BLAS 和 cuBLAS 函数和子例程的 V2 接口。

2.7.1.1. isamax

如果您使用 cublas_v2 模块，则 cublasIsamax 的接口将更改为以下内容

integer(4) function cublasIsamax(h, n, x, incx, res)
  type(cublasHandle) :: h
  integer :: n
  real(4), device, dimension(*) :: x
  integer :: incx
  integer, device :: res ! device or host variable

2.7.1.2. isamin

如果您使用 cublas_v2 模块，则 cublasIsamin 的接口将更改为以下内容

integer(4) function cublasIsamin(h, n, x, incx, res)
  type(cublasHandle) :: h
  integer :: n
  real(4), device, dimension(*) :: x
  integer :: incx
  integer, device :: res ! device or host variable

2.7.1.3. sasum

如果您使用 cublas_v2 模块，则 cublasSasum 的接口将更改为以下内容

integer(4) function cublasSasum(h, n, x, incx, res)
  type(cublasHandle) :: h
  integer :: n
  real(4), device, dimension(*) :: x
  integer :: incx
  real(4), device :: res ! device or host variable

2.7.1.4. saxpy

如果您使用 cublas_v2 模块，则 cublasSaxpy 的接口将更改为以下内容

integer(4) function cublasSaxpy(h, n, a, x, incx, y, incy)
  type(cublasHandle) :: h
  integer :: n
  real(4), device :: a ! device or host variable
  real(4), device, dimension(*) :: x, y
  integer :: incx, incy

2.7.1.5. scopy

如果您使用 cublas_v2 模块，则 cublasScopy 的接口将更改为以下内容

integer(4) function cublasScopy(h, n, x, incx, y, incy)
  type(cublasHandle) :: h
  integer :: n
  real(4), device, dimension(*) :: x, y
  integer :: incx, incy

2.7.1.6. sdot

如果您使用 cublas_v2 模块，则 cublasSdot 的接口将更改为以下内容

integer(4) function cublasSdot(h, n, x, incx, y, incy, res)
  type(cublasHandle) :: h
  integer :: n
  real(4), device, dimension(*) :: x, y
  integer :: incx, incy
  real(4), device :: res ! device or host variable

2.7.1.7. snrm2

如果您使用 cublas_v2 模块，则 cublasSnrm2 的接口将更改为以下内容

integer(4) function cublasSnrm2(h, n, x, incx, res)
  type(cublasHandle) :: h
  integer :: n
  real(4), device, dimension(*) :: x
  integer :: incx
  real(4), device :: res ! device or host variable

2.7.1.8. srot

如果您使用 cublas_v2 模块，则 cublasSrot 的接口将更改为以下内容

integer(4) function cublasSrot(h, n, x, incx, y, incy, sc, ss)
  type(cublasHandle) :: h
  integer :: n
  real(4), device :: sc, ss ! device or host variable
  real(4), device, dimension(*) :: x, y
  integer :: incx, incy

2.7.1.9. srotg

如果您使用 cublas_v2 模块，则 cublasSrotg 的接口将更改为以下内容

integer(4) function cublasSrotg(h, sa, sb, sc, ss)
  type(cublasHandle) :: h
  real(4), device :: sa, sb, sc, ss ! device or host variable

2.7.1.10. srotm

如果您使用 cublas_v2 模块，则 cublasSrotm 的接口将更改为以下内容

integer(4) function cublasSrotm(h, n, x, incx, y, incy, param)
  type(cublasHandle) :: h
  integer :: n
  real(4), device :: param(*) ! device or host variable
  real(4), device, dimension(*) :: x, y
  integer :: incx, incy

2.7.1.11. srotmg

如果您使用 cublas_v2 模块，则 cublasSrotmg 的接口将更改为以下内容

integer(4) function cublasSrotmg(h, d1, d2, x1, y1, param)
  type(cublasHandle) :: h
  real(4), device :: d1, d2, x1, y1, param(*) ! device or host variable

2.7.1.12. sscal

如果您使用 cublas_v2 模块，则 cublasSscal 的接口将更改为以下内容

integer(4) function cublasSscal(h, n, a, x, incx)
  type(cublasHandle) :: h
  integer :: n
  real(4), device :: a ! device or host variable
  real(4), device, dimension(*) :: x
  integer :: incx

2.7.1.13. sswap

如果您使用 cublas_v2 模块，则 cublasSswap 的接口将更改为以下内容

integer(4) function cublasSswap(h, n, x, incx, y, incy)
  type(cublasHandle) :: h
  integer :: n
  real(4), device, dimension(*) :: x, y
  integer :: incx, incy

2.7.1.14. sgbmv

如果您使用 cublas_v2 模块，则 cublasSgbmv 的接口将更改为以下内容

integer(4) function cublasSgbmv(h, t, m, n, kl, ku, alpha, a, lda, x, incx, beta, y, incy)
  type(cublasHandle) :: h
  integer :: t
  integer :: m, n, kl, ku, lda, incx, incy
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(*) :: x, y
  real(4), device :: alpha, beta ! device or host variable

2.7.1.15. sgemv

如果您使用 cublas_v2 模块，则 cublasSgemv 的接口将更改为以下内容

integer(4) function cublasSgemv(h, t, m, n, alpha, a, lda, x, incx, beta, y, incy)
  type(cublasHandle) :: h
  integer :: t
  integer :: m, n, lda, incx, incy
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(*) :: x, y
  real(4), device :: alpha, beta ! device or host variable

2.7.1.16. sger

如果您使用 cublas_v2 模块，则 cublasSger 的接口将更改为以下内容

integer(4) function cublasSger(h, m, n, alpha, x, incx, y, incy, a, lda)
  type(cublasHandle) :: h
  integer :: m, n, lda, incx, incy
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(*) :: x, y
  real(4), device :: alpha ! device or host variable

2.7.1.17. ssbmv

如果您使用 cublas_v2 模块，则 cublasSsbmv 的接口将更改为以下内容

integer(4) function cublasSsbmv(h, t, n, k, alpha, a, lda, x, incx, beta, y, incy)
  type(cublasHandle) :: h
  integer :: t
  integer :: k, n, lda, incx, incy
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(*) :: x, y
  real(4), device :: alpha, beta ! device or host variable

2.7.1.18. sspmv

如果您使用 cublas_v2 模块，则 cublasSspmv 的接口将更改为以下内容

integer(4) function cublasSspmv(h, t, n, alpha, a, x, incx, beta, y, incy)
  type(cublasHandle) :: h
  integer :: t
  integer :: n, incx, incy
  real(4), device, dimension(*) :: a, x, y
  real(4), device :: alpha, beta ! device or host variable

2.7.1.19. sspr

如果您使用 cublas_v2 模块，则 cublasSspr 的接口将更改为以下内容

integer(4) function cublasSspr(h, t, n, alpha, x, incx, a)
  type(cublasHandle) :: h
  integer :: t
  integer :: n, incx
  real(4), device, dimension(*) :: a, x
  real(4), device :: alpha ! device or host variable

2.7.1.20. sspr2

如果您使用 cublas_v2 模块，则 cublasSspr2 的接口将更改为以下内容

integer(4) function cublasSspr2(h, t, n, alpha, x, incx, y, incy, a)
  type(cublasHandle) :: h
  integer :: t
  integer :: n, incx, incy
  real(4), device, dimension(*) :: a, x, y
  real(4), device :: alpha ! device or host variable

2.7.1.21. ssymv

如果您使用 cublas_v2 模块，则 cublasSsymv 的接口将更改为以下内容

integer(4) function cublasSsymv(h, uplo, n, alpha, a, lda, x, incx, beta, y, incy)
  type(cublasHandle) :: h
  integer :: uplo
  integer :: n, lda, incx, incy
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(*) :: x, y
  real(4), device :: alpha, beta ! device or host variable

2.7.1.22. ssyr

如果您使用 cublas_v2 模块，则 cublasSsyr 的接口将更改为以下内容

integer(4) function cublasSsyr(h, t, n, alpha, x, incx, a, lda)
  type(cublasHandle) :: h
  integer :: t
  integer :: n, incx, lda
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(*) :: x
  real(4), device :: alpha ! device or host variable

2.7.1.23. ssyr2

如果您使用 cublas_v2 模块，则 cublasSsyr2 的接口将更改为以下内容

integer(4) function cublasSsyr2(h, t, n, alpha, x, incx, y, incy, a, lda)
  type(cublasHandle) :: h
  integer :: t
  integer :: n, incx, incy, lda
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(*) :: x, y
  real(4), device :: alpha ! device or host variable

2.7.1.24. stbmv

如果您使用 cublas_v2 模块，则 cublasStbmv 的接口将更改为以下内容

integer(4) function cublasStbmv(h, u, t, d, n, k, a, lda, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, k, incx, lda
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(*) :: x

2.7.1.25. stbsv

如果您使用 cublas_v2 模块，则 cublasStbsv 的接口将更改为以下内容

integer(4) function cublasStbsv(h, u, t, d, n, k, a, lda, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, k, incx, lda
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(*) :: x

2.7.1.26. stpmv

如果您使用 cublas_v2 模块，则 cublasStpmv 的接口将更改为以下内容

integer(4) function cublasStpmv(h, u, t, d, n, a, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, incx
  real(4), device, dimension(*) :: a, x

2.7.1.27. stpsv

如果您使用 cublas_v2 模块，则 cublasStpsv 的接口将更改为以下内容

integer(4) function cublasStpsv(h, u, t, d, n, a, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, incx
  real(4), device, dimension(*) :: a, x

2.7.1.28. strmv

如果您使用 cublas_v2 模块，则 cublasStrmv 的接口将更改为以下内容

integer(4) function cublasStrmv(h, u, t, d, n, a, lda, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, incx, lda
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(*) :: x

2.7.1.29. strsv

如果您使用 cublas_v2 模块，则 cublasStrsv 的接口将更改为以下内容

integer(4) function cublasStrsv(h, u, t, d, n, a, lda, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, incx, lda
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(*) :: x

2.7.1.30. sgemm

如果您使用 cublas_v2 模块，则 cublasSgemm 的接口将更改为以下内容

integer(4) function cublasSgemm(h, transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: transa, transb
  integer :: m, n, k, lda, ldb, ldc
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(ldb, *) :: b
  real(4), device, dimension(ldc, *) :: c
  real(4), device :: alpha, beta ! device or host variable

2.7.1.31. ssymm

如果您使用 cublas_v2 模块，则 cublasSsymm 的接口将更改为以下内容

integer(4) function cublasSsymm(h, side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: side, uplo
  integer :: m, n, lda, ldb, ldc
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(ldb, *) :: b
  real(4), device, dimension(ldc, *) :: c
  real(4), device :: alpha, beta ! device or host variable

2.7.1.32. ssyrk

如果您使用 cublas_v2 模块，则 cublasSsyrk 的接口将更改为以下内容

integer(4) function cublasSsyrk(h, uplo, trans, n, k, alpha, a, lda, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: uplo, trans
  integer :: n, k, lda, ldc
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(ldc, *) :: c
  real(4), device :: alpha, beta ! device or host variable

2.7.1.33. ssyr2k

如果您使用 cublas_v2 模块，则 cublasSsyr2k 的接口将更改为以下内容

integer(4) function cublasSsyr2k(h, uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(ldb, *) :: b
  real(4), device, dimension(ldc, *) :: c
  real(4), device :: alpha, beta ! device or host variable

2.7.1.34. ssyrkx

如果您使用 cublas_v2 模块，则 cublasSsyrkx 的接口将更改为以下内容

integer(4) function cublasSsyrkx(h, uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(ldb, *) :: b
  real(4), device, dimension(ldc, *) :: c
  real(4), device :: alpha, beta ! device or host variable

2.7.1.35. strmm

如果您使用 cublas_v2 模块，则 cublasStrmm 的接口将更改为以下内容

integer(4) function cublasStrmm(h, side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb, c, ldc)
  type(cublasHandle) :: h
  integer :: side, uplo, transa, diag
  integer :: m, n, lda, ldb, ldc
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(ldb, *) :: b
  real(4), device, dimension(ldc, *) :: c
  real(4), device :: alpha ! device or host variable

2.7.1.36. strsm

如果您使用 cublas_v2 模块，则 cublasStrsm 的接口将更改为以下内容

integer(4) function cublasStrsm(h, side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)
  type(cublasHandle) :: h
  integer :: side, uplo, transa, diag
  integer :: m, n, lda, ldb
  real(4), device, dimension(lda, *) :: a
  real(4), device, dimension(ldb, *) :: b
  real(4), device :: alpha ! device or host variable

2.7.2. 双精度函数和子例程

本节包含双精度 BLAS 和 cuBLAS 函数和子例程的 V2 接口。

2.7.2.1. idamax

如果您使用 cublas_v2 模块，则 cublasIdamax 的接口将更改为以下内容

integer(4) function cublasIdamax(h, n, x, incx, res)
  type(cublasHandle) :: h
  integer :: n
  real(8), device, dimension(*) :: x
  integer :: incx
  integer, device :: res ! device or host variable

2.7.2.2. idamin

如果您使用 cublas_v2 模块，则 cublasIdamin 的接口将更改为以下内容

integer(4) function cublasIdamin(h, n, x, incx, res)
  type(cublasHandle) :: h
  integer :: n
  real(8), device, dimension(*) :: x
  integer :: incx
  integer, device :: res ! device or host variable

2.7.2.3. dasum

如果您使用 cublas_v2 模块，则 cublasDasum 的接口将更改为以下内容

integer(4) function cublasDasum(h, n, x, incx, res)
  type(cublasHandle) :: h
  integer :: n
  real(8), device, dimension(*) :: x
  integer :: incx
  real(8), device :: res ! device or host variable

2.7.2.4. daxpy

如果您使用 cublas_v2 模块，则 cublasDaxpy 的接口将更改为以下内容

integer(4) function cublasDaxpy(h, n, a, x, incx, y, incy)
  type(cublasHandle) :: h
  integer :: n
  real(8), device :: a ! device or host variable
  real(8), device, dimension(*) :: x, y
  integer :: incx, incy

2.7.2.5. dcopy

如果您使用 cublas_v2 模块，则 cublasDcopy 的接口将更改为以下内容

integer(4) function cublasDcopy(h, n, x, incx, y, incy)
  type(cublasHandle) :: h
  integer :: n
  real(8), device, dimension(*) :: x, y
  integer :: incx, incy

2.7.2.6. ddot

如果您使用 cublas_v2 模块，则 cublasDdot 的接口将更改为以下内容

integer(4) function cublasDdot(h, n, x, incx, y, incy, res)
  type(cublasHandle) :: h
  integer :: n
  real(8), device, dimension(*) :: x, y
  integer :: incx, incy
  real(8), device :: res ! device or host variable

2.7.2.7. dnrm2

如果您使用 cublas_v2 模块，则 cublasDnrm2 的接口将更改为以下内容

integer(4) function cublasDnrm2(h, n, x, incx, res)
  type(cublasHandle) :: h
  integer :: n
  real(8), device, dimension(*) :: x
  integer :: incx
  real(8), device :: res ! device or host variable

2.7.2.8. drot

如果您使用 cublas_v2 模块，则 cublasDrot 的接口将更改为以下内容

integer(4) function cublasDrot(h, n, x, incx, y, incy, sc, ss)
  type(cublasHandle) :: h
  integer :: n
  real(8), device :: sc, ss ! device or host variable
  real(8), device, dimension(*) :: x, y
  integer :: incx, incy

2.7.2.9. drotg

如果您使用 cublas_v2 模块，则 cublasDrotg 的接口将更改为以下内容

integer(4) function cublasDrotg(h, sa, sb, sc, ss)
  type(cublasHandle) :: h
  real(8), device :: sa, sb, sc, ss ! device or host variable

2.7.2.10. drotm

如果您使用 cublas_v2 模块，则 cublasDrotm 的接口将更改为以下内容

integer(4) function cublasDrotm(h, n, x, incx, y, incy, param)
  type(cublasHandle) :: h
  integer :: n
  real(8), device :: param(*) ! device or host variable
  real(8), device, dimension(*) :: x, y
  integer :: incx, incy

2.7.2.11. drotmg

如果您使用 cublas_v2 模块，则 cublasDrotmg 的接口将更改为以下内容

integer(4) function cublasDrotmg(h, d1, d2, x1, y1, param)
  type(cublasHandle) :: h
  real(8), device :: d1, d2, x1, y1, param(*) ! device or host variable

2.7.2.12. dscal

如果您使用 cublas_v2 模块，则 cublasDscal 的接口将更改为以下内容

integer(4) function cublasDscal(h, n, a, x, incx)
  type(cublasHandle) :: h
  integer :: n
  real(8), device :: a ! device or host variable
  real(8), device, dimension(*) :: x
  integer :: incx

2.7.2.13. dswap

如果您使用 cublas_v2 模块，则 cublasDswap 的接口将更改为以下内容

integer(4) function cublasDswap(h, n, x, incx, y, incy)
  type(cublasHandle) :: h
  integer :: n
  real(8), device, dimension(*) :: x, y
  integer :: incx, incy

2.7.2.14. dgbmv

如果您使用 cublas_v2 模块，则 cublasDgbmv 的接口将更改为以下内容

integer(4) function cublasDgbmv(h, t, m, n, kl, ku, alpha, a, lda, x, incx, beta, y, incy)
  type(cublasHandle) :: h
  integer :: t
  integer :: m, n, kl, ku, lda, incx, incy
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(*) :: x, y
  real(8), device :: alpha, beta ! device or host variable

2.7.2.15. dgemv

如果您使用 cublas_v2 模块，则 cublasDgemv 的接口将更改为以下内容

integer(4) function cublasDgemv(h, t, m, n, alpha, a, lda, x, incx, beta, y, incy)
  type(cublasHandle) :: h
  integer :: t
  integer :: m, n, lda, incx, incy
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(*) :: x, y
  real(8), device :: alpha, beta ! device or host variable

2.7.2.16. dger

如果您使用 cublas_v2 模块，则 cublasDger 的接口将更改为以下内容

integer(4) function cublasDger(h, m, n, alpha, x, incx, y, incy, a, lda)
  type(cublasHandle) :: h
  integer :: m, n, lda, incx, incy
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(*) :: x, y
  real(8), device :: alpha ! device or host variable

2.7.2.17. dsbmv

如果您使用 cublas_v2 模块，则 cublasDsbmv 的接口将更改为以下内容

integer(4) function cublasDsbmv(h, t, n, k, alpha, a, lda, x, incx, beta, y, incy)
  type(cublasHandle) :: h
  integer :: t
  integer :: k, n, lda, incx, incy
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(*) :: x, y
  real(8), device :: alpha, beta ! device or host variable

2.7.2.18. dspmv

如果您使用 cublas_v2 模块，则 cublasDspmv 的接口将更改为以下内容

integer(4) function cublasDspmv(h, t, n, alpha, a, x, incx, beta, y, incy)
  type(cublasHandle) :: h
  integer :: t
  integer :: n, incx, incy
  real(8), device, dimension(*) :: a, x, y
  real(8), device :: alpha, beta ! device or host variable

2.7.2.19. dspr

如果您使用 cublas_v2 模块，则 cublasDspr 的接口将更改为以下内容

integer(4) function cublasDspr(h, t, n, alpha, x, incx, a)
  type(cublasHandle) :: h
  integer :: t
  integer :: n, incx
  real(8), device, dimension(*) :: a, x
  real(8), device :: alpha ! device or host variable

2.7.2.20. dspr2

如果您使用 cublas_v2 模块，则 cublasDspr2 的接口将更改为以下内容

integer(4) function cublasDspr2(h, t, n, alpha, x, incx, y, incy, a)
  type(cublasHandle) :: h
  integer :: t
  integer :: n, incx, incy
  real(8), device, dimension(*) :: a, x, y
  real(8), device :: alpha ! device or host variable

2.7.2.21. dsymv

如果您使用 cublas_v2 模块，则 cublasDsymv 的接口将更改为以下内容

integer(4) function cublasDsymv(h, uplo, n, alpha, a, lda, x, incx, beta, y, incy)
  type(cublasHandle) :: h
  integer :: uplo
  integer :: n, lda, incx, incy
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(*) :: x, y
  real(8), device :: alpha, beta ! device or host variable

2.7.2.22. dsyr

如果您使用 cublas_v2 模块，则 cublasDsyr 的接口将更改为以下内容

integer(4) function cublasDsyr(h, t, n, alpha, x, incx, a, lda)
  type(cublasHandle) :: h
  integer :: t
  integer :: n, incx, lda
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(*) :: x
  real(8), device :: alpha ! device or host variable

2.7.2.23. dsyr2

如果您使用 cublas_v2 模块，则 cublasDsyr2 的接口将更改为以下内容

integer(4) function cublasDsyr2(h, t, n, alpha, x, incx, y, incy, a, lda)
  type(cublasHandle) :: h
  integer :: t
  integer :: n, incx, incy, lda
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(*) :: x, y
  real(8), device :: alpha ! device or host variable

2.7.2.24. dtbmv

如果您使用 cublas_v2 模块，则 cublasDtbmv 的接口将更改为以下内容

integer(4) function cublasDtbmv(h, u, t, d, n, k, a, lda, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, k, incx, lda
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(*) :: x

2.7.2.25. dtbsv

如果您使用 cublas_v2 模块，则 cublasDtbsv 的接口将更改为以下内容

integer(4) function cublasDtbsv(h, u, t, d, n, k, a, lda, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, k, incx, lda
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(*) :: x

2.7.2.26. dtpmv

如果您使用 cublas_v2 模块，则 cublasDtpmv 的接口将更改为以下内容

integer(4) function cublasDtpmv(h, u, t, d, n, a, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, incx
  real(8), device, dimension(*) :: a, x

2.7.2.27. dtpsv

如果您使用 cublas_v2 模块，则 cublasDtpsv 的接口将更改为以下内容

integer(4) function cublasDtpsv(h, u, t, d, n, a, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, incx
  real(8), device, dimension(*) :: a, x

2.7.2.28. dtrmv

如果您使用 cublas_v2 模块，则 cublasDtrmv 的接口将更改为以下内容

integer(4) function cublasDtrmv(h, u, t, d, n, a, lda, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, incx, lda
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(*) :: x

2.7.2.29. dtrsv

如果您使用 cublas_v2 模块，则 cublasDtrsv 的接口将更改为以下内容

integer(4) function cublasDtrsv(h, u, t, d, n, a, lda, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, incx, lda
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(*) :: x

2.7.2.30. dgemm

如果您使用 cublas_v2 模块，则 cublasDgemm 的接口将更改为以下内容

integer(4) function cublasDgemm(h, transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: transa, transb
  integer :: m, n, k, lda, ldb, ldc
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(ldb, *) :: b
  real(8), device, dimension(ldc, *) :: c
  real(8), device :: alpha, beta ! device or host variable

2.7.2.31. dsymm

如果您使用 cublas_v2 模块，则 cublasDsymm 的接口将更改为以下内容

integer(4) function cublasDsymm(h, side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: side, uplo
  integer :: m, n, lda, ldb, ldc
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(ldb, *) :: b
  real(8), device, dimension(ldc, *) :: c
  real(8), device :: alpha, beta ! device or host variable

2.7.2.32. dsyrk

如果您使用 cublas_v2 模块，则 cublasDsyrk 的接口将更改为以下内容

integer(4) function cublasDsyrk(h, uplo, trans, n, k, alpha, a, lda, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: uplo, trans
  integer :: n, k, lda, ldc
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(ldc, *) :: c
  real(8), device :: alpha, beta ! device or host variable

2.7.2.33. dsyr2k

如果您使用 cublas_v2 模块，则 cublasDsyr2k 的接口将更改为以下内容

integer(4) function cublasDsyr2k(h, uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(ldb, *) :: b
  real(8), device, dimension(ldc, *) :: c
  real(8), device :: alpha, beta ! device or host variable

2.7.2.34. dsyrkx

如果您使用 cublas_v2 模块，则 cublasDsyrkx 的接口将更改为以下内容

integer(4) function cublasDsyrkx(h, uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(ldb, *) :: b
  real(8), device, dimension(ldc, *) :: c
  real(8), device :: alpha, beta ! device or host variable

2.7.2.35. dtrmm

如果您使用 cublas_v2 模块，则 cublasDtrmm 的接口将更改为以下内容

integer(4) function cublasDtrmm(h, side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb, c, ldc)
  type(cublasHandle) :: h
  integer :: side, uplo, transa, diag
  integer :: m, n, lda, ldb, ldc
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(ldb, *) :: b
  real(8), device, dimension(ldc, *) :: c
  real(8), device :: alpha ! device or host variable

2.7.2.36. dtrsm

如果您使用 cublas_v2 模块，则 cublasDtrsm 的接口将更改为以下内容

integer(4) function cublasDtrsm(h, side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)
  type(cublasHandle) :: h
  integer :: side, uplo, transa, diag
  integer :: m, n, lda, ldb
  real(8), device, dimension(lda, *) :: a
  real(8), device, dimension(ldb, *) :: b
  real(8), device :: alpha ! device or host variable

2.7.3. 单精度复数函数和子例程

本节包含单精度复数 BLAS 和 cuBLAS 函数和子例程的 V2 接口。

2.7.3.1. icamax

如果您使用 cublas_v2 模块，则 cublasIcamax 的接口将更改为以下内容

integer(4) function cublasIcamax(h, n, x, incx, res)
  type(cublasHandle) :: h
  integer :: n
  complex(4), device, dimension(*) :: x
  integer :: incx
  integer, device :: res ! device or host variable

2.7.3.2. icamin

如果您使用 cublas_v2 模块，则 cublasIcamin 的接口将更改为以下内容

integer(4) function cublasIcamin(h, n, x, incx, res)
  type(cublasHandle) :: h
  integer :: n
  complex(4), device, dimension(*) :: x
  integer :: incx
  integer, device :: res ! device or host variable

2.7.3.3. scasum

如果您使用 cublas_v2 模块，则 cublasScasum 的接口将更改为以下内容

integer(4) function cublasScasum(h, n, x, incx, res)
  type(cublasHandle) :: h
  integer :: n
  complex(4), device, dimension(*) :: x
  integer :: incx
  real(4), device :: res ! device or host variable

2.7.3.4. caxpy

如果您使用 cublas_v2 模块，则 cublasCaxpy 的接口将更改为以下内容

integer(4) function cublasCaxpy(h, n, a, x, incx, y, incy)
  type(cublasHandle) :: h
  integer :: n
  complex(4), device :: a ! device or host variable
  complex(4), device, dimension(*) :: x, y
  integer :: incx, incy

2.7.3.5. ccopy

如果您使用 cublas_v2 模块，则 cublasCcopy 的接口将更改为以下内容

integer(4) function cublasCcopy(h, n, x, incx, y, incy)
  type(cublasHandle) :: h
  integer :: n
  complex(4), device, dimension(*) :: x, y
  integer :: incx, incy

2.7.3.6. cdotc

如果您使用 cublas_v2 模块，则 cublasCdotc 的接口将更改为以下内容

integer(4) function cublasCdotc(h, n, x, incx, y, incy, res)
  type(cublasHandle) :: h
  integer :: n
  complex(4), device, dimension(*) :: x, y
  integer :: incx, incy
  complex(4), device :: res ! device or host variable

2.7.3.7. cdotu

如果您使用 cublas_v2 模块，则 cublasCdotu 的接口将更改为以下内容

integer(4) function cublasCdotu(h, n, x, incx, y, incy, res)
  type(cublasHandle) :: h
  integer :: n
  complex(4), device, dimension(*) :: x, y
  integer :: incx, incy
  complex(4), device :: res ! device or host variable

2.7.3.8. scnrm2

如果您使用 cublas_v2 模块，则 cublasScnrm2 的接口将更改为以下内容

integer(4) function cublasScnrm2(h, n, x, incx, res)
  type(cublasHandle) :: h
  integer :: n
  complex(4), device, dimension(*) :: x
  integer :: incx
  real(4), device :: res ! device or host variable

2.7.3.9. crot

如果您使用 cublas_v2 模块，则 cublasCrot 的接口将更改为以下内容

integer(4) function cublasCrot(h, n, x, incx, y, incy, sc, ss)
  type(cublasHandle) :: h
  integer :: n
  real(4), device :: sc ! device or host variable
  complex(4), device :: ss ! device or host variable
  complex(4), device, dimension(*) :: x, y
  integer :: incx, incy

2.7.3.10. csrot

如果您使用 cublas_v2 模块，则 cublasCsrot 的接口将更改为以下内容

integer(4) function cublasCsrot(h, n, x, incx, y, incy, sc, ss)
  type(cublasHandle) :: h
  integer :: n
  real(4), device :: sc, ss ! device or host variable
  complex(4), device, dimension(*) :: x, y
  integer :: incx, incy

2.7.3.11. crotg

如果您使用 cublas_v2 模块，则 cublasCrotg 的接口将更改为以下内容

integer(4) function cublasCrotg(h, sa, sb, sc, ss)
  type(cublasHandle) :: h
  complex(4), device :: sa, sb, ss ! device or host variable
  real(4), device :: sc ! device or host variable

2.7.3.12. cscal

如果您使用 cublas_v2 模块，则 cublasCscal 的接口将更改为以下内容

integer(4) function cublasCscal(h, n, a, x, incx)
  type(cublasHandle) :: h
  integer :: n
  complex(4), device :: a ! device or host variable
  complex(4), device, dimension(*) :: x
  integer :: incx

2.7.3.13. csscal

如果您使用 cublas_v2 模块，则 cublasCsscal 的接口将更改为以下内容

integer(4) function cublasCsscal(h, n, a, x, incx)
  type(cublasHandle) :: h
  integer :: n
  real(4), device :: a ! device or host variable
  complex(4), device, dimension(*) :: x
  integer :: incx

2.7.3.14. cswap

如果您使用 cublas_v2 模块，则 cublasCswap 的接口将更改为以下内容

integer(4) function cublasCswap(h, n, x, incx, y, incy)
  type(cublasHandle) :: h
  integer :: n
  complex(4), device, dimension(*) :: x, y
  integer :: incx, incy

2.7.3.15. cgbmv

如果您使用 cublas_v2 模块，则 cublasCgbmv 的接口将更改为以下内容

integer(4) function cublasCgbmv(h, t, m, n, kl, ku, alpha, a, lda, x, incx, beta, y, incy)
  type(cublasHandle) :: h
  integer :: t
  integer :: m, n, kl, ku, lda, incx, incy
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(*) :: x, y
  complex(4), device :: alpha, beta ! device or host variable

2.7.3.16. cgemv

如果您使用 cublas_v2 模块，则 cublasCgemv 的接口将更改为以下内容

integer(4) function cublasCgemv(h, t, m, n, alpha, a, lda, x, incx, beta, y, incy)
  type(cublasHandle) :: h
  integer :: t
  integer :: m, n, lda, incx, incy
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(*) :: x, y
  complex(4), device :: alpha, beta ! device or host variable

2.7.3.17. cgerc

如果您使用 cublas_v2 模块，则 cublasCgerc 的接口将更改为以下内容

integer(4) function cublasCgerc(h, m, n, alpha, x, incx, y, incy, a, lda)
  type(cublasHandle) :: h
  integer :: m, n, lda, incx, incy
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(*) :: x, y
  complex(4), device :: alpha ! device or host variable

2.7.3.18. cgeru

如果您使用 cublas_v2 模块，则 cublasCgeru 的接口将更改为以下内容

integer(4) function cublasCgeru(h, m, n, alpha, x, incx, y, incy, a, lda)
  type(cublasHandle) :: h
  integer :: m, n, lda, incx, incy
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(*) :: x, y
  complex(4), device :: alpha ! device or host variable

2.7.3.19. csymv

如果您使用 cublas_v2 模块，则 cublasCsymv 的接口将更改为以下内容

integer(4) function cublasCsymv(h, uplo, n, alpha, a, lda, x, incx, beta, y, incy)
  type(cublasHandle) :: h
  integer :: uplo
  integer :: n, lda, incx, incy
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(*) :: x, y
  complex(4), device :: alpha, beta ! device or host variable

2.7.3.20. csyr

如果您使用 cublas_v2 模块，则 cublasCsyr 的接口将更改为以下内容

integer(4) function cublasCsyr(h, t, n, alpha, x, incx, a, lda)
  type(cublasHandle) :: h
  integer :: t
  integer :: n, incx, lda
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(*) :: x
  complex(4), device :: alpha ! device or host variable

2.7.3.21. csyr2

如果您使用 cublas_v2 模块，则 cublasCsyr2 的接口将更改为以下内容

integer(4) function cublasCsyr2(h, t, n, alpha, x, incx, y, incy, a, lda)
  type(cublasHandle) :: h
  integer :: t
  integer :: n, incx, incy, lda
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(*) :: x, y
  complex(4), device :: alpha ! device or host variable

2.7.3.22. ctbmv

如果您使用 cublas_v2 模块，则 cublasCtbmv 的接口将更改为以下内容

integer(4) function cublasCtbmv(h, u, t, d, n, k, a, lda, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, k, incx, lda
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(*) :: x

2.7.3.23. ctbsv

如果您使用 cublas_v2 模块，则 cublasCtbsv 的接口将更改为以下内容

integer(4) function cublasCtbsv(h, u, t, d, n, k, a, lda, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, k, incx, lda
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(*) :: x

2.7.3.24. ctpmv

如果您使用 cublas_v2 模块，则 cublasCtpmv 的接口将更改为以下内容

integer(4) function cublasCtpmv(h, u, t, d, n, a, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, incx
  complex(4), device, dimension(*) :: a, x

2.7.3.25. ctpsv

如果您使用 cublas_v2 模块，则 cublasCtpsv 的接口将更改为以下内容

integer(4) function cublasCtpsv(h, u, t, d, n, a, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, incx
  complex(4), device, dimension(*) :: a, x

2.7.3.26. ctrmv

如果您使用 cublas_v2 模块，则 cublasCtrmv 的接口将更改为以下内容

integer(4) function cublasCtrmv(h, u, t, d, n, a, lda, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, incx, lda
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(*) :: x

2.7.3.27. ctrsv

如果您使用 cublas_v2 模块，则 cublasCtrsv 的接口将更改为以下内容

integer(4) function cublasCtrsv(h, u, t, d, n, a, lda, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, incx, lda
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(*) :: x

2.7.3.28. chbmv

如果您使用 cublas_v2 模块，则 cublasChbmv 的接口将更改为以下内容

integer(4) function cublasChbmv(h, uplo, n, k, alpha, a, lda, x, incx, beta, y, incy)
  type(cublasHandle) :: h
  integer :: uplo
  integer :: k, n, lda, incx, incy
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(*) :: x, y
  complex(4), device :: alpha, beta ! device or host variable

2.7.3.29. chemv

如果您使用 cublas_v2 模块，则 cublasChemv 的接口将更改为以下内容

integer(4) function cublasChemv(h, uplo, n, alpha, a, lda, x, incx, beta, y, incy)
  type(cublasHandle) :: h
  integer :: uplo
  integer :: n, lda, incx, incy
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(*) :: x, y
  complex(4), device :: alpha, beta ! device or host variable

2.7.3.30. chpmv

如果您使用 cublas_v2 模块，则 cublasChpmv 的接口将更改为以下内容

integer(4) function cublasChpmv(h, uplo, n, alpha, a, x, incx, beta, y, incy)
  type(cublasHandle) :: h
  integer :: uplo
  integer :: n, incx, incy
  complex(4), device, dimension(*) :: a, x, y
  complex(4), device :: alpha, beta ! device or host variable

2.7.3.31. cher

如果您使用 cublas_v2 模块，则 cublasCher 的接口将更改为以下内容

integer(4) function cublasCher(h, t, n, alpha, x, incx, a, lda)
  type(cublasHandle) :: h
  integer :: t
  integer :: n, incx, lda
  complex(4), device, dimension(*) :: a, x
  real(4), device :: alpha ! device or host variable

2.7.3.32. cher2

如果您使用 cublas_v2 模块，则 cublasCher2 的接口将更改为以下内容

integer(4) function cublasCher2(h, t, n, alpha, x, incx, y, incy, a, lda)
  type(cublasHandle) :: h
  integer :: t
  integer :: n, incx, incy, lda
  complex(4), device, dimension(*) :: a, x, y
  complex(4), device :: alpha ! device or host variable

2.7.3.33. chpr

如果您使用 cublas_v2 模块，则 cublasChpr 的接口将更改为以下内容

integer(4) function cublasChpr(h, t, n, alpha, x, incx, a)
  type(cublasHandle) :: h
  integer :: t
  integer :: n, incx
  complex(4), device, dimension(*) :: a, x
  real(4), device :: alpha ! device or host variable

2.7.3.34. chpr2

如果您使用 cublas_v2 模块，则 cublasChpr2 的接口将更改为以下内容

integer(4) function cublasChpr2(h, t, n, alpha, x, incx, y, incy, a)
  type(cublasHandle) :: h
  integer :: t
  integer :: n, incx, incy
  complex(4), device, dimension(*) :: a, x, y
  complex(4), device :: alpha ! device or host variable

2.7.3.35. cgemm

如果您使用 cublas_v2 模块，则 cublasCgemm 的接口将更改为以下内容

integer(4) function cublasCgemm(h, transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: transa, transb
  integer :: m, n, k, lda, ldb, ldc
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(ldb, *) :: b
  complex(4), device, dimension(ldc, *) :: c
  complex(4), device :: alpha, beta ! device or host variable

2.7.3.36. csymm

如果您使用 cublas_v2 模块，则 cublasCsymm 的接口将更改为以下内容

integer(4) function cublasCsymm(h, side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: side, uplo
  integer :: m, n, lda, ldb, ldc
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(ldb, *) :: b
  complex(4), device, dimension(ldc, *) :: c
  complex(4), device :: alpha, beta ! device or host variable

2.7.3.37. csyrk

如果您使用 cublas_v2 模块，则 cublasCsyrk 的接口将更改为以下内容

integer(4) function cublasCsyrk(h, uplo, trans, n, k, alpha, a, lda, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: uplo, trans
  integer :: n, k, lda, ldc
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(ldc, *) :: c
  complex(4), device :: alpha, beta ! device or host variable

2.7.3.38. csyr2k

如果您使用 cublas_v2 模块，则 cublasCsyr2k 的接口将更改为以下内容

integer(4) function cublasCsyr2k(h, uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(ldb, *) :: b
  complex(4), device, dimension(ldc, *) :: c
  complex(4), device :: alpha, beta ! device or host variable

2.7.3.39. csyrkx

如果您使用 cublas_v2 模块，则 cublasCsyrkx 的接口将更改为以下内容

integer(4) function cublasCsyrkx(h, uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(ldb, *) :: b
  complex(4), device, dimension(ldc, *) :: c
  complex(4), device :: alpha, beta ! device or host variable

2.7.3.40. ctrmm

如果您使用 cublas_v2 模块，则 cublasCtrmm 的接口将更改为以下内容

integer(4) function cublasCtrmm(h, side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb, c, ldc)
  type(cublasHandle) :: h
  integer :: side, uplo, transa, diag
  integer :: m, n, lda, ldb, ldc
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(ldb, *) :: b
  complex(4), device, dimension(ldc, *) :: c
  complex(4), device :: alpha ! device or host variable

2.7.3.41. ctrsm

如果您使用 cublas_v2 模块，则 cublasCtrsm 的接口将更改为以下内容

integer(4) function cublasCtrsm(h, side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)
  type(cublasHandle) :: h
  integer :: side, uplo, transa, diag
  integer :: m, n, lda, ldb
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(ldb, *) :: b
  complex(4), device :: alpha ! device or host variable

2.7.3.42. chemm

如果您使用 cublas_v2 模块，则 cublasChemm 的接口将更改为以下内容

integer(4) function cublasChemm(h, side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: side, uplo
  integer :: m, n, lda, ldb, ldc
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(ldb, *) :: b
  complex(4), device, dimension(ldc, *) :: c
  complex(4), device :: alpha, beta ! device or host variable

2.7.3.43. cherk

如果您使用 cublas_v2 模块，则 cublasCherk 的接口将更改为以下内容

integer(4) function cublasCherk(h, uplo, trans, n, k, alpha, a, lda, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: uplo, trans
  integer :: n, k, lda, ldc
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(ldc, *) :: c
  real(4), device :: alpha, beta ! device or host variable

2.7.3.44. cher2k

如果您使用 cublas_v2 模块，则 cublasCher2k 的接口将更改为以下内容

integer(4) function cublasCher2k(h, uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(ldb, *) :: b
  complex(4), device, dimension(ldc, *) :: c
  complex(4), device :: alpha ! device or host variable
  real(4), device :: beta ! device or host variable

2.7.3.45. cherkx

如果您使用 cublas_v2 模块，则 cublasCherkx 的接口将更改为以下内容

integer(4) function cublasCherkx(h, uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  complex(4), device, dimension(lda, *) :: a
  complex(4), device, dimension(ldb, *) :: b
  complex(4), device, dimension(ldc, *) :: c
  complex(4), device :: alpha ! device or host variable
  real(4), device :: beta ! device or host variable

2.7.4. 双精度复数函数和子例程

本节包含双精度复数 BLAS 和 cuBLAS 函数与子例程的 V2 接口。

2.7.4.1. izamax

如果您使用 cublas_v2 模块，则 cublasIzamax 的接口将更改为以下内容

integer(4) function cublasIzamax(h, n, x, incx, res)
  type(cublasHandle) :: h
  integer :: n
  complex(8), device, dimension(*) :: x
  integer :: incx
  integer, device :: res ! device or host variable

2.7.4.2. izamin

如果您使用 cublas_v2 模块，则 cublasIzamin 的接口将更改为以下内容

integer(4) function cublasIzamin(h, n, x, incx, res)
  type(cublasHandle) :: h
  integer :: n
  complex(8), device, dimension(*) :: x
  integer :: incx
  integer, device :: res ! device or host variable

2.7.4.3. dzasum

如果您使用 cublas_v2 模块，则 cublasDzasum 的接口将更改为以下内容

integer(4) function cublasDzasum(h, n, x, incx, res)
  type(cublasHandle) :: h
  integer :: n
  complex(8), device, dimension(*) :: x
  integer :: incx
  real(8), device :: res ! device or host variable

2.7.4.4. zaxpy

如果您使用 cublas_v2 模块，则 cublasZaxpy 的接口将更改为以下内容

integer(4) function cublasZaxpy(h, n, a, x, incx, y, incy)
  type(cublasHandle) :: h
  integer :: n
  complex(8), device :: a ! device or host variable
  complex(8), device, dimension(*) :: x, y
  integer :: incx, incy

2.7.4.5. zcopy

如果您使用 cublas_v2 模块，则 cublasZcopy 的接口将更改为以下内容

integer(4) function cublasZcopy(h, n, x, incx, y, incy)
  type(cublasHandle) :: h
  integer :: n
  complex(8), device, dimension(*) :: x, y
  integer :: incx, incy

2.7.4.6. zdotc

如果您使用 cublas_v2 模块，则 cublasZdotc 的接口将更改为以下内容

integer(4) function cublasZdotc(h, n, x, incx, y, incy, res)
  type(cublasHandle) :: h
  integer :: n
  complex(8), device, dimension(*) :: x, y
  integer :: incx, incy
  complex(8), device :: res ! device or host variable

2.7.4.7. zdotu

如果您使用 cublas_v2 模块，则 cublasZdotu 的接口将更改为以下内容

integer(4) function cublasZdotu(h, n, x, incx, y, incy, res)
  type(cublasHandle) :: h
  integer :: n
  complex(8), device, dimension(*) :: x, y
  integer :: incx, incy
  complex(8), device :: res ! device or host variable

2.7.4.8. dznrm2

如果您使用 cublas_v2 模块，则 cublasDznrm2 的接口将更改为以下内容

integer(4) function cublasDznrm2(h, n, x, incx, res)
  type(cublasHandle) :: h
  integer :: n
  complex(8), device, dimension(*) :: x
  integer :: incx
  real(8), device :: res ! device or host variable

2.7.4.9. zrot

如果您使用 cublas_v2 模块，则 cublasZrot 的接口将更改为以下内容

integer(4) function cublasZrot(h, n, x, incx, y, incy, sc, ss)
  type(cublasHandle) :: h
  integer :: n
  real(8), device :: sc ! device or host variable
  complex(8), device :: ss ! device or host variable
  complex(8), device, dimension(*) :: x, y
  integer :: incx, incy

2.7.4.10. zsrot

如果您使用 cublas_v2 模块，则 cublasZsrot 的接口将更改为以下内容

integer(4) function cublasZsrot(h, n, x, incx, y, incy, sc, ss)
  type(cublasHandle) :: h
  integer :: n
  real(8), device :: sc, ss ! device or host variable
  complex(8), device, dimension(*) :: x, y
  integer :: incx, incy

2.7.4.11. zrotg

如果您使用 cublas_v2 模块，则 cublasZrotg 的接口将更改为以下内容

integer(4) function cublasZrotg(h, sa, sb, sc, ss)
  type(cublasHandle) :: h
  complex(8), device :: sa, sb, ss ! device or host variable
  real(8), device :: sc ! device or host variable

2.7.4.12. zscal

如果您使用 cublas_v2 模块，则 cublasZscal 的接口将更改为以下内容

integer(4) function cublasZscal(h, n, a, x, incx)
  type(cublasHandle) :: h
  integer :: n
  complex(8), device :: a ! device or host variable
  complex(8), device, dimension(*) :: x
  integer :: incx

2.7.4.13. zdscal

如果您使用 cublas_v2 模块，则 cublasZdscal 的接口将更改为以下内容

integer(4) function cublasZdscal(h, n, a, x, incx)
  type(cublasHandle) :: h
  integer :: n
  real(8), device :: a ! device or host variable
  complex(8), device, dimension(*) :: x
  integer :: incx

2.7.4.14. zswap

如果您使用 cublas_v2 模块，则 cublasZswap 的接口将更改为以下内容

integer(4) function cublasZswap(h, n, x, incx, y, incy)
  type(cublasHandle) :: h
  integer :: n
  complex(8), device, dimension(*) :: x, y
  integer :: incx, incy

2.7.4.15. zgbmv

如果您使用 cublas_v2 模块，则 cublasZgbmv 的接口将更改为以下内容

integer(4) function cublasZgbmv(h, t, m, n, kl, ku, alpha, a, lda, x, incx, beta, y, incy)
  type(cublasHandle) :: h
  integer :: t
  integer :: m, n, kl, ku, lda, incx, incy
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(*) :: x, y
  complex(8), device :: alpha, beta ! device or host variable

2.7.4.16. zgemv

如果您使用 cublas_v2 模块，则 cublasZgemv 的接口将更改为以下内容

integer(4) function cublasZgemv(h, t, m, n, alpha, a, lda, x, incx, beta, y, incy)
  type(cublasHandle) :: h
  integer :: t
  integer :: m, n, lda, incx, incy
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(*) :: x, y
  complex(8), device :: alpha, beta ! device or host variable

2.7.4.17. zgerc

如果您使用 cublas_v2 模块，则 cublasZgerc 的接口将更改为以下内容

integer(4) function cublasZgerc(h, m, n, alpha, x, incx, y, incy, a, lda)
  type(cublasHandle) :: h
  integer :: m, n, lda, incx, incy
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(*) :: x, y
  complex(8), device :: alpha ! device or host variable

2.7.4.18. zgeru

如果您使用 cublas_v2 模块，则 cublasZgeru 的接口将更改为以下内容

integer(4) function cublasZgeru(h, m, n, alpha, x, incx, y, incy, a, lda)
  type(cublasHandle) :: h
  integer :: m, n, lda, incx, incy
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(*) :: x, y
  complex(8), device :: alpha ! device or host variable

2.7.4.19. zsymv

如果您使用 cublas_v2 模块，则 cublasZsymv 的接口将更改为以下内容

integer(4) function cublasZsymv(h, uplo, n, alpha, a, lda, x, incx, beta, y, incy)
  type(cublasHandle) :: h
  integer :: uplo
  integer :: n, lda, incx, incy
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(*) :: x, y
  complex(8), device :: alpha, beta ! device or host variable

2.7.4.20. zsyr

如果您使用 cublas_v2 模块，则 cublasZsyr 的接口将更改为以下内容

integer(4) function cublasZsyr(h, t, n, alpha, x, incx, a, lda)
  type(cublasHandle) :: h
  integer :: t
  integer :: n, incx, lda
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(*) :: x
  complex(8), device :: alpha ! device or host variable

2.7.4.21. zsyr2

如果您使用 cublas_v2 模块，则 cublasZsyr2 的接口将更改为以下内容

integer(4) function cublasZsyr2(h, t, n, alpha, x, incx, y, incy, a, lda)
  type(cublasHandle) :: h
  integer :: t
  integer :: n, incx, incy, lda
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(*) :: x, y
  complex(8), device :: alpha ! device or host variable

2.7.4.22. ztbmv

如果您使用 cublas_v2 模块，则 cublasZtbmv 的接口将更改为以下内容

integer(4) function cublasZtbmv(h, u, t, d, n, k, a, lda, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, k, incx, lda
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(*) :: x

2.7.4.23. ztbsv

如果您使用 cublas_v2 模块，则 cublasZtbsv 的接口将更改为以下内容

integer(4) function cublasZtbsv(h, u, t, d, n, k, a, lda, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, k, incx, lda
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(*) :: x

2.7.4.24. ztpmv

如果您使用 cublas_v2 模块，则 cublasZtpmv 的接口将更改为以下内容

integer(4) function cublasZtpmv(h, u, t, d, n, a, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, incx
  complex(8), device, dimension(*) :: a, x

2.7.4.25. ztpsv

如果您使用 cublas_v2 模块，则 cublasZtpsv 的接口将更改为以下内容

integer(4) function cublasZtpsv(h, u, t, d, n, a, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, incx
  complex(8), device, dimension(*) :: a, x

2.7.4.26. ztrmv

如果您使用 cublas_v2 模块，则 cublasZtrmv 的接口将更改为以下内容

integer(4) function cublasZtrmv(h, u, t, d, n, a, lda, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, incx, lda
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(*) :: x

2.7.4.27. ztrsv

如果您使用 cublas_v2 模块，则 cublasZtrsv 的接口将更改为以下内容

integer(4) function cublasZtrsv(h, u, t, d, n, a, lda, x, incx)
  type(cublasHandle) :: h
  integer :: u, t, d
  integer :: n, incx, lda
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(*) :: x

2.7.4.28. zhbmv

如果您使用 cublas_v2 模块，则 cublasZhbmv 的接口将更改为以下内容

integer(4) function cublasZhbmv(h, uplo, n, k, alpha, a, lda, x, incx, beta, y, incy)
  type(cublasHandle) :: h
  integer :: uplo
  integer :: k, n, lda, incx, incy
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(*) :: x, y
  complex(8), device :: alpha, beta ! device or host variable

2.7.4.29. zhemv

如果您使用 cublas_v2 模块，则 cublasZhemv 的接口将更改为以下内容

integer(4) function cublasZhemv(h, uplo, n, alpha, a, lda, x, incx, beta, y, incy)
  type(cublasHandle) :: h
  integer :: uplo
  integer :: n, lda, incx, incy
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(*) :: x, y
  complex(8), device :: alpha, beta ! device or host variable

2.7.4.30. zhpmv

如果您使用 cublas_v2 模块，则 cublasZhpmv 的接口将更改为以下内容

integer(4) function cublasZhpmv(h, uplo, n, alpha, a, x, incx, beta, y, incy)
  type(cublasHandle) :: h
  integer :: uplo
  integer :: n, incx, incy
  complex(8), device, dimension(*) :: a, x, y
  complex(8), device :: alpha, beta ! device or host variable

2.7.4.31. zher

如果您使用 cublas_v2 模块，则 cublasZher 的接口将更改为以下内容

integer(4) function cublasZher(h, t, n, alpha, x, incx, a, lda)
  type(cublasHandle) :: h
  integer :: t
  integer :: n, incx, lda
  complex(8), device, dimension(*) :: a, x
  real(8), device :: alpha ! device or host variable

2.7.4.32. zher2

如果您使用 cublas_v2 模块，则 cublasZher2 的接口将更改为以下内容

integer(4) function cublasZher2(h, t, n, alpha, x, incx, y, incy, a, lda)
  type(cublasHandle) :: h
  integer :: t
  integer :: n, incx, incy, lda
  complex(8), device, dimension(*) :: a, x, y
  complex(8), device :: alpha ! device or host variable

2.7.4.33. zhpr

如果您使用 cublas_v2 模块，则 cublasZhpr 的接口将更改为以下内容

integer(4) function cublasZhpr(h, t, n, alpha, x, incx, a)
  type(cublasHandle) :: h
  integer :: t
  integer :: n, incx
  complex(8), device, dimension(*) :: a, x
  real(8), device :: alpha ! device or host variable

2.7.4.34. zhpr2

如果您使用 cublas_v2 模块，则 cublasZhpr2 的接口将更改为以下内容

integer(4) function cublasZhpr2(h, t, n, alpha, x, incx, y, incy, a)
  type(cublasHandle) :: h
  integer :: t
  integer :: n, incx, incy
  complex(8), device, dimension(*) :: a, x, y
  complex(8), device :: alpha ! device or host variable

2.7.4.35. zgemm

如果您使用 cublas_v2 模块，则 cublasZgemm 的接口将更改为以下内容

integer(4) function cublasZgemm(h, transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: transa, transb
  integer :: m, n, k, lda, ldb, ldc
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(ldb, *) :: b
  complex(8), device, dimension(ldc, *) :: c
  complex(8), device :: alpha, beta ! device or host variable

2.7.4.36. zsymm

如果您使用 cublas_v2 模块，则 cublasZsymm 的接口将更改为以下内容

integer(4) function cublasZsymm(h, side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: side, uplo
  integer :: m, n, lda, ldb, ldc
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(ldb, *) :: b
  complex(8), device, dimension(ldc, *) :: c
  complex(8), device :: alpha, beta ! device or host variable

2.7.4.37. zsyrk

如果您使用 cublas_v2 模块，则 cublasZsyrk 的接口将更改为以下内容

integer(4) function cublasZsyrk(h, uplo, trans, n, k, alpha, a, lda, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: uplo, trans
  integer :: n, k, lda, ldc
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(ldc, *) :: c
  complex(8), device :: alpha, beta ! device or host variable

2.7.4.38. zsyr2k

如果您使用 cublas_v2 模块，则 cublasZsyr2k 的接口将更改为以下内容

integer(4) function cublasZsyr2k(h, uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(ldb, *) :: b
  complex(8), device, dimension(ldc, *) :: c
  complex(8), device :: alpha, beta ! device or host variable

2.7.4.39. zsyrkx

如果您使用 cublas_v2 模块，则 cublasZsyrkx 的接口将更改为以下内容

integer(4) function cublasZsyrkx(h, uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(ldb, *) :: b
  complex(8), device, dimension(ldc, *) :: c
  complex(8), device :: alpha, beta ! device or host variable

2.7.4.40. ztrmm

如果您使用 cublas_v2 模块，则 cublasZtrmm 的接口将更改为以下内容

integer(4) function cublasZtrmm(h, side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb, c, ldc)
  type(cublasHandle) :: h
  integer :: side, uplo, transa, diag
  integer :: m, n, lda, ldb, ldc
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(ldb, *) :: b
  complex(8), device, dimension(ldc, *) :: c
  complex(8), device :: alpha ! device or host variable

2.7.4.41. ztrsm

如果您使用 cublas_v2 模块，则 cublasZtrsm 的接口将更改为以下内容

integer(4) function cublasZtrsm(h, side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)
  type(cublasHandle) :: h
  integer :: side, uplo, transa, diag
  integer :: m, n, lda, ldb
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(ldb, *) :: b
  complex(8), device :: alpha ! device or host variable

2.7.4.42. zhemm

如果您使用 cublas_v2 模块，则 cublasZhemm 的接口将更改为以下内容

integer(4) function cublasZhemm(h, side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: side, uplo
  integer :: m, n, lda, ldb, ldc
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(ldb, *) :: b
  complex(8), device, dimension(ldc, *) :: c
  complex(8), device :: alpha, beta ! device or host variable

2.7.4.43. zherk

如果您使用 cublas_v2 模块，则 cublasZherk 的接口将更改为以下内容

integer(4) function cublasZherk(h, uplo, trans, n, k, alpha, a, lda, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: uplo, trans
  integer :: n, k, lda, ldc
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(ldc, *) :: c
  real(8), device :: alpha, beta ! device or host variable

2.7.4.44. zher2k

如果您使用 cublas_v2 模块，则 cublasZher2k 的接口将更改为以下内容

integer(4) function cublasZher2k(h, uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(ldb, *) :: b
  complex(8), device, dimension(ldc, *) :: c
  complex(8), device :: alpha ! device or host variable
  real(8), device :: beta ! device or host variable

2.7.4.45. zherkx

如果您使用 cublas_v2 模块，则 cublasZherkx 的接口将更改为以下内容

integer(4) function cublasZherkx(h, uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasHandle) :: h
  integer :: uplo, trans
  integer :: n, k, lda, ldb, ldc
  complex(8), device, dimension(lda, *) :: a
  complex(8), device, dimension(ldb, *) :: b
  complex(8), device, dimension(ldc, *) :: c
  complex(8), device :: alpha ! device or host variable
  real(8), device :: beta ! device or host variable

2.8. CUBLAS XT 模块函数

本节包含 cuBLAS XT 模块函数的接口。用户可以通过在程序单元中插入代码行 use cublasXt 来访问此模块。cublasXt 库是一个主机端库，支持多个 GPU。这是一个示例

subroutine testxt(n)
use cublasXt
complex*16 :: a(n,n), b(n,n), c(n,n), alpha, beta
type(cublasXtHandle) :: h
integer ndevices(1)
a = cmplx(1.0d0,0.0d0)
b = cmplx(2.0d0,0.0d0)
c = cmplx(-1.0d0,0.0d0)
alpha = cmplx(1.0d0,0.0d0)
beta = cmplx(0.0d0,0.0d0)
istat = cublasXtCreate(h)
if (istat .ne. CUBLAS_STATUS_SUCCESS) print *,istat
ndevices(1) = 0
istat = cublasXtDeviceSelect(h, 1, ndevices)
if (istat .ne. CUBLAS_STATUS_SUCCESS) print *,istat
istat = cublasXtZgemm(h, CUBLAS_OP_N, CUBLAS_OP_N, &
                      n, n, n, &
                      alpha, A, n, B, n, beta, C, n)
if (istat .ne. CUBLAS_STATUS_SUCCESS) print *,istat
istat = cublasXtDestroy(h)
if (istat .ne. CUBLAS_STATUS_SUCCESS) print *,istat
if (all(dble(c).eq.2.0d0*n)) then
    print *,"Test PASSED"
else
    print *,"Test FAILED"
endif
end

cublasXt 模块包含 cublas 模块中的所有类型和定义，以及这些附加类型和枚举

TYPE cublasXtHandle
  TYPE(C_PTR)  :: handle
END TYPE

! Pinned memory mode
enum, bind(c)
    enumerator :: CUBLASXT_PINNING_DISABLED=0
    enumerator :: CUBLASXT_PINNING_ENABLED=1
end enum

! cublasXtOpType
enum, bind(c)
    enumerator :: CUBLASXT_FLOAT=0
    enumerator :: CUBLASXT_DOUBLE=1
    enumerator :: CUBLASXT_COMPLEX=2
    enumerator :: CUBLASXT_DOUBLECOMPLEX=3
end enum

! cublasXtBlasOp
enum, bind(c)
    enumerator :: CUBLASXT_GEMM=0
    enumerator :: CUBLASXT_SYRK=1
    enumerator :: CUBLASXT_HERK=2
    enumerator :: CUBLASXT_SYMM=3
    enumerator :: CUBLASXT_HEMM=4
    enumerator :: CUBLASXT_TRSM=5
    enumerator :: CUBLASXT_SYR2K=6
    enumerator :: CUBLASXT_HER2K=7
    enumerator :: CUBLASXT_SPMM=8
    enumerator :: CUBLASXT_SYRKX=9
    enumerator :: CUBLASXT_HERKX=10
    enumerator :: CUBLASXT_TRMM=11
    enumerator :: CUBLASXT_ROUTINE_MAX=12
end enum

2.8.1. cublasXtCreate

此函数初始化 cublasXt API 并创建一个句柄，指向保存 cublasXT 库上下文的不透明结构。它在主机和设备上分配硬件资源，并且必须在进行任何其他 cublasXt API 库调用之前调用。

integer(4) function cublasXtcreate(h)
  type(cublasXtHandle) :: h

2.8.2. cublasXtDestroy

此函数释放 cublasXt API 上下文使用的硬件资源。此函数通常是使用特定句柄对 cublasXt API 的最后一次调用。

integer(4) function cublasXtdestroy(h)
  type(cublasXtHandle) :: h

2.8.3. cublasXtDeviceSelect

此函数允许用户提供 GPU 设备的数量及其各自的 ID，这些设备将参与后续的 cublasXt API 数学函数调用。此函数将为列表中提供的每个 GPU 创建一个 cuBLAS 上下文。目前，设备配置是静态的，并且不能在数学函数调用之间更改。在这方面，此函数应在 cublasXtCreate 之后仅调用一次。为了能够运行多个配置，应创建多个 cublasXt API 上下文。

integer(4) function cublasXtdeviceselect(h, ndevices, deviceid)
  type(cublasXtHandle) :: h
  integer :: ndevices
  integer, dimension(*) :: deviceid

2.8.4. cublasXtSetBlockDim

此函数允许用户设置用于后续数学函数调用的矩阵平铺的分块维度。矩阵被分割成 blockDim x blockDim 维度的正方形瓦片。可以随时调用此函数，并将对后续的数学函数调用生效。应选择分块维度以优化数学运算，并确保 PCI 传输与计算良好地重叠。

integer(4) function cublasXtsetblockdim(h, blockdim)
  type(cublasXtHandle) :: h
  integer :: blockdim

2.8.5. cublasXtGetBlockDim

此函数允许用户查询用于矩阵平铺的分块维度。

integer(4) function cublasXtgetblockdim(h, blockdim)
  type(cublasXtHandle) :: h
  integer :: blockdim

2.8.6. cublasXtSetCpuRoutine

此函数允许用户提供相应 BLAS 例程的 CPU 实现。此函数可以与函数 cublasXtSetCpuRatio() 一起使用，以定义 CPU 和 GPU 之间的混合计算。目前，混合功能仅支持 xGEMM 例程。

integer(4) function cublasXtsetcpuroutine(h, blasop, blastype)
  type(cublasXtHandle) :: h
  integer :: blasop, blastype

2.8.7. cublasXtSetCpuRatio

此函数允许用户定义在混合计算上下文中应在 CPU 上完成的工作负载百分比。此函数可以与函数 cublasXtSetCpuRoutine() 一起使用，以定义 CPU 和 GPU 之间的混合计算。目前，混合功能仅支持 xGEMM 例程。

integer(4) function cublasXtsetcpuratio(h, blasop, blastype, ratio)
  type(cublasXtHandle) :: h
  integer :: blasop, blastype
  real(4) :: ratio

2.8.8. cublasXtSetPinningMemMode

此函数允许用户启用或禁用固定内存模式。启用后，如果矩阵尚未固定，则在后续 cublasXt API 调用中传递的矩阵将分别使用 CUDART 例程 cudaHostRegister 和 cudaHostUnregister 进行固定/取消固定。如果矩阵碰巧部分固定，它也不会被固定。固定内存可提高 PCI 传输性能，并允许 PCI 内存传输与计算重叠。但是，固定/取消固定内存需要一些时间，这可能无法摊销。建议用户使用 cudaMallocHost 或 cudaHostRegister 自行固定内存，并在计算序列完成后取消固定。默认情况下，固定内存模式处于禁用状态。

integer(4) function cublasXtsetpinningmemmode(h, mode)
  type(cublasXtHandle) :: h
  integer :: mode

2.8.9. cublasXtGetPinningMemMode

此函数允许用户查询固定内存模式。默认情况下，固定内存模式处于禁用状态。

integer(4) function cublasXtgetpinningmemmode(h, mode)
  type(cublasXtHandle) :: h
  integer :: mode

2.8.10. cublasXtSgemm

SGEMM 执行矩阵-矩阵运算 C := alpha*op( A )*op( B ) + beta*C 之一，其中 op( X ) 是 op( X ) = X 或 op( X ) = X**T 之一，alpha 和 beta 是标量，A、B 和 C 是矩阵，其中 op( A ) 是 m x k 矩阵，op( B ) 是 k x n 矩阵，C 是 m x n 矩阵。

integer(4) function cublasXtsgemm(h, transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasXtHandle) :: h
  integer :: transa, transb
  integer(kind=c_intptr_t) :: m, n, k, lda, ldb, ldc
  real(4), dimension(lda, *) :: a
  real(4), dimension(ldb, *) :: b
  real(4), dimension(ldc, *) :: c
  real(4) :: alpha, beta

2.8.11. cublasXtSsymm

SSYMM 执行矩阵-矩阵运算 C := alpha*A*B + beta*C 或 C := alpha*B*A + beta*C 之一，其中 alpha 和 beta 是标量，A 是对称矩阵，B 和 C 是 m x n 矩阵。

integer(4) function cublasXtssymm(h, side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasXtHandle) :: h
  integer :: side, uplo
  integer(kind=c_intptr_t) :: m, n, lda, ldb, ldc
  real(4), dimension(lda, *) :: a
  real(4), dimension(ldb, *) :: b
  real(4), dimension(ldc, *) :: c
  real(4) :: alpha, beta

2.8.12. cublasXtSsyrk

SSYRK 执行对称秩 k 运算 C := alpha*A*A**T + beta*C 或 C := alpha*A**T*A + beta*C 之一，其中 alpha 和 beta 是标量，C 是 n x n 对称矩阵，A 在第一种情况下是 n x k 矩阵，在第二种情况下是 k x n 矩阵。

integer(4) function cublasXtssyrk(h, uplo, trans, n, k, alpha, a, lda, beta, c, ldc)
  type(cublasXtHandle) :: h
  integer :: uplo, trans
  integer(kind=c_intptr_t) :: n, k, lda, ldc
  real(4), dimension(lda, *) :: a
  real(4), dimension(ldc, *) :: c
  real(4) :: alpha, beta

2.8.13. cublasXtSsyr2k

SSYR2K 执行对称秩 2k 运算 C := alpha*A*B**T + alpha*B*A**T + beta*C 或 C := alpha*A**T*B + alpha*B**T*A + beta*C 之一，其中 alpha 和 beta 是标量，C 是 n x n 对称矩阵，A 和 B 在第一种情况下是 n x k 矩阵，在第二种情况下是 k x n 矩阵。

integer(4) function cublasXtssyr2k(h, uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasXtHandle) :: h
  integer :: uplo, trans
  integer(kind=c_intptr_t) :: n, k, lda, ldb, ldc
  real(4), dimension(lda, *) :: a
  real(4), dimension(ldb, *) :: b
  real(4), dimension(ldc, *) :: c
  real(4) :: alpha, beta

2.8.14. cublasXtSsyrkx

SSYRKX 执行对称秩 k 更新 C := alpha*A*B**T + beta*C 的变体，其中 alpha 和 beta 是标量，C 是以下三角或上三角模式存储的 n x n 对称矩阵，A 和 B 是 n x k 矩阵。当 B 以某种方式使得结果保证对称时，可以使用此例程。有关更多详细信息，请参阅 CUBLAS 文档。

integer(4) function cublasXtssyrkx(h, uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasXtHandle) :: h
  integer :: uplo, trans
  integer(kind=c_intptr_t) :: n, k, lda, ldb, ldc
  real(4), dimension(lda, *) :: a
  real(4), dimension(ldb, *) :: b
  real(4), dimension(ldc, *) :: c
  real(4) :: alpha, beta

2.8.15. cublasXtStrmm

STRMM 执行矩阵-矩阵运算 B := alpha*op( A )*B 或 B := alpha*B*op( A ) 之一，其中 alpha 是标量，B 是 m x n 矩阵，A 是单位或非单位上或下三角矩阵，op( A ) 是 op( A ) = A 或 op( A ) = A**T 之一。

integer(4) function cublasXtstrmm(h, side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb, c, ldc)
  type(cublasXtHandle) :: h
  integer :: side, uplo, transa, diag
  integer(kind=c_intptr_t) :: m, n, lda, ldb, ldc
  real(4), dimension(lda, *) :: a
  real(4), dimension(ldb, *) :: b
  real(4), dimension(ldc, *) :: c
  real(4) :: alpha

2.8.16. cublasXtStrsm

STRSM 求解矩阵方程 op( A )*X = alpha*B 或 X*op( A ) = alpha*B 之一，其中 alpha 是标量，X 和 B 是 m x n 矩阵，A 是单位或非单位上或下三角矩阵，op( A ) 是 op( A ) = A 或 op( A ) = A**T 之一。矩阵 X 在 B 上被覆盖。

integer(4) function cublasXtstrsm(h, side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)
  type(cublasXtHandle) :: h
  integer :: side, uplo, transa, diag
  integer(kind=c_intptr_t) :: m, n, lda, ldb
  real(4), dimension(lda, *) :: a
  real(4), dimension(ldb, *) :: b
  real(4) :: alpha

2.8.17. cublasXtSspmm

SSPMM 执行对称压缩矩阵-矩阵运算 C := alpha*A*B + beta*C，或 C := alpha*B*A + beta*C 之一，其中 alpha 和 beta 是标量，A 是以压缩格式存储的 n x n 对称矩阵，B 和 C 是 m x n 矩阵。

integer(4) function cublasXtsspmm(h, side, uplo, m, n, alpha, ap, b, ldb, beta, c, ldc)
  type(cublasXtHandle) :: h
  integer :: side, uplo
  integer(kind=c_intptr_t) :: m, n, ldb, ldc
  real(4), dimension(*) :: ap
  real(4), dimension(ldb, *) :: b
  real(4), dimension(ldc, *) :: c
  real(4) :: alpha, beta

2.8.18. cublasXtCgemm

CGEMM 执行矩阵-矩阵运算 C := alpha*op( A )*op( B ) + beta*C 之一，其中 op( X ) 是 op( X ) = X 或 op( X ) = X**T 或 op( X ) = X**H 之一，alpha 和 beta 是标量，A、B 和 C 是矩阵，其中 op( A ) 是一个 m 乘 k 矩阵，op( B ) 是一个 k 乘 n 矩阵，C 是一个 m 乘 n 矩阵。

integer(4) function cublasXtcgemm(h, transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasXtHandle) :: h
  integer :: transa, transb
  integer(kind=c_intptr_t) :: m, n, k, lda, ldb, ldc
  complex(4), dimension(lda, *) :: a
  complex(4), dimension(ldb, *) :: b
  complex(4), dimension(ldc, *) :: c
  complex(4) :: alpha, beta

2.8.19. cublasXtChemm

CHEMM 执行矩阵-矩阵运算 C := alpha*A*B + beta*C 或 C := alpha*B*A + beta*C 之一，其中 alpha 和 beta 是标量，A 是一个埃尔米特矩阵，B 和 C 是 m 乘 n 矩阵。

integer(4) function cublasXtchemm(h, side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasXtHandle) :: h
  integer :: side, uplo
  integer(kind=c_intptr_t) :: m, n, lda, ldb, ldc
  complex(4), dimension(lda, *) :: a
  complex(4), dimension(ldb, *) :: b
  complex(4), dimension(ldc, *) :: c
  complex(4) :: alpha, beta

2.8.20. cublasXtCherk

CHERK 执行埃尔米特秩 k 运算 C := alpha*A*A**H + beta*C 或 C := alpha*A**H*A + beta*C 之一，其中 alpha 和 beta 是实标量，C 是一个 n 乘 n 埃尔米特矩阵，A 在第一种情况下是一个 n 乘 k 矩阵，在第二种情况下是一个 k 乘 n 矩阵。

integer(4) function cublasXtcherk(h, uplo, trans, n, k, alpha, a, lda, beta, c, ldc)
  type(cublasXtHandle) :: h
  integer :: uplo, trans
  integer(kind=c_intptr_t) :: n, k, lda, ldc
  complex(4), dimension(lda, *) :: a
  complex(4), dimension(ldc, *) :: c
  real(4) :: alpha, beta

2.8.21. cublasXtCher2k

CHER2K 执行埃尔米特秩 2k 运算 C := alpha*A*B**H + conjg( alpha )*B*A**H + beta*C 或 C := alpha*A**H*B + conjg( alpha )*B**H*A + beta*C 之一，其中 alpha 和 beta 是标量，beta 是实数，C 是一个 n 乘 n 埃尔米特矩阵，A 和 B 在第一种情况下是 n 乘 k 矩阵，在第二种情况下是 k 乘 n 矩阵。

integer(4) function cublasXtcher2k(h, uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasXtHandle) :: h
  integer :: uplo, trans
  integer(kind=c_intptr_t) :: n, k, lda, ldb, ldc
  complex(4), dimension(lda, *) :: a
  complex(4), dimension(ldb, *) :: b
  complex(4), dimension(ldc, *) :: c
  complex(4) :: alpha
  real(4) :: beta

2.8.22. cublasXtCherkx

CHERKX 执行埃尔米特秩 k 运算 C := alpha*A*B**H + beta*C 的变体，其中 alpha 和 beta 是实标量，C 是一个以 lower 或 upper 模式存储的 n 乘 n 埃尔米特矩阵，A 和 B 是 n 乘 k 矩阵。有关更多详细信息，请参阅 CUBLAS 文档。

integer(4) function cublasXtcherkx(h, uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasXtHandle) :: h
  integer :: uplo, trans
  integer(kind=c_intptr_t) :: n, k, lda, ldb, ldc
  complex(4), dimension(lda, *) :: a
  complex(4), dimension(ldb, *) :: b
  complex(4), dimension(ldc, *) :: c
  complex(4) :: alpha
  real(4) :: beta

2.8.23. cublasXtCsymm

CSYMM 执行矩阵-矩阵运算 C := alpha*A*B + beta*C 或 C := alpha*B*A + beta*C 之一，其中 alpha 和 beta 是标量，A 是一个对称矩阵，B 和 C 是 m 乘 n 矩阵。

integer(4) function cublasXtcsymm(h, side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasXtHandle) :: h
  integer :: side, uplo
  integer(kind=c_intptr_t) :: m, n, lda, ldb, ldc
  complex(4), dimension(lda, *) :: a
  complex(4), dimension(ldb, *) :: b
  complex(4), dimension(ldc, *) :: c
  complex(4) :: alpha, beta

2.8.24. cublasXtCsyrk

CSYRK 执行对称秩 k 运算 C := alpha*A*A**T + beta*C 或 C := alpha*A**T*A + beta*C 之一，其中 alpha 和 beta 是标量，C 是一个 n 乘 n 对称矩阵，A 在第一种情况下是一个 n 乘 k 矩阵，在第二种情况下是一个 k 乘 n 矩阵。

integer(4) function cublasXtcsyrk(h, uplo, trans, n, k, alpha, a, lda, beta, c, ldc)
  type(cublasXtHandle) :: h
  integer :: uplo, trans
  integer(kind=c_intptr_t) :: n, k, lda, ldc
  complex(4), dimension(lda, *) :: a
  complex(4), dimension(ldc, *) :: c
  complex(4) :: alpha, beta

2.8.25. cublasXtCsyr2k

CSYR2K 执行对称秩 2k 运算 C := alpha*A*B**T + alpha*B*A**T + beta*C 或 C := alpha*A**T*B + alpha*B**T*A + beta*C 之一，其中 alpha 和 beta 是标量，C 是一个 n 乘 n 对称矩阵，A 和 B 在第一种情况下是 n 乘 k 矩阵，在第二种情况下是 k 乘 n 矩阵。

integer(4) function cublasXtcsyr2k(h, uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasXtHandle) :: h
  integer :: uplo, trans
  integer(kind=c_intptr_t) :: n, k, lda, ldb, ldc
  complex(4), dimension(lda, *) :: a
  complex(4), dimension(ldb, *) :: b
  complex(4), dimension(ldc, *) :: c
  complex(4) :: alpha, beta

2.8.26. cublasXtCsyrkx

CSYRKX 执行对称秩 k 更新 C := alpha*A*B**T + beta*C 的变体，其中 alpha 和 beta 是标量，C 是一个以 lower 或 upper 模式存储的 n 乘 n 对称矩阵，A 和 B 是 n 乘 k 矩阵。当 B 以某种方式使得结果保证对称时，可以使用此例程。有关更多详细信息，请参阅 CUBLAS 文档。

integer(4) function cublasXtcsyrkx(h, uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasXtHandle) :: h
  integer :: uplo, trans
  integer(kind=c_intptr_t) :: n, k, lda, ldb, ldc
  complex(4), dimension(lda, *) :: a
  complex(4), dimension(ldb, *) :: b
  complex(4), dimension(ldc, *) :: c
  complex(4) :: alpha, beta

2.8.27. cublasXtCtrmm

CTRMM 执行矩阵-矩阵运算 B := alpha*op( A )*B 或 B := alpha*B*op( A ) 之一，其中 alpha 是一个标量，B 是一个 m 乘 n 矩阵，A 是一个单位或非单位上或下三角矩阵，op( A ) 是 op( A ) = A 或 op( A ) = A**T 或 op( A ) = A**H 之一。

integer(4) function cublasXtctrmm(h, side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb, c, ldc)
  type(cublasXtHandle) :: h
  integer :: side, uplo, transa, diag
  integer(kind=c_intptr_t) :: m, n, lda, ldb, ldc
  complex(4), dimension(lda, *) :: a
  complex(4), dimension(ldb, *) :: b
  complex(4), dimension(ldc, *) :: c
  complex(4) :: alpha

2.8.28. cublasXtCtrsm

CTRSM 求解矩阵方程 op( A )*X = alpha*B 或 X*op( A ) = alpha*B 之一，其中 alpha 是一个标量，X 和 B 是 m 乘 n 矩阵，A 是一个单位或非单位上或下三角矩阵，op( A ) 是 op( A ) = A 或 op( A ) = A**T 或 op( A ) = A**H 之一。矩阵 X 在 B 上被覆盖。

integer(4) function cublasXtctrsm(h, side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)
  type(cublasXtHandle) :: h
  integer :: side, uplo, transa, diag
  integer(kind=c_intptr_t) :: m, n, lda, ldb
  complex(4), dimension(lda, *) :: a
  complex(4), dimension(ldb, *) :: b
  complex(4) :: alpha

2.8.29. cublasXtCspmm

CSPMM 执行对称压缩矩阵-矩阵运算 C := alpha*A*B + beta*C，或 C := alpha*B*A + beta*C 之一，其中 alpha 和 beta 是标量，A 是以压缩格式存储的 n x n 对称矩阵，B 和 C 是 m x n 矩阵。

integer(4) function cublasXtcspmm(h, side, uplo, m, n, alpha, ap, b, ldb, beta, c, ldc)
  type(cublasXtHandle) :: h
  integer :: side, uplo
  integer(kind=c_intptr_t) :: m, n, ldb, ldc
  complex(4), dimension(*) :: ap
  complex(4), dimension(ldb, *) :: b
  complex(4), dimension(ldc, *) :: c
  complex(4) :: alpha, beta

2.8.30. cublasXtDgemm

DGEMM 执行矩阵-矩阵运算 C := alpha*op( A )*op( B ) + beta*C 之一，其中 op( X ) 是 op( X ) = X 或 op( X ) = X**T 之一，alpha 和 beta 是标量，A、B 和 C 是矩阵，其中 op( A ) 是 m x k 矩阵，op( B ) 是 k x n 矩阵，C 是 m x n 矩阵。

integer(4) function cublasXtdgemm(h, transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasXtHandle) :: h
  integer :: transa, transb
  integer(kind=c_intptr_t) :: m, n, k, lda, ldb, ldc
  real(8), dimension(lda, *) :: a
  real(8), dimension(ldb, *) :: b
  real(8), dimension(ldc, *) :: c
  real(8) :: alpha, beta

2.8.31. cublasXtDsymm

DSYMM 执行矩阵-矩阵运算 C := alpha*A*B + beta*C 或 C := alpha*B*A + beta*C 之一，其中 alpha 和 beta 是标量，A 是对称矩阵，B 和 C 是 m x n 矩阵。

integer(4) function cublasXtdsymm(h, side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasXtHandle) :: h
  integer :: side, uplo
  integer(kind=c_intptr_t) :: m, n, lda, ldb, ldc
  real(8), dimension(lda, *) :: a
  real(8), dimension(ldb, *) :: b
  real(8), dimension(ldc, *) :: c
  real(8) :: alpha, beta

2.8.32. cublasXtDsyrk

DSYRK 执行对称秩 k 运算 C := alpha*A*A**T + beta*C 或 C := alpha*A**T*A + beta*C 之一，其中 alpha 和 beta 是标量，C 是 n x n 对称矩阵，A 在第一种情况下是 n x k 矩阵，在第二种情况下是 k x n 矩阵。

integer(4) function cublasXtdsyrk(h, uplo, trans, n, k, alpha, a, lda, beta, c, ldc)
  type(cublasXtHandle) :: h
  integer :: uplo, trans
  integer(kind=c_intptr_t) :: n, k, lda, ldc
  real(8), dimension(lda, *) :: a
  real(8), dimension(ldc, *) :: c
  real(8) :: alpha, beta

2.8.33. cublasXtDsyr2k

DSYR2K 执行对称秩 2k 运算 C := alpha*A*B**T + alpha*B*A**T + beta*C 或 C := alpha*A**T*B + alpha*B**T*A + beta*C 之一，其中 alpha 和 beta 是标量，C 是 n x n 对称矩阵，A 和 B 在第一种情况下是 n x k 矩阵，在第二种情况下是 k x n 矩阵。

integer(4) function cublasXtdsyr2k(h, uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasXtHandle) :: h
  integer :: uplo, trans
  integer(kind=c_intptr_t) :: n, k, lda, ldb, ldc
  real(8), dimension(lda, *) :: a
  real(8), dimension(ldb, *) :: b
  real(8), dimension(ldc, *) :: c
  real(8) :: alpha, beta

2.8.34. cublasXtDsyrkx

DSYRKX 执行对称秩 k 更新 C := alpha*A*B**T + beta*C 的变体，其中 alpha 和 beta 是标量，C 是以三角下或上三角模式存储的 n x n 对称矩阵，A 和 B 是 n x k 矩阵。当 B 以某种方式使得结果保证对称时，可以使用此例程。有关更多详细信息，请参阅 CUBLAS 文档。

integer(4) function cublasXtdsyrkx(h, uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasXtHandle) :: h
  integer :: uplo, trans
  integer(kind=c_intptr_t) :: n, k, lda, ldb, ldc
  real(8), dimension(lda, *) :: a
  real(8), dimension(ldb, *) :: b
  real(8), dimension(ldc, *) :: c
  real(8) :: alpha, beta

2.8.35. cublasXtDtrmm

DTRMM 执行矩阵-矩阵运算 B := alpha*op( A )*B 或 B := alpha*B*op( A ) 之一，其中 alpha 是标量，B 是 m x n 矩阵，A 是单位或非单位上或下三角矩阵，op( A ) 是 op( A ) = A 或 op( A ) = A**T 之一。

integer(4) function cublasXtdtrmm(h, side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb, c, ldc)
  type(cublasXtHandle) :: h
  integer :: side, uplo, transa, diag
  integer(kind=c_intptr_t) :: m, n, lda, ldb, ldc
  real(8), dimension(lda, *) :: a
  real(8), dimension(ldb, *) :: b
  real(8), dimension(ldc, *) :: c
  real(8) :: alpha

2.8.36. cublasXtDtrsm

DTRSM 求解矩阵方程 op( A )*X = alpha*B 或 X*op( A ) = alpha*B 之一，其中 alpha 是标量，X 和 B 是 m x n 矩阵，A 是单位或非单位上或下三角矩阵，op( A ) 是 op( A ) = A 或 op( A ) = A**T 之一。矩阵 X 在 B 上被覆盖。

integer(4) function cublasXtdtrsm(h, side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)
  type(cublasXtHandle) :: h
  integer :: side, uplo, transa, diag
  integer(kind=c_intptr_t) :: m, n, lda, ldb
  real(8), dimension(lda, *) :: a
  real(8), dimension(ldb, *) :: b
  real(8) :: alpha

2.8.37. cublasXtDspmm

DSPMM 执行对称压缩矩阵-矩阵运算 C := alpha*A*B + beta*C，或 C := alpha*B*A + beta*C 之一，其中 alpha 和 beta 是标量，A 是以压缩格式存储的 n x n 对称矩阵，B 和 C 是 m x n 矩阵。

integer(4) function cublasXtdspmm(h, side, uplo, m, n, alpha, ap, b, ldb, beta, c, ldc)
  type(cublasXtHandle) :: h
  integer :: side, uplo
  integer(kind=c_intptr_t) :: m, n, ldb, ldc
  real(8), dimension(*) :: ap
  real(8), dimension(ldb, *) :: b
  real(8), dimension(ldc, *) :: c
  real(8) :: alpha, beta

2.8.38. cublasXtZgemm

ZGEMM 执行矩阵-矩阵运算 C := alpha*op( A )*op( B ) + beta*C 之一，其中 op( X ) 是 op( X ) = X 或 op( X ) = X**T 或 op( X ) = X**H 之一，alpha 和 beta 是标量，A、B 和 C 是矩阵，其中 op( A ) 是一个 m 乘 k 矩阵，op( B ) 是一个 k 乘 n 矩阵，C 是一个 m 乘 n 矩阵。

integer(4) function cublasXtzgemm(h, transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasXtHandle) :: h
  integer :: transa, transb
  integer(kind=c_intptr_t) :: m, n, k, lda, ldb, ldc
  complex(8), dimension(lda, *) :: a
  complex(8), dimension(ldb, *) :: b
  complex(8), dimension(ldc, *) :: c
  complex(8) :: alpha, beta

2.8.39. cublasXtZhemm

ZHEMM 执行矩阵-矩阵运算 C := alpha*A*B + beta*C 或 C := alpha*B*A + beta*C 之一，其中 alpha 和 beta 是标量，A 是一个埃尔米特矩阵，B 和 C 是 m 乘 n 矩阵。

integer(4) function cublasXtzhemm(h, side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasXtHandle) :: h
  integer :: side, uplo
  integer(kind=c_intptr_t) :: m, n, lda, ldb, ldc
  complex(8), dimension(lda, *) :: a
  complex(8), dimension(ldb, *) :: b
  complex(8), dimension(ldc, *) :: c
  complex(8) :: alpha, beta

2.8.40. cublasXtZherk

ZHERK 执行埃尔米特秩 k 运算 C := alpha*A*A**H + beta*C 或 C := alpha*A**H*A + beta*C 之一，其中 alpha 和 beta 是实标量，C 是一个 n 乘 n 埃尔米特矩阵，A 在第一种情况下是一个 n 乘 k 矩阵，在第二种情况下是一个 k 乘 n 矩阵。

integer(4) function cublasXtzherk(h, uplo, trans, n, k, alpha, a, lda, beta, c, ldc)
  type(cublasXtHandle) :: h
  integer :: uplo, trans
  integer(kind=c_intptr_t) :: n, k, lda, ldc
  complex(8), dimension(lda, *) :: a
  complex(8), dimension(ldc, *) :: c
  real(8) :: alpha, beta

2.8.41. cublasXtZher2k

ZHER2K 执行埃尔米特秩 2k 运算 C := alpha*A*B**H + conjg( alpha )*B*A**H + beta*C 或 C := alpha*A**H*B + conjg( alpha )*B**H*A + beta*C 之一，其中 alpha 和 beta 是标量，beta 是实数，C 是一个 n 乘 n 埃尔米特矩阵，A 和 B 在第一种情况下是 n 乘 k 矩阵，在第二种情况下是 k 乘 n 矩阵。

integer(4) function cublasXtzher2k(h, uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasXtHandle) :: h
  integer :: uplo, trans
  integer(kind=c_intptr_t) :: n, k, lda, ldb, ldc
  complex(8), dimension(lda, *) :: a
  complex(8), dimension(ldb, *) :: b
  complex(8), dimension(ldc, *) :: c
  complex(8) :: alpha
  real(8) :: beta

2.8.42. cublasXtZherkx

ZHERKX 执行埃尔米特秩 k 运算 C := alpha*A*B**H + beta*C 的变体，其中 alpha 和 beta 是实标量，C 是一个以 lower 或 upper 模式存储的 n 乘 n 埃尔米特矩阵，A 和 B 是 n 乘 k 矩阵。有关更多详细信息，请参阅 CUBLAS 文档。

integer(4) function cublasXtzherkx(h, uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasXtHandle) :: h
  integer :: uplo, trans
  integer(kind=c_intptr_t) :: n, k, lda, ldb, ldc
  complex(8), dimension(lda, *) :: a
  complex(8), dimension(ldb, *) :: b
  complex(8), dimension(ldc, *) :: c
  complex(8) :: alpha
  real(8) :: beta

2.8.43. cublasXtZsymm

ZSYMM 执行矩阵-矩阵运算 C := alpha*A*B + beta*C 或 C := alpha*B*A + beta*C 之一，其中 alpha 和 beta 是标量，A 是一个对称矩阵，B 和 C 是 m 乘 n 矩阵。

integer(4) function cublasXtzsymm(h, side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasXtHandle) :: h
  integer :: side, uplo
  integer(kind=c_intptr_t) :: m, n, lda, ldb, ldc
  complex(8), dimension(lda, *) :: a
  complex(8), dimension(ldb, *) :: b
  complex(8), dimension(ldc, *) :: c
  complex(8) :: alpha, beta

2.8.44. cublasXtZsyrk

ZSYRK 执行对称秩 k 运算 C := alpha*A*A**T + beta*C 或 C := alpha*A**T*A + beta*C 之一，其中 alpha 和 beta 是标量，C 是一个 n 乘 n 对称矩阵，A 在第一种情况下是一个 n 乘 k 矩阵，在第二种情况下是一个 k 乘 n 矩阵。

integer(4) function cublasXtzsyrk(h, uplo, trans, n, k, alpha, a, lda, beta, c, ldc)
  type(cublasXtHandle) :: h
  integer :: uplo, trans
  integer(kind=c_intptr_t) :: n, k, lda, ldc
  complex(8), dimension(lda, *) :: a
  complex(8), dimension(ldc, *) :: c
  complex(8) :: alpha, beta

2.8.45. cublasXtZsyr2k

ZSYR2K 执行对称秩 2k 运算 C := alpha*A*B**T + alpha*B*A**T + beta*C 或 C := alpha*A**T*B + alpha*B**T*A + beta*C 之一，其中 alpha 和 beta 是标量，C 是一个 n 乘 n 对称矩阵，A 和 B 在第一种情况下是 n 乘 k 矩阵，在第二种情况下是 k 乘 n 矩阵。

integer(4) function cublasXtzsyr2k(h, uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasXtHandle) :: h
  integer :: uplo, trans
  integer(kind=c_intptr_t) :: n, k, lda, ldb, ldc
  complex(8), dimension(lda, *) :: a
  complex(8), dimension(ldb, *) :: b
  complex(8), dimension(ldc, *) :: c
  complex(8) :: alpha, beta

2.8.46. cublasXtZsyrkx

ZSYRKX 执行对称秩 k 更新 C := alpha*A*B**T + beta*C 的变体，其中 alpha 和 beta 是标量，C 是一个以 lower 或 upper 模式存储的 n 乘 n 对称矩阵，A 和 B 是 n 乘 k 矩阵。当 B 以某种方式使得结果保证对称时，可以使用此例程。有关更多详细信息，请参阅 CUBLAS 文档。

integer(4) function cublasXtzsyrkx(h, uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
  type(cublasXtHandle) :: h
  integer :: uplo, trans
  integer(kind=c_intptr_t) :: n, k, lda, ldb, ldc
  complex(8), dimension(lda, *) :: a
  complex(8), dimension(ldb, *) :: b
  complex(8), dimension(ldc, *) :: c
  complex(8) :: alpha, beta

2.8.47. cublasXtZtrmm

ZTRMM 执行矩阵-矩阵运算 B := alpha*op( A )*B 或 B := alpha*B*op( A ) 之一，其中 alpha 是一个标量，B 是一个 m 乘 n 矩阵，A 是一个单位或非单位上或下三角矩阵，op( A ) 是 op( A ) = A 或 op( A ) = A**T 或 op( A ) = A**H 之一。

integer(4) function cublasXtztrmm(h, side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb, c, ldc)
  type(cublasXtHandle) :: h
  integer :: side, uplo, transa, diag
  integer(kind=c_intptr_t) :: m, n, lda, ldb, ldc
  complex(8), dimension(lda, *) :: a
  complex(8), dimension(ldb, *) :: b
  complex(8), dimension(ldc, *) :: c
  complex(8) :: alpha

2.8.48. cublasXtZtrsm

ZTRSM 求解矩阵方程 op( A )*X = alpha*B 或 X*op( A ) = alpha*B 之一，其中 alpha 是一个标量，X 和 B 是 m 乘 n 矩阵，A 是一个单位或非单位上或下三角矩阵，op( A ) 是 op( A ) = A 或 op( A ) = A**T 或 op( A ) = A**H 之一。矩阵 X 在 B 上被覆盖。

integer(4) function cublasXtztrsm(h, side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)
  type(cublasXtHandle) :: h
  integer :: side, uplo, transa, diag
  integer(kind=c_intptr_t) :: m, n, lda, ldb
  complex(8), dimension(lda, *) :: a
  complex(8), dimension(ldb, *) :: b
  complex(8) :: alpha

2.8.49. cublasXtZspmm

ZSPMM 执行对称压缩矩阵-矩阵运算 C := alpha*A*B + beta*C，或 C := alpha*B*A + beta*C 之一，其中 alpha 和 beta 是标量，A 是以压缩格式存储的 n x n 对称矩阵，B 和 C 是 m x n 矩阵。

integer(4) function cublasXtzspmm(h, side, uplo, m, n, alpha, ap, b, ldb, beta, c, ldc)
  type(cublasXtHandle) :: h
  integer :: side, uplo
  integer(kind=c_intptr_t) :: m, n, ldb, ldc
  complex(8), dimension(*) :: ap
  complex(8), dimension(ldb, *) :: b
  complex(8), dimension(ldc, *) :: c
  complex(8) :: alpha, beta

2.9. CUBLAS MP 模块函数

本节包含 cuBLAS MP 模块函数的接口。用户可以通过在程序单元中插入代码行 use cublasMp 来访问此模块。cublasMp 库是一个主机端库，它在分布式设备数据上运行，并支持多进程和 GPU。它基于 ScaLAPACK PBLAS 库。

从 25.1 版本开始，cublasMp 库针对 CUDA 版本 > 12.0 具有更新的 API，特别是 cublasMp 版本 0.3.0 及更高版本。对于 CUDA 版本 <= 11.8 的用户，旧模块已重命名，您可以通过在程序单元中插入代码行 use cublasMp02 来访问它。版本 0.3.x 的一个主要区别是，所有 cublasMp 函数现在都返回 type(cublasMpStatus) 而不是 integer(4)。还有其他添加和更改，我们将在下面的各个描述中指出。有关 cublasMp 0.2.x 的 Fortran 接口的完整文档，请参阅 2024 NVHPC 版本的文档。

新模块中提供了一些用于比较和赋值 type(cublasMpStatus) 变量和表达式的重载操作。

cublasMp 模块包含 cublas 模块中的所有通用类型和定义、nvf_cal_comm 模块中的类型和接口，以及这些附加类型和枚举

! Version information
integer, parameter :: CUBLASMP_VER_MAJOR = 0
integer, parameter :: CUBLASMP_VER_MINOR = 3
integer, parameter :: CUBLASMP_VER_PATCH = 0
integer, parameter :: CUBLASMP_VERSION = &
     (CUBLASMP_VER_MAJOR * 1000 + CUBLASMP_VER_MINOR * 100 + CUBLASMP_VER_PATCH)

! New status type, with version 0.3.0
TYPE cublasMpStatus
  integer(4) :: stat
END TYPE
TYPE(cublasMpStatus), parameter :: &
  CUBLASMP_STATUS_SUCCESS                = cublasMpStatus(0), &
  CUBLASMP_STATUS_NOT_INITIALIZED        = cublasMpStatus(1), &
  CUBLASMP_STATUS_ALLOCATION_FAILED      = cublasMpStatus(2), &
  CUBLASMP_STATUS_INVALID_VALUE          = cublasMpStatus(3), &
  CUBLASMP_STATUS_ARCHITECTURE_MISMATCH  = cublasMpStatus(4), &
  CUBLASMP_STATUS_EXECUTION_FAILED       = cublasMpStatus(5), &
  CUBLASMP_STATUS_INTERNAL_ERROR         = cublasMpStatus(6), &
  CUBLASMP_STATUS_NOT_SUPPORTED          = cublasMpStatus(7)

! Grid Layout
TYPE cublasMpGridLayout
  integer(4) :: grid
END TYPE
TYPE(cublasMpGridLayout), parameter :: &
  CUBLASMP_GRID_LAYOUT_COL_MAJOR = cublasMpGridLayout(0), &
  CUBLASMP_GRID_LAYOUT_ROW_MAJOR = cublasMpGridLayout(1)

! Matmul Descriptor Attributes
TYPE cublasMpMatmulDescriptorAttribute
  integer(4) :: attr
END TYPE
TYPE(cublasMpMatmulDescriptorAttribute), parameter :: &
  CUBLASMP_MATMUL_DESCRIPTOR_ATTRIBUTE_TRANSA       = cublasMpMatmulDescriptorAttribute(0), &
  CUBLASMP_MATMUL_DESCRIPTOR_ATTRIBUTE_TRANSB       = cublasMpMatmulDescriptorAttribute(1), &
  CUBLASMP_MATMUL_DESCRIPTOR_ATTRIBUTE_COMPUTE_TYPE = cublasMpMatmulDescriptorAttribute(2), &
  CUBLASMP_MATMUL_DESCRIPTOR_ATTRIBUTE_ALGO_TYPE    = cublasMpMatmulDescriptorAttribute(3)

! Matmul Algorithm Type
TYPE cublasMpMatmulAlgoType
  integer(4) :: atyp
END TYPE
TYPE(cublasMpMatmulAlgoType), parameter :: &
  CUBLASMP_MATMUL_ALGO_TYPE_DEFAULT          = cublasMpMatmulAlgoType(0), &
  CUBLASMP_MATMUL_ALGO_TYPE_SPLIT_P2P        = cublasMpMatmulAlgoType(1), &
  CUBLASMP_MATMUL_ALGO_TYPE_SPLIT_MULTICAST  = cublasMpMatmulAlgoType(2), &
  CUBLASMP_MATMUL_ALGO_TYPE_ATOMIC_P2P       = cublasMpMatmulAlgoType(3), &
  CUBLASMP_MATMUL_ALGO_TYPE_ATOMIC_MULTICAST = cublasMpMatmulAlgoType(4)

TYPE cublasMpHandle
  TYPE(C_PTR)  :: handle
END TYPE

TYPE cublasMpGrid
  TYPE(C_PTR)  :: handle
END TYPE

TYPE cublasMpMatrixDescriptor
  TYPE(C_PTR)  :: handle
END TYPE

TYPE cublasMpMatmulDescriptor
  TYPE(C_PTR)  :: handle
END TYPE

2.9.1. cublasMpCreate

此函数初始化 cublasMp API 并创建一个句柄，指向保存 cublasMp 库上下文的不透明结构。它在主机和设备上分配硬件资源，并且必须在进行任何其他 cublasMp 库调用之前调用。

type(cublasMpStatus) function cublasMpCreate(handle, stream)
  type(cublasMpHandle) :: handle
  integer(kind=cuda_stream_kind()) :: stream

2.9.2. cublasMpDestroy

此函数释放 cublasMp 句柄和上下文使用的资源。

type(cublasMpStatus) function cublasMpDestroy(handle)
  type(cublasMpHandle) :: handle

2.9.3. cublasMpStreamSet

此函数设置要在 cublasMp 计算中使用的 CUDA 流。

type(cublasMpStatus) function cublasMpStreamSet(handle, stream)
  type(cublasMpHandle) :: handle
  integer(kind=cuda_stream_kind()) :: stream

2.9.4. cublasMpStreamGet

此函数返回 cublasMp 计算中使用的当前 CUDA 流。

type(cublasMpStatus) function cublasMpStreamGet(handle, stream)
  type(cublasMpHandle) :: handle
  integer(kind=cuda_stream_kind()) :: stream

2.9.5. cublasMpGetVersion

此函数返回 cublasMp 库的版本号。

type(cublasMpStatus) function cublasMpGetVersion(handle, version)
  type(cublasMpHandle) :: handle
  integer(4) :: version

2.9.6. cublasMpGridCreate

此函数初始化 cublasMp 库中使用的网格数据结构。它接受一个通信器以及与数据布局相关的其他信息作为输入。从版本 0.3.0 开始，它不再接受句柄参数。

type(cublasMpStatus) function cublasMpGridCreate(nprow, npcol, &
          layout, comm, grid)
  integer(8) :: nprow, npcol
  type(cublasMpGridLayout) :: layout ! usually column major in Fortran
  type(cal_comm) :: comm
  type(cublasMpGrid), intent(out) :: grid

2.9.7. cublasMpGridDestroy

此函数释放 cublasMp 库中使用的网格数据结构。从版本 0.3.0 开始，它不再接受句柄参数。

type(cublasMpStatus) function cublasMpGridDestroy(grid)
  type(cublasMpGrid) :: grid

2.9.8. cublasMpMatrixDescriptorCreate

此函数初始化 cublasMp 库中使用的矩阵描述符对象。它接受全局数组中的行数 (M) 和列数 (N)，以及每个维度上的分块因子。RSRC 和 CSRC 当前必须为 0。LLD 是本地矩阵的引导维度，在分块和分布矩阵之后。从版本 0.3.0 开始，它不再接受句柄参数。

type(cublasMpStatus) function cublasMpMatrixDescriptorCreate(M, N, MB, NB, &
          RSRC, CSRC, LLD, dataType, grid, descr)
  integer(8) :: M, N, MB, NB, RSRC, CSRC, LLD
  type(cudaDataType) :: dataType
  type(cublasMpGrid) :: grid
  type(cublasMpMatrixDescriptor), intent(out)  :: descr

2.9.9. cublasMpMatrixDescriptorDestroy

此函数释放 cublasMp 库中使用的矩阵描述符对象。从版本 0.3.0 开始，它不再接受句柄参数。

type(cublasMpStatus) function cublasMpMatrixDescriptorDestroy(descr)
  type(cublasMpMatrixDescriptor) :: descr

2.9.10. cublasMpMatrixDescriptorInit

此函数初始化 cublasMp 库中使用的矩阵描述符对象中的值。它接受全局数组中的行数 (M) 和列数 (N)，以及每个维度上的分块因子。RSRC 和 CSRC 当前必须为 0。LLD 是本地矩阵的引导维度，在分块和分布矩阵之后。

type(cublasMpStatus) function cublasMpMatrixDescriptorInit(M, N, MB, NB, &
          RSRC, CSRC, LLD, dataType, grid, descr)
  integer(8) :: M, N, MB, NB, RSRC, CSRC, LLD
  type(cudaDataType) :: dataType
  type(cublasMpGrid) :: grid
  type(cublasMpMatrixDescriptor), intent(out)  :: descr

2.9.11. cublasMpNumroc

此函数计算（并返回）分布式矩阵的本地行数或列数，类似于 ScaLAPACK NUMROC 函数。

type(cublasMpStatus) function cublasMpNumroc(N, NB, iproc, isrcproc, nprocs)
  integer(8) :: N, NB
  integer(4) :: iproc, isrcproc, nprocs

2.9.12. cublasMpMatmulDescriptorCreate

此函数初始化 cublasMp 库中使用的 matmul 描述符对象。

type(cublasMpStatus) function cublasMpMatmulDescriptorCreate(descr, computeType)
  type(cublasMpMatmulDescriptor)  :: descr
  type(cublasComputeType) :: computeType

2.9.13. cublasMpMatmulDescriptorDestroy

此函数销毁 cublasMp 库中使用的 matmul 描述符对象。

type(cublasMpStatus) function cublasMpMatmulDescriptorDestroy(descr)
  type(cublasMpMatmulDescriptor)  :: descr

2.9.14. cublasMpMatmulDescriptorAttributeSet

此函数设置 cublasMp 库中使用的 matmul 描述符对象中的属性。

type(cublasMpStatus) function cublasMpMatmulDescriptorAttributeSet(descr, attr &
          buf, sizeInBytes)
  type(cublasMpMatmulDescriptor)  :: descr
  type(cublasMpMatmulDescriptorAttribute)  :: attr
  integer(1) :: buf(sizeInBytes) ! Any type, kind, or rank allowed
  integer(8) :: sizeInBytes

2.9.15. cublasMpMatmulDescriptorAttributeGet

此函数检索 cublasMp 库中使用的 matmul 描述符对象中的属性。

type(cublasMpStatus) function cublasMpMatmulDescriptorAttributeGet(descr, attr &
          buf, sizeInBytes, sizeWritten)
  type(cublasMpMatmulDescriptor)  :: descr
  type(cublasMpMatmulDescriptorAttribute)  :: attr
  integer(1) :: buf(sizeInBytes) ! Any type, kind, or rank allowed
  integer(8) :: sizeInBytes, sizeWritten

2.9.16. cublasMpGemr2D_bufferSize

此函数计算 cublasMpGemr2D 的工作空间需求

type(cublasMpStatus) function cublasMpGemr2D_bufferSize(handle, M, N, &
   A, IA, JA, descrA, B, IB, JB, descrB, &
   devWorkspaceSizeInBytes, hostWorkspaceSizeInBytes, comm)
   type(cublasMpHandle) :: handle
   integer(8), intent(in) :: M, N, IA, JA, IB, JB
   real(4), device, dimension(*) :: A, B  ! Any supported type and kind
   type(cublasMpMatrixDescriptor) :: descrA, descrB
   integer(8), intent(out) :: devWorkspaceSizeInBytes, hostWorkspaceSizeInBytes
   type(cal_comm) :: comm

2.9.17. cublasMpGemr2D

此函数将矩阵从一种分布式形式复制到另一种形式。每个矩阵的布局在矩阵描述符中定义。M 和 N 是全局矩阵维度。IA、JA、IB 和 JB 是基于 1 的，并且对于完整矩阵通常等于 1。

type(cublasMpStatus) function cublasMpGemr2D(handle, M, N,  &
   A, IA, JA, descrA, B, IB, JB, descrB, &
   bufferOnDevice, devWorkspaceSizeInBytes, &
   bufferOnHost, hostWorkspaceSizeInBytes, comm)
   type(cublasMpHandle) :: handle
   integer(8), intent(in) :: M, N, IA, JA, IB, JB
   real(4), device, dimension(*) :: A, B  ! Any supported type and kind
   type(cublasMpMatrixDescriptor) :: descrA, descrB
   integer(8), intent(in) :: devWorkspaceSizeInBytes, hostWorkspaceSizeInBytes
   integer(1), device :: bufferOnDevice(devWorkspaceSizeInBytes) ! Any type
   integer(1)         :: bufferOnHost(hostWorkspaceSizeInBytes)  ! Any type
   type(cal_comm) :: comm

2.9.18. cublasMpTrmr2D_bufferSize

此函数计算 cublasMpTrmr2D 的工作空间需求

type(cublasMpStatus) function cublasMpTrmr2D_bufferSize(handle, uplo, diag, &
   M, N, A, IA, JA, descrA, B, IB, JB, descrB, &
   devWorkspaceSizeInBytes, hostWorkspaceSizeInBytes, comm)
   type(cublasMpHandle) :: handle
   integer(4), intent(in) :: uplo, diag
   integer(8), intent(in) :: M, N, IA, JA, IB, JB
   real(4), device, dimension(*) :: A, B  ! Any supported type and kind
   type(cublasMpMatrixDescriptor) :: descrA, descrB
   integer(8), intent(out) :: devWorkspaceSizeInBytes, hostWorkspaceSizeInBytes
   type(cal_comm) :: comm

2.9.19. cublasMpTrmr2D

此函数将梯形矩阵从一种分布式形式复制到另一种形式。每个矩阵的布局在矩阵描述符中定义。M 和 N 是全局矩阵维度。IA、JA、IB 和 JB 是基于 1 的，并且对于完整矩阵通常等于 1。

type(cublasMpStatus) function cublasMpTrmr2D(handle, uplo, diag,  &
   M, N, A, IA, JA, descrA, B, IB, JB, descrB, &
   bufferOnDevice, devWorkspaceSizeInBytes, &
   bufferOnHost, hostWorkspaceSizeInBytes, comm)
   type(cublasMpHandle) :: handle
   integer(4), intent(in) :: uplo, diag
   integer(8), intent(in) :: M, N, IA, JA, IB, JB
   real(4), device, dimension(*) :: A, B  ! Any supported type and kind
   type(cublasMpMatrixDescriptor) :: descrA, descrB
   integer(8), intent(in) :: devWorkspaceSizeInBytes, hostWorkspaceSizeInBytes
   integer(1), device :: bufferOnDevice(devWorkspaceSizeInBytes) ! Any type
   integer(1)         :: bufferOnHost(hostWorkspaceSizeInBytes)  ! Any type
   type(cal_comm) :: comm

2.9.20. cublasMpGemm_bufferSize

此函数计算 cublasMpGemm 的工作空间需求。

type(cublasMpStatus) function cublasMpGemm_bufferSize(handle, transA, transB, M, N, K, &
   alpha, A, IA, JA, descrA, B, IB, JB, descrB, beta, C, IC, JC, descrC, &
   computeType, devWorkspaceSizeInBytes, hostWorkspaceSizeInBytes)
   type(cublasMpHandle) :: handle
   integer(4) :: transA, transB
   integer(8), intent(in) :: M, N, K, IA, JA, IB, JB, IC, JC
   real(4) :: alpha, beta  ! type and kind compatible with computeType
   real(4), device, dimension(*) :: A, B, C  ! Any supported type and kind
   type(cublasMpMatrixDescriptor) :: descrA, descrB, descrC
   type(cublasComputeType) :: computeType
   integer(8), intent(out) :: devWorkspaceSizeInBytes, hostWorkspaceSizeInBytes

2.9.21. cublasMpGemm

这是 BLAS GEMM 操作的多处理器版本，类似于 ScaLAPACK PBLAS 函数 pdgemm、pzgemm 等。

GEMM 执行以下矩阵-矩阵运算之一

C := alpha*op( A )*op( B ) + beta*C,

其中 op( X ) 是以下之一

op( X ) = X 或 op( X ) = X**T,

alpha 和 beta 是标量，A、B 和 C 是矩阵，其中 op( A ) 是 m x k 矩阵，op( B ) 是 k x n 矩阵，C 是 m x n 矩阵。A、B 和 C 的数据应正确分布在进程网格上。该映射包含在描述符 descrA、descrB 和 descrC 中，通过 cublasMpMatrixDescriptorCreate() 函数。数据类型也在那时指定。M、N 和 K 是全局矩阵维度。IA、JA、IB、JB、IC 和 JC 是基于 1 的，并且对于完整矩阵通常等于 1。Integer(4) 输入值将根据接口提升为 integer(8)。

type(cublasMpStatus) function cublasMpGemm(handle, transA, transB, M, N, K, &
   alpha, A, IA, JA, descrA, B, IB, JB, descrB, beta, C, IC, JC, descrC, &
   computeType, bufferOnDevice, devWorkspaceSizeInBytes, &
   bufferOnHost, hostWorkspaceSizeInBytes)
   type(cublasMpHandle) :: handle
   integer(4) :: transA, transB
   integer(8), intent(in) :: M, N, K, IA, JA, IB, JB, IC, JC
   real(4) :: alpha, beta  ! type and kind compatible with computeType
   real(4), device, dimension(*) :: A, B, C  ! Any supported type and kind
   type(cublasMpMatrixDescriptor) :: descrA, descrB, descrC
   type(cublasComputeType) :: computeType
   integer(8), intent(in) :: devWorkspaceSizeInBytes, hostWorkspaceSizeInBytes
   integer(1), device :: bufferOnDevice(devWorkspaceInBytes) ! Any type
   integer(1)         :: bufferOnHost(hostWorkspaceInBytes)  ! Any type

2.9.22. cublasMpMatmul_bufferSize

此函数计算 cublasMpMatmul 的工作空间需求。

type(cublasMpStatus) function cublasMpMatmul_bufferSize(handle, matmulDescr, M, N, K, &
   alpha, A, IA, JA, descrA, B, IB, JB, descrB, beta, C, IC, JC, descrC, &
   D, ID, JD, descrD, devWorkspaceSizeInBytes, hostWorkspaceSizeInBytes)
   type(cublasMpHandle) :: handle
   type(cublasMpMatmulDescriptor) :: matmulDescr
   integer(8), intent(in) :: M, N, K, IA, JA, IB, JB, IC, JC, ID, JD
   real(4) :: alpha, beta  ! Any compatible kind
   real(4), device, dimension(*) :: A, B, C, D  ! Any supported type and kind
   type(cublasMpMatrixDescriptor) :: descrA, descrB, descrC, descrD
   integer(8), intent(out) :: devWorkspaceSizeInBytes, hostWorkspaceSizeInBytes

2.9.23. cublasMpMatmul

这是矩阵乘法操作的多处理器版本。

Matmul 执行以下矩阵-矩阵运算之一

D := alpha*op( A )*op( B ) + beta*C,

其中 op( X ) 是以下之一

op( X ) = X 或 op( X ) = X**T，由调用 cublasMpMatmulDescriptorAttributeSet() 设置。

alpha 和 beta 是标量，A、B、C 和 D 是矩阵，其中 op( A ) 是 m x k 矩阵，op( B ) 是 k x n 矩阵，C 和 D 是 m x n 矩阵。A、B、C 和 D 的数据应正确分布在进程网格上。该映射包含在描述符 descrA、descrB、descrC 和 descrD 中，通过 cublasMpMatrixDescriptorCreate() 函数。数据类型也在那里指定。M、N 和 K 是全局矩阵维度。IA、JA、IB、JB、IC、JC、ID 和 JD 是基于 1 的，并且对于完整矩阵通常等于 1。Integer(4) 输入值将根据接口提升为 integer(8)。

type(cublasMpStatus) function cublasMpMatmul(handle, matmulDescr, M, N, K, &
   alpha, A, IA, JA, descrA, B, IB, JB, descrB, beta, C, IC, JC, descrC, &
   D, ID, JD, descrD, bufferOnDevice, devWorkspaceSizeInBytes, &
   bufferOnHost, hostWorkspaceSizeInBytes)
   type(cublasMpHandle) :: handle
   type(cublasMpMatmulDescriptor) :: matmulDescr
   integer(8), intent(in) :: M, N, K, IA, JA, IB, JB, IC, JC, ID, JD
   real(4) :: alpha, beta  ! Any supported type and kind
   real(4), device, dimension(*) :: A, B, C, D  ! Any supported type and kind
   type(cublasMpMatrixDescriptor) :: descrA, descrB, descrC, descrD
   integer(8), intent(in) :: devWorkspaceSizeInBytes, hostWorkspaceSizeInBytes
   integer(1), device :: bufferOnDevice(devWorkspaceInBytes) ! Any type
   integer(1)         :: bufferOnHost(hostWorkspaceInBytes)  ! Any type

2.9.24. cublasMpSyrk

这是 BLAS SYRK 操作的多处理器版本，类似于 ScaLAPACK PBLAS 函数 pdsyrk、pzsyrk 等。

SYRK 执行以下对称秩 k 运算之一

C := alpha*A*A**T + beta*C, 或

C := alpha*A**T*A + beta*C

alpha 和 beta 是标量，A 和 C 是矩阵。A 是 N x K 或 K x N，具体取决于 trans 参数，C 是 N x N。A 和 C 的数据应正确分布在进程网格上。该映射包含在描述符 descrA 和 descrC 中，通过 cublasMpMatrixDescriptorCreate() 函数。数据类型也在那时指定。N 和 K 是全局矩阵维度。IA、JA、IC 和 JC 是基于 1 的，并且对于完整矩阵通常等于 1。Integer(4) 输入值将根据接口提升为 integer(8)。

type(cublasMpStatus) function cublasMpSyrk(handle, uplo, trans, &
   N, K, alpha, A, IA, JA, descrA, beta, C, IC, JC, descrC, &
   computeType, bufferOnDevice, devWorkspaceSizeInBytes, &
   bufferOnHost, hostWorkspaceSizeInBytes)
   type(cublasMpHandle) :: handle
   integer(4) :: uplo, trans
   integer(8), intent(in) :: N, K, IA, JA, IC, JC
   real(4) :: alpha, beta  ! type and kind compatible with computeType
   real(4), device, dimension(*) :: A, C  ! Any supported type and kind
   type(cublasMpMatrixDescriptor) :: descrA, descrC
   type(cublasComputeType) :: computeType
   integer(8), intent(in) :: devWorkspaceSizeInBytes, hostWorkspaceSizeInBytes
   integer(1), device :: bufferOnDevice(devWorkspaceSizeInBytes) ! Any type
   integer(1)         :: bufferOnHost(hostWorkspaceSizeInBytes)  ! Any type

2.9.25. cublasMpSyrk

这是 BLAS SYRK 操作的多处理器版本，类似于 ScaLAPACK PBLAS 函数 pdsyrk、pzsyrk 等。

SYRK 执行以下对称秩 k 运算之一

C := alpha*A*A**T + beta*C, 或

C := alpha*A**T*A + beta*C

alpha 和 beta 是标量，A 和 C 是矩阵。A 是 N x K 或 K x N，具体取决于 trans 参数，C 是 N x N。A 和 C 的数据应正确分布在进程网格上。该映射包含在描述符 descrA 和 descrC 中，通过 cublasMpMatrixDescriptorCreate() 函数。数据类型也在那时指定。N 和 K 是全局矩阵维度。IA、JA、IC 和 JC 是基于 1 的，并且对于完整矩阵通常等于 1。Integer(4) 输入值将根据接口提升为 integer(8)。

type(cublasMpStatus) function cublasMpSyrk(handle, uplo, trans, &
   N, K, alpha, A, IA, JA, descrA, beta, C, IC, JC, descrC, &
   computeType, bufferOnDevice, devWorkspaceSizeInBytes, &
   bufferOnHost, hostWorkspaceSizeInBytes)
   type(cublasMpHandle) :: handle
   integer(4) :: uplo, trans
   integer(8), intent(in) :: N, K, IA, JA, IC, JC
   real(4) :: alpha, beta  ! type and kind compatible with computeType
   real(4), device, dimension(*) :: A, C  ! Any supported type and kind
   type(cublasMpMatrixDescriptor) :: descrA, descrC
   type(cublasComputeType) :: computeType
   integer(8), intent(in) :: devWorkspaceSizeInBytes, hostWorkspaceSizeInBytes
   integer(1), device :: bufferOnDevice(devWorkspaceSizeInBytes) ! Any type
   integer(1)         :: bufferOnHost(hostWorkspaceSizeInBytes)  ! Any type

2.9.26. cublasMpTrsm_bufferSize

此函数计算 cublasMpTrsm 的工作空间需求。

type(cublasMpStatus) function cublasMpTrsm_bufferSize(handle, side, uplo, trans, diag, &
   M, N, alpha, A, IA, JA, descrA, B, IB, JB, descrB, &
   computeType, devWorkspaceSizeInBytes, hostWorkspaceSizeInBytes)
   type(cublasMpHandle) :: handle
   integer(4) :: side, uplo, trans, diag
   integer(8), intent(in) :: M, N, IA, JA, IB, JB
   real(4) :: alpha  ! type and kind compatible with computeType
   real(4), device, dimension(*) :: A, B  ! Any supported type and kind
   type(cublasMpMatrixDescriptor) :: descrA, descrB
   type(cublasComputeType) :: computeType
   integer(8), intent(out) :: devWorkspaceSizeInBytes, hostWorkspaceSizeInBytes

2.9.27. cublasMpTrsm

这是 BLAS TRSM 操作的多处理器版本，类似于 ScaLAPACK PBLAS 函数 pdtrsm、pztrsm 等。

TRSM 求解以下矩阵方程之一

op( A )*X = alpha*B, 或

X*op( A ) = alpha*B

alpha 是标量，A 和 B 是矩阵，其维度由 side 参数确定。A 和 B 的数据应正确分布在进程网格上。该映射包含在描述符 descrA 和 descrB 中，通过 cublasMpMatrixDescriptorCreate() 函数。数据类型也在那时指定。M 和 N 是全局矩阵维度。IA、JA、IB 和 JB 是基于 1 的，并且对于完整矩阵通常等于 1。Integer(4) 输入值将根据接口提升为 integer(8)。

type(cublasMpStatus) function cublasMpTrsm(handle, side, uplo, trans, diag,  &
   M, N, alpha, A, IA, JA, descrA, B, IB, JB, descrB, &
   computeType, bufferOnDevice, devWorkspaceSizeInBytes, &
   bufferOnHost, hostWorkspaceSizeInBytes)
   type(cublasMpHandle) :: handle
   integer(4) :: side, uplo, trans, diag
   integer(8), intent(in) :: M, N, IA, JA, IB, JB
   real(4) :: alpha  ! type and kind compatible with computeType
   real(4), device, dimension(*) :: A, B  ! Any supported type and kind
   type(cublasMpMatrixDescriptor) :: descrA, descrB
   type(cublasComputeType) :: computeType
   integer(8), intent(in) :: devWorkspaceSizeInBytes, hostWorkspaceSizeInBytes
   integer(1), device :: bufferOnDevice(devWorkspaceSizeInBytes) ! Any type
   integer(1)         :: bufferOnHost(hostWorkspaceSizeInBytes)     ! Any type

2.9.28. cublasMpGeadd_bufferSize

此函数计算 cublasMpGeadd 的工作空间需求。

type(cublasMpStatus) function cublasMpGeadd_bufferSize(handle, trans, &
   M, N, alpha, A, IA, JA, descrA, beta, C, IC, JC, descrC, &
   devWorkspaceSizeInBytes, hostWorkspaceSizeInBytes)
   type(cublasMpHandle) :: handle
   integer(4) :: trans
   integer(8), intent(in) :: M, N, IA, JA, IC, JC
   real(4) :: alpha, beta  ! Any compatible kind
   real(4), device, dimension(*) :: A, C  ! Any supported type and kind
   type(cublasMpMatrixDescriptor) :: descrA, descrC
   integer(8), intent(out) :: devWorkspaceSizeInBytes, hostWorkspaceSizeInBytes

2.9.29. cublasMpGeadd

这是一般矩阵加法函数的多处理器版本。

GEADD 执行矩阵-矩阵加法运算

C := alpha*A + beta*C

alpha 和 beta 是标量，A 和 C 是矩阵。A 的维度取决于 trans 参数，可以是 M x N 或 N x M，C 的维度是 M x N。A 和 C 的数据应在进程网格上正确分布。该映射包含在描述符 descrA 和 descrC 中，通过 cublasMpMatrixDescriptorCreate() 函数创建。数据类型也在那时指定。M 和 N 是全局矩阵维度。IA、JA、IC 和 JC 是从 1 开始的索引，对于完整矩阵通常等于 1。Integer(4) 输入值将根据接口提升为 integer(8)。

type(cublasMpStatus) function cublasMpGeadd(handle, trans, &
   M, N, alpha, A, IA, JA, descrA, beta, C, IC, JC, descrC, &
   bufferOnDevice, devWorkspaceSizeInBytes, &
   bufferOnHost, hostWorkspaceSizeInBytes)
   type(cublasMpHandle) :: handle
   integer(4) :: trans
   integer(8), intent(in) :: M, N, IA, JA, IC, JC
   real(4) :: alpha, beta  ! Any compatible type and kind
   real(4), device, dimension(*) :: A, C  ! Any supported type and kind
   type(cublasMpMatrixDescriptor) :: descrA, descrC
   integer(8), intent(in) :: devWorkspaceSizeInBytes, hostWorkspaceSizeInBytes
   integer(1), device :: bufferOnDevice(devWorkspaceSizeInBytes) ! Any type
   integer(1)         :: bufferOnHost(hostWorkspaceSizeInBytes)  ! Any type

2.9.30. cublasMpTradd_bufferSize

此函数计算 cublasMpTradd 的工作空间需求。

type(cublasMpStatus) function cublasMpTradd_bufferSize(handle, uplo, trans, &
   M, N, alpha, A, IA, JA, descrA, beta, C, IC, JC, descrC, &
   devWorkspaceSizeInBytes, hostWorkspaceSizeInBytes)
   type(cublasMpHandle) :: handle
   integer(4) :: uplo, trans
   integer(8), intent(in) :: M, N, IA, JA, IC, JC
   real(4) :: alpha, beta  ! Any compatible kind
   real(4), device, dimension(*) :: A, C  ! Any supported type and kind
   type(cublasMpMatrixDescriptor) :: descrA, descrC
   integer(8), intent(out) :: devWorkspaceSizeInBytes, hostWorkspaceSizeInBytes

2.9.31. cublasMpTradd

这是梯形矩阵加法函数的多处理器版本。

TRADD 执行梯形矩阵-矩阵加法运算

C := alpha*A + beta*C

alpha 和 beta 是标量，A 和 C 是矩阵。A 的维度取决于 trans 参数，可以是 M x N 或 N x M，C 的维度是 M x N。A 和 C 的数据应在进程网格上正确分布。该映射包含在描述符 descrA 和 descrC 中，通过 cublasMpMatrixDescriptorCreate() 函数创建。数据类型也在那时指定。M 和 N 是全局矩阵维度。IA、JA、IC 和 JC 是从 1 开始的索引，对于完整矩阵通常等于 1。Integer(4) 输入值将根据接口提升为 integer(8)。

type(cublasMpStatus) function cublasMpTradd(handle, uplo, trans, &
   M, N, alpha, A, IA, JA, descrA, beta, C, IC, JC, descrC, &
   bufferOnDevice, devWorkspaceSizeInBytes, &
   bufferOnHost, hostWorkspaceSizeInBytes)
   type(cublasMpHandle) :: handle
   integer(4) :: uplo, trans
   integer(8), intent(in) :: M, N, IA, JA, IC, JC
   real(4) :: alpha, beta  ! Any compatible type and kind
   real(4), device, dimension(*) :: A, C  ! Any supported type and kind
   type(cublasMpMatrixDescriptor) :: descrA, descrC
   integer(8), intent(in) :: devWorkspaceSizeInBytes, hostWorkspaceSizeInBytes
   integer(1), device :: bufferOnDevice(devWorkspaceSizeInBytes) ! Any type
   integer(1)         :: bufferOnHost(hostWorkspaceSizeInBytes)  ! Any type

2.9.32. cublasMpLoggerSetFile

此函数指定要用作 cublasMp 日志文件的 Fortran 单元。

type(cublasMpStatus) function cublasMpLoggerSetFile(unit)
  integer :: unit

2.9.33. cublasMpLoggerOpenFile

此函数指定要打开并用作 cublasMp 日志文件的 Fortran 字符串。

type(cublasMpStatus) function cublasMpLoggerOpenFile(logFile)
  character*(*) :: logFile

2.9.34. cublasMpLoggerSetLevel

此函数指定 cublasMp 日志记录级别。

type(cublasMpStatus) function cublasMpLoggerSetLevel(level)
  integer :: level

2.9.35. cublasMpLoggerSetMask

此函数指定 cublasMp 日志记录掩码。

type(cublasMpStatus) function cublasMpLoggerSetMask(mask)
  integer :: mask

2.9.36. cublasMpLoggerForceDisable

此函数禁用 cublasMp 日志记录。

type(cublasMpStatus) function cublasMpLoggerForceDisable()

3. FFT 运行时库 API

本节介绍 cuFFT 库的 Fortran 接口。FFT 函数只能从主机代码访问。所有运行时 API 例程都是返回错误代码的整数函数；如果调用成功，它们返回 CUFFT_SUCCESS 值，如果出现错误，则返回另一个 cuFFT 状态返回值。

第 10 章包含从 OpenACC 和 CUDA Fortran 访问 cuFFT 库例程的示例。在这两种情况下，可以通过添加以下行来公开库的接口

use cufft

到您的程序单元。

从 21.9 版本开始，我们还支持 cufftXt 模块，该模块提供对 cuFFT 库中提供的多 GPU 支持的接口。这些接口可以在任何 Fortran 程序中使用，方法是添加以下行

use cufftxt

到您的程序单元。cufftXt 接口的文档从本章第 4 节开始。

除非在以下接口中提供了特定的 kind，否则 plain integer 类型意味着 integer(4)，plain real 类型意味着 real(4)。

3.1. CUFFT 定义和辅助函数

本节包含 cuFFT 库中使用的定义和数据类型，以及 cuFFT 辅助函数的接口。

cufft 模块包含以下常量和枚举

integer, parameter :: CUFFT_FORWARD = -1
integer, parameter :: CUFFT_INVERSE = 1

! CUFFT Status
enum, bind(C)
    enumerator :: CUFFT_SUCCESS        = 0
    enumerator :: CUFFT_INVALID_PLAN   = 1
    enumerator :: CUFFT_ALLOC_FAILED   = 2
    enumerator :: CUFFT_INVALID_TYPE   = 3
    enumerator :: CUFFT_INVALID_VALUE  = 4
    enumerator :: CUFFT_INTERNAL_ERROR = 5
    enumerator :: CUFFT_EXEC_FAILED    = 6
    enumerator :: CUFFT_SETUP_FAILED   = 7
    enumerator :: CUFFT_INVALID_SIZE   = 8
    enumerator :: CUFFT_UNALIGNED_DATA = 9
end enum

! CUFFT Transform Types
enum, bind(C)
    enumerator :: CUFFT_R2C = z'2a'     ! Real to Complex (interleaved)
    enumerator :: CUFFT_C2R = z'2c'     ! Complex (interleaved) to Real
    enumerator :: CUFFT_C2C = z'29'     ! Complex to Complex, interleaved
    enumerator :: CUFFT_D2Z = z'6a'     ! Double to Double-Complex
    enumerator :: CUFFT_Z2D = z'6c'     ! Double-Complex to Double
    enumerator :: CUFFT_Z2Z = z'69'     ! Double-Complex to Double-Complex
end enum

! CUFFT Data Layouts
enum, bind(C)
    enumerator :: CUFFT_COMPATIBILITY_NATIVE          = 0
    enumerator :: CUFFT_COMPATIBILITY_FFTW_PADDING    = 1
    enumerator :: CUFFT_COMPATIBILITY_FFTW_ASYMMETRIC = 2
    enumerator :: CUFFT_COMPATIBILITY_FFTW_ALL        = 3
end enum

integer, parameter :: CUFFT_COMPATIBILITY_DEFAULT = CUFFT_COMPATIBILITY_FFTW_PADDING

3.1.1. cufftSetCompatibilityMode

此函数配置 FFTW 兼容模式下 cuFFT 输出的布局。

integer(4) function cufftSetCompatibilityMode( plan, mode )
  integer :: plan
  integer :: mode

3.1.2. cufftSetStream

此函数设置 cuFFT 库用于执行其例程的流。

integer(4) function cufftSetStream(plan, stream)
  integer :: plan
  integer(kind=cuda_stream_kind) :: stream

3.1.3. cufftGetVersion

此函数返回 cuFFT 的版本号。

integer(4) function cufftGetVersion( version )
  integer :: version

3.1.4. cufftSetAutoAllocation

此函数指示调用者打算为已生成的计划分配和管理工作区。cuFFT 默认行为是在计划生成时分配工作区。如果在调用 cufftMakePlan*() 之一之前调用了 cufftSetAutoAllocation()，并将 autoAllocate 设置为 0，则 cuFFT 不会分配工作区。对于希望管理工作区分配的调用者来说，这是首选的顺序。

integer(4) function cufftSetAutoAllocation(plan, autoAllocate)
  integer(4) :: plan, autoallocate

3.1.5. cufftSetWorkArea

此函数覆盖与计划关联的工作区指针。如果工作区是自动分配的，则 cuFFT 会释放自动分配的空间。cufftExecute*() 调用假定工作区指针有效，并且它指向设备内存中的一个连续区域，该区域不与其他任何工作区重叠。如果不是这种情况，结果将是不确定的。

integer(4) function cufftSetWorkArea(plan, workArea)
  integer(4) :: plan
  integer, device :: workArea(*) ! Can be integer, real, complex
                                 ! or a type(c_devptr)

3.1.6. cufftDestroy

此函数释放与 cuFFT 计划关联的所有 GPU 资源，并销毁内部计划数据结构。

integer(4) function cufftDestroy( plan )
  integer :: plan

3.2. CUFFT 计划和估计大小函数

本节包含 cuFFT 库中用于创建计划和估计工作缓冲区大小的函数。

3.2.1. cufftPlan1d

此函数为指定的信号大小和数据类型创建 1D FFT 计划配置。Nx 是变换的大小；batch 是大小为 nx 的变换的数量。

integer(4) function cufftPlan1d(plan, nx, ffttype, batch)
  integer :: plan
  integer :: nx
  integer :: ffttype
  integer :: batch

3.2.2. cufftPlan2d

此函数根据指定的信号大小和数据类型创建 2D FFT 计划配置。对于 Fortran 数组 (nx,ny)，nx 是变换中第 1 维的大小，但它是函数的第 2 个大小参数；ny 是第 2 维的大小，并且是函数的第 1 个大小参数。

integer(4) function cufftPlan2d( plan, ny, nx, ffttype )
  integer :: plan
  integer :: ny, nx
  integer :: ffttype

3.2.3. cufftPlan3d

此函数根据指定的信号大小和数据类型创建 3D FFT 计划配置。对于 Fortran 数组 (nx,ny,nz)，nx 是变换中第 1 维的大小，但它是函数的第 3 个大小参数；nz 是第 3 维的大小，并且是函数的第 1 个大小参数。

integer(4) function cufftPlan3d( plan, nz, ny, nx, ffttype )
  integer :: plan
  integer :: nz, ny, nx
  integer :: ffttype

3.2.4. cufftPlanMany

此函数创建维度为 rank 的 FFT 计划配置，大小在数组 n 中指定。Batch 是要配置的变换的数量。此函数使用参数 inembed、istride、idist、onembed、ostride 和 odist 支持更复杂的输入和输出数据布局。在 C 函数中，如果 inembed 和 onembed 设置为 NULL，则所有其他步幅信息都将被忽略。当使用 NVIDIA cufft 模块时，Fortran 程序员可以通过将 F90 指针设置为 null() 来传递 NULL，可以通过直接赋值、使用 c_f_pointer() 和 c_null_ptr 作为第一个参数，或 nullify 语句，然后将 nullified F90 指针作为 inembed 和 onembed 哑元的实际参数传递。

integer(4) function cufftPlanMany(plan, rank, n, inembed, istride, idist, onembed, ostride, odist, ffttype, batch )
  integer :: plan
  integer :: rank
  integer :: n
  integer :: inembed, onembed
  integer :: istride, idist, ostride, odist
  integer :: ffttype, batch

3.2.5. cufftCreate

此函数为进一步的 cuFFT 调用创建不透明句柄，并在主机上分配一些小型数据结构。在 C 中，句柄类型当前 typedef 为 int，因此在 Fortran 中，我们使用 integer*4 来保存计划。

integer(4) function cufftCreate(plan)
  integer(4) :: plan

3.2.6. cufftMakePlan1d

在调用 cufftCreate() 之后，此函数为指定的信号大小和数据类型创建 1D FFT 计划配置。Nx 是变换的大小；batch 是大小为 nx 的变换的数量。如果在本次调用之前使用多个 GPU 调用了 cufftXtSetGPUs，则 workSize 是一个包含多个大小的数组。workSize 值以字节为单位。

integer(4) function cufftMakePlan1d(plan, nx, ffttype, batch, worksize)
  integer(4) :: plan
  integer(4) :: nx
  integer(4) :: ffttype
  integer(4) :: batch
  integer(kind=int_ptr_kind()) :: workSize(*)

3.2.7. cufftMakePlan2d

在调用 cufftCreate() 之后，此函数根据指定的信号大小和数据类型创建 2D FFT 计划配置。对于 Fortran 数组 (nx,ny)，nx 是变换中第 1 维的大小，但它是函数的第 2 个大小参数；ny 是第 2 维的大小，并且是函数的第 1 个大小参数。如果在本次调用之前使用多个 GPU 调用了 cufftXtSetGPUs，则 workSize 是一个包含多个大小的数组。workSize 值以字节为单位。

integer(4) function cufftMakePlan2d(plan, ny, nx, ffttype, workSize)
  integer(4) :: plan
  integer(4) :: ny, nx
  integer(4) :: ffttype
  integer(kind=int_ptr_kind()) :: workSize(*)

3.2.8. cufftMakePlan3d

在调用 cufftCreate() 之后，此函数根据指定的信号大小和数据类型创建 3D FFT 计划配置。对于 Fortran 数组 (nx,ny,nz)，nx 是变换中第 1 维的大小，但它是函数的第 3 个大小参数；nz 是第 3 维的大小，并且是函数的第 1 个大小参数。如果在本次调用之前使用多个 GPU 调用了 cufftXtSetGPUs，则 workSize 是一个包含多个大小的数组。workSize 值以字节为单位。

integer(4) function cufftMakePlan3d(plan, nz, ny, nx, ffttype, workSize)
  integer(4) :: plan
  integer(4) :: nz, ny, nx
  integer(4) :: ffttype
  integer(kind=int_ptr_kind()) :: workSize(*)

3.2.9. cufftMakePlanMany

在调用 cufftCreate() 之后，此函数创建维度为 rank 的 FFT 计划配置，大小在数组 n 中指定。Batch 是要配置的变换的数量。此函数使用参数 inembed、istride、idist、onembed、ostride 和 odist 支持更复杂的输入和输出数据布局。

在 C 函数中，如果 inembed 和 onembed 设置为 NULL，则所有其他步幅信息都将被忽略。当使用 NVIDIA cufft 模块时，Fortran 程序员可以通过将 F90 指针设置为 null() 来传递 NULL，可以通过直接赋值、使用 c_f_pointer() 和 c_null_ptr 作为第一个参数，或 nullify 语句，然后将 nullified F90 指针作为 inembed 和 onembed 哑元的实际参数传递。

如果在本次调用之前使用多个 GPU 调用了 cufftXtSetGPUs，则 workSize 是一个包含多个大小的数组。workSize 值以字节为单位。

integer(4) function cufftMakePlanMany(plan, rank, n, inembed, istride, idist, onembed, ostride, odist, ffttype, batch, workSize)
  integer(4) :: plan
  integer(4) :: rank
  integer :: n(rank)
  integer :: inembed(rank), onembed(rank)
  integer(4) :: istride, idist, ostride, odist
  integer(4) :: ffttype, batch
  integer(kind=int_ptr_kind()) :: workSize(*)

3.2.10. cufftEstimate1d

此函数返回所需工作区大小的估计值（以字节为单位），给定指定的大小和数据类型，并假设使用默认计划设置。

integer(4) function cufftEstimate1d(nx, ffttype, batch, workSize)
  integer(4) :: nx
  integer(4) :: ffttype
  integer(4) :: batch
  integer(kind=int_ptr_kind()) :: workSize(*)

3.2.11. cufftEstimate2d

此函数返回所需工作区大小的估计值（以字节为单位），给定指定的大小和数据类型，并假设使用默认计划设置。

integer(4) function cufftEstimate2d(ny, nx, ffttype, workSize)
  integer(4) :: ny, nx
  integer(4) :: ffttype
  integer(kind=int_ptr_kind()) :: workSize(*)

3.2.12. cufftEstimate3d

此函数返回所需工作区大小的估计值（以字节为单位），给定指定的大小和数据类型，并假设使用默认计划设置。

integer(4) function cufftEstimate3d(nz, ny, nx, ffttype, workSize)
  integer(4) :: nz, ny, nx
  integer(4) :: ffttype
  integer(kind=int_ptr_kind()) :: workSize(*)

3.2.13. cufftEstimateMany

此函数返回所需工作区大小的估计值（以字节为单位），给定指定的大小和数据类型，并假设使用默认计划设置。

integer(4) function cufftEstimateMany(rank, n, inembed, istride, idist, onembed, ostride, odist, ffttype, batch, workSize)
  integer(4) :: rank, istride, idist, ostride, odist
  integer(4), dimension(rank) :: n, inembed, onembed
  integer(4) :: ffttype
  integer(4) :: batch
  integer(kind=int_ptr_kind()) :: workSize(*)

3.2.14. cufftGetSize1d

此函数比 cufftEstimate1d() 更准确地估计所需工作区的大小（以字节为单位），给定指定的计划参数，并考虑可能已完成的任何计划设置。

integer(4) function cufftGetSize1d(plan, nx, ffttype, batch, workSize)
  integer(4) :: plan, nx, ffttype, batch
  integer(kind=int_ptr_kind()) :: workSize(*)

3.2.15. cufftGetSize2d

此函数比 cufftEstimate2d() 更准确地估计所需工作区的大小（以字节为单位），给定指定的计划参数，并考虑可能已完成的任何计划设置。

integer(4) function cufftGetSize2d(plan, ny, nx, ffttype, workSize)
  integer(4) :: plan, ny, nx, ffttype
  integer(kind=int_ptr_kind()) :: workSize(*)

3.2.16. cufftGetSize3d

此函数比 cufftEstimate3d() 更准确地估计所需工作区的大小（以字节为单位），给定指定的计划参数，并考虑可能已完成的任何计划设置。

integer(4) function cufftGetSize3d(plan, nz, ny, nx, ffttype, workSize)
  integer(4) :: plan, nz, ny, nx, ffttype
  integer(kind=int_ptr_kind()) :: workSize(*)

3.2.17. cufftGetSizeMany

此函数比 cufftEstimateMany() 更准确地估计所需工作区的大小（以字节为单位），给定指定的计划参数，并考虑可能已完成的任何计划设置。

integer(4) function cufftGetSizeMany(plan, rank, n, inembed, istride, idist, onembed, ostride, odist, ffttype, batch, workSize)
  integer(4) :: plan, rank, istride, idist, ostride, odist
  integer(4), dimension(rank) :: n, inembed, onembed
  integer(4) :: ffttype
  integer(4) :: batch
  integer(kind=int_ptr_kind()) :: workSize(*)

3.2.18. cufftGetSize

一旦完成计划生成（无论是使用原始 API 还是可扩展 API），此调用将返回支持该计划所需的实际工作区大小（以字节为单位）。选择在其应用程序中管理工作区分配的调用者必须在计划生成之后以及在计划生成之后可能更改所需工作空间大小的任何 cufftSet*() 调用之后使用此调用。

integer(4) function cufftGetSize(plan, workSize)
  integer(4) :: plan
  integer(kind=int_ptr_kind()) :: workSize(*)

3.3. CUFFT 执行函数

本节包含 cuFFT 库中执行实际傅里叶变换的执行函数。

3.3.1. cufftExecC2C

此函数在 direction 参数指定的变换方向中执行单精度复数到复数变换计划。如果 idata 和 odata 相同，则此函数执行就地变换。

integer(4) function cufftExecC2C( plan, idata, odata, direction )
  integer :: plan
  complex(4), device, dimension(*) :: idata, odata
  integer :: direction

3.3.2. cufftExecR2C

此函数执行单精度实数到复数、隐式正向 cuFFT 变换计划。如果 idata 和 odata 相同，则此函数执行就地变换，但请注意，对于 cuFFT 中的实数到复数 FFT，就地变换和异地变换之间存在数据布局差异。

integer(4) function cufftExecR2C( plan, idata, odata )
  integer :: plan
  real(4), device, dimension(*) :: idata
  complex(4), device, dimension(*) :: odata

3.3.3. cufftExecC2R

此函数执行单精度复数到实数、隐式反向 cuFFT 变换计划。如果 idata 和 odata 相同，则此函数执行就地变换。

integer(4) function cufftExecC2R( plan, idata, odata )
  integer :: plan
  complex(4), device, dimension(*) :: idata
  real(4), device, dimension(*) :: odata

3.3.4. cufftExecZ2Z

此函数在 direction 参数指定的变换方向中执行双精度复数到复数变换计划。如果 idata 和 odata 相同，则此函数执行就地变换。

integer(4) function cufftExecZ2Z( plan, idata, odata, direction )
  integer :: plan
  complex(8), device, dimension(*) :: idata, odata
  integer :: direction

3.3.5. cufftExecD2Z

此函数执行双精度实数到复数、隐式正向 cuFFT 变换计划。如果 idata 和 odata 相同，则此函数执行就地变换，但请注意，对于 cuFFT 中的实数到复数 FFT，就地变换和异地变换之间存在数据布局差异。

integer(4) function cufftExecD2Z( plan, idata, odata )
  integer :: plan
  real(8), device, dimension(*) :: idata
  complex(8), device, dimension(*) :: odata

3.3.6. cufftExecZ2D

此函数执行双精度复数到实数、隐式反向 cuFFT 变换计划。如果 idata 和 odata 相同，则此函数执行就地变换。

integer(4) function cufftExecZ2D( plan, idata, odata )
  integer :: plan
  complex(8), device, dimension(*) :: idata
  real(8), device, dimension(*) :: odata

3.4. CUFFTXT 定义和辅助函数

本节包含 cufftXt 库中使用的定义和数据类型，以及辅助函数的接口。从 NVHPC 22.5 版本开始，此模块还包含一些与 cuFFTMp 库一起使用的接口和定义。

cufftXt 模块包含以下常量和枚举

integer, parameter :: MAX_CUDA_DESCRIPTOR_GPUS = 64

! libFormat enum is used for the library member of cudaLibXtDesc
enum, bind(C)
    enumerator :: LIB_FORMAT_CUFFT     = 0
    enumerator :: LIB_FORMAT_UNDEFINED = 1
end enum

! cufftXtSubFormat identifies the data layout of a memory descriptor
enum, bind(C)
    ! by default input is in linear order across GPUs
    enumerator :: CUFFT_XT_FORMAT_INPUT = 0

    ! by default output is in scrambled order depending on transform
    enumerator :: CUFFT_XT_FORMAT_OUTPUT = 1

    ! by default inplace is input order, which is linear across GPUs
    enumerator :: CUFFT_XT_FORMAT_INPLACE = 2

    ! shuffled output order after execution of the transform
    enumerator :: CUFFT_XT_FORMAT_INPLACE_SHUFFLED = 3

    ! shuffled input order prior to execution of 1D transforms
    enumerator :: CUFFT_XT_FORMAT_1D_INPUT_SHUFFLED = 4

    ! distributed input order
    enumerator :: CUFFT_XT_FORMAT_DISTRIBUTED_INPUT = 5

    ! distributed output order
    enumerator :: CUFFT_XT_FORMAT_DISTRIBUTED_OUTPUT = 6

    enumerator :: CUFFT_FORMAT_UNDEFINED = 7
end enum

! cufftXtCopyType specifies the type of copy for cufftXtMemcpy
enum, bind(C)
    enumerator :: CUFFT_COPY_HOST_TO_DEVICE   = 0
    enumerator :: CUFFT_COPY_DEVICE_TO_HOST   = 1
    enumerator :: CUFFT_COPY_DEVICE_TO_DEVICE = 2
    enumerator :: CUFFT_COPY_UNDEFINED        = 3
end enum

! cufftXtQueryType specifies the type of query for cufftXtQueryPlan
enum, bind(c)
    enumerator :: CUFFT_QUERY_1D_FACTORS = 0
    enumerator :: CUFFT_QUERY_UNDEFINED  = 1
end enum

! cufftXtWorkAreaPolicy specifies the policy for cufftXtSetWorkAreaPolicy
enum, bind(c)
    enumerator :: CUFFT_WORKAREA_MINIMAL     = 0 ! maximum reduction
    enumerator :: CUFFT_WORKAREA_USER        = 1 ! use workSize parameter as limit
    enumerator :: CUFFT_WORKAREA_PERFORMANCE = 2 ! default - 1x overhead or more, max perf
end enum

! cufftMpCommType specifies how to initialize cuFFTMp
enum, bind(c)
    enumerator :: CUFFT_COMM_MPI       = 0
    enumerator :: CUFFT_COMM_NVSHMEM   = 1
    enumerator :: CUFFT_COMM_UNDEFINED = 2
end enum

cufftXt 模块包含以下派生类型定义

! cufftXt1dFactors type
type, bind(c) :: cufftXt1dFactors
    integer(8) :: size
    integer(8) :: stringCount
    integer(8) :: stringLength
    integer(8) :: subStringLength
    integer(8) :: factor1
    integer(8) :: factor2
    integer(8) :: stringMask
    integer(8) :: subStringMask
    integer(8) :: factor1Mask
    integer(8) :: factor2Mask
    integer(4) :: stringShift
    integer(4) :: subStringShift
    integer(4) :: factor1Shift
    integer(4) :: factor2Shift
end type cufftXt1dFactors

type, bind(C) :: cudaXtDesc
    integer(4) :: version
    integer(4) :: nGPUs
    integer(4) :: GPUs(MAX_CUDA_DESCRIPTOR_GPUS)
    type(c_devptr) :: data(MAX_CUDA_DESCRIPTOR_GPUS)
    integer(8) :: size(MAX_CUDA_DESCRIPTOR_GPUS)
    type(c_ptr) :: cudaXtState
end type cudaXtDesc

type, bind(C) :: cudaLibXtDesc
    integer(4) :: version
    type(c_ptr) :: descriptor     ! cudaXtDesc *descriptor
    integer(4) :: library         ! libFormat library
    integer(4) :: subFormat
    type(c_ptr) :: libDescriptor  ! void *libDescriptor
end type cudaLibXtDesc

type, bind(C) :: cufftBox3d
    integer(8) :: lower(3)
    integer(8) :: upper(3)
    integer(8) :: strides(3)
end type cufftBox3d

3.4.1. cufftXtSetGPUs

此函数标识计划要使用的 GPU。cufftXtSetGPUs 的调用必须发生在调用 cufftCreate 之后，但在调用 cufftMakePlan* 之前。

integer(4) function cufftXtSetGPUs( plan, nGPUs, whichGPUs )
  integer(4) :: plan
  integer(4) :: nGPUs
  integer(4) :: whichGPUs(*)

3.4.2. cufftXtMalloc

此函数分配 cufftXt 描述符，以及与计划关联的 GPU 中数据的内存。cufftXtSubFormat 的值确定缓冲区是用于输入还是输出。Fortran 程序员应声明并传递指向 type(cudaLibXtDesc) 变量的指针，以便可以存储所有信息，并在后续调用 cufftXtFree 中释放。对于熟悉 C 接口的程序员，此函数的变体可以接受 type(c_ptr) 作为第 2 个参数。

integer(4) function cufftXtMalloc( plan, descriptor, format )
  integer(4) :: plan
  type(cudaLibXtDesc), pointer :: descriptor  ! A type(c_ptr) is also accepted.
  integer(4) :: format ! cufftXtSubFormat value

3.4.3. cufftXtFree

此函数释放 cufftXt 描述符以及与之关联的所有内存。描述符和内存必须已通过先前对 cufftXtMalloc 的调用分配。Fortran 程序员应声明并传递指向 type(cudaLibXtDesc) 变量的指针。对于熟悉 C 接口的程序员，此函数的变体可以接受 type(c_ptr) 作为唯一参数。

integer(4) function cufftXtFree( descriptor )
  type(cudaLibXtDesc), pointer :: descriptor  ! A type(c_ptr) is also accepted.

3.4.4. cufftXtMemcpy

此函数在主机和 GPU 上的缓冲区之间或 GPU 之间复制数据。type 参数的值确定复制方向。此外，此 Fortran 函数被重载为接受 type(cudaLibXtDesc) 变量作为目标（H2D 传输）、源（D2H 传输）或两者（D2D 传输），在这种情况下，不需要 type 参数。

integer(4) function cufftXtMemcpy( plan, dst, src, type )
  integer(4) :: plan
  type(cudaLibXtDesc) :: dst  ! Or any host buffer, depending on the type
  type(cudaLibXtDesc) :: src  ! Or any host buffer, depending on the type
  integer(4) :: type          ! optional cufftXtCopyType value

3.5. CUFFTXT 计划和工作区函数

本节包含 cufftXt 库中用于创建计划和管理工作缓冲区的函数。

3.5.1. cufftXtMakePlanMany

在调用 cufftCreate() 之后，此函数创建维度为 rank 的 FFT 计划配置，大小在数组 n 中指定。Batch 是要配置的变换的数量。此函数使用参数 inembed、istride、idist、onembed、ostride 和 odist 支持更复杂的输入和输出数据布局。在 C 函数中，如果 inembed 和 onembed 设置为 NULL，则所有其他步幅信息都将被忽略。当使用 NVIDIA cufft 模块时，Fortran 程序员可以通过将 F90 指针设置为 null() 来传递 NULL，可以通过直接赋值、使用 c_f_pointer() 和 c_null_ptr 作为第一个参数，或 nullify 语句，然后将 nullified F90 指针作为 inembed 和 onembed 哑元的实际参数传递。

integer(4) function cufftXtMakePlanMany(plan, rank, n, inembed, istride, &
    idist, inputType, onembed, ostride, odist, outputType, batch, workSize, &
    executionType)
  integer(4) :: plan
  integer(4) :: rank
  integer(8) :: n(*)
  integer(8) :: inembed(*), onembed(*)
  integer(8) :: istride, idist, ostride, odist
  type(cudaDataType) :: inputType, outputType, executionType
  integer(4) :: batch
  integer(8) :: workSize(*)

3.5.2. cufftXtQueryPlan

此函数仅支持多 GPU 1D 变换。它返回一个派生类型 factors，其中包含字符串的数量、因子的分解以及（在 2 的幂大小的情况下）一些其他有用的掩码和移位元素，用于在置换索引和线性索引之间进行转换。

integer(4) function cufftXtQueryPlan(plan, factors, queryType)
  integer(4) :: plan
  type(cufftXt1DFactors) :: factors
  integer(4) :: queryType

3.5.3. cufftXtSetWorkAreaPolicy

此函数覆盖与计划关联的工作区。目前，workAreaPolicy 可以指定为 CUFFT_WORKAREA_MINIMAL，cuFFT 将尝试重新计划以使用零字节的工作区内存。有关其他功能的支持，请参阅 CUFFT 文档。

integer(4) function cufftXtSetWorkAreaPolicy(plan, workAreaPolicy, workSize)
  integer(4) :: plan
  integer(4) :: workAreaPolicy
  integer(8) :: workSize

3.5.4. cufftXtGetSizeMany

此函数比 cufftEstimateMany() 更准确地估计所需工作区的大小（以字节为单位），给定用于 cufftXtMakePlanMany 的指定计划参数，并考虑可能已完成的任何计划设置。

integer(4) function cufftXtGetSizeMany(plan, rank, n, inembed, istride, &
    idist, inputType, onembed, ostride, odist, outputType, batch, workSize, &
    executionType)
  integer(4) :: plan
  integer(4) :: rank
  integer(8) :: n(*)
  integer(8) :: inembed(*), onembed(*)
  integer(8) :: istride, idist, ostride, odist
  type(cudaDataType) :: inputType, outputType, executionType
  integer(4) :: batch
  integer(8) :: workSize(*)

3.5.5. cufftXtSetWorkArea

此函数覆盖与计划关联的工作区。如果工作区是自动分配的，则 cuFFT 会释放自动分配的空间。cufftExecute*() 调用假定工作区指针有效，并且它指向设备内存中的一个连续区域，该区域不与其他任何工作区重叠。如果不是这种情况，结果将是不确定的。

integer(4) function cufftXtSetWorkArea(plan, workArea)
  integer(4) :: plan
  type(c_devptr) :: workArea(*)

3.5.6. cufftXtSetDistribution

此函数注册并描述后续 FFT 操作的数据分布。cufftXtSetDistribution 的调用必须发生在调用 cufftCreate 之后，但在调用 cufftMakePlan* 之前。

integer(4) function cufftXtSetDistribution( plan, boxIn, boxOut )
  integer(4) :: plan
  type(cufftBox3d) :: boxIn
  type(cufftBox3d) :: boxOut

3.6. CUFFTXT 执行函数

本节包含 cufftXt 库中执行实际傅里叶变换的执行函数。

3.6.1. cufftXtExec

此函数执行任何傅里叶变换，无论精度和类型如何。在复数到实数和实数到复数变换的情况下，direction 参数将被忽略。否则，变换方向由 direction 参数指定。此函数使用 input 指向的 GPU 内存作为输入数据，并将计算出的傅里叶系数存储在 output 数组中。如果它们相同，则此方法执行就地变换。接受 input 和 output 数组的任何有效数据类型。

integer(4) function cufftXtExec( plan, input, output, direction )
  integer :: plan
  real, dimension(*) :: input, output  ! Any data type is allowed
  integer :: direction

3.6.2. cufftXtExecDescriptor

此函数执行任何傅里叶变换，无论精度和类型如何。在复数到实数和实数到复数变换的情况下，direction 参数将被忽略。否则，变换方向由 direction 参数指定。此函数将结果存储在指定的输出数组中。

integer(4) function cufftXtExecDescriptor( plan, input, output, direction )
  integer :: plan
  type(cudaLibXtDesc) :: input, output
  integer :: direction

3.6.3. cufftXtExecDescriptorC2C

此函数在 direction 参数指定的变换方向中执行单精度复数到复数变换计划。此多 GPU 函数目前仅支持就地变换；结果将存储在输入数组中。

integer(4) function cufftXtExecDescriptorC2C( plan, input, output, direction )
  integer :: plan
  type(cudaLibXtDesc) :: input, output
  integer :: direction

3.6.4. cufftXtExecDescriptorZ2Z

此函数在 direction 参数指定的变换方向中执行双精度复数到复数变换计划。此多 GPU 函数目前仅支持就地变换；结果将存储在输入数组中。

integer(4) function cufftXtExecDescriptorZ2Z( plan, input, output, direction )
  integer :: plan
  type(cudaLibXtDesc) :: input, output
  integer :: direction

3.6.5. cufftXtExecDescriptorR2C

此函数执行单精度实数到复数变换计划。此多 GPU 函数目前仅支持就地变换；结果将存储在输入数组中。

integer(4) function cufftXtExecDescriptorR2C( plan, input, output )
  integer :: plan
  type(cudaLibXtDesc) :: input, output

3.6.6. cufftXtExecDescriptorD2Z

此函数执行双精度实数到复数变换计划。此多 GPU 函数目前仅支持就地变换；结果将存储在输入数组中。

integer(4) function cufftXtExecDescriptorD2Z( plan, input, output )
  integer :: plan
  type(cudaLibXtDesc) :: input, output

3.6.7. cufftXtExecDescriptorC2R

此函数执行单精度复数到实数变换计划。此多 GPU 函数目前仅支持就地变换；结果将存储在输入数组中。

integer(4) function cufftXtExecDescriptorC2R( plan, input, output )
  integer :: plan
  type(cudaLibXtDesc) :: input, output

3.6.8. cufftXtExecDescriptorZ2D

此函数执行双精度复数到实数变换计划。此多 GPU 函数目前仅支持就地变换；结果将存储在输入数组中。

integer(4) function cufftXtExecDescriptorZ2D( plan, input, output )
  integer :: plan
  type(cudaLibXtDesc) :: input, output

3.7. CUFFTMP 函数

本节包含 cuFFTMp 函数，这些函数将 cuFFTXt 库的功能扩展到多个进程和多个 GPU。

3.7.1. cufftMpNvshmemMalloc

此函数从 NVSHMEM 对称堆中分配空间。cuFFTMp 库基于 NVSHMEM。但是，不允许用户在其自己的应用程序中链接和使用 NVSHMEM。这可能会导致应用程序启动时崩溃。此限制将在 cuFFTMp 的未来版本中解除。

但是，cuFFTMp 的某些功能需要 NVSHMEM 分配的内存，因此目前公开并支持此功能。此函数要求在使用之前至少有一个 cuFFTMp 计划处于活动状态。

integer(4) function cufftMpNvshmemMalloc( size, workArea )
  integer(8) :: size  ! Size is in bytes
  type(c_devptr) :: workArea

3.7.2. cufftMpNvshmemFree

此函数释放先前从 NVSHMEM 对称堆中分配的空间。cuFFTMp 库基于 NVSHMEM。但是，不允许用户在其自己的应用程序中链接和使用 NVSHMEM。这可能会导致应用程序启动时崩溃。此限制将在 cuFFTMp 的未来版本中解除。

但是，cuFFTMp 的某些功能需要 NVSHMEM 分配的内存，因此目前公开并支持此功能。此函数要求在使用之前至少有一个 cuFFTMp 计划处于活动状态。

integer(4) function cufftMpNvshmemFree( workArea )
  type(c_devptr) :: workArea

3.7.3. cufftMpAttachComm

此函数将通信器（例如 MPI_COMM_WORLD）附加到 cuFFT 计划，以便稍后应用分布式 FFT 操作

integer(4) function cufftMpAttachComm( plan, commType, fcomm )
  integer(4) :: plan
  integer(4) :: commType
  integer(4) :: fcomm

3.7.4. cufftMpCreateReshape

此函数创建一个 cuFFTMp reshape 句柄，以便稍后应用分布式 FFT 操作

integer(4) function cufftMpCreateReshape( reshapeHandle )
  type(c_ptr) :: reshapeHandle

3.7.5. cufftMpAttachReshapeComm

此函数将通信器（例如 MPI_COMM_WORLD）附加到 cuFFTMp reshape 句柄，以便稍后应用分布式 FFT 操作

integer(4) function cufftMpAttachReshapeComm( reshapeHandle, commType, fcomm )
  type(c_ptr) :: reshapeHandle
  integer(4) :: commType
  integer(4) :: fcomm

3.7.6. cufftMpGetReshapeSize

此函数返回后续 cuFFTMp reshape 执行中工作空间所需的大小。目前，不需要工作区，但这在未来的版本中可能会更改。

integer(4) function cufftMpGetReshapeSize( reshapeHandle, workSize )
   type(c_ptr) :: reshapeHandle
   integer(8)  :: workSize

3.7.7. cufftMpMakeReshape

此函数基于输入和输出框创建 cuFFTMp reshape 计划。请注意，这些框使用 C 约定来表示边界和步幅。

integer(4) function cufftMpMakeReshape( reshapeHandle, &
       elementSize, boxIn, boxOut )
   type(c_ptr) :: reshapeHandle
   integer(8)  :: elementSize
   type(cufftBox3d) :: boxIn
   type(cufftBox3d) :: boxOut

3.7.8. cufftMpExecReshapeAsync

此函数在指定的流上执行 cuFFTMp reshape 计划。

integer(4) function cufftMpExecReshapeAsync( reshapeHandle, &
       dataOut, dataIn, workSpace, stream )
   type(c_ptr) :: reshapeHandle
   type(c_devptr) :: dataOut
   type(c_devptr) :: dataIn
   type(c_devptr) :: workSpace
   integer(kind=cuda_stream_kind) :: stream

3.7.9. cufftMpDestroyReshape

此函数销毁 cuFFTMp reshape 句柄。

integer(4) function cufftMpDestroyReshape( reshapeHandle )
  type(c_ptr) :: reshapeHandle

4. 随机数运行时库 API

本节介绍 CUDA cuRAND 库的 Fortran 接口。cuRAND 功能可以从主机和设备代码访问。在主机库中，所有运行时 API 例程都是返回错误代码的整数函数；如果调用成功，它们返回 CURAND_STATUS_SUCCESS 值，如果出现错误，则返回其他 cuRAND 返回状态值。主机库例程旨在生成一系列或数组随机数。在设备库中，init 例程是子例程，生成器函数返回正在生成的值的类型。设备库例程旨在为每个线程每次调用生成一个值。

第 10 章包含从 OpenACC 和 CUDA Fortran 访问 cuRAND 库例程的示例。在这两种情况下，可以通过在主机代码中添加以下行来公开库的接口

use curand

到您的程序单元。

除非提供了特定的 kind，否则 plain integer 类型意味着 integer(4)，plain real 类型意味着 real(4)。

4.1. CURAND 定义和辅助函数

本节包含 cuRAND 库中使用的定义和数据类型，以及 cuRAND 辅助函数的接口。

curand 模块包含以下派生类型定义

TYPE curandGenerator
  TYPE(C_PTR)  :: handle
END TYPE

curand 模块包含以下枚举

! CURAND Status
enum, bind(c)
    enumerator :: CURAND_STATUS_SUCCESS                   = 0
    enumerator :: CURAND_STATUS_VERSION_MISMATCH          = 100
    enumerator :: CURAND_STATUS_NOT_INITIALIZED           = 101
    enumerator :: CURAND_STATUS_ALLOCATION_FAILED         = 102
    enumerator :: CURAND_STATUS_TYPE_ERROR                = 103
    enumerator :: CURAND_STATUS_OUT_OF_RANGE              = 104
    enumerator :: CURAND_STATUS_LENGTH_NOT_MULTIPLE       = 105
    enumerator :: CURAND_STATUS_DOUBLE_PRECISION_REQUIRED = 106
    enumerator :: CURAND_STATUS_LAUNCH_FAILURE            = 201
    enumerator :: CURAND_STATUS_PREEXISTING_FAILURE       = 202
    enumerator :: CURAND_STATUS_INITIALIZATION_FAILED     = 203
    enumerator :: CURAND_STATUS_ARCH_MISMATCH             = 204
    enumerator :: CURAND_STATUS_INTERNAL_ERROR            = 999
end enum

! CURAND Generator Types
enum, bind(c)
    enumerator :: CURAND_RNG_TEST                    = 0
    enumerator :: CURAND_RNG_PSEUDO_DEFAULT          = 100
    enumerator :: CURAND_RNG_PSEUDO_XORWOW           = 101
    enumerator :: CURAND_RNG_PSEUDO_MRG32K3A         = 121
    enumerator :: CURAND_RNG_PSEUDO_MTGP32           = 141
    enumerator :: CURAND_RNG_PSEUDO_MT19937          = 142
    enumerator :: CURAND_RNG_PSEUDO_PHILOX4_32_10    = 161
    enumerator :: CURAND_RNG_QUASI_DEFAULT           = 200
    enumerator :: CURAND_RNG_QUASI_SOBOL32           = 201
    enumerator :: CURAND_RNG_QUASI_SCRAMBLED_SOBOL32 = 202
    enumerator :: CURAND_RNG_QUASI_SOBOL64           = 203
    enumerator :: CURAND_RNG_QUASI_SCRAMBLED_SOBOL64 = 204
end enum

! CURAND Memory Ordering
enum, bind(c)
    enumerator :: CURAND_ORDERING_PSEUDO_BEST    = 100
    enumerator :: CURAND_ORDERING_PSEUDO_DEFAULT = 101
    enumerator :: CURAND_ORDERING_PSEUDO_SEEDED  = 102
    enumerator :: CURAND_ORDERING_QUASI_DEFAULT  = 201
end enum

! CURAND Direction Vectors
enum, bind(c)
    enumerator :: CURAND_DIRECTION_VECTORS_32_JOEKUO6           = 101
    enumerator :: CURAND_SCRAMBLED_DIRECTION_VECTORS_32_JOEKUO6 = 102
    enumerator :: CURAND_DIRECTION_VECTORS_64_JOEKUO6           = 103
    enumerator :: CURAND_SCRAMBLED_DIRECTION_VECTORS_64_JOEKUO6 = 104
end enum

! CURAND Methods
enum, bind(c)
    enumerator :: CURAND_CHOOSE_BEST    = 0
    enumerator :: CURAND_ITR            = 1
    enumerator :: CURAND_KNUTH          = 2
    enumerator :: CURAND_HITR           = 3
    enumerator :: CURAND_M1             = 4
    enumerator :: CURAND_M2             = 5
    enumerator :: CURAND_BINARY_SEARCH  = 6
    enumerator :: CURAND_DISCRETE_GAUSS = 7
    enumerator :: CURAND_REJECTION      = 8
    enumerator :: CURAND_DEVICE_API     = 9
    enumerator :: CURAND_FAST_REJECTION = 10
    enumerator :: CURAND_3RD            = 11
    enumerator :: CURAND_DEFINITION     = 12
    enumerator :: CURAND_POISSON        = 13
end enum

4.1.1. curandCreateGenerator

此函数创建一个新的类型为 rng 的随机数生成器。有关 rng 的有效值，请参阅本节开头。

integer(4) function curandCreateGenerator(generator, rng)
  type(curandGenerator) :: generator
  integer :: rng

4.1.2. curandCreateGeneratorHost

此函数创建一个新的类型为 rng 的主机 CPU 随机数生成器。有关 rng 的有效值，请参阅本节开头。

integer(4) function curandCreateGeneratorHost(generator, rng)
  type(curandGenerator) :: generator
  integer :: rng

4.1.3. curandDestroyGenerator

此函数销毁一个现有的随机数生成器。

integer(4) function curandDestroyGenerator(generator)
  type(curandGenerator) :: generator

4.1.4. curandGetVersion

此函数返回 cuRAND 库的版本号。

integer(4) function curandGetVersion(version)
  integer(4) :: version

4.1.5. curandSetStream

此函数为 cuRAND 内核启动设置当前流。

integer(4) function curandSetStream(generator, stream)
  type(curandGenerator) :: generator
  integer(kind=c_intptr_t) :: stream

4.1.6. curandSetPseudoRandomGeneratorSeed

此函数设置伪随机数生成器的种子值。

integer(4) function curandSetPseudoRandomGeneratorSeed(generator, seed)
  type(curandGenerator) :: generator
  integer(8) :: seed

4.1.7. curandSetGeneratorOffset

此函数设置伪随机数或准随机数生成器的绝对偏移量。

integer(4) function curandSetGeneratorOffset(generator, offset)
  type(curandGenerator) :: generator
  integer(8) :: offset

4.1.8. curandSetGeneratorOrdering

此函数设置伪随机数或准随机数生成器结果的排序。

integer(4) function curandSetGeneratorOrdering(generator, order)
  type(curandGenerator) :: generator
  integer(4) :: order

4.1.9. curandSetQuasiRandomGeneratorDimensions

此函数设置准随机数生成器的维度数量。

integer(4) function curandSetQuasiRandomGeneratorDimensions(generator, num)
  type(curandGenerator) :: generator
  integer(4) :: num

4.2. CURAND 生成器函数

本节包含 cuRAND 生成器函数的接口。

4.2.1. curandGenerate

此函数生成 32 位伪随机数或准随机数。

integer(4) function curandGenerate(generator, array, num )
  type(curandGenerator) :: generator
  integer(4), device :: array(*) ! Host or device depending on the generator
  integer(kind=c_intptr_t) :: num

4.2.2. curandGenerateLongLong

此函数生成 64 位整数准随机数。函数 curandGenerate() 也被重载以接受这些函数参数。

integer(4) function curandGenerateLongLong(generator, array, num )
  type(curandGenerator) :: generator
  integer(8), device :: array(*) ! Host or device depending on the generator
  integer(kind=c_intptr_t) :: num

4.2.3. curandGenerateUniform

此函数生成 32 位浮点均匀分布的随机数。函数 curandGenerate() 也被重载以接受这些函数参数。

integer(4) function curandGenerateUniform(generator, array, num )
  type(curandGenerator) :: generator
  real(4), device :: array(*) ! Host or device depending on the generator
  integer(kind=c_intptr_t) :: num

4.2.4. curandGenerateUniformDouble

此函数生成 64 位浮点均匀分布的随机数。函数 curandGenerate() 也被重载以接受这些函数参数。

integer(4) function curandGenerateUniformDouble(generator, array, num )
  type(curandGenerator) :: generator
  real(8), device :: array(*) ! Host or device depending on the generator
  integer(kind=c_intptr_t) :: num

4.2.5. curandGenerateNormal

此函数生成 32 位浮点正态分布的随机数。函数 curandGenerate() 也被重载以接受这些函数参数。

integer(4) function curandGenerateNormal(generator, array, num, mean, stddev )
  type(curandGenerator) :: generator
  real(4), device :: array(*) ! Host or device depending on the generator
  integer(kind=c_intptr_t) :: num
  real(4) :: mean, stddev

4.2.6. curandGenerateNormalDouble

此函数生成 64 位浮点正态分布的随机数。函数 curandGenerate() 也被重载以接受这些函数参数。

integer(4) function curandGenerateNormalDouble(generator, array, num, mean, stddev )
  type(curandGenerator) :: generator
  real(8), device :: array(*) ! Host or device depending on the generator
  integer(kind=c_intptr_t) :: num
  real(8) :: mean, stddev

4.2.7. curandGeneratePoisson

此函数生成泊松分布的随机数。函数 curandGenerate() 也被重载以接受这些函数参数。

integer(4) function curandGeneratePoisson(generator, array, num, lambda )
  type(curandGenerator) :: generator
  real(8), device :: array(*) ! Host or device depending on the generator
  integer(kind=c_intptr_t) :: num
  real(8) :: lambda

4.2.8. curandGenerateSeeds

此函数设置生成器的起始状态。

integer(4) function curandGenerateSeeds(generator)
  type(curandGenerator) :: generator

4.2.9. curandGenerateLogNormal

此函数生成 32 位浮点对数正态分布的随机数。

integer(4) function curandGenerateLogNormal(generator, array, num, mean, stddev )
  type(curandGenerator) :: generator
  real(4), device :: array(*) ! Host or device depending on the generator
  integer(kind=c_intptr_t) :: num
  real(4) :: mean, stddev

4.2.10. curandGenerateLogNormalDouble

此函数生成 64 位浮点对数正态分布的随机数。

integer(4) function curandGenerateLogNormalDouble(generator, array, num, mean, stddev )
  type(curandGenerator) :: generator
  real(8), device :: array(*) ! Host or device depending on the generator
  integer(kind=c_intptr_t) :: num
  real(8) :: mean, stddev

4.3. CURAND 设备定义和函数

本节包含 cuRAND 设备库中使用的定义和数据类型，以及 cuRAND 函数的接口。

curand 设备模块包含以下派生类型定义

TYPE curandStateXORWOW
    integer(4) :: d
    integer(4) :: v(5)
    integer(4) :: boxmuller_flag
    integer(4) :: boxmuller_flag_double
    real(4)    :: boxmuller_extra
    real(8)    :: boxmuller_extra_double
END TYPE curandStateXORWOW

TYPE curandStateMRG32k3a
    real(8)    :: s1(3)
    real(8)    :: s2(3)
    integer(4) :: boxmuller_flag
    integer(4) :: boxmuller_flag_double
    real(4)    :: boxmuller_extra
    real(8)    :: boxmuller_extra_double
END TYPE curandStateMRG32k3a

TYPE curandStateSobol32
    integer(4) :: d
    integer(4) :: x
    integer(4) :: c
    integer(4) :: direction_vectors(32)
END TYPE curandStateSobol32

TYPE curandStateScrambledSobol32
    integer(4) :: d
    integer(4) :: x
    integer(4) :: c
    integer(4) :: direction_vectors(32)
END TYPE curandStateScrambledSobol32

TYPE curandStateSobol64
    integer(8) :: d
    integer(8) :: x
    integer(8) :: c
    integer(8) :: direction_vectors(32)
END TYPE curandStateSobol64

TYPE curandStateScrambledSobol64
    integer(8) :: d
    integer(8) :: x
    integer(8) :: c
    integer(8) :: direction_vectors(32)
END TYPE curandStateScrambledSobol64

TYPE curandStateMtgp32
    integer(4) :: s(MTGP32_STATE_SIZE)
    integer(4) :: offset
    integer(4) :: pIdx
    integer(kind=int_ptr_kind()) :: k
    integer(4) :: precise_double_flag
END TYPE curandStateMtgp32

TYPE curandStatePhilox4_32_10
    integer(4) :: ctr
    integer(4) :: output
    integer(2) :: key
    integer(4) :: state
    integer(4) :: boxmuller_flag
    integer(4) :: boxmuller_flag_double
    real(4)    :: boxmuller_extra
    real(8)    :: boxmuller_extra_double
END TYPE curandStatePhilox4_32_10

4.3.1. curand_Init

此重载设备子例程初始化随机数生成器的状态。这些设备子例程在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

4.3.1.1. curandInitXORWOW

此函数初始化 XORWOW 随机数生成器的状态。函数 curand_init() 也被重载以接受这些函数参数，如同在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

subroutine curandInitXORWOW(seed, sequence, offset, state)
  integer(8) :: seed
  integer(8) :: sequence
  integer(8) :: offset
  TYPE(curandStateXORWOW) :: state

4.3.1.2. curandInitMRG32k3a

此函数初始化 MRG32k3a 随机数生成器的状态。函数 curand_init() 也被重载以接受这些函数参数，如同在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

subroutine curandInitMRG32k3a(seed, sequence, offset, state)
  integer(8) :: seed
  integer(8) :: sequence
  integer(8) :: offset
  TYPE(curandStateMRG32k3a) :: state

4.3.1.3. curandInitPhilox4_32_10

此函数初始化 Philox4_32_10 随机数生成器的状态。函数 curand_init() 也被重载以接受这些函数参数，如同在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

subroutine curandInitPhilox4_32_10(seed, sequence, offset, state)
  integer(8) :: seed
  integer(8) :: sequence
  integer(8) :: offset
  TYPE(curandStatePhilox4_32_10) :: state

4.3.1.4. curandInitSobol32

此函数初始化 Sobol32 随机数生成器的状态。函数 curand_init() 也被重载以接受这些函数参数，如同在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

subroutine curandInitSobol32(direction_vectors, offset, state)
  integer :: direction_vectors(*)
  integer(4) :: offset
  TYPE(curandStateSobol32) :: state

4.3.1.5. curandInitScrambledSobol32

此函数初始化 scrambled Sobol32 随机数生成器的状态。函数 curand_init() 也被重载以接受这些函数参数，如同在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

subroutine curandInitScrambledSobol32(direction_vectors, scramble, offset, state)
  integer :: direction_vectors(*)
  integer(4) :: scramble
  integer(4) :: offset
  TYPE(curandStateScrambledSobol32) :: state

4.3.1.6. curandInitSobol64

此函数初始化 Sobol64 随机数生成器的状态。函数 curand_init() 也被重载以接受这些函数参数，如同在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

subroutine curandInitSobol64(direction_vectors, offset, state)
  integer :: direction_vectors(*)
  integer(8) :: offset
  TYPE(curandStateSobol64) :: state

4.3.1.7. curandInitScrambledSobol64

此函数初始化 scrambled Sobol64 随机数生成器的状态。函数 curand_init() 也被重载以接受这些函数参数，如同在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

subroutine curandInitScrambledSobol64(direction_vectors, scramble, offset, state)
  integer :: direction_vectors(*)
  integer(8) :: scramble
  integer(8) :: offset
  TYPE(curandStateScrambledSobol64) :: state

4.3.2. curand

此重载设备函数根据状态参数返回 32 位或 64 位的随机数据。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

4.3.2.1. curandGetXORWOW

此函数从 XORWOW 随机数生成器返回 32 位的伪随机数。函数 curand() 也被重载以接受这些函数参数，如同在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

integer(4) function curandGetXORWOW(state)
  TYPE(curandStateXORWOW) :: state

4.3.2.2. curandGetMRG32k3a

此函数从 MRG32k3a 随机数生成器返回 32 位的伪随机数。函数 curand() 也被重载以接受这些函数参数，如同在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

integer(4) function curandGetMRG32k3a(state)
  TYPE(curandStateMRG32k3a) :: state

4.3.2.3. curandGetPhilox4_32_10

此函数从 Philox4_32_10 随机数生成器返回 32 位的伪随机数。函数 curand() 也被重载以接受这些函数参数，如同在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

integer(4) function curandGetPhilox4_32_10(state)
  TYPE(curandStatePhilox4_32_10) :: state

4.3.2.4. curandGetSobol32

此函数从 Sobol32 随机数生成器返回 32 位的准随机数。函数 curand() 也被重载以接受这些函数参数，如同在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

integer(4) function curandGetSobol32(state)
  TYPE(curandStateSobol32) :: state

4.3.2.5. curandGetScrambledSobol32

此函数从 scrambled Sobol32 随机数生成器返回 32 位的准随机数。函数 curand() 也被重载以接受这些函数参数，如同在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

integer(4) function curandGetScrambledSobol32(state)
  TYPE(curandStateScrambledSobol32) :: state

4.3.2.6. curandGetSobol64

此函数从 Sobol64 随机数生成器返回 64 位的准随机数。函数 curand() 也被重载以接受这些函数参数，如同在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

integer(4) function curandGetSobol64(state)
  TYPE(curandStateSobol64) :: state

4.3.2.7. curandGetScrambledSobol64

此函数从 scrambled Sobol64 随机数生成器返回 64 位的准随机数。函数 curand() 也被重载以接受这些函数参数，如同在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

integer(4) function curandGetScrambledSobol64(state)
  TYPE(curandStateScrambledSobol64) :: state

4.3.3. Curand_Normal

此重载设备函数返回一个 32 位浮点正态分布的随机数。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

4.3.3.1. curandNormalXORWOW

此函数从 XORWOW 生成器返回一个 32 位浮点正态分布的随机数。函数 curand_normal() 也被重载以接受这些函数参数，如同在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

real(4) function curandNormalXORWOW(state)
  TYPE(curandStateXORWOW) :: state

4.3.3.2. curandNormalMRG32k3a

此函数从 MRG32k3a 生成器返回一个 32 位浮点正态分布的随机数。函数 curand_normal() 也被重载以接受这些函数参数，如同在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

real(4) function curandNormalMRG32k3a(state)
  TYPE(curandStateMRG32k3a) :: state

4.3.3.3. curandNormalPhilox4_32_10

此函数从 Philox4_32_10 生成器返回一个 32 位浮点正态分布的随机数。函数 curand_normal() 也被重载以接受这些函数参数，如同在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

real(4) function curandNormalPhilox4_32_10(state)
  TYPE(curandStatePhilox4_32_10) :: state

4.3.3.4. curandNormalSobol32

此函数从 Sobol32 生成器返回一个 32 位浮点正态分布的随机数。函数 curand_normal() 也被重载以接受这些函数参数，如同在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

real(4) function curandNormalSobol32(state)
  TYPE(curandStateSobol32) :: state

4.3.3.5. curandNormalScrambledSobol32

此函数从 scrambled Sobol32 生成器返回一个 32 位浮点正态分布的随机数。函数 curand_normal() 也被重载以接受这些函数参数，如同在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

real(4) function curandNormalScrambledSobol32(state)
  TYPE(curandStateScrambledSobol32) :: state

4.3.3.6. curandNormalSobol64

此函数从 Sobol64 生成器返回一个 32 位浮点正态分布的随机数。函数 curand_normal() 也被重载以接受这些函数参数，如同在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

real(4) function curandNormalSobol64(state)
  TYPE(curandStateSobol64) :: state

4.3.3.7. curandNormalScrambledSobol64

此函数从 scrambled Sobol64 生成器返回一个 32 位浮点正态分布的随机数。函数 curand_normal() 也被重载以接受这些函数参数，如同在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

real(4) function curandNormalScrambledSobol64(state)
  TYPE(curandStateScrambledSobol64) :: state

4.3.4. Curand_Normal_Double

此重载设备函数返回一个 64 位浮点正态分布的随机数。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

4.3.4.1. curandNormalDoubleXORWOW

此函数从 XORWOW 生成器返回一个 64 位浮点正态分布的随机数。函数 curand_normal_double() 也被重载以接受这些函数参数，如同在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

real(8) function curandNormalDoubleXORWOW(state)
  TYPE(curandStateXORWOW) :: state

4.3.4.2. curandNormalDoubleMRG32k3a

此函数从 MRG32k3a 生成器返回一个 64 位浮点正态分布的随机数。函数 curand_normal_double() 也被重载以接受这些函数参数，如同在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

real(8) function curandNormalDoubleMRG32k3a(state)
  TYPE(curandStateMRG32k3a) :: state

4.3.4.3. curandNormalDoublePhilox4_32_10

此函数从 Philox4_32_10 生成器返回一个 64 位浮点正态分布的随机数。函数 curand_normal_double() 也被重载以接受这些函数参数，如同在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

real(8) function curandNormalDoublePhilox4_32_10(state)
  TYPE(curandStatePhilox4_32_10) :: state

4.3.4.4. curandNormalDoubleSobol32

此函数从 Sobol32 生成器返回一个 64 位浮点正态分布的随机数。函数 curand_normal_double() 也被重载以接受这些函数参数，如同在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

real(8) function curandNormalDoubleSobol32(state)
  TYPE(curandStateSobol32) :: state

4.3.4.5. curandNormalDoubleScrambledSobol32

此函数从 scrambled Sobol32 生成器返回一个 64 位浮点正态分布的随机数。函数 curand_normal_double() 也被重载以接受这些函数参数，如同在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

real(8) function curandNormalDoubleScrambledSobol32(state)
  TYPE(curandStateScrambledSobol32) :: state

4.3.4.6. curandNormalDoubleSobol64

此函数从 Sobol64 生成器返回一个 64 位浮点正态分布的随机数。函数 curand_normal_double() 也被重载以接受这些函数参数，如同在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

real(8) function curandNormalDoubleSobol64(state)
  TYPE(curandStateSobol64) :: state

4.3.4.7. curandNormalDoubleScrambledSobol64

此函数从 scrambled Sobol64 生成器返回一个 64 位浮点正态分布的随机数。函数 curand_normal_double() 也被重载以接受这些函数参数，如同在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

real(8) function curandNormalDoubleScrambledSobol64(state)
  TYPE(curandStateScrambledSobol64) :: state

4.3.5. Curand_Log_Normal

此重载设备函数返回一个 32 位浮点对数正态分布的随机数。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

4.3.5.1. curandLogNormalXORWOW

此函数从 XORWOW 生成器返回一个 32 位浮点对数正态分布的随机数。函数 curand_log_normal() 也被重载以接受这些函数参数，如同在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

real(4) function curandLogNormalXORWOW(state)
  TYPE(curandStateXORWOW) :: state

4.3.5.2. curandLogNormalMRG32k3a

此函数从 MRG32k3a 生成器返回一个 32 位浮点对数正态分布的随机数。函数 curand_log_normal() 也被重载以接受这些函数参数，如同在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

real(4) function curandLogNormalMRG32k3a(state)
  TYPE(curandStateMRG32k3a) :: state

4.3.5.3. curandLogNormalPhilox4_32_10

此函数从 Philox4_32_10 生成器返回一个 32 位浮点对数正态分布的随机数。函数 curand_log_normal() 也被重载以接受这些函数参数，如同在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

real(4) function curandLogNormalPhilox4_32_10(state)
  TYPE(curandStatePhilox4_32_10) :: state

4.3.5.4. curandLogNormalSobol32

此函数从 Sobol32 生成器返回一个 32 位浮点对数正态分布的随机数。函数 curand_log_normal() 也被重载以接受这些函数参数，如同在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

real(4) function curandLogNormalSobol32(state)
  TYPE(curandStateSobol32) :: state

4.3.5.5. curandLogNormalScrambledSobol32

此函数从 scrambled Sobol32 生成器返回一个 32 位浮点对数正态分布的随机数。函数 curand_log_normal() 也被重载以接受这些函数参数，如同在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

real(4) function curandLogNormalScrambledSobol32(state)
  TYPE(curandStateScrambledSobol32) :: state

4.3.5.6. curandLogNormalSobol64

此函数从 Sobol64 生成器返回一个 32 位浮点对数正态分布的随机数。函数 curand_log_normal() 也被重载以接受这些函数参数，如同在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

real(4) function curandLogNormalSobol64(state)
  TYPE(curandStateSobol64) :: state

4.3.5.7. curandLogNormalScrambledSobol64

此函数从 scrambled Sobol64 生成器返回一个 32 位浮点对数正态分布的随机数。函数 curand_log_normal() 也被重载以接受这些函数参数，如同在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

real(4) function curandLogNormalScrambledSobol64(state)
  TYPE(curandStateScrambledSobol64) :: state

4.3.6. Curand_Log_Normal_Double

此重载设备函数返回一个 64 位浮点对数正态分布的随机数。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

4.3.6.1. curandLogNormalDoubleXORWOW

此函数从 XORWOW 生成器返回一个 64 位浮点对数正态分布的随机数。函数 curand_log_normal_double() 也被重载以接受这些函数参数，如同在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

real(8) function curandLogNormalDoubleXORWOW(state)
  TYPE(curandStateXORWOW) :: state

4.3.6.2. curandLogNormalDoubleMRG32k3a

此函数从 MRG32k3a 生成器返回一个 64 位浮点对数正态分布的随机数。函数 curand_log_normal_double() 也被重载以接受这些函数参数，如同在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

real(8) function curandLogNormalDoubleMRG32k3a(state)
  TYPE(curandStateMRG32k3a) :: state

4.3.6.3. curandLogNormalDoublePhilox4_32_10

此函数从 Philox4_32_10 生成器返回一个 64 位浮点对数正态分布的随机数。函数 curand_log_normal_double() 也被重载以接受这些函数参数，如同在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

real(8) function curandLogNormalDoublePhilox4_32_10(state)
  TYPE(curandStatePhilox4_32_10) :: state

4.3.6.4. curandLogNormalDoubleSobol32

此函数从 Sobol32 生成器返回一个 64 位浮点对数正态分布的随机数。函数 curand_log_normal_double() 也被重载以接受这些函数参数，如同在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

real(8) function curandLogNormalDoubleSobol32(state)
  TYPE(curandStateSobol32) :: state

4.3.6.5. curandLogNormalDoubleScrambledSobol32

此函数从 scrambled Sobol32 生成器返回一个 64 位浮点对数正态分布的随机数。函数 curand_log_normal_double() 也被重载以接受这些函数参数，如同在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

real(8) function curandLogNormalDoubleScrambledSobol32(state)
  TYPE(curandStateScrambledSobol32) :: state

4.3.6.6. curandLogNormalDoubleSobol64

此函数从 Sobol64 生成器返回一个 64 位浮点对数正态分布的随机数。函数 curand_log_normal_double() 也被重载以接受这些函数参数，如同在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

real(8) function curandLogNormalDoubleSobol64(state)
  TYPE(curandStateSobol64) :: state

4.3.6.7. curandLogNormalDoubleScrambledSobol64

此函数从 scrambled Sobol64 生成器返回一个 64 位浮点对数正态分布的随机数。函数 curand_log_normal_double() 也被重载以接受这些函数参数，如同在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

real(8) function curandLogNormalDoubleScrambledSobol64(state)
  TYPE(curandStateScrambledSobol64) :: state

4.3.7. Curand_Uniform

此重载设备函数返回一个 32 位浮点均匀分布的随机数。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

4.3.7.1. curandUniformXORWOW

此函数从 XORWOW 生成器返回一个 32 位浮点均匀分布的随机数。函数 curand_uniform() 也被重载以接受这些函数参数，如同在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

real(4) function curandUniformXORWOW(state)
  TYPE(curandStateXORWOW) :: state

4.3.7.2. curandUniformMRG32k3a

此函数从 MRG32k3a 生成器返回一个 32 位浮点均匀分布的随机数。函数 curand_uniform() 也被重载以接受这些函数参数，如同在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

real(4) function curandUniformMRG32k3a(state)
  TYPE(curandStateMRG32k3a) :: state

4.3.7.3. curandUniformPhilox4_32_10

此函数从 Philox4_32_10 生成器返回一个 32 位浮点均匀分布的随机数。函数 curand_uniform() 也被重载以接受这些函数参数，如同在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

real(4) function curandUniformPhilox4_32_10(state)
  TYPE(curandStatePhilox4_32_10) :: state

4.3.7.4. curandUniformSobol32

此函数从 Sobol32 生成器返回一个 32 位浮点均匀分布随机数。函数 curand_uniform() 也被重载以接受这些函数参数，就像在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

real(4) function curandUniformSobol32(state)
  TYPE(curandStateSobol32) :: state

4.3.7.5. curandUniformScrambledSobol32

此函数从 scrambled Sobol32 生成器返回一个 32 位浮点均匀分布随机数。函数 curand_uniform() 也被重载以接受这些函数参数，就像在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

real(4) function curandUniformScrambledSobol32(state)
  TYPE(curandStateScrambledSobol32) :: state

4.3.7.6. curandUniformSobol64

此函数从 Sobol64 生成器返回一个 32 位浮点均匀分布随机数。函数 curand_uniform() 也被重载以接受这些函数参数，就像在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

real(4) function curandUniformSobol64(state)
  TYPE(curandStateSobol64) :: state

4.3.7.7. curandUniformScrambledSobol64

此函数从 scrambled Sobol64 生成器返回一个 32 位浮点均匀分布随机数。函数 curand_uniform() 也被重载以接受这些函数参数，就像在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

real(4) function curandUniformScrambledSobol64(state)
  TYPE(curandStateScrambledSobol64) :: state

4.3.8. Curand_Uniform_Double

此重载的设备函数返回一个 64 位浮点均匀分布随机数。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

4.3.8.1. curandUniformDoubleXORWOW

此函数从 XORWOW 生成器返回一个 64 位浮点均匀分布随机数。函数 curand_uniform_double() 也被重载以接受这些函数参数，就像在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

real(8) function curandUniformDoubleXORWOW(state)
  TYPE(curandStateXORWOW) :: state

4.3.8.2. curandUniformDoubleMRG32k3a

此函数从 MRG32k3a 生成器返回一个 64 位浮点均匀分布随机数。函数 curand_uniform_double() 也被重载以接受这些函数参数，就像在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

real(8) function curandUniformDoubleMRG32k3a(state)
  TYPE(curandStateMRG32k3a) :: state

4.3.8.3. curandUniformDoublePhilox4_32_10

此函数从 Philox4_32_10 生成器返回一个 64 位浮点均匀分布随机数。函数 curand_uniform_double() 也被重载以接受这些函数参数，就像在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

real(8) function curandUniformDoublePhilox4_32_10(state)
  TYPE(curandStatePhilox4_32_10) :: state

4.3.8.4. curandUniformDoubleSobol32

此函数从 Sobol32 生成器返回一个 64 位浮点均匀分布随机数。函数 curand_uniform_double() 也被重载以接受这些函数参数，就像在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

real(8) function curandUniformDoubleSobol32(state)
  TYPE(curandStateSobol32) :: state

4.3.8.5. curandUniformDoubleScrambledSobol32

此函数从 scrambled Sobol32 生成器返回一个 64 位浮点均匀分布随机数。函数 curand_uniform_double() 也被重载以接受这些函数参数，就像在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

real(8) function curandUniformDoubleScrambledSobol32(state)
  TYPE(curandStateScrambledSobol32) :: state

4.3.8.6. curandUniformDoubleSobol64

此函数从 Sobol64 生成器返回一个 64 位浮点均匀分布随机数。函数 curand_uniform_double() 也被重载以接受这些函数参数，就像在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

real(8) function curandUniformDoubleSobol64(state)
  TYPE(curandStateSobol64) :: state

4.3.8.7. curandUniformDoubleScrambledSobol64

此函数从 scrambled Sobol64 生成器返回一个 64 位浮点均匀分布随机数。函数 curand_uniform_double() 也被重载以接受这些函数参数，就像在 CUDA C++ 中一样。设备函数在 CUDA Fortran 中声明为 attributes(device)，在 OpenACC 中声明为 !$acc routine() seq。

real(8) function curandUniformDoubleScrambledSobol64(state)
  TYPE(curandStateScrambledSobol64) :: state

5. SPARSE 矩阵运行时库 API

本节介绍 CUDA cuSPARSE 库的 Fortran 接口。cuSPARSE 函数只能从主机代码访问。所有运行时 API 例程都是返回错误代码的整数函数；如果调用成功，它们将返回值 CUSPARSE_STATUS_SUCCESS，如果发生错误，则返回另一个 cuSPARSE 状态返回值。

第 10 章包含从 OpenACC 和 CUDA Fortran 访问 cuSPARSE 库例程的示例。在这两种情况下，可以通过添加以下行来公开库的接口

use cusparse

到您的程序单元。

本章中列出的许多函数接口可以接受主机或设备标量参数。这些函数还有一个额外的 v2 接口，该接口不会隐式管理这些调用的指针模式。有关指针模式处理的更多讨论，请参见第 1.6 节。

除非提供了特定的 kind，否则接口中使用的普通 integer 类型表示 integer(4)，而普通 real 类型表示 real(4)。

5.1. CUSPARSE 定义和辅助函数

本节包含 cuSPARSE 库中使用的定义和数据类型，以及 cuSPARSE 辅助函数的接口。

cuSPARSE 模块包含以下派生类型定义

type cusparseHandle
  type(c_ptr) :: handle
end type cusparseHandle

type :: cusparseMatDescr
     type(c_ptr) :: descr
end type cusparseMatDescr

! This type was removed in CUDA 11.0
type cusparseSolveAnalysisInfo
     type(c_ptr) :: info
end type cusparseSolveAnalysisInfo

! This type was removed in CUDA 11.0
type cusparseHybMat
     type(c_ptr) :: mat
end type cusparseHybMat

type cusparseCsrsv2Info
     type(c_ptr) :: info
end type cusparseCsrsv2Info

type cusparseCsric02Info
     type(c_ptr) :: info
end type cusparseCsric02Info

type cusparseCsrilu02Info
     type(c_ptr) :: info
end type cusparseCsrilu02Info

type cusparseBsrsv2Info
     type(c_ptr) :: info
end type cusparseBsrsv2Info

type cusparseBsric02Info
     type(c_ptr) :: info
end type cusparseBsric02Info

type cusparseBsrilu02Info
     type(c_ptr) :: info
end type cusparseBsrilu02Info

type cusparseBsrsm2Info
     type(c_ptr) :: info
end type cusparseBsrsm2Info

type cusparseCsrgemm2Info
     type(c_ptr) :: info
end type cusparseCsrgemm2Info

type cusparseColorInfo
     type(c_ptr) :: info
end type cusparseColorInfo

type cusparseCsru2csrInfo
     type(c_ptr) :: info
end type cusparseCsru2csrInfo

type cusparseSpVecDescr
     type(c_ptr) :: descr
end type cusparseSpVecDescr

type cusparseDnVecDescr
     type(c_ptr) :: descr
end type cusparseDnVecDescr

type cusparseSpMatDescr
     type(c_ptr) :: descr
end type cusparseSpMatDescr

type cusparseDnMatDescr
     type(c_ptr) :: descr
end type cusparseDnMatDescr

type cusparseSpSVDescr
     type(c_ptr) :: descr
end type cusparseSpSVDescr

type cusparseSpSMDescr
     type(c_ptr) :: descr
end type cusparseSpSMDescr

type cusparseSpGEMMDescr
     type(c_ptr) :: descr
end type cusparseSpGEMMDescr

cuSPARSE 模块包含以下常量和枚举

! cuSPARSE Version Info
  integer, parameter :: CUSPARSE_VER_MAJOR = 12
  integer, parameter :: CUSPARSE_VER_MINOR = 1
  integer, parameter :: CUSPARSE_VER_PATCH = 2
  integer, parameter :: CUSPARSE_VER_BUILD = 129
  integer, parameter :: CUSPARSE_VERSION   = (CUSPARSE_VER_MAJOR * 1000 + &
                          CUSPARSE_VER_MINOR *  100 + CUSPARSE_VER_PATCH)

! cuSPARSE status return values
enum, bind(C) ! cusparseStatus_t
    enumerator :: CUSPARSE_STATUS_SUCCESS=0
    enumerator :: CUSPARSE_STATUS_NOT_INITIALIZED=1
    enumerator :: CUSPARSE_STATUS_ALLOC_FAILED=2
    enumerator :: CUSPARSE_STATUS_INVALID_VALUE=3
    enumerator :: CUSPARSE_STATUS_ARCH_MISMATCH=4
    enumerator :: CUSPARSE_STATUS_MAPPING_ERROR=5
    enumerator :: CUSPARSE_STATUS_EXECUTION_FAILED=6
    enumerator :: CUSPARSE_STATUS_INTERNAL_ERROR=7
    enumerator :: CUSPARSE_STATUS_MATRIX_TYPE_NOT_SUPPORTED=8
    enumerator :: CUSPARSE_STATUS_ZERO_PIVOT=9
    enumerator :: CUSPARSE_STATUS_NOT_SUPPORTED=10
    enumerator :: CUSPARSE_STATUS_INSUFFICIENT_RESOURCES=11
end enum

enum, bind(c) ! cusparsePointerMode_t
    enumerator :: CUSPARSE_POINTER_MODE_HOST = 0
    enumerator :: CUSPARSE_POINTER_MODE_DEVICE = 1
end enum

enum, bind(c) ! cusparseAction_t
    enumerator :: CUSPARSE_ACTION_SYMBOLIC = 0
    enumerator :: CUSPARSE_ACTION_NUMERIC = 1
end enum

enum, bind(C) ! cusparseMatrixType_t
    enumerator :: CUSPARSE_MATRIX_TYPE_GENERAL = 0
    enumerator :: CUSPARSE_MATRIX_TYPE_SYMMETRIC = 1
    enumerator :: CUSPARSE_MATRIX_TYPE_HERMITIAN = 2
    enumerator :: CUSPARSE_MATRIX_TYPE_TRIANGULAR = 3
end enum

enum, bind(C) ! cusparseFillMode_t
    enumerator :: CUSPARSE_FILL_MODE_LOWER = 0
    enumerator :: CUSPARSE_FILL_MODE_UPPER = 1
end enum

enum, bind(C) ! cusparseDiagType_t
    enumerator :: CUSPARSE_DIAG_TYPE_NON_UNIT = 0
    enumerator :: CUSPARSE_DIAG_TYPE_UNIT = 1
end enum

enum, bind(C) ! cusparseIndexBase_t
    enumerator :: CUSPARSE_INDEX_BASE_ZERO = 0
    enumerator :: CUSPARSE_INDEX_BASE_ONE = 1
end enum

enum, bind(C) ! cusparseOperation_t
    enumerator :: CUSPARSE_OPERATION_NON_TRANSPOSE = 0
    enumerator :: CUSPARSE_OPERATION_TRANSPOSE = 1
    enumerator :: CUSPARSE_OPERATION_CONJUGATE_TRANSPOSE = 2
end enum

enum, bind(C) ! cusparseDirection_t
    enumerator :: CUSPARSE_DIRECTION_ROW = 0
    enumerator :: CUSPARSE_DIRECTION_COLUMN = 1
end enum

enum, bind(C) ! cusparseHybPartition_t
    enumerator :: CUSPARSE_HYB_PARTITION_AUTO = 0
    enumerator :: CUSPARSE_HYB_PARTITION_USER = 1
    enumerator :: CUSPARSE_HYB_PARTITION_MAX = 2
end enum

enum, bind(C) ! cusparseSolvePolicy_t
    enumerator :: CUSPARSE_SOLVE_POLICY_NO_LEVEL = 0
    enumerator :: CUSPARSE_SOLVE_POLICY_USE_LEVEL = 1
end enum

enum, bind(C) ! cusparseSideMode_t
    enumerator :: CUSPARSE_SIDE_LEFT  = 0
    enumerator :: CUSPARSE_SIDE_RIGHT = 1
end enum

enum, bind(C) ! cusparseColorAlg_t
    enumerator :: CUSPARSE_COLOR_ALG0 = 0
    enumerator :: CUSPARSE_COLOR_ALG1 = 1
end enum

enum, bind(C) ! cusparseAlgMode_t;
    enumerator :: CUSPARSE_ALG0           = 0
    enumerator :: CUSPARSE_ALG1           = 1
    enumerator :: CUSPARSE_ALG_NAIVE      = 0
    enumerator :: CUSPARSE_ALG_MERGE_PATH = 0
end enum

enum, bind(C) ! cusparseCsr2CscAlg_t;
    enumerator :: CUSPARSE_CSR2CSC_ALG_DEFAULT = 1
    enumerator :: CUSPARSE_CSR2CSC_ALG1 = 1
    enumerator :: CUSPARSE_CSR2CSC_ALG2 = 2
end enum

enum, bind(C) ! cusparseFormat_t;
    enumerator :: CUSPARSE_FORMAT_CSR     = 1
    enumerator :: CUSPARSE_FORMAT_CSC     = 2
    enumerator :: CUSPARSE_FORMAT_COO     = 3
    enumerator :: CUSPARSE_FORMAT_COO_AOS = 4
    enumerator :: CUSPARSE_FORMAT_BLOCKED_ELL = 5
    enumerator :: CUSPARSE_FORMAT_BSR     = 6
    enumerator :: CUSPARSE_FORMAT_SLICED_ELLPACK = 7
end enum

enum, bind(C) ! cusparseOrder_t;
    enumerator :: CUSPARSE_ORDER_COL = 1
    enumerator :: CUSPARSE_ORDER_ROW = 2
end enum

enum, bind(C) ! cusparseSpMVAlg_t;
    enumerator :: CUSPARSE_MV_ALG_DEFAULT = 0
    enumerator :: CUSPARSE_COOMV_ALG      = 1
    enumerator :: CUSPARSE_CSRMV_ALG1     = 2
    enumerator :: CUSPARSE_CSRMV_ALG2     = 3
    enumerator :: CUSPARSE_SPMV_ALG_DEFAULT = 0
    enumerator :: CUSPARSE_SPMV_CSR_ALG1    = 2
    enumerator :: CUSPARSE_SPMV_CSR_ALG2    = 3
    enumerator :: CUSPARSE_SPMV_COO_ALG1    = 1
    enumerator :: CUSPARSE_SPMV_COO_ALG2    = 4
    enumerator :: CUSPARSE_SPMV_SELL_ALG1   = 5
end enum

enum, bind(C) ! cusparseSpMMAlg_t;
    enumerator :: CUSPARSE_MM_ALG_DEFAULT = 0
    enumerator :: CUSPARSE_COOMM_ALG1 = 1
    enumerator :: CUSPARSE_COOMM_ALG2 = 2
    enumerator :: CUSPARSE_COOMM_ALG3 = 3
    enumerator :: CUSPARSE_CSRMM_ALG1 = 4
    enumerator :: CUSPARSE_SPMM_ALG_DEFAULT = 0
    enumerator :: CUSPARSE_SPMM_COO_ALG1    = 1
    enumerator :: CUSPARSE_SPMM_COO_ALG2    = 2
    enumerator :: CUSPARSE_SPMM_COO_ALG3    = 3
    enumerator :: CUSPARSE_SPMM_COO_ALG4    = 5
    enumerator :: CUSPARSE_SPMM_CSR_ALG1    = 4
    enumerator :: CUSPARSE_SPMM_CSR_ALG2    = 6
    enumerator :: CUSPARSE_SPMM_CSR_ALG3    = 12
    enumerator :: CUSPARSE_SPMM_BLOCKED_ELL_ALG1 = 13
end enum

enum, bind(C) ! cusparseIndexType_t;
    enumerator :: CUSPARSE_INDEX_16U = 1
    enumerator :: CUSPARSE_INDEX_32I = 2
    enumerator :: CUSPARSE_INDEX_64I = 3
end enum

enum, bind(C) ! cusparseSpMatAttribute_t;
    enumerator :: CUSPARSE_SPMAT_FILL_MODE = 0
    enumerator :: CUSPARSE_SPMAT_DIAG_TYPE = 1
end enum

enum, bind(C) ! cusparseSparseToDenseAlg_t;
    enumerator :: CUSPARSE_SPARSETODENSE_ALG_DEFAULT = 0
    enumerator :: CUSPARSE_DENSETOSPARSE_ALG_DEFAULT = 0
end enum

enum, bind(C) ! cusparseSpSVAlg_t;
    enumerator :: CUSPARSE_SPSV_ALG_DEFAULT = 0
end enum

enum, bind(C) ! cusparseSpSVUpdate_t;
    enumerator :: CUSPARSE_SPSV_UPDATE_GENERAL  = 0
    enumerator :: CUSPARSE_SPSV_UPDATE_DIAGONAL = 1
end enum

enum, bind(C) ! cusparseSpSMAlg_t;
    enumerator :: CUSPARSE_SPSM_ALG_DEFAULT = 0
end enum

enum, bind(C) ! cusparseSpMMOpAlg_t;
    enumerator :: CUSPARSE_SPMM_OP_ALG_DEFAULT = 0
end enum

enum, bind(C) ! cusparseSpGEMMAlg_t;
    enumerator :: CUSPARSE_SPGEMM_DEFAULT = 0
    enumerator :: CUSPARSE_SPGEMM_CSR_ALG_DETERMINISTIC = 1
    enumerator :: CUSPARSE_SPGEMM_CSR_ALG_DETERMINITIC  = 1
    enumerator :: CUSPARSE_SPGEMM_CSR_ALG_NONDETERMINISTIC = 2
    enumerator :: CUSPARSE_SPGEMM_CSR_ALG_NONDETERMINITIC  = 2
    enumerator :: CUSPARSE_SPGEMM_ALG1 = 3
    enumerator :: CUSPARSE_SPGEMM_ALG2 = 4
    enumerator :: CUSPARSE_SPGEMM_ALG3 = 5
end enum

enum, bind(C) ! cusparseSDDMMAlg_t;
    enumerator :: CUSPARSE_SDDMM_ALG_DEFAULT = 0
end enum

5.1.1. cusparseCreate

此函数初始化 cuSPARSE 库并在 cuSPARSE 上下文上创建句柄。必须在调用任何其他 cuSPARSE API 函数之前调用它。它分配访问 GPU 所需的硬件资源。

integer(4) function cusparseCreate(handle)
  type(cusparseHandle) :: handle

5.1.2. cusparseDestroy

此函数释放 cuSPARSE 库使用的 CPU 端资源。GPU 端资源的释放可能会延迟到应用程序关闭时。

integer(4) function cusparseDestroy(handle)
  type(cusparseHandle) :: handle

5.1.3. cusparseGetErrorName

此函数返回错误代码名称。

character*128 function cusparseGetErrorName(ierr)
   integer(c_int) :: ierr

5.1.4. cusparseGetErrorString

此函数返回错误代码的描述字符串。

character*128 function cusparseGetErrorString(ierr)
   integer(c_int) :: ierr

5.1.5. cusparseGetVersion

此函数返回 cuSPARSE 库的版本号。

integer(4) function cusparseGetVersion(handle, version)
  type(cusparseHandle) :: handle
  integer(c_int) :: version

5.1.6. cusparseSetStream

此函数设置 cuSPARSE 库用于执行其例程的流。

integer(4) function cusparseSetStream(handle, stream)
  type(cusparseHandle) :: handle
  integer(cuda_stream_kind) :: stream

5.1.7. cusparseGetStream

此函数获取 cuSPARSE 库用于执行其例程的流。如果未设置 cuSPARSE 库流，则所有内核都使用默认的 NULL 流。

integer(4) function cusparseGetStream(handle, stream)
  type(cusparseHandle) :: handle
  integer(cuda_stream_kind) :: stream

5.1.8. cusparseGetPointerMode

此函数获取 cuSPARSE 库使用的指针模式。有关指针模式的更多详细信息，请参见第 1.6 节。

integer(4) function cusparseGetPointerMode(handle, mode)
  type(cusparseHandle) :: handle
  integer(c_int) :: mode

5.1.9. cusparseSetPointerMode

此函数设置 cuSPARSE 库使用的指针模式。在这些 Fortran 接口中，这仅在使用 *_v2 接口时才有效。默认情况下，值通过主机上的引用传递。有关指针模式的更多详细信息，请参见第 1.6 节。

integer(4) function cusparseSetPointerMode(handle, mode)
  type(cusparseHandle) :: handle
  integer(4) :: mode

5.1.10. cusparseCreateMatDescr

此函数初始化矩阵描述符。它将字段 MatrixType 和 IndexBase 分别设置为默认值 CUSPARSE_MATRIX_TYPE_GENERAL 和 CUSPARSE_INDEX_BASE_ZERO，同时将其他字段保持未初始化状态。

integer(4) function cusparseCreateMatDescr(descrA)
  type(cusparseMatDescr) :: descrA

5.1.11. cusparseDestroyMatDescr

此函数释放为矩阵描述符分配的内存。

integer(4) function cusparseDestroyMatDescr(descrA)
  type(cusparseMatDescr) :: descrA

5.1.12. cusparseSetMatType

此函数设置矩阵描述符 descrA 的 MatrixType。

integer(4) function cusparseSetMatType(descrA, type)
  type(cusparseMatDescr) :: descrA
  integer(4) :: type

5.1.13. cusparseGetMatType

此函数返回矩阵描述符 descrA 的 MatrixType。

integer(4) function cusparseGetMatType(descrA)
  type(cusparseMatDescr) :: descrA

5.1.14. cusparseSetMatFillMode

此函数设置矩阵描述符 descrA 的 FillMode 字段。

integer(4) function cusparseSetMatFillMode(descrA, mode)
  type(cusparseMatDescr) :: descrA
  integer(4) :: mode

5.1.15. cusparseGetMatFillMode

此函数返回矩阵描述符 descrA 的 FillMode 字段。

integer(4) function cusparseGetMatFillMode(descrA)
  type(cusparseMatDescr) :: descrA

5.1.16. cusparseSetMatDiagType

此函数设置矩阵描述符 descrA 的 DiagType。

integer(4) function cusparseSetMatDiagType(descrA, type)
  type(cusparseMatDescr) :: descrA
  integer(4) :: type

5.1.17. cusparseGetMatDiagType

此函数返回矩阵描述符 descrA 的 DiagType。

integer(4) function cusparseGetMatDiagType(descrA)
  type(cusparseMatDescr) :: descrA

5.1.18. cusparseSetMatIndexBase

此函数设置矩阵描述符 descrA 的 IndexBase 字段。

integer(4) function cusparseSetMatIndexBase(descrA, base)
  type(cusparseMatDescr) :: descrA
  integer(4) :: base

5.1.19. cusparseGetMatIndexBase

此函数返回矩阵描述符 descrA 的 IndexBase 字段。

integer(4) function cusparseGetMatIndexBase(descrA)
  type(cusparseMatDescr) :: descrA

5.1.20. cusparseCreateSolveAnalysisInfo

此函数创建 solve 和 analysis 结构并将其初始化为默认值。此函数以及所有使用 cusparseSolveAnalysisInfo 类型的函数已在 CUDA 11.0 中移除。

integer(4) function cusparseCreateSolveAnalysisInfo(info)
  type(cusparseSolveAnalysisinfo) :: info

5.1.21. cusparseDestroySolveAnalysisInfo

此函数销毁并释放结构所需的任何内存。此函数以及所有使用 cusparseSolveAnalysisInfo 类型的函数已在 CUDA 11.0 中移除。

integer(4) function cusparseDestroySolveAnalysisInfo(info)
  type(cusparseSolveAnalysisinfo) :: info

5.1.22. cusparseGetLevelInfo

此函数返回级别数以及由 csrsv_analysis、csrsm_analysis 或 hybsv_analysis 例程计算的行到级别的分配。

integer(4) function cusparseGetLevelInfo(handle, info, nlevels, levelPtr, levelInd)
  type(cusparseHandle) :: handle
  type(cusparseSolveAnalysisinfo) :: info
  integer(c_int) :: nlevels
  type(c_ptr) :: levelPtr
  type(c_ptr) :: levelInd

5.1.23. cusparseCreateHybMat

此函数创建并初始化 hybA 不透明数据结构。此函数以及所有使用 cusparseHybMat 类型的函数已在 CUDA 11.0 中移除。

integer(4) function cusparseCreateHybMat(hybA)
  type(cusparseHybMat) :: hybA

5.1.24. cusparseDestroyHybMat

此函数销毁并释放 hybA 结构所需的任何内存。此函数以及所有使用 cusparseHybMat 类型的函数已在 CUDA 11.0 中移除。

integer(4) function cusparseDestroyHybMat(hybA)
  type(cusparseHybMat) :: hybA

5.1.25. cusparseCreateCsrsv2Info

此函数创建 csrsv2 的 solve 和 analysis 结构并将其初始化为默认值。

integer(4) function cusparseCreateCsrsv2Info(info)
  type(cusparseCsrsv2Info) :: info

5.1.26. cusparseDestroyCsrsv2Info

此函数销毁并释放结构所需的任何内存。

integer(4) function cusparseDestroyCsrsv2Info(info)
  type(cusparseCsrsv2Info) :: info

5.1.27. cusparseCreateCsric02Info

此函数创建不完全 Cholesky 分解的 solve 和 analysis 结构并将其初始化为默认值。

integer(4) function cusparseCreateCsric02Info(info)
  type(cusparseCsric02Info) :: info

5.1.28. cusparseDestroyCsric02Info

此函数销毁并释放结构所需的任何内存。

integer(4) function cusparseDestroyCsric02Info(info)
  type(cusparseCsric02Info) :: info

5.1.29. cusparseCreateCsrilu02Info

此函数创建不完全 LU 分解的 solve 和 analysis 结构并将其初始化为默认值。

integer(4) function cusparseCreateCsrilu02Info(info)
  type(cusparseCsrilu02Info) :: info

5.1.30. cusparseDestroyCsrilu02Info

此函数销毁并释放结构所需的任何内存。

integer(4) function cusparseDestroyCsrilu02Info(info)
  type(cusparseCsrilu02Info) :: info

5.1.31. cusparseCreateBsrsv2Info

此函数创建 bsrsv2 的 solve 和 analysis 结构并将其初始化为默认值。

integer(4) function cusparseCreateBsrsv2Info(info)
  type(cusparseBsrsv2Info) :: info

5.1.32. cusparseDestroyBsrsv2Info

此函数销毁并释放结构所需的任何内存。

integer(4) function cusparseDestroyBsrsv2Info(info)
  type(cusparseBsrsv2Info) :: info

5.1.33. cusparseCreateBsric02Info

此函数创建块不完全 Cholesky 分解的 solve 和 analysis 结构并将其初始化为默认值。

integer(4) function cusparseCreateBsric02Info(info)
  type(cusparseBsric02Info) :: info

5.1.34. cusparseDestroyBsric02Info

此函数销毁并释放结构所需的任何内存。

integer(4) function cusparseDestroyBsric02Info(info)
  type(cusparseBsric02Info) :: info

5.1.35. cusparseCreateBsrilu02Info

此函数创建块不完全 LU 分解的 solve 和 analysis 结构并将其初始化为默认值。

integer(4) function cusparseCreateBsrilu02Info(info)
  type(cusparseBsrilu02Info) :: info

5.1.36. cusparseDestroyBsrilu02Info

此函数销毁并释放结构所需的任何内存。

integer(4) function cusparseDestroyBsrilu02Info(info)
  type(cusparseBsrilu02Info) :: info

5.1.37. cusparseCreateBsrsm2Info

此函数创建 bsrsm2 的 solve 和 analysis 结构并将其初始化为默认值。

integer(4) function cusparseCreateBsrsm2Info(info)
  type(cusparseBsrsm2Info) :: info

5.1.38. cusparseDestroyBsrsm2Info

此函数销毁并释放结构所需的任何内存。

integer(4) function cusparseDestroyBsrsm2Info(info)
  type(cusparseBsrsm2Info) :: info

5.1.39. cusparseCreateCsrgemm2Info

此函数创建通用稀疏矩阵-矩阵乘法的 analysis 结构。

integer(4) function cusparseCreateCsrgemm2Info(info)
  type(cusparseCsrgemm2Info) :: info

5.1.40. cusparseDestroyCsrgemm2Info

此函数销毁并释放结构所需的任何内存。

integer(4) function cusparseDestroyCsrgemm2Info(info)
  type(cusparseCsrgemm2Info) :: info

5.1.41. cusparseCreateColorInfo

此函数创建 CSRCOLOR 等调用中使用的着色信息。

integer(4) function cusparseCreateColorInfo(info)
  type(cusparseColorInfo) :: info

5.1.42. cusparseDestroyColorInfo

此函数销毁 CSRCOLOR 等调用中使用的着色信息。

integer(4) function cusparseDestroyColorInfo(info)
  type(cusparseColorInfo) :: info

5.1.43. cusparseCreateCsru2csrInfo

此函数创建 CSRU2CSR 等调用中使用的排序信息。

integer(4) function cusparseCreateCsru2csrInfo(info)
  type(cusparseCsru2csrInfo) :: info

5.1.44. cusparseDestroyCsru2csrInfo

此函数创建 CSRU2CSR 等调用中使用的排序信息。

integer(4) function cusparseDestroyCsru2csrInfo(info)
  type(cusparseCsru2csrInfo) :: info

5.2. CUSPARSE Level 1 函数

本节包含用于执行稠密向量和稀疏向量之间运算的 1 级稀疏线性代数函数的接口。

5.2.1. cusparseSaxpyi

SAXPY 执行常数乘以向量加向量。此函数将稀疏格式的向量 x 乘以常数 alpha，并将结果添加到稠密格式的向量 y，即 y = y + alpha * xVal(xInd)

integer(4) function cusparseSaxpyi(handle, nnz, alpha, xVal, xInd, y, idxBase)
  type(cusparseHandle) :: handle
  integer :: nnz
  real(4), device :: alpha ! device or host variable
  real(4), device :: xVal(*)
  integer(4), device :: xInd(*)
  real(4), device :: y(*)
  integer :: idxBase

5.2.2. cusparseDaxpyi

DAXPY 执行常数乘以向量加向量。此函数将稀疏格式的向量 x 乘以常数 alpha，并将结果添加到稠密格式的向量 y，即 y = y + alpha * xVal(xInd)

integer(4) function cusparseDaxpyi(handle, nnz, alpha, xVal, xInd, y, idxBase)
  type(cusparseHandle) :: handle
  integer :: nnz
  real(8), device :: alpha ! device or host variable
  real(8), device :: xVal(*)
  integer(4), device :: xInd(*)
  real(8), device :: y(*)
  integer :: idxBase

5.2.3. cusparseCaxpyi

CAXPY 执行常数乘以向量加向量。此函数将稀疏格式的向量 x 乘以常数 alpha，并将结果添加到稠密格式的向量 y，即 y = y + alpha * xVal(xInd)

integer(4) function cusparseCaxpyi(handle, nnz, alpha, xVal, xInd, y, idxBase)
  type(cusparseHandle) :: handle
  integer :: nnz
  complex(4), device :: alpha ! device or host variable
  complex(4), device :: xVal(*)
  integer(4), device :: xInd(*)
  complex(4), device :: y(*)
  integer :: idxBase

5.2.4. cusparseZaxpyi

ZAXPY 执行常数乘以向量加向量。此函数将稀疏格式的向量 x 乘以常数 alpha，并将结果添加到稠密格式的向量 y，即 y = y + alpha * xVal(xInd)

integer(4) function cusparseZaxpyi(handle, nnz, alpha, xVal, xInd, y, idxBase)
  type(cusparseHandle) :: handle
  integer :: nnz
  complex(8), device :: alpha ! device or host variable
  complex(8), device :: xVal(*)
  integer(4), device :: xInd(*)
  complex(8), device :: y(*)
  integer :: idxBase

5.2.5. cusparseSdoti

SDOT 形成两个向量的点积。此函数返回稀疏格式的向量 x 和稠密格式的向量 y 的点积，即 res = sum(y * xVal(xInd))

此函数已在 CUDA 11.0 中移除。应将其替换为对 cusparseSpVV 的调用

integer(4) function cusparseSdoti(handle, nnz, xVal, xInd, y, res, idxBase)
  type(cusparseHandle) :: handle
  integer :: nnz
  real(4), device :: xVal(*)
  integer(4), device :: xInd(*)
  real(4), device :: y(*)
  real(4), device :: res ! device or host variable
  integer :: idxBase

5.2.6. cusparseDdoti

DDOT 形成两个向量的点积。此函数返回稀疏格式的向量 x 和稠密格式的向量 y 的点积，即 res = sum(y * xVal(xInd))

此函数已在 CUDA 11.0 中移除。应将其替换为对 cusparseSpVV 的调用

integer(4) function cusparseDdoti(handle, nnz, xVal, xInd, y, res, idxBase)
  type(cusparseHandle) :: handle
  integer :: nnz
  real(8), device :: xVal(*)
  integer(4), device :: xInd(*)
  real(8), device :: y(*)
  real(8), device :: res ! device or host variable
  integer :: idxBase

5.2.7. cusparseCdoti

CDOT 形成两个向量的点积。此函数返回稀疏格式的向量 x 和稠密格式的向量 y 的点积，即 res = sum(y * xVal(xInd))

此函数已在 CUDA 11.0 中移除。应将其替换为对 cusparseSpVV 的调用

integer(4) function cusparseCdoti(handle, nnz, xVal, xInd, y, res, idxBase)
  type(cusparseHandle) :: handle
  integer :: nnz
  complex(4), device :: xVal(*)
  integer(4), device :: xInd(*)
  complex(4), device :: y(*)
  complex(4), device :: res ! device or host variable
  integer :: idxBase

5.2.8. cusparseZdoti

ZDOT 形成两个向量的点积。此函数返回稀疏格式的向量 x 和稠密格式的向量 y 的点积，即 res = sum(y * xVal(xInd))

此函数已在 CUDA 11.0 中移除。应将其替换为对 cusparseSpVV 的调用

integer(4) function cusparseZdoti(handle, nnz, xVal, xInd, y, res, idxBase)
  type(cusparseHandle) :: handle
  integer :: nnz
  complex(8), device :: xVal(*)
  integer(4), device :: xInd(*)
  complex(8), device :: y(*)
  complex(8), device :: res ! device or host variable
  integer :: idxBase

5.2.9. cusparseCdotci

CDOTC 形成两个向量的点积，共轭第一个向量。此函数返回稀疏格式的向量 x 和稠密格式的向量 y 的点积，即 res = sum(y * conjg(xVal(xInd))

此函数已在 CUDA 11.0 中移除。应将其替换为对 cusparseSpVV 的调用

integer(4) function cusparseCdotci(handle, nnz, xVal, xInd, y, res, idxBase)
  type(cusparseHandle) :: handle
  integer :: nnz
  complex(4), device :: xVal(*)
  integer(4), device :: xInd(*)
  complex(4), device :: y(*)
  complex(4), device :: res ! device or host variable
  integer :: idxBase

5.2.10. cusparseZdotci

ZDOTC 形成两个向量的点积，共轭第一个向量。此函数返回稀疏格式的向量 x 和稠密格式的向量 y 的点积，即 res = sum(y * conjg(xVal(xInd))

此函数已在 CUDA 11.0 中移除。应将其替换为对 cusparseSpVV 的调用

integer(4) function cusparseZdotci(handle, nnz, xVal, xInd, y, res, idxBase)
  type(cusparseHandle) :: handle
  integer :: nnz
  complex(8), device :: xVal(*)
  integer(4), device :: xInd(*)
  complex(8), device :: y(*)
  complex(8), device :: res ! device or host variable
  integer :: idxBase

5.2.11. cusparseSgthr

此函数将索引数组 xInd 中列出的向量 y 的元素收集到数据数组 xVal 中，即 xVal = y(xInd)。Fortran 程序员通常应使用 idxBase == 1。

integer(4) function cusparseSgthr(handle, nnz, y, xVal, xInd, idxBase)
  type(cusparseHandle) :: handle
  integer(4) :: nnz
  real(4), device :: y(*)
  real(4), device :: xVal(*)
  integer(4), device :: xInd(*)
  integer(4) :: idxBase

5.2.12. cusparseDgthr

此函数将索引数组 xInd 中列出的向量 y 的元素收集到数据数组 xVal 中，即 xVal = y(xInd)。Fortran 程序员通常应使用 idxBase == 1。

integer(4) function cusparseDgthr(handle, nnz, y, xVal, xInd, idxBase)
  type(cusparseHandle) :: handle
  integer(4) :: nnz
  real(8), device :: y(*)
  real(8), device :: xVal(*)
  integer(4), device :: xInd(*)
  integer(4) :: idxBase

5.2.13. cusparseCgthr

此函数将索引数组 xInd 中列出的向量 y 的元素收集到数据数组 xVal 中，即 xVal = y(xInd)。Fortran 程序员通常应使用 idxBase == 1。

integer(4) function cusparseCgthr(handle, nnz, y, xVal, xInd, idxBase)
  type(cusparseHandle) :: handle
  integer(4) :: nnz
  complex(4), device :: y(*)
  complex(4), device :: xVal(*)
  integer(4), device :: xInd(*)
  integer(4) :: idxBase

5.2.14. cusparseZgthr

此函数将索引数组 xInd 中列出的向量 y 的元素收集到数据数组 xVal 中，即 xVal = y(xInd)。Fortran 程序员通常应使用 idxBase == 1。

integer(4) function cusparseZgthr(handle, nnz, y, xVal, xInd, idxBase)
  type(cusparseHandle) :: handle
  integer(4) :: nnz
  complex(8), device :: y(*)
  complex(8), device :: xVal(*)
  integer(4), device :: xInd(*)
  integer(4) :: idxBase

5.2.15. cusparseSgthrz

此函数将索引数组 xInd 中列出的向量 y 的元素收集到数据数组 xVal 中，即 xVal = y(xInd); y(xInd) = 0.0。Fortran 程序员通常应使用 idxBase == 1。

integer(4) function cusparseSgthrz(handle, nnz, y, xVal, xInd, idxBase)
  type(cusparseHandle) :: handle
  integer(4) :: nnz
  real(4), device :: y(*)
  real(4), device :: xVal(*)
  integer(4), device :: xInd(*)
  integer(4) :: idxBase

5.2.16. cusparseDgthrz

此函数将索引数组 xInd 中列出的向量 y 的元素收集到数据数组 xVal 中，即 xVal = y(xInd); y(xInd) = 0.0。Fortran 程序员通常应使用 idxBase == 1。

integer(4) function cusparseDgthrz(handle, nnz, y, xVal, xInd, idxBase)
  type(cusparseHandle) :: handle
  integer(4) :: nnz
  real(8), device :: y(*)
  real(8), device :: xVal(*)
  integer(4), device :: xInd(*)
  integer(4) :: idxBase

5.2.17. cusparseCgthrz

此函数将索引数组 xInd 中列出的向量 y 的元素收集到数据数组 xVal 中，即 xVal = y(xInd); y(xInd) = 0.0。Fortran 程序员通常应使用 idxBase == 1。

integer(4) function cusparseCgthrz(handle, nnz, y, xVal, xInd, idxBase)
  type(cusparseHandle) :: handle
  integer(4) :: nnz
  complex(4), device :: y(*)
  complex(4), device :: xVal(*)
  integer(4), device :: xInd(*)
  integer(4) :: idxBase

5.2.18. cusparseZgthrz

此函数将索引数组 xInd 中列出的向量 y 的元素收集到数据数组 xVal 中，即 xVal = y(xInd); y(xInd) = 0.0。Fortran 程序员通常应使用 idxBase == 1。

integer(4) function cusparseZgthrz(handle, nnz, y, xVal, xInd, idxBase)
  type(cusparseHandle) :: handle
  integer(4) :: nnz
  complex(8), device :: y(*)
  complex(8), device :: xVal(*)
  integer(4), device :: xInd(*)
  integer(4) :: idxBase

5.2.19. cusparseSsctr

此函数将稠密格式向量 x 的元素分散到稀疏格式的向量 y 中，即 y(xInd) = x。Fortran 程序员通常应使用 idxBase == 1。

integer(4) function cusparseSsctr(handle, nnz, xVal, xInd, y, idxBase)
  type(cusparseHandle) :: handle
  integer(4) :: nnz
  real(4), device :: xVal(*)
  integer(4), device :: xInd(*)
  real(4), device :: y(*)
  integer(4) :: idxBase

5.2.20. cusparseDsctr

此函数将稠密格式向量 x 的元素分散到稀疏格式的向量 y 中，即 y(xInd) = x。Fortran 程序员通常应使用 idxBase == 1。

integer(4) function cusparseDsctr(handle, nnz, xVal, xInd, y, idxBase)
  type(cusparseHandle) :: handle
  integer(4) :: nnz
  real(8), device :: xVal(*)
  integer(4), device :: xInd(*)
  real(8), device :: y(*)
  integer(4) :: idxBase

5.2.21. cusparseCsctr

此函数将稠密格式向量 x 的元素分散到稀疏格式的向量 y 中，即 y(xInd) = x。Fortran 程序员通常应使用 idxBase == 1。

integer(4) function cusparseCsctr(handle, nnz, xVal, xInd, y, idxBase)
  type(cusparseHandle) :: handle
  integer(4) :: nnz
  complex(4), device :: xVal(*)
  integer(4), device :: xInd(*)
  complex(4), device :: y(*)
  integer(4) :: idxBase

5.2.22. cusparseZsctr

此函数将稠密格式向量 x 的元素分散到稀疏格式的向量 y 中，即 y(xInd) = x。Fortran 程序员通常应使用 idxBase == 1。

integer(4) function cusparseZsctr(handle, nnz, xVal, xInd, y, idxBase)
  type(cusparseHandle) :: handle
  integer(4) :: nnz
  complex(8), device :: xVal(*)
  integer(4), device :: xInd(*)
  complex(8), device :: y(*)
  integer(4) :: idxBase

5.2.23. cusparseSroti

SROT 应用平面旋转。X 是稀疏向量，Y 是稠密向量。

integer(4) function cusparseSroti(handle, nnz, xVal, xInd, y, c, s, idxBase)
  type(cusparseHandle) :: handle
  integer :: nnz
  real(4), device :: xVal(*)
  integer(4), device :: xInd(*)
  real(4), device :: y(*)
  real(4), device :: c, s ! device or host variable
  integer :: idxBase

5.2.24. cusparseDroti

DROT 应用平面旋转。X 是稀疏向量，Y 是稠密向量。

integer(4) function cusparseDroti(handle, nnz, xVal, xInd, y, c, s, idxBase)
  type(cusparseHandle) :: handle
  integer :: nnz
  real(8), device :: xVal(*)
  integer(4), device :: xInd(*)
  real(8), device :: y(*)
  real(8), device :: c, s ! device or host variable
  integer :: idxBase

5.3. CUSPARSE Level 2 函数

本节包含用于执行稀疏矩阵和稠密向量之间运算的 2 级稀疏线性代数函数的接口。

5.3.1. cusparseSbsrmv

BSRMV 执行矩阵-向量运算 y := alpha*A*x + beta*y, 或 y := alpha*A**T*x + beta*y, 其中 alpha 和 beta 是标量，x 和 y 是向量，A 是一个 (mb*blockDim) x (nb*blockDim) 稀疏矩阵，该矩阵在 BSR 存储格式中由三个数组 bsrVal、bsrRowPtr 和 bsrColInd 定义

integer(4) function cusparseSbsrmv(handle, dir, trans, mb, nb, nnzb, alpha, descr, bsrVal, bsrRowPtr, bsrColInd, blockDim, x, beta, y)
  type(cusparseHandle) :: handle
  integer :: dir
  integer :: trans
  integer :: mb, nb, nnzb
  real(4), device :: alpha ! device or host variable
  type(cusparseMatDescr) :: descr
  real(4), device :: bsrVal(*)
  integer(4), device :: bsrRowPtr(*)
  integer(4), device :: bsrColInd(*)
  integer :: blockDim
  real(4), device :: x(*)
  real(4), device :: beta ! device or host variable
  real(4), device :: y(*)

5.3.2. cusparseDbsrmv

BSRMV 执行矩阵-向量运算 y := alpha*A*x + beta*y, 或 y := alpha*A**T*x + beta*y, 其中 alpha 和 beta 是标量，x 和 y 是向量，A 是一个 (mb*blockDim) x (nb*blockDim) 稀疏矩阵，该矩阵在 BSR 存储格式中由三个数组 bsrVal、bsrRowPtr 和 bsrColInd 定义

integer(4) function cusparseDbsrmv(handle, dir, trans, mb, nb, nnzb, alpha, descr, bsrVal, bsrRowPtr, bsrColInd, blockDim, x, beta, y)
  type(cusparseHandle) :: handle
  integer :: dir
  integer :: trans
  integer :: mb, nb, nnzb
  real(8), device :: alpha ! device or host variable
  type(cusparseMatDescr) :: descr
  real(8), device :: bsrVal(*)
  integer(4), device :: bsrRowPtr(*)
  integer(4), device :: bsrColInd(*)
  integer :: blockDim
  real(8), device :: x(*)
  real(8), device :: beta ! device or host variable
  real(8), device :: y(*)

5.3.3. cusparseCbsrmv

BSRMV 执行矩阵-向量运算 y := alpha*A*x + beta*y, 或 y := alpha*A**T*x + beta*y, 其中 alpha 和 beta 是标量，x 和 y 是向量，A 是一个 (mb*blockDim) x (nb*blockDim) 稀疏矩阵，该矩阵在 BSR 存储格式中由三个数组 bsrVal、bsrRowPtr 和 bsrColInd 定义

integer(4) function cusparseCbsrmv(handle, dir, trans, mb, nb, nnzb, alpha, descr, bsrVal, bsrRowPtr, bsrColInd, blockDim, x, beta, y)
  type(cusparseHandle) :: handle
  integer :: dir
  integer :: trans
  integer :: mb, nb, nnzb
  complex(4), device :: alpha ! device or host variable
  type(cusparseMatDescr) :: descr
  complex(4), device :: bsrVal(*)
  integer(4), device :: bsrRowPtr(*)
  integer(4), device :: bsrColInd(*)
  integer :: blockDim
  complex(4), device :: x(*)
  complex(4), device :: beta ! device or host variable
  complex(4), device :: y(*)

5.3.4. cusparseZbsrmv

BSRMV 执行矩阵-向量运算 y := alpha*A*x + beta*y, 或 y := alpha*A**T*x + beta*y, 其中 alpha 和 beta 是标量，x 和 y 是向量，A 是一个 (mb*blockDim) x (nb*blockDim) 稀疏矩阵，该矩阵在 BSR 存储格式中由三个数组 bsrVal、bsrRowPtr 和 bsrColInd 定义

integer(4) function cusparseZbsrmv(handle, dir, trans, mb, nb, nnzb, alpha, &
           descr, bsrVal, bsrRowPtr, bsrColInd, blockDim, x, beta, y)
  type(cusparseHandle) :: handle
  integer :: dir
  integer :: trans
  integer :: mb, nb, nnzb
  complex(8), device :: alpha ! device or host variable
  type(cusparseMatDescr) :: descr
  complex(8), device :: bsrVal(*)
  integer(4), device :: bsrRowPtr(*)
  integer(4), device :: bsrColInd(*)
  integer :: blockDim
  complex(8), device :: x(*)
  complex(8), device :: beta ! device or host variable
  complex(8), device :: y(*)

5.3.5. cusparseSbsrxmv

BSRXMV 执行 BSRMV 和掩码运算。

integer(4) function cusparseSbsrxmv(handle, dir, trans, sizeOfMask, mb, nb, nnzb, alpha, &
           descr, bsrVal, bsrMaskPtr, bsrRowPtr, bsrEndPtr, bsrColInd, blockDim, x, beta, y)
  type(cusparseHandle) :: handle
  integer :: dir
  integer :: trans
  integer :: sizeOfMask
  integer :: mb, nb, nnzb
  real(4), device :: alpha ! device or host variable
  type(cusparseMatDescr) :: descr
  real(4), device :: bsrVal(*)
  integer(4), device :: bsrMaskPtr(*), bsrRowPtr(*), bsrEndPtr(*)
  integer(4), device :: bsrColInd(*)
  integer :: blockDim
  real(4), device :: x(*)
  real(4), device :: beta ! device or host variable
  real(4), device :: y(*)

5.3.6. cusparseDbsrxmv

BSRXMV 执行 BSRMV 和掩码运算。

integer(4) function cusparseDbsrxmv(handle, dir, trans, sizeOfMask, mb, nb, nnzb, alpha, &
           descr, bsrVal, bsrMaskPtr, bsrRowPtr, bsrEndPtr, bsrColInd, blockDim, x, beta, y)
  type(cusparseHandle) :: handle
  integer :: dir
  integer :: trans
  integer :: sizeOfMask
  integer :: mb, nb, nnzb
  real(8), device :: alpha ! device or host variable
  type(cusparseMatDescr) :: descr
  real(8), device :: bsrVal(*)
  integer(4), device :: bsrMaskPtr(*), bsrRowPtr(*), bsrEndPtr(*)
  integer(4), device :: bsrColInd(*)
  integer :: blockDim
  real(8), device :: x(*)
  real(8), device :: beta ! device or host variable
  real(8), device :: y(*)

5.3.7. cusparseCbsrxmv

BSRXMV 执行 BSRMV 和掩码运算。

integer(4) function cusparseCbsrxmv(handle, dir, trans, sizeOfMask, mb, nb, nnzb, alpha, &
           descr, bsrVal, bsrMaskPtr, bsrRowPtr, bsrEndPtr, bsrColInd, blockDim, x, beta, y)
  type(cusparseHandle) :: handle
  integer :: dir
  integer :: trans
  integer :: sizeOfMask
  integer :: mb, nb, nnzb
  complex(4), device :: alpha ! device or host variable
  type(cusparseMatDescr) :: descr
  complex(4), device :: bsrVal(*)
  integer(4), device :: bsrMaskPtr(*), bsrRowPtr(*), bsrEndPtr(*)
  integer(4), device :: bsrColInd(*)
  integer :: blockDim
  complex(4), device :: x(*)
  complex(4), device :: beta ! device or host variable
  complex(4), device :: y(*)

5.3.8. cusparseZbsrxmv

BSRXMV 执行 BSRMV 和掩码运算。

integer(4) function cusparseZbsrxmv(handle, dir, trans, sizeOfMask, mb, nb, nnzb, alpha, &
           descr, bsrVal, bsrMaskPtr, bsrRowPtr, bsrEndPtr, bsrColInd, blockDim, x, beta, y)
  type(cusparseHandle) :: handle
  integer :: dir
  integer :: trans
  integer :: sizeOfMask
  integer :: mb, nb, nnzb
  complex(8), device :: alpha ! device or host variable
  type(cusparseMatDescr) :: descr
  complex(8), device :: bsrVal(*)
  integer(4), device :: bsrMaskPtr(*), bsrRowPtr(*), bsrEndPtr(*)
  integer(4), device :: bsrColInd(*)
  integer :: blockDim
  complex(8), device :: x(*)
  complex(8), device :: beta ! device or host variable
  complex(8), device :: y(*)

5.3.9. cusparseScsrmv

CSRMV 执行矩阵-向量运算 y := alpha*A*x + beta*y, 或 y := alpha*A**T*x + beta*y, 其中 alpha 和 beta 是标量，x 和 y 是向量，A 是一个 m x n 稀疏矩阵，该矩阵在 CSR 存储格式中由三个数组 csrValA、csrRowPtrA 和 csrColIndA 定义

此函数已在 CUDA 11.0 中移除。应将其替换为对 cusparseSpMV 的调用

integer(4) function cusparseScsrmv(handle, trans, m, n, nnz, alpha, descr, csrVal, csrRowPtr, csrColInd, x, beta, y)
  type(cusparseHandle) :: handle
  integer :: trans
  integer :: m, n, nnz
  real(4), device :: alpha ! device or host variable
  type(cusparseMatDescr) :: descr
  real(4), device :: csrVal(*)
  integer(4), device :: csrRowPtr(*)
  integer(4), device :: csrColInd(*)
  real(4), device :: x(*)
  real(4), device :: beta ! device or host variable
  real(4), device :: y(*)

5.3.10. cusparseDcsrmv

CSRMV 执行矩阵-向量运算 y := alpha*A*x + beta*y, 或 y := alpha*A**T*x + beta*y, 其中 alpha 和 beta 是标量，x 和 y 是向量，A 是一个 m x n 稀疏矩阵，该矩阵在 CSR 存储格式中由三个数组 csrValA、csrRowPtrA 和 csrColIndA 定义

此函数已在 CUDA 11.0 中移除。应将其替换为对 cusparseSpMV 的调用

integer(4) function cusparseDcsrmv(handle, trans, m, n, nnz, alpha, descr, csrVal, csrRowPtr, csrColInd, x, beta, y)
  type(cusparseHandle) :: handle
  integer :: trans
  integer :: m, n, nnz
  real(8), device :: alpha ! device or host variable
  type(cusparseMatDescr) :: descr
  real(8), device :: csrVal(*)
  integer(4), device :: csrRowPtr(*)
  integer(4), device :: csrColInd(*)
  real(8), device :: x(*)
  real(8), device :: beta ! device or host variable
  real(8), device :: y(*)

5.3.11. cusparseCcsrmv

CSRMV 执行矩阵-向量运算 y := alpha*A*x + beta*y, 或 y := alpha*A**T*x + beta*y, 其中 alpha 和 beta 是标量，x 和 y 是向量，A 是一个 m x n 稀疏矩阵，该矩阵在 CSR 存储格式中由三个数组 csrValA、csrRowPtrA 和 csrColIndA 定义

此函数已在 CUDA 11.0 中移除。应将其替换为对 cusparseSpMV 的调用

integer(4) function cusparseCcsrmv(handle, trans, m, n, nnz, alpha, descr, csrVal, csrRowPtr, csrColInd, x, beta, y)
  type(cusparseHandle) :: handle
  integer :: trans
  integer :: m, n, nnz
  complex(4), device :: alpha ! device or host variable
  type(cusparseMatDescr) :: descr
  complex(4), device :: csrVal(*)
  integer(4), device :: csrRowPtr(*)
  integer(4), device :: csrColInd(*)
  complex(4), device :: x(*)
  complex(4), device :: beta ! device or host variable
  complex(4), device :: y(*)

5.3.12. cusparseZcsrmv

CSRMV 执行矩阵-向量运算 y := alpha*A*x + beta*y, 或 y := alpha*A**T*x + beta*y, 其中 alpha 和 beta 是标量，x 和 y 是向量，A 是一个 m x n 稀疏矩阵，该矩阵在 CSR 存储格式中由三个数组 csrValA、csrRowPtrA 和 csrColIndA 定义

此函数已在 CUDA 11.0 中移除。应将其替换为对 cusparseSpMV 的调用

integer(4) function cusparseZcsrmv(handle, trans, m, n, nnz, alpha, descr, csrVal, csrRowPtr, csrColInd, x, beta, y)
  type(cusparseHandle) :: handle
  integer :: trans
  integer :: m, n, nnz
  complex(8), device :: alpha ! device or host variable
  type(cusparseMatDescr) :: descr
  complex(8), device :: csrVal(*)
  integer(4), device :: csrRowPtr(*)
  integer(4), device :: csrColInd(*)
  complex(8), device :: x(*)
  complex(8), device :: beta ! device or host variable
  complex(8), device :: y(*)

5.3.13. cusparseScsrsv_analysis

此函数执行 csrsv 的分析阶段。

integer(4) function cusparseScsrsv_analysis(handle, trans, m, nnz, descr, csrVal, csrRowPtr, csrColInd, info)
  type(cusparseHandle) :: handle
  integer(4) :: trans
  integer(4) :: m, nnz
  type(cusparseMatDescr) :: descr
  real(4), device :: csrVal(*)
  integer(4), device :: csrRowPtr(*)
  integer(4), device :: csrColInd(*)
  type(cusparseSolveAnalysisInfo) :: info

5.3.14. cusparseDcsrsv_analysis

此函数执行 csrsv 的分析阶段。

integer(4) function cusparseDcsrsv_analysis(handle, trans, m, nnz, descr, csrVal, csrRowPtr, csrColInd, info)
  type(cusparseHandle) :: handle
  integer(4) :: trans
  integer(4) :: m, nnz
  type(cusparseMatDescr) :: descr
  real(8), device :: csrVal(*)
  integer(4), device :: csrRowPtr(*)
  integer(4), device :: csrColInd(*)
  type(cusparseSolveAnalysisInfo) :: info

5.3.15. cusparseCcsrsv_analysis

此函数执行 csrsv 的分析阶段。

integer(4) function cusparseCcsrsv_analysis(handle, trans, m, nnz, descr, csrVal, csrRowPtr, csrColInd, info)
  type(cusparseHandle) :: handle
  integer(4) :: trans
  integer(4) :: m, nnz
  type(cusparseMatDescr) :: descr
  complex(4), device :: csrVal(*)
  integer(4), device :: csrRowPtr(*)
  integer(4), device :: csrColInd(*)
  type(cusparseSolveAnalysisInfo) :: info

5.3.16. cusparseZcsrsv_analysis

此函数执行 csrsv 的分析阶段。

integer(4) function cusparseZcsrsv_analysis(handle, trans, m, nnz, descr, csrVal, csrRowPtr, csrColInd, info)
  type(cusparseHandle) :: handle
  integer(4) :: trans
  integer(4) :: m, nnz
  type(cusparseMatDescr) :: descr
  complex(8), device :: csrVal(*)
  integer(4), device :: csrRowPtr(*)
  integer(4), device :: csrColInd(*)
  type(cusparseSolveAnalysisInfo) :: info

5.3.17. cusparseScsrsv_solve

此函数执行 csrsv 的求解阶段。

integer(4) function cusparseScsrsv_solve(handle, trans, m, alpha, descr, csrVal, csrRowPtr, csrColInd, info, x, y)
  type(cusparseHandle) :: handle
  integer :: trans
  integer :: m
  real(4), device :: alpha ! device or host variable
  type(cusparseMatDescr) :: descr
  real(4), device :: csrVal(*)
  integer(4), device :: csrRowPtr(*)
  integer(4), device :: csrColInd(*)
  type(cusparseSolveAnalysisInfo) :: info
  real(4), device :: x(*)
  real(4), device :: y(*)

5.3.18. cusparseDcsrsv_solve

此函数执行 csrsv 的求解阶段。

integer(4) function cusparseDcsrsv_solve(handle, trans, m, alpha, descr, csrVal, csrRowPtr, csrColInd, info, x, y)
  type(cusparseHandle) :: handle
  integer :: trans
  integer :: m
  real(8), device :: alpha ! device or host variable
  type(cusparseMatDescr) :: descr
  real(8), device :: csrVal(*)
  integer(4), device :: csrRowPtr(*)
  integer(4), device :: csrColInd(*)
  type(cusparseSolveAnalysisInfo) :: info
  real(8), device :: x(*)
  real(8), device :: y(*)

5.3.19. cusparseCcsrsv_solve

此函数执行 csrsv 的求解阶段。

integer(4) function cusparseCcsrsv_solve(handle, trans, m, alpha, descr, csrVal, csrRowPtr, csrColInd, info, x, y)
  type(cusparseHandle) :: handle
  integer :: trans
  integer :: m
  complex(4), device :: alpha ! device or host variable
  type(cusparseMatDescr) :: descr
  complex(4), device :: csrVal(*)
  integer(4), device :: csrRowPtr(*)
  integer(4), device :: csrColInd(*)
  type(cusparseSolveAnalysisInfo) :: info
  complex(4), device :: x(*)
  complex(4), device :: y(*)

5.3.20. cusparseZcsrsv_solve

此函数执行 csrsv 的求解阶段。

integer(4) function cusparseZcsrsv_solve(handle, trans, m, alpha, descr, csrVal, csrRowPtr, csrColInd, info, x, y)
  type(cusparseHandle) :: handle
  integer :: trans
  integer :: m
  complex(8), device :: alpha ! device or host variable
  type(cusparseMatDescr) :: descr
  complex(8), device :: csrVal(*)
  integer(4), device :: csrRowPtr(*)
  integer(4), device :: csrColInd(*)
  type(cusparseSolveAnalysisInfo) :: info
  complex(8), device :: x(*)
  complex(8), device :: y(*)

5.3.21. cusparseSgemvi_bufferSize

此函数返回 cusparseSgemvi 所需的缓冲区大小（以字节为单位）。

integer(4) function cusparseSgemvi_bufferSize(handle, transA, m, n, nnz, pBufferSize)
  type(cusparseHandle) :: handle
  integer :: transA
  integer :: m, n, nnz
  integer(4) :: pBufferSize

5.3.22. cusparseDgemvi_bufferSize

此函数返回 cusparseDgemvi 所需的缓冲区大小（以字节为单位）。

integer(4) function cusparseDgemvi_bufferSize(handle, transA, m, n, nnz, pBufferSize)
  type(cusparseHandle) :: handle
  integer :: transA
  integer :: m, n, nnz
  integer(4) :: pBufferSize

5.3.23. cusparseCgemvi_bufferSize

此函数返回 cusparseCgemvi 所需的缓冲区大小（以字节为单位）。

integer(4) function cusparseCgemvi_bufferSize(handle, transA, m, n, nnz, pBufferSize)
  type(cusparseHandle) :: handle
  integer :: transA
  integer :: m, n, nnz
  integer(4) :: pBufferSize

5.3.24. cusparseZgemvi_bufferSize

此函数返回 cusparseZgemvi 所需的缓冲区大小（以字节为单位）。

integer(4) function cusparseZgemvi_bufferSize(handle, transA, m, n, nnz, pBufferSize)
  type(cusparseHandle) :: handle
  integer :: transA
  integer :: m, n, nnz
  integer(4) :: pBufferSize

5.3.25. cusparseSgemvi

GEMVI 执行矩阵-向量运算 y := alpha*A*x + beta*y，其中 alpha 和 beta 是标量，A 是 m x n 稠密矩阵，x 是稀疏向量，y 是稠密向量。

integer(4) function cusparseSgemvi(handle, transA, m, n, alpha, A, lda, nnz, xVal, xInd, beta, y, idxBase, pBuffer)
  type(cusparseHandle) :: handle
  integer :: transA
  integer :: m, n, lda, nnz, idxBase
  real(4), device :: alpha, beta ! device or host variable
  real(4), device :: A(lda,*)
  real(4), device :: xVal(*)
  integer(4), device :: xInd(*)
  real(4), device :: y(*)
  integer(1), device :: pBuffer(*) ! Any data type is allowed

5.3.26. cusparseDgemvi

GEMVI 执行矩阵-向量运算 y := alpha*A*x + beta*y，其中 alpha 和 beta 是标量，A 是 m x n 稠密矩阵，x 是稀疏向量，y 是稠密向量。

integer(4) function cusparseDgemvi(handle, transA, m, n, alpha, A, lda, nnz, xVal, xInd, beta, y, idxBase, pBuffer)
  type(cusparseHandle) :: handle
  integer :: transA
  integer :: m, n, lda, nnz, idxBase
  real(8), device :: alpha, beta ! device or host variable
  real(8), device :: A(lda,*)
  real(8), device :: xVal(*)
  integer(4), device :: xInd(*)
  real(8), device :: y(*)
  integer(1), device :: pBuffer(*) ! Any data type is allowed

5.3.27. cusparseCgemvi

GEMVI 执行矩阵-向量运算 y := alpha*A*x + beta*y，其中 alpha 和 beta 是标量，A 是 m x n 稠密矩阵，x 是稀疏向量，y 是稠密向量。

integer(4) function cusparseCgemvi(handle, transA, m, n, alpha, A, lda, nnz, xVal, xInd, beta, y, idxBase, pBuffer)
  type(cusparseHandle) :: handle
  integer :: transA
  integer :: m, n, lda, nnz, idxBase
  complex(4), device :: alpha, beta ! device or host variable
  complex(4), device :: A(lda,*)
  complex(4), device :: xVal(*)
  integer(4), device :: xInd(*)
  complex(4), device :: y(*)
  integer(1), device :: pBuffer(*) ! Any data type is allowed

5.3.28. cusparseZgemvi

GEMVI 执行矩阵-向量运算 y := alpha*A*x + beta*y，其中 alpha 和 beta 是标量，A 是 m x n 稠密矩阵，x 是稀疏向量，y 是稠密向量。

integer(4) function cusparseZgemvi(handle, transA, m, n, alpha, A, lda, nnz, xVal, xInd, beta, y, idxBase, pBuffer)
  type(cusparseHandle) :: handle
  integer :: transA
  integer :: m, n, lda, nnz, idxBase
  complex(8), device :: alpha, beta ! device or host variable
  complex(8), device :: A(lda,*)
  complex(8), device :: xVal(*)
  integer(4), device :: xInd(*)
  complex(8), device :: y(*)
  integer(1), device :: pBuffer(*) ! Any data type is allowed

5.3.29. cusparseShybmv

HYBMV 执行矩阵-向量运算 y := alpha*A*x + beta*y，其中 alpha 和 beta 是标量，x 和 y 是向量，A 是一个以 HYB 存储格式定义的 m x n 稀疏矩阵。

此函数已在 CUDA 11.0 中移除。

integer(4) function cusparseShybmv(handle, trans, alpha, descr, hyb, x, beta, y)
  type(cusparseHandle) :: handle
  integer :: trans
  real(4), device :: alpha ! device or host variable
  type(cusparseMatDescr) :: descr
  type(cusparseHybMat) :: hyb
  real(4), device :: x(*)
  real(4), device :: beta ! device or host variable
  real(4), device :: y(*)

5.3.30. cusparseDhybmv

HYBMV 执行矩阵-向量运算 y := alpha*A*x + beta*y，其中 alpha 和 beta 是标量，x 和 y 是向量，A 是一个以 HYB 存储格式定义的 m x n 稀疏矩阵。

此函数已在 CUDA 11.0 中移除。

integer(4) function cusparseDhybmv(handle, trans, alpha, descr, hyb, x, beta, y)
  type(cusparseHandle) :: handle
  integer :: trans
  real(8), device :: alpha ! device or host variable
  type(cusparseMatDescr) :: descr
  type(cusparseHybMat) :: hyb
  real(8), device :: x(*)
  real(8), device :: beta ! device or host variable
  real(8), device :: y(*)

5.3.31. cusparseChybmv

HYBMV 执行矩阵-向量运算 y := alpha*A*x + beta*y，其中 alpha 和 beta 是标量，x 和 y 是向量，A 是一个以 HYB 存储格式定义的 m x n 稀疏矩阵。

此函数已在 CUDA 11.0 中移除。

integer(4) function cusparseChybmv(handle, trans, alpha, descr, hyb, x, beta, y)
  type(cusparseHandle) :: handle
  integer :: trans
  complex(4), device :: alpha ! device or host variable
  type(cusparseMatDescr) :: descr
  type(cusparseHybMat) :: hyb
  complex(4), device :: x(*)
  complex(4), device :: beta ! device or host variable
  complex(4), device :: y(*)

5.3.32. cusparseZhybmv

HYBMV 执行矩阵-向量运算 y := alpha*A*x + beta*y，其中 alpha 和 beta 是标量，x 和 y 是向量，A 是一个以 HYB 存储格式定义的 m x n 稀疏矩阵。

此函数已在 CUDA 11.0 中移除。

integer(4) function cusparseZhybmv(handle, trans, alpha, descr, hyb, x, beta, y)
  type(cusparseHandle) :: handle
  integer :: trans
  complex(8), device :: alpha ! device or host variable
  type(cusparseMatDescr) :: descr
  type(cusparseHybMat) :: hyb
  complex(8), device :: x(*)
  complex(8), device :: beta ! device or host variable
  complex(8), device :: y(*)

5.3.33. cusparseShybsv_analysis

此函数执行 hybsv 的分析阶段。

integer(4) function cusparseShybsv_analysis(handle, trans, descr, hyb, info)
  type(cusparseHandle) :: handle
  integer(4) :: trans
  type(cusparseMatDescr) :: descr
  type(cusparseHybMat) :: hyb
  type(cusparseSolveAnalysisInfo) :: info

5.3.34. cusparseDhybsv_analysis

此函数执行 hybsv 的分析阶段。

integer(4) function cusparseDhybsv_analysis(handle, trans, descr, hyb, info)
  type(cusparseHandle) :: handle
  integer(4) :: trans
  type(cusparseMatDescr) :: descr
  type(cusparseHybMat) :: hyb
  type(cusparseSolveAnalysisInfo) :: info

5.3.35. cusparseChybsv_analysis

此函数执行 hybsv 的分析阶段。

integer(4) function cusparseChybsv_analysis(handle, trans, descr, hyb, info)
  type(cusparseHandle) :: handle
  integer(4) :: trans
  type(cusparseMatDescr) :: descr
  type(cusparseHybMat) :: hyb
  type(cusparseSolveAnalysisInfo) :: info

5.3.36. cusparseZhybsv_analysis

此函数执行 hybsv 的分析阶段。

integer(4) function cusparseZhybsv_analysis(handle, trans, descr, hyb, info)
  type(cusparseHandle) :: handle
  integer(4) :: trans
  type(cusparseMatDescr) :: descr
  type(cusparseHybMat) :: hyb
  type(cusparseSolveAnalysisInfo) :: info

5.3.37. cusparseShybsv_solve

此函数执行 hybsv 的求解阶段。

integer(4) function cusparseShybsv_solve(handle, trans, alpha, descr, hyb, info, x, y)
  type(cusparseHandle) :: handle
  integer :: trans
  real(4), device :: alpha ! device or host variable
  type(cusparseMatDescr) :: descr
  type(cusparseHybMat) :: hyb
  type(cusparseSolveAnalysisInfo) :: info
  real(4), device :: x(*)
  real(4), device :: y(*)

5.3.38. cusparseDhybsv_solve

此函数执行 hybsv 的求解阶段。

integer(4) function cusparseDhybsv_solve(handle, trans, alpha, descr, hyb, info, x, y)
  type(cusparseHandle) :: handle
  integer :: trans
  real(8), device :: alpha ! device or host variable
  type(cusparseMatDescr) :: descr
  type(cusparseHybMat) :: hyb
  type(cusparseSolveAnalysisInfo) :: info
  real(8), device :: x(*)
  real(8), device :: y(*)

5.3.39. cusparseChybsv_solve

此函数执行 hybsv 的求解阶段。

integer(4) function cusparseChybsv_solve(handle, trans, alpha, descr, hyb, info, x, y)
  type(cusparseHandle) :: handle
  integer :: trans
  complex(4), device :: alpha ! device or host variable
  type(cusparseMatDescr) :: descr
  type(cusparseHybMat) :: hyb
  type(cusparseSolveAnalysisInfo) :: info
  complex(4), device :: x(*)
  complex(4), device :: y(*)

5.3.40. cusparseZhybsv_solve

此函数执行 hybsv 的求解阶段。

integer(4) function cusparseZhybsv_solve(handle, trans, alpha, descr, hyb, info, x, y)
  type(cusparseHandle) :: handle
  integer :: trans
  complex(8), device :: alpha ! device or host variable
  type(cusparseMatDescr) :: descr
  type(cusparseHybMat) :: hyb
  type(cusparseSolveAnalysisInfo) :: info
  complex(8), device :: x(*)
  complex(8), device :: y(*)

5.3.41. cusparseSbsrsv2_bufferSize

此函数返回 bsrsv2 中使用的缓冲区大小。

integer(4) function cusparseSbsrsv2_bufferSize(handle, dirA, transA, mb, nnzb, &
           descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, pBufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: dirA, transA
  integer(4) :: mb, nnzb
  type(cusparseMatDescr) :: descrA
  real(4), device :: bsrValA(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer(4) :: blockDim
  type(cusparseBsrsv2Info) :: info
  integer(4) :: pBufferSize ! integer(8) also accepted

5.3.42. cusparseDbsrsv2_bufferSize

此函数返回 bsrsv2 中使用的缓冲区大小。

integer(4) function cusparseDbsrsv2_bufferSize(handle, dirA, transA, mb, nnzb, &
           descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, pBufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: dirA, transA
  integer(4) :: mb, nnzb
  type(cusparseMatDescr) :: descrA
  real(8), device :: bsrValA(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer(4) :: blockDim
  type(cusparseBsrsv2Info) :: info
  integer(4) :: pBufferSize ! integer(8) also accepted

5.3.43. cusparseCbsrsv2_bufferSize

此函数返回 bsrsv2 中使用的缓冲区大小。

integer(4) function cusparseCbsrsv2_bufferSize(handle, dirA, transA, mb, nnzb, &
           descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, pBufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: dirA, transA
  integer(4) :: mb, nnzb
  type(cusparseMatDescr) :: descrA
  complex(4), device :: bsrValA(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer(4) :: blockDim
  type(cusparseBsrsv2Info) :: info
  integer(4) :: pBufferSize ! integer(8) also accepted

5.3.44. cusparseZbsrsv2_bufferSize

此函数返回 bsrsv2 中使用的缓冲区大小。

integer(4) function cusparseZbsrsv2_bufferSize(handle, dirA, transA, mb, nnzb, &
           descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, pBufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: dirA, transA
  integer(4) :: mb, nnzb
  type(cusparseMatDescr) :: descrA
  complex(8), device :: bsrValA(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer(4) :: blockDim
  type(cusparseBsrsv2Info) :: info
  integer(4) :: pBufferSize ! integer(8) also accepted

5.3.45. cusparseSbsrsv2_analysis

此函数执行 bsrsv2 的分析阶段。

integer(4) function cusparseSbsrsv2_analysis(handle, dirA, transA, mb, nnzb, &
           descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: dirA, transA
  integer(4) :: mb, nnzb
  type(cusparseMatDescr) :: descrA
  real(4), device :: bsrValA(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer(4) :: blockDim
  type(cusparseBsrsv2Info) :: info
  integer(4) :: policy
  character(c_char), device :: pBuffer(*)

5.3.46. cusparseDbsrsv2_analysis

此函数执行 bsrsv2 的分析阶段。

integer(4) function cusparseDbsrsv2_analysis(handle, dirA, transA, mb, nnzb, &
           descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: dirA, transA
  integer(4) :: mb, nnzb
  type(cusparseMatDescr) :: descrA
  real(8), device :: bsrValA(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer(4) :: blockDim
  type(cusparseBsrsv2Info) :: info
  integer(4) :: policy
  character(c_char), device :: pBuffer(*)

5.3.47. cusparseCbsrsv2_analysis

此函数执行 bsrsv2 的分析阶段。

integer(4) function cusparseCbsrsv2_analysis(handle, dirA, transA, mb, nnzb, &
           descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: dirA, transA
  integer(4) :: mb, nnzb
  type(cusparseMatDescr) :: descrA
  complex(4), device :: bsrValA(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer(4) :: blockDim
  type(cusparseBsrsv2Info) :: info
  integer(4) :: policy
  character(c_char), device :: pBuffer(*)

5.3.48. cusparseZbsrsv2_analysis

此函数执行 bsrsv2 的分析阶段。

integer(4) function cusparseZbsrsv2_analysis(handle, dirA, transA, mb, nnzb, &
           descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: dirA, transA
  integer(4) :: mb, nnzb
  type(cusparseMatDescr) :: descrA
  complex(8), device :: bsrValA(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer(4) :: blockDim
  type(cusparseBsrsv2Info) :: info
  integer(4) :: policy
  character(c_char), device :: pBuffer(*)

5.3.49. cusparseSbsrsv2_solve

此函数执行 bsrsv2 的求解阶段。

integer(4) function cusparseSbsrsv2_solve(handle, dirA, transA, mb, nnzb, &
           alpha, descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, x, y, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer :: dirA, transA, mb, nnzb
  real(4), device :: alpha ! device or host variable
  type(cusparseMatDescr) :: descrA
  real(4), device :: bsrValA(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer :: blockDim
  type(cusparseBsrsv2Info) :: info
  real(4), device :: x(*), y(*)
  integer :: policy
  character, device :: pBuffer(*)

5.3.50. cusparseDbsrsv2_solve

此函数执行 bsrsv2 的求解阶段。

integer(4) function cusparseDbsrsv2_solve(handle, dirA, transA, mb, nnzb, &
           alpha, descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, x, y, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer :: dirA, transA, mb, nnzb
  real(8), device :: alpha ! device or host variable
  type(cusparseMatDescr) :: descrA
  real(8), device :: bsrValA(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer :: blockDim
  type(cusparseBsrsv2Info) :: info
  real(8), device :: x(*), y(*)
  integer :: policy
  character, device :: pBuffer(*)

5.3.51. cusparseCbsrsv2_solve

此函数执行 bsrsv2 的求解阶段。

integer(4) function cusparseCbsrsv2_solve(handle, dirA, transA, mb, nnzb, alpha, &
           descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, x, y, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer :: dirA, transA, mb, nnzb
  complex(4), device :: alpha ! device or host variable
  type(cusparseMatDescr) :: descrA
  complex(4), device :: bsrValA(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer :: blockDim
  type(cusparseBsrsv2Info) :: info
  complex(4), device :: x(*), y(*)
  integer :: policy
  character, device :: pBuffer(*)

5.3.52. cusparseZbsrsv2_solve

此函数执行 bsrsv2 的求解阶段。

integer(4) function cusparseZbsrsv2_solve(handle, dirA, transA, mb, nnzb, alpha, &
           descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, x, y, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer :: dirA, transA, mb, nnzb
  complex(8), device :: alpha ! device or host variable
  type(cusparseMatDescr) :: descrA
  complex(8), device :: bsrValA(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer :: blockDim
  type(cusparseBsrsv2Info) :: info
  complex(8), device :: x(*), y(*)
  integer :: policy
  character, device :: pBuffer(*)

5.3.53. cusparseXbsrsv2_zeroPivot

当 A(j,j) 是结构零或数值零时，此函数返回等于 CUSPARSE_STATUS_ZERO_PIVOT 的错误代码，并将 position 设置为 j。否则，position 将设置为 -1。

integer(4) function cusparseXbsrsv2_zeroPivot(handle, info, position)
  type(cusparseHandle) :: handle
  type(cusparseBsrsv2Info) :: info
  integer(4), device :: position ! device or host variable

5.3.54. cusparseScsrsv2_bufferSize

此函数返回 csrsv2 中使用的缓冲区大小。

integer(4) function cusparseScsrsv2_bufferSize(handle, transA, m, nnz, descrA, &
           csrValA, csrRowPtrA, csrColIndA, info, pBufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: transA, m, nnz
  type(cusparseMatDescr) :: descrA
  real(4), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseCsrsv2Info) :: info
  integer(4) :: pBufferSize ! integer(8) also accepted

5.3.55. cusparseDcsrsv2_bufferSize

此函数返回 csrsv2 中使用的缓冲区大小。

integer(4) function cusparseDcsrsv2_bufferSize(handle, transA, m, nnz, descrA, &
           csrValA, csrRowPtrA, csrColIndA, info, pBufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: transA, m, nnz
  type(cusparseMatDescr) :: descrA
  real(8), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseCsrsv2Info) :: info
  integer(4) :: pBufferSize ! integer(8) also accepted

5.3.56. cusparseCcsrsv2_bufferSize

此函数返回 csrsv2 中使用的缓冲区大小。

integer(4) function cusparseCcsrsv2_bufferSize(handle, transA, m, nnz, descrA, csrValA, &
           csrRowPtrA, csrColIndA, info, pBufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: transA, m, nnz
  type(cusparseMatDescr) :: descrA
  complex(4), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseCsrsv2Info) :: info
  integer(4) :: pBufferSize ! integer(8) also accepted

5.3.57. cusparseZcsrsv2_bufferSize

此函数返回 csrsv2 中使用的缓冲区大小。

integer(4) function cusparseZcsrsv2_bufferSize(handle, transA, m, nnz, descrA, &
           csrValA, csrRowPtrA, csrColIndA, info, pBufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: transA, m, nnz
  type(cusparseMatDescr) :: descrA
  complex(8), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseCsrsv2Info) :: info
  integer(4) :: pBufferSize ! integer(8) also accepted

5.3.58. cusparseScsrsv2_analysis

此函数执行 csrsv2 的分析阶段。

integer(4) function cusparseScsrsv2_analysis(handle, transA, m, nnz, descrA, &
           csrValA, csrRowPtrA, csrColIndA, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: transA, m, nnz
  type(cusparseMatDescr) :: descrA
  real(4), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseCsrsv2Info) :: info
  integer(4) :: policy
  character(c_char), device :: pBuffer(*)

5.3.59. cusparseDcsrsv2_analysis

此函数执行 csrsv2 的分析阶段。

integer(4) function cusparseDcsrsv2_analysis(handle, transA, m, nnz, descrA, &
           csrValA, csrRowPtrA, csrColIndA, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: transA, m, nnz
  type(cusparseMatDescr) :: descrA
  real(8), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseCsrsv2Info) :: info
  integer(4) :: policy
  character(c_char), device :: pBuffer(*)

5.3.60. cusparseCcsrsv2_analysis

此函数执行 csrsv2 的分析阶段。

integer(4) function cusparseCcsrsv2_analysis(handle, transA, m, nnz, descrA, &
           csrValA, csrRowPtrA, csrColIndA, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: transA, m, nnz
  type(cusparseMatDescr) :: descrA
  complex(4), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseCsrsv2Info) :: info
  integer(4) :: policy
  character(c_char), device :: pBuffer(*)

5.3.61. cusparseZcsrsv2_analysis

此函数执行 csrsv2 的分析阶段。

integer(4) function cusparseZcsrsv2_analysis(handle, transA, m, nnz, descrA, &
           csrValA, csrRowPtrA, csrColIndA, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: transA, m, nnz
  type(cusparseMatDescr) :: descrA
  complex(8), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseCsrsv2Info) :: info
  integer(4) :: policy
  character(c_char), device :: pBuffer(*)

5.3.62. cusparseScsrsv2_solve

此函数执行 csrsv2 的求解阶段。

integer(4) function cusparseScsrsv2_solve(handle, transA, m, nnz, alpha, descrA, &
           csrValA, csrRowPtrA, csrColIndA, info, x, y, policy, pBuffer)
  type(cusparseHandle) :: handle
  real(4), device :: alpha ! device or host variable
  type(cusparseMatDescr) :: descrA
  real(4), device :: csrValA(*), x(*), y(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseCsrsv2Info) :: info
  integer :: policy
  character, device :: pBuffer(*)

5.3.63. cusparseDcsrsv2_solve

此函数执行 csrsv2 的求解阶段。

integer(4) function cusparseDcsrsv2_solve(handle, transA, m, nnz, alpha, &
           descrA, csrValA, csrRowPtrA, csrColIndA, info, x, y, policy, pBuffer)
  type(cusparseHandle) :: handle
  real(8), device :: alpha ! device or host variable
  type(cusparseMatDescr) :: descrA
  real(8), device :: csrValA(*), x(*), y(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseCsrsv2Info) :: info
  integer :: policy
  character, device :: pBuffer(*)

5.3.64. cusparseCcsrsv2_solve

此函数执行 csrsv2 的求解阶段。

integer(4) function cusparseCcsrsv2_solve(handle, transA, m, nnz, alpha, &
           descrA, csrValA, csrRowPtrA, csrColIndA, info, x, y, policy, pBuffer)
  type(cusparseHandle) :: handle
  complex(4), device :: alpha ! device or host variable
  type(cusparseMatDescr) :: descrA
  complex(4), device :: csrValA(*), x(*), y(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseCsrsv2Info) :: info
  integer :: policy
  character, device :: pBuffer(*)

5.3.65. cusparseZcsrsv2_solve

此函数执行 csrsv2 的求解阶段。

integer(4) function cusparseZcsrsv2_solve(handle, transA, m, nnz, alpha, &
           descrA, csrValA, csrRowPtrA, csrColIndA, info, x, y, policy, pBuffer)
  type(cusparseHandle) :: handle
  complex(8), device :: alpha ! device or host variable
  type(cusparseMatDescr) :: descrA
  complex(8), device :: csrValA(*), x(*), y(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseCsrsv2Info) :: info
  integer :: policy
  character, device :: pBuffer(*)

5.3.66. cusparseXcsrsv2_zeroPivot

当 A(j,j) 是结构零或数值零时，此函数返回等于 CUSPARSE_STATUS_ZERO_PIVOT 的错误代码，并将 position 设置为 j。否则，position 将设置为 -1。

integer(4) function cusparseXcsrsv2_zeroPivot(handle, info, position)
  type(cusparseHandle) :: handle
  type(cusparseCsrsv2Info) :: info
  integer(4), device :: position ! device or host variable

5.4. CUSPARSE Level 3 函数

本节包含用于执行稀疏矩阵和稠密矩阵之间运算的 3 级稀疏线性代数函数的接口。

5.4.1. cusparseScsrmm

CSRMM 执行矩阵-矩阵运算 C := alpha*op( A ) * B + beta*C 之一，其中 op( A ) 是 op( A ) = A 或 op( A ) = A**T 之一，alpha 和 beta 是标量。A 是一个 m x k 稀疏矩阵，通过三个数组 csrValA、csrRowPtrA 和 csrColIndA 以 CSR 存储格式定义。B 和 C 是稠密矩阵。

此函数已在 CUDA 11.0 中移除。应将其替换为对 cusparseSpMM 的调用

integer(4) function cusparseScsrmm(handle, transA, m, n, k, nnz, alpha, &
           descrA, csrValA, csrRowPtrA, csrColIndA, B, ldb, beta, C, ldc)
  type(cusparseHandle) :: handle
  integer :: transA, m, n, k, nnz
  real(4), device :: alpha, beta ! device or host variable
  type(cusparseMatDescr) :: descrA
  real(4), device :: csrValA(*), B(*), C(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  integer :: ldb, ldc

5.4.2. cusparseDcsrmm

CSRMM 执行矩阵-矩阵运算 C := alpha*op( A ) * B + beta*C 之一，其中 op( A ) 是 op( A ) = A 或 op( A ) = A**T 之一，alpha 和 beta 是标量。A 是一个 m x k 稀疏矩阵，通过三个数组 csrValA、csrRowPtrA 和 csrColIndA 以 CSR 存储格式定义。B 和 C 是稠密矩阵。

此函数已在 CUDA 11.0 中移除。应将其替换为对 cusparseSpMM 的调用

integer(4) function cusparseDcsrmm(handle, transA, m, n, k, nnz, alpha, &
           descrA, csrValA, csrRowPtrA, csrColIndA, B, ldb, beta, C, ldc)
  type(cusparseHandle) :: handle
  integer :: transA, m, n, k, nnz
  real(8), device :: alpha, beta ! device or host variable
  type(cusparseMatDescr) :: descrA
  real(8), device :: csrValA(*), B(*), C(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  integer :: ldb, ldc

5.4.3. cusparseCcsrmm

CSRMM 执行矩阵-矩阵运算 C := alpha*op( A ) * B + beta*C 之一，其中 op( A ) 是 op( A ) = A 或 op( A ) = A**T 之一，alpha 和 beta 是标量。A 是一个 m x k 稀疏矩阵，通过三个数组 csrValA、csrRowPtrA 和 csrColIndA 以 CSR 存储格式定义。B 和 C 是稠密矩阵。

此函数已在 CUDA 11.0 中移除。应将其替换为对 cusparseSpMM 的调用

integer(4) function cusparseCcsrmm(handle, transA, m, n, k, nnz, alpha, &
           descrA, csrValA, csrRowPtrA, csrColIndA, B, ldb, beta, C, ldc)
  type(cusparseHandle) :: handle
  integer :: transA, m, n, k, nnz
  complex(4), device :: alpha, beta ! device or host variable
  type(cusparseMatDescr) :: descrA
  complex(4), device :: csrValA(*), B(*), C(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  integer :: ldb, ldc

5.4.4. cusparseZcsrmm

CSRMM 执行矩阵-矩阵运算 C := alpha*op( A ) * B + beta*C 之一，其中 op( A ) 是 op( A ) = A 或 op( A ) = A**T 之一，alpha 和 beta 是标量。A 是一个 m x k 稀疏矩阵，通过三个数组 csrValA、csrRowPtrA 和 csrColIndA 以 CSR 存储格式定义。B 和 C 是稠密矩阵。

此函数已在 CUDA 11.0 中移除。应将其替换为对 cusparseSpMM 的调用

integer(4) function cusparseZcsrmm(handle, transA, m, n, k, nnz, alpha, &
           descrA, csrValA, csrRowPtrA, csrColIndA, B, ldb, beta, C, ldc)
  type(cusparseHandle) :: handle
  integer :: transA, m, n, k, nnz
  complex(8), device :: alpha, beta ! device or host variable
  type(cusparseMatDescr) :: descrA
  complex(8), device :: csrValA(*), B(*), C(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  integer :: ldb, ldc

5.4.5. cusparseScsrmm2

CSRMM2 执行矩阵-矩阵运算 C := alpha*op( A ) * op( B ) + beta*C 之一，其中 op( A ) 是 op( X ) = X 或 op( X ) = X**T 之一，alpha 和 beta 是标量。A 是一个 m x k 稀疏矩阵，通过三个数组 csrValA、csrRowPtrA 和 csrColIndA 以 CSR 存储格式定义。B 和 C 是稠密矩阵。

此函数已在 CUDA 11.0 中移除。应将其替换为对 cusparseSpMM 的调用

integer(4) function cusparseScsrmm2(handle, transA, transB, m, n, k, nnz, alpha, &
           descrA, csrValA, csrRowPtrA, csrColIndA, B, ldb, beta, C, ldc)
  type(cusparseHandle) :: handle
  integer :: transA, transB, m, n, k, nnz
  real(4), device :: alpha, beta ! device or host variable
  type(cusparseMatDescr) :: descrA
  real(4), device :: csrValA(*), B(*), C(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  integer :: ldb, ldc

5.4.6. cusparseDcsrmm2

CSRMM2 执行矩阵-矩阵运算 C := alpha*op( A ) * op( B ) + beta*C 之一，其中 op( A ) 是 op( X ) = X 或 op( X ) = X**T 之一，alpha 和 beta 是标量。A 是一个 m x k 稀疏矩阵，通过三个数组 csrValA、csrRowPtrA 和 csrColIndA 以 CSR 存储格式定义。B 和 C 是稠密矩阵。

此函数已在 CUDA 11.0 中移除。应将其替换为对 cusparseSpMM 的调用

integer(4) function cusparseDcsrmm2(handle, transA, transB, m, n, k, nnz, alpha, &
           descrA, csrValA, csrRowPtrA, csrColIndA, B, ldb, beta, C, ldc)
  type(cusparseHandle) :: handle
  integer :: transA, transB, m, n, k, nnz
  real(8), device :: alpha, beta ! device or host variable
  type(cusparseMatDescr) :: descrA
  real(8), device :: csrValA(*), B(*), C(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  integer :: ldb, ldc

5.4.7. cusparseCcsrmm2

CSRMM2 执行矩阵-矩阵运算 C := alpha*op( A ) * op( B ) + beta*C 之一，其中 op( A ) 是 op( X ) = X 或 op( X ) = X**T 之一，alpha 和 beta 是标量。A 是一个 m x k 稀疏矩阵，通过三个数组 csrValA、csrRowPtrA 和 csrColIndA 以 CSR 存储格式定义。B 和 C 是稠密矩阵。

此函数已在 CUDA 11.0 中移除。应将其替换为对 cusparseSpMM 的调用

integer(4) function cusparseCcsrmm2(handle, transA, transB, m, n, k, nnz, alpha, &
           descrA, csrValA, csrRowPtrA, csrColIndA, B, ldb, beta, C, ldc)
  type(cusparseHandle) :: handle
  integer :: transA, transB, m, n, k, nnz
  complex(4), device :: alpha, beta ! device or host variable
  type(cusparseMatDescr) :: descrA
  complex(4), device :: csrValA(*), B(*), C(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  integer :: ldb, ldc

5.4.8. cusparseZcsrmm2

CSRMM2 执行矩阵-矩阵运算 C := alpha*op( A ) * op( B ) + beta*C 之一，其中 op( A ) 是 op( X ) = X 或 op( X ) = X**T 之一，alpha 和 beta 是标量。A 是一个 m x k 稀疏矩阵，通过三个数组 csrValA、csrRowPtrA 和 csrColIndA 以 CSR 存储格式定义。B 和 C 是稠密矩阵。

此函数已在 CUDA 11.0 中移除。应将其替换为对 cusparseSpMM 的调用

integer(4) function cusparseZcsrmm2(handle, transA, transB, m, n, k, nnz, alpha, &
           descrA, csrValA, csrRowPtrA, csrColIndA, B, ldb, beta, C, ldc)
  type(cusparseHandle) :: handle
  integer :: transA, transB, m, n, k, nnz
  complex(8), device :: alpha, beta ! device or host variable
  type(cusparseMatDescr) :: descrA
  complex(8), device :: csrValA(*), B(*), C(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  integer :: ldb, ldc

5.4.9. cusparseScsrsm_analysis

此函数执行 csrsm 的分析阶段。

integer(4) function cusparseScsrsm_analysis(handle, transA, m, nnz, descrA, csrValA, csrRowPtrA, csrColIndA, info)
  type(cusparseHandle) :: handle
  integer(4) :: transA, m, nnz
  type(cusparseMatDescr) :: descrA
  real(4), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseSolveAnalysisInfo) :: info

5.4.10. cusparseDcsrsm_analysis

此函数执行 csrsm 的分析阶段。

integer(4) function cusparseDcsrsm_analysis(handle, transA, m, nnz, descrA, csrValA, csrRowPtrA, csrColIndA, info)
  type(cusparseHandle) :: handle
  integer(4) :: transA, m, nnz
  type(cusparseMatDescr) :: descrA
  real(8), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseSolveAnalysisInfo) :: info

5.4.11. cusparseCcsrsm_analysis

此函数执行 csrsm 的分析阶段。

integer(4) function cusparseCcsrsm_analysis(handle, transA, m, nnz, descrA, csrValA, csrRowPtrA, csrColIndA, info)
  type(cusparseHandle) :: handle
  integer(4) :: transA, m, nnz
  type(cusparseMatDescr) :: descrA
  complex(4), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseSolveAnalysisInfo) :: info

5.4.12. cusparseZcsrsm_analysis

此函数执行 csrsm 的分析阶段。

integer(4) function cusparseZcsrsm_analysis(handle, transA, m, nnz, descrA, csrValA, csrRowPtrA, csrColIndA, info)
  type(cusparseHandle) :: handle
  integer(4) :: transA, m, nnz
  type(cusparseMatDescr) :: descrA
  complex(8), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseSolveAnalysisInfo) :: info

5.4.13. cusparseScsrsm_solve

此函数执行 csrsm 的求解阶段。

integer(4) function cusparseScsrsm_solve(handle, transA, m, n, alpha, &
           descrA, csrValA, csrRowPtrA, csrColIndA, info, X, ldx, Y, ldy)
  type(cusparseHandle) :: handle
  integer :: transA, m, n
  real(4), device :: alpha ! device or host variable
  type(cusparseMatDescr) :: descrA
  real(4), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseSolveAnalysisInfo) :: info
  real(4), device :: X(*), Y(*)
  integer :: ldx, ldy

5.4.14. cusparseDcsrsm_solve

此函数执行 csrsm 的求解阶段。

integer(4) function cusparseDcsrsm_solve(handle, transA, m, n, alpha, &
           descrA, csrValA, csrRowPtrA, csrColIndA, info, X, ldx, Y, ldy)
  type(cusparseHandle) :: handle
  integer :: transA, m, n
  real(8), device :: alpha ! device or host variable
  type(cusparseMatDescr) :: descrA
  real(8), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseSolveAnalysisInfo) :: info
  real(8), device :: X(*), Y(*)
  integer :: ldx, ldy

5.4.15. cusparseCcsrsm_solve

此函数执行 csrsm 的求解阶段。

integer(4) function cusparseCcsrsm_solve(handle, transA, m, n, alpha, &
           descrA, csrValA, csrRowPtrA, csrColIndA, info, X, ldx, Y, ldy)
  type(cusparseHandle) :: handle
  integer :: transA, m, n
  complex(4), device :: alpha ! device or host variable
  type(cusparseMatDescr) :: descrA
  complex(4), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseSolveAnalysisInfo) :: info
  complex(4), device :: X(*), Y(*)
  integer :: ldx, ldy

5.4.16. cusparseZcsrsm_solve

此函数执行 csrsm 的求解阶段。

integer(4) function cusparseZcsrsm_solve(handle, transA, m, n, alpha, &
           descrA, csrValA, csrRowPtrA, csrColIndA, info, X, ldx, Y, ldy)
  type(cusparseHandle) :: handle
  integer :: transA, m, n
  complex(8), device :: alpha ! device or host variable
  type(cusparseMatDescr) :: descrA
  complex(8), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseSolveAnalysisInfo) :: info
  complex(8), device :: X(*), Y(*)
  integer :: ldx, ldy

5.4.17. cusparseScsrsm2_bufferSizeExt

此函数计算 cusparseScsrsm2 例程所需的工作缓冲区大小。

integer(4) function cusparseScsrsm2_bufferSizeExt(handle, algo, transA, transB, m, nrhs, nnz, alpha, &
           descrA, csrValA, csrRowPtrA, csrColIndA, B, ldb, info, policy, pBufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: algo, transA, transB, m, nrhs, nnz, ldb, policy
  real(4) :: alpha ! host or device variable
  type(cusparseMatDescr) :: descrA
  real(4), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  real(4), device :: B(ldb,*)
  type(cusparseCsrsm2Info) :: info
  integer(8) :: pBufferSize

5.4.18. cusparseDcsrsm2_bufferSizeExt

此函数计算 cusparseDcsrsm2 例程所需的工作缓冲区大小。

integer(4) function cusparseDcsrsm2_bufferSizeExt(handle, algo, transA, transB, m, nrhs, nnz, alpha, &
           descrA, csrValA, csrRowPtrA, csrColIndA, B, ldb, info, policy, pBufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: algo, transA, transB, m, nrhs, nnz, ldb, policy
  real(8) :: alpha ! host or device variable
  type(cusparseMatDescr) :: descrA
  real(8), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  real(8), device :: B(ldb,*)
  type(cusparseCsrsm2Info) :: info
  integer(8) :: pBufferSize

5.4.19. cusparseCcsrsm2_bufferSizeExt

此函数计算 cusparseCcsrsm2 例程所需的工作缓冲区大小。

integer(4) function cusparseCcsrsm2_bufferSizeExt(handle, algo, transA, transB, m, nrhs, nnz, alpha, &
           descrA, csrValA, csrRowPtrA, csrColIndA, B, ldb, info, policy, pBufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: algo, transA, transB, m, nrhs, nnz, ldb, policy
  complex(4) :: alpha ! host or device variable
  type(cusparseMatDescr) :: descrA
  complex(4), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  complex(4), device :: B(ldb,*)
  type(cusparseCsrsm2Info) :: info
  integer(8) :: pBufferSize

5.4.20. cusparseZcsrsm2_bufferSizeExt

此函数计算 cusparseZcsrsm2 例程所需的工作缓冲区大小。

integer(4) function cusparseZcsrsm2_bufferSizeExt(handle, algo, transA, transB, m, nrhs, nnz, alpha, &
           descrA, csrValA, csrRowPtrA, csrColIndA, B, ldb, info, policy, pBufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: algo, transA, transB, m, nrhs, nnz, ldb, policy
  complex(8) :: alpha ! host or device variable
  type(cusparseMatDescr) :: descrA
  complex(8), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  complex(8), device :: B(ldb,*)
  type(cusparseCsrsm2Info) :: info
  integer(8) :: pBufferSize

5.4.21. cusparseScsrsm2_analysis

此函数执行 csrsm 的分析阶段。

integer(4) function cusparseScsrsm2_analysis(handle, algo, transA, transB, m, nrhs, nnz, alpha, &
           descrA, csrValA, csrRowPtrA, csrColIndA, B, ldb, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: algo, transA, transB, m, nrhs, nnz, ldb, policy
  real(4) :: alpha ! host or device variable
  type(cusparseMatDescr) :: descrA
  real(4), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  real(4), device :: B(ldb,*)
  type(cusparseCsrsm2Info) :: info
  integer(1), device :: pBuffer ! Any data type

5.4.22. cusparseDcsrsm2_analysis

此函数执行 csrsm 的分析阶段。

integer(4) function cusparseDcsrsm2_analysis(handle, algo, transA, transB, m, nrhs, nnz, alpha, descrA, &
           csrValA, csrRowPtrA, csrColIndA, B, ldb, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: algo, transA, transB, m, nrhs, nnz, ldb, policy
  real(8) :: alpha ! host or device variable
  type(cusparseMatDescr) :: descrA
  real(8), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  real(8), device :: B(ldb,*)
  type(cusparseCsrsm2Info) :: info
  integer(1), device :: pBuffer ! Any data type

5.4.23. cusparseCcsrsm2_analysis

此函数执行 csrsm 的分析阶段。

integer(4) function cusparseCcsrsm2_analysis(handle, algo, transA, transB, m, nrhs, nnz, alpha, &
           descrA, csrValA, csrRowPtrA, csrColIndA, B, ldb, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: algo, transA, transB, m, nrhs, nnz, ldb, policy
  complex(4) :: alpha ! host or device variable
  type(cusparseMatDescr) :: descrA
  complex(4), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  complex(4), device :: B(ldb,*)
  type(cusparseCsrsm2Info) :: info
  integer(1), device :: pBuffer ! Any data type

5.4.24. cusparseZcsrsm2_analysis

此函数执行 csrsm 的分析阶段。

integer(4) function cusparseZcsrsm2_analysis(handle, algo, transA, transB, m, nrhs, nnz, alpha, &
           descrA, csrValA, csrRowPtrA, csrColIndA, B, ldb, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: algo, transA, transB, m, nrhs, nnz, ldb, policy
  complex(8) :: alpha ! host or device variable
  type(cusparseMatDescr) :: descrA
  complex(8), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  complex(8), device :: B(ldb,*)
  type(cusparseCsrsm2Info) :: info
  integer(1), device :: pBuffer ! Any data type

5.4.25. cusparseScsrsm2_solve

此函数执行 csrsm2 的求解阶段，求解稀疏三角线性系统 op(A) * op(X) = alpha * op(B)。A 是 CSR 存储格式的 m x m 稀疏矩阵；B 和 X 是右手侧矩阵和解矩阵，B 被 X 覆盖。

integer(4) function cusparseScsrsm2_solve(handle, algo, transA, transB, m, nrhs, nnz, alpha, &
           descrA, csrValA, csrRowPtrA, csrColIndA, B, ldb, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: algo, transA, transB, m, nrhs, nnz, ldb, policy
  real(4) :: alpha ! host or device variable
  type(cusparseMatDescr) :: descrA
  real(4), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  real(4), device :: B(ldb,*)
  type(cusparseCsrsm2Info) :: info
  integer(1), device :: pBuffer ! Any data type

5.4.26. cusparseDcsrsm2_solve

此函数执行 csrsm2 的求解阶段，求解稀疏三角线性系统 op(A) * op(X) = alpha * op(B)。A 是 CSR 存储格式的 m x m 稀疏矩阵；B 和 X 是右手侧矩阵和解矩阵，B 被 X 覆盖。

integer(4) function cusparseDcsrsm2_solve(handle, algo, transA, transB, m, nrhs, nnz, alpha, &
           descrA, csrValA, csrRowPtrA, csrColIndA, B, ldb, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: algo, transA, transB, m, nrhs, nnz, ldb, policy
  real(8) :: alpha ! host or device variable
  type(cusparseMatDescr) :: descrA
  real(8), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  real(8), device :: B(ldb,*)
  type(cusparseCsrsm2Info) :: info
  integer(1), device :: pBuffer ! Any data type

5.4.27. cusparseCcsrsm2_solve

此函数执行 csrsm2 的求解阶段，求解稀疏三角线性系统 op(A) * op(X) = alpha * op(B)。A 是 CSR 存储格式的 m x m 稀疏矩阵；B 和 X 是右手侧矩阵和解矩阵，B 被 X 覆盖。

integer(4) function cusparseCcsrsm2_solve(handle, algo, transA, transB, m, nrhs, nnz, alpha, descrA, csrValA, csrRowPtrA, csrColIndA, B, ldb, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: algo, transA, transB, m, nrhs, nnz, ldb, policy
  complex(4) :: alpha ! host or device variable
  type(cusparseMatDescr) :: descrA
  complex(4), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  complex(4), device :: B(ldb,*)
  type(cusparseCsrsm2Info) :: info
  integer(1), device :: pBuffer ! Any data type

5.4.28. cusparseZcsrsm2_solve

此函数执行 csrsm2 的求解阶段，求解稀疏三角线性系统 op(A) * op(X) = alpha * op(B)。A 是 CSR 存储格式的 m x m 稀疏矩阵；B 和 X 是右手侧矩阵和解矩阵，B 被 X 覆盖。

integer(4) function cusparseZcsrsm2_solve(handle, algo, transA, transB, m, nrhs, nnz, alpha, &
           descrA, csrValA, csrRowPtrA, csrColIndA, B, ldb, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: algo, transA, transB, m, nrhs, nnz, ldb, policy
  complex(8) :: alpha ! host or device variable
  type(cusparseMatDescr) :: descrA
  complex(8), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  complex(8), device :: B(ldb,*)
  type(cusparseCsrsm2Info) :: info
  integer(1), device :: pBuffer ! Any data type

5.4.29. cusparseXcsrsm2_zeroPivot

当 A(j,j) 是结构零或数值零时，此函数返回等于 CUSPARSE_STATUS_ZERO_PIVOT 的错误代码，并将 position 设置为 j。否则，position 将设置为 -1。

integer(4) function cusparseXcsrsm2_zeroPivot(handle, info, position)
  type(cusparseHandle) :: handle
  type(cusparseCsrsm2Info) :: info
  integer(4), device :: position ! device or host variable

5.4.30. cusparseSbsrmm

BSRMM 执行矩阵-矩阵运算 C := alpha*op( A ) * op( B ) + beta*C 之一，其中 op( X ) 是 op( X ) = X 或 op( X ) = X**T 之一，alpha 和 beta 是标量。A 是一个 mb x kb 稀疏矩阵，通过三个数组 bsrValA、bsrRowPtrA 和 bsrColIndA 以 BSR 存储格式定义。B 和 C 是稠密矩阵。

integer(4) function cusparseSbsrmm(handle, dirA, transA, transB, mb, n, kb, nnzb, alpha, &
           descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, B, ldb, beta, C, ldc)
  type(cusparseHandle) :: handle
  integer :: dirA, transA, transB, mb, n, kb, nnzb, blockDim
  real(4), device :: alpha, beta ! device or host variable
  type(cusparseMatDescr) :: descrA
  real(4), device :: bsrValA(*), B(*), C(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer :: ldb, ldc

5.4.31. cusparseDbsrmm

BSRMM 执行矩阵-矩阵运算 C := alpha*op( A ) * op( B ) + beta*C 之一，其中 op( X ) 是 op( X ) = X 或 op( X ) = X**T 之一，alpha 和 beta 是标量。A 是一个 mb x kb 稀疏矩阵，通过三个数组 bsrValA、bsrRowPtrA 和 bsrColIndA 以 BSR 存储格式定义。B 和 C 是稠密矩阵。

integer(4) function cusparseDbsrmm(handle, dirA, transA, transB, mb, n, kb, nnzb, alpha, &
           descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, B, ldb, beta, C, ldc)
  type(cusparseHandle) :: handle
  integer :: dirA, transA, transB, mb, n, kb, nnzb, blockDim
  real(8), device :: alpha, beta ! device or host variable
  type(cusparseMatDescr) :: descrA
  real(8), device :: bsrValA(*), B(*), C(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer :: ldb, ldc

5.4.32. cusparseCbsrmm

BSRMM 执行矩阵-矩阵运算 C := alpha*op( A ) * op( B ) + beta*C 之一，其中 op( X ) 是 op( X ) = X 或 op( X ) = X**T 之一，alpha 和 beta 是标量。A 是一个 mb x kb 稀疏矩阵，通过三个数组 bsrValA、bsrRowPtrA 和 bsrColIndA 以 BSR 存储格式定义。B 和 C 是稠密矩阵。

integer(4) function cusparseCbsrmm(handle, dirA, transA, transB, mb, n, kb, nnzb, alpha, &
           descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, B, ldb, beta, C, ldc)
  type(cusparseHandle) :: handle
  integer :: dirA, transA, transB, mb, n, kb, nnzb, blockDim
  complex(4), device :: alpha, beta ! device or host variable
  type(cusparseMatDescr) :: descrA
  complex(4), device :: bsrValA(*), B(*), C(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer :: ldb, ldc

5.4.33. cusparseZbsrmm

BSRMM 执行矩阵-矩阵运算 C := alpha*op( A ) * op( B ) + beta*C 之一，其中 op( X ) 是 op( X ) = X 或 op( X ) = X**T 之一，alpha 和 beta 是标量。A 是一个 mb x kb 稀疏矩阵，通过三个数组 bsrValA、bsrRowPtrA 和 bsrColIndA 以 BSR 存储格式定义。B 和 C 是稠密矩阵。

integer(4) function cusparseZbsrmm(handle, dirA, transA, transB, mb, n, kb, nnzb, alpha, &
           descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, B, ldb, beta, C, ldc)
  type(cusparseHandle) :: handle
  integer :: dirA, transA, transB, mb, n, kb, nnzb, blockDim
  complex(8), device :: alpha, beta ! device or host variable
  type(cusparseMatDescr) :: descrA
  complex(8), device :: bsrValA(*), B(*), C(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer :: ldb, ldc

5.4.34. cusparseSbsrsm2_bufferSize

此函数返回 bsrsm2 中使用的缓冲区大小。

integer(4) function cusparseSbsrsm2_bufferSize(handle, dirA, transA, transX, mb, n, nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, pBufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: dirA, transA, transX, mb, n, nnzb, blockDim
  type(cusparseMatDescr) :: descrA
  real(4), device :: bsrValA(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  type(cusparseBsrsm2Info) :: info
  integer(4) :: pBufferSize ! integer(8) also accepted

5.4.35. cusparseDbsrsm2_bufferSize

此函数返回 bsrsm2 中使用的缓冲区大小。

integer(4) function cusparseDbsrsm2_bufferSize(handle, dirA, transA, transX, mb, n, nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, pBufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: dirA, transA, transX, mb, n, nnzb, blockDim
  type(cusparseMatDescr) :: descrA
  real(8), device :: bsrValA(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  type(cusparseBsrsm2Info) :: info
  integer(4) :: pBufferSize ! integer(8) also accepted

5.4.36. cusparseCbsrsm2_bufferSize

此函数返回 bsrsm2 中使用的缓冲区大小。

integer(4) function cusparseCbsrsm2_bufferSize(handle, dirA, transA, transX, mb, n, nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, pBufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: dirA, transA, transX, mb, n, nnzb, blockDim
  type(cusparseMatDescr) :: descrA
  complex(4), device :: bsrValA(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  type(cusparseBsrsm2Info) :: info
  integer(4) :: pBufferSize ! integer(8) also accepted

5.4.37. cusparseZbsrsm2_bufferSize

此函数返回 bsrsm2 中使用的缓冲区大小。

integer(4) function cusparseZbsrsm2_bufferSize(handle, dirA, transA, transX, mb, n, nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, pBufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: dirA, transA, transX, mb, n, nnzb, blockDim
  type(cusparseMatDescr) :: descrA
  complex(8), device :: bsrValA(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  type(cusparseBsrsm2Info) :: info
  integer(4) :: pBufferSize ! integer(8) also accepted

5.4.38. cusparseSbsrsm2_analysis

此函数执行 bsrsm2 的分析阶段。

integer(4) function cusparseSbsrsm2_analysis(handle, dirA, transA, transX, mb, n, nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: dirA, transA, transX, mb, n, nnzb, blockDim
  type(cusparseMatDescr) :: descrA
  real(4), device :: bsrValA(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  type(cusparseBsrsm2Info) :: info
  integer(4) :: policy
  character(c_char), device :: pBuffer(*)

5.4.39. cusparseDbsrsm2_analysis

此函数执行 bsrsm2 的分析阶段。

integer(4) function cusparseDbsrsm2_analysis(handle, dirA, transA, transX, mb, n, nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: dirA, transA, transX, mb, n, nnzb, blockDim
  type(cusparseMatDescr) :: descrA
  real(8), device :: bsrValA(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  type(cusparseBsrsm2Info) :: info
  integer(4) :: policy
  character(c_char), device :: pBuffer(*)

5.4.40. cusparseCbsrsm2_analysis

此函数执行 bsrsm2 的分析阶段。

integer(4) function cusparseCbsrsm2_analysis(handle, dirA, transA, transX, mb, n, nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: dirA, transA, transX, mb, n, nnzb, blockDim
  type(cusparseMatDescr) :: descrA
  complex(4), device :: bsrValA(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  type(cusparseBsrsm2Info) :: info
  integer(4) :: policy
  character(c_char), device :: pBuffer(*)

5.4.41. cusparseZbsrsm2_analysis

此函数执行 bsrsm2 的分析阶段。

integer(4) function cusparseZbsrsm2_analysis(handle, dirA, transA, transX, mb, n, nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: dirA, transA, transX, mb, n, nnzb, blockDim
  type(cusparseMatDescr) :: descrA
  complex(8), device :: bsrValA(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  type(cusparseBsrsm2Info) :: info
  integer(4) :: policy
  character(c_char), device :: pBuffer(*)

5.4.42. cusparseSbsrsm2_solve

此函数执行 bsrsm2 的求解阶段。

integer(4) function cusparseSbsrsm2_solve(handle, dirA, transA, transX, mb, n, nnzb, alpha, &
           descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, x, ldx, y, ldy, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer :: dirA, transA, transX, mb, n, nnzb
  real(4), device :: alpha ! device or host variable
  type(cusparseMatDescr) :: descrA
  real(4), device :: bsrValA(*), x(*), y(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer :: blockDim, policy, ldx, ldy
  type(cusparseBsrsm2Info) :: info
  character, device :: pBuffer(*)

5.4.43. cusparseDbsrsm2_solve

此函数执行 bsrsm2 的求解阶段。

integer(4) function cusparseDbsrsm2_solve(handle, dirA, transA, transX, mb, n, nnzb, alpha, &
           descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, x, ldx, y, ldy, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer :: dirA, transA, transX, mb, n, nnzb
  real(8), device :: alpha ! device or host variable
  type(cusparseMatDescr) :: descrA
  real(8), device :: bsrValA(*), x(*), y(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer :: blockDim, policy, ldx, ldy
  type(cusparseBsrsm2Info) :: info
  character, device :: pBuffer(*)

5.4.44. cusparseCbsrsm2_solve

此函数执行 bsrsm2 的求解阶段。

integer(4) function cusparseCbsrsm2_solve(handle, dirA, transA, transX, mb, n, nnzb, alpha, &
           descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, x, ldx, y, ldy, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer :: dirA, transA, transX, mb, n, nnzb
  complex(4), device :: alpha ! device or host variable
  type(cusparseMatDescr) :: descrA
  complex(4), device :: bsrValA(*), x(*), y(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer :: blockDim, policy, ldx, ldy
  type(cusparseBsrsm2Info) :: info
  character, device :: pBuffer(*)

5.4.45. cusparseZbsrsm2_solve

此函数执行 bsrsm2 的求解阶段。

integer(4) function cusparseZbsrsm2_solve(handle, dirA, transA, transX, mb, n, nnzb, alpha, &
           descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, x, ldx, y, ldy, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer :: dirA, transA, transX, mb, n, nnzb
  complex(8), device :: alpha ! device or host variable
  type(cusparseMatDescr) :: descrA
  complex(8), device :: bsrValA(*), x(*), y(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer :: blockDim, policy, ldx, ldy
  type(cusparseBsrsm2Info) :: info
  character, device :: pBuffer(*)

5.4.46. cusparseXbsrsm2_zeroPivot

当 A(j,j) 是结构零或数值零时，此函数返回等于 CUSPARSE_STATUS_ZERO_PIVOT 的错误代码，并将 position 设置为 j。否则，position 将设置为 -1。

integer(4) function cusparseXbsrsm2_zeroPivot(handle, info, position)
  type(cusparseHandle) :: handle
  type(cusparseBsrsm2Info) :: info
  integer(4), device :: position ! device or host variable

5.4.47. cusparseSgemmi

GEMMI 执行矩阵-矩阵运算 C := alpha*A*B + beta*C，其中 alpha 和 beta 是标量，A 是 m x k 稠密矩阵，B 是 k x n 稀疏矩阵，C 是 m x n 稠密矩阵。Fortran 程序员应注意，此函数仅对 B 使用从零开始的索引。

此函数已弃用，将在未来的版本中移除。建议改用 cusparseSpMM。

integer(4) function cusparseSgemmi(handle, m, n, k, nnz, alpha, &
           A, lda, cscValB, cscColPtrB, cscRowIndB, beta, C, ldc)
  type(cusparseHandle) :: handle
  integer :: m, n, k, nnz, lda, ldc
  real(4), device :: alpha, beta ! device or host variable
  real(4), device :: A(lda,*)
  real(4), device :: cscValB(*)
  real(4), device :: C(ldc,*)
  integer(4), device :: cscColPtrB(*), cscRowIndB(*)

5.4.48. cusparseDgemmi

GEMMI 执行矩阵-矩阵运算 C := alpha*A*B + beta*C，其中 alpha 和 beta 是标量，A 是 m x k 稠密矩阵，B 是 k x n 稀疏矩阵，C 是 m x n 稠密矩阵。Fortran 程序员应注意，此函数仅对 B 使用从零开始的索引。

此函数已弃用，将在未来的版本中移除。建议改用 cusparseSpMM。

integer(4) function cusparseDgemmi(handle, m, n, k, nnz, alpha, &
           A, lda, cscValB, cscColPtrB, cscRowIndB, beta, C, ldc)
  type(cusparseHandle) :: handle
  integer :: m, n, k, nnz, lda, ldc
  real(8), device :: alpha, beta ! device or host variable
  real(8), device :: A(lda,*)
  real(8), device :: cscValB(*)
  real(8), device :: C(ldc,*)
  integer(4), device :: cscColPtrB(*), cscRowIndB(*)

5.4.49. cusparseCgemmi

GEMMI 执行矩阵-矩阵运算 C := alpha*A*B + beta*C，其中 alpha 和 beta 是标量，A 是 m x k 稠密矩阵，B 是 k x n 稀疏矩阵，C 是 m x n 稠密矩阵。Fortran 程序员应注意，此函数仅对 B 使用从零开始的索引。

此函数已弃用，将在未来的版本中移除。建议改用 cusparseSpMM。

integer(4) function cusparseCgemmi(handle, m, n, k, nnz, alpha, &
           A, lda, cscValB, cscColPtrB, cscRowIndB, beta, C, ldc)
  type(cusparseHandle) :: handle
  integer :: m, n, k, nnz, lda, ldc
  complex(4), device :: alpha, beta ! device or host variable
  complex(4), device :: A(lda,*)
  complex(4), device :: cscValB(*)
  complex(4), device :: C(ldc,*)
  integer(4), device :: cscColPtrB(*), cscRowIndB(*)

5.4.50. cusparseZgemmi

GEMMI 执行矩阵-矩阵运算 C := alpha*A*B + beta*C，其中 alpha 和 beta 是标量，A 是 m x k 稠密矩阵，B 是 k x n 稀疏矩阵，C 是 m x n 稠密矩阵。Fortran 程序员应注意，此函数仅对 B 使用从零开始的索引。

此函数已弃用，将在未来的版本中移除。建议改用 cusparseSpMM。

integer(4) function cusparseZgemmi(handle, m, n, k, nnz, alpha, &
           A, lda, cscValB, cscColPtrB, cscRowIndB, beta, C, ldc)
  type(cusparseHandle) :: handle
  integer :: m, n, k, nnz, lda, ldc
  complex(8), device :: alpha, beta ! device or host variable
  complex(8), device :: A(lda,*)
  complex(8), device :: cscValB(*)
  complex(8), device :: C(ldc,*)
  integer(4), device :: cscColPtrB(*), cscRowIndB(*)

5.5. CUSPARSE 扩展函数

本节包含用于操作稀疏矩阵的扩展函数的接口。

5.5.1. cusparseXcsrgeamNnz

cusparseXcsrgeamNnz 计算 CSRGEAM 将生成的非零元素的数量。

此函数已在 CUDA 11.0 中移除。应将其替换为 cusparseXcsrgeam2Nnz

integer(4) function cusparseXcsrgeamNnz(handle, m, n, descrA, nnzA, csrRowPtrA, csrColIndA, descrB, nnzB, csrRowPtrB, csrColIndB, descrC, csrRowPtrC, nnzTotalDevHostPtr)
  type(cusparseHandle) :: handle
  integer :: m, n, nnzA, nnzB
  type(cusparseMatDescr) :: descrA, descrB, descrC
  integer(4), device :: csrRowPtrA(*), csrColIndA(*), csrRowPtrB(*), csrColIndB(*), csrRowPtrC(*)
  integer(4), device :: nnzTotalDevHostPtr ! device or host variable

5.5.2. cusparseScsrgeam

CSRGEAM 执行矩阵-矩阵运算 C := alpha * A + beta * B，alpha 和 beta 是标量。A、B 和 C 是 m x n 稀疏矩阵，通过三个数组 csrVal{A|B|C}、csrRowPtr{A|B|C} 和 csrColInd{A|B|C} 以 CSR 存储格式定义。应使用 cusparseXcsrgeamNnz 来确定 csrRowPtrC 和结果中非零元素的数量。

此函数已在 CUDA 11.0 中移除。应将其替换为 cusparseScsrgeam2 例程

integer(4) function cusparseScsrgeam(handle, m, n, &
           alpha, descrA, nnzA, csrValA, csrRowPtrA, csrColIndA, &
           beta, descrB, nnzB, csrValB, csrRowPtrB, csrColIndB, descrC, csrValC, csrRowPtrC, csrColIndC)
  type(cusparseHandle) :: handle
  integer :: m, n, nnzA, nnzB
  real(4), device :: alpha, beta ! device or host variable
  type(cusparseMatDescr):: descrA, descrB, descrC
  real(4), device :: csrValA(*), csrValB(*), csrValC(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*), csrRowPtrB(*), csrColIndB(*), csrRowPtrC(*), csrColIndC(*)

5.5.3. cusparseDcsrgeam

CSRGEAM 执行矩阵-矩阵运算 C := alpha * A + beta * B，alpha 和 beta 是标量。A、B 和 C 是 m x n 稀疏矩阵，通过三个数组 csrVal{A|B|C}、csrRowPtr{A|B|C} 和 csrColInd{A|B|C} 以 CSR 存储格式定义。应使用 cusparseXcsrgeamNnz 来确定 csrRowPtrC 和结果中非零元素的数量。

此函数已在 CUDA 11.0 中移除。应将其替换为 cusparseDcsrgeam2 例程

integer(4) function cusparseDcsrgeam(handle, m, n, &
           alpha, descrA, nnzA, csrValA, csrRowPtrA, csrColIndA, &
           beta, descrB, nnzB, csrValB, csrRowPtrB, csrColIndB, descrC, csrValC, csrRowPtrC, csrColIndC)
  type(cusparseHandle) :: handle
  integer :: m, n, nnzA, nnzB
  real(8), device :: alpha, beta ! device or host variable
  type(cusparseMatDescr):: descrA, descrB, descrC
  real(8), device :: csrValA(*), csrValB(*), csrValC(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*), csrRowPtrB(*), csrColIndB(*), csrRowPtrC(*), csrColIndC(*)

5.5.4. cusparseCcsrgeam

CSRGEAM 执行矩阵-矩阵运算 C := alpha * A + beta * B，alpha 和 beta 是标量。A、B 和 C 是 m x n 稀疏矩阵，通过三个数组 csrVal{A|B|C}、csrRowPtr{A|B|C} 和 csrColInd{A|B|C} 以 CSR 存储格式定义。应使用 cusparseXcsrgeamNnz 来确定 csrRowPtrC 和结果中非零元素的数量。

此函数已在 CUDA 11.0 中移除。应将其替换为 cusparseCcsrgeam2 例程

integer(4) function cusparseCcsrgeam(handle, m, n, &
        alpha, descrA, nnzA, csrValA, csrRowPtrA, csrColIndA, &
        beta, descrB, nnzB, csrValB, csrRowPtrB, csrColIndB, descrC, csrValC, csrRowPtrC, csrColIndC)
  type(cusparseHandle) :: handle
  integer :: m, n, nnzA, nnzB
  complex(4), device :: alpha, beta ! device or host variable
  type(cusparseMatDescr):: descrA, descrB, descrC
  complex(4), device :: csrValA(*), csrValB(*), csrValC(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*), csrRowPtrB(*), csrColIndB(*), csrRowPtrC(*), csrColIndC(*)

5.5.5. cusparseZcsrgeam

CSRGEAM 执行矩阵-矩阵运算 C := alpha * A + beta * B，alpha 和 beta 是标量。A、B 和 C 是 m x n 稀疏矩阵，通过三个数组 csrVal{A|B|C}、csrRowPtr{A|B|C} 和 csrColInd{A|B|C} 以 CSR 存储格式定义。应使用 cusparseXcsrgeamNnz 来确定 csrRowPtrC 和结果中非零元素的数量。

此函数已在 CUDA 11.0 中移除。应将其替换为 cusparseZcsrgeam2 例程

integer(4) function cusparseZcsrgeam(handle, m, n, alpha, descrA, nnzA, csrValA, csrRowPtrA, csrColIndA, &
           beta, descrB, nnzB, csrValB, csrRowPtrB, csrColIndB, descrC, csrValC, csrRowPtrC, csrColIndC)
  type(cusparseHandle) :: handle
  integer :: m, n, nnzA, nnzB
  complex(8), device :: alpha, beta ! device or host variable
  type(cusparseMatDescr):: descrA, descrB, descrC
  complex(8), device :: csrValA(*), csrValB(*), csrValC(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*), csrRowPtrB(*), csrColIndB(*), csrRowPtrC(*), csrColIndC(*)

5.5.6. cusparseScsrgeam2_bufferSizeExt

此函数确定 cusparseScsrgeam2 的工作缓冲区大小。CSRGEAM2 执行矩阵-矩阵运算 C := alpha * A + beta * B，alpha 和 beta 是标量。A、B 和 C 是 m x n 稀疏矩阵，通过三个数组 csrVal{A|B|C}、csrRowPtr{A|B|C} 和 csrColInd{A|B|C} 以 CSR 存储格式定义。应使用 cusparseXcsrgeam2Nnz 来确定 csrRowPtrC 和结果中非零元素的数量。

integer(4) function cusparseScsrgeam2_bufferSizeExt(handle, m, n, alpha, descrA, nnzA, csrValA, csrRowPtrA, csrColIndA, &
           beta, descrB, nnzB, csrValB, csrRowPtrB, csrColIndB, descrC, csrValC, csrRowPtrC, csrColIndC, pBufferSizeInBytes)
  type(cusparseHandle) :: handle
  integer :: m, n, nnzA, nnzB
  real(4), device :: alpha, beta ! device or host variable
  type(cusparseMatDescr):: descrA, descrB, descrC
  real(4), device :: csrValA(*), csrValB(*), csrValC(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*), csrRowPtrB(*), csrColIndB(*), csrRowPtrC(*), csrColIndC(*)
  integer(8) :: pBufferSizeInBytes

5.5.7. cusparseDcsrgeam2_bufferSizeExt

此函数确定 cusparseDcsrgeam2 的工作缓冲区大小。CSRGEAM2 执行矩阵-矩阵运算 C := alpha * A + beta * B，alpha 和 beta 是标量。A、B 和 C 是 m x n 稀疏矩阵，通过三个数组 csrVal{A|B|C}、csrRowPtr{A|B|C} 和 csrColInd{A|B|C} 以 CSR 存储格式定义。应使用 cusparseXcsrgeam2Nnz 来确定 csrRowPtrC 和结果中非零元素的数量。

integer(4) function cusparseDcsrgeam2_bufferSizeExt(handle, m, n, alpha, &
           descrA, nnzA, csrValA, csrRowPtrA, csrColIndA, beta, descrB, nnzB, &
           csrValB, csrRowPtrB, csrColIndB, descrC, csrValC, csrRowPtrC, csrColIndC, pBufferSizeInBytes)
  type(cusparseHandle) :: handle
  integer :: m, n, nnzA, nnzB
  real(8), device :: alpha, beta ! device or host variable
  type(cusparseMatDescr):: descrA, descrB, descrC
  real(8), device :: csrValA(*), csrValB(*), csrValC(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*), csrRowPtrB(*), csrColIndB(*), csrRowPtrC(*), csrColIndC(*)
  integer(8) :: pBufferSizeInBytes

5.5.8. cusparseCcsrgeam2_bufferSizeExt

此函数确定 cusparseCcsrgeam2 的工作缓冲区大小。CSRGEAM2 执行矩阵-矩阵运算 C := alpha * A + beta * B，alpha 和 beta 是标量。A、B 和 C 是 m x n 稀疏矩阵，通过三个数组 csrVal{A|B|C}、csrRowPtr{A|B|C} 和 csrColInd{A|B|C} 以 CSR 存储格式定义。应使用 cusparseXcsrgeam2Nnz 来确定 csrRowPtrC 和结果中非零元素的数量。

integer(4) function cusparseCcsrgeam2_bufferSizeExt(handle, m, n, alpha, &
           descrA, nnzA, csrValA, csrRowPtrA, csrColIndA, beta, descrB, nnzB, &
           csrValB, csrRowPtrB, csrColIndB, descrC, csrValC, csrRowPtrC, csrColIndC, pBufferSizeInBytes)
  type(cusparseHandle) :: handle
  integer :: m, n, nnzA, nnzB
  complex(4), device :: alpha, beta ! device or host variable
  type(cusparseMatDescr):: descrA, descrB, descrC
  complex(4), device :: csrValA(*), csrValB(*), csrValC(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*), csrRowPtrB(*), csrColIndB(*), csrRowPtrC(*), csrColIndC(*)
  integer(8) :: pBufferSizeInBytes

5.5.9. cusparseZcsrgeam2_bufferSizeExt

此函数确定 cusparseZcsrgeam2 的工作缓冲区大小。CSRGEAM2 执行矩阵-矩阵运算 C := alpha * A + beta * B，alpha 和 beta 是标量。A、B 和 C 是 m x n 稀疏矩阵，通过三个数组 csrVal{A|B|C}、csrRowPtr{A|B|C} 和 csrColInd{A|B|C} 以 CSR 存储格式定义。应使用 cusparseXcsrgeam2Nnz 来确定 csrRowPtrC 和结果中非零元素的数量。

integer(4) function cusparseZcsrgeam2_bufferSizeExt(handle, m, n, alpha, descrA, &
           nnzA, csrValA, csrRowPtrA, csrColIndA, beta, descrB, nnzB, csrValB, &
           csrRowPtrB, csrColIndB, descrC, csrValC, csrRowPtrC, csrColIndC, pBufferSizeInBytes)
  type(cusparseHandle) :: handle
  integer :: m, n, nnzA, nnzB
  complex(8), device :: alpha, beta ! device or host variable
  type(cusparseMatDescr):: descrA, descrB, descrC
  complex(8), device :: csrValA(*), csrValB(*), csrValC(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*), csrRowPtrB(*), csrColIndB(*), csrRowPtrC(*), csrColIndC(*)
  integer(8) :: pBufferSizeInBytes

5.5.10. cusparseXcsrgeam2Nnz

cusparseXcsrgeam2Nnz 计算 CSRGEAM2 将生成的非零元素的数量。

integer(4) function cusparseXcsrgeam2Nnz(handle, m, n, descrA, nnzA, csrRowPtrA, csrColIndA, &
           descrB, nnzB, csrRowPtrB, csrColIndB, descrC, csrRowPtrC, nnzTotalDevHostPtr, pBuffer)
  type(cusparseHandle) :: handle
  type(cusparseMatDescr) :: descrA, descrB, descrC
  integer(4) :: m, n, nnzA, nnzB
  integer(4), device :: csrRowPtrA(*), csrColIndA(*), csrRowPtrB(*), csrColIndB(*), csrRowPtrC(*)
  integer(c_int) :: nnzTotalDevHostPtr
  character(c_char), device :: pBuffer(*)

5.5.11. cusparseScsrgeam2

CSRGEAM2 执行矩阵-矩阵运算 C := alpha * A + beta * B，alpha 和 beta 是标量。A、B 和 C 是 m x n 稀疏矩阵，通过三个数组 csrVal{A|B|C}、csrRowPtr{A|B|C} 和 csrColInd{A|B|C} 以 CSR 存储格式定义。应使用 cusparseXcsrgeam2Nnz 来确定 csrRowPtrC 和结果中非零元素的数量。

integer(4) function cusparseCcsrgeam2(handle, m, n, alpha, descrA, nnzA, csrValA, csrRowPtrA, &
           csrColIndA, beta, descrB, nnzB, csrValB, csrRowPtrB, csrColIndB, descrC, csrValC, csrRowPtrC, csrColIndC, pBuffer)
  type(cusparseHandle) :: handle
  integer :: m, n, nnzA, nnzB
  real(4), device :: alpha, beta ! device or host variable
  type(cusparseMatDescr):: descrA, descrB, descrC
  real(4), device :: csrValA(*), csrValB(*), csrValC(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*), csrRowPtrB(*), csrColIndB(*), csrRowPtrC(*), csrColIndC(*)
  integer(1), device :: pBuffer ! can be of any type

5.5.12. cusparseDcsrgeam2

CSRGEAM2 执行矩阵-矩阵运算 C := alpha * A + beta * B，alpha 和 beta 是标量。A、B 和 C 是 m x n 稀疏矩阵，通过三个数组 csrVal{A|B|C}、csrRowPtr{A|B|C} 和 csrColInd{A|B|C} 以 CSR 存储格式定义。应使用 cusparseXcsrgeam2Nnz 来确定 csrRowPtrC 和结果中非零元素的数量。

integer(4) function cusparseCcsrgeam2(handle, m, n, alpha, descrA, nnzA, csrValA, csrRowPtrA, &
           csrColIndA, beta, descrB, nnzB, csrValB, csrRowPtrB, csrColIndB, descrC, csrValC, csrRowPtrC, csrColIndC, pBuffer)
  type(cusparseHandle) :: handle
  integer :: m, n, nnzA, nnzB
  real(8), device :: alpha, beta ! device or host variable
  type(cusparseMatDescr):: descrA, descrB, descrC
  real(8), device :: csrValA(*), csrValB(*), csrValC(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*), csrRowPtrB(*), csrColIndB(*), csrRowPtrC(*), csrColIndC(*)
  integer(1), device :: pBuffer ! can be of any type

5.5.13. cusparseCcsrgeam2

CSRGEAM2 执行矩阵-矩阵运算 C := alpha * A + beta * B，alpha 和 beta 是标量。A、B 和 C 是 m x n 稀疏矩阵，通过三个数组 csrVal{A|B|C}、csrRowPtr{A|B|C} 和 csrColInd{A|B|C} 以 CSR 存储格式定义。应使用 cusparseXcsrgeam2Nnz 来确定 csrRowPtrC 和结果中非零元素的数量。

integer(4) function cusparseCcsrgeam2(handle, m, n, alpha, descrA, nnzA, csrValA, csrRowPtrA, csrColIndA, &
           beta, descrB, nnzB, csrValB, csrRowPtrB, csrColIndB, descrC, csrValC, csrRowPtrC, csrColIndC, pBuffer)
  type(cusparseHandle) :: handle
  integer :: m, n, nnzA, nnzB
  complex(4), device :: alpha, beta ! device or host variable
  type(cusparseMatDescr):: descrA, descrB, descrC
  complex(4), device :: csrValA(*), csrValB(*), csrValC(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*), csrRowPtrB(*), csrColIndB(*), csrRowPtrC(*), csrColIndC(*)
  integer(1), device :: pBuffer ! can be of any type

5.5.14. cusparseZcsrgeam2

CSRGEAM2 执行矩阵-矩阵运算 C := alpha * A + beta * B，alpha 和 beta 是标量。A、B 和 C 是 m x n 稀疏矩阵，通过三个数组 csrVal{A|B|C}、csrRowPtr{A|B|C} 和 csrColInd{A|B|C} 以 CSR 存储格式定义。应使用 cusparseXcsrgeam2Nnz 来确定 csrRowPtrC 和结果中非零元素的数量。

integer(4) function cusparseCcsrgeam2(handle, m, n, alpha, descrA, nnzA, csrValA, csrRowPtrA, csrColIndA, &
           beta, descrB, nnzB, csrValB, csrRowPtrB, csrColIndB, descrC, csrValC, csrRowPtrC, csrColIndC, pBuffer)
  type(cusparseHandle) :: handle
  integer :: m, n, nnzA, nnzB
  complex(8), device :: alpha, beta ! device or host variable
  type(cusparseMatDescr):: descrA, descrB, descrC
  complex(8), device :: csrValA(*), csrValB(*), csrValC(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*), csrRowPtrB(*), csrColIndB(*), csrRowPtrC(*), csrColIndC(*)
  integer(1), device :: pBuffer ! can be of any type

5.5.15. cusparseXcsrgemmNnz

cusparseXcsrgemmNnz 计算 CSRGEMM 将生成的非零元素的数量。

此函数已在 CUDA 11.0 中移除。应将其替换为 cusparseXcsrgemm2Nnz 例程

integer(4) function cusparseXcsrgemmNnz(handle, transA, transB, m, n, k, &
           descrA, nnzA, csrRowPtrA, csrColIndA, &
           descrB, nnzB, csrRowPtrB, csrColIndB, descrC, csrRowPtrC, nnzTotalDevHostPtr)
  type(cusparseHandle) :: handle
  integer :: transA, transB, m, n, k, nnzA, nnzB
  type(cusparseMatDescr) :: descrA, descrB, descrC
  integer(4), device :: csrRowPtrA(*), csrColIndA(*), csrRowPtrB(*), csrColIndB(*), csrRowPtrC(*)
  integer(4), device :: nnzTotalDevHostPtr ! device or host variable

5.5.16. cusparseScsrgemm

CSRGEMM 执行矩阵-矩阵运算 C := op( A ) * op( B )，其中 op( X ) 是 op( X ) = X 或 op( X ) = X**T 之一，A、B 和 C 是 m x k、k x n 和 m x n 稀疏矩阵，通过三个数组 csrVal{A|B|C}、csrRowPtr{A|B|C} 和 csrColInd{A|B|C} 以 CSR 存储格式定义。应使用 cusparseXcsrgemmNnz 来确定 csrRowPtrC 和结果中非零元素的数量。

此函数已在 CUDA 11.0 中移除。应将其替换为 cusparseScsrgemm2 例程

integer(4) function cusparseScsrgemm(handle, transA, transB, m, n, k, &
           descrA, nnzA, csrValA, csrRowPtrA, csrColIndA, &
           descrB, nnzB, csrValB, csrRowPtrB, csrColIndB, &
           descrC, csrValC, csrRowPtrC, csrColIndC)
  type(cusparseHandle) :: handle
  integer(4) :: transA, transB, m, n, k, nnzA, nnzB
  type(cusparseMatDescr) :: descrA, descrB, descrC
  real(4), device :: csrValA(*), csrValB(*), csrValC(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*), csrRowPtrB(*), csrColIndB(*), csrRowPtrC(*), csrColIndC(*)

5.5.17. cusparseDcsrgemm

CSRGEMM 执行矩阵-矩阵运算 C := op( A ) * op( B )，其中 op( X ) 是 op( X ) = X 或 op( X ) = X**T 之一，A、B 和 C 是 m x k、k x n 和 m x n 稀疏矩阵，通过三个数组 csrVal{A|B|C}、csrRowPtr{A|B|C} 和 csrColInd{A|B|C} 以 CSR 存储格式定义。应使用 cusparseXcsrgemmNnz 来确定 csrRowPtrC 和结果中非零元素的数量。

此函数已在 CUDA 11.0 中移除。应将其替换为 cusparseDcsrgemm2 例程

integer(4) function cusparseDcsrgemm(handle, transA, transB, m, n, k, &
           descrA, nnzA, csrValA, csrRowPtrA, csrColIndA, &
           descrB, nnzB, csrValB, csrRowPtrB, csrColIndB, &
           descrC, csrValC, csrRowPtrC, csrColIndC)
  type(cusparseHandle) :: handle
  integer(4) :: transA, transB, m, n, k, nnzA, nnzB
  type(cusparseMatDescr) :: descrA, descrB, descrC
  real(8), device :: csrValA(*), csrValB(*), csrValC(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*), csrRowPtrB(*), csrColIndB(*), csrRowPtrC(*), csrColIndC(*)

5.5.18. cusparseCcsrgemm

CSRGEMM 执行矩阵-矩阵运算 C := op( A ) * op( B )，其中 op( X ) 是 op( X ) = X 或 op( X ) = X**T 之一，A、B 和 C 是 m x k、k x n 和 m x n 稀疏矩阵，通过三个数组 csrVal{A|B|C}、csrRowPtr{A|B|C} 和 csrColInd{A|B|C} 以 CSR 存储格式定义。应使用 cusparseXcsrgemmNnz 来确定 csrRowPtrC 和结果中非零元素的数量。

此函数已在 CUDA 11.0 中移除。应将其替换为 cusparseCcsrgemm2 例程

integer(4) function cusparseCcsrgemm(handle, transA, transB, m, n, k, &
           descrA, nnzA, csrValA, csrRowPtrA, csrColIndA, &
           descrB, nnzB, csrValB, csrRowPtrB, csrColIndB, &
           descrC, csrValC, csrRowPtrC, csrColIndC)
  type(cusparseHandle) :: handle
  integer(4) :: transA, transB, m, n, k, nnzA, nnzB
  type(cusparseMatDescr) :: descrA, descrB, descrC
  complex(4), device :: csrValA(*), csrValB(*), csrValC(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*), csrRowPtrB(*), csrColIndB(*), csrRowPtrC(*), csrColIndC(*)

5.5.19. cusparseZcsrgemm

CSRGEMM 执行矩阵-矩阵运算 C := op( A ) * op( B )，其中 op( X ) 是 op( X ) = X 或 op( X ) = X**T 之一，A、B 和 C 是 m x k、k x n 和 m x n 稀疏矩阵，通过三个数组 csrVal{A|B|C}、csrRowPtr{A|B|C} 和 csrColInd{A|B|C} 以 CSR 存储格式定义。应使用 cusparseXcsrgemmNnz 来确定 csrRowPtrC 和结果中非零元素的数量。

此函数已在 CUDA 11.0 中移除。应将其替换为 cusparseZcsrgemm2 例程

integer(4) function cusparseZcsrgemm(handle, transA, transB, m, n, k, &
           descrA, nnzA, csrValA, csrRowPtrA, csrColIndA, &
           descrB, nnzB, csrValB, csrRowPtrB, csrColIndB, &
           descrC, csrValC, csrRowPtrC, csrColIndC)
  type(cusparseHandle) :: handle
  integer(4) :: transA, transB, m, n, k, nnzA, nnzB
  type(cusparseMatDescr) :: descrA, descrB, descrC
  complex(8), device :: csrValA(*), csrValB(*), csrValC(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*), csrRowPtrB(*), csrColIndB(*), csrRowPtrC(*), csrColIndC(*)

5.5.20. cusparseScsrgemm2_bufferSizeExt

此函数返回 csrgemm2 中使用的缓冲区大小。

integer(4) function cusparseScsrgemm2_bufferSizeExt(handle, m, n, k, alpha, &
           descrA, nnzA, csrRowPtrA, csrColIndA, &
           descrB, nnzB, csrRowPtrB, csrColIndB, beta, &
           descrD, nnzD, csrRowPtrD, csrColIndD, info, pBufferSizeInBytes)
  type(cusparseHandle) :: handle
  real(4), device :: alpha, beta ! device or host variable
  integer :: m, n, k, nnzA, nnzB, nnzD
  type(cusparseMatDescr) :: descrA, descrB, descrD
  integer(4), device :: csrRowPtrA(*), csrColIndA(*), csrRowPtrB(*), csrColIndB(*), csrRowPtrD(*), csrColIndD(*)
  type(cusparseCsrgemm2Info) :: info
  integer(8) :: pBufferSizeInBytes

5.5.21. cusparseDcsrgemm2_bufferSizeExt

此函数返回 csrgemm2 中使用的缓冲区大小。

integer(4) function cusparseDcsrgemm2_bufferSizeExt(handle, m, n, k, alpha, &
           descrA, nnzA, csrRowPtrA, csrColIndA, &
           descrB, nnzB, csrRowPtrB, csrColIndB, beta, &
           descrD, nnzD, csrRowPtrD, csrColIndD, info, pBufferSizeInBytes)
  type(cusparseHandle) :: handle
  real(8), device :: alpha, beta ! device or host variable
  integer :: m, n, k, nnzA, nnzB, nnzD
  type(cusparseMatDescr) :: descrA, descrB, descrD
  integer(4), device :: csrRowPtrA(*), csrColIndA(*), csrRowPtrB(*), csrColIndB(*), csrRowPtrD(*), csrColIndD(*)
  type(cusparseCsrgemm2Info) :: info
  integer(8) :: pBufferSizeInBytes

5.5.22. cusparseCcsrgemm2_bufferSizeExt

此函数返回 csrgemm2 中使用的缓冲区大小。

integer(4) function cusparseCcsrgemm2_bufferSizeExt(handle, m, n, k, alpha, &
           descrA, nnzA, csrRowPtrA, csrColIndA, &
           descrB, nnzB, csrRowPtrB, csrColIndB, beta, &
           descrD, nnzD, csrRowPtrD, csrColIndD, info, pBufferSizeInBytes)
  type(cusparseHandle) :: handle
  complex(4), device :: alpha, beta ! device or host variable
  integer :: m, n, k, nnzA, nnzB, nnzD
  type(cusparseMatDescr) :: descrA, descrB, descrD
  integer(4), device :: csrRowPtrA(*), csrColIndA(*), csrRowPtrB(*), csrColIndB(*), csrRowPtrD(*), csrColIndD(*)
  type(cusparseCsrgemm2Info) :: info
  integer(8) :: pBufferSizeInBytes

5.5.23. cusparseZcsrgemm2_bufferSizeExt

此函数返回 csrgemm2 中使用的缓冲区大小。

integer(4) function cusparseZcsrgemm2_bufferSizeExt(handle, m, n, k, alpha, &
           descrA, nnzA, csrRowPtrA, csrColIndA, &
           descrB, nnzB, csrRowPtrB, csrColIndB, beta, &
           descrD, nnzD, csrRowPtrD, csrColIndD, info, pBufferSizeInBytes)
  type(cusparseHandle) :: handle
  complex(8), device :: alpha, beta ! device or host variable
  integer :: m, n, k, nnzA, nnzB, nnzD
  type(cusparseMatDescr) :: descrA, descrB, descrD
  integer(4), device :: csrRowPtrA(*), csrColIndA(*), csrRowPtrB(*), csrColIndB(*), csrRowPtrD(*), csrColIndD(*)
  type(cusparseCsrgemm2Info) :: info
  integer(8) :: pBufferSizeInBytes

5.5.24. cusparseXcsrgemm2Nnz

cusparseXcsrgemm2Nnz 计算 CSRGEMM2 将生成的非零元素的数量。

integer(4) function cusparseXcsrgemm2Nnz(handle, m, n, k, &
           descrA, nnzA, csrRowPtrA, csrColIndA, &
           descrB, nnzB, csrRowPtrB, csrColIndB, &
           descrD, nnzD, csrRowPtrD, csrColIndD, &
           descrC, csrRowPtrC, nnzTotalDevHostPtr, info, pBuffer)
  type(cusparseHandle) :: handle
  type(cusparseMatDescr) :: descrA, descrB, descrD, descrC
  type(cusparseCsrgemm2Info) :: info
  integer(4) :: m, n, k, nnzA, nnzB, nnzD
  integer(4), device :: csrRowPtrA(*), csrColIndA(*), csrRowPtrB(*), csrColIndB(*), csrRowPtrD(*), csrColIndD(*), csrRowPtrC(*)
  integer(c_int) :: nnzTotalDevHostPtr
  character(c_char), device :: pBuffer(*)

5.5.25. cusparseScsrgemm2

CSRGEMM2 执行矩阵-矩阵运算 C := alpha * A * B + beta * D alpha 和 beta 是标量。A、B 和 C 是 m x k、k x n 和 m x n 稀疏矩阵，通过三个数组 csrVal{A|B|C|D}、csrRowPtr{A|B|C|D} 和 csrColInd{A|B|C|D} 以 CSR 存储格式定义。应使用 cusparseXcsrgemm2Nnz 来确定 csrRowPtrC 和结果中非零元素的数量。

integer(4) function cusparseScsrgemm2(handle, m, n, k, alpha, &
           descrA, nnzA, csrValA, csrRowPtrA, csrColIndA, &
           descrB, nnzB, csrValB, csrRowPtrB, csrColIndB, beta, &
           descrD, nnzD, csrValD, csrRowPtrD, csrColIndD, &
           descrC, csrValC, csrRowPtrC, csrColIndC, info, pBuffer)
  type(cusparseHandle) :: handle
  type(cusparseMatDescr) :: descrA, descrB, descrD, descrC
  type(cusparseCsrgemm2Info) :: info
  integer :: m, n, k, nnzA, nnzB, nnzD
  integer(4), device :: csrRowPtrA(*), csrColIndA(*), csrRowPtrB(*), csrColIndB(*), csrRowPtrD(*), csrColIndD(*), csrRowPtrC(*), csrColIndC(*)
  real(4), device :: csrValA(*), csrValB(*), csrValD(*), csrValC(*)
  real(4), device :: alpha, beta ! device or host variable
  integer(4), device :: nnzTotalDevHostPtr ! device or host variable
  character, device :: pBuffer(*)

5.5.26. cusparseDcsrgemm2

CSRGEMM2 执行矩阵-矩阵运算 C := alpha * A * B + beta * D alpha 和 beta 是标量。A、B 和 C 是 m x k、k x n 和 m x n 稀疏矩阵，通过三个数组 csrVal{A|B|C|D}、csrRowPtr{A|B|C|D} 和 csrColInd{A|B|C|D} 以 CSR 存储格式定义。应使用 cusparseXcsrgemm2Nnz 来确定 csrRowPtrC 和结果中非零元素的数量。

integer(4) function cusparseDcsrgemm2(handle, m, n, k, alpha, &
           descrA, nnzA, csrValA, csrRowPtrA, csrColIndA, &
           descrB, nnzB, csrValB, csrRowPtrB, csrColIndB, beta, &
           descrD, nnzD, csrValD, csrRowPtrD, csrColIndD, &
           descrC, csrValC, csrRowPtrC, csrColIndC, info, pBuffer)
  type(cusparseHandle) :: handle
  type(cusparseMatDescr) :: descrA, descrB, descrD, descrC
  type(cusparseCsrgemm2Info) :: info
  integer :: m, n, k, nnzA, nnzB, nnzD
  integer(4), device :: csrRowPtrA(*), csrColIndA(*), csrRowPtrB(*), csrColIndB(*), csrRowPtrD(*), csrColIndD(*), csrRowPtrC(*), csrColIndC(*)
  real(8), device :: csrValA(*), csrValB(*), csrValD(*), csrValC(*)
  real(8), device :: alpha, beta ! device or host variable
  integer(4), device :: nnzTotalDevHostPtr ! device or host variable
  character, device :: pBuffer(*)

5.5.27. cusparseCcsrgemm2

CSRGEMM2 执行矩阵-矩阵运算 C := alpha * A * B + beta * D alpha 和 beta 是标量。A、B 和 C 是 m x k、k x n 和 m x n 稀疏矩阵，通过三个数组 csrVal{A|B|C|D}、csrRowPtr{A|B|C|D} 和 csrColInd{A|B|C|D} 以 CSR 存储格式定义。应使用 cusparseXcsrgemm2Nnz 来确定 csrRowPtrC 和结果中非零元素的数量。

integer(4) function cusparseCcsrgemm2(handle, m, n, k, alpha, &
           descrA, nnzA, csrValA, csrRowPtrA, csrColIndA, &
           descrB, nnzB, csrValB, csrRowPtrB, csrColIndB, beta, &
           descrD, nnzD, csrValD, csrRowPtrD, csrColIndD, &
           descrC, csrValC, csrRowPtrC, csrColIndC, info, pBuffer)
  type(cusparseHandle) :: handle
  type(cusparseMatDescr) :: descrA, descrB, descrD, descrC
  type(cusparseCsrgemm2Info) :: info
  integer :: m, n, k, nnzA, nnzB, nnzD
  integer(4), device :: csrRowPtrA(*), csrColIndA(*), csrRowPtrB(*), csrColIndB(*), csrRowPtrD(*), csrColIndD(*), csrRowPtrC(*), csrColIndC(*)
  complex(4), device :: csrValA(*), csrValB(*), csrValD(*), csrValC(*)
  complex(4), device :: alpha, beta ! device or host variable
  integer(4), device :: nnzTotalDevHostPtr ! device or host variable
  character, device :: pBuffer(*)

5.5.28. cusparseZcsrgemm2

CSRGEMM2 执行矩阵-矩阵运算 C := alpha * A * B + beta * D alpha 和 beta 是标量。A、B 和 C 是 m x k、k x n 和 m x n 稀疏矩阵，通过三个数组 csrVal{A|B|C|D}、csrRowPtr{A|B|C|D} 和 csrColInd{A|B|C|D} 以 CSR 存储格式定义。应使用 cusparseXcsrgemm2Nnz 来确定 csrRowPtrC 和结果中非零元素的数量。

integer(4) function cusparseZcsrgemm2(handle, m, n, k, alpha, descrA, nnzA, csrValA, csrRowPtrA, csrColIndA, descrB, nnzB, csrValB, csrRowPtrB, csrColIndB, beta, descrD, nnzD, csrValD, csrRowPtrD, csrColIndD, descrC, csrValC, csrRowPtrC, csrColIndC, info, pBuffer)
  type(cusparseHandle) :: handle
  type(cusparseMatDescr) :: descrA, descrB, descrD, descrC
  type(cusparseCsrgemm2Info) :: info
  integer :: m, n, k, nnzA, nnzB, nnzD
  integer(4), device :: csrRowPtrA(*), csrColIndA(*),   csrRowPtrB(*), csrColIndB(*),   csrRowPtrD(*), csrColIndD(*), csrRowPtrC(*), csrColIndC(*)
  complex(8), device :: csrValA(*), csrValB(*), csrValD(*), csrValC(*)
  complex(8), device :: alpha, beta ! device or host variable
  integer(4), device :: nnzTotalDevHostPtr ! device or host variable
  character, device :: pBuffer(*)

5.6. CUSPARSE 预处理函数

本节包含用于处理稀疏矩阵的预处理函数的接口。

5.6.1. cusparseScsric0

CSRIC0 计算不完全 Cholesky 分解，零填充且无旋转。A 是一个 m x n Hermitian/对称正定稀疏矩阵，通过三个数组 csrValA、csrRowPtrA 和 csrColIndA 以 CSR 存储格式定义。

integer(4) function cusparseScsric0(handle, trans, m, descrA, csrValM, csrRowPtrA, csrColIndA, info)
  type(cusparseHandle) :: handle
  integer(4) :: trans, m
  type(cusparseMatDescr) :: descrA
  real(4), device :: csrValM(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseSolveAnalysisInfo) :: info

5.6.2. cusparseDcsric0

CSRIC0 计算不完全 Cholesky 分解，零填充且无旋转。A 是一个 m x n Hermitian/对称正定稀疏矩阵，通过三个数组 csrValA、csrRowPtrA 和 csrColIndA 以 CSR 存储格式定义。

integer(4) function cusparseDcsric0(handle, trans, m, descrA, csrValM, csrRowPtrA, csrColIndA, info)
  type(cusparseHandle) :: handle
  integer(4) :: trans, m
  type(cusparseMatDescr) :: descrA
  real(8), device :: csrValM(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseSolveAnalysisInfo) :: info

5.6.3. cusparseCcsric0

CSRIC0 计算不完全 Cholesky 分解，零填充且无旋转。A 是一个 m x n Hermitian/对称正定稀疏矩阵，通过三个数组 csrValA、csrRowPtrA 和 csrColIndA 以 CSR 存储格式定义。

integer(4) function cusparseCcsric0(handle, trans, m, descrA, csrValM, csrRowPtrA, csrColIndA, info)
  type(cusparseHandle) :: handle
  integer(4) :: trans, m
  type(cusparseMatDescr) :: descrA
  complex(4), device :: csrValM(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseSolveAnalysisInfo) :: info

5.6.4. cusparseZcsric0

CSRIC0 计算不完全 Cholesky 分解，零填充且无旋转。A 是一个 m x n Hermitian/对称正定稀疏矩阵，通过三个数组 csrValA、csrRowPtrA 和 csrColIndA 以 CSR 存储格式定义。

integer(4) function cusparseZcsric0(handle, trans, m, descrA, csrValM, csrRowPtrA, csrColIndA, info)
  type(cusparseHandle) :: handle
  integer(4) :: trans, m
  type(cusparseMatDescr) :: descrA
  complex(8), device :: csrValM(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseSolveAnalysisInfo) :: info

5.6.5. cusparseScsrilu0

CSRILU0 计算不完全 LU 分解，零填充且无旋转。A 是一个 m x n 稀疏矩阵，通过三个数组 csrValA、csrRowPtrA 和 csrColIndA 以 CSR 存储格式定义。

integer(4) function cusparseScsrilu0(handle, trans, m, descrA, csrValM, csrRowPtrA, csrColIndA, info)
  type(cusparseHandle) :: handle
  integer(4) :: trans, m
  type(cusparseMatDescr) :: descrA
  real(4), device :: csrValM(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseSolveAnalysisInfo) :: info

5.6.6. cusparseDcsrilu0

CSRILU0 计算不完全 LU 分解，零填充且无旋转。A 是一个 m x n 稀疏矩阵，通过三个数组 csrValA、csrRowPtrA 和 csrColIndA 以 CSR 存储格式定义。

integer(4) function cusparseDcsrilu0(handle, trans, m, descrA, csrValM, csrRowPtrA, csrColIndA, info)
  type(cusparseHandle) :: handle
  integer(4) :: trans, m
  type(cusparseMatDescr) :: descrA
  real(8), device :: csrValM(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseSolveAnalysisInfo) :: info

5.6.7. cusparseCcsrilu0

CSRILU0 计算不完全 LU 分解，零填充且无旋转。A 是一个 m x n 稀疏矩阵，通过三个数组 csrValA、csrRowPtrA 和 csrColIndA 以 CSR 存储格式定义。

integer(4) function cusparseCcsrilu0(handle, trans, m, descrA, csrValM, csrRowPtrA, csrColIndA, info)
  type(cusparseHandle) :: handle
  integer(4) :: trans, m
  type(cusparseMatDescr) :: descrA
  complex(4), device :: csrValM(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseSolveAnalysisInfo) :: info

5.6.8. cusparseZcsrilu0

CSRILU0 计算不完全 LU 分解，零填充且无旋转。A 是一个 m x n 稀疏矩阵，通过三个数组 csrValA、csrRowPtrA 和 csrColIndA 以 CSR 存储格式定义。

integer(4) function cusparseZcsrilu0(handle, trans, m, descrA, csrValM, csrRowPtrA, csrColIndA, info)
  type(cusparseHandle) :: handle
  integer(4) :: trans, m
  type(cusparseMatDescr) :: descrA
  complex(8), device :: csrValM(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseSolveAnalysisInfo) :: info

5.6.9. cusparseSgtsv

GTSV 计算具有多个右手侧的三对角线性系统的解：A * Y = a * x。此三对角线性系统的系数矩阵 A 由三个向量定义，分别对应于其下对角线 (dl)、主对角线 (d) 和上对角线 (du)；右手侧存储在稠密矩阵 X 中。解 Y 在退出时覆盖右手侧矩阵 X。

此函数已在 CUDA 11.0 中移除。它和类似的例程应替换为 cusparseSgtsv2 变体。

integer(4) function cusparseSgtsv(handle, m, n, dl, d, du, B, ldb)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, ldb
  real(4), device :: dl(*), d(*), du(*), B(*)

5.6.10. cusparseDgtsv

GTSV 计算具有多个右手侧的三对角线性系统的解：A * Y = a * x。此三对角线性系统的系数矩阵 A 由三个向量定义，分别对应于其下对角线 (dl)、主对角线 (d) 和上对角线 (du)；右手侧存储在稠密矩阵 X 中。解 Y 在退出时覆盖右手侧矩阵 X。

此函数已在 CUDA 11.0 中移除。它和类似的例程应替换为 cusparseDgtsv2 变体。

integer(4) function cusparseDgtsv(handle, m, n, dl, d, du, B, ldb)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, ldb
  real(8), device :: dl(*), d(*), du(*), B(*)

5.6.11. cusparseCgtsv

GTSV 计算具有多个右手侧的三对角线性系统的解：A * Y = a * x。此三对角线性系统的系数矩阵 A 由三个向量定义，分别对应于其下对角线 (dl)、主对角线 (d) 和上对角线 (du)；右手侧存储在稠密矩阵 X 中。解 Y 在退出时覆盖右手侧矩阵 X。

此函数已在 CUDA 11.0 中移除。它和类似的例程应替换为 cusparseCgtsv2 变体。

integer(4) function cusparseCgtsv(handle, m, n, dl, d, du, B, ldb)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, ldb
  complex(4), device :: dl(*), d(*), du(*), B(*)

5.6.12. cusparseZgtsv

GTSV 计算具有多个右手侧的三对角线性系统的解：A * Y = a * x。此三对角线性系统的系数矩阵 A 由三个向量定义，分别对应于其下对角线 (dl)、主对角线 (d) 和上对角线 (du)；右手侧存储在稠密矩阵 X 中。解 Y 在退出时覆盖右手侧矩阵 X。

此函数已在 CUDA 11.0 中移除。它和类似的例程应替换为 cusparseZgtsv2 变体。

integer(4) function cusparseZgtsv(handle, m, n, dl, d, du, B, ldb)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, ldb
  complex(8), device :: dl(*), d(*), du(*), B(*)

5.6.13. cusparseSgtsv2_buffersize

Sgtsv2_buffersize 返回 Sgtsv2() 中所需的缓冲区大小（以字节为单位）。

integer(4) function cusparseSgtsv2_bufferSize(handle, m, n, dl, d, du, B, ldb, pBufferSizeInBytes)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, ldb
  real(4), device :: dl(m), d(m), du(m), B(ldb,n)
  integer(8) :: pBufferSizeInBytes

5.6.14. cusparseDgtsv2_buffersize

Dgtsv2_buffersize 返回 Dgtsv2() 中所需的缓冲区大小（以字节为单位）。

integer(4) function cusparseDgtsv2_bufferSize(handle, m, n, dl, d, du, B, ldb, pBufferSizeInBytes)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, ldb
  real(8), device :: dl(m), d(m), du(m), B(ldb,n)
  integer(8) :: pBufferSizeInBytes

5.6.15. cusparseCgtsv2_buffersize

Cgtsv2_buffersize 返回 Cgtsv2() 中所需的缓冲区大小（以字节为单位）。

integer(4) function cusparseCgtsv2_bufferSize(handle, m, n, dl, d, du, B, ldb, pBufferSizeInBytes)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, ldb
  complex(4), device :: dl(m), d(m), du(m), B(ldb,n)
  integer(8) :: pBufferSizeInBytes

5.6.16. cusparseZgtsv2_buffersize

Zgtsv2_buffersize 返回 Zgtsv2() 中所需的缓冲区大小（以字节为单位）。

integer(4) function cusparseZgtsv2_bufferSize(handle, m, n, dl, d, du, B, ldb, pBufferSizeInBytes)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, ldb
  complex(8), device :: dl(m), d(m), du(m), B(ldb,n)
  integer(8) :: pBufferSizeInBytes

5.6.17. cusparseSgtsv2

Sgtsv2 计算具有多个右手侧的三对角线性系统的解：A * X = B。三对角线性系统的系数矩阵 A 由三个向量定义，分别对应于其下对角线 (dl)、主对角线 (d) 和上对角线 (du)；右手侧存储在稠密矩阵 B 中。解 X 在退出时覆盖右手侧矩阵 B。输入 m 是线性系统的大小。输入 n 是 B 中右手侧的数量。

integer(4) function cusparseSgtsv2(handle, m, n, dl, d, du, B, ldb, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, ldb
  real(4), device :: dl(m), d(m), du(m), B(ldb,n)
  character(1), device :: pBuffer(*)

5.6.18. cusparseDgtsv2

Dgtsv2 计算具有多个右手侧的三对角线性系统的解：A * X = B。三对角线性系统的系数矩阵 A 由三个向量定义，分别对应于其下对角线 (dl)、主对角线 (d) 和上对角线 (du)；右手侧存储在稠密矩阵 B 中。解 X 在退出时覆盖右手侧矩阵 B。输入 m 是线性系统的大小。输入 n 是 B 中右手侧的数量。

integer(4) function cusparseDgtsv2(handle, m, n, dl, d, du, B, ldb, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, ldb
  real(8), device :: dl(m), d(m), du(m), B(ldb,n)
  character(1), device :: pBuffer(*)

5.6.19. cusparseCgtsv2

Cgtsv2 计算具有多个右手侧的三对角线性系统的解：A * X = B。三对角线性系统的系数矩阵 A 由三个向量定义，分别对应于其下对角线 (dl)、主对角线 (d) 和上对角线 (du)；右手侧存储在稠密矩阵 B 中。解 X 在退出时覆盖右手侧矩阵 B。输入 m 是线性系统的大小。输入 n 是 B 中右手侧的数量。

integer(4) function cusparseCgtsv2(handle, m, n, dl, d, du, B, ldb, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, ldb
  complex(4), device :: dl(m), d(m), du(m), B(ldb,n)
  character(1), device :: pBuffer(*)

5.6.20. cusparseZgtsv2

Zgtsv2 计算具有多个右手侧的三对角线性系统的解：A * X = B。三对角线性系统的系数矩阵 A 由三个向量定义，分别对应于其下对角线 (dl)、主对角线 (d) 和上对角线 (du)；右手侧存储在稠密矩阵 B 中。解 X 在退出时覆盖右手侧矩阵 B。输入 m 是线性系统的大小。输入 n 是 B 中右手侧的数量。

integer(4) function cusparseZgtsv2(handle, m, n, dl, d, du, B, ldb, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, ldb
  complex(8), device :: dl(m), d(m), du(m), B(ldb,n)
  character(1), device :: pBuffer(*)

5.6.21. cusparseSgtsv2_nopivot_buffersize

Sgtsv2_nopivot_buffersize 返回 Sgtsv2_nopivot() 中所需的缓冲区大小（以字节为单位）。

integer(4) function cusparseSgtsv2_nopivot_bufferSize(handle, m, n, dl, d, du, B, ldb, pBufferSizeInBytes)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, ldb
  real(4), device :: dl(m), d(m), du(m), B(ldb,n)
  integer(8) :: pBufferSizeInBytes

5.6.22. cusparseDgtsv2_nopivot_buffersize

Dgtsv2_nopivot_buffersize 返回 Dgtsv2_nopivot() 中所需的缓冲区大小（以字节为单位）。

integer(4) function cusparseDgtsv2_nopivot_bufferSize(handle, m, n, dl, d, du, B, ldb, pBufferSizeInBytes)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, ldb
  real(8), device :: dl(m), d(m), du(m), B(ldb,n)
  integer(8) :: pBufferSizeInBytes

5.6.23. cusparseCgtsv2_nopivot_buffersize

Cgtsv2_nopivot_buffersize 返回 Cgtsv2_nopivot() 中所需的缓冲区大小（以字节为单位）。

integer(4) function cusparseCgtsv2_nopivot_bufferSize(handle, m, n, dl, d, du, B, ldb, pBufferSizeInBytes)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, ldb
  complex(4), device :: dl(m), d(m), du(m), B(ldb,n)
  integer(8) :: pBufferSizeInBytes

5.6.24. cusparseZgtsv2_nopivot_buffersize

Zgtsv2_nopivot_buffersize 返回 Zgtsv2_nopivot() 中所需的缓冲区大小（以字节为单位）。

integer(4) function cusparseZgtsv2_nopivot_bufferSize(handle, m, n, dl, d, du, B, ldb, pBufferSizeInBytes)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, ldb
  complex(8), device :: dl(m), d(m), du(m), B(ldb,n)
  integer(8) :: pBufferSizeInBytes

5.6.25. cusparseSgtsv2_nopivot

Sgtsv2_nopivot 计算具有多个右手侧的三对角线性系统的解，无需旋转：A * X = B。三对角线性系统的系数矩阵 A 由三个向量定义，分别对应于其下对角线 (dl)、主对角线 (d) 和上对角线 (du)；右手侧存储在稠密矩阵 B 中。解 X 在退出时覆盖右手侧矩阵 B。输入 m 是线性系统的大小。输入 n 是 B 中右手侧的数量。

integer(4) function cusparseSgtsv2_nopivot(handle, m, n, dl, d, du, B, ldb, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, ldb
  real(4), device :: dl(m), d(m), du(m), B(ldb,n)
  character(1), device :: pBuffer(*)

5.6.26. cusparseDgtsv2_nopivot

Dgtsv2_nopivot 计算具有多个右手侧的三对角线性系统的解，无需旋转：A * X = B。三对角线性系统的系数矩阵 A 由三个向量定义，分别对应于其下对角线 (dl)、主对角线 (d) 和上对角线 (du)；右手侧存储在稠密矩阵 B 中。解 X 在退出时覆盖右手侧矩阵 B。输入 m 是线性系统的大小。输入 n 是 B 中右手侧的数量。

integer(4) function cusparseDgtsv2_nopivot(handle, m, n, dl, d, du, B, ldb, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, ldb
  real(8), device :: dl(m), d(m), du(m), B(ldb,n)
  character(1), device :: pBuffer(*)

5.6.27. cusparseCgtsv2_nopivot

Cgtsv2_nopivot 计算具有多个右手侧的三对角线性系统的解，无需旋转：A * X = B。三对角线性系统的系数矩阵 A 由三个向量定义，分别对应于其下对角线 (dl)、主对角线 (d) 和上对角线 (du)；右手侧存储在稠密矩阵 B 中。解 X 在退出时覆盖右手侧矩阵 B。输入 m 是线性系统的大小。输入 n 是 B 中右手侧的数量。

integer(4) function cusparseCgtsv2_nopivot(handle, m, n, dl, d, du, B, ldb, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, ldb
  complex(4), device :: dl(m), d(m), du(m), B(ldb,n)
  character(1), device :: pBuffer(*)

5.6.28. cusparseZgtsv2_nopivot

Zgtsv2_nopivot 计算具有多个右手侧的三对角线性系统的解，无需旋转：A * X = B。三对角线性系统的系数矩阵 A 由三个向量定义，分别对应于其下对角线 (dl)、主对角线 (d) 和上对角线 (du)；右手侧存储在稠密矩阵 B 中。解 X 在退出时覆盖右手侧矩阵 B。输入 m 是线性系统的大小。输入 n 是 B 中右手侧的数量。

integer(4) function cusparseZgtsv2_nopivot(handle, m, n, dl, d, du, B, ldb, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, ldb
  complex(8), device :: dl(m), d(m), du(m), B(ldb,n)
  character(1), device :: pBuffer(*)

5.6.29. cusparseSgtsv2StridedBatch_buffersize

Sgtsv2StridedBatch_buffersize 返回 Sgtsv2StridedBatch() 中所需的缓冲区大小（以字节为单位）。

integer(4) function cusparseSgtsv2StridedBatch_bufferSize(handle, m, dl, d, du, x, batchCount, batchStride, pBufferSizeInBytes)
  type(cusparseHandle) :: handle
  integer(4) :: m, batchCount, batchStride
  real(4), device :: dl(*), d(*), du(*), x(*)
  integer(8) :: pBufferSizeInBytes

5.6.30. cusparseDgtsv2StridedBatch_buffersize

Dgtsv2StridedBatch_buffersize 返回 Dgtsv2StridedBatch() 中所需的缓冲区大小（以字节为单位）。

integer(4) function cusparseDgtsv2StridedBatch_bufferSize(handle, m, dl, d, du, x, batchCount, batchStride, pBufferSizeInBytes)
  type(cusparseHandle) :: handle
  integer(4) :: m, batchCount, batchStride
  real(8), device :: dl(*), d(*), du(*), x(*)
  integer(8) :: pBufferSizeInBytes

5.6.31. cusparseCgtsv2StridedBatch_buffersize

Cgtsv2StridedBatch_buffersize 返回 Cgtsv2StridedBatch() 中所需的缓冲区大小（以字节为单位）。

integer(4) function cusparseCgtsv2StridedBatch_bufferSize(handle, m, dl, d, du, x, batchCount, batchStride, pBufferSizeInBytes)
  type(cusparseHandle) :: handle
  integer(4) :: m, batchCount, batchStride
  complex(4), device :: dl(*), d(*), du(*), x(*)
  integer(8) :: pBufferSizeInBytes

5.6.32. cusparseZgtsv2StridedBatch_buffersize

Zgtsv2StridedBatch_buffersize 返回 Zgtsv2StridedBatch() 中所需的缓冲区大小（以字节为单位）。

integer(4) function cusparseZgtsv2StridedBatch_bufferSize(handle, m, dl, d, du, x, batchCount, batchStride, pBufferSizeInBytes)
  type(cusparseHandle) :: handle
  integer(4) :: m, batchCount, batchStride
  complex(8), device :: dl(*), d(*), du(*), x(*)
  integer(8) :: pBufferSizeInBytes

5.6.33. cusparseSgtsv2StridedBatch

Sgtsv2StridedBatch 计算具有多个右手侧的多个三对角线性系统的解：A * X = B。每个三对角线性系统的系数矩阵 A 由三个向量定义，分别对应于其下对角线 (dl)、主对角线 (d) 和上对角线 (du)；右手侧存储在稠密矩阵 B 中。解 X 在退出时覆盖右手侧矩阵 B。

integer(4) function cusparseSgtsv2StridedBatch(handle, m, dl, d, du, x, batchCount, batchStride, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: m, batchCount, batchStride
  real(4), device :: dl(*), d(*), du(*), x(*)
  character(1), device :: pBuffer(*)

5.6.34. cusparseDgtsv2StridedBatch

Dgtsv2StridedBatch 计算具有多个右端项的多个三对角线性系统的解：A * X = B。每个三对角线性系统的系数矩阵 A 由与其下对角线 (dl)、主对角线 (d) 和上对角线 (du) 相对应的三个向量定义；右端项存储在稠密矩阵 B 中。解 X 在退出时会覆盖右端项矩阵 B。

integer(4) function cusparseDgtsv2StridedBatch(handle, m, dl, d, du, x, batchCount, batchStride, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: m, batchCount, batchStride
  real(8), device :: dl(*), d(*), du(*), x(*)
  character(1), device :: pBuffer(*)

5.6.35. cusparseCgtsv2StridedBatch

Cgtsv2StridedBatch 计算具有多个右端项的多个三对角线性系统的解：A * X = B。每个三对角线性系统的系数矩阵 A 由与其下对角线 (dl)、主对角线 (d) 和上对角线 (du) 相对应的三个向量定义；右端项存储在稠密矩阵 B 中。解 X 在退出时会覆盖右端项矩阵 B。

integer(4) function cusparseCgtsv2StridedBatch(handle, m, dl, d, du, x, batchCount, batchStride, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: m, batchCount, batchStride
  complex(4), device :: dl(*), d(*), du(*), x(*)
  character(1), device :: pBuffer(*)

5.6.36. cusparseZgtsv2StridedBatch

Zgtsv2StridedBatch 计算具有多个右端项的多个三对角线性系统的解：A * X = B。每个三对角线性系统的系数矩阵 A 由与其下对角线 (dl)、主对角线 (d) 和上对角线 (du) 相对应的三个向量定义；右端项存储在稠密矩阵 B 中。解 X 在退出时会覆盖右端项矩阵 B。

integer(4) function cusparseZgtsv2StridedBatch(handle, m, dl, d, du, x, batchCount, batchStride, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: m, batchCount, batchStride
  complex(8), device :: dl(*), d(*), du(*), x(*)
  character(1), device :: pBuffer(*)

5.6.37. cusparseSgtsvInterleavedBatch_buffersize

SgtsvInterleavedBatch_buffersize 返回 SgtsvInterleavedBatch() 中所需的缓冲区大小（以字节为单位）。

integer(4) function cusparseSgtsvInterleavedBatch_bufferSize(handle, algo, m, dl, d, du, x, batchCount, pBufferSizeInBytes)
  type(cusparseHandle) :: handle
  integer(4) :: algo, m, batchCount
  real(4), device :: dl(*), d(*), du(*), x(*)
  integer(8) :: pBufferSizeInBytes

5.6.38. cusparseDgtsvInterleavedBatch_buffersize

DgtsvInterleavedBatch_buffersize 返回 DgtsvInterleavedBatch() 中所需的缓冲区大小（以字节为单位）。

integer(4) function cusparseDgtsvInterleavedBatch_bufferSize(handle, algo, m, dl, d, du, x, batchCount, pBufferSizeInBytes)
  type(cusparseHandle) :: handle
  integer(4) :: algo, m, batchCount
  real(8), device :: dl(*), d(*), du(*), x(*)
  integer(8) :: pBufferSizeInBytes

5.6.39. cusparseCgtsvInterleavedBatch_buffersize

CgtsvInterleavedBatch_buffersize 返回 CgtsvInterleavedBatch() 中所需的缓冲区大小（以字节为单位）。

integer(4) function cusparseCgtsvInterleavedBatch_bufferSize(handle, algo, m, dl, d, du, x, batchCount, pBufferSizeInBytes)
  type(cusparseHandle) :: handle
  integer(4) :: algo, m, batchCount
  complex(4), device :: dl(*), d(*), du(*), x(*)
  integer(8) :: pBufferSizeInBytes

5.6.40. cusparseZgtsvInterleavedBatch_buffersize

ZgtsvInterleavedBatch_buffersize 返回 ZgtsvInterleavedBatch() 中所需的缓冲区大小（以字节为单位）。

integer(4) function cusparseZgtsvInterleavedBatch_bufferSize(handle, algo, m, dl, d, du, x, batchCount, pBufferSizeInBytes)
  type(cusparseHandle) :: handle
  integer(4) :: algo, m, batchCount
  complex(8), device :: dl(*), d(*), du(*), x(*)
  integer(8) :: pBufferSizeInBytes

5.6.41. cusparseSgtsvInterleavedBatch

SgtsvInterleavedBatch 计算具有多个右端项的多个三对角线性系统的解：A * X = B。每个三对角线性系统的系数矩阵 A 由与其下对角线 (dl)、主对角线 (d) 和上对角线 (du) 相对应的三个向量定义；右端项存储在稠密矩阵 B 中。解 X 在退出时会覆盖右端项矩阵 B。此例程与 SgtsvStridedBatch 例程的不同之处在于，对角线、RHS 和解向量的数据是交错存储的，从一个批次到 batchCount，而不是一个接一个地存储。有关当前支持的 algo 值，请参阅 cuSPARSE 库文档。

integer(4) function cusparseSgtsvInterleavedBatch(handle, algo, m, dl, d, du, x, batchCount, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: algo, m, batchCount
  real(4), device :: dl(*), d(*), du(*), x(*)
  character(1), device :: pBuffer(*)

5.6.42. cusparseDgtsvInterleavedBatch

DgtsvInterleavedBatch 计算具有多个右端项的多个三对角线性系统的解：A * X = B。每个三对角线性系统的系数矩阵 A 由与其下对角线 (dl)、主对角线 (d) 和上对角线 (du) 相对应的三个向量定义；右端项存储在稠密矩阵 B 中。解 X 在退出时会覆盖右端项矩阵 B。此例程与 DgtsvStridedBatch 例程的不同之处在于，对角线、RHS 和解向量的数据是交错存储的，从一个批次到 batchCount，而不是一个接一个地存储。有关当前支持的 algo 值，请参阅 cuSPARSE 库文档。

integer(4) function cusparseDgtsvInterleavedBatch(handle, algo, m, dl, d, du, x, batchCount, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: algo, m, batchCount
  real(8), device :: dl(*), d(*), du(*), x(*)
  character(1), device :: pBuffer(*)

5.6.43. cusparseCgtsvInterleavedBatch

CgtsvInterleavedBatch 计算具有多个右端项的多个三对角线性系统的解：A * X = B。每个三对角线性系统的系数矩阵 A 由与其下对角线 (dl)、主对角线 (d) 和上对角线 (du) 相对应的三个向量定义；右端项存储在稠密矩阵 B 中。解 X 在退出时会覆盖右端项矩阵 B。此例程与 CgtsvStridedBatch 例程的不同之处在于，对角线、RHS 和解向量的数据是交错存储的，从一个批次到 batchCount，而不是一个接一个地存储。有关当前支持的 algo 值，请参阅 cuSPARSE 库文档。

integer(4) function cusparseCgtsvInterleavedBatch(handle, algo, m, dl, d, du, x, batchCount, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: algo, m, batchCount
  complex(4), device :: dl(*), d(*), du(*), x(*)
  character(1), device :: pBuffer(*)

5.6.44. cusparseZgtsvInterleavedBatch

ZgtsvInterleavedBatch 计算具有多个右端项的多个三对角线性系统的解：A * X = B。每个三对角线性系统的系数矩阵 A 由与其下对角线 (dl)、主对角线 (d) 和上对角线 (du) 相对应的三个向量定义；右端项存储在稠密矩阵 B 中。解 X 在退出时会覆盖右端项矩阵 B。此例程与 ZgtsvStridedBatch 例程的不同之处在于，对角线、RHS 和解向量的数据是交错存储的，从一个批次到 batchCount，而不是一个接一个地存储。有关当前支持的 algo 值，请参阅 cuSPARSE 库文档。

integer(4) function cusparseZgtsvInterleavedBatch(handle, algo, m, dl, d, du, x, batchCount, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: algo, m, batchCount
  complex(8), device :: dl(*), d(*), du(*), x(*)
  character(1), device :: pBuffer(*)

5.6.45. cusparseSgpsvInterleavedBatch_buffersize

SgpsvInterleavedBatch_buffersize 返回 SgpsvInterleavedBatch() 中所需的缓冲区大小（以字节为单位）。

integer(4) function cusparseSgpsvInterleavedBatch_bufferSize(handle, algo, m, ds, dl, d, du, dw, x, batchCount, pBufferSizeInBytes)
  type(cusparseHandle) :: handle
  integer(4) :: algo, m, batchCount
  real(4), device :: ds(*), dl(*), d(*), du(*), dw(*), x(*)
  integer(8) :: pBufferSizeInBytes

5.6.46. cusparseDgpsvInterleavedBatch_buffersize

DgpsvInterleavedBatch_buffersize 返回 DgpsvInterleavedBatch() 中所需的缓冲区大小（以字节为单位）。

integer(4) function cusparseDgpsvInterleavedBatch_bufferSize(handle, algo, m, ds, dl, d, du, dw, x, batchCount, pBufferSizeInBytes)
  type(cusparseHandle) :: handle
  integer(4) :: algo, m, batchCount
  real(8), device :: ds(*), dl(*), d(*), du(*), dw(*), x(*)
  integer(8) :: pBufferSizeInBytes

5.6.47. cusparseCgpsvInterleavedBatch_buffersize

CgpsvInterleavedBatch_buffersize 返回 CgpsvInterleavedBatch() 中所需的缓冲区大小（以字节为单位）。

integer(4) function cusparseCgpsvInterleavedBatch_bufferSize(handle, algo, m, ds, dl, d, du, dw, x, batchCount, pBufferSizeInBytes)
  type(cusparseHandle) :: handle
  integer(4) :: algo, m, batchCount
  complex(4), device :: ds(*), dl(*), d(*), du(*), dw(*), x(*)
  integer(8) :: pBufferSizeInBytes

5.6.48. cusparseZgpsvInterleavedBatch_buffersize

ZgpsvInterleavedBatch_buffersize 返回 ZgpsvInterleavedBatch() 中所需的缓冲区大小（以字节为单位）。

integer(4) function cusparseZgpsvInterleavedBatch_bufferSize(handle, algo, m, ds, dl, d, du, dw, x, batchCount, pBufferSizeInBytes)
  type(cusparseHandle) :: handle
  integer(4) :: algo, m, batchCount
  complex(8), device :: ds(*), dl(*), d(*), du(*), dw(*), x(*)
  integer(8) :: pBufferSizeInBytes

5.6.49. cusparseSgpsvInterleavedBatch

SgpsvInterleavedBatch 计算具有多个右端项的多个五对角线性系统的解：A * X = B。每个五对角线性系统的系数矩阵 A 由与其下对角线 (ds, dl)、主对角线 (d) 和上对角线 (du, dw) 相对应的五个向量定义；右端项存储在稠密矩阵 B 中。解 X 在退出时会覆盖右端项矩阵 B。此例程与 StridedBatch 例程的不同之处在于，对角线、RHS 和解向量的数据是交错存储的，从一个批次到 batchCount，而不是一个接一个地存储。有关当前支持的 algo 值，请参阅 cuSPARSE 库文档。

integer(4) function cusparseSgpsvInterleavedBatch(handle, algo, m, ds, dl, d, du, dw, x, batchCount, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: algo, m, batchCount
  real(4), device :: ds(*), dl(*), d(*), du(*), dw(*), x(*)
  character(1), device :: pBuffer(*)

5.6.50. cusparseDgpsvInterleavedBatch

DgpsvInterleavedBatch 计算具有多个右端项的多个五对角线性系统的解：A * X = B。每个五对角线性系统的系数矩阵 A 由与其下对角线 (ds, dl)、主对角线 (d) 和上对角线 (du, dw) 相对应的五个向量定义；右端项存储在稠密矩阵 B 中。解 X 在退出时会覆盖右端项矩阵 B。此例程与 StridedBatch 例程的不同之处在于，对角线、RHS 和解向量的数据是交错存储的，从一个批次到 batchCount，而不是一个接一个地存储。有关当前支持的 algo 值，请参阅 cuSPARSE 库文档。

integer(4) function cusparseDgpsvInterleavedBatch(handle, algo, m, ds, dl, d, du, dw, x, batchCount, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: algo, m, batchCount
  real(8), device :: ds(*), dl(*), d(*), du(*), dw(*), x(*)
  character(1), device :: pBuffer(*)

5.6.51. cusparseCgpsvInterleavedBatch

CgpsvInterleavedBatch 计算具有多个右端项的多个五对角线性系统的解：A * X = B。每个五对角线性系统的系数矩阵 A 由与其下对角线 (ds, dl)、主对角线 (d) 和上对角线 (du, dw) 相对应的五个向量定义；右端项存储在稠密矩阵 B 中。解 X 在退出时会覆盖右端项矩阵 B。此例程与 StridedBatch 例程的不同之处在于，对角线、RHS 和解向量的数据是交错存储的，从一个批次到 batchCount，而不是一个接一个地存储。有关当前支持的 algo 值，请参阅 cuSPARSE 库文档。

integer(4) function cusparseCgpsvInterleavedBatch(handle, algo, m, ds, dl, d, du, dw, x, batchCount, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: algo, m, batchCount
  complex(4), device :: ds(*), dl(*), d(*), du(*), dw(*), x(*)
  character(1), device :: pBuffer(*)

5.6.52. cusparseZgpsvInterleavedBatch

ZgpsvInterleavedBatch 计算具有多个右端项的多个五对角线性系统的解：A * X = B。每个五对角线性系统的系数矩阵 A 由与其下对角线 (ds, dl)、主对角线 (d) 和上对角线 (du, dw) 相对应的五个向量定义；右端项存储在稠密矩阵 B 中。解 X 在退出时会覆盖右端项矩阵 B。此例程与 StridedBatch 例程的不同之处在于，对角线、RHS 和解向量的数据是交错存储的，从一个批次到 batchCount，而不是一个接一个地存储。有关当前支持的 algo 值，请参阅 cuSPARSE 库文档。

integer(4) function cusparseZgpsvInterleavedBatch(handle, algo, m, ds, dl, d, du, dw, x, batchCount, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: algo, m, batchCount
  complex(8), device :: ds(*), dl(*), d(*), du(*), dw(*), x(*)
  character(1), device :: pBuffer(*)

5.6.53. cusparseScsric02_bufferSize

此函数返回 csric02 中使用的缓冲区大小。

integer(4) function cusparseScsric02_bufferSize(handle, m, nnz, descrA, csrValA, csrRowPtrA, csrColIndA, info, pBufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: m, nnz
  type(cusparseMatDescr) :: descrA
  real(4), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseCsric02Info) :: info
  integer(4) :: pBufferSize ! integer(8) also accepted

5.6.54. cusparseDcsric02_bufferSize

此函数返回 csric02 中使用的缓冲区大小。

integer(4) function cusparseDcsric02_bufferSize(handle, m, nnz, descrA, csrValA, csrRowPtrA, csrColIndA, info, pBufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: m, nnz
  type(cusparseMatDescr) :: descrA
  real(8), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseCsric02Info) :: info
  integer(4) :: pBufferSize ! integer(8) also accepted

5.6.55. cusparseCcsric02_bufferSize

此函数返回 csric02 中使用的缓冲区大小。

integer(4) function cusparseCcsric02_bufferSize(handle, m, nnz, descrA, csrValA, csrRowPtrA, csrColIndA, info, pBufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: m, nnz
  type(cusparseMatDescr) :: descrA
  complex(4), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseCsric02Info) :: info
  integer(4) :: pBufferSize ! integer(8) also accepted

5.6.56. cusparseZcsric02_bufferSize

此函数返回 csric02 中使用的缓冲区大小。

integer(4) function cusparseZcsric02_bufferSize(handle, m, nnz, descrA, csrValA, csrRowPtrA, csrColIndA, info, pBufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: m, nnz
  type(cusparseMatDescr) :: descrA
  complex(8), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseCsric02Info) :: info
  integer(4) :: pBufferSize ! integer(8) also accepted

5.6.57. cusparseScsric02_analysis

此函数执行 csric02 的分析阶段。

integer(4) function cusparseScsric02_analysis(handle, m, nnz, descrA, csrValA, csrRowPtrA, csrColIndA, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: m, nnz
  type(cusparseMatDescr) :: descrA
  real(4), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseCsric02Info) :: info
  integer(4) :: policy
  character(c_char), device :: pBuffer(*)

5.6.58. cusparseDcsric02_analysis

此函数执行 csric02 的分析阶段。

integer(4) function cusparseDcsric02_analysis(handle, m, nnz, descrA, csrValA, csrRowPtrA, csrColIndA, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: m, nnz
  type(cusparseMatDescr) :: descrA
  real(8), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseCsric02Info) :: info
  integer(4) :: policy
  character(c_char), device :: pBuffer(*)

5.6.59. cusparseCcsric02_analysis

此函数执行 csric02 的分析阶段。

integer(4) function cusparseCcsric02_analysis(handle, m, nnz, descrA, csrValA, csrRowPtrA, csrColIndA, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: m, nnz
  type(cusparseMatDescr) :: descrA
  complex(4), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseCsric02Info) :: info
  integer(4) :: policy
  character(c_char), device :: pBuffer(*)

5.6.60. cusparseZcsric02_analysis

此函数执行 csric02 的分析阶段。

integer(4) function cusparseZcsric02_analysis(handle, m, nnz, descrA, csrValA, csrRowPtrA, csrColIndA, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: m, nnz
  type(cusparseMatDescr) :: descrA
  complex(8), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseCsric02Info) :: info
  integer(4) :: policy
  character(c_char), device :: pBuffer(*)

5.6.61. cusparseScsric02

CSRIC02 执行计算不完全 Cholesky 分解的求解阶段，该分解具有零填充且无旋转。

integer(4) function cusparseScsric02(handle, m, nnz, descrA, csrValA, csrRowPtrA, csrColIndA, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: m, nnz
  type(cusparseMatDescr) :: descrA
  real(4), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseCsric02Info) :: info
  integer(4) :: policy
  character(c_char), device :: pBuffer(*)

5.6.62. cusparseDcsric02

CSRIC02 执行计算不完全 Cholesky 分解的求解阶段，该分解具有零填充且无旋转。

integer(4) function cusparseDcsric02(handle, m, nnz, descrA, csrValA, csrRowPtrA, csrColIndA, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: m, nnz
  type(cusparseMatDescr) :: descrA
  real(8), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseCsric02Info) :: info
  integer(4) :: policy
  character(c_char), device :: pBuffer(*)

5.6.63. cusparseCcsric02

CSRIC02 执行计算不完全 Cholesky 分解的求解阶段，该分解具有零填充且无旋转。

integer(4) function cusparseCcsric02(handle, m, nnz, descrA, csrValA, csrRowPtrA, csrColIndA, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: m, nnz
  type(cusparseMatDescr) :: descrA
  complex(4), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseCsric02Info) :: info
  integer(4) :: policy
  character(c_char), device :: pBuffer(*)

5.6.64. cusparseZcsric02

CSRIC02 执行计算不完全 Cholesky 分解的求解阶段，该分解具有零填充且无旋转。

integer(4) function cusparseZcsric02(handle, m, nnz, descrA, csrValA, csrRowPtrA, csrColIndA, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: m, nnz
  type(cusparseMatDescr) :: descrA
  complex(8), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseCsric02Info) :: info
  integer(4) :: policy
  character(c_char), device :: pBuffer(*)

5.6.65. cusparseXcsric02_zeroPivot

当 A(j,j) 是结构零或数值零时，此函数返回等于 CUSPARSE_STATUS_ZERO_PIVOT 的错误代码，并将 position 设置为 j。否则，position 将设置为 -1。

integer(4) function cusparseXcsric02_zeroPivot(handle, info, position)
  type(cusparseHandle) :: handle
  type(cusparseCsric02Info) :: info
  integer(4), device :: position ! device or host variable

5.6.66. cusparseScsrilu02_numericBoost

此函数根据 tol 输入参数，提升值以替换不完全 LU 分解中的数值。

integer(4) function cusparseScsrilu02_numericBoost(handle, info, enable_boost, tol, boost_val)
  type(cusparseHandle) :: handle
  type(cusparseCsrilu02Info) :: info
  integer :: enable_boost
  real(8), device :: tol ! device or host variable
  real(4), device :: boost_val ! device or host variable

5.6.67. cusparseDcsrilu02_numericBoost

此函数根据 tol 输入参数，提升值以替换不完全 LU 分解中的数值。

integer(4) function cusparseDcsrilu02_numericBoost(handle, info, enable_boost, tol, boost_val)
  type(cusparseHandle) :: handle
  type(cusparseCsrilu02Info) :: info
  integer :: enable_boost
  real(8), device :: tol ! device or host variable
  real(8), device :: boost_val ! device or host variable

5.6.68. cusparseCcsrilu02_numericBoost

此函数根据 tol 输入参数，提升值以替换不完全 LU 分解中的数值。

integer(4) function cusparseCcsrilu02_numericBoost(handle, info, enable_boost, tol, boost_val)
  type(cusparseHandle) :: handle
  type(cusparseCsrilu02Info) :: info
  integer :: enable_boost
  real(8), device :: tol ! device or host variable
  complex(4), device :: boost_val ! device or host variable

5.6.69. cusparseZcsrilu02_numericBoost

此函数根据 tol 输入参数，提升值以替换不完全 LU 分解中的数值。

integer(4) function cusparseZcsrilu02_numericBoost(handle, info, enable_boost, tol, boost_val)
  type(cusparseHandle) :: handle
  type(cusparseCsrilu02Info) :: info
  integer :: enable_boost
  real(8), device :: tol ! device or host variable
  complex(8), device :: boost_val ! device or host variable

5.6.70. cusparseScsrilu02_bufferSize

此函数返回 csrilu02 中使用的缓冲区大小。

integer(4) function cusparseScsrilu02_bufferSize(handle, m, nnz, descrA, csrValA, csrRowPtrA, csrColIndA, info, pBufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: m, nnz
  type(cusparseMatDescr) :: descrA
  real(4), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseCsrilu02Info) :: info
  integer(4) :: pBufferSize ! integer(8) also accepted

5.6.71. cusparseDcsrilu02_bufferSize

此函数返回 csrilu02 中使用的缓冲区大小。

integer(4) function cusparseDcsrilu02_bufferSize(handle, m, nnz, descrA, csrValA, csrRowPtrA, csrColIndA, info, pBufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: m, nnz
  type(cusparseMatDescr) :: descrA
  real(8), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseCsrilu02Info) :: info
  integer(4) :: pBufferSize ! integer(8) also accepted

5.6.72. cusparseCcsrilu02_bufferSize

此函数返回 csrilu02 中使用的缓冲区大小。

integer(4) function cusparseCcsrilu02_bufferSize(handle, m, nnz, descrA, csrValA, csrRowPtrA, csrColIndA, info, pBufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: m, nnz
  type(cusparseMatDescr) :: descrA
  complex(4), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseCsrilu02Info) :: info
  integer(4) :: pBufferSize ! integer(8) also accepted

5.6.73. cusparseZcsrilu02_bufferSize

此函数返回 csrilu02 中使用的缓冲区大小。

integer(4) function cusparseZcsrilu02_bufferSize(handle, m, nnz, descrA, csrValA, csrRowPtrA, csrColIndA, info, pBufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: m, nnz
  type(cusparseMatDescr) :: descrA
  complex(8), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseCsrilu02Info) :: info
  integer(4) :: pBufferSize ! integer(8) also accepted

5.6.74. cusparseScsrilu02_analysis

此函数执行 csrilu02 的分析阶段。

integer(4) function cusparseScsrilu02_analysis(handle, m, nnz, descrA, csrValA, csrRowPtrA, csrColIndA, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: m, nnz
  type(cusparseMatDescr) :: descrA
  real(4), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseCsrilu02Info) :: info
  integer(4) :: policy
  character(c_char), device :: pBuffer(*)

5.6.75. cusparseDcsrilu02_analysis

此函数执行 csrilu02 的分析阶段。

integer(4) function cusparseDcsrilu02_analysis(handle, m, nnz, descrA, csrValA, csrRowPtrA, csrColIndA, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: m, nnz
  type(cusparseMatDescr) :: descrA
  real(8), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseCsrilu02Info) :: info
  integer(4) :: policy
  character(c_char), device :: pBuffer(*)

5.6.76. cusparseCcsrilu02_analysis

此函数执行 csrilu02 的分析阶段。

integer(4) function cusparseCcsrilu02_analysis(handle, m, nnz, descrA, csrValA, csrRowPtrA, csrColIndA, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: m, nnz
  type(cusparseMatDescr) :: descrA
  complex(4), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseCsrilu02Info) :: info
  integer(4) :: policy
  character(c_char), device :: pBuffer(*)

5.6.77. cusparseZcsrilu02_analysis

此函数执行 csrilu02 的分析阶段。

integer(4) function cusparseZcsrilu02_analysis(handle, m, nnz, descrA, csrValA, csrRowPtrA, csrColIndA, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: m, nnz
  type(cusparseMatDescr) :: descrA
  complex(8), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseCsrilu02Info) :: info
  integer(4) :: policy
  character(c_char), device :: pBuffer(*)

5.6.78. cusparseScsrilu02

CSRILU02 执行不完全 LU 分解的求解阶段，该分解具有零填充且无旋转。A 是一个 m x m 稀疏矩阵，它由三个数组 csrValA_valM、csrRowPtrA 和 csrColIndA 以 CSR 存储格式定义。

integer(4) function cusparseScsrilu02(handle, m, nnz, descrA,
  type(cusparseHandle) :: handle
  integer(4) :: m, nnz
  type(cusparseMatDescr) :: descrA
  real(4), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseCsrilu02Info) :: info
  integer(4) :: policy
  character(c_char), device :: pBuffer(*)

5.6.79. cusparseDcsrilu02

CSRILU02 执行不完全 LU 分解的求解阶段，该分解具有零填充且无旋转。A 是一个 m x m 稀疏矩阵，它由三个数组 csrValA_valM、csrRowPtrA 和 csrColIndA 以 CSR 存储格式定义。

integer(4) function cusparseDcsrilu02(handle, m, nnz, descrA, csrValA, csrRowPtrA, csrColIndA, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: m, nnz
  type(cusparseMatDescr) :: descrA
  real(8), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseCsrilu02Info) :: info
  integer(4) :: policy
  character(c_char), device :: pBuffer(*)

5.6.80. cusparseCcsrilu02

CSRILU02 执行不完全 LU 分解的求解阶段，该分解具有零填充且无旋转。A 是一个 m x m 稀疏矩阵，它由三个数组 csrValA_valM、csrRowPtrA 和 csrColIndA 以 CSR 存储格式定义。

integer(4) function cusparseCcsrilu02(handle, m, nnz, descrA, csrValA, csrRowPtrA, csrColIndA, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: m, nnz
  type(cusparseMatDescr) :: descrA
  complex(4), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseCsrilu02Info) :: info
  integer(4) :: policy
  character(c_char), device :: pBuffer(*)

5.6.81. cusparseZcsrilu02

CSRILU02 执行不完全 LU 分解的求解阶段，该分解具有零填充且无旋转。A 是一个 m x m 稀疏矩阵，它由三个数组 csrValA_valM、csrRowPtrA 和 csrColIndA 以 CSR 存储格式定义。

integer(4) function cusparseZcsrilu02(handle, m, nnz, descrA, csrValA, csrRowPtrA, csrColIndA, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: m, nnz
  type(cusparseMatDescr) :: descrA
  complex(8), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseCsrilu02Info) :: info
  integer(4) :: policy
  character(c_char), device :: pBuffer(*)

5.6.82. cusparseXcsrilu02_zeroPivot

当 A(j,j) 是结构零或数值零时，此函数返回等于 CUSPARSE_STATUS_ZERO_PIVOT 的错误代码，并将 position 设置为 j。否则，position 将设置为 -1。

integer(4) function cusparseXcsrilu02_zeroPivot(handle, info, position)
  type(cusparseHandle) :: handle
  type(cusparseCsrilu02Info) :: info
  integer(4), device :: position ! device or host variable

5.6.83. cusparseSbsric02_bufferSize

此函数返回 bsric02 中使用的缓冲区大小。

integer(4) function cusparseSbsric02_bufferSize(handle, dirA, mb, nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, pBufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: dirA
  integer(4) :: mb, nnzb
  type(cusparseMatDescr) :: descrA
  real(4), device :: bsrValA(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer(4) :: blockDim
  type(cusparseBsric02Info) :: info
  integer(4) :: pBufferSize ! integer(8) also accepted

5.6.84. cusparseDbsric02_bufferSize

此函数返回 bsric02 中使用的缓冲区大小。

integer(4) function cusparseDbsric02_bufferSize(handle, dirA, mb, nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, pBufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: dirA
  integer(4) :: mb, nnzb
  type(cusparseMatDescr) :: descrA
  real(8), device :: bsrValA(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer(4) :: blockDim
  type(cusparseBsric02Info) :: info
  integer(4) :: pBufferSize ! integer(8) also accepted

5.6.85. cusparseCbsric02_bufferSize

此函数返回 bsric02 中使用的缓冲区大小。

integer(4) function cusparseCbsric02_bufferSize(handle, dirA, mb, nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, pBufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: dirA
  integer(4) :: mb, nnzb
  type(cusparseMatDescr) :: descrA
  complex(4), device :: bsrValA(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer(4) :: blockDim
  type(cusparseBsric02Info) :: info
  integer(4) :: pBufferSize ! integer(8) also accepted

5.6.86. cusparseZbsric02_bufferSize

此函数返回 bsric02 中使用的缓冲区大小。

integer(4) function cusparseZbsric02_bufferSize(handle, dirA, mb, nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, pBufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: dirA
  integer(4) :: mb, nnzb
  type(cusparseMatDescr) :: descrA
  complex(8), device :: bsrValA(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer(4) :: blockDim
  type(cusparseBsric02Info) :: info
  integer(4) :: pBufferSize ! integer(8) also accepted

5.6.87. cusparseSbsric02_analysis

此函数执行 bsric02 的分析阶段。

integer(4) function cusparseSbsric02_analysis(handle, dirA, mb, nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: dirA
  integer(4) :: mb, nnzb
  type(cusparseMatDescr) :: descrA
  real(4), device :: bsrValA(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer(4) :: blockDim
  type(cusparseBsric02Info) :: info
  integer(4) :: policy
  character(c_char), device :: pBuffer(*)

5.6.88. cusparseDbsric02_analysis

此函数执行 bsric02 的分析阶段。

integer(4) function cusparseDbsric02_analysis(handle, dirA, mb, nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: dirA
  integer(4) :: mb, nnzb
  type(cusparseMatDescr) :: descrA
  real(8), device :: bsrValA(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer(4) :: blockDim
  type(cusparseBsric02Info) :: info
  integer(4) :: policy
  character(c_char), device :: pBuffer(*)

5.6.89. cusparseCbsric02_analysis

此函数执行 bsric02 的分析阶段。

integer(4) function cusparseCbsric02_analysis(handle, dirA, mb, nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: dirA
  integer(4) :: mb, nnzb
  type(cusparseMatDescr) :: descrA
  complex(4), device :: bsrValA(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer(4) :: blockDim
  type(cusparseBsric02Info) :: info
  integer(4) :: policy
  character(c_char), device :: pBuffer(*)

5.6.90. cusparseZbsric02_analysis

此函数执行 bsric02 的分析阶段。

integer(4) function cusparseZbsric02_analysis(handle, dirA, mb, nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: dirA
  integer(4) :: mb, nnzb
  type(cusparseMatDescr) :: descrA
  complex(8), device :: bsrValA(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer(4) :: blockDim
  type(cusparseBsric02Info) :: info
  integer(4) :: policy
  character(c_char), device :: pBuffer(*)

5.6.91. cusparseSbsric02

BSRIC02 执行不完全 Cholesky 分解的求解阶段，该分解具有零填充且无旋转。A 是一个 (mb*blockDim) x (mb*blockDim) 稀疏矩阵，它由三个数组 bsrValA、bsrRowPtrA 和 bsrColIndA 以 BSR 存储格式定义。

integer(4) function cusparseSbsric02(handle, dirA, mb, nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: dirA
  integer(4) :: mb, nnzb
  type(cusparseMatDescr) :: descrA
  real(4), device :: bsrValA(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer(4) :: blockDim
  type(cusparseBsric02Info) :: info
  integer(4) :: policy
  character(c_char), device :: pBuffer(*)

5.6.92. cusparseDbsric02

BSRIC02 执行不完全 Cholesky 分解的求解阶段，该分解具有零填充且无旋转。A 是一个 (mb*blockDim) x (mb*blockDim) 稀疏矩阵，它由三个数组 bsrValA、bsrRowPtrA 和 bsrColIndA 以 BSR 存储格式定义。

integer(4) function cusparseDbsric02(handle, dirA, mb, nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: dirA
  integer(4) :: mb, nnzb
  type(cusparseMatDescr) :: descrA
  real(8), device :: bsrValA(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer(4) :: blockDim
  type(cusparseBsric02Info) :: info
  integer(4) :: policy
  character(c_char), device :: pBuffer(*)

5.6.93. cusparseCbsric02

BSRIC02 执行不完全 Cholesky 分解的求解阶段，该分解具有零填充且无旋转。A 是一个 (mb*blockDim) x (mb*blockDim) 稀疏矩阵，它由三个数组 bsrValA、bsrRowPtrA 和 bsrColIndA 以 BSR 存储格式定义。

integer(4) function cusparseCbsric02(handle, dirA, mb, nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: dirA
  integer(4) :: mb, nnzb
  type(cusparseMatDescr) :: descrA
  complex(4), device :: bsrValA(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer(4) :: blockDim
  type(cusparseBsric02Info) :: info
  integer(4) :: policy
  character(c_char), device :: pBuffer(*)

5.6.94. cusparseZbsric02

BSRIC02 执行不完全 Cholesky 分解的求解阶段，该分解具有零填充且无旋转。A 是一个 (mb*blockDim) x (mb*blockDim) 稀疏矩阵，它由三个数组 bsrValA、bsrRowPtrA 和 bsrColIndA 以 BSR 存储格式定义。

integer(4) function cusparseZbsric02(handle, dirA, mb, nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: dirA
  integer(4) :: mb, nnzb
  type(cusparseMatDescr) :: descrA
  complex(8), device :: bsrValA(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer(4) :: blockDim
  type(cusparseBsric02Info) :: info
  integer(4) :: policy
  character(c_char), device :: pBuffer(*)

5.6.95. cusparseXbsric02_zeroPivot

当 A(j,j) 是结构零或数值零时，此函数返回等于 CUSPARSE_STATUS_ZERO_PIVOT 的错误代码，并将 position 设置为 j。否则，position 将设置为 -1。

integer(4) function cusparseXbsric02_zeroPivot(handle, info, position)
  type(cusparseHandle) :: handle
  type(cusparseBsric02Info) :: info
  integer(4), device :: position ! device or host variable

5.6.96. cusparseSbsrilu02_numericBoost

此函数根据 tol 输入参数，提升值以替换不完全 LU 分解中的数值。

integer(4) function cusparseSbsrilu02_numericBoost(handle, info, enable_boost, tol, boost_val)
  type(cusparseHandle) :: handle
  type(cusparseBsrilu02Info) :: info
  integer :: enable_boost
  real(8), device :: tol ! device or host variable
  real(4), device :: boost_val ! device or host variable

5.6.97. cusparseDbsrilu02_numericBoost

此函数根据 tol 输入参数，提升值以替换不完全 LU 分解中的数值。

integer(4) function cusparseDbsrilu02_numericBoost(handle, info, enable_boost, tol, boost_val)
  type(cusparseHandle) :: handle
  type(cusparseBsrilu02Info) :: info
  integer :: enable_boost
  real(8), device :: tol ! device or host variable
  real(8), device :: boost_val ! device or host variable

5.6.98. cusparseCbsrilu02_numericBoost

此函数根据 tol 输入参数，提升值以替换不完全 LU 分解中的数值。

integer(4) function cusparseCbsrilu02_numericBoost(handle, info, enable_boost, tol, boost_val)
  type(cusparseHandle) :: handle
  type(cusparseBsrilu02Info) :: info
  integer :: enable_boost
  real(8), device :: tol ! device or host variable
  complex(4), device :: boost_val ! device or host variable

5.6.99. cusparseZbsrilu02_numericBoost

此函数根据 tol 输入参数，提升值以替换不完全 LU 分解中的数值。

integer(4) function cusparseZbsrilu02_numericBoost(handle, info, enable_boost, tol, boost_val)
  type(cusparseHandle) :: handle
  type(cusparseBsrilu02Info) :: info
  integer :: enable_boost
  real(8), device :: tol ! device or host variable
  complex(8), device :: boost_val ! device or host variable

5.6.100. cusparseSbsrilu02_bufferSize

此函数返回 bsrilu02 中使用的缓冲区大小。

integer(4) function cusparseSbsrilu02_bufferSize(handle, dirA, mb, nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, pBufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: dirA
  integer(4) :: mb, nnzb
  type(cusparseMatDescr) :: descrA
  real(4), device :: bsrValA(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer(4) :: blockDim
  type(cusparseBsrilu02Info) :: info
  integer(4) :: pBufferSize ! integer(8) also accepted

5.6.101. cusparseDbsrilu02_bufferSize

此函数返回 bsrilu02 中使用的缓冲区大小。

integer(4) function cusparseDbsrilu02_bufferSize(handle, dirA, mb, nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, pBufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: dirA
  integer(4) :: mb, nnzb
  type(cusparseMatDescr) :: descrA
  real(8), device :: bsrValA(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer(4) :: blockDim
  type(cusparseBsrilu02Info) :: info
  integer(4) :: pBufferSize ! integer(8) also accepted

5.6.102. cusparseCbsrilu02_bufferSize

此函数返回 bsrilu02 中使用的缓冲区大小。

integer(4) function cusparseCbsrilu02_bufferSize(handle, dirA, mb, nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, pBufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: dirA
  integer(4) :: mb, nnzb
  type(cusparseMatDescr) :: descrA
  complex(4), device :: bsrValA(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer(4) :: blockDim
  type(cusparseBsrilu02Info) :: info
  integer(4) :: pBufferSize ! integer(8) also accepted

5.6.103. cusparseZbsrilu02_bufferSize

此函数返回 bsrilu02 中使用的缓冲区大小。

integer(4) function cusparseZbsrilu02_bufferSize(handle, dirA, mb, nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, pBufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: dirA
  integer(4) :: mb, nnzb
  type(cusparseMatDescr) :: descrA
  complex(8), device :: bsrValA(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer(4) :: blockDim
  type(cusparseBsrilu02Info) :: info
  integer(4) :: pBufferSize ! integer(8) also accepted

5.6.104. cusparseSbsrilu02_analysis

此函数执行 bsrilu02 的分析阶段。

integer(4) function cusparseSbsrilu02_analysis(handle, dirA, mb, nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: dirA
  integer(4) :: mb, nnzb
  type(cusparseMatDescr) :: descrA
  real(4), device :: bsrValA(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer(4) :: blockDim
  type(cusparseBsrilu02Info) :: info
  integer(4) :: policy
  character(c_char), device :: pBuffer(*)

5.6.105. cusparseDbsrilu02_analysis

此函数执行 bsrilu02 的分析阶段。

integer(4) function cusparseDbsrilu02_analysis(handle, dirA, mb, nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: dirA
  integer(4) :: mb, nnzb
  type(cusparseMatDescr) :: descrA
  real(8), device :: bsrValA(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer(4) :: blockDim
  type(cusparseBsrilu02Info) :: info
  integer(4) :: policy
  character(c_char), device :: pBuffer(*)

5.6.106. cusparseCbsrilu02_analysis

此函数执行 bsrilu02 的分析阶段。

integer(4) function cusparseCbsrilu02_analysis(handle, dirA, mb, nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: dirA
  integer(4) :: mb, nnzb
  type(cusparseMatDescr) :: descrA
  complex(4), device :: bsrValA(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer(4) :: blockDim
  type(cusparseBsrilu02Info) :: info
  integer(4) :: policy
  character(c_char), device :: pBuffer(*)

5.6.107. cusparseZbsrilu02_analysis

此函数执行 bsrilu02 的分析阶段。

integer(4) function cusparseZbsrilu02_analysis(handle, dirA, mb, nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: dirA
  integer(4) :: mb, nnzb
  type(cusparseMatDescr) :: descrA
  complex(8), device :: bsrValA(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer(4) :: blockDim
  type(cusparseBsrilu02Info) :: info
  integer(4) :: policy
  character(c_char), device :: pBuffer(*)

5.6.108. cusparseSbsrilu02

BSRILU02 执行不完全 LU 分解的求解阶段，该分解具有零填充且无旋转。A 是一个 (mb*blockDim) x (mb*blockDim) 稀疏矩阵，它由三个数组 bsrValA、bsrRowPtrA 和 bsrColIndA 以 BSR 存储格式定义。

integer(4) function cusparseSbsrilu02(handle, dirA, mb, nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: dirA
  integer(4) :: mb, nnzb
  type(cusparseMatDescr) :: descrA
  real(4), device :: bsrValA(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer(4) :: blockDim
  type(cusparseBsrilu02Info) :: info
  integer(4) :: policy
  character(c_char), device :: pBuffer(*)

5.6.109. cusparseDbsrilu02

BSRILU02 执行不完全 LU 分解的求解阶段，该分解具有零填充且无旋转。A 是一个 (mb*blockDim) x (mb*blockDim) 稀疏矩阵，它由三个数组 bsrValA、bsrRowPtrA 和 bsrColIndA 以 BSR 存储格式定义。

integer(4) function cusparseDbsrilu02(handle, dirA, mb, nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: dirA
  integer(4) :: mb, nnzb
  type(cusparseMatDescr) :: descrA
  real(8), device :: bsrValA(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer(4) :: blockDim
  type(cusparseBsrilu02Info) :: info
  integer(4) :: policy
  character(c_char), device :: pBuffer(*)

5.6.110. cusparseCbsrilu02

BSRILU02 执行不完全 LU 分解的求解阶段，该分解具有零填充且无旋转。A 是一个 (mb*blockDim) x (mb*blockDim) 稀疏矩阵，它由三个数组 bsrValA、bsrRowPtrA 和 bsrColIndA 以 BSR 存储格式定义。

integer(4) function cusparseCbsrilu02(handle, dirA, mb, nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: dirA
  integer(4) :: mb, nnzb
  type(cusparseMatDescr) :: descrA
  complex(4), device :: bsrValA(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer(4) :: blockDim
  type(cusparseBsrilu02Info) :: info
  integer(4) :: policy
  character(c_char), device :: pBuffer(*)

5.6.111. cusparseZbsrilu02

BSRILU02 执行不完全 LU 分解的求解阶段，该分解具有零填充且无旋转。A 是一个 (mb*blockDim) x (mb*blockDim) 稀疏矩阵，它由三个数组 bsrValA、bsrRowPtrA 和 bsrColIndA 以 BSR 存储格式定义。

integer(4) function cusparseZbsrilu02(handle, dirA, mb, nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, info, policy, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: dirA
  integer(4) :: mb, nnzb
  type(cusparseMatDescr) :: descrA
  complex(8), device :: bsrValA(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer(4) :: blockDim
  type(cusparseBsrilu02Info) :: info
  integer(4) :: policy
  character(c_char), device :: pBuffer(*)

5.6.112. cusparseXbsrilu02_zeroPivot

当 A(j,j) 是结构零或数值零时，此函数返回等于 CUSPARSE_STATUS_ZERO_PIVOT 的错误代码，并将 position 设置为 j。否则，position 将设置为 -1。

integer(4) function cusparseXbsrilu02_zeroPivot(handle, info, position)
  type(cusparseHandle) :: handle
  type(cusparseBsrilu02Info) :: info
  integer(4), device :: position ! device or host variable

5.7. CUSPARSE 重排序函数

本节包含用于操作稀疏矩阵的重排序函数的接口。

5.7.1. cusparseScsrColor

此函数执行与以 CSR 格式存储的矩阵 A 关联的邻接图的着色。

integer(4) function cusparseScsrColor(handle, m, nnz, descrA, csrValA, csrRowPtrA, csrColIndA, fractionToColor, ncolors, coloring, reordering, info)
  type(cusparseHandle) :: handle
  type(cusparseMatDescr) :: descrA
  type(cusparseColorInfo) :: info
  integer :: m, nnz
  real(4), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*), coloring(*), reordering(*)
  real(4), device :: fractionToColor ! device or host variable
  integer(4), device :: ncolors ! device or host variable

5.7.2. cusparseDcsrColor

此函数执行与以 CSR 格式存储的矩阵 A 关联的邻接图的着色。

integer(4) function cusparseDcsrColor(handle, m, nnz, descrA, csrValA, csrRowPtrA, csrColIndA, fractionToColor, ncolors, coloring, reordering, info)
  type(cusparseHandle) :: handle
  type(cusparseMatDescr) :: descrA
  type(cusparseColorInfo) :: info
  integer :: m, nnz
  real(8), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*), coloring(*), reordering(*)
  real(8), device :: fractionToColor ! device or host variable
  integer(4), device :: ncolors ! device or host variable

5.7.3. cusparseCcsrColor

此函数执行与以 CSR 格式存储的矩阵 A 关联的邻接图的着色。

integer(4) function cusparseCcsrColor(handle, m, nnz, descrA, csrValA, csrRowPtrA, csrColIndA, fractionToColor, ncolors, coloring, reordering, info)
  type(cusparseHandle) :: handle
  type(cusparseMatDescr) :: descrA
  type(cusparseColorInfo) :: info
  integer :: m, nnz
  complex(4), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*), coloring(*), reordering(*)
  real(4), device :: fractionToColor ! device or host variable
  integer(4), device :: ncolors ! device or host variable

5.7.4. cusparseZcsrColor

此函数执行与以 CSR 格式存储的矩阵 A 关联的邻接图的着色。

integer(4) function cusparseZcsrColor(handle, m, nnz, descrA, csrValA, csrRowPtrA, csrColIndA, fractionToColor, ncolors, coloring, reordering, info)
  type(cusparseHandle) :: handle
  type(cusparseMatDescr) :: descrA
  type(cusparseColorInfo) :: info
  integer :: m, nnz
  complex(8), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*), coloring(*), reordering(*)
  real(8), device :: fractionToColor ! device or host variable
  integer(4), device :: ncolors ! device or host variable

5.8. CUSPARSE 格式转换函数

本节包含用于在不同稀疏和稠密矩阵存储格式之间切换的转换函数的接口。

5.8.1. cusparseSbsr2csr

此函数将以 BSR 格式（由三个数组 bsrValA、bsrRowPtrA 和 bsrColIndA 定义）表示的稀疏矩阵转换为以 CSR 格式（由数组 csrValC、csrRowPtrC 和 csrColIndC 定义）表示的稀疏矩阵。

integer(4) function cusparseSbsr2csr(handle, dirA, nm, nb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, descrC, csrValC, csrRowPtrC, csrColIndC)
  type(cusparseHandle) :: handle
  integer(4) :: dirA, mb, nb, blockDim
  type(cusparseMatDescr) :: descrA, descrC
  real(4), device :: bsrValA(*), csrValC(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*), csrRowPtrC(*), csrColIndC(*)

5.8.2. cusparseDbsr2csr

此函数将以 BSR 格式（由三个数组 bsrValA、bsrRowPtrA 和 bsrColIndA 定义）表示的稀疏矩阵转换为以 CSR 格式（由数组 csrValC、csrRowPtrC 和 csrColIndC 定义）表示的稀疏矩阵。

integer(4) function cusparseDbsr2csr(handle, dirA, nm, nb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, descrC, csrValC, csrRowPtrC, csrColIndC)
  type(cusparseHandle) :: handle
  integer(4) :: dirA, mb, nb, blockDim
  type(cusparseMatDescr) :: descrA, descrC
  real(8), device :: bsrValA(*), csrValC(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*), csrRowPtrC(*), csrColIndC(*)

5.8.3. cusparseCbsr2csr

此函数将以 BSR 格式（由三个数组 bsrValA、bsrRowPtrA 和 bsrColIndA 定义）表示的稀疏矩阵转换为以 CSR 格式（由数组 csrValC、csrRowPtrC 和 csrColIndC 定义）表示的稀疏矩阵。

integer(4) function cusparseCbsr2csr(handle, dirA, nm, nb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, descrC, csrValC, csrRowPtrC, csrColIndC)
  type(cusparseHandle) :: handle
  integer(4) :: dirA, mb, nb, blockDim
  type(cusparseMatDescr) :: descrA, descrC
  complex(4), device :: bsrValA(*), csrValC(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*), csrRowPtrC(*), csrColIndC(*)

5.8.4. cusparseZbsr2csr

此函数将以 BSR 格式（由三个数组 bsrValA、bsrRowPtrA 和 bsrColIndA 定义）表示的稀疏矩阵转换为以 CSR 格式（由数组 csrValC、csrRowPtrC 和 csrColIndC 定义）表示的稀疏矩阵。

integer(4) function cusparseZbsr2csr(handle, dirA, nm, nb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, blockDim, descrC, csrValC, csrRowPtrC, csrColIndC)
  type(cusparseHandle) :: handle
  integer(4) :: dirA, mb, nb, blockDim
  type(cusparseMatDescr) :: descrA, descrC
  complex(8), device :: bsrValA(*), csrValC(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*), csrRowPtrC(*), csrColIndC(*)

5.8.5. cusparseXcoo2csr

此函数将包含未压缩行索引（对应于 COO 格式）的数组转换为压缩行指针（对应于 CSR 格式）的数组。

integer(4) function cusparseXcoo2csr(handle, cooRowInd, nnz, m, csrRowPtr, idxBase)
  type(cusparseHandle) :: handle
  integer(4) :: nnz, m, idxBase
  integer(4), device :: cooRowInd(*), csrRowPtr(*)

5.8.6. cusparseScsc2dense

此函数将以 CSC 格式（由三个数组 cscValA、cscColPtrA 和 cscRowIndA 定义）表示的稀疏矩阵转换为稠密格式的矩阵 A。稠密矩阵 A 用稀疏矩阵的值填充，其余位置用零填充。

integer(4) function cusparseScsc2dense(handle, m, n, descrA, cscValA, cscRowIndA, cscColPtrA, A, lda)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, lda
  type(cusparseMatDescr) :: descrA
  real(4), device :: cscValA(*), A(*)
  integer(4), device :: cscRowIndA(*), cscColPtrA(*)

5.8.7. cusparseDcsc2dense

此函数将以 CSC 格式（由三个数组 cscValA、cscColPtrA 和 cscRowIndA 定义）表示的稀疏矩阵转换为稠密格式的矩阵 A。稠密矩阵 A 用稀疏矩阵的值填充，其余位置用零填充。

integer(4) function cusparseDcsc2dense(handle, m, n, descrA, cscValA, cscRowIndA, cscColPtrA, A, lda)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, lda
  type(cusparseMatDescr) :: descrA
  real(8), device :: cscValA(*), A(*)
  integer(4), device :: cscRowIndA(*), cscColPtrA(*)

5.8.8. cusparseCcsc2dense

此函数将以 CSC 格式（由三个数组 cscValA、cscColPtrA 和 cscRowIndA 定义）表示的稀疏矩阵转换为稠密格式的矩阵 A。稠密矩阵 A 用稀疏矩阵的值填充，其余位置用零填充。

integer(4) function cusparseCcsc2dense(handle, m, n, descrA, cscValA, cscRowIndA, cscColPtrA, A, lda)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, lda
  type(cusparseMatDescr) :: descrA
  complex(4), device :: cscValA(*), A(*)
  integer(4), device :: cscRowIndA(*), cscColPtrA(*)

5.8.9. cusparseZcsc2dense

此函数将以 CSC 格式（由三个数组 cscValA、cscColPtrA 和 cscRowIndA 定义）表示的稀疏矩阵转换为稠密格式的矩阵 A。稠密矩阵 A 用稀疏矩阵的值填充，其余位置用零填充。

integer(4) function cusparseZcsc2dense(handle, m, n, descrA, cscValA, cscRowIndA, cscColPtrA, A, lda)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, lda
  type(cusparseMatDescr) :: descrA
  complex(8), device :: cscValA(*), A(*)
  integer(4), device :: cscRowIndA(*), cscColPtrA(*)

5.8.10. cusparseScsc2hyb

此函数将以 CSC 格式（由三个数组 cscValA、cscColPtrA 和 cscRowIndA 定义）表示的稀疏矩阵转换为 HYB 格式的稀疏矩阵 A。

integer(4) function cusparseScsc2hyb(handle, m, n, descrA, cscValA, cscRowIndA, cscColPtrA, hybA, userEllWidth, partitionType)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, userEllWidth, partitionType
  type(cusparseMatDescr) :: descrA
  real(4), device :: cscValA(*)
  integer(4), device :: cscRowIndA(*), cscColPtrA(*)
  type(cusparseHybMat) :: hybA

5.8.11. cusparseDcsc2hyb

此函数将以 CSC 格式（由三个数组 cscValA、cscColPtrA 和 cscRowIndA 定义）表示的稀疏矩阵转换为 HYB 格式的稀疏矩阵 A。

integer(4) function cusparseDcsc2hyb(handle, m, n, descrA, cscValA, cscRowIndA, cscColPtrA, hybA, userEllWidth, partitionType)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, userEllWidth, partitionType
  type(cusparseMatDescr) :: descrA
  real(8), device :: cscValA(*)
  integer(4), device :: cscRowIndA(*), cscColPtrA(*)
  type(cusparseHybMat) :: hybA

5.8.12. cusparseCcsc2hyb

此函数将以 CSC 格式（由三个数组 cscValA、cscColPtrA 和 cscRowIndA 定义）表示的稀疏矩阵转换为 HYB 格式的稀疏矩阵 A。

integer(4) function cusparseCcsc2hyb(handle, m, n, descrA, cscValA, cscRowIndA, cscColPtrA, hybA, userEllWidth, partitionType)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, userEllWidth, partitionType
  type(cusparseMatDescr) :: descrA
  complex(4), device :: cscValA(*)
  integer(4), device :: cscRowIndA(*), cscColPtrA(*)
  type(cusparseHybMat) :: hybA

5.8.13. cusparseZcsc2hyb

此函数将以 CSC 格式（由三个数组 cscValA、cscColPtrA 和 cscRowIndA 定义）表示的稀疏矩阵转换为 HYB 格式的稀疏矩阵 A。

integer(4) function cusparseZcsc2hyb(handle, m, n, descrA, cscValA, cscRowIndA, cscColPtrA, hybA, userEllWidth, partitionType)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, userEllWidth, partitionType
  type(cusparseMatDescr) :: descrA
  complex(8), device :: cscValA(*)
  integer(4), device :: cscRowIndA(*), cscColPtrA(*)
  type(cusparseHybMat) :: hybA

5.8.14. cusparseXcsr2bsrNnz

cusparseXcsrgeamNnz 计算 CSRGEAM 将生成的非零元素的数量。

integer(4) function cusparseXcsr2bsrNnz(handle, dirA, m, n, descrA, csrRowPtrA, csrColIndA, blockDim, descrC, bsrRowPtrC, nnzTotalDevHostPtr)
  type(cusparseHandle) :: handle
  integer :: dirA, m, n, blockdim
  type(cusparseMatDescr) :: descrA, descrC
  integer(4), device :: csrRowPtrA(*), csrColIndA(*), bsrRowPtrC(*)
  integer(4), device :: nnzTotalDevHostPtr ! device or host variable

5.8.15. cusparseScsr2bsr

此函数将以 CSR 存储格式（由三个数组 csrValA、csrRowPtrA 和 csrColIndA 定义）表示的稀疏矩阵转换为以 BSR 格式（由数组 bsrValC、bsrRowPtrC 和 bsrColIndC 定义）表示的稀疏矩阵。

integer(4) function cusparseScsr2bsr(handle, dirA, m, n, descrA, csrValA, csrRowPtrA, csrColIndA, blockDim, descrC, bsrValC, bsrRowPtrC, bsrColIndC)
  type(cusparseHandle) :: handle
  integer(4) :: dirA, m, n, blockdim
  type(cusparseMatDescr) :: descrA, descrC
  real(4), device :: csrValA(*), bsrValC(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*), bsrRowPtrC(*), bsrColIndC(*)

5.8.16. cusparseDcsr2bsr

此函数将以 CSR 存储格式（由三个数组 csrValA、csrRowPtrA 和 csrColIndA 定义）表示的稀疏矩阵转换为以 BSR 格式（由数组 bsrValC、bsrRowPtrC 和 bsrColIndC 定义）表示的稀疏矩阵。

integer(4) function cusparseDcsr2bsr(handle, dirA, m, n, descrA, csrValA, csrRowPtrA, csrColIndA, blockDim, descrC, bsrValC, bsrRowPtrC, bsrColIndC)
  type(cusparseHandle) :: handle
  integer(4) :: dirA, m, n, blockdim
  type(cusparseMatDescr) :: descrA, descrC
  real(8), device :: csrValA(*), bsrValC(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*), bsrRowPtrC(*), bsrColIndC(*)

5.8.17. cusparseCcsr2bsr

此函数将以 CSR 存储格式（由三个数组 csrValA、csrRowPtrA 和 csrColIndA 定义）表示的稀疏矩阵转换为以 BSR 格式（由数组 bsrValC、bsrRowPtrC 和 bsrColIndC 定义）表示的稀疏矩阵。

integer(4) function cusparseCcsr2bsr(handle, dirA, m, n, descrA, csrValA, csrRowPtrA, csrColIndA, blockDim, descrC, bsrValC, bsrRowPtrC, bsrColIndC)
  type(cusparseHandle) :: handle
  integer(4) :: dirA, m, n, blockdim
  type(cusparseMatDescr) :: descrA, descrC
  complex(4), device :: csrValA(*), bsrValC(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*), bsrRowPtrC(*), bsrColIndC(*)

5.8.18. cusparseZcsr2bsr

此函数将以 CSR 存储格式（由三个数组 csrValA、csrRowPtrA 和 csrColIndA 定义）表示的稀疏矩阵转换为以 BSR 格式（由数组 bsrValC、bsrRowPtrC 和 bsrColIndC 定义）表示的稀疏矩阵。

integer(4) function cusparseZcsr2bsr(handle, dirA, m, n, descrA, csrValA, csrRowPtrA, csrColIndA, blockDim, descrC, bsrValC, bsrRowPtrC, bsrColIndC)
  type(cusparseHandle) :: handle
  integer(4) :: dirA, m, n, blockdim
  type(cusparseMatDescr) :: descrA, descrC
  complex(8), device :: csrValA(*), bsrValC(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*), bsrRowPtrC(*), bsrColIndC(*)

5.8.19. cusparseXcsr2coo

此函数将包含压缩行指针（对应于 CSR 格式）的数组转换为未压缩行索引（对应于 COO 格式）的数组。

integer(4) function cusparseXcsr2coo(handle, csrRowPtr, nnz, m, cooRowInd, idxBase)
  type(cusparseHandle) :: handle
  integer(4) :: nnz, m, idxBase
  integer(4), device :: csrRowPtr(*), cooRowInd(*)

5.8.20. cusparseScsr2csc

此函数将以 CSR 存储格式（由三个数组 csrVal、csrRowPtr 和 csrColInd 定义）表示的稀疏矩阵转换为以 CSC 格式（由数组 cscVal、cscRowInd 和 cscColPtr 定义）表示的稀疏矩阵。

此函数已在 CUDA 11.0 中移除。请改用 cusparseCsr2cscEx2 例程。

integer(4) function cusparseScsr2csc(handle, m, n, nnz, csrVal, csrRowPtr, csrColInd, cscVal, cscRowInd, cscColPtr, copyValues, idxBase)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, nnz, copyValues, idxBase
  real(4), device :: csrVal(*), cscVal(*)
  integer(4), device :: csrRowPtr(*), csrColInd(*), cscRowInd(*), cscColPtr(*)

5.8.21. cusparseDcsr2csc

此函数将以 CSR 存储格式（由三个数组 csrVal、csrRowPtr 和 csrColInd 定义）表示的稀疏矩阵转换为以 CSC 格式（由数组 cscVal、cscRowInd 和 cscColPtr 定义）表示的稀疏矩阵。

此函数已在 CUDA 11.0 中移除。请改用 cusparseCsr2cscEx2 例程。

integer(4) function cusparseDcsr2csc(handle, m, n, nnz, csrVal, csrRowPtr, csrColInd, cscVal, cscRowInd, cscColPtr, copyValues, idxBase)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, nnz, copyValues, idxBase
  real(8), device :: csrVal(*), cscVal(*)
  integer(4), device :: csrRowPtr(*), csrColInd(*), cscRowInd(*), cscColPtr(*)

5.8.22. cusparseCcsr2csc

此函数将以 CSR 存储格式（由三个数组 csrVal、csrRowPtr 和 csrColInd 定义）表示的稀疏矩阵转换为以 CSC 格式（由数组 cscVal、cscRowInd 和 cscColPtr 定义）表示的稀疏矩阵。

此函数已在 CUDA 11.0 中移除。请改用 cusparseCsr2cscEx2 例程。

integer(4) function cusparseCcsr2csc(handle, m, n, nnz, csrVal, csrRowPtr, csrColInd, cscVal, cscRowInd, cscColPtr, copyValues, idxBase)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, nnz, copyValues, idxBase
  complex(4), device :: csrVal(*), cscVal(*)
  integer(4), device :: csrRowPtr(*), csrColInd(*), cscRowInd(*), cscColPtr(*)

5.8.23. cusparseZcsr2csc

此函数将以 CSR 存储格式（由三个数组 csrVal、csrRowPtr 和 csrColInd 定义）表示的稀疏矩阵转换为以 CSC 格式（由数组 cscVal、cscRowInd 和 cscColPtr 定义）表示的稀疏矩阵。

此函数已在 CUDA 11.0 中移除。请改用 cusparseCsr2cscEx2 例程。

integer(4) function cusparseZcsr2csc(handle, m, n, nnz, csrVal, csrRowPtr, csrColInd, cscVal, cscRowInd, cscColPtr, copyValues, idxBase)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, nnz, copyValues, idxBase
  complex(8), device :: csrVal(*), cscVal(*)
  integer(4), device :: csrRowPtr(*), csrColInd(*), cscRowInd(*), cscColPtr(*)

5.8.24. cusparseCsr2cscEx2_bufferSize

此函数确定 cusparseCsr2cscEx2 所需的工作缓冲区的大小。

integer(4) function cusparseScsr2cscEx2_bufferSize(handle, m, n, nnz, csrVal, csrRowPtr, csrColInd, cscVal, &
           cscColPtr, cscRowInd, valType, copyValues, idxBase, alg, bufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, nnz, valType, copyValues, idxBase, alg
  real(4), device :: csrVal(*), cscVal(*)  ! Can be any supported type
  integer(4), device :: csrRowPtr(*), csrColInd(*), cscRowInd(*), cscColPtr(*)
  integer(8) :: bufferSize

5.8.25. cusparseCsr2cscEx2

此函数将以 CSR 存储格式（由三个数组 csrVal、csrRowPtr 和 csrColInd 定义）表示的稀疏矩阵转换为以 CSC 格式（由数组 cscVal、cscRowInd 和 cscColPtr 定义）表示的稀疏矩阵。数组的类型由 valType 参数设置。

integer(4) function cusparseScsr2cscEx2(handle, m, n, nnz, csrVal, csrRowPtr, csrColInd, cscVal, &
           cscColPtr, cscRowInd, valType, copyValues, idxBase, alg, buffer)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, nnz, valType, copyValues, idxBase, alg
  real(4), device :: csrVal(*), cscVal(*)  ! Can be any supported type
  integer(4), device :: csrRowPtr(*), csrColInd(*), cscRowInd(*), cscColPtr(*)
  integer(1), device :: buffer ! Can be any type

5.8.26. cusparseScsr2dense

此函数将以 CSR 格式（由三个数组 cscValA、cscRowPtrA 和 cscColIndA 定义）表示的稀疏矩阵转换为稠密格式的矩阵 A。稠密矩阵 A 用稀疏矩阵的值填充，其余位置用零填充。

integer(4) function cusparseScsr2dense(handle, m, n, descrA, csrValA, csrRowPtrA, csrColIndA, A, lda)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, lda
  type(cusparseMatDescr) :: descrA
  real(4), device :: csrValA(*), A(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)

5.8.27. cusparseDcsr2dense

此函数将以 CSR 格式（由三个数组 cscValA、cscRowPtrA 和 cscColIndA 定义）表示的稀疏矩阵转换为稠密格式的矩阵 A。稠密矩阵 A 用稀疏矩阵的值填充，其余位置用零填充。

integer(4) function cusparseDcsr2dense(handle, m, n, descrA, csrValA, csrRowPtrA, csrColIndA, A, lda)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, lda
  type(cusparseMatDescr) :: descrA
  real(8), device :: csrValA(*), A(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)

5.8.28. cusparseCcsr2dense

此函数将以 CSR 格式（由三个数组 cscValA、cscRowPtrA 和 cscColIndA 定义）表示的稀疏矩阵转换为稠密格式的矩阵 A。稠密矩阵 A 用稀疏矩阵的值填充，其余位置用零填充。

integer(4) function cusparseCcsr2dense(handle, m, n, descrA, csrValA, csrRowPtrA, csrColIndA, A, lda)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, lda
  type(cusparseMatDescr) :: descrA
  complex(4), device :: csrValA(*), A(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)

5.8.29. cusparseZcsr2dense

此函数将以 CSR 格式（由三个数组 cscValA、cscRowPtrA 和 cscColIndA 定义）表示的稀疏矩阵转换为稠密格式的矩阵 A。稠密矩阵 A 用稀疏矩阵的值填充，其余位置用零填充。

integer(4) function cusparseZcsr2dense(handle, m, n, descrA, csrValA, csrRowPtrA, csrColIndA, A, lda)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, lda
  type(cusparseMatDescr) :: descrA
  complex(8), device :: csrValA(*), A(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)

5.8.30. cusparseScsr2hyb

此函数将以 CSR 格式（由三个数组 cscValA、cscRowPtrA 和 cscColIndA 定义）表示的稀疏矩阵转换为 HYB 格式的稀疏矩阵。

integer(4) function cusparseScsr2hyb(handle, m, n, descrA, csrValA, csrRowPtrA, csrColIndA, hybA, userEllWidth, partitionType)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, userEllWidth, partitionType
  type(cusparseMatDescr) :: descrA
  type(cusparseHybMat) :: hybA
  real(4), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)

5.8.31. cusparseDcsr2hyb

此函数将以 CSR 格式（由三个数组 cscValA、cscRowPtrA 和 cscColIndA 定义）表示的稀疏矩阵转换为 HYB 格式的稀疏矩阵。

integer(4) function cusparseDcsr2hyb(handle, m, n, descrA, csrValA, csrRowPtrA, csrColIndA, hybA, userEllWidth, partitionType)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, userEllWidth, partitionType
  type(cusparseMatDescr) :: descrA
  type(cusparseHybMat) :: hybA
  real(8), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)

5.8.32. cusparseCcsr2hyb

此函数将以 CSR 格式（由三个数组 cscValA、cscRowPtrA 和 cscColIndA 定义）表示的稀疏矩阵转换为 HYB 格式的稀疏矩阵。

integer(4) function cusparseCcsr2hyb(handle, m, n, descrA, csrValA, csrRowPtrA, csrColIndA, hybA, userEllWidth, partitionType)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, userEllWidth, partitionType
  type(cusparseMatDescr) :: descrA
  type(cusparseHybMat) :: hybA
  complex(4), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)

5.8.33. cusparseZcsr2hyb

此函数将以 CSR 格式（由三个数组 cscValA、cscRowPtrA 和 cscColIndA 定义）表示的稀疏矩阵转换为 HYB 格式的稀疏矩阵。

integer(4) function cusparseZcsr2hyb(handle, m, n, descrA, csrValA, csrRowPtrA, csrColIndA, hybA, userEllWidth, partitionType)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, userEllWidth, partitionType
  type(cusparseMatDescr) :: descrA
  type(cusparseHybMat) :: hybA
  complex(8), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)

5.8.34. cusparseSdense2csc

此函数将稠密格式的矩阵 A 转换为 CSC 格式的稀疏矩阵。

integer(4) function cusparseSdense2csc(handle, m, n, descrA, A, lda, nnzPerCol, cscValA, cscRowIndA, cscColPtrA)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, lda
  type(cusparseMatDescr) :: descrA
  real(4), device :: A(*), cscValA(*)
  integer(4), device :: nnzPerCol(*), cscRowIndA(*), cscColPtrA(*)

5.8.35. cusparseDdense2csc

此函数将稠密格式的矩阵 A 转换为 CSC 格式的稀疏矩阵。

integer(4) function cusparseDdense2csc(handle, m, n, descrA, A, lda, nnzPerCol, cscValA, cscRowIndA, cscColPtrA)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, lda
  type(cusparseMatDescr) :: descrA
  real(8), device :: A(*), cscValA(*)
  integer(4), device :: nnzPerCol(*), cscRowIndA(*), cscColPtrA(*)

5.8.36. cusparseCdense2csc

此函数将稠密格式的矩阵 A 转换为 CSC 格式的稀疏矩阵。

integer(4) function cusparseCdense2csc(handle, m, n, descrA, A, lda, nnzPerCol, cscValA, cscRowIndA, cscColPtrA)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, lda
  type(cusparseMatDescr) :: descrA
  complex(4), device :: A(*), cscValA(*)
  integer(4), device :: nnzPerCol(*), cscRowIndA(*), cscColPtrA(*)

5.8.37. cusparseZdense2csc

此函数将稠密格式的矩阵 A 转换为 CSC 格式的稀疏矩阵。

integer(4) function cusparseZdense2csc(handle, m, n, descrA, A, lda, nnzPerCol, cscValA, cscRowIndA, cscColPtrA)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, lda
  type(cusparseMatDescr) :: descrA
  complex(8), device :: A(*), cscValA(*)
  integer(4), device :: nnzPerCol(*), cscRowIndA(*), cscColPtrA(*)

5.8.38. cusparseSdense2csr

此函数将稠密格式的矩阵 A 转换为 CSR 格式的稀疏矩阵。

integer(4) function cusparseSdense2csr(handle, m, n, descrA, A, lda, nnzPerRow, csrValA, csrRowPtrA, csrColIndA)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, lda
  type(cusparseMatDescr) :: descrA
  real(4), device :: A(*), csrValA(*)
  integer(4), device :: nnzPerRow(*), csrRowPtrA(*), csrColIndA(*)

5.8.39. cusparseDdense2csr

此函数将稠密格式的矩阵 A 转换为 CSR 格式的稀疏矩阵。

integer(4) function cusparseDdense2csr(handle, m, n, descrA, A, lda, nnzPerRow, csrValA, csrRowPtrA, csrColIndA)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, lda
  type(cusparseMatDescr) :: descrA
  real(8), device :: A(*), csrValA(*)
  integer(4), device :: nnzPerRow(*), csrRowPtrA(*), csrColIndA(*)

5.8.40. cusparseCdense2csr

此函数将稠密格式的矩阵 A 转换为 CSR 格式的稀疏矩阵。

integer(4) function cusparseCdense2csr(handle, m, n, descrA, A, lda, nnzPerRow, csrValA, csrRowPtrA, csrColIndA)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, lda
  type(cusparseMatDescr) :: descrA
  complex(4), device :: A(*), csrValA(*)
  integer(4), device :: nnzPerRow(*), csrRowPtrA(*), csrColIndA(*)

5.8.41. cusparseZdense2csr

此函数将稠密格式的矩阵 A 转换为 CSR 格式的稀疏矩阵。

integer(4) function cusparseZdense2csr(handle, m, n, descrA, A, lda, nnzPerRow, csrValA, csrRowPtrA, csrColIndA)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, lda
  type(cusparseMatDescr) :: descrA
  complex(8), device :: A(*), csrValA(*)
  integer(4), device :: nnzPerRow(*), csrRowPtrA(*), csrColIndA(*)

5.8.42. cusparseSdense2hyb

此函数将稠密格式的矩阵 A 转换为 HYB 格式的稀疏矩阵。

integer(4) function cusparseSdense2hyb(handle, m, n, descrA, A, lda, nnzPerRow, hybA, userEllWidth, partitionType)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, lda, userEllWidth, partitionType
  type(cusparseMatDescr) :: descrA
  type(cusparseHybMat) :: hybA
  real(4), device :: A(*)
  integer(4), device :: nnzPerRow(*)

5.8.43. cusparseDdense2hyb

此函数将稠密格式的矩阵 A 转换为 HYB 格式的稀疏矩阵。

integer(4) function cusparseDdense2hyb(handle, m, n, descrA, A, lda, nnzPerRow, hybA, userEllWidth, partitionType)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, lda, userEllWidth, partitionType
  type(cusparseMatDescr) :: descrA
  type(cusparseHybMat) :: hybA
  real(8), device :: A(*)
  integer(4), device :: nnzPerRow(*)

5.8.44. cusparseCdense2hyb

此函数将稠密格式的矩阵 A 转换为 HYB 格式的稀疏矩阵。

integer(4) function cusparseCdense2hyb(handle, m, n, descrA, A, lda, nnzPerRow, hybA, userEllWidth, partitionType)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, lda, userEllWidth, partitionType
  type(cusparseMatDescr) :: descrA
  type(cusparseHybMat) :: hybA
  complex(4), device :: A(*)
  integer(4), device :: nnzPerRow(*)

5.8.45. cusparseZdense2hyb

此函数将稠密格式的矩阵 A 转换为 HYB 格式的稀疏矩阵。

integer(4) function cusparseZdense2hyb(handle, m, n, descrA, A, lda, nnzPerRow, hybA, userEllWidth, partitionType)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, lda, userEllWidth, partitionType
  type(cusparseMatDescr) :: descrA
  type(cusparseHybMat) :: hybA
  complex(8), device :: A(*)
  integer(4), device :: nnzPerRow(*)

5.8.46. cusparseShyb2csc

此函数将 HYB 格式的稀疏矩阵 A 转换为 CSC 格式的稀疏矩阵。

integer(4) function cusparseShyb2csc(handle, descrA, hybA, cscValA, cscRowIndA, cscColPtrA)
  type(cusparseHandle) :: handle
  type(cusparseMatDescr) :: descrA
  type(cusparseHybMat) :: hybA
  real(4), device :: cscValA(*)
  integer(4), device :: cscRowIndA(*), cscColPtrA(*)

5.8.47. cusparseDhyb2csc

此函数将 HYB 格式的稀疏矩阵 A 转换为 CSC 格式的稀疏矩阵。

integer(4) function cusparseDhyb2csc(handle, descrA, hybA, cscValA, cscRowIndA, cscColPtrA)
  type(cusparseHandle) :: handle
  type(cusparseMatDescr) :: descrA
  type(cusparseHybMat) :: hybA
  real(8), device :: cscValA(*)
  integer(4), device :: cscRowIndA(*), cscColPtrA(*)

5.8.48. cusparseChyb2csc

此函数将 HYB 格式的稀疏矩阵 A 转换为 CSC 格式的稀疏矩阵。

integer(4) function cusparseChyb2csc(handle, descrA, hybA, cscValA, cscRowIndA, cscColPtrA)
  type(cusparseHandle) :: handle
  type(cusparseMatDescr) :: descrA
  type(cusparseHybMat) :: hybA
  complex(4), device :: cscValA(*)
  integer(4), device :: cscRowIndA(*), cscColPtrA(*)

5.8.49. cusparseZhyb2csc

此函数将 HYB 格式的稀疏矩阵 A 转换为 CSC 格式的稀疏矩阵。

integer(4) function cusparseZhyb2csc(handle, descrA, hybA, cscValA, cscRowIndA, cscColPtrA)
  type(cusparseHandle) :: handle
  type(cusparseMatDescr) :: descrA
  type(cusparseHybMat) :: hybA
  complex(8), device :: cscValA(*)
  integer(4), device :: cscRowIndA(*), cscColPtrA(*)

5.8.50. cusparseShyb2csr

此函数将 HYB 格式的稀疏矩阵 A 转换为 CSR 格式的稀疏矩阵。

integer(4) function cusparseShyb2csr(handle, descrA, hybA, csrValA, csrRowPtrA, csrColIndA)
  type(cusparseHandle) :: handle
  type(cusparseMatDescr) :: descrA
  type(cusparseHybMat) :: hybA
  real(4), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)

5.8.51. cusparseDhyb2csr

此函数将 HYB 格式的稀疏矩阵 A 转换为 CSR 格式的稀疏矩阵。

integer(4) function cusparseDhyb2csr(handle, descrA, hybA, csrValA, csrRowPtrA, csrColIndA)
  type(cusparseHandle) :: handle
  type(cusparseMatDescr) :: descrA
  type(cusparseHybMat) :: hybA
  real(8), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)

5.8.52. cusparseChyb2csr

此函数将 HYB 格式的稀疏矩阵 A 转换为 CSR 格式的稀疏矩阵。

integer(4) function cusparseChyb2csr(handle, descrA, hybA, csrValA, csrRowPtrA, csrColIndA)
  type(cusparseHandle) :: handle
  type(cusparseMatDescr) :: descrA
  type(cusparseHybMat) :: hybA
  complex(4), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)

5.8.53. cusparseZhyb2csr

此函数将 HYB 格式的稀疏矩阵 A 转换为 CSR 格式的稀疏矩阵。

integer(4) function cusparseZhyb2csr(handle, descrA, hybA, csrValA, csrRowPtrA, csrColIndA)
  type(cusparseHandle) :: handle
  type(cusparseMatDescr) :: descrA
  type(cusparseHybMat) :: hybA
  complex(8), device :: csrValA(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)

5.8.54. cusparseShyb2dense

此函数将 HYB 格式的稀疏矩阵转换为稠密格式的矩阵 A。稠密矩阵 A 用稀疏矩阵的值填充，其余位置用零填充。

integer(4) function cusparseShyb2dense(handle, descrA, hybA, A, lda)
  type(cusparseHandle) :: handle
  type(cusparseMatDescr) :: descrA
  type(cusparseHybMat) :: hybA
  real(4), device :: A(*)
  integer(4) :: lda

5.8.55. cusparseDhyb2dense

此函数将 HYB 格式的稀疏矩阵转换为稠密格式的矩阵 A。稠密矩阵 A 用稀疏矩阵的值填充，其余位置用零填充。

integer(4) function cusparseDhyb2dense(handle, descrA, hybA, A, lda)
  type(cusparseHandle) :: handle
  type(cusparseMatDescr) :: descrA
  type(cusparseHybMat) :: hybA
  real(8), device :: A(*)
  integer(4) :: lda

5.8.56. cusparseChyb2dense

此函数将 HYB 格式的稀疏矩阵转换为稠密格式的矩阵 A。稠密矩阵 A 用稀疏矩阵的值填充，其余位置用零填充。

integer(4) function cusparseChyb2dense(handle, descrA, hybA, A, lda)
  type(cusparseHandle) :: handle
  type(cusparseMatDescr) :: descrA
  type(cusparseHybMat) :: hybA
  complex(4), device :: A(*)
  integer(4) :: lda

5.8.57. cusparseZhyb2dense

此函数将 HYB 格式的稀疏矩阵转换为稠密格式的矩阵 A。稠密矩阵 A 用稀疏矩阵的值填充，其余位置用零填充。

integer(4) function cusparseZhyb2dense(handle, descrA, hybA, A, lda)
  type(cusparseHandle) :: handle
  type(cusparseMatDescr) :: descrA
  type(cusparseHybMat) :: hybA
  complex(8), device :: A(*)
  integer(4) :: lda

5.8.58. cusparseSnnz

此函数计算稠密矩阵中每行或每列的非零元素数量以及非零元素的总数。

integer(4) function cusparseSnnz(handle, dirA, m, n, descrA, A, lda, nnzPerRowColumn, nnzTotalDevHostPtr)
  type(cusparseHandle) :: handle
  integer :: dirA, m, n, lda
  type(cusparseMatDescr) :: descrA
  real(4), device :: A(*)
  integer(4), device :: nnzPerRowColumn(*)
  integer(4), device :: nnzTotalDevHostPtr ! device or host variable

5.8.59. cusparseDnnz

此函数计算稠密矩阵中每行或每列的非零元素数量以及非零元素的总数。

integer(4) function cusparseDnnz(handle, dirA, m, n, descrA, A, lda, nnzPerRowColumn, nnzTotalDevHostPtr)
  type(cusparseHandle) :: handle
  integer :: dirA, m, n, lda
  type(cusparseMatDescr) :: descrA
  real(8), device :: A(*)
  integer(4), device :: nnzPerRowColumn(*)
  integer(4), device :: nnzTotalDevHostPtr ! device or host variable

5.8.60. cusparseCnnz

此函数计算稠密矩阵中每行或每列的非零元素数量以及非零元素的总数。

integer(4) function cusparseCnnz(handle, dirA, m, n, descrA, A, lda, nnzPerRowColumn, nnzTotalDevHostPtr)
  type(cusparseHandle) :: handle
  integer :: dirA, m, n, lda
  type(cusparseMatDescr) :: descrA
  complex(4), device :: A(*)
  integer(4), device :: nnzPerRowColumn(*)
  integer(4), device :: nnzTotalDevHostPtr ! device or host variable

5.8.61. cusparseZnnz

此函数计算稠密矩阵中每行或每列的非零元素数量以及非零元素的总数。

integer(4) function cusparseZnnz(handle, dirA, m, n, descrA, A, lda, nnzPerRowColumn, nnzTotalDevHostPtr)
  type(cusparseHandle) :: handle
  integer :: dirA, m, n, lda
  type(cusparseMatDescr) :: descrA
  complex(8), device :: A(*)
  integer(4), device :: nnzPerRowColumn(*)
  integer(4), device :: nnzTotalDevHostPtr ! device or host variable

5.8.62. cusparseSgebsr2gebsc_bufferSize

此函数返回 gebsr2gebsc 中使用的缓冲区大小。

integer(4) function cusparseSgebsr2gebsc_bufferSize(handle, mb, nb, nnzb, bsrVal, bsrRowPtr, bsrColInd, rowBlockDim, colBlockDim, pBufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: mb, nb, nnzb
  real(4), device :: bsrVal(*)
  integer(4), device :: bsrRowPtr(*), bsrColInd(*)
  integer(4) :: rowBlockDim, colBlockDim
  integer(4) :: pBufferSize ! integer(8) also accepted

5.8.63. cusparseDgebsr2gebsc_bufferSize

此函数返回 gebsr2gebsc 中使用的缓冲区大小。

integer(4) function cusparseDgebsr2gebsc_bufferSize(handle, mb, nb, nnzb, bsrVal, bsrRowPtr, bsrColInd, rowBlockDim, colBlockDim, pBufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: mb, nb, nnzb
  real(8), device :: bsrVal(*)
  integer(4), device :: bsrRowPtr(*), bsrColInd(*)
  integer(4) :: rowBlockDim, colBlockDim
  integer(4) :: pBufferSize ! integer(8) also accepted

5.8.64. cusparseCgebsr2gebsc_bufferSize

此函数返回 gebsr2gebsc 中使用的缓冲区大小。

integer(4) function cusparseCgebsr2gebsc_bufferSize(handle, mb, nb, nnzb, bsrVal, bsrRowPtr, bsrColInd, rowBlockDim, colBlockDim, pBufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: mb, nb, nnzb
  complex(4), device :: bsrVal(*)
  integer(4), device :: bsrRowPtr(*), bsrColInd(*)
  integer(4) :: rowBlockDim, colBlockDim
  integer(4) :: pBufferSize ! integer(8) also accepted

5.8.65. cusparseZgebsr2gebsc_bufferSize

此函数返回 gebsr2gebsc 中使用的缓冲区大小。

integer(4) function cusparseZgebsr2gebsc_bufferSize(handle, mb, nb, nnzb, bsrVal, bsrRowPtr, bsrColInd, rowBlockDim, colBlockDim, pBufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: mb, nb, nnzb
  complex(8), device :: bsrVal(*)
  integer(4), device :: bsrRowPtr(*), bsrColInd(*)
  integer(4) :: rowBlockDim, colBlockDim
  integer(4) :: pBufferSize ! integer(8) also accepted

5.8.66. cusparseSgebsr2gebsc

此函数将一般块 CSR 存储格式的稀疏矩阵转换为一般块 CSC 存储格式的稀疏矩阵。

integer(4) function cusparseSgebsr2gebsc(handle, mb, nb, nnzb, bsrVal, bsrRowPtr, &
           bsrColInd, rowBlockDim, colBlockDim, bscVal, bscRowInd, bscColPtr, copyValues, baseIdx, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: mb, nb, nnzb
  real(4), device :: bsrVal(*)
  integer(4), device :: bsrRowPtr(*), bsrColInd(*)
  integer(4) :: rowBlockDim, colBlockDim
  real(4), device :: bscVal(*)
  integer(4), device :: bscRowInd(*), bscColPtr(*)
  integer(4) :: copyValues, baseIdx
  character(c_char), device :: pBuffer(*)

5.8.67. cusparseDgebsr2gebsc

此函数将一般块 CSR 存储格式的稀疏矩阵转换为一般块 CSC 存储格式的稀疏矩阵。

integer(4) function cusparseDgebsr2gebsc(handle, mb, nb, nnzb, bsrVal, bsrRowPtr, &
           bsrColInd, rowBlockDim, colBlockDim, bscVal, bscRowInd, bscColPtr, copyValues, baseIdx, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: mb, nb, nnzb
  real(8), device :: bsrVal(*)
  integer(4), device :: bsrRowPtr(*), bsrColInd(*)
  integer(4) :: rowBlockDim, colBlockDim
  real(8), device :: bscVal(*)
  integer(4), device :: bscRowInd(*), bscColPtr(*)
  integer(4) :: copyValues, baseIdx
  character(c_char), device :: pBuffer(*)

5.8.68. cusparseCgebsr2gebsc

此函数将一般块 CSR 存储格式的稀疏矩阵转换为一般块 CSC 存储格式的稀疏矩阵。

integer(4) function cusparseCgebsr2gebsc(handle, mb, nb, nnzb, bsrVal, bsrRowPtr, &
           bsrColInd, rowBlockDim, colBlockDim, bscVal, bscRowInd, bscColPtr, copyValues, baseIdx, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: mb, nb, nnzb
  complex(4), device :: bsrVal(*)
  integer(4), device :: bsrRowPtr(*), bsrColInd(*)
  integer(4) :: rowBlockDim, colBlockDim
  complex(4), device :: bscVal(*)
  integer(4), device :: bscRowInd(*), bscColPtr(*)
  integer(4) :: copyValues, baseIdx
  character(c_char), device :: pBuffer(*)

5.8.69. cusparseZgebsr2gebsc

此函数将一般块 CSR 存储格式的稀疏矩阵转换为一般块 CSC 存储格式的稀疏矩阵。

integer(4) function cusparseZgebsr2gebsc(handle, mb, nb, nnzb, bsrVal, bsrRowPtr, &
           bsrColInd, rowBlockDim, colBlockDim, bscVal, bscRowInd, bscColPtr, copyValues, baseIdx, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: mb, nb, nnzb
  complex(8), device :: bsrVal(*)
  integer(4), device :: bsrRowPtr(*), bsrColInd(*)
  integer(4) :: rowBlockDim, colBlockDim
  complex(8), device :: bscVal(*)
  integer(4), device :: bscRowInd(*), bscColPtr(*)
  integer(4) :: copyValues, baseIdx
  character(c_char), device :: pBuffer(*)

5.8.70. cusparseSgebsr2gebsr_bufferSize

此函数返回 gebsr2gebsrnnz 和 gebsr2gebsr 中使用的缓冲区大小。

integer(4) function cusparseSgebsr2gebsr_bufferSize(handle, mb, nb, nnzb, bsrVal, bsrRowPtr, &
           bsrColInd, rowBlockDimA, colBlockDimA, rowBlockDimC, colBlockDimC, pBufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: mb, nb, nnzb
  real(4), device :: bsrVal(*)
  integer(4), device :: bsrRowPtr(*), bsrColInd(*)
  integer(4) :: rowBlockDimA, colBlockDimA, rowBlockDimC, colBlockDimC
  integer(4) :: pBufferSize ! integer(8) also accepted

5.8.71. cusparseDgebsr2gebsr_bufferSize

此函数返回 gebsr2gebsrnnz 和 gebsr2gebsr 中使用的缓冲区大小。

integer(4) function cusparseDgebsr2gebsr_bufferSize(handle, mb, nb, nnzb, bsrVal, bsrRowPtr, &
           bsrColInd, rowBlockDimA, colBlockDimA, rowBlockDimC, colBlockDimC, pBufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: mb, nb, nnzb
  real(8), device :: bsrVal(*)
  integer(4), device :: bsrRowPtr(*), bsrColInd(*)
  integer(4) :: rowBlockDimA, colBlockDimA, rowBlockDimC, colBlockDimC
  integer(4) :: pBufferSize ! integer(8) also accepted

5.8.72. cusparseCgebsr2gebsr_bufferSize

此函数返回 gebsr2gebsrnnz 和 gebsr2gebsr 中使用的缓冲区大小。

integer(4) function cusparseCgebsr2gebsr_bufferSize(handle, mb, nb, nnzb, bsrVal, bsrRowPtr, &
           bsrColInd, rowBlockDimA, colBlockDimA, rowBlockDimC, colBlockDimC, pBufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: mb, nb, nnzb
  complex(4), device :: bsrVal(*)
  integer(4), device :: bsrRowPtr(*), bsrColInd(*)
  integer(4) :: rowBlockDimA, colBlockDimA, rowBlockDimC, colBlockDimC
  integer(4) :: pBufferSize ! integer(8) also accepted

5.8.73. cusparseZgebsr2gebsr_bufferSize

此函数返回 gebsr2gebsrnnz 和 gebsr2gebsr 中使用的缓冲区大小。

integer(4) function cusparseZgebsr2gebsr_bufferSize(handle, mb, nb, nnzb, bsrVal, bsrRowPtr, &
           bsrColInd, rowBlockDimA, colBlockDimA, rowBlockDimC, colBlockDimC, pBufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: mb, nb, nnzb
  complex(8), device :: bsrVal(*)
  integer(4), device :: bsrRowPtr(*), bsrColInd(*)
  integer(4) :: rowBlockDimA, colBlockDimA, rowBlockDimC, colBlockDimC
  integer(4) :: pBufferSize ! integer(8) also accepted

5.8.74. cusparseXgebsr2gebsrNnz

cusparseXcsrgeamNnz 计算 CSRGEAM 将生成的非零元素的数量。

integer(4) function cusparseXgebsr2gebsrNnz(handle, dir, mb, nb, nnzb, descrA, bsrRowPtrA, &
           bsrColIndA, rowBlockDimA, colBlockDimA, descrC, bsrRowPtrC, rowBlockDimC, colBlockDimC, nnzTotalDevHostPtr, pBuffer)
  type(cusparseHandle) :: handle
  integer :: dir, mb, nb, nnzb
  type(cusparseMatDescr) :: descrA
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer :: rowBlockDimA, colBlockDimA
  type(cusparseMatDescr) :: descrC
  integer(4), device :: bsrRowPtrC(*)
  integer :: rowBlockDimC, colBlockDimC
  integer(4), device :: nnzTotalDevHostPtr ! device or host variable
  character, device :: pBuffer(*)

5.8.75. cusparseSgebsr2gebsr

此函数将由三个数组 bsrValA、bsrRowPtrA 和 bsrColIndA 定义的一般 BSR 存储格式的稀疏矩阵转换为由数组 bsrValC、bsrRowPtrC 和 bsrColIndC 定义的另一种一般 BSR 格式的稀疏矩阵。

integer(4) function cusparseSgebsr2gebsr(handle, dir, mb, nb, nnzb, descrA, bsrValA, bsrRowPtrA, &
           bsrColIndA, rowBlockDimA, colBlockDimA, descrC, bsrValC, bsrRowPtrC, bsrColIndC, rowBlockDimC, colBlockDimC, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: dir, mb, nb, nnzb
  type(cusparseMatDescr) :: descrA
  real(4), device :: bsrValA(*), bsrValC(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer(4) :: rowBlockDimA, colBlockDimA
  type(cusparseMatDescr) :: descrC
  integer(4), device :: bsrRowPtrC(*), bsrColIndC(*)
  integer(4) :: rowBlockDimC, colBlockDimC
  character(c_char), device :: pBuffer(*)

5.8.76. cusparseDgebsr2gebsr

此函数将由三个数组 bsrValA、bsrRowPtrA 和 bsrColIndA 定义的一般 BSR 存储格式的稀疏矩阵转换为由数组 bsrValC、bsrRowPtrC 和 bsrColIndC 定义的另一种一般 BSR 格式的稀疏矩阵。

integer(4) function cusparseDgebsr2gebsr(handle, dir, mb, nb, nnzb, descrA, bsrValA, bsrRowPtrA, &
           bsrColIndA, rowBlockDimA, colBlockDimA, descrC, bsrValC, bsrRowPtrC, bsrColIndC, rowBlockDimC, colBlockDimC, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: dir, mb, nb, nnzb
  type(cusparseMatDescr) :: descrA
  real(8), device :: bsrValA(*), bsrValC(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer(4) :: rowBlockDimA, colBlockDimA
  type(cusparseMatDescr) :: descrC
  integer(4), device :: bsrRowPtrC(*), bsrColIndC(*)
  integer(4) :: rowBlockDimC, colBlockDimC
  character(c_char), device :: pBuffer(*)

5.8.77. cusparseCgebsr2gebsr

此函数将由三个数组 bsrValA、bsrRowPtrA 和 bsrColIndA 定义的一般 BSR 存储格式的稀疏矩阵转换为由数组 bsrValC、bsrRowPtrC 和 bsrColIndC 定义的另一种一般 BSR 格式的稀疏矩阵。

integer(4) function cusparseCgebsr2gebsr(handle, dir, mb, nb, nnzb, descrA, bsrValA, bsrRowPtrA, &
           bsrColIndA, rowBlockDimA, colBlockDimA, descrC, bsrValC, bsrRowPtrC, bsrColIndC, rowBlockDimC, colBlockDimC, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: dir, mb, nb, nnzb
  type(cusparseMatDescr) :: descrA
  complex(4), device :: bsrValA(*), bsrValC(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer(4) :: rowBlockDimA, colBlockDimA
  type(cusparseMatDescr) :: descrC
  integer(4), device :: bsrRowPtrC(*), bsrColIndC(*)
  integer(4) :: rowBlockDimC, colBlockDimC
  character(c_char), device :: pBuffer(*)

5.8.78. cusparseZgebsr2gebsr

此函数将由三个数组 bsrValA、bsrRowPtrA 和 bsrColIndA 定义的一般 BSR 存储格式的稀疏矩阵转换为由数组 bsrValC、bsrRowPtrC 和 bsrColIndC 定义的另一种一般 BSR 格式的稀疏矩阵。

integer(4) function cusparseZgebsr2gebsr(handle, dir, mb, nb, nnzb, descrA, bsrValA, bsrRowPtrA, &
           bsrColIndA, rowBlockDimA, colBlockDimA, descrC, bsrValC, bsrRowPtrC, bsrColIndC, rowBlockDimC, colBlockDimC, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: dir, mb, nb, nnzb
  type(cusparseMatDescr) :: descrA
  complex(8), device :: bsrValA(*), bsrValC(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer(4) :: rowBlockDimA, colBlockDimA
  type(cusparseMatDescr) :: descrC
  integer(4), device :: bsrRowPtrC(*), bsrColIndC(*)
  integer(4) :: rowBlockDimC, colBlockDimC
  character(c_char), device :: pBuffer(*)

5.8.79. cusparseSgebsr2csr

此函数将由三个数组 bsrValA、bsrRowPtrA 和 bsrColIndA 定义的一般 BSR 存储格式的稀疏矩阵转换为由数组 csrValC、csrRowPtrC 和 csrColIndC 定义的 CSR 格式的稀疏矩阵。

integer(4) function cusparseSgebsr2csr(handle, dir, mb, nb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, &
           rowBlockDimA, colBlockDimA, descrC, csrValC, csrRowPtrC, csrColIndC)
  type(cusparseHandle) :: handle
  integer(4) :: dir, mb, nb, nnzb
  type(cusparseMatDescr) :: descrA
  real(4), device :: bsrValA(*), csrValC(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer(4) :: rowBlockDimA, colBlockDimA
  type(cusparseMatDescr) :: descrC
  integer(4), device :: csrRowPtrC(*), csrColIndC(*)

5.8.80. cusparseDgebsr2csr

此函数将由三个数组 bsrValA、bsrRowPtrA 和 bsrColIndA 定义的一般 BSR 存储格式的稀疏矩阵转换为由数组 csrValC、csrRowPtrC 和 csrColIndC 定义的 CSR 格式的稀疏矩阵。

integer(4) function cusparseDgebsr2csr(handle, dir, mb, nb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, &
           rowBlockDimA, colBlockDimA, descrC, csrValC, csrRowPtrC, csrColIndC)
  type(cusparseHandle) :: handle
  integer(4) :: dir, mb, nb, nnzb
  type(cusparseMatDescr) :: descrA
  real(8), device :: bsrValA(*), csrValC(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer(4) :: rowBlockDimA, colBlockDimA
  type(cusparseMatDescr) :: descrC
  integer(4), device :: csrRowPtrC(*), csrColIndC(*)

5.8.81. cusparseCgebsr2csr

此函数将由三个数组 bsrValA、bsrRowPtrA 和 bsrColIndA 定义的一般 BSR 存储格式的稀疏矩阵转换为由数组 csrValC、csrRowPtrC 和 csrColIndC 定义的 CSR 格式的稀疏矩阵。

integer(4) function cusparseCgebsr2csr(handle, dir, mb, nb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, &
           rowBlockDimA, colBlockDimA, descrC, csrValC, csrRowPtrC, csrColIndC)
  type(cusparseHandle) :: handle
  integer(4) :: dir, mb, nb, nnzb
  type(cusparseMatDescr) :: descrA
  complex(4), device :: bsrValA(*), csrValC(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer(4) :: rowBlockDimA, colBlockDimA
  type(cusparseMatDescr) :: descrC
  integer(4), device :: csrRowPtrC(*), csrColIndC(*)

5.8.82. cusparseZgebsr2csr

此函数将由三个数组 bsrValA、bsrRowPtrA 和 bsrColIndA 定义的一般 BSR 存储格式的稀疏矩阵转换为由数组 csrValC、csrRowPtrC 和 csrColIndC 定义的 CSR 格式的稀疏矩阵。

integer(4) function cusparseZgebsr2csr(handle, dir, mb, nb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, &
           rowBlockDimA, colBlockDimA, descrC, csrValC, csrRowPtrC, csrColIndC)
  type(cusparseHandle) :: handle
  integer(4) :: dir, mb, nb, nnzb
  type(cusparseMatDescr) :: descrA
  complex(8), device :: bsrValA(*), csrValC(*)
  integer(4), device :: bsrRowPtrA(*), bsrColIndA(*)
  integer(4) :: rowBlockDimA, colBlockDimA
  type(cusparseMatDescr) :: descrC
  integer(4), device :: csrRowPtrC(*), csrColIndC(*)

5.8.83. cusparseScsr2gebsr_bufferSize

此函数返回 csr2gebsrnnz 和 csr2gebsr 中使用的缓冲区大小。

integer(4) function cusparseScsr2gebsr_bufferSize(handle, dir, m, n, descrA, csrVal, csrRowPtr, csrColInd, rowBlockDim, colBlockDim, pBufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: dir, m, n
  real(4), device :: csrVal(*)
  integer(4), device :: csrRowPtr(*), csrColInd(*)
  integer(4) :: rowBlockDim, colBlockDim
  integer(4) :: pBufferSize ! integer(8) also accepted

5.8.84. cusparseDcsr2gebsr_bufferSize

此函数返回 csr2gebsrnnz 和 csr2gebsr 中使用的缓冲区大小。

integer(4) function cusparseDcsr2gebsr_bufferSize(handle, dir, m, n, descrA, csrVal, csrRowPtr, csrColInd, rowBlockDim, colBlockDim, pBufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: dir, m, n
  real(8), device :: csrVal(*)
  integer(4), device :: csrRowPtr(*), csrColInd(*)
  integer(4) :: rowBlockDim, colBlockDim
  integer(4) :: pBufferSize ! integer(8) also accepted

5.8.85. cusparseCcsr2gebsr_bufferSize

此函数返回 csr2gebsrnnz 和 csr2gebsr 中使用的缓冲区大小。

integer(4) function cusparseCcsr2gebsr_bufferSize(handle, dir, m, n, descrA, csrVal, csrRowPtr, csrColInd, rowBlockDim, colBlockDim, pBufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: dir, m, n
  complex(4), device :: csrVal(*)
  integer(4), device :: csrRowPtr(*), csrColInd(*)
  integer(4) :: rowBlockDim, colBlockDim
  integer(4) :: pBufferSize ! integer(8) also accepted

5.8.86. cusparseZcsr2gebsr_bufferSize

此函数返回 csr2gebsrnnz 和 csr2gebsr 中使用的缓冲区大小。

integer(4) function cusparseZcsr2gebsr_bufferSize(handle, dir, m, n, descrA, csrVal, csrRowPtr, csrColInd, rowBlockDim, colBlockDim, pBufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: dir, m, n
  complex(8), device :: csrVal(*)
  integer(4), device :: csrRowPtr(*), csrColInd(*)
  integer(4) :: rowBlockDim, colBlockDim
  integer(4) :: pBufferSize ! integer(8) also accepted

5.8.87. cusparseXcsr2gebsrNnz

cusparseXcsrgeamNnz 计算 CSRGEAM 将生成的非零元素的数量。

integer(4) function cusparseXcsr2gebsrNnz(handle, dir, m, n, descrA, csrRowPtrA, csrColIndA, &
           descrC, bsrRowPtrC, rowBlockDimC, colBlockDimC, nnzTotalDevHostPtr, pBuffer)
  type(cusparseHandle) :: handle
  integer :: dir, m, n
  type(cusparseMatDescr) :: descrA
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseMatDescr) :: descrC
  integer(4), device :: bsrRowPtrC(*)
  integer :: rowBlockDimC, colBlockDimC
  integer(4), device :: nnzTotalDevHostPtr ! device or host variable
  character, device :: pBuffer(*)

5.8.88. cusparseScsr2gebsr

此函数将由三个数组 csrValA、csrRowPtrA 和 csrColIndA 定义的 CSR 存储格式的稀疏矩阵转换为由数组 bsrValC、bsrRowPtrC 和 bsrColIndC 定义的一般 BSR 格式的稀疏矩阵。

integer(4) function cusparseScsr2gebsr(handle, dir, m, n, descrA, csrValA, csrRowPtrA, csrColIndA, &
           descrC, bsrValC, bsrRowPtrC, bsrColIndC, rowBlockDimC, colBlockDimC, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: dir, mb, nb, nnzb
  type(cusparseMatDescr) :: descrA
  real(4), device :: csrValA(*), bsrValC(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseMatDescr) :: descrC
  integer(4), device :: bsrRowPtrC(*), bsrColIndC(*)
  integer(4) :: rowBlockDimC, colBlockDimC
  character(c_char), device :: pBuffer(*)

5.8.89. cusparseDcsr2gebsr

此函数将由三个数组 csrValA、csrRowPtrA 和 csrColIndA 定义的 CSR 存储格式的稀疏矩阵转换为由数组 bsrValC、bsrRowPtrC 和 bsrColIndC 定义的一般 BSR 格式的稀疏矩阵。

integer(4) function cusparseDcsr2gebsr(handle, dir, m, n, descrA, csrValA, csrRowPtrA, csrColIndA, &
           descrC, bsrValC, bsrRowPtrC, bsrColIndC, rowBlockDimC, colBlockDimC, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: dir, mb, nb, nnzb
  type(cusparseMatDescr) :: descrA
  real(8), device :: csrValA(*), bsrValC(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseMatDescr) :: descrC
  integer(4), device :: bsrRowPtrC(*), bsrColIndC(*)
  integer(4) :: rowBlockDimC, colBlockDimC
  character(c_char), device :: pBuffer(*)

5.8.90. cusparseCcsr2gebsr

此函数将由三个数组 csrValA、csrRowPtrA 和 csrColIndA 定义的 CSR 存储格式的稀疏矩阵转换为由数组 bsrValC、bsrRowPtrC 和 bsrColIndC 定义的一般 BSR 格式的稀疏矩阵。

integer(4) function cusparseCcsr2gebsr(handle, dir, m, n, descrA, csrValA, csrRowPtrA, csrColIndA, &
           descrC, bsrValC, bsrRowPtrC, bsrColIndC, rowBlockDimC, colBlockDimC, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: dir, mb, nb, nnzb
  type(cusparseMatDescr) :: descrA
  complex(4), device :: csrValA(*), bsrValC(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseMatDescr) :: descrC
  integer(4), device :: bsrRowPtrC(*), bsrColIndC(*)
  integer(4) :: rowBlockDimC, colBlockDimC
  character(c_char), device :: pBuffer(*)

5.8.91. cusparseZcsr2gebsr

此函数将由三个数组 csrValA、csrRowPtrA 和 csrColIndA 定义的 CSR 存储格式的稀疏矩阵转换为由数组 bsrValC、bsrRowPtrC 和 bsrColIndC 定义的一般 BSR 格式的稀疏矩阵。

integer(4) function cusparseZcsr2gebsr(handle, dir, m, n, descrA, csrValA, csrRowPtrA, csrColIndA, &
           descrC, bsrValC, bsrRowPtrC, bsrColIndC, rowBlockDimC, colBlockDimC, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: dir, mb, nb, nnzb
  type(cusparseMatDescr) :: descrA
  complex(8), device :: csrValA(*), bsrValC(*)
  integer(4), device :: csrRowPtrA(*), csrColIndA(*)
  type(cusparseMatDescr) :: descrC
  integer(4), device :: bsrRowPtrC(*), bsrColIndC(*)
  integer(4) :: rowBlockDimC, colBlockDimC
  character(c_char), device :: pBuffer(*)

5.8.92. cusparseCreateIdentityPermutation

此函数创建恒等映射。输出参数 p 通过 p = 0:1:(n-1) 表示此映射。此函数通常与 coosort、csrsort、cscsort 和 csr2csc_indexOnly 一起使用。

integer(4) function cusparseCreateIdentityPermutation(handle, n, p)
  type(cusparseHandle) :: handle
  integer(4) :: n
  integer(4), device :: p(*)

5.8.93. cusparseXcoosort_bufferSize

此函数返回 coosort 中使用的缓冲区大小。

integer(4) function cusparseXcoosort_bufferSize(handle, m, n, nnz, cooRows, cooCols, pBufferSizeInBytes)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, nnz
  integer(4), device :: cooRows(*), cooCols(*)
  integer(8) :: pBufferSizeInBytes

5.8.94. cusparseXcoosortByRow

此函数对以 COO 格式存储的稀疏矩阵进行排序。

integer(4) function cusparseXcoosortByRow(handle, m, n, nnz, cooRows, cooCols, P, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, nnz
  integer(4), device :: cooRows(*), cooCols(*), P(*)
  character(c_char), device :: pBuffer(*)

5.8.95. cusparseXcoosortByColumn

此函数对以 COO 格式存储的稀疏矩阵进行排序。

integer(4) function cusparseXcoosortByColumn(handle, m, n, nnz, cooRows, cooCols, P, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, nnz
  integer(4), device :: cooRows(*), cooCols(*), P(*)
  character(c_char), device :: pBuffer(*)

5.8.96. cusparseXcsrsort_bufferSize

此函数返回 csrsort 中使用的缓冲区大小。

integer(4) function cusparseXcsrsort_bufferSize(handle, m, n, nnz, csrRowInd, csrColInd, pBufferSizeInBytes)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, nnz
  integer(4), device :: csrRowInd(*), csrColInd(*)
  integer(8) :: pBufferSizeInBytes

5.8.97. cusparseXcsrsort

此函数对以 CSR 格式存储的稀疏矩阵进行排序。

integer(4) function cusparseXcsrsort(handle, m, n, nnz, csrRowInd, csrColInd, P, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, nnz
  integer(4), device :: csrRowInd(*), csrColInd(*), P(*)
  character(c_char), device :: pBuffer(*)

5.8.98. cusparseXcscsort_bufferSize

此函数返回 cscsort 中使用的缓冲区大小。

integer(4) function cusparseXcscsort_bufferSize(handle, m, n, nnz, cscColPtr, cscRowInd, pBufferSizeInBytes)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, nnz
  integer(4), device :: cscColPtr(*), cscRowInd(*)
  integer(8) :: pBufferSizeInBytes

5.8.99. cusparseXcscsort

此函数对以 CSC 格式存储的稀疏矩阵进行排序。

integer(4) function cusparseXcscsort(handle, m, n, nnz, cscColPtr, cscRowInd, P, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, nnz
  integer(4), device :: cscColPtr(*), cscRowInd(*), P(*)
  character(c_char), device :: pBuffer(*)

5.8.100. cusparseScsru2csr_bufferSize

此函数返回 csru2csr 中使用的缓冲区大小。

integer(4) function cusparseScsru2csr_bufferSize(handle, m, n, nnz, csrVal, csrRowPtr, csrColInd, info, pBufferSizeInBytes)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, nnz
  real(4), device :: csrVal(*)
  integer(4), device :: csrRowPtr(*), csrColInd(*)
  type(cusparseCsru2csrInfo) :: info
  integer(8) :: pBufferSizeInBytes

5.8.101. cusparseDcsru2csr_bufferSize

此函数返回 csru2csr 中使用的缓冲区大小。

integer(4) function cusparseDcsru2csr_bufferSize(handle, m, n, nnz, csrVal, csrRowPtr, csrColInd, info, pBufferSizeInBytes)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, nnz
  real(8), device :: csrVal(*)
  integer(4), device :: csrRowPtr(*), csrColInd(*)
  type(cusparseCsru2csrInfo) :: info
  integer(8) :: pBufferSizeInBytes

5.8.102. cusparseCcsru2csr_bufferSize

此函数返回 csru2csr 中使用的缓冲区大小。

integer(4) function cusparseCcsru2csr_bufferSize(handle, m, n, nnz, csrVal, csrRowPtr, csrColInd, info, pBufferSizeInBytes)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, nnz
  complex(4), device :: csrVal(*)
  integer(4), device :: csrRowPtr(*), csrColInd(*)
  type(cusparseCsru2csrInfo) :: info
  integer(8) :: pBufferSizeInBytes

5.8.103. cusparseZcsru2csr_bufferSize

此函数返回 csru2csr 中使用的缓冲区大小。

integer(4) function cusparseZcsru2csr_bufferSize(handle, m, n, nnz, csrVal, csrRowPtr, csrColInd, info, pBufferSizeInBytes)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, nnz
  complex(8), device :: csrVal(*)
  integer(4), device :: csrRowPtr(*), csrColInd(*)
  type(cusparseCsru2csrInfo) :: info
  integer(8) :: pBufferSizeInBytes

5.8.104. cusparseScsru2csr

此函数将未排序的 CSR 格式转换为 CSR 格式。

integer(4) function cusparseScsru2csr(handle, m, n, nnz, descrA, csrVal, csrRowPtr, csrColInd, info, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, nnz
  type(cusparseMatDescr) :: descrA
  real(4), device :: csrVal(*)
  integer(4), device :: csrRowPtr(*), csrColInd(*)
  type(cusparseCsru2csrInfo) :: info
  character(c_char), device :: pBuffer(*)

5.8.105. cusparseDcsru2csr

此函数将未排序的 CSR 格式转换为 CSR 格式。

integer(4) function cusparseDcsru2csr(handle, m, n, nnz, descrA, csrVal, csrRowPtr, csrColInd, info, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, nnz
  type(cusparseMatDescr) :: descrA
  real(8), device :: csrVal(*)
  integer(4), device :: csrRowPtr(*), csrColInd(*)
  type(cusparseCsru2csrInfo) :: info
  character(c_char), device :: pBuffer(*)

5.8.106. cusparseCcsru2csr

此函数将未排序的 CSR 格式转换为 CSR 格式。

integer(4) function cusparseCcsru2csr(handle, m, n, nnz, descrA, csrVal, csrRowPtr, csrColInd, info, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, nnz
  type(cusparseMatDescr) :: descrA
  complex(4), device :: csrVal(*)
  integer(4), device :: csrRowPtr(*), csrColInd(*)
  type(cusparseCsru2csrInfo) :: info
  character(c_char), device :: pBuffer(*)

5.8.107. cusparseZcsru2csr

此函数将未排序的 CSR 格式转换为 CSR 格式。

integer(4) function cusparseZcsru2csr(handle, m, n, nnz, descrA, csrVal, csrRowPtr, csrColInd, info, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, nnz
  type(cusparseMatDescr) :: descrA
  complex(8), device :: csrVal(*)
  integer(4), device :: csrRowPtr(*), csrColInd(*)
  type(cusparseCsru2csrInfo) :: info
  character(c_char), device :: pBuffer(*)

5.8.108. cusparseScsr2csru

此函数执行从排序的 CSR 格式到未排序的 CSR 格式的反向转换。

integer(4) function cusparseScsr2csru(handle, m, n, nnz, descrA, csrVal, csrRowPtr, csrColInd, info, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, nnz
  type(cusparseMatDescr) :: descrA
  real(4), device :: csrVal(*)
  integer(4), device :: csrRowPtr(*), csrColInd(*)
  type(cusparseCsru2csrInfo) :: info
  character(c_char), device :: pBuffer(*)

5.8.109. cusparseDcsr2csru

此函数执行从排序的 CSR 格式到未排序的 CSR 格式的反向转换。

integer(4) function cusparseDcsr2csru(handle, m, n, nnz, descrA, csrVal, csrRowPtr, csrColInd, info, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, nnz
  type(cusparseMatDescr) :: descrA
  real(8), device :: csrVal(*)
  integer(4), device :: csrRowPtr(*), csrColInd(*)
  type(cusparseCsru2csrInfo) :: info
  character(c_char), device :: pBuffer(*)

5.8.110. cusparseCcsr2csru

此函数执行从排序的 CSR 格式到未排序的 CSR 格式的反向转换。

integer(4) function cusparseCcsr2csru(handle, m, n, nnz, descrA, csrVal, csrRowPtr, csrColInd, info, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, nnz
  type(cusparseMatDescr) :: descrA
  complex(4), device :: csrVal(*)
  integer(4), device :: csrRowPtr(*), csrColInd(*)
  type(cusparseCsru2csrInfo) :: info
  character(c_char), device :: pBuffer(*)

5.8.111. cusparseZcsr2csru

此函数执行从排序的 CSR 格式到未排序的 CSR 格式的反向转换。

integer(4) function cusparseZcsr2csru(handle, m, n, nnz, descrA, csrVal, csrRowPtr, csrColInd, info, pBuffer)
  type(cusparseHandle) :: handle
  integer(4) :: m, n, nnz
  type(cusparseMatDescr) :: descrA
  complex(8), device :: csrVal(*)
  integer(4), device :: csrRowPtr(*), csrColInd(*)
  type(cusparseCsru2csrInfo) :: info
  character(c_char), device :: pBuffer(*)

5.9. CUSPARSE 通用 API 函数

本节包含用于执行向量-向量 (SpVV)、矩阵-向量 (SpMV) 和矩阵-矩阵 (SpMM) 运算的通用 API 函数的接口。

5.9.1. cusparseDenseToSparse_bufferSize

此函数返回 cusparseDenseToSparse_analysis() 所需的工作空间大小。返回的值以字节为单位。

integer(4) function cusparseDenseToSparse_bufferSize(handle, matA, matB, alg, bufferSize)
  type(cusparseHandle) :: handle
  type(cusparseDnMatDescr) :: MatA
  type(cusparseSpMatDescr) :: matB
  integer(4) :: alg
  integer(8), intent(out) :: bufferSize

5.9.2. cusparseDenseToSparse_analysis

此函数更新稀疏矩阵描述符 matB 中所需的非零元素数量。

integer(4) function cusparseDenseToSparse_analysis(handle, matA, matB, alg, buffer)
  type(cusparseHandle) :: handle
  type(cusparseDnMatDescr) :: matA
  type(cusparseSpMatDescr) :: matB
  integer(4) :: alg
  integer(4), device :: buffer(*)

5.9.3. cusparseDenseToSparse_convert

此函数在描述符 matB 中提供的区域中填充稀疏矩阵值。

integer(4) function cusparseDenseToSparse_convert(handle, matA, matB, alg, buffer)
  type(cusparseHandle) :: handle
  type(cusparseDnMatDescr) :: matA
  type(cusparseSpMatDescr) :: matB
  integer(4) :: alg
  integer(4), device :: buffer(*)

5.9.4. cusparseSparseToDense_bufferSize

此函数返回 cusparseSparseToDense_analysis() 所需的工作空间大小。返回的值以字节为单位。

integer(4) function cusparseSparseToDense_bufferSize(handle, matA, matB, alg, bufferSize)
  type(cusparseHandle) :: handle
  type(cusparseSpMatDescr) :: MatA
  type(cusparseDnMatDescr) :: matB
  integer(4) :: alg
  integer(8), intent(out) :: bufferSize

5.9.5. cusparseSparseToDense

此函数在描述符 matB 中提供的区域中填充稠密值。

integer(4) function cusparseSparseToDense(handle, matA, matB, alg, buffer)
  type(cusparseHandle) :: handle
  type(cusparseSpMatDescr) :: matA
  type(cusparseDnMatDescr) :: matB
  integer(4) :: alg
  integer(4), device :: buffer(*)

5.9.6. cusparseCreateSpVec

此函数初始化通用 API 中使用的稀疏向量描述符。输入参数 indices 和 values 的类型、种类和秩实际上被忽略，并从输入参数 idxType 和 valueType 中获取。向量被假定为连续的。idxBase 参数在 Fortran 中通常为 CUSPARSE_INDEX_BASE_ONE。

integer(4) function cusparseCreateSpVec(descr, size, nnz, indices, values, idxType, idxBase, valueType)
  type(cusparseSpVecDescr) :: descr
  integer(8) :: size, nnz
  integer(4), device :: indices(*)
  real(4), device    :: values(*)
  integer(4) :: idxType, idxBase, valueType

5.9.7. cusparseDestroySpVec

此函数释放与通用 API 中使用的稀疏向量描述符关联的主机内存。

integer(4) function cusparseDestroySpVec(descr)
  type(cusparseSpVecDescr) :: descr

5.9.8. cusparseSpVecGet

此函数返回通用 API 中使用的稀疏向量描述符中的字段。

integer(4) function cusparseSpVecGet(descr, size, nnz, indices, values, idxType, idxBase, valueType)
  type(cusparseSpVecDescr) :: descr
  integer(8) :: size, nnz
  type(c_devptr) :: indices
  type(c_devptr) :: values
  integer(4) :: idxType, idxBase, valueType

5.9.9. cusparseSpVecGetIndexBase

此函数返回通用 API 中使用的稀疏向量描述符中的 idxBase 字段。

integer(4) function cusparseSpVecGetIndexBase(descr, idxBase)
  type(cusparseSpVecDescr) :: descr
  integer(4) :: idxBase

5.9.10. cusparseSpVecGetValues

此函数返回通用 API 中使用的稀疏向量描述符中的 values 字段。

integer(4) function cusparseSpVecGetValues(descr, values)
  type(cusparseSpVecDescr) :: descr
  type(c_devptr) :: values

5.9.11. cusparseSpVecSetValues

此函数设置通用 API 中使用的稀疏向量描述符中的 values 字段。values 参数的类型、种类和秩被忽略；类型由描述符中的 valueType 字段确定。

integer(4) function cusparseSpVecSetValues(descr, values)
  type(cusparseSpVecDescr) :: descr
  real(4), device :: values(*)

5.9.12. cusparseCreateDnVec

此函数初始化通用 API 中使用的稠密向量描述符。values 输入参数的类型、种类和秩被忽略，并从输入参数 valueType 中获取。向量被假定为连续的。

integer(4) function cusparseCreateDnVec(descr, size, values, valueType)
  type(cusparseDnVecDescr) :: descr
  integer(8) :: size
  real(4), device    :: values(*)
  integer(4) :: valueType

5.9.13. cusparseDestroyDnVec

此函数释放与通用 API 中使用的稠密向量描述符关联的主机内存。

integer(4) function cusparseDestroyDnVec(descr)
  type(cusparseDnVecDescr) :: descr

5.9.14. cusparseDnVecGet

此函数返回通用 API 中使用的稠密向量描述符中的字段。

integer(4) function cusparseDnVecGet(descr, size, values, valueType)
  type(cusparseDnVecDescr) :: descr
  integer(8) :: size
  type(c_devptr) :: values
  integer(4) :: valueType

5.9.15. cusparseDnVecGetValues

此函数返回通用 API 中使用的稠密向量描述符中的 values 字段。

integer(4) function cusparseDnVecGetValues(descr, values)
  type(cusparseDnVecDescr) :: descr
  type(c_devptr) :: values

5.9.16. cusparseDnVecSetValues

此函数设置通用 API 中使用的稠密向量描述符中的 values 字段。values 参数的类型、种类和秩被忽略；类型由描述符中的 valueType 字段确定。

integer(4) function cusparseDnVecSetValues(descr, values)
  type(cusparseDnVecDescr) :: descr
  real(4), device :: values(*)

5.9.17. cusparseCreateCoo

此函数初始化通用 API 中使用的 COO 格式的稀疏矩阵描述符。输入参数 cooRowInd、cooColInd 和 cooValues 的类型、种类和秩实际上被忽略，并从输入参数 idxType 和 valueType 中获取。idxBase 参数在 Fortran 中通常为 CUSPARSE_INDEX_BASE_ONE。

integer(4) function cusparseCreateCoo(descr, rows, cols, nnz, cooRowInd, cooColInd, cooValues, idxType, idxBase, valueType)
  type(cusparseSpMatDescr) :: descr
  integer(8) :: rows, cols, nnz
  integer(4), device :: cooRowInd(*), cooColInd(*)
  real(4), device    :: cooValues(*)
  integer(4) :: idxType, idxBase, valueType

5.9.18. cusparseCreateCooAoS

此函数初始化通用 API 中使用的具有结构数组布局的 COO 格式的稀疏矩阵描述符。输入参数 cooInd 和 cooValues 的类型、种类和秩实际上被忽略，并从输入参数 idxType 和 valueType 中获取。idxBase 参数在 Fortran 中通常为 CUSPARSE_INDEX_BASE_ONE。

integer(4) function cusparseCreateCooAoS(descr, rows, cols, nnz, cooInd, cooValues, idxType, idxBase, valueType)
  type(cusparseSpMatDescr) :: descr
  integer(8) :: rows, cols, nnz
  integer(4), device :: cooInd(*)
  real(4), device    :: cooValues(*)
  integer(4) :: idxType, idxBase, valueType

5.9.19. cusparseCreateCsr

此函数初始化通用 API 中使用的 CSR 格式的稀疏矩阵描述符。输入参数 csrRowOffsets、csrColInd 和 csrValues 的类型、种类和秩实际上被忽略，并从输入参数 csrRowOffsetsType、csrColIndType 和 valueType 中获取。idxBase 参数在 Fortran 中通常为 CUSPARSE_INDEX_BASE_ONE。

integer(4) function cusparseCreateCsr(descr, rows, cols, nnz, csrRowOffsets, csrColInd, csrValues, &
           csrRowOffsetsType, csrColIndType, idxBase, valueType)
  type(cusparseSpMatDescr) :: descr
  integer(8) :: rows, cols, nnz
  integer(4), device :: csrRowOffsets(*), csrColInd(*)
  real(4), device    :: csrValues(*)
  integer(4) :: csrRowOffsetsType, csrColIndType, idxBase, valueType

5.9.20. cusparseCreateBlockedEll

此函数初始化通用 API 中使用的 Blocked-Ellpack (ELL) 格式的稀疏矩阵描述符。输入参数 ellColInd 和 ellValues 的类型、种类和秩实际上被忽略，并从输入参数 ellIdxType 和 valueType 中获取。idxBase 参数在 Fortran 中通常为 CUSPARSE_INDEX_BASE_ONE。

integer(4) function cusparseCreateBlockedEll(descr, rows, cols, &
       ellBlockSize, ellCols, ellColInd, ellValues, ellIdxType, idxBase, valueType)
  type(cusparseSpMatDescr) :: descr
  integer(8) :: rows, cols, ellBlockSize, ellCols
  integer(4), device :: ellColInd(*)
  real(4), device    :: ellValues(*)
  integer(4) :: ellIdxType, idxBase, valueType

5.9.21. cusparseDestroySpMat

此函数释放与通用 API 中使用的稀疏矩阵描述符关联的主机内存。

integer(4) function cusparseDestroySpMat(descr)
  type(cusparseSpMatDescr) :: descr

5.9.22. cusparseCooGet

此函数返回通用 API 中使用的 COO 格式的稀疏矩阵描述符中的字段。

integer(4) function cusparseCooGet(descr, rows, cols, nnz, cooRowInd, cooColInd, cooValues, idxType, idxBase, valueType)
  type(cusparseSpMatDescr) :: descr
  integer(8) :: rows, cols, nnz
  type(c_devptr) :: cooRowInd, cooColInd, cooValues
  integer(4) :: idxType, idxBase, valueType

5.9.23. cusparseCooAoSGet

此函数返回通用 API 中使用的结构数组布局的 COO 格式的稀疏矩阵描述符中的字段。

integer(4) function cusparseCooAoSGet(descr, rows, cols, nnz, cooInd, cooValues, idxType, idxBase, valueType)
  type(cusparseSpMatDescr) :: descr
  integer(8) :: rows, cols, nnz
  type(c_devptr) :: cooInd, cooValues
  integer(4) :: idxType, idxBase, valueType

5.9.24. cusparseCsrGet

此函数返回通用 API 中使用的 CSR 格式的稀疏矩阵描述符中的字段。

integer(4) function cusparseCsrGet(descr, rows, cols, nnz, csrRowOffsets, csrColInd, csrValues, &
           csrRowOffsetsType, crsColIndType, idxBase, valueType)
  type(cusparseSpMatDescr) :: descr
  integer(8) :: rows, cols, nnz
  type(c_devptr) :: csrRowOffsets, csrColInd, csrValues
  integer(4) :: csrRowOffsetsType, csrColIndType, idxBase, valueType

5.9.25. cusparseBlockedEllGet

此函数返回以 Blocked-Ellpack (ELL) 格式存储的稀疏矩阵描述符中的字段。

integer(4) function cusparseBlockedEllGet(descr, rows, cols, &
       ellBlockSize, ellCols, ellColInd, ellValues, ellIdxType, idxBase, valueType)
  type(cusparseSpMatDescr) :: descr
  integer(8) :: rows, cols, ellBlockSize, ellCols
  type(c_devptr) :: ellColInd, ellValues
  integer(4) :: ellIdxType, idxBase, valueType

5.9.26. cusparseCsrSetPointers

此函数设置通用 API 中使用的 CSR 格式的稀疏矩阵描述符中的指针。接受行偏移、列索引和值的任何类型。

integer(4) function cusparseCsrSetPointers(descr, csrRowOffsets, csrColInd, csrValues)
  type(cusparseSpMatDescr) :: descr
  integer(4), device :: csrRowOffsets(*), csrColInd(*)
  real(4), device :: csrValues(*)

5.9.27. cusparseCscSetPointers

此函数设置通用 API 中使用的 CSC 格式的稀疏矩阵描述符中的指针。接受列偏移、行索引和值的任何类型。

integer(4) function cusparseCscSetPointers(descr, cscColOffsets, cscRowInd, cscValues)
  type(cusparseSpMatDescr) :: descr
  integer(4), device :: cscColOffsets(*), cscRowInd(*)
  real(4), device :: cscValues(*)

5.9.28. cusparseSpMatGetFormat

此函数返回通用 API 中使用的稀疏矩阵描述符中的 format 字段。通用 API 的有效格式为 CUSPARSE_FORMAT_CSR、CUSPARSE_FORMAT_COO 和 CUSPARSE_FORMAT_COO_AOS。

integer(4) function cusparseSpMatGetFormat(descr, format)
  type(cusparseSpMatDescr) :: descr
  integer(4) :: format

5.9.29. cusparseSpMatGetIndexBase

此函数返回通用 API 中使用的稀疏矩阵描述符中的 idxBase 字段。

integer(4) function cusparseSpMatGetIndexBase(descr, idxBase)
  type(cusparseSpMatDescr) :: descr
  integer(4) :: idxBase

5.9.30. cusparseSpMatGetSize

此函数返回通用 API 中使用的稀疏矩阵描述符中的稀疏矩阵大小。

integer(4) function cusparseSpMatGetSize(descr, rows, cols, nnz)
  type(cusparseSpMatDescr) :: descr
  integer(8) :: rows, cols, nnz

5.9.31. cusparseSpMatGetValues

此函数返回通用 API 中使用的稀疏矩阵描述符中的 values 字段。

integer(4) function cusparseSpMatGetValues(descr, values)
  type(cusparseSpMatDescr) :: descr
  type(c_devptr) :: values

5.9.32. cusparseSpMatSetValues

此函数设置通用 API 中使用的稀疏矩阵描述符中的 values 字段。values 参数的类型、种类和秩被忽略；类型由描述符中的 valueType 字段确定。

integer(4) function cusparseSpMatSetValues(descr, values)
  type(cusparseSpMatDescr) :: descr
  real(4), device :: values(*)

5.9.33. cusparseSpMatGetStridedBatch

此函数返回通用 API 中使用的稀疏矩阵描述符中的 batchCount 字段。

integer(4) function cusparseSpMatGetStridedBatch(descr, batchCount)
  type(cusparseSpMatDescr) :: descr
  integer(4) :: batchCount

5.9.34. cusparseSpMatSetStridedBatch

此函数设置通用 API 中使用的稀疏矩阵描述符中的 batchCount 字段。它在版本 >= CUDA 12.0 中被移除。

integer(4) function cusparseSpMatSetStridedBatch(descr, batchCount)
  type(cusparseSpMatDescr) :: descr
  integer(4) :: batchCount

5.9.35. cusparseCooSetStridedBatch

此函数设置 COO 稀疏矩阵描述符中的 batchCount 和 batchStride 字段。

integer(4) function cusparseCooSetStridedBatch(descr, batchCount, &
      batchStride)
  type(cusparseSpMatDescr) :: descr
  integer(4) :: batchCount
  integer(8) :: batchStride

5.9.36. cusparseCsrSetStridedBatch

此函数设置 CSR 稀疏矩阵描述符中的 batchCount 和 batchStride 字段。

integer(4) function cusparseCsrSetStridedBatch(descr, batchCount, &
      offsetsBatchStride, columnsValuesBatchStride)
  type(cusparseSpMatDescr) :: descr
  integer(4) :: batchCount
  integer(8) :: offsetsBatchStride, columnsValuesBatchStride

5.9.37. cusparseBsrSetStridedBatch

此函数设置 BSR 稀疏矩阵描述符中的 batchCount 和 batchStride 字段。

integer(4) function cusparseBsrSetStridedBatch(descr, batchCount, &
      offsetsBatchStride, columnsBatchStride, valuesBatchStride)
  type(cusparseSpMatDescr) :: descr
  integer(4) :: batchCount
  integer(8) :: offsetsBatchStride, columnsBatchStride
  integer(8) :: valuesBatchStride

5.9.38. cusparseSpMatGetAttribute

此函数从通用 API 中使用的稀疏矩阵描述符返回稀疏矩阵属性。属性当前可以是 CUSPARSE_SPMAT_FILL_MODE 或 CUSPARSE_SPMAT_DIAG_TYPE。

integer(4) function cusparseSpMatGetAttribute(descr, attribute, data, dataSize)
  type(cusparseSpMatDescr), intent(in) :: descr
  integer(4), intent(in)  :: attribute
  integer(4), intent(out) :: data
  integer(8), intent(in)  :: dataSize

5.9.39. cusparseSpMatSetAttribute

此函数为通用 API 中使用的稀疏矩阵描述符设置稀疏矩阵属性。属性当前可以是 CUSPARSE_SPMAT_FILL_MODE 或 CUSPARSE_SPMAT_DIAG_TYPE。

integer(4) function cusparseSpMatSetAttribute(descr, attribute, data, dataSize)
  type(cusparseSpMatDescr), intent(out) :: descr
  integer(4), intent(in) :: attribute
  integer(4), intent(in) :: data
  integer(8), intent(in) :: dataSize

5.9.40. cusparseCreateDnMat

此函数初始化通用 API 中使用的稠密矩阵描述符。values 输入参数的类型、种类和秩被忽略，并从输入参数 valueType 中获取。Fortran 中的 order 参数通常应为 CUSPARSE_ORDER_COL。

integer(4) function cusparseCreateDnMat(descr, rows, cols, ld, values, valueType, order)
  type(cusparseDnMatDescr) :: descr
  integer(8) :: rows, cols, ld
  real(4), device    :: values(*)
  integer(4), value  :: valueType, order

5.9.41. cusparseDestroyDnMat

此函数释放与通用 API 中使用的稠密矩阵描述符关联的主机内存。

integer(4) function cusparseDestroyDnMat(descr)
  type(cusparseDnMatDescr) :: descr

5.9.42. cusparseDnMatGet

此函数返回通用 API 中使用的稠密矩阵描述符中的字段。

integer(4) function cusparseDnMatGet(descr, rows, cols, ld, values, valueType, order)
  type(cusparseDnMatDescr) :: descr
  integer(8) :: rows, cols, ld
  type(c_devptr) :: values
  integer(4) :: valueType, order

5.9.43. cusparseDnMatGetValues

此函数返回通用 API 中使用的稠密矩阵描述符中的 values 字段。

integer(4) function cusparseDnMatGetValues(descr, values)
  type(cusparseDnMatDescr) :: descr
  type(c_devptr) :: values

5.9.44. cusparseDnMatSetValues

此函数设置通用 API 中使用的稠密矩阵描述符中的 values 字段。values 参数的类型、种类和秩被忽略；类型由描述符中的 valueType 字段确定。

integer(4) function cusparseDnMatSetValues(descr, values)
  type(cusparseDnMatDescr) :: descr
  real(4), device :: values(*)

5.9.45. cusparseDnMatGetStridedBatch

此函数返回通用 API 中使用的稠密矩阵描述符中的 batchCount 字段。

integer(4) function cusparseDnMatGetStridedBatch(descr, batchCount)
  type(cusparseDnMatDescr) :: descr
  integer(4) :: batchCount

5.9.46. cusparseDnMatSetStridedBatch

此函数设置通用 API 中使用的稠密矩阵描述符中的 batchCount 字段。

integer(4) function cusparseDnMatSetStridedBatch(descr, batchCount)
  type(cusparseDnMatDescr) :: descr
  integer(4) :: batchCount

5.9.47. cusparseSpVV_bufferSize

此函数返回 cusparseSpVV() 所需的工作空间大小。返回的值以字节为单位。

integer(4) function cusparseSpVV_bufferSize(handle, opX, vecX, vecY, result, computeType, bufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: opX
  type(cusparseSpVecDescr) :: vecX
  type(cusparseDnVecDescr) :: vecY
  real(4), device    :: result ! device or host variable
  integer(4) :: computeType
  integer(8), intent(out) :: bufferSize

5.9.48. cusparseSpVV

此函数形成稀疏向量 vecX 和稠密向量 vecY 的点积。buffer 参数可以是任何类型，但大小应大于或等于从 cusparseSpVV_buffersize() 返回的大小。有关每个版本中支持的数据类型和 computetype 组合，请参阅 cuSPARSE 库文档。

integer(4) function cusparseSpVV(handle, opX, vecX, vecY, result, computeType, buffer)
  type(cusparseHandle) :: handle
  integer(4) :: opX
  type(cusparseSpVecDescr) :: vecX
  type(cusparseDnVecDescr) :: vecY
  real(4), device    :: result ! device or host variable
  integer(4) :: computeType
  integer(4), device :: buffer(*)

5.9.49. cusparseSpMV_bufferSize

此函数返回 cusparseSpMV() 所需的工作空间大小。返回的值以字节为单位。

integer(4) function cusparseSpMV_bufferSize(handle, opA, alpha, matA, vecX, beta, vecY, computeType, alg, bufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: opA
  real(4) :: alpha, beta ! device or host variable
  type(cusparseSpMatDescr) :: matA
  type(cusparseDnVecDescr) :: vecX, vecY
  integer(4) :: computeType, alg
  integer(8), intent(out) :: bufferSize

5.9.50. cusparseSpMV

此函数形成稀疏矩阵 matA 和稠密向量 vecX 的乘法，以生成稠密向量 vecY。buffer 参数可以是任何类型，但大小应大于或等于从 cusparseSpMV_buffersize() 返回的大小。参数 alpha 和 beta 的类型应与 computeType 参数匹配。有关每个版本中支持的数据类型、computeType、稀疏格式和 alg 组合，请参阅 cuSPARSE 库文档。

integer(4) function cusparseSpMV(handle, opA, alpha, matA, vecX, beta, vecY, computeType, alg, buffer)
  type(cusparseHandle) :: handle
  integer(4) :: opA
  real(4), device :: alpha, beta ! device or host variable
  type(cusparseSpMatDescr) :: matA
  type(cusparseDnVecDescr) :: vecX, vecY
  integer(4) :: computeType, alg
  integer(4), device :: buffer(*)

5.9.51. cusparseSpSV_CreateDescr

此函数初始化用于求解稀疏三角系统的稀疏矩阵描述符。

integer(4) function cusparseSpSV_CreateDescr(descr)
  type(cusparseSpSVDescr) :: descr

5.9.52. cusparseSpSV_DestroyDescr

此函数释放并销毁用于求解稀疏三角系统的稀疏矩阵描述符。

integer(4) function cusparseSpSV_DestroyDescr(descr)
  type(cusparseSpSVDescr) :: descr

5.9.53. cusparseSpSV_bufferSize

此函数返回 cusparseSpSV() 所需的工作空间大小。返回的值以字节为单位。

integer(4) function cusparseSpSV_bufferSize(handle, opA, alpha, matA, vecX, vecY, &
  computeType, alg, spsvDescr, bufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: opA
  real(4) :: alpha ! device or host variable
  type(cusparseSpMatDescr) :: matA
  type(cusparseDnVecDescr) :: vecX, vecY
  integer(4) :: computeType, alg
  type(cusparseSpSVDescr) :: spsvDescr
  integer(8), intent(out) :: bufferSize

5.9.54. cusparseSpSV_analysis

此函数执行 cusparseSpSV() 所需的分析阶段。

integer(4) function cusparseSpSV_analysis(handle, opA, alpha, matA, vecX, vecY, &
  computeType, alg, spsvDescr, buffer)
  type(cusparseHandle) :: handle
  integer(4) :: opA
  real(4) :: alpha ! device or host variable
  type(cusparseSpMatDescr) :: matA
  type(cusparseDnVecDescr) :: vecX, vecY
  integer(4) :: computeType, alg
  type(cusparseSpSVDescr) :: spsvDescr
  integer(4), device :: buffer(*)

5.9.55. cusparseSpSV_solve

此函数执行稀疏三角线性系统的求解阶段。

integer(4) function cusparseSpSV_analysis(handle, opA, alpha, matA, vecX, vecY, &
  computeType, alg, spsvDescr)
  type(cusparseHandle) :: handle
  integer(4) :: opA
  real(4) :: alpha ! device or host variable
  type(cusparseSpMatDescr) :: matA
  type(cusparseDnVecDescr) :: vecX, vecY
  integer(4) :: computeType, alg
  type(cusparseSpSVDescr) :: spsvDescr

5.9.56. cusparseSpSV_updateMatrix

此函数更新 cusparseSpSV() 使用的稀疏矩阵中的值。值类型应与稀疏矩阵类型匹配。更新可以是针对整个矩阵 CUSPARSE_SPSV_UPDATE_GENERAL，也可以是针对对角线 CUSPARSE_SPSV_UPDATE_DIAGONAL。

integer(4) function cusparseSpSV_updateMatrix(handle, spsvDescr, &
      newValues, updatePart)
  type(cusparseHandle) :: handle
  type(cusparseSpSVDescr) :: spsvDescr
  real(4), device :: newValues(*)  ! Any type, same as the Matrix
  integer(4) :: updatePart  ! General or Diagonal

5.9.57. cusparseSpMM_bufferSize

此函数返回 cusparseSpMM() 所需的工作空间大小。返回的值以字节为单位。

integer(4) function cusparseSpMM_bufferSize(handle, opA, opB, alpha, matA, matB, beta, matC, computeType, alg, bufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: opA, opB
  real(4), device :: alpha, beta ! device or host variable
  type(cusparseSpMatDescr) :: matA
  type(cusparseDnMatDescr) :: matB, matC
  integer(4) :: computeType, alg
  integer(8), intent(out) :: bufferSize

5.9.58. cusparseSpMM_preprocess

此函数可用于加速 cusparseSpMM 计算。有关每个版本中支持的功能，请参阅 cuSPARSE 库文档。

integer(4) function cusparseSpMM_preprocess(handle, opA, opB, alpha, matA, matB, beta, matC, computeType, alg, buffer)
  type(cusparseHandle) :: handle
  integer(4) :: opA, opB
  real(4), device :: alpha, beta ! device or host variable
  type(cusparseSpMatDescr) :: matA
  type(cusparseDnMatDescr) :: matB, matC
  integer(4) :: computeType, alg
  integer(4), device :: buffer(*)

5.9.59. cusparseSpMM

此函数形成稀疏矩阵 matA 和稠密矩阵 matB 的乘法，以生成稠密矩阵 matC。buffer 参数可以是任何类型，但大小应大于或等于从 cusparseSpMM_buffersize() 返回的大小。参数 alpha 和 beta 的类型应与 computeType 参数匹配。有关每个版本中支持的数据类型、computeType、稀疏格式和 alg 组合，请参阅 cuSPARSE 库文档。

integer(4) function cusparseSpMM(handle, opA, opB, alpha, matA, matB, beta, matC, computeType, alg, buffer)
  type(cusparseHandle) :: handle
  integer(4) :: opA, opB
  real(4), device :: alpha, beta ! device or host variable
  type(cusparseSpMatDescr) :: matA
  type(cusparseDnMatDescr) :: matB, matC
  integer(4) :: computeType, alg
  integer(4), device :: buffer(*)

5.9.60. cusparseSpSM_CreateDescr

此函数初始化用于求解稀疏三角系统的稀疏矩阵描述符，当存在多个 RHS 向量时。

integer(4) function cusparseSpSM_CreateDescr(descr)
  type(cusparseSpSMDescr) :: descr

5.9.61. cusparseSpSM_DestroyDescr

此函数释放并销毁用于求解稀疏三角系统的稀疏矩阵描述符。

integer(4) function cusparseSpSM_DestroyDescr(descr)
  type(cusparseSpSMDescr) :: descr

5.9.62. cusparseSpSM_bufferSize

此函数返回 cusparseSpSM() 所需的工作空间大小。返回的值以字节为单位。

integer(4) function cusparseSpSM_bufferSize(handle, opA, opB, alpha, matA, matB, matC, &
  computeType, alg, spsmDescr, bufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: opA, opB
  real(4) :: alpha ! device or host variable
  type(cusparseSpMatDescr) :: matA
  type(cusparseDnMatDescr) :: MatB, MatC
  integer(4) :: computeType, alg
  type(cusparseSpSMDescr) :: spsmDescr
  integer(8), intent(out) :: bufferSize

5.9.63. cusparseSpSM_analysis

此函数执行 cusparseSpSM() 所需的分析阶段。

integer(4) function cusparseSpSM_analysis(handle, opA, opB, alpha, &
  matA, matB, matC, computeType, alg, spsmDescr, buffer)
  type(cusparseHandle) :: handle
  integer(4) :: opA, opB
  real(4) :: alpha ! device or host variable
  type(cusparseSpMatDescr) :: matA
  type(cusparseDnMatDescr) :: matB, matC
  integer(4) :: computeType, alg
  type(cusparseSpMVDescr) :: spsmDescr
  integer(4), device :: buffer(*)

5.9.64. cusparseSpSM_solve

此函数执行稀疏三角线性系统的求解阶段。

integer(4) function cusparseSpSM_analysis(handle, opA, opB, &
  alpha, matA, matB, matC, computeType, alg, spsmDescr)
  type(cusparseHandle) :: handle
  integer(4) :: opA, opB
  real(4) :: alpha ! device or host variable
  type(cusparseSpMatDescr) :: matA
  type(cusparseDnMatDescr) :: matB, matC
  integer(4) :: computeType, alg
  type(cusparseSpSMDescr) :: spsmDescr

5.9.65. cusparseSDDMM_bufferSize

此函数返回 cusparseSDDMM() 所需的工作空间大小。返回的值以字节为单位。

integer(4) function cusparseSDDMM_bufferSize(handle, opA, opB, alpha, matA, matB, beta, matC, computeType, alg, bufferSize)
  type(cusparseHandle) :: handle
  integer(4) :: opA, opB
  real(4), device :: alpha, beta ! device or host variable
  type(cusparseDnMatDescr) :: matA, matB
  type(cusparseSpMatDescr) :: matC
  integer(4) :: computeType, alg
  integer(8), intent(out) :: bufferSize

5.9.66. cusparseSDDMM_preprocess

此函数可用于加速 cusparseSDDMM 计算。有关每个版本中支持的功能，请参阅 cuSPARSE 库文档。

integer(4) function cusparseSDDMM_preprocess(handle, opA, opB, alpha, matA, matB, beta, matC, computeType, alg, buffer)
  type(cusparseHandle) :: handle
  integer(4) :: opA, opB
  real(4), device :: alpha, beta ! device or host variable
  type(cusparseDnMatDescr) :: matA, matB
  type(cusparseSpMatDescr) :: matC
  integer(4) :: computeType, alg
  integer(4), device :: buffer(*)

5.9.67. cusparseSDDMM

此函数形成稠密矩阵 matA 和稠密矩阵 matB 的乘法，然后与矩阵 matC 的稀疏模式进行逐元素乘法。buffer 参数可以是任何类型，但大小应大于或等于从 cusparseSDDMM_buffersize() 返回的大小。参数 alpha 和 beta 的类型应与 computeType 参数匹配。有关每个版本中支持的数据类型、computeType、稀疏格式和 alg 组合，请参阅 cuSPARSE 库文档。

integer(4) function cusparseSDDMM(handle, opA, opB, alpha, matA, matB, beta, matC, computeType, alg, buffer)
  type(cusparseHandle) :: handle
  integer(4) :: opA, opB
  real(4), device :: alpha, beta ! device or host variable
  type(cusparseDnMatDescr) :: matA, matB
  type(cusparseSpMatDescr) :: matC
  integer(4) :: computeType, alg
  integer(4), device :: buffer(*)

5.9.68. cusparseSpGEMM_CreateDescr

此函数初始化用于将两个稀疏矩阵相乘的稀疏矩阵描述符。

integer(4) function cusparseSpGEMM_CreateDescr(descr)
  type(cusparseSpGEMMDescr) :: descr

5.9.69. cusparseSpGEMM_DestroyDescr

此函数释放并销毁用于将两个稀疏矩阵相乘的稀疏矩阵描述符。

integer(4) function cusparseSpGEMM_DestroyDescr(descr)
  type(cusparseSpGEMMDescr) :: descr

5.9.70. cusparseSpGEMM_workEstimation

此函数以及 cusparseSpGEMM_compute() 都用于确定缓冲区需求和执行实际计算。在典型用法中，对 cusparseSgGEMM_workEstimation() 的第一次调用应为 buffer1 传递空指针。该函数将返回所需的大小要求。分配该空间后，应使用实际分配的 buffer1 参数再次调用 cusparseSpGEMM_workEstimation()。

integer(4) function cusparseSpGEMM_workEstimation(handle, opA, opB, &
  alpha, matA, matB, beta, matC, computeType, alg, spgemmDescr, bufferSize1, buffer1)
  type(cusparseHandle) :: handle
  integer(4) :: opA, opB
  real(4) :: alpha, beta ! device or host variable
  type(cusparseSpMatDescr) :: matA, MatB, MatC
  integer(4) :: computeType, alg
  type(cusparseSpGEMMDescr) :: spgemmDescr
  integer(8) :: bufferSize1
  integer(4), device :: buffer1

5.9.71. cusparseSpGEMM_getNumProducts

此函数查询稀疏矩阵描述符以获取中间产品的数量。

integer(4) function cusparseSpGEMM_getNumProducts(descr, num_prods)
  type(cusparseSpGEMMDescr) :: descr
  integer(8) :: num_prods

5.9.72. cusparseSpGEMM_estimateMemory

此函数以及 cusparseSpGEMM_compute() 和 cusparseSpGEMM_workEstimation() 用于确定执行 SpGEMM 算法 2 和 3 的内存需求。

integer(4) function cusparseSpGEMM_estimateMemory(handle, opA, opB, &
  alpha, matA, matB, beta, matC, computeType, alg, spgemmDescr, &
  chunk_fraction, bufferSize3, buffer3, bufferSize2)
  type(cusparseHandle) :: handle
  integer(4) :: opA, opB
  real(4) :: alpha, beta ! device or host variable
  type(cusparseSpMatDescr) :: matA, MatB, MatC
  integer(4) :: computeType, alg
  type(cusparseSpGEMMDescr) :: spgemmDescr
  real(4) :: chunk_fraction
  integer(8) :: bufferSize3
  integer(4), device :: buffer3  ! Any type is okay
  integer(8) :: bufferSize2

5.9.73. cusparseSpGEMM_compute

此函数与 cusparseSpGEMM_workEstimation() 一起使用，用于确定缓冲区需求和执行实际计算。在典型用法中，首次调用 cusparseSgGEMM_compute() 时，应为 buffer2 传递空指针。该函数将返回所需的空间大小。一旦分配了该空间，应使用实际分配的 buffer2 参数再次调用 cusparseSpGEMM_compute()。

integer(4) function cusparseSpGEMM_compute(handle, opA, opB, &
  alpha, matA, matB, beta, matC, computeType, alg, spgemmDescr, bufferSize2, buffer2)
  type(cusparseHandle) :: handle
  integer(4) :: opA, opB
  real(4) :: alpha, beta ! device or host variable
  type(cusparseSpMatDescr) :: matA, MatB, MatC
  integer(4) :: computeType, alg
  type(cusparseSpGEMMDescr) :: spgemmDescr
  integer(8) :: bufferSize2
  integer(4), device :: buffer2

5.9.74. cusparseSpGEMM_copy

此函数与 cusparseSpGEMM_workEstimation() 和 cusparseSgGEMM_compute() 一起用于执行稀疏矩阵乘法。工作缓冲区的指针保存在 spgemmDescr 参数中。

integer(4) function cusparseSpGEMM_copy(handle, opA, opB, &
  alpha, matA, matB, beta, matC, computeType, alg, spgemmDescr)
  type(cusparseHandle) :: handle
  integer(4) :: opA, opB
  real(4) :: alpha, beta ! device or host variable
  type(cusparseSpMatDescr) :: matA, MatB, MatC
  integer(4) :: computeType, alg
  type(cusparseSpGEMMDescr) :: spgemmDescr

以下是执行稀疏矩阵乘法所需的一组调用的示例

! Create a csr descriptor for sparse C.  Sizes unknown
status = cusparseCreateCsr(matC, nd, nd, 0, nullp, nullp, &
           nullp, CUSPARSE_INDEX_32I, CUSPARSE_INDEX_32I, &
           CUSPARSE_INDEX_BASE_ONE, CUDA_R_64F)
call printStatus('cusparseCreateCsr', status, CUSPARSE_STATUS_SUCCESS)

status = cusparseSpGEMM_workEstimation(h, CUSPARSE_OPERATION_NON_TRANSPOSE, &
         CUSPARSE_OPERATION_NON_TRANSPOSE, Dalpha, matA, matB, Dbeta, &
         matC, CUDA_R_64F, CUSPARSE_SPGEMM_DEFAULT, spgemmd, bsize, nullp)
call printStatus('cusparseSpGEMM_workEstimation', status, CUSPARSE_STATUS_SUCCESS)

print *,"SpGEMM buffersize1 required: ",bsize
if (bsize.gt.0) allocate(buffer_d(bsize))

status = cusparseSpGEMM_workEstimation(h, CUSPARSE_OPERATION_NON_TRANSPOSE, &
         CUSPARSE_OPERATION_NON_TRANSPOSE, Dalpha, matA, matB, Dbeta, &
         matC, CUDA_R_64F, CUSPARSE_SPGEMM_DEFAULT, spgemmd, bsize, buffer_d)
call printStatus('cusparseSpGEMM_workEstimation', status, CUSPARSE_STATUS_SUCCESS)

status = cusparseSpGEMM_compute(h, CUSPARSE_OPERATION_NON_TRANSPOSE, &
         CUSPARSE_OPERATION_NON_TRANSPOSE, Dalpha, matA, matB, Dbeta, &
         matC, CUDA_R_64F, CUSPARSE_SPGEMM_DEFAULT, spgemmd, bsize2, nullp)
call printStatus('cusparseSpGEMM_compute', status, CUSPARSE_STATUS_SUCCESS)

print *,"SpGEMM buffersize2 required: ",bsize2
if (bsize2.gt.0) allocate(buffer2_d(bsize2))

status = cusparseSpGEMM_compute(h, CUSPARSE_OPERATION_NON_TRANSPOSE, &
         CUSPARSE_OPERATION_NON_TRANSPOSE, Dalpha, matA, matB, Dbeta, &
         matC, CUDA_R_64F, CUSPARSE_SPGEMM_DEFAULT, spgemmd, bsize2, buffer2_d)
call printStatus('cusparseSpGEMM_compute', status, CUSPARSE_STATUS_SUCCESS)

status = cusparseSpMatGetSize(matC, nrows, ncols, nnz)
print *,"SpGEMM C matrix sizes: ",nrows, ncols, nnz
if (nrows.gt.0) allocate(csrRowPtrC_d(nrows+1))
if (nnz.gt.0) allocate(csrColIndC_d(nnz))
if (nnz.gt.0) allocate(csrValDC_d(nnz))

status = cusparseCsrSetPointers(matC, csrRowPtrC_d, csrColIndC_d, csrValDC_d)
call printStatus('cusparseCsrSetPointers', status, CUSPARSE_STATUS_SUCCESS)

status = cusparseSpGEMM_copy(h, CUSPARSE_OPERATION_NON_TRANSPOSE, &
         CUSPARSE_OPERATION_NON_TRANSPOSE, Dalpha, matA, matB, Dbeta, &
         matC, CUDA_R_64F, CUSPARSE_SPGEMM_DEFAULT, spgemmd)
call printStatus('cusparseSpGEMM_copy', status, CUSPARSE_STATUS_SUCCESS)

if (bsize.gt.0) deallocate(buffer_d)
if (bsize2.gt.0) deallocate(buffer2_d)

5.9.75. cusparseSpGEMMreuse_workEstimation

此函数以及 cusparseSpGEMM_compute() 都用于确定缓冲区需求和执行实际计算。在典型用法中，对 cusparseSgGEMM_workEstimation() 的第一次调用应为 buffer1 传递空指针。该函数将返回所需的大小要求。分配该空间后，应使用实际分配的 buffer1 参数再次调用 cusparseSpGEMM_workEstimation()。

integer(4) function cusparseSpGEMMreuse_workEstimation(handle, opA, opB, &
  alpha, matA, matB, beta, matC, computeType, alg, spgemmDescr, bufferSize1, buffer1)
  type(cusparseHandle) :: handle
  integer(4) :: opA, opB
  real(4) :: alpha, beta ! device or host variable
  type(cusparseSpMatDescr) :: matA, MatB, MatC
  integer(4) :: computeType, alg
  type(cusparseSpGEMMDescr) :: spgemmDescr
  integer(8) :: bufferSize1
  integer(4), device :: buffer1

5.9.76. cusparseSpGEMMreuse_nnz

此函数以及 cusparseSpGEMM_compute() 都用于确定缓冲区需求和执行实际计算。在典型用法中，对 cusparseSgGEMM_workEstimation() 的第一次调用应为 buffer1 传递空指针。该函数将返回所需的大小要求。分配该空间后，应使用实际分配的 buffer1 参数再次调用 cusparseSpGEMM_workEstimation()。

integer(4) function cusparseSpGEMMreuse_nnz(handle, opA, opB, &
      alpha, matA, matB, beta, matC, computeType, alg, spgemmDescr, bufferSize2, buffer2, &
      bufferSize3, buffer3, bufferSize4, buffer4)
  type(cusparseHandle) :: handle
  integer(4) :: opA, opB
  real(4) :: alpha, beta ! device or host variable
  type(cusparseSpMatDescr) :: matA, MatB, MatC
  integer(4) :: computeType, alg
  type(cusparseSpGEMMDescr) :: spgemmDescr
  integer(8) :: bufferSize2, bufferSize3, bufferSize4
  integer(4), device :: buffer2, buffer3, buffer4

5.9.77. cusparseSpGEMMreuse_copy

此函数以及 cusparseSpGEMM_compute() 都用于确定缓冲区需求和执行实际计算。在典型用法中，对 cusparseSgGEMM_workEstimation() 的第一次调用应为 buffer1 传递空指针。该函数将返回所需的大小要求。分配该空间后，应使用实际分配的 buffer1 参数再次调用 cusparseSpGEMM_workEstimation()。

integer(4) function cusparseSpGEMMreuse_copy(handle, opA, opB, &
  alpha, matA, matB, beta, matC, computeType, alg, spgemmDescr, bufferSize5, buffer5)
  type(cusparseHandle) :: handle
  integer(4) :: opA, opB
  real(4) :: alpha, beta ! device or host variable
  type(cusparseSpMatDescr) :: matA, MatB, MatC
  integer(4) :: computeType, alg
  type(cusparseSpGEMMDescr) :: spgemmDescr
  integer(8) :: bufferSize5
  integer(4), device :: buffer5

5.9.78. cusparseSpGEMMreuse_compute

此函数以及 cusparseSpGEMM_compute() 都用于确定缓冲区需求和执行实际计算。在典型用法中，对 cusparseSgGEMM_workEstimation() 的第一次调用应为 buffer1 传递空指针。该函数将返回所需的大小要求。分配该空间后，应使用实际分配的 buffer1 参数再次调用 cusparseSpGEMM_workEstimation()。

integer(4) function cusparseSpGEMMreuse_compute(handle, opA, opB, &
  alpha, matA, matB, beta, matC, computeType, alg, spgemmDescr)
  type(cusparseHandle) :: handle
  integer(4) :: opA, opB
  real(4) :: alpha, beta ! device or host variable
  type(cusparseSpMatDescr) :: matA, MatB, MatC
  integer(4) :: computeType, alg
  type(cusparseSpGEMMDescr) :: spgemmDescr

6. 矩阵求解器运行时库 API

本节介绍 CUDA cuSOLVER 库的 Fortran 接口。cuSOLVER 函数只能从主机代码访问。所有运行时 API 例程都是返回错误代码的整数函数；如果调用成功，它们将返回值 CUSOLVER_STATUS_SUCCESS，如果出现错误，则返回另一个 cuSOLVER 状态返回值。

目前，我们为 cuSolverDN（密集 LAPACK 函数）提供 Fortran 接口。

第 10 章包含从 OpenACC 和 CUDA Fortran 访问 cuSOLVER 库例程的示例。在这两种情况下，可以通过添加以下行来公开库的接口

use cusolverDn

到您的程序单元。

除非提供了特定的 kind，否则接口中使用的普通 integer 类型表示 integer(4)，而普通 real 类型表示 real(4)。

6.1. CUSOLVER 定义和辅助函数

本节包含 cuSOLVER 库中使用的定义和数据类型，以及 cuSOLVER 辅助函数的接口。

cuSOLVER 模块包含以下派生类型定义

! Definitions from cusolver_common.h
integer, parameter :: CUSOLVER_VER_MAJOR = 11
integer, parameter :: CUSOLVER_VER_MINOR = 6
integer, parameter :: CUSOLVER_VER_PATCH = 4

cuSOLVER 模块包含以下枚举

enum, bind(c)
    enumerator :: CUSOLVER_STATUS_SUCCESS                   = 0
    enumerator :: CUSOLVER_STATUS_NOT_INITIALIZED           = 1
    enumerator :: CUSOLVER_STATUS_ALLOC_FAILED              = 2
    enumerator :: CUSOLVER_STATUS_INVALID_VALUE             = 3
    enumerator :: CUSOLVER_STATUS_ARCH_MISMATCH             = 4
    enumerator :: CUSOLVER_STATUS_MAPPING_ERROR             = 5
    enumerator :: CUSOLVER_STATUS_EXECUTION_FAILED          = 6
    enumerator :: CUSOLVER_STATUS_INTERNAL_ERROR            = 7
    enumerator :: CUSOLVER_STATUS_MATRIX_TYPE_NOT_SUPPORTED = 8
    enumerator :: CUSOLVER_STATUS_NOT_SUPPORTED             = 9
    enumerator :: CUSOLVER_STATUS_ZERO_PIVOT                = 10
    enumerator :: CUSOLVER_STATUS_INVALID_LICENSE           = 11
    enumerator :: CUSOLVER_STATUS_IRS_PARAMS_NOT_INITIALIZED= 12
    enumerator :: CUSOLVER_STATUS_IRS_PARAMS_INVALID        = 13
    enumerator :: CUSOLVER_STATUS_IRS_PARAMS_INVALID_PREC   = 14
    enumerator :: CUSOLVER_STATUS_IRS_PARAMS_INVALID_REFINE = 15
    enumerator :: CUSOLVER_STATUS_IRS_PARAMS_INVALID_MAXITER= 16
    enumerator :: CUSOLVER_STATUS_IRS_INTERNAL_ERROR        = 20
    enumerator :: CUSOLVER_STATUS_IRS_NOT_SUPPORTED         = 21
    enumerator :: CUSOLVER_STATUS_IRS_OUT_OF_RANGE          = 22
    enumerator :: CUSOLVER_STATUS_IRS_NRHS_NOT_SUPPORTED_FOR_REFINE_GMRES=23
    enumerator :: CUSOLVER_STATUS_IRS_INFOS_NOT_INITIALIZED = 25
    enumerator :: CUSOLVER_STATUS_IRS_INFOS_NOT_DESTROYED   = 26
    enumerator :: CUSOLVER_STATUS_IRS_MATRIX_SINGULAR       = 30
    enumerator :: CUSOLVER_STATUS_INVALID_WORKSPACE         = 31
end enum

enum, bind(c)
    enumerator :: CUSOLVER_EIG_TYPE_1 = 1
    enumerator :: CUSOLVER_EIG_TYPE_2 = 2
    enumerator :: CUSOLVER_EIG_TYPE_3 = 3
end enum

enum, bind(c)
    enumerator :: CUSOLVER_EIG_MODE_NOVECTOR = 0
    enumerator :: CUSOLVER_EIG_MODE_VECTOR   = 1
end enum

enum, bind(c)
    enumerator :: CUSOLVER_EIG_RANGE_ALL = 1001
    enumerator :: CUSOLVER_EIG_RANGE_I   = 1002
    enumerator :: CUSOLVER_EIG_RANGE_V   = 1003
end enum

enum, bind(c)
    enumerator :: CUSOLVER_INF_NORM = 104
    enumerator :: CUSOLVER_MAX_NORM = 105
    enumerator :: CUSOLVER_ONE_NORM = 106
    enumerator :: CUSOLVER_FRO_NORM = 107
end enum

enum, bind(c)
    enumerator :: CUSOLVER_IRS_REFINE_NOT_SET          = 1100
    enumerator :: CUSOLVER_IRS_REFINE_NONE             = 1101
    enumerator :: CUSOLVER_IRS_REFINE_CLASSICAL        = 1102
    enumerator :: CUSOLVER_IRS_REFINE_CLASSICAL_GMRES  = 1103
    enumerator :: CUSOLVER_IRS_REFINE_GMRES            = 1104
    enumerator :: CUSOLVER_IRS_REFINE_GMRES_GMRES      = 1105
    enumerator :: CUSOLVER_IRS_REFINE_GMRES_NOPCOND    = 1106

    enumerator :: CUSOLVER_PREC_DD           = 1150
    enumerator :: CUSOLVER_PREC_SS           = 1151
    enumerator :: CUSOLVER_PREC_SHT          = 1152
end enum

enum, bind(c)
    enumerator :: CUSOLVER_R_8I  = 1201
    enumerator :: CUSOLVER_R_8U  = 1202
    enumerator :: CUSOLVER_R_64F = 1203
    enumerator :: CUSOLVER_R_32F = 1204
    enumerator :: CUSOLVER_R_16F = 1205
    enumerator :: CUSOLVER_R_16BF  = 1206
    enumerator :: CUSOLVER_R_TF32  = 1207
    enumerator :: CUSOLVER_R_AP  = 1208
    enumerator :: CUSOLVER_C_8I  = 1211
    enumerator :: CUSOLVER_C_8U  = 1212
    enumerator :: CUSOLVER_C_64F = 1213
    enumerator :: CUSOLVER_C_32F = 1214
    enumerator :: CUSOLVER_C_16F = 1215
    enumerator :: CUSOLVER_C_16BF  = 1216
    enumerator :: CUSOLVER_C_TF32  = 1217
    enumerator :: CUSOLVER_C_AP  = 1218
end enum

enum, bind(c)
    enumerator :: CUSOLVER_ALG_0 = 0
    enumerator :: CUSOLVER_ALG_1 = 1
end enum

enum, bind(c)
    enumerator :: CUBLAS_STOREV_COLUMNWISE = 0
    enumerator :: CUBLAS_STOREV_ROWWISE    = 1
end enum

enum, bind(c)
    enumerator :: CUBLAS_DIRECT_FORWARD    = 0
    enumerator :: CUBLAS_DIRECT_BACKWARD   = 1
end enum

cuSOLVERDN 模块包含以下枚举和类型定义

type cusolverDnHandle
  type(c_ptr) :: handle
end type

type cusolverDnParams
  type(c_ptr) :: params
end type

type cusolverDnSyevjInfo
  type(c_ptr) :: info
end type

enum, bind(c)
    enumerator :: CUSOLVERDN_GETRF = 0
end enum

6.1.1. cusolverDnCreate

此函数初始化 cusolverDn 库，并在 cusolverDn 上下文中创建句柄。必须在调用任何其他 cuSolverDn API 函数之前调用它。它分配访问 GPU 所需的硬件资源。

integer(4) function cusolverDnCreate(handle)
  type(cusolverDnHandle) :: handle

6.1.2. cusolverDnDestroy

此函数释放 cuSolverDn 库使用的 CPU 端资源。

integer(4) function cusolverDnDestroy(handle)
  type(cusolverDnHandle) :: handle

6.1.3. cusolverDnCreateParams

此函数创建 64 位 API 结构并将其初始化为默认值。

integer(4) function cusolverDnCreateParams(params)
  type(cusolverDnParams) :: params

6.1.4. cusolverDnDestroyParams

此函数释放 64 位 API 结构使用的任何资源。

integer(4) function cusolverDnDestroyParams(params)
  type(cusolverDnParams) :: params

6.1.5. cusolverDnCreateSyevjInfo

此函数创建 Syevj API 结构并将其初始化为默认值。

integer(4) function cusolverDnCreateSyevjInfo(info)
  type(cusolverDnSyevjInfo) :: info

6.1.6. cusolverDnDestroySyevjInfo

此函数释放 Syevj API 结构使用的任何资源。

integer(4) function cusolverDnDestroySyevjInfo(info)
  type(cusolverDnSyevjInfo) :: info

6.1.7. cusolverDnSetAdvOptions

此函数配置 64 位 API 中使用的算法。

integer(4) function cusolverDnSetAdvOptions(params, function, algo)
   type(cusolverDnParams) :: params
   integer(4) :: function, algo

6.1.8. cusolverDnGetStream

此函数获取 cuSolverDn 库用于执行其例程的流。

integer(4) function cusolverDnGetStream(handle, stream)
  type(cusolverDnHandle) :: handle
  integer(cuda_stream_kind) :: stream

6.1.9. cusolverDnSetStream

此函数设置 cuSolverDn 库用于执行其例程的流。

integer(4) function cusolverDnSetStream(handle, stream)
  type(cusolverDnHandle) :: handle
  integer(cuda_stream_kind) :: stream

6.1.10. cusolverDnXsyevjSetTolerance

此函数配置 Xsyevj 函数中使用的容差值。

integer(4) function cusolverDnXsyevjSetTolerance(info, tolerance)
   type(cusolverSyevjInfo) :: info
   real(8) :: tolerance

6.1.11. cusolverDnXsyevjSetMaxSweeps

此函数设置 Xsyevj 函数中使用的最大扫描次数。

integer(4) function cusolverDnXsyevjSetMaxSweeps(info, sweeps)
   type(cusolverSyevjInfo) :: info
   integer(4) :: sweeps

6.1.12. cusolverDnXsyevjSetSortEig

此函数设置 Xsyevj 函数中使用的排序行为。

integer(4) function cusolverDnXsyevjSetSortEig(info, sort_eig)
   type(cusolverSyevjInfo) :: info
   integer(4) :: sort_eig

6.1.13. cusolverDnXsyevjGetResidual

此函数提供执行 Xsyevj 函数后的残差。

integer(4) function cusolverDnXsyevjGetResidual(handle, info, residual)
   type(cusolverDnHandle)  :: handle
   type(cusolverSyevjInfo) :: info
   real(8) :: residual

6.1.14. cusolverDnXsyevjGetSweeps

此函数提供执行 Xsyevj 函数后使用的扫描次数。

integer(4) function cusolverDnXsyevjGetSweeps(handle, info, sweeps)
   type(cusolverDnHandle)  :: handle
   type(cusolverSyevjInfo) :: info
   integer(4) :: sweeps

6.2. cusolverDn 传统 API

本节介绍 cusolverDn 的线性求解器传统 API，包括 Cholesky 分解、带部分主元的 LU 分解、QR 分解和 Bunch-Kaufman (LDLT) 分解。

6.2.1. cusolverDnSpotrf_buffersize

此函数计算传递到 cusolverDnSpotrf 的设备工作空间所需的缓冲区大小

integer function cusolverDnSpotrf_buffersize(handle, &
    uplo, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda
    real(4), device, dimension(lda,*) :: A
    integer(4) :: lwork

6.2.2. cusolverDnDpotrf_buffersize

此函数计算传递到 cusolverDnDpotrf 的设备工作空间所需的缓冲区大小

integer function cusolverDnDpotrf_buffersize(handle, &
    uplo, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda
    real(8), device, dimension(lda,*) :: A
    integer(4) :: lwork

6.2.3. cusolverDnCpotrf_buffersize

此函数计算传递到 cusolverDnCpotrf 的设备工作空间所需的缓冲区大小

integer function cusolverDnCpotrf_buffersize(handle, &
    uplo, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda
    complex(4), device, dimension(lda,*) :: A
    integer(4) :: lwork

6.2.4. cusolverDnZpotrf_buffersize

此函数计算传递到 cusolverDnZpotrf 的设备工作空间所需的缓冲区大小

integer function cusolverDnZpotrf_buffersize(handle, &
    uplo, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda
    complex(8), device, dimension(lda,*) :: A
    integer(4) :: lwork

6.2.5. cusolverDnSpotrf

此函数计算 Hermitian 正定矩阵的 Cholesky 分解

integer function cusolverDnSpotrf(handle, &
    uplo, n, A, lda, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.2.6. cusolverDnDpotrf

此函数计算 Hermitian 正定矩阵的 Cholesky 分解

integer function cusolverDnDpotrf(handle, &
    uplo, n, A, lda, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.2.7. cusolverDnCpotrf

此函数计算 Hermitian 正定矩阵的 Cholesky 分解

integer function cusolverDnCpotrf(handle, &
    uplo, n, A, lda, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.2.8. cusolverDnZpotrf

此函数计算 Hermitian 正定矩阵的 Cholesky 分解

integer function cusolverDnZpotrf(handle, &
    uplo, n, A, lda, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.2.9. cusolverDnSpotrs

此函数使用 cusolverDnSpotrf 求解 Hermitian 正定矩阵的 Cholesky 分解产生的线性方程组

integer function cusolverDnSpotrs(handle, &
    uplo, n, nrhs, A, lda, B, ldb, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, nrhs, lda, ldb
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(ldb,*) :: B
    integer(4), device, intent(out) :: devinfo

6.2.10. cusolverDnDpotrs

此函数使用 cusolverDnDpotrf 求解 Hermitian 正定矩阵的 Cholesky 分解产生的线性方程组

integer function cusolverDnDpotrs(handle, &
    uplo, n, nrhs, A, lda, B, ldb, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, nrhs, lda, ldb
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(ldb,*) :: B
    integer(4), device, intent(out) :: devinfo

6.2.11. cusolverDnCpotrs

此函数使用 cusolverDnCpotrf 求解 Hermitian 正定矩阵的 Cholesky 分解产生的线性方程组

integer function cusolverDnCpotrs(handle, &
    uplo, n, nrhs, A, lda, B, ldb, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, nrhs, lda, ldb
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(ldb,*) :: B
    integer(4), device, intent(out) :: devinfo

6.2.12. cusolverDnZpotrs

此函数使用 cusolverDnZpotrf 求解 Hermitian 正定矩阵的 Cholesky 分解产生的线性方程组

integer function cusolverDnZpotrs(handle, &
    uplo, n, nrhs, A, lda, B, ldb, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, nrhs, lda, ldb
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(ldb,*) :: B
    integer(4), device, intent(out) :: devinfo

6.2.13. cusolverDnSpotrfBatched

此函数计算一系列 Hermitian 正定矩阵的 Cholesky 分解

integer function cusolverDnSpotrfBatched(handle, &
    uplo, n, Aarray, lda, devinfo, batchCount)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, batchCount
    type(c_devptr), device :: Aarray(*)
    integer(4), device, intent(out) :: devinfo

6.2.14. cusolverDnDpotrfBatched

此函数计算一系列 Hermitian 正定矩阵的 Cholesky 分解

integer function cusolverDnDpotrfBatched(handle, &
    uplo, n, Aarray, lda, devinfo, batchCount)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, batchCount
    type(c_devptr), device :: Aarray(*)
    integer(4), device, intent(out) :: devinfo

6.2.15. cusolverDnCpotrfBatched

此函数计算一系列 Hermitian 正定矩阵的 Cholesky 分解

integer function cusolverDnCpotrfBatched(handle, &
    uplo, n, Aarray, lda, devinfo, batchCount)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, batchCount
    type(c_devptr), device :: Aarray(*)
    integer(4), device, intent(out) :: devinfo

6.2.16. cusolverDnZpotrfBatched

此函数计算一系列 Hermitian 正定矩阵的 Cholesky 分解

integer function cusolverDnZpotrfBatched(handle, &
    uplo, n, Aarray, lda, devinfo, batchCount)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, batchCount
    type(c_devptr), device :: Aarray(*)
    integer(4), device, intent(out) :: devinfo

6.2.17. cusolverDnSpotrsBatched

此函数使用 cusolverDnSpotrfBatched 求解一系列 Hermitian 正定矩阵的 Cholesky 分解产生的一系列线性方程组

integer function cusolverDnSpotrsBatched(handle, &
    uplo, n, nrhs, Aarray, lda, Barray, ldb, devinfo, batchCount)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, nrhs, lda, ldb, batchCount
    type(c_devptr), device :: Aarray(*)
    type(c_devptr), device :: Barray(*)
    integer(4), device, intent(out) :: devinfo

6.2.18. cusolverDnDpotrsBatched

此函数使用 cusolverDnDpotrfBatched 求解一系列 Hermitian 正定矩阵的 Cholesky 分解产生的一系列线性方程组

integer function cusolverDnDpotrsBatched(handle, &
    uplo, n, nrhs, Aarray, lda, Barray, ldb, devinfo, batchCount)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, nrhs, lda, ldb, batchCount
    type(c_devptr), device :: Aarray(*)
    type(c_devptr), device :: Barray(*)
    integer(4), device, intent(out) :: devinfo

6.2.19. cusolverDnCpotrsBatched

此函数使用 cusolverDnCpotrfBatched 求解一系列 Hermitian 正定矩阵的 Cholesky 分解产生的一系列线性方程组

integer function cusolverDnCpotrsBatched(handle, &
    uplo, n, nrhs, Aarray, lda, Barray, ldb, devinfo, batchCount)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, nrhs, lda, ldb, batchCount
    type(c_devptr), device :: Aarray(*)
    type(c_devptr), device :: Barray(*)
    integer(4), device, intent(out) :: devinfo

6.2.20. cusolverDnZpotrsBatched

此函数使用 cusolverDnZpotrfBatched 求解一系列 Hermitian 正定矩阵的 Cholesky 分解产生的一系列线性方程组

integer function cusolverDnZpotrsBatched(handle, &
    uplo, n, nrhs, Aarray, lda, Barray, ldb, devinfo, batchCount)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, nrhs, lda, ldb, batchCount
    type(c_devptr), device :: Aarray(*)
    type(c_devptr), device :: Barray(*)
    integer(4), device, intent(out) :: devinfo

6.2.21. cusolverDnSpotri_buffersize

此函数计算传递到 cusolverDnSpotri 的设备工作空间所需的缓冲区大小

integer function cusolverDnSpotri_buffersize(handle, &
    uplo, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda
    real(4), device, dimension(lda,*) :: A
    integer(4) :: lwork

6.2.22. cusolverDnDpotri_buffersize

此函数计算传递到 cusolverDnDpotri 的设备工作空间所需的缓冲区大小

integer function cusolverDnDpotri_buffersize(handle, &
    uplo, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda
    real(8), device, dimension(lda,*) :: A
    integer(4) :: lwork

6.2.23. cusolverDnCpotri_buffersize

此函数计算传递到 cusolverDnCpotri 的设备工作空间所需的缓冲区大小

integer function cusolverDnCpotri_buffersize(handle, &
    uplo, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda
    complex(4), device, dimension(lda,*) :: A
    integer(4) :: lwork

6.2.24. cusolverDnZpotri_buffersize

此函数计算传递到 cusolverDnZpotri 的设备工作空间所需的缓冲区大小

integer function cusolverDnZpotri_buffersize(handle, &
    uplo, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda
    complex(8), device, dimension(lda,*) :: A
    integer(4) :: lwork

6.2.25. cusolverDnSpotri

此函数使用 cusolverDnSpotrf 计算的 Cholesky 分解来计算正定矩阵的逆矩阵。

integer function cusolverDnSpotri(handle, &
    uplo, n, A, lda, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.2.26. cusolverDnDpotri

此函数使用 cusolverDnDpotrf 计算的 Cholesky 分解来计算正定矩阵的逆矩阵。

integer function cusolverDnDpotri(handle, &
    uplo, n, A, lda, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.2.27. cusolverDnCpotri

此函数使用 cusolverDnCpotrf 计算的 Cholesky 分解来计算正定矩阵的逆矩阵。

integer function cusolverDnCpotri(handle, &
    uplo, n, A, lda, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.2.28. cusolverDnZpotri

此函数使用 cusolverDnZpotrf 计算的 Cholesky 分解来计算正定矩阵的逆矩阵。

integer function cusolverDnZpotri(handle, &
    uplo, n, A, lda, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.2.29. cusolverDnStrtri_buffersize

此函数计算传递到 cusolverDnStrtri 的设备工作空间所需的缓冲区大小

integer function cusolverDnStrtri_buffersize(handle, &
    uplo, diag, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo, diag
    integer(4) :: n, lda
    real(4), device, dimension(lda,*) :: A
    integer(4) :: lwork

6.2.30. cusolverDnDtrtri_buffersize

此函数计算传递到 cusolverDnDtrtri 的设备工作空间所需的缓冲区大小

integer function cusolverDnDtrtri_buffersize(handle, &
    uplo, diag, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo, diag
    integer(4) :: n, lda
    real(8), device, dimension(lda,*) :: A
    integer(4) :: lwork

6.2.31. cusolverDnCtrtri_buffersize

此函数计算传递到 cusolverDnCtrtri 的设备工作空间所需的缓冲区大小

integer function cusolverDnCtrtri_buffersize(handle, &
    uplo, diag, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo, diag
    integer(4) :: n, lda
    complex(4), device, dimension(lda,*) :: A
    integer(4) :: lwork

6.2.32. cusolverDnZtrtri_buffersize

此函数计算传递到 cusolverDnZtrtri 的设备工作空间所需的缓冲区大小

integer function cusolverDnZtrtri_buffersize(handle, &
    uplo, diag, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo, diag
    integer(4) :: n, lda
    complex(8), device, dimension(lda,*) :: A
    integer(4) :: lwork

6.2.33. cusolverDnStrtri

此函数计算上三角或下三角矩阵 A 的逆矩阵。它通常由 cusolverDnSpotri 调用。

integer function cusolverDnStrtri(handle, &
    uplo, diag, n, A, lda, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo, diag
    integer(4) :: n, lda, lwork
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.2.34. cusolverDnDtrtri

此函数计算上三角或下三角矩阵 A 的逆矩阵。它通常由 cusolverDnDpotri 调用。

integer function cusolverDnDtrtri(handle, &
    uplo, diag, n, A, lda, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo, diag
    integer(4) :: n, lda, lwork
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.2.35. cusolverDnCtrtri

此函数计算上三角或下三角矩阵 A 的逆矩阵。它通常由 cusolverDnCpotri 调用。

integer function cusolverDnCtrtri(handle, &
    uplo, diag, n, A, lda, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo, diag
    integer(4) :: n, lda, lwork
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.2.36. cusolverDnZtrtri

此函数计算上三角或下三角矩阵 A 的逆矩阵。它通常由 cusolverDnZpotri 调用。

integer function cusolverDnZtrtri(handle, &
    uplo, diag, n, A, lda, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo, diag
    integer(4) :: n, lda, lwork
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.2.37. cusolverDnSlauum_buffersize

此函数计算传递到 cusolverDnSlauum 的设备工作空间所需的缓冲区大小

integer function cusolverDnSlauum_buffersize(handle, &
    uplo, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda
    real(4), device, dimension(lda,*) :: A
    integer(4) :: lwork

6.2.38. cusolverDnDlauum_buffersize

此函数计算传递到 cusolverDnDlauum 的设备工作空间所需的缓冲区大小

integer function cusolverDnDlauum_buffersize(handle, &
    uplo, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda
    real(8), device, dimension(lda,*) :: A
    integer(4) :: lwork

6.2.39. cusolverDnClauum_buffersize

此函数计算传递到 cusolverDnClauum 的设备工作空间所需的缓冲区大小

integer function cusolverDnClauum_buffersize(handle, &
    uplo, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda
    complex(4), device, dimension(lda,*) :: A
    integer(4) :: lwork

6.2.40. cusolverDnZlauum_buffersize

此函数计算传递到 cusolverDnZlauum 的设备工作空间所需的缓冲区大小

integer function cusolverDnZlauum_buffersize(handle, &
    uplo, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda
    complex(8), device, dimension(lda,*) :: A
    integer(4) :: lwork

6.2.41. cusolverDnSlauum

此函数计算乘积 U * U**T 或 L**T * L。它通常由 cusolverDnSpotri 调用。

integer function cusolverDnSlauum(handle, &
    uplo, n, A, lda, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.2.42. cusolverDnDlauum

此函数计算乘积 U * U**T 或 L**T * L。它通常由 cusolverDnDpotri 调用。

integer function cusolverDnDlauum(handle, &
    uplo, n, A, lda, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.2.43. cusolverDnClauum

此函数计算乘积 U * U**T 或 L**T * L。它通常由 cusolverDnCpotri 调用。

integer function cusolverDnClauum(handle, &
    uplo, n, A, lda, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.2.44. cusolverDnZlauum

此函数计算乘积 U * U**T 或 L**T * L。它通常由 cusolverDnZpotri 调用。

integer function cusolverDnZlauum(handle, &
    uplo, n, A, lda, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.2.45. cusolverDnSgetrf_buffersize

此函数计算传递到 cusolverDnSgetrf 的设备工作空间所需的缓冲区大小

integer function cusolverDnSgetrf_buffersize(handle, &
    m, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda
    real(4), device, dimension(lda,*) :: A
    integer(4) :: lwork

6.2.46. cusolverDnDgetrf_buffersize

此函数计算传递到 cusolverDnDgetrf 的设备工作空间所需的缓冲区大小

integer function cusolverDnDgetrf_buffersize(handle, &
    m, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda
    real(8), device, dimension(lda,*) :: A
    integer(4) :: lwork

6.2.47. cusolverDnCgetrf_buffersize

此函数计算传递到 cusolverDnCgetrf 的设备工作空间所需的缓冲区大小

integer function cusolverDnCgetrf_buffersize(handle, &
    m, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda
    complex(4), device, dimension(lda,*) :: A
    integer(4) :: lwork

6.2.48. cusolverDnZgetrf_buffersize

此函数计算传递到 cusolverDnZgetrf 的设备工作空间所需的缓冲区大小

integer function cusolverDnZgetrf_buffersize(handle, &
    m, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda
    complex(8), device, dimension(lda,*) :: A
    integer(4) :: lwork

6.2.49. cusolverDnSgetrf

此函数计算一般 mxn 矩阵的 LU 分解

integer function cusolverDnSgetrf(handle, &
    m, n, A, lda, workspace, devipiv, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(*) :: workspace
    integer(4), device, dimension(*) :: devipiv
    integer(4), device, intent(out) :: devinfo

6.2.50. cusolverDnDgetrf

此函数计算一般 mxn 矩阵的 LU 分解

integer function cusolverDnDgetrf(handle, &
    m, n, A, lda, workspace, devipiv, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(*) :: workspace
    integer(4), device, dimension(*) :: devipiv
    integer(4), device, intent(out) :: devinfo

6.2.51. cusolverDnCgetrf

此函数计算一般 mxn 矩阵的 LU 分解

integer function cusolverDnCgetrf(handle, &
    m, n, A, lda, workspace, devipiv, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(*) :: workspace
    integer(4), device, dimension(*) :: devipiv
    integer(4), device, intent(out) :: devinfo

6.2.52. cusolverDnZgetrf

此函数计算一般 mxn 矩阵的 LU 分解

integer function cusolverDnZgetrf(handle, &
    m, n, A, lda, workspace, devipiv, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(*) :: workspace
    integer(4), device, dimension(*) :: devipiv
    integer(4), device, intent(out) :: devinfo

6.2.53. cusolverDnSgetrs

此函数使用 cusolverDnSgetrf 求解矩阵的 LU 分解产生的线性方程组

integer function cusolverDnSgetrs(handle, &
    trans, n, nrhs, A, lda, devipiv, B, ldb, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: trans
    integer(4) :: n, nrhs, lda, ldb
    real(4), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    real(4), device, dimension(ldb,*) :: B
    integer(4), device, intent(out) :: devinfo

6.2.54. cusolverDnDgetrs

此函数使用 cusolverDnDgetrf 求解矩阵的 LU 分解产生的线性方程组

integer function cusolverDnDgetrs(handle, &
    trans, n, nrhs, A, lda, devipiv, B, ldb, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: trans
    integer(4) :: n, nrhs, lda, ldb
    real(8), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    real(8), device, dimension(ldb,*) :: B
    integer(4), device, intent(out) :: devinfo

6.2.55. cusolverDnCgetrs

此函数使用 cusolverDnCgetrf 求解矩阵的 LU 分解产生的线性方程组

integer function cusolverDnCgetrs(handle, &
    trans, n, nrhs, A, lda, devipiv, B, ldb, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: trans
    integer(4) :: n, nrhs, lda, ldb
    complex(4), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    complex(4), device, dimension(ldb,*) :: B
    integer(4), device, intent(out) :: devinfo

6.2.56. cusolverDnZgetrs

此函数使用 cusolverDnZgetrf 求解矩阵的 LU 分解产生的线性方程组

integer function cusolverDnZgetrs(handle, &
    trans, n, nrhs, A, lda, devipiv, B, ldb, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: trans
    integer(4) :: n, nrhs, lda, ldb
    complex(8), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    complex(8), device, dimension(ldb,*) :: B
    integer(4), device, intent(out) :: devinfo

6.2.57. cusolverDnSlaswp

此函数执行行主元。它通常由 cusolverDnSgetrf 调用。

integer function cusolverDnSlaswp(handle, &
    n, A, lda, k1, k2, devipiv, incx)
    type(cusolverDnHandle) :: handle
    integer(4) :: n, lda, k1, k2, incx
    real(4), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv

6.2.58. cusolverDnDlaswp

此函数执行行主元。它通常由 cusolverDnDgetrf 调用。

integer function cusolverDnDlaswp(handle, &
    n, A, lda, k1, k2, devipiv, incx)
    type(cusolverDnHandle) :: handle
    integer(4) :: n, lda, k1, k2, incx
    real(8), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv

6.2.59. cusolverDnClaswp

此函数执行行主元。它通常由 cusolverDnCgetrf 调用。

integer function cusolverDnClaswp(handle, &
    n, A, lda, k1, k2, devipiv, incx)
    type(cusolverDnHandle) :: handle
    integer(4) :: n, lda, k1, k2, incx
    complex(4), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv

6.2.60. cusolverDnZlaswp

此函数执行行主元。它通常由 cusolverDnZgetrf 调用。

integer function cusolverDnZlaswp(handle, &
    n, A, lda, k1, k2, devipiv, incx)
    type(cusolverDnHandle) :: handle
    integer(4) :: n, lda, k1, k2, incx
    complex(8), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv

6.2.61. cusolverDnSgeqrf_buffersize

此函数计算传递到 cusolverDnSgeqrf 的设备工作空间所需的缓冲区大小

integer function cusolverDnSgeqrf_buffersize(handle, &
    m, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda
    real(4), device, dimension(lda,*) :: A
    integer(4) :: lwork

6.2.62. cusolverDnDgeqrf_buffersize

此函数计算传递到 cusolverDnDgeqrf 的设备工作空间所需的缓冲区大小

integer function cusolverDnDgeqrf_buffersize(handle, &
    m, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda
    real(8), device, dimension(lda,*) :: A
    integer(4) :: lwork

6.2.63. cusolverDnCgeqrf_buffersize

此函数计算传递到 cusolverDnCgeqrf 的设备工作空间所需的缓冲区大小

integer function cusolverDnCgeqrf_buffersize(handle, &
    m, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda
    complex(4), device, dimension(lda,*) :: A
    integer(4) :: lwork

6.2.64. cusolverDnZgeqrf_buffersize

此函数计算传递到 cusolverDnZgeqrf 的设备工作空间所需的缓冲区大小

integer function cusolverDnZgeqrf_buffersize(handle, &
    m, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda
    complex(8), device, dimension(lda,*) :: A
    integer(4) :: lwork

6.2.65. cusolverDnSgeqrf

此函数计算 mxn 矩阵的 QR 分解

integer function cusolverDnSgeqrf(handle, &
    m, n, A, lda, tau, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda, lwork
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(*) :: tau
    real(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.2.66. cusolverDnDgeqrf

此函数计算 mxn 矩阵的 QR 分解

integer function cusolverDnDgeqrf(handle, &
    m, n, A, lda, tau, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda, lwork
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(*) :: tau
    real(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.2.67. cusolverDnCgeqrf

此函数计算 mxn 矩阵的 QR 分解

integer function cusolverDnCgeqrf(handle, &
    m, n, A, lda, tau, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda, lwork
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(*) :: tau
    complex(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.2.68. cusolverDnZgeqrf

此函数计算 mxn 矩阵的 QR 分解

integer function cusolverDnZgeqrf(handle, &
    m, n, A, lda, tau, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda, lwork
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(*) :: tau
    complex(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.2.69. cusolverDnSorgqr_buffersize

此函数计算传递到 cusolverDnSorgqr 的设备工作空间所需的缓冲区大小

integer function cusolverDnSorgqr_buffersize(handle, &
    m, n, k, A, lda, tau, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, k, lda
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(*) :: tau
    integer(4) :: lwork

6.2.70. cusolverDnDorgqr_buffersize

此函数计算传递到 cusolverDnDorgqr 的设备工作空间所需的缓冲区大小

integer function cusolverDnDorgqr_buffersize(handle, &
    m, n, k, A, lda, tau, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, k, lda
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(*) :: tau
    integer(4) :: lwork

6.2.71. cusolverDnCorgqr_buffersize

此函数计算传递到 cusolverDnCorgqr 的设备工作空间所需的缓冲区大小

integer function cusolverDnCorgqr_buffersize(handle, &
    m, n, k, A, lda, tau, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, k, lda
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(*) :: tau
    integer(4) :: lwork

6.2.72. cusolverDnZorgqr_buffersize

此函数计算传递到 cusolverDnZorgqr 的设备工作空间所需的缓冲区大小

integer function cusolverDnZorgqr_buffersize(handle, &
    m, n, k, A, lda, tau, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, k, lda
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(*) :: tau
    integer(4) :: lwork

6.2.73. cusolverDnSorgqr

此函数从 mxn 矩阵的 QR 分解生成酉矩阵 Q

integer function cusolverDnSorgqr(handle, &
    m, n, k, A, lda, tau, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, k, lda, lwork
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(*) :: tau
    real(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.2.74. cusolverDnDorgqr

此函数从 mxn 矩阵的 QR 分解生成酉矩阵 Q

integer function cusolverDnDorgqr(handle, &
    m, n, k, A, lda, tau, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, k, lda, lwork
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(*) :: tau
    real(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.2.75. cusolverDnCorgqr

此函数从 mxn 矩阵的 QR 分解生成酉矩阵 Q

integer function cusolverDnCorgqr(handle, &
    m, n, k, A, lda, tau, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, k, lda, lwork
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(*) :: tau
    complex(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.2.76. cusolverDnZorgqr

此函数从 mxn 矩阵的 QR 分解生成酉矩阵 Q

integer function cusolverDnZorgqr(handle, &
    m, n, k, A, lda, tau, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, k, lda, lwork
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(*) :: tau
    complex(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.2.77. cusolverDnSormqr_buffersize

此函数计算传递到 cusolverDnSormqr 的设备工作空间所需的缓冲区大小

integer function cusolverDnSormqr_buffersize(handle, &
    side, trans, m, n, k, A, lda, tau, C, ldc, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: side, trans
    integer(4) :: m, n, k, lda, ldc
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(*) :: tau
    real(4), device, dimension(ldc,*) :: C
    integer(4) :: lwork

6.2.78. cusolverDnDormqr_buffersize

此函数计算传递到 cusolverDnDormqr 的设备工作空间所需的缓冲区大小

integer function cusolverDnDormqr_buffersize(handle, &
    side, trans, m, n, k, A, lda, tau, C, ldc, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: side, trans
    integer(4) :: m, n, k, lda, ldc
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(*) :: tau
    real(8), device, dimension(ldc,*) :: C
    integer(4) :: lwork

6.2.79. cusolverDnCormqr_buffersize

此函数计算传递到 cusolverDnCormqr 的设备工作空间所需的缓冲区大小

integer function cusolverDnCormqr_buffersize(handle, &
    side, trans, m, n, k, A, lda, tau, C, ldc, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: side, trans
    integer(4) :: m, n, k, lda, ldc
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(*) :: tau
    complex(4), device, dimension(ldc,*) :: C
    integer(4) :: lwork

6.2.80. cusolverDnZormqr_buffersize

此函数计算传递到 cusolverDnZormqr 的设备工作空间所需的缓冲区大小

integer function cusolverDnZormqr_buffersize(handle, &
    side, trans, m, n, k, A, lda, tau, C, ldc, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: side, trans
    integer(4) :: m, n, k, lda, ldc
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(*) :: tau
    complex(8), device, dimension(ldc,*) :: C
    integer(4) :: lwork

6.2.81. cusolverDnSormqr

此函数从 mxn 矩阵的 QR 分解生成酉矩阵 Q，并根据 side 和 trans 参数覆盖数组 C。

integer function cusolverDnSormqr(handle, &
    side, trans, m, n, k, A, lda, tau, C, ldc, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: side, trans
    integer(4) :: m, n, k, lda, ldc, lwork
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(*) :: tau
    real(4), device, dimension(ldc,*) :: C
    real(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.2.82. cusolverDnDormqr

此函数从 mxn 矩阵的 QR 分解生成酉矩阵 Q，并根据 side 和 trans 参数覆盖数组 C。

integer function cusolverDnDormqr(handle, &
    side, trans, m, n, k, A, lda, tau, C, ldc, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: side, trans
    integer(4) :: m, n, k, lda, ldc, lwork
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(*) :: tau
    real(8), device, dimension(ldc,*) :: C
    real(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.2.83. cusolverDnCormqr

此函数从 mxn 矩阵的 QR 分解生成酉矩阵 Q，并根据 side 和 trans 参数覆盖数组 C。

integer function cusolverDnCormqr(handle, &
    side, trans, m, n, k, A, lda, tau, C, ldc, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: side, trans
    integer(4) :: m, n, k, lda, ldc, lwork
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(*) :: tau
    complex(4), device, dimension(ldc,*) :: C
    complex(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.2.84. cusolverDnZormqr

此函数从 mxn 矩阵的 QR 分解生成酉矩阵 Q，并根据 side 和 trans 参数覆盖数组 C。

integer function cusolverDnZormqr(handle, &
    side, trans, m, n, k, A, lda, tau, C, ldc, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: side, trans
    integer(4) :: m, n, k, lda, ldc, lwork
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(*) :: tau
    complex(8), device, dimension(ldc,*) :: C
    complex(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.2.85. cusolverDnSsytrf_buffersize

此函数计算传递到 cusolverDnSsytrf 的设备工作空间所需的缓冲区大小

integer function cusolverDnSsytrf_buffersize(handle, &
    n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: n, lda
    real(4), device, dimension(lda,*) :: A
    integer(4) :: lwork

6.2.86. cusolverDnDsytrf_buffersize

此函数计算传递到 cusolverDnDsytrf 的设备工作空间所需的缓冲区大小

integer function cusolverDnDsytrf_buffersize(handle, &
    n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: n, lda
    real(8), device, dimension(lda,*) :: A
    integer(4) :: lwork

6.2.87. cusolverDnCsytrf_buffersize

此函数计算传递到 cusolverDnCsytrf 的设备工作空间所需的缓冲区大小

integer function cusolverDnCsytrf_buffersize(handle, &
    n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: n, lda
    complex(4), device, dimension(lda,*) :: A
    integer(4) :: lwork

6.2.88. cusolverDnZsytrf_buffersize

此函数计算传递到 cusolverDnZsytrf 的设备工作空间所需的缓冲区大小

integer function cusolverDnZsytrf_buffersize(handle, &
    n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: n, lda
    complex(8), device, dimension(lda,*) :: A
    integer(4) :: lwork

6.2.89. cusolverDnSsytrf

此函数计算 nxn 对称不定矩阵的 Bunch-Kaufman 分解

integer function cusolverDnSsytrf(handle, &
    uplo, n, A, lda, devipiv, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    real(4), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    real(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.2.90. cusolverDnDsytrf

此函数计算 nxn 对称不定矩阵的 Bunch-Kaufman 分解

integer function cusolverDnDsytrf(handle, &
    uplo, n, A, lda, devipiv, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    real(8), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    real(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.2.91. cusolverDnCsytrf

此函数计算 nxn 对称不定矩阵的 Bunch-Kaufman 分解

integer function cusolverDnCsytrf(handle, &
    uplo, n, A, lda, devipiv, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    complex(4), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    complex(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.2.92. cusolverDnZsytrf

此函数计算 nxn 对称不定矩阵的 Bunch-Kaufman 分解

integer function cusolverDnZsytrf(handle, &
    uplo, n, A, lda, devipiv, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    complex(8), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    complex(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.2.93. cusolverDnSsytrs_bufferSize

此函数计算传递到 cusolverDnSsytrs 的设备工作空间所需的缓冲区大小

integer function cusolverDnSsytrs_bufferSize(handle, &
    uplo, n, nrhs, A, lda, devipiv, B, ldb, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, nrhs, lda, ldb
    real(4), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    real(4), device, dimension(ldb,*) :: B
    integer(4), intent(out) :: lwork

6.2.94. cusolverDnDsytrs_bufferSize

此函数计算传递到 cusolverDnDsytrs 的设备工作空间所需的缓冲区大小

integer function cusolverDnDsytrs_bufferSize(handle, &
    uplo, n, nrhs, A, lda, devipiv, B, ldb, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, nrhs, lda, ldb
    real(8), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    real(8), device, dimension(ldb,*) :: B
    integer(4), intent(out) :: lwork

6.2.95. cusolverDnCsytrs_bufferSize

此函数计算传递到 cusolverDnCsytrs 的设备工作空间所需的缓冲区大小

integer function cusolverDnCsytrs_bufferSize(handle, &
    uplo, n, nrhs, A, lda, devipiv, B, ldb, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, nrhs, lda, ldb
    complex(4), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    complex(4), device, dimension(ldb,*) :: B
    integer(4), intent(out) :: lwork

6.2.96. cusolverDnZsytrs_bufferSize

此函数计算传递到 cusolverDnZsytrs 的设备工作空间所需的缓冲区大小

integer function cusolverDnZsytrs_bufferSize(handle, &
    uplo, n, nrhs, A, lda, devipiv, B, ldb, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, nrhs, lda, ldb
    complex(8), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    complex(8), device, dimension(ldb,*) :: B
    integer(4), intent(out) :: lwork

6.2.97. cusolverDnSsytrs

此函数使用 cusolverDnSsytrf 求解 nxn 对称不定矩阵的 Bunch-Kaufman 分解产生的线性方程组

integer function cusolverDnSsytrs(handle, &
    uplo, n, nrhs, A, lda, devipiv, B, ldb, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, nrhs, lda, ldb, lwork
    real(4), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    real(4), device, dimension(ldb,*) :: B
    real(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.2.98. cusolverDnDsytrs

此函数使用 cusolverDnDsytrf 求解 nxn 对称不定矩阵的 Bunch-Kaufman 分解产生的线性方程组

integer function cusolverDnDsytrs(handle, &
    uplo, n, nrhs, A, lda, devipiv, B, ldb, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, nrhs, lda, ldb, lwork
    real(8), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    real(8), device, dimension(ldb,*) :: B
    real(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.2.99. cusolverDnCsytrs

此函数使用 cusolverDnCsytrf 求解 nxn 对称不定矩阵的 Bunch-Kaufman 分解产生的线性方程组

integer function cusolverDnCsytrs(handle, &
    uplo, n, nrhs, A, lda, devipiv, B, ldb, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, nrhs, lda, ldb, lwork
    complex(4), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    complex(4), device, dimension(ldb,*) :: B
    complex(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.2.100. cusolverDnZsytrs

此函数使用 cusolverDnZsytrf 求解 nxn 对称不定矩阵的 Bunch-Kaufman 分解产生的线性方程组

integer function cusolverDnZsytrs(handle, &
    uplo, n, nrhs, A, lda, devipiv, B, ldb, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, nrhs, lda, ldb, lwork
    complex(8), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    complex(8), device, dimension(ldb,*) :: B
    complex(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.2.101. cusolverDnSsytri_bufferSize

此函数计算传递到 cusolverDnSsytri 的设备工作空间所需的缓冲区大小

integer function cusolverDnSsytri_bufferSize(handle, &
    uplo, n, A, lda, devipiv, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda
    real(4), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    integer(4), intent(out) :: lwork

6.2.102. cusolverDnDsytri_bufferSize

此函数计算传递到 cusolverDnDsytri 的设备工作空间所需的缓冲区大小

integer function cusolverDnDsytri_bufferSize(handle, &
    uplo, n, A, lda, devipiv, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda
    real(8), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    integer(4), intent(out) :: lwork

6.2.103. cusolverDnCsytri_bufferSize

此函数计算传递到 cusolverDnCsytri 的设备工作空间所需的缓冲区大小

integer function cusolverDnCsytri_bufferSize(handle, &
    uplo, n, A, lda, devipiv, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda
    complex(4), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    integer(4), intent(out) :: lwork

6.2.104. cusolverDnZsytri_bufferSize

此函数计算传递到 cusolverDnZsytri 的设备工作空间所需的缓冲区大小

integer function cusolverDnZsytri_bufferSize(handle, &
    uplo, n, A, lda, devipiv, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda
    complex(8), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    integer(4), intent(out) :: lwork

6.2.105. cusolverDnSsytri

此函数使用 cusolverDnSsytrf 反演从 nxn 对称不定矩阵的 Bunch-Kaufman 分解得到的矩阵

integer function cusolverDnSsytri(handle, &
    uplo, n, A, lda, devipiv, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    real(4), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    real(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.2.106. cusolverDnDsytri

此函数使用 cusolverDnDsytrf 反演从 nxn 对称不定矩阵的 Bunch-Kaufman 分解得到的矩阵

integer function cusolverDnDsytri(handle, &
    uplo, n, A, lda, devipiv, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    real(8), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    real(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.2.107. cusolverDnCsytri

此函数使用 cusolverDnCsytrf 反演从 nxn 对称不定矩阵的 Bunch-Kaufman 分解得到的矩阵

integer function cusolverDnCsytri(handle, &
    uplo, n, A, lda, devipiv, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    complex(4), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    complex(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.2.108. cusolverDnZsytri

此函数使用 cusolverDnZsytrf 反演从 nxn 对称不定矩阵的 Bunch-Kaufman 分解得到的矩阵

integer function cusolverDnZsytri(handle, &
    uplo, n, A, lda, devipiv, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    complex(8), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    complex(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.3. cusolverDn Legacy Eigenvalue Solver API

本节介绍 cusolverDn 的特征值求解器传统 API，包括双对角化和 SVD。

6.3.1. cusolverDnSgebrd_buffersize

此函数计算传递到 cusolverDnSgebrd 的设备工作空间所需的缓冲区大小

integer function cusolverDnSgebrd_buffersize(handle, &
    m, n, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n
    integer(4) :: lwork

6.3.2. cusolverDnDgebrd_buffersize

此函数计算传递到 cusolverDnDgebrd 的设备工作空间所需的缓冲区大小

integer function cusolverDnDgebrd_buffersize(handle, &
    m, n, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n
    integer(4) :: lwork

6.3.3. cusolverDnCgebrd_buffersize

此函数计算传递到 cusolverDnCgebrd 的设备工作空间所需的缓冲区大小

integer function cusolverDnCgebrd_buffersize(handle, &
    m, n, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n
    integer(4) :: lwork

6.3.4. cusolverDnZgebrd_buffersize

此函数计算传递到 cusolverDnZgebrd 的设备工作空间所需的缓冲区大小

integer function cusolverDnZgebrd_buffersize(handle, &
    m, n, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n
    integer(4) :: lwork

6.3.5. cusolverDnSgebrd

此函数通过正交变换 QH * A * P = B 将通用 mxn 矩阵 A 约简为上或下双对角形式 B

integer function cusolverDnSgebrd(handle, &
    m, n, A, lda, D, E, TauQ, TauP, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda, lwork
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(*) :: D
    real(4), device, dimension(*) :: E
    real(4), device, dimension(*) :: TauQ
    real(4), device, dimension(*) :: TauP
    real(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.3.6. cusolverDnDgebrd

此函数通过正交变换 QH * A * P = B 将通用 mxn 矩阵 A 约简为上或下双对角形式 B

integer function cusolverDnDgebrd(handle, &
    m, n, A, lda, D, E, TauQ, TauP, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda, lwork
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(*) :: D
    real(8), device, dimension(*) :: E
    real(8), device, dimension(*) :: TauQ
    real(8), device, dimension(*) :: TauP
    real(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.3.7. cusolverDnCgebrd

此函数通过正交变换 QH * A * P = B 将通用 mxn 矩阵 A 约简为上或下双对角形式 B

integer function cusolverDnCgebrd(handle, &
    m, n, A, lda, D, E, TauQ, TauP, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda, lwork
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(*) :: D
    complex(4), device, dimension(*) :: E
    complex(4), device, dimension(*) :: TauQ
    complex(4), device, dimension(*) :: TauP
    complex(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.3.8. cusolverDnZgebrd

此函数通过正交变换 QH * A * P = B 将通用 mxn 矩阵 A 约简为上或下双对角形式 B

integer function cusolverDnZgebrd(handle, &
    m, n, A, lda, D, E, TauQ, TauP, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda, lwork
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(*) :: D
    complex(8), device, dimension(*) :: E
    complex(8), device, dimension(*) :: TauQ
    complex(8), device, dimension(*) :: TauP
    complex(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.3.9. cusolverDnSorgbr_buffersize

此函数计算传递到 cusolverDnSorgbr 的设备工作空间所需的缓冲区大小

integer function cusolverDnSorgbr_buffersize(handle, &
    side, m, n, k, A, lda, tau, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: side
    integer(4) :: m, n, k, lda
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(*) :: tau
    integer(4) :: lwork

6.3.10. cusolverDnDorgbr_buffersize

此函数计算传递到 cusolverDnDorgbr 的设备工作空间所需的缓冲区大小

integer function cusolverDnDorgbr_buffersize(handle, &
    side, m, n, k, A, lda, tau, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: side
    integer(4) :: m, n, k, lda
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(*) :: tau
    integer(4) :: lwork

6.3.11. cusolverDnCungbr_buffersize

此函数计算传递到 cusolverDnCungbr 的设备工作空间所需的缓冲区大小

integer function cusolverDnCungbr_buffersize(handle, &
    side, m, n, k, A, lda, tau, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: side
    integer(4) :: m, n, k, lda
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(*) :: tau
    integer(4) :: lwork

6.3.12. cusolverDnZungbr_buffersize

此函数计算传递到 cusolverDnZungbr 的设备工作空间所需的缓冲区大小

integer function cusolverDnZungbr_buffersize(handle, &
    side, m, n, k, A, lda, tau, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: side
    integer(4) :: m, n, k, lda
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(*) :: tau
    integer(4) :: lwork

6.3.13. cusolverDnSorgbr

此函数生成由 cusolverDnSgebrd 确定的酉矩阵 Q 或 P**H 之一。

integer function cusolverDnSorgbr(handle, &
    side, m, n, k, A, lda, tau, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: side
    integer(4) :: m, n, k, lda, lwork
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(*) :: tau
    real(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.3.14. cusolverDnDorgbr

此函数生成由 cusolverDnDgebrd 确定的酉矩阵 Q 或 P**H 之一。

integer function cusolverDnDorgbr(handle, &
    side, m, n, k, A, lda, tau, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: side
    integer(4) :: m, n, k, lda, lwork
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(*) :: tau
    real(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.3.15. cusolverDnCungbr

此函数生成由 cusolverDnCgebrd 确定的酉矩阵 Q 或 P**H 之一。

integer function cusolverDnCungbr(handle, &
    side, m, n, k, A, lda, tau, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: side
    integer(4) :: m, n, k, lda, lwork
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(*) :: tau
    complex(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.3.16. cusolverDnZungbr

此函数生成由 cusolverDnZgebrd 确定的酉矩阵 Q 或 P**H 之一。

integer function cusolverDnZungbr(handle, &
    side, m, n, k, A, lda, tau, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: side
    integer(4) :: m, n, k, lda, lwork
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(*) :: tau
    complex(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.3.17. cusolverDnSsytrd_buffersize

此函数计算传递到 cusolverDnSsytrd 的设备工作空间所需的缓冲区大小

integer function cusolverDnSsytrd_buffersize(handle, &
    uplo, n, A, lda, D, E, tau, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: side
    integer(4) :: n, lda
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(*) :: D
    real(4), device, dimension(*) :: E
    real(4), device, dimension(*) :: tau
    integer(4) :: lwork

6.3.18. cusolverDnDsytrd_buffersize

此函数计算传递到 cusolverDnDsytrd 的设备工作空间所需的缓冲区大小

integer function cusolverDnDsytrd_buffersize(handle, &
    uplo, n, A, lda, D, E, tau, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: side
    integer(4) :: n, lda
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(*) :: D
    real(8), device, dimension(*) :: E
    real(8), device, dimension(*) :: tau
    integer(4) :: lwork

6.3.19. cusolverDnChetrd_buffersize

此函数计算传递到 cusolverDnChetrd 的设备工作空间所需的缓冲区大小

integer function cusolverDnChetrd_buffersize(handle, &
    uplo, n, A, lda, D, E, tau, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: side
    integer(4) :: n, lda
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(*) :: D
    complex(4), device, dimension(*) :: E
    complex(4), device, dimension(*) :: tau
    integer(4) :: lwork

6.3.20. cusolverDnZhetrd_buffersize

此函数计算传递到 cusolverDnZhetrd 的设备工作空间所需的缓冲区大小

integer function cusolverDnZhetrd_buffersize(handle, &
    uplo, n, A, lda, D, E, tau, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: side
    integer(4) :: n, lda
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(*) :: D
    complex(8), device, dimension(*) :: E
    complex(8), device, dimension(*) :: tau
    integer(4) :: lwork

6.3.21. cusolverDnSsytrd

此函数将通用对称或 Hermitian nxn 矩阵约简为实对称三对角形式。

integer function cusolverDnSsytrd(handle, &
    uplo, n, A, lda, D, E, tau, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(*) :: D
    real(4), device, dimension(*) :: E
    real(4), device, dimension(*) :: tau
    real(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.3.22. cusolverDnDsytrd

此函数将通用对称或 Hermitian nxn 矩阵约简为实对称三对角形式。

integer function cusolverDnDsytrd(handle, &
    uplo, n, A, lda, D, E, tau, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(*) :: D
    real(8), device, dimension(*) :: E
    real(8), device, dimension(*) :: tau
    real(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.3.23. cusolverDnChetrd

此函数将通用对称或 Hermitian nxn 矩阵约简为实对称三对角形式。

integer function cusolverDnChetrd(handle, &
    uplo, n, A, lda, D, E, tau, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(*) :: D
    complex(4), device, dimension(*) :: E
    complex(4), device, dimension(*) :: tau
    complex(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.3.24. cusolverDnZhetrd

此函数将通用对称或 Hermitian nxn 矩阵约简为实对称三对角形式。

integer function cusolverDnZhetrd(handle, &
    uplo, n, A, lda, D, E, tau, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(*) :: D
    complex(8), device, dimension(*) :: E
    complex(8), device, dimension(*) :: tau
    complex(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.3.25. cusolverDnSormtr_buffersize

此函数计算传递到 cusolverDnSormtr 的设备工作空间所需的缓冲区大小

integer function cusolverDnSormtr_buffersize(handle, &
    side, uplo, trans, m, n, A, lda, tau, C, ldc, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: side, uplo, trans
    integer(4) :: m, n, lda, ldc
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(*) :: tau
    real(4), device, dimension(ldc,*) :: C
    integer(4) :: lwork

6.3.26. cusolverDnDormtr_buffersize

此函数计算传递到 cusolverDnDormtr 的设备工作空间所需的缓冲区大小

integer function cusolverDnDormtr_buffersize(handle, &
    side, uplo, trans, m, n, A, lda, tau, C, ldc, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: side, uplo, trans
    integer(4) :: m, n, lda, ldc
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(*) :: tau
    real(8), device, dimension(ldc,*) :: C
    integer(4) :: lwork

6.3.27. cusolverDnCunmtr_buffersize

此函数计算传递到 cusolverDnCunmtr 的设备工作空间所需的缓冲区大小

integer function cusolverDnCunmtr_buffersize(handle, &
    side, uplo, trans, m, n, A, lda, tau, C, ldc, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: side, uplo, trans
    integer(4) :: m, n, lda, ldc
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(*) :: tau
    complex(4), device, dimension(ldc,*) :: C
    integer(4) :: lwork

6.3.28. cusolverDnZunmtr_buffersize

此函数计算传递到 cusolverDnZunmtr 的设备工作空间所需的缓冲区大小

integer function cusolverDnZunmtr_buffersize(handle, &
    side, uplo, trans, m, n, A, lda, tau, C, ldc, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: side, uplo, trans
    integer(4) :: m, n, lda, ldc
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(*) :: tau
    complex(8), device, dimension(ldc,*) :: C
    integer(4) :: lwork

6.3.29. cusolverDnSormtr

此函数基于 side 和 trans 参数，生成由一系列初等反射向量组成的酉矩阵 Q 并覆盖数组 C。

integer function cusolverDnSormtr(handle, &
    side, uplo, trans, m, n, A, lda, tau, C, ldc, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: side, uplo, trans
    integer(4) :: m, n, lda, ldc, lwork
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(*) :: tau
    real(4), device, dimension(ldc,*) :: C
    real(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.3.30. cusolverDnDormtr

此函数基于 side 和 trans 参数，生成由一系列初等反射向量组成的酉矩阵 Q 并覆盖数组 C。

integer function cusolverDnDormtr(handle, &
    side, uplo, trans, m, n, A, lda, tau, C, ldc, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: side, uplo, trans
    integer(4) :: m, n, lda, ldc, lwork
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(*) :: tau
    real(8), device, dimension(ldc,*) :: C
    real(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.3.31. cusolverDnCunmtr

此函数基于 side 和 trans 参数，生成由一系列初等反射向量组成的酉矩阵 Q 并覆盖数组 C。

integer function cusolverDnCunmtr(handle, &
    side, uplo, trans, m, n, A, lda, tau, C, ldc, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: side, uplo, trans
    integer(4) :: m, n, lda, ldc, lwork
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(*) :: tau
    complex(4), device, dimension(ldc,*) :: C
    complex(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.3.32. cusolverDnZunmtr

此函数基于 side 和 trans 参数，生成由一系列初等反射向量组成的酉矩阵 Q 并覆盖数组 C。

integer function cusolverDnZunmtr(handle, &
    side, uplo, trans, m, n, A, lda, tau, C, ldc, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: side, uplo, trans
    integer(4) :: m, n, lda, ldc, lwork
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(*) :: tau
    complex(8), device, dimension(ldc,*) :: C
    complex(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.3.33. cusolverDnSorgtr_buffersize

此函数计算传递到 cusolverDnSorgtr 的设备工作空间所需的缓冲区大小

integer function cusolverDnSorgtr_buffersize(handle, &
    uplo, n, A, lda, tau, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(*) :: tau
    integer(4) :: lwork

6.3.34. cusolverDnDorgtr_buffersize

此函数计算传递到 cusolverDnDorgtr 的设备工作空间所需的缓冲区大小

integer function cusolverDnDorgtr_buffersize(handle, &
    uplo, n, A, lda, tau, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(*) :: tau
    integer(4) :: lwork

6.3.35. cusolverDnCungtr_buffersize

此函数计算传递到 cusolverDnCungtr 的设备工作空间所需的缓冲区大小

integer function cusolverDnCungtr_buffersize(handle, &
    uplo, n, A, lda, tau, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(*) :: tau
    integer(4) :: lwork

6.3.36. cusolverDnZungtr_buffersize

此函数计算传递到 cusolverDnZungtr 的设备工作空间所需的缓冲区大小

integer function cusolverDnZungtr_buffersize(handle, &
    uplo, n, A, lda, tau, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(*) :: tau
    integer(4) :: lwork

6.3.37. cusolverDnSorgtr

此函数生成酉矩阵 Q，该矩阵定义为由 cusolverDnSsytrd 产生的 n 阶 n-1 个初等反射器的乘积。

integer function cusolverDnSorgtr(handle, &
    uplo, n, A, lda, tau, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(*) :: tau
    real(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.3.38. cusolverDnDorgtr

此函数生成酉矩阵 Q，该矩阵定义为由 cusolverDnDsytrd 产生的 n 阶 n-1 个初等反射器的乘积。

integer function cusolverDnDorgtr(handle, &
    uplo, n, A, lda, tau, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(*) :: tau
    real(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.3.39. cusolverDnCungtr

此函数生成酉矩阵 Q，该矩阵定义为由 cusolverDnCsytrd 产生的 n 阶 n-1 个初等反射器的乘积。

integer function cusolverDnCungtr(handle, &
    uplo, n, A, lda, tau, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(*) :: tau
    complex(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.3.40. cusolverDnZungtr

此函数生成酉矩阵 Q，该矩阵定义为由 cusolverDnZsytrd 产生的 n 阶 n-1 个初等反射器的乘积。

integer function cusolverDnZungtr(handle, &
    uplo, n, A, lda, tau, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(*) :: tau
    complex(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.3.41. cusolverDnSgesvd_buffersize

此函数计算传递到 cusolverDnSgesvd 的设备工作空间所需的缓冲区大小

integer function cusolverDnSgesvd_buffersize(handle, &
    m, n, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n
    integer(4) :: lwork

6.3.42. cusolverDnDgesvd_buffersize

此函数计算传递到 cusolverDnDgesvd 的设备工作空间所需的缓冲区大小

integer function cusolverDnDgesvd_buffersize(handle, &
    m, n, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n
    integer(4) :: lwork

6.3.43. cusolverDnCgesvd_buffersize

此函数计算传递到 cusolverDnCgesvd 的设备工作空间所需的缓冲区大小

integer function cusolverDnCgesvd_buffersize(handle, &
    m, n, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n
    integer(4) :: lwork

6.3.44. cusolverDnZgesvd_buffersize

此函数计算传递到 cusolverDnZgesvd 的设备工作空间所需的缓冲区大小

integer function cusolverDnZgesvd_buffersize(handle, &
    m, n, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n
    integer(4) :: lwork

6.3.45. cusolverDnSgesvd

此函数计算 mxn 矩阵 A 的奇异值分解 (SVD) 以及相应的左奇异向量和/或右奇异向量。CusolverDnSgesvd 仅支持 m >= n。

integer function cusolverDnSgesvd(handle, &
    jobu, jobvt, m, n, A, lda, S, U, ldu, VT, ldvt, workspace, lwork, rwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda, ldu, ldvt, lwork
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(*) :: S
    real(4), device, dimension(ldu,*) :: U
    real(4), device, dimension(ldvt,*) :: VT
    real(4), device, dimension(lwork) :: workspace
    real(4), device, dimension(lwork) :: rwork
    integer(4), device, intent(out) :: devinfo

6.3.46. cusolverDnDgesvd

此函数计算 mxn 矩阵 A 的奇异值分解 (SVD) 以及相应的左奇异向量和/或右奇异向量。CusolverDnDgesvd 仅支持 m >= n。

integer function cusolverDnDgesvd(handle, &
    jobu, jobvt, m, n, A, lda, S, U, ldu, VT, ldvt, workspace, lwork, rwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda, ldu, ldvt, lwork
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(*) :: S
    real(8), device, dimension(ldu,*) :: U
    real(4), device, dimension(ldvt,*) :: VT
    real(8), device, dimension(lwork) :: workspace
    real(8), device, dimension(lwork) :: rwork
    integer(4), device, intent(out) :: devinfo

6.3.47. cusolverDnCgesvd

此函数计算 mxn 矩阵 A 的奇异值分解 (SVD) 以及相应的左奇异向量和/或右奇异向量。CusolverDnCgesvd 仅支持 m >= n。

integer function cusolverDnCgesvd(handle, &
    jobu, jobvt, m, n, A, lda, S, U, ldu, VT, ldvt, workspace, lwork, rwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda, ldu, ldvt, lwork
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(*) :: S
    complex(4), device, dimension(ldu,*) :: U
    complex(4), device, dimension(ldvt,*) :: VT
    complex(4), device, dimension(lwork) :: workspace
    real(4), device, dimension(lwork) :: rwork
    integer(4), device, intent(out) :: devinfo

6.3.48. cusolverDnZgesvd

此函数计算 mxn 矩阵 A 的奇异值分解 (SVD) 以及相应的左奇异向量和/或右奇异向量。CusolverDnZgesvd 仅支持 m >= n。

integer function cusolverDnZgesvd(handle, &
    jobu, jobvt, m, n, A, lda, S, U, ldu, VT, ldvt, workspace, lwork, rwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda, ldu, ldvt, lwork
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(*) :: S
    complex(8), device, dimension(ldu,*) :: U
    complex(8), device, dimension(ldvt,*) :: VT
    complex(8), device, dimension(lwork) :: workspace
    real(8), device, dimension(lwork) :: rwork
    integer(4), device, intent(out) :: devinfo

6.3.49. cusolverDnSsyevd_buffersize

此函数计算传递到 cusolverDnSsyevd 的设备工作空间所需的缓冲区大小

integer function cusolverDnSsyevd_buffersize(handle, &
    jobz, uplo, n, A, lda, W, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(*) :: W
    integer(4) :: lwork

6.3.50. cusolverDnDsyevd_buffersize

此函数计算传递到 cusolverDnDsyevd 的设备工作空间所需的缓冲区大小

integer function cusolverDnDsyevd_buffersize(handle, &
    jobz, uplo, n, A, lda, W, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(*) :: W
    integer(4) :: lwork

6.3.51. cusolverDnCheevd_buffersize

此函数计算传递到 cusolverDnCheevd 的设备工作空间所需的缓冲区大小

integer function cusolverDnCheevd_buffersize(handle, &
    jobz, uplo, n, A, lda, W, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(*) :: W
    integer(4) :: lwork

6.3.52. cusolverDnZheevd_buffersize

此函数计算传递到 cusolverDnZheevd 的设备工作空间所需的缓冲区大小

integer function cusolverDnZheevd_buffersize(handle, &
    jobz, uplo, n, A, lda, W, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(*) :: W
    integer(4) :: lwork

6.3.53. cusolverDnSsyevd

此函数计算对称或 Hermitian nxn 矩阵 A 的特征值和特征向量。

integer function cusolverDnSsyevd(handle, &
    jobz, uplo, n, A, lda, W, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda, lwork
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(n) :: W
    real(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.3.54. cusolverDnDsyevd

此函数计算对称或 Hermitian nxn 矩阵 A 的特征值和特征向量。

integer function cusolverDnDsyevd(handle, &
    jobz, uplo, n, A, lda, W, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda, lwork
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(n) :: W
    real(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.3.55. cusolverDnCheevd

此函数计算对称或 Hermitian nxn 矩阵 A 的特征值和特征向量。

integer function cusolverDnCheevd(handle, &
    jobz, uplo, n, A, lda, W, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda, lwork
    complex(4), device, dimension(lda,*) :: A
    real(4), device, dimension(n) :: W
    complex(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.3.56. cusolverDnZheevd

此函数计算对称或 Hermitian nxn 矩阵 A 的特征值和特征向量。

integer function cusolverDnZheevd(handle, &
    jobz, uplo, n, A, lda, W, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda, lwork
    complex(8), device, dimension(lda,*) :: A
    real(8), device, dimension(n) :: W
    complex(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.3.57. cusolverDnSsyevdx_buffersize

此函数计算传递到 cusolverDnSsyevdx 的设备工作空间所需的缓冲区大小

integer function cusolverDnSsyevdx_buffersize(handle, &
    jobz, range, uplo, n, A, lda, vl, vu, il, iu, meig, W, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, range, uplo
    integer(4) :: n, lda, il, iu
    real(4) :: vl, vu
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(n) :: W
    integer(4) :: meig, lwork

6.3.58. cusolverDnDsyevdx_buffersize

此函数计算传递到 cusolverDnDsyevdx 的设备工作空间所需的缓冲区大小

integer function cusolverDnDsyevdx_buffersize(handle, &
    jobz, range, uplo, n, A, lda, vl, vu, il, iu, meig, W, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, range, uplo
    integer(4) :: n, lda, il, iu
    real(8) :: vl, vu
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(n) :: W
    integer(4) :: meig, lwork

6.3.59. cusolverDnCheevdx_buffersize

此函数计算传递到 cusolverDnCheevdx 的设备工作空间所需的缓冲区大小

integer function cusolverDnCheevdx_buffersize(handle, &
    jobz, range, uplo, n, A, lda, vl, vu, il, iu, meig, W, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, range, uplo
    integer(4) :: n, lda, il, iu
    real(4) :: vl, vu
    complex(4), device, dimension(lda,*) :: A
    real(4), device, dimension(n) :: W
    integer(4) :: meig, lwork

6.3.60. cusolverDnZheevdx_buffersize

此函数计算传递到 cusolverDnZheevdx 的设备工作空间所需的缓冲区大小

integer function cusolverDnZheevdx_buffersize(handle, &
    jobz, range, uplo, n, A, lda, vl, vu, il, iu, meig, W, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, range, uplo
    integer(4) :: n, lda, il, iu
    real(8) :: vl, vu
    complex(8), device, dimension(lda,*) :: A
    real(8), device, dimension(n) :: W
    integer(4) :: meig, lwork

6.3.61. cusolverDnSsyevdx

此函数计算对称或 Hermitian nxn 矩阵 A 的所有或部分特征值和特征向量。

integer function cusolverDnSsyevdx(handle, &
    jobz, range, uplo, n, A, lda, vl, vu, il, iu, meig, W, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, range, uplo
    integer(4) :: n, lda, il, iu, lwork
    real(4) :: vl, vu
    real(4), device, dimension(lda,*) :: A
    integer(4), intent(out) :: meig
    real(4), device, dimension(n) :: W
    real(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.3.62. cusolverDnDsyevdx

此函数计算对称或 Hermitian nxn 矩阵 A 的所有或部分特征值和特征向量。

integer function cusolverDnDsyevdx(handle, &
    jobz, range, uplo, n, A, lda, vl, vu, il, iu, meig, W, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, range, uplo
    integer(4) :: n, lda, il, iu, lwork
    real(8) :: vl, vu
    real(8), device, dimension(lda,*) :: A
    integer(4), intent(out) :: meig
    real(8), device, dimension(n) :: W
    real(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.3.63. cusolverDnCheevdx

此函数计算对称或 Hermitian nxn 矩阵 A 的所有或部分特征值和特征向量。

integer function cusolverDnCheevdx(handle, &
    jobz, range, uplo, n, A, lda, vl, vu, il, iu, meig, W, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, range, uplo
    integer(4) :: n, lda, il, iu, lwork
    real(4) :: vl, vu
    complex(4), device, dimension(lda,*) :: A
    integer(4), intent(out) :: meig
    real(4), device, dimension(n) :: W
    complex(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.3.64. cusolverDnZheevdx

此函数计算对称或 Hermitian nxn 矩阵 A 的所有或部分特征值和特征向量。

integer function cusolverDnZheevdx(handle, &
    jobz, range, uplo, n, A, lda, vl, vu, il, iu, meig, W, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, range, uplo
    integer(4) :: n, lda, il, iu, lwork
    real(8) :: vl, vu
    complex(8), device, dimension(lda,*) :: A
    integer(4), intent(out) :: meig
    real(8), device, dimension(n) :: W
    complex(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.3.65. cusolverDnSsyevj_buffersize

此函数计算传递到 cusolverDnSsyevj 的设备工作空间所需的缓冲区大小

integer function cusolverDnSsyevj_buffersize(handle, &
    jobz, uplo, n, A, lda, W, lwork, params)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(*) :: W
    integer(4), intent(out) :: lwork
    type(cusolverDnSyevjInfo) :: params

6.3.66. cusolverDnDsyevj_buffersize

此函数计算传递到 cusolverDnDsyevj 的设备工作空间所需的缓冲区大小

integer function cusolverDnDsyevj_buffersize(handle, &
    jobz, uplo, n, A, lda, W, lwork, params)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(*) :: W
    integer(4), intent(out) :: lwork
    type(cusolverDnSyevjInfo) :: params

6.3.67. cusolverDnCheevj_buffersize

此函数计算传递到 cusolverDnCheevj 的设备工作空间所需的缓冲区大小

integer function cusolverDnCheevj_buffersize(handle, &
    jobz, uplo, n, A, lda, W, lwork, params)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda
    complex(4), device, dimension(lda,*) :: A
    real(4), device, dimension(*) :: W
    integer(4), intent(out) :: lwork
    type(cusolverDnSyevjInfo) :: params

6.3.68. cusolverDnZheevj_buffersize

此函数计算传递到 cusolverDnZheevj 的设备工作空间所需的缓冲区大小

integer function cusolverDnZheevj_buffersize(handle, &
    jobz, uplo, n, A, lda, W, lwork, params)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda
    complex(8), device, dimension(lda,*) :: A
    real(8), device, dimension(*) :: W
    integer(4), intent(out) :: lwork
    type(cusolverDnSyevjInfo) :: params

6.3.69. cusolverDnSsyevj

此函数计算对称或 Hermitian nxn 矩阵 A 的特征值和特征向量。

integer function cusolverDnSsyevj(handle, &
    jobz, uplo, n, A, lda, W, workspace, lwork, devinfo, params)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda, lwork
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(n) :: W
    real(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo
 type(cusolverDnSyevjInfo) :: params

6.3.70. cusolverDnDsyevj

此函数计算对称或 Hermitian nxn 矩阵 A 的特征值和特征向量。

integer function cusolverDnDsyevj(handle, &
    jobz, uplo, n, A, lda, W, workspace, lwork, devinfo, params)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda, lwork
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(n) :: W
    real(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo
    type(cusolverDnSyevjInfo) :: params

6.3.71. cusolverDnCheevj

此函数计算对称或 Hermitian nxn 矩阵 A 的特征值和特征向量。

integer function cusolverDnCheevj(handle, &
    jobz, uplo, n, A, lda, W, workspace, lwork, devinfo, params)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda, lwork
    complex(4), device, dimension(lda,*) :: A
    real(4), device, dimension(n) :: W
    complex(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo
    type(cusolverDnSyevjInfo) :: params

6.3.72. cusolverDnZheevj

此函数计算对称或 Hermitian nxn 矩阵 A 的特征值和特征向量。

integer function cusolverDnZheevj(handle, &
    jobz, uplo, n, A, lda, W, workspace, lwork, devinfo, params)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda, lwork
    complex(8), device, dimension(lda,*) :: A
    real(4), device, dimension(n) :: W
    complex(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo
    type(cusolverDnSyevjInfo) :: params

6.3.73. cusolverDnSsyevjBatched_bufferSize

此函数计算传递到 cusolverDnSsyevjBatched 的设备工作空间所需的缓冲区大小。

integer function cusolverDnSsyevjBatched_bufferSize(handle, &
    jobz, uplo, n, A, lda, W, lwork, params, batchSize)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda, lwork
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(n) :: W
    integer(4), intent(out) :: lwork
    type(cusolverDnSyevjInfo) :: params
    integer(4) :: batchSize

6.3.74. cusolverDnDsyevjBatched_bufferSize

此函数计算传递到 cusolverDnDsyevjBatched 的设备工作空间所需的缓冲区大小。

integer function cusolverDnDsyevjBatched_bufferSize(handle, &
    jobz, uplo, n, A, lda, W, lwork, params, batchSize)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda, lwork
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(n) :: W
    integer(4), intent(out) :: lwork
    type(cusolverDnSyevjInfo) :: params
    integer(4) :: batchSize

6.3.75. cusolverDnCheevjBatched_bufferSize

此函数计算传递到 cusolverDnCheevjBatched 的设备工作空间所需的缓冲区大小。

integer function cusolverDnCheevjBatched_bufferSize(handle, &
    jobz, uplo, n, A, lda, W, lwork, params, batchSize)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda, lwork
    complex(4), device, dimension(lda,*) :: A
    real(4), device, dimension(n) :: W
    integer(4), intent(out) :: lwork
    type(cusolverDnSyevjInfo) :: params
    integer(4) :: batchSize

6.3.76. cusolverDnZheevjBatched_bufferSize

此函数计算传递到 cusolverDnZheevjBatched 的设备工作空间所需的缓冲区大小。

integer function cusolverDnZheevjBatched_bufferSize(handle, &
    jobz, uplo, n, A, lda, W, lwork, params, batchSize)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda, lwork
    complex(8), device, dimension(lda,*) :: A
    real(8), device, dimension(n) :: W
    integer(4), intent(out) :: lwork
    type(cusolverDnSyevjInfo) :: params
    integer(4) :: batchSize

6.3.77. cusolverDnSsyevjBatched

此函数计算对称或 Hermitian nxn 矩阵的特征值和特征向量。

integer function cusolverDnSsyevjBatched(handle, &
    jobz, uplo, n, A, lda, W, workspace, lwork, devinfo, params, batchSize)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda, lwork
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(n) :: W
    real(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo
    type(cusolverDnSyevjInfo) :: params
    integer(4) :: batchSize

6.3.78. cusolverDnDsyevjBatched

此函数计算对称或 Hermitian nxn 矩阵的特征值和特征向量。

integer function cusolverDnDsyevjBatched(handle, &
    jobz, uplo, n, A, lda, W, workspace, lwork, devinfo, params, batchSize)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda, lwork
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(n) :: W
    real(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo
    type(cusolverDnSyevjInfo) :: params
    integer(4) :: batchSize

6.3.79. cusolverDnCheevjBatched

此函数计算对称或 Hermitian nxn 矩阵的特征值和特征向量。

integer function cusolverDnCheevjBatched(handle, &
    jobz, uplo, n, A, lda, W, workspace, lwork, devinfo, params, batchSize)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda, lwork
    complex(4), device, dimension(lda,*) :: A
    real(4), device, dimension(n) :: W
    complex(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo
    type(cusolverDnSyevjInfo) :: params
    integer(4) :: batchSize

6.3.80. cusolverDnZheevjBatched

此函数计算对称或 Hermitian nxn 矩阵的特征值和特征向量。

integer function cusolverDnZheevjBatched(handle, &
    jobz, uplo, n, A, lda, W, workspace, lwork, devinfo, params, batchSize)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda, lwork
    complex(8), device, dimension(lda,*) :: A
    real(8), device, dimension(n) :: W
    complex(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo
    type(cusolverDnSyevjInfo) :: params
    integer(4) :: batchSize

6.3.81. cusolverDnSsygvd_buffersize

此函数计算传递到 cusolverDnSsygvd 的设备工作空间所需的缓冲区大小

integer function cusolverDnSsygvd_buffersize(handle, &
    itype, jobz, uplo, n, A, lda, B, ldb, W, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: itype, jobz, uplo
    integer(4) :: n, lda, ldb
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(ldb,*) :: B
    real(4), device, dimension(n) :: W
    integer(4) :: lwork

6.3.82. cusolverDnDsygvd_buffersize

此函数计算传递到 cusolverDnDsygvd 的设备工作空间所需的缓冲区大小

integer function cusolverDnDsygvd_buffersize(handle, &
    itype, jobz, uplo, n, A, lda, B, ldb, W, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: itype, jobz, uplo
    integer(4) :: n, lda, ldb
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(ldb,*) :: B
    real(8), device, dimension(n) :: W
    integer(4) :: lwork

6.3.83. cusolverDnChegvd_buffersize

此函数计算传递到 cusolverDnChegvd 的设备工作空间所需的缓冲区大小

integer function cusolverDnChegvd_buffersize(handle, &
    itype, jobz, uplo, n, A, lda, B, ldb, W, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: itype, jobz, uplo
    integer(4) :: n, lda, ldb
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(ldb,*) :: B
    real(4), device, dimension(n) :: W
    integer(4) :: lwork

6.3.84. cusolverDnZhegvd_buffersize

此函数计算传递到 cusolverDnZhegvd 的设备工作空间所需的缓冲区大小

integer function cusolverDnZhegvd_buffersize(handle, &
    itype, jobz, uplo, n, A, lda, B, ldb, W, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: itype, jobz, uplo
    integer(4) :: n, lda, ldb
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(ldb,*) :: B
    real(8), device, dimension(n) :: W
    integer(4) :: lwork

6.3.85. cusolverDnSsygvd

此函数计算对称或 Hermitian nxn 矩阵对 (A,B) 的特征值和特征向量。

integer function cusolverDnSsygvd(handle, &
    itype, jobz, uplo, n, A, lda, B, ldb, W, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: itype, jobz, uplo
    integer(4) :: n, lda, ldb, lwork
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(ldb,*) :: B
    real(4), device, dimension(n) :: W
    real(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.3.86. cusolverDnDsygvd

此函数计算对称或 Hermitian nxn 矩阵对 (A,B) 的特征值和特征向量。

integer function cusolverDnDsygvd(handle, &
    itype, jobz, uplo, n, A, lda, B, ldb, W, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: itype, jobz, uplo
    integer(4) :: n, lda, ldb, lwork
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(ldb,*) :: B
    real(8), device, dimension(n) :: W
    real(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.3.87. cusolverDnChegvd

此函数计算对称或 Hermitian nxn 矩阵对 (A,B) 的特征值和特征向量。

integer function cusolverDnChegvd(handle, &
    itype, jobz, uplo, n, A, lda, B, ldb, W, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: itype, jobz, uplo
    integer(4) :: n, lda, ldb, lwork
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(ldb,*) :: B
    real(4), device, dimension(n) :: W
    complex(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.3.88. cusolverDnZhegvd

此函数计算对称或 Hermitian nxn 矩阵对 (A,B) 的特征值和特征向量。

integer function cusolverDnZhegvd(handle, &
    itype, jobz, uplo, n, A, lda, B, ldb, W, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: itype, jobz, uplo
    integer(4) :: n, lda, ldb, lwork
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(ldb,*) :: B
    real(8), device, dimension(n) :: W
    complex(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.3.89. cusolverDnSsygvdx_buffersize

此函数计算传递到 cusolverDnSsygvdx 的设备工作空间所需的缓冲区大小

integer function cusolverDnSsygvdx_buffersize(handle, &
    itype, jobz, range, uplo, n, A, lda, B, ldb, vl, vu, il, iu, meig, W, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: itype, jobz, range, uplo
    integer(4) :: n, lda, ldb, il, iu
    real(4) :: vl, vu
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(ldb,*) :: B
    real(4), device, dimension(n) :: W
    integer(4) :: meig, lwork

6.3.90. cusolverDnDsygvdx_buffersize

此函数计算传递到 cusolverDnDsygvdx 的设备工作空间所需的缓冲区大小

integer function cusolverDnDsygvdx_buffersize(handle, &
    itype, jobz, range, uplo, n, A, lda, B, ldb, vl, vu, il, iu, meig, W, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: itype, jobz, range, uplo
    integer(4) :: n, lda, ldb, il, iu
    real(8) :: vl, vu
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(ldb,*) :: B
    real(8), device, dimension(n) :: W
    integer(4) :: meig, lwork

6.3.91. cusolverDnChegvdx_buffersize

此函数计算传递到 cusolverDnChegvdx 的设备工作空间所需的缓冲区大小

integer function cusolverDnChegvdx_buffersize(handle, &
    itype, jobz, range, uplo, n, A, lda, B, ldb, vl, vu, il, iu, meig, W, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: itype, jobz, range, uplo
    integer(4) :: n, lda, ldb, il, iu
    real(4) :: vl, vu
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(ldb,*) :: B
    real(4), device, dimension(n) :: W
    integer(4) :: meig, lwork

6.3.92. cusolverDnZhegvdx_buffersize

此函数计算传递到 cusolverDnZhegvdx 的设备工作空间所需的缓冲区大小

integer function cusolverDnZhegvdx_buffersize(handle, &
    itype, jobz, range, uplo, n, A, lda, B, ldb, vl, vu, il, iu, meig, W, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: itype, jobz, range, uplo
    integer(4) :: n, lda, ldb, il, iu
    real(8) :: vl, vu
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(ldb,*) :: B
    real(8), device, dimension(n) :: W
    integer(4) :: meig, lwork

6.3.93. cusolverDnSsygvdx

此函数计算对称或 Hermitian nxn 矩阵对 (A,B) 的所有或部分特征值和特征向量。

integer function cusolverDnSsygvdx(handle, &
    itype, jobz, range, uplo, n, A, lda, B, ldb, vl, vu, il, iu, meig, W, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: itype, jobz, range, uplo
    integer(4) :: n, lda, ldb, il, iu, lwork
    real(4) :: vl, vu
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(ldb,*) :: B
    integer(4), intent(out) :: meig
    real(4), device, dimension(n) :: W
    real(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.3.94. cusolverDnDsygvdx

此函数计算对称或 Hermitian nxn 矩阵对 (A,B) 的所有或部分特征值和特征向量。

integer function cusolverDnDsygvdx(handle, &
    itype, jobz, range, uplo, n, A, lda, B, ldb, vl, vu, il, iu, meig, W, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: itype, jobz, range, uplo
    integer(4) :: n, lda, ldb, il, iu, lwork
    real(8) :: vl, vu
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(ldb,*) :: B
    integer(4), intent(out) :: meig
    real(8), device, dimension(n) :: W
    real(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.3.95. cusolverDnChegvdx

此函数计算对称或 Hermitian nxn 矩阵对 (A,B) 的所有或部分特征值和特征向量。

integer function cusolverDnChegvdx(handle, &
    itype, jobz, range, uplo, n, A, lda, B, ldb, vl, vu, il, iu, meig, W, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: itype, jobz, range, uplo
    integer(4) :: n, lda, ldb, il, iu, lwork
    real(4) :: vl, vu
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(ldb,*) :: B
    integer(4), intent(out) :: meig
    real(4), device, dimension(n) :: W
    complex(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.3.96. cusolverDnZhegvdx

此函数计算对称或 Hermitian nxn 矩阵对 (A,B) 的所有或部分特征值和特征向量。

integer function cusolverDnZhegvdx(handle, &
    itype, jobz, range, uplo, n, A, lda, B, ldb, vl, vu, il, iu, meig, W, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: itype, jobz, range, uplo
    integer(4) :: n, lda, ldb, il, iu, lwork
    real(8) :: vl, vu
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(ldb,*) :: B
    integer(4), intent(out) :: meig
    real(8), device, dimension(n) :: W
    complex(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

6.4. cusolverDn 64-bit API

本节介绍 cusolverDn 的线性求解器 64 位 API，包括 Cholesky 分解、带部分主元的 LU 分解和 QR 分解。

6.4.1. cusolverDnXpotrf_buffersize

此函数计算传递到 cusolverDnXpotrf 的主机和设备工作空间所需的缓冲区大小

A 矩阵的类型和种类由 dataTypeA 参数确定。computeType 通常设置为相同。数组大小和维度，例如 n, m, lda 将由编译器提升为 integer(8)，因此可以使用其他整数类型。

integer function cusolverDnXpotrf_buffersize(handle, &
    params, uplo, n, dataTypeA, A, lda, computeType, &
    workspaceInBytesOnDevice, workspaceInBytesOnHost)
    type(cusolverDnHandle) :: handle
    type(cusolverDnParams) :: params
    integer(4) :: uplo
    integer(8) :: n, lda
    type(cudaDataType) :: dataTypeA, computeType
    real, device, dimension(lda,*) :: A
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost

6.4.2. cusolverDnXpotrf

此函数计算 Hermitian 正定矩阵的 Cholesky 分解

A 矩阵的类型和种类由 dataTypeA 参数确定。computeType 通常设置为相同。数组大小和维度，例如 n, m, lda 将由编译器提升为 integer(8)，因此可以使用其他整数类型。只要有足够的字节空间，工作空间可以是任何类型和种类。

integer function cusolverDnXpotrf(handle, &
    params, uplo, n, dataTypeA, A, lda, computeType, &
    bufferOnDevice, workspaceInBytesOnDevice, &
    bufferOnHost, workspaceInBytesOnHost, devinfo)
    type(cusolverDnHandle) :: handle
    type(cusolverDnParams) :: params
    integer(4) :: uplo
    integer(8) :: n, lda
    type(cudaDataType) :: dataTypeA, computeType
    real, device, dimension(lda,*) :: A
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(1), device :: bufferOnDevice(workspaceInBytesOnDevice)
    integer(1)         :: bufferOnHost(workspaceInBytesOnHost)
    integer(4), device, intent(out) :: devinfo

6.4.3. cusolverDnXpotrs

此函数使用 cusolverDnXpotrf 求解 Hermitian 正定矩阵的 Cholesky 分解得到的线性方程组

A, B 矩阵的类型和种类分别由 dataTypeA 和 dataTypeB 参数确定。数组大小和维度，例如 n, m, lda 将由编译器提升为 integer(8)，因此可以使用其他整数类型。

integer function cusolverDnXpotrs(handle, &
    params, uplo, n, nrhs, dataTypeA, A, lda, &
    dataTypeB, B, ldb, devinfo)
    type(cusolverDnHandle) :: handle
    type(cusolverDnParams) :: params
    integer(4) :: uplo
    integer(8) :: n, nrhs, lda, ldb
    type(cudaDataType) :: dataTypeA, dataTypeB
    real, device, dimension(lda,*) :: A
    real, device, dimension(ldb,*) :: B
    integer(4), device, intent(out) :: devinfo

6.4.4. cusolverDnXgeqrf_buffersize

此函数计算传递到 cusolverDnXgeqrf 的主机和设备工作空间所需的缓冲区大小

A 矩阵和 tau 向量的类型和种类分别由 dataTypeA 和 dataTypeTau 参数确定。computeType 通常设置为相同。数组大小和维度，例如 n, m, lda 将由编译器提升为 integer(8)，因此可以使用其他整数类型。

integer function cusolverDnXgeqrf_buffersize(handle, &
    params, m, n, dataTypeA, A, lda, dataTypeTau, tau, computeType, &
    workspaceInBytesOnDevice, workspaceInBytesOnHost)
    type(cusolverDnHandle) :: handle
    type(cusolverDnParams) :: params
    integer(8) :: m, n, lda
    type(cudaDataType) :: dataTypeA, dataTypeTau, computeType
    real, device, dimension(lda,*) :: A
    real, device, dimension(*)     :: tau
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost

6.4.5. cusolverDnXgeqrf

此函数计算通用 mxn 矩阵的 QR 分解

A 矩阵和 tau 向量的类型和种类分别由 dataTypeA 和 dataTypeTau 参数确定。computeType 通常设置为相同。数组大小和维度，例如 n, m, lda 将由编译器提升为 integer(8)，因此可以使用其他整数类型。只要有足够的字节空间，工作空间可以是任何类型和种类。

integer function cusolverDnXgeqrf(handle, &
    params, m, n, dataTypeA, A, lda, dataTypeTau, tau, computeType, &
    bufferOnDevice, workspaceInBytesOnDevice, &
    bufferOnHost, workspaceInBytesOnHost, devinfo)
    type(cusolverDnHandle) :: handle
    type(cusolverDnParams) :: params
    integer(8) :: m, n, lda
    type(cudaDataType) :: dataTypeA, dataTypeTau, computeType
    real, device, dimension(lda,*) :: A
    real, device, dimension(*)     :: tau
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(1), device :: bufferOnDevice(workspaceInBytesOnDevice)
    integer(1)         :: bufferOnHost(workspaceInBytesOnHost)
    integer(4), device, intent(out) :: devinfo

6.4.6. cusolverDnXgetrf_buffersize

此函数计算传递到 cusolverDnXgetrf 的主机和设备工作空间所需的缓冲区大小

A 矩阵的类型和种类由 dataTypeA 参数确定。computeType 通常设置为相同。数组大小和维度，例如 n, m, lda 将由编译器提升为 integer(8)，因此可以使用其他整数类型。

integer function cusolverDnXgetrf_buffersize(handle, &
    params, m, n, dataTypeA, A, lda, computeType, &
    workspaceInBytesOnDevice, workspaceInBytesOnHost)
    type(cusolverDnHandle) :: handle
    type(cusolverDnParams) :: params
    integer(8) :: m, n, lda
    type(cudaDataType) :: dataTypeA, computeType
    real, device, dimension(lda,*) :: A
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost

6.4.7. cusolverDnXgetrf

此函数计算一般 mxn 矩阵的 LU 分解

A 矩阵的类型和种类由 dataTypeA 参数确定。computeType 通常设置为相同。数组大小和维度，例如 n, m, lda 将由编译器提升为 integer(8)，因此可以使用其他整数类型。只要有足够的字节空间，工作空间可以是任何类型和种类。

integer function cusolverDnXgetrf(handle, &
    params, m, n, dataTypeA, A, lda, devipiv, computeType, &
    bufferOnDevice, workspaceInBytesOnDevice, &
    bufferOnHost, workspaceInBytesOnHost, devinfo)
    type(cusolverDnHandle) :: handle
    type(cusolverDnParams) :: params
    integer(8) :: n, m, lda
    type(cudaDataType) :: dataTypeA, computeType
    real, device, dimension(lda,*) :: A
    integer(8), device, dimension(*), intent(out) :: devipiv
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(1), device :: bufferOnDevice(workspaceInBytesOnDevice)
    integer(1)         :: bufferOnHost(workspaceInBytesOnHost)
    integer(4), device, intent(out) :: devinfo

6.4.8. cusolverDnXgetrs

此函数求解应用通用 nxn 矩阵的多个右侧线性系统，该矩阵已使用 cusolverDnXgetrf 进行 LU 分解

A, B 矩阵的类型和种类分别由 dataTypeA 和 dataTypeB 参数确定。数组大小和维度，例如 n, m, lda 将由编译器提升为 integer(8)，因此可以使用其他整数类型。

integer function cusolverDnXpotrs(handle, &
    params, trans, n, nrhs, dataTypeA, A, lda, devipiv, &
    dataTypeB, B, ldb, devinfo)
    type(cusolverDnHandle) :: handle
    type(cusolverDnParams) :: params
    integer(4) :: trans
    integer(8) :: n, nrhs, lda, ldb
    type(cudaDataType) :: dataTypeA, dataTypeB
    real, device, dimension(lda,*) :: A
    integer(8), device, dimension(*), intent(in) :: devipiv
    real, device, dimension(ldb,*) :: B
    integer(4), device, intent(out) :: devinfo

6.4.9. cusolverDnXsyevd_buffersize

此函数计算传递到 cusolverDnXsyevd 的主机和设备工作空间所需的缓冲区大小

A 矩阵和 W 数组的类型和种类分别由 dataTypeA 和 dataTypeW 参数确定。computeType 通常设置为相同。数组大小和维度，例如 n, m, lda 将由编译器提升为 integer(8)，因此可以使用其他整数类型。

integer function cusolverDnXsyevd_buffersize(handle, &
    params, jobz, uplo, n, dataTypeA, A, lda, &
    dataTypeW, W, computeType, &
    workspaceInBytesOnDevice, workspaceInBytesOnHost)
    type(cusolverDnHandle) :: handle
    type(cusolverDnParams) :: params
    integer(4) :: jobz, uplo
    integer(8) :: n, lda
    type(cudaDataType) :: dataTypeA, dataTypeW, computeType
    real, device, dimension(lda,*) :: A
    real, device, dimension(*)     :: W
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost

6.4.10. cusolverDnXsyevd

此函数计算对称（Hermitian）nxn 矩阵的特征值和特征向量

A 矩阵和 W 数组的类型和种类分别由 dataTypeA 和 dataTypeW 参数确定。computeType 通常设置为相同。数组大小和维度，例如 n, m, lda 将由编译器提升为 integer(8)，因此可以使用其他整数类型。只要有足够的字节空间，工作空间可以是任何类型和种类。

integer function cusolverDnXsyevd(handle, &
    params, jobz, uplo, n, dataTypeA, A, lda, &
    dataTypeW, W, computeType, &
    bufferOnDevice, workspaceInBytesOnDevice, &
    bufferOnHost, workspaceInBytesOnHost, devinfo)
    type(cusolverDnHandle) :: handle
    type(cusolverDnParams) :: params
    integer(4) :: jobz, uplo
    integer(8) :: n, lda
    type(cudaDataType) :: dataTypeA, dataTypeW, computeType
    real, device, dimension(lda,*) :: A
    real, device, dimension(*)     :: W
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(1), device :: bufferOnDevice(workspaceInBytesOnDevice)
    integer(1)         :: bufferOnHost(workspaceInBytesOnHost)
    integer(4), device, intent(out) :: devinfo

6.4.11. cusolverDnXsyevdx_buffersize

此函数计算传递到 cusolverDnXsyevdx 的主机和设备工作空间所需的缓冲区大小

A 矩阵和 W 数组的类型和种类分别由 dataTypeA 和 dataTypeW 参数确定。computeType 通常设置为相同。数组大小和维度，例如 n, m, lda 将由编译器提升为 integer(8)，因此可以使用其他整数类型。

integer function cusolverDnXsyevdx_buffersize(handle, &
    params, jobz, range, uplo, n, dataTypeA, A, lda, &
    vl, vu, il, iu, meig, &
    dataTypeW, W, computeType, &
    workspaceInBytesOnDevice, workspaceInBytesOnHost)
    type(cusolverDnHandle) :: handle
    type(cusolverDnParams) :: params
    integer(4) :: jobz, range, uplo
    integer(8) :: n, lda, il, iu
    type(cudaDataType) :: dataTypeA, dataTypeW, computeType
    real, device, dimension(lda,*) :: A
    real :: vl, vu
    integer(8) :: meig
    real, device, dimension(*)     :: W
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost

6.4.12. cusolverDnXsyevdx

此函数计算对称（Hermitian）nxn 矩阵的所有或部分特征值，并可选择计算特征向量

A 矩阵和 W 数组的类型和种类分别由 dataTypeA 和 dataTypeW 参数确定。computeType 通常设置为相同。数组大小和维度，例如 n, m, lda 将由编译器提升为 integer(8)，因此可以使用其他整数类型。只要有足够的字节空间，工作空间可以是任何类型和种类。

integer function cusolverDnXsyevdx(handle, &
    params, jobz, range, uplo, n, dataTypeA, A, lda, &
    vl, vu, il, iu, meig, &
    dataTypeW, W, computeType, &
    bufferOnDevice, workspaceInBytesOnDevice, &
    bufferOnHost, workspaceInBytesOnHost, devinfo)
    type(cusolverDnHandle) :: handle
    type(cusolverDnParams) :: params
    integer(4) :: jobz, range, uplo
    integer(8) :: n, lda, il, iu
    type(cudaDataType) :: dataTypeA, dataTypeW, computeType
    real, device, dimension(lda,*) :: A
    real :: vl, vu
    integer(8) :: meig
    real, device, dimension(*)     :: W
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(1), device :: bufferOnDevice(workspaceInBytesOnDevice)
    integer(1)         :: bufferOnHost(workspaceInBytesOnHost)
    integer(4), device, intent(out) :: devinfo

6.4.13. cusolverDnXsytrs_bufferSize

此函数计算使用通用 API cusolverDnXsytrs 函数求解线性方程组所需的缓冲区大小。

integer function cusolverDnXsytrs_bufferSize(handle, &
    uplo, n, nrhs, datatypeA, A, lda, &
    devipiv, datatypeB, B, ldb, &
    workspaceInBytesOnDevice, workspaceInBytesOnHost)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    type(cudaDataType) :: dataTypeA, dataTypeB
    integer(8) :: n, nrhs, lda, ldb
    real, device, dimension(lda,*) :: A
    integer(8), device :: devipiv(*)
    real, device, dimension(ldb,*) :: B
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost

6.4.14. cusolverDnXsytrs

此函数使用通用 API 求解线性方程组。

integer function cusolverDnXsytrs(handle, &
    uplo, n, nrhs, datatypeA, A, lda, &
    devipiv, datatypeB, B, ldb, &
    bufferOnDevice, workspaceInBytesOnDevice, &
    bufferOnHost, workspaceInBytesOnHost, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    type(cudaDataType) :: dataTypeA, dataTypeB
    integer(8) :: n, nrhs, lda, ldb
    real, device, dimension(lda,*) :: A
    integer(8), device :: devipiv(*)
    real, device, dimension(ldb,*) :: B
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(1), device :: bufferOnDevice(workspaceInBytesOnDevice)
    integer(1)         :: bufferOnHost(workspaceInBytesOnHost)
    integer(4), device, intent(out) :: devinfo

6.4.15. cusolverDnXtrtri_bufferSize

此函数计算使用通用 API cusolverDnXtrtri 函数计算上三角或下三角矩阵 A 的逆矩阵所需的缓冲区大小。

integer function cusolverDnXtrtri_bufferSize(handle, &
    uplo, diag, n, datatypeA, A, lda, &
    workspaceInBytesOnDevice, workspaceInBytesOnHost)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo, diag
    type(cudaDataType) :: dataTypeA
    integer(8) :: n, lda
    real, device, dimension(lda,*) :: A
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost

6.4.16. cusolverDnXtrtri

此函数使用通用 API 接口计算上三角或下三角矩阵 A 的逆矩阵。

integer function cusolverDnXtrtri(handle, &
    uplo, diag, n, datatypeA, A, lda, &
    bufferOnDevice, workspaceInBytesOnDevice, &
    bufferOnHost, workspaceInBytesOnHost, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo, diag
    type(cudaDataType) :: dataTypeA
    integer(8) :: n, lda
    real, device, dimension(lda,*) :: A
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(1), device :: bufferOnDevice(workspaceInBytesOnDevice)
    integer(1)         :: bufferOnHost(workspaceInBytesOnHost)
    integer(4), device, intent(out) :: devinfo

6.4.17. cusolverDnXgesvd_buffersize

此函数计算传递到 cusolverDnXgesvd 中的主机和设备工作空间所需的缓冲区大小。

A、 U 和 VT 矩阵以及 S 数组的类型和 kind 由相关的 dataType 参数确定。 computeType 通常设置为相同类型。编译器会将数组大小和维度（例如 n、 m、 lda）提升为 integer(8)，因此可以使用其他整数 kind。

integer function cusolverDnXgesvd_buffersize(handle, &
    params, jobu, jobvt, m, n, dataTypeA, A, lda, &
    dataTypeS, S, dataTypeU, U, ldu, &
    dataTypeVT, VT, ldvt, computeType, &
    workspaceInBytesOnDevice, workspaceInBytesOnHost)
    type(cusolverDnHandle) :: handle
    type(cusolverDnParams) :: params
    character*1 :: jobu, jobvt
    integer(8) :: m, n, lda, ldu, ldvt
    type(cudaDataType) :: dataTypeA, dataTypeS, dataTypeU, dataTypeVT, &
    computeType
    real, device, dimension(lda,*) :: A
    real, device, dimension(*)     :: S
    real, device, dimension(ldu,*) :: U
    real, device, dimension(ldvt,*) :: VT
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost

6.4.18. cusolverDnXgesvd

此函数计算 mxn 矩阵的奇异值分解 (SVD)。

A、 U 和 VT 矩阵以及 S 数组的类型和 kind 由相关的 dataType 参数确定。 computeType 通常设置为相同类型。编译器会将数组大小和维度（例如 n、 m、 lda）提升为 integer(8)，因此可以使用其他整数 kind。只要字节空间足够，工作空间可以是任何类型和 kind。

integer function cusolverDnXgesvd(handle, &
    params, jobu, jobvt, m, n, dataTypeA, A, lda, &
    dataTypeS, S, dataTypeU, U, ldu, &
    dataTypeVT, VT, ldvt, computeType, &
    bufferOnDevice, workspaceInBytesOnDevice, &
    bufferOnHost, workspaceInBytesOnHost, devinfo)
    type(cusolverDnHandle) :: handle
    type(cusolverDnParams) :: params
    character*1 :: jobu, jobvt
    integer(8) :: m, n, lda, ldu, ldvt
    type(cudaDataType) :: dataTypeA, dataTypeS, dataTypeU, dataTypeVT, &
    computeType
    real, device, dimension(lda,*) :: A
    real, device, dimension(*)     :: S
    real, device, dimension(ldu,*) :: U
    real, device, dimension(ldvt,*) :: VT
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(1), device :: bufferOnDevice(workspaceInBytesOnDevice)
    integer(1)         :: bufferOnHost(workspaceInBytesOnHost)
    integer(4), device, intent(out) :: devinfo

6.4.19. cusolverDnXgesvdp_buffersize

此函数计算传递到 cusolverDnXgesvdp 中的主机和设备工作空间所需的缓冲区大小。

A、 U 和 V 矩阵以及 S 数组的类型和 kind 由相关的 dataType 参数确定。 computeType 通常设置为相同类型。编译器会将数组大小和维度（例如 n、 m、 lda）提升为 integer(8)，因此可以使用其他整数 kind。

integer function cusolverDnXgesvdp_buffersize(handle, &
    params, jobz, econ, m, n, dataTypeA, A, lda, &
    dataTypeS, S, dataTypeU, U, ldu, &
    dataTypeV, V, ldv, computeType, &
    workspaceInBytesOnDevice, workspaceInBytesOnHost)
    type(cusolverDnHandle) :: handle
    type(cusolverDnParams) :: params
    integer(4) :: jobz, econ
    integer(8) :: m, n, lda, ldu, ldv
    type(cudaDataType) :: dataTypeA, dataTypeS, dataTypeU, dataTypeV, &
    computeType
    real, device, dimension(lda,*) :: A
    real, device, dimension(*)     :: S
    real, device, dimension(ldu,*) :: U
    real, device, dimension(ldv,*) :: V
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost

6.4.20. cusolverDnXgesvdp

此函数计算 mxn 矩阵的奇异值分解 (SVD)。此变体结合了极分解和 cusolverDnXsyevd 来计算 SVD。

A、 U 和 V 矩阵以及 S 数组的类型和 kind 由相关的 dataType 参数确定。 computeType 通常设置为相同类型。编译器会将数组大小和维度（例如 n、 m、 lda）提升为 integer(8)，因此可以使用其他整数 kind。只要字节空间足够，工作空间可以是任何类型和 kind。

integer function cusolverDnXgesvdp(handle, &
    params, jobz, econ, m, n, dataTypeA, A, lda, &
    dataTypeS, S, dataTypeU, U, ldu, &
    dataTypeV, V, ldv, computeType, &
    bufferOnDevice, workspaceInBytesOnDevice, &
    bufferOnHost, workspaceInBytesOnHost, devinfo)
    type(cusolverDnHandle) :: handle
    type(cusolverDnParams) :: params
    integer(4) :: jobz, econ
    integer(8) :: m, n, lda, ldu, ldv
    type(cudaDataType) :: dataTypeA, dataTypeS, dataTypeU, dataTypeVT, &
    computeType
    real, device, dimension(lda,*) :: A
    real, device, dimension(*)     :: S
    real, device, dimension(ldu,*) :: U
    real, device, dimension(ldv,*) :: V
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(1), device :: bufferOnDevice(workspaceInBytesOnDevice)
    integer(1)         :: bufferOnHost(workspaceInBytesOnHost)
    integer(4), device, intent(out) :: devinfo

6.4.21. cusolverDnXgesvdr_buffersize

此函数计算传递到 cusolverDnXgesvdr 中的主机和设备工作空间所需的缓冲区大小。

A、 Urand 和 Vrand 矩阵以及 Srand 数组的类型和 kind 由相关的 dataType 参数确定。 computeType 通常设置为相同类型。编译器会将数组大小和维度（例如 n、 m、 lda）提升为 integer(8)，因此可以使用其他整数 kind。

integer function cusolverDnXgesvdr_buffersize(handle, &
    params, jobu, jobvt, m, n, k, p, niters, dataTypeA, A, lda, &
    dataTypeSrand, Srand, dataTypeUrand, Urand, ldurand, &
    dataTypeVrand, Vrand, ldvrand, computeType, &
    workspaceInBytesOnDevice, workspaceInBytesOnHost)
    type(cusolverDnHandle) :: handle
    type(cusolverDnParams) :: params
    character*1 :: jobu, jobvt
    integer(8) :: m, n, k, p, niters, lda, ldurand, ldvrand
    type(cudaDataType) :: dataTypeA, dataTypeSrand, dataTypeUrand, &
      dataTypeVrand, computeType
    real, device, dimension(lda,*) :: A
    real, device, dimension(*)     :: Srand
    real, device, dimension(ldurand,*) :: Urand
    real, device, dimension(ldvrand,*) :: Vrand
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost

6.4.22. cusolverDnXgesvdr

此函数计算 mxn 矩阵的近似秩-k 奇异值分解 (SVD)。

A、 Urand 和 Vrand 矩阵以及 Srand 数组的类型和 kind 由相关的 dataType 参数确定。 computeType 通常设置为相同类型。编译器会将数组大小和维度（例如 n、 m、 lda）提升为 integer(8)，因此可以使用其他整数 kind。只要字节空间足够，工作空间可以是任何类型和 kind。

integer function cusolverDnXgesvdr(handle, &
    params, jobu, jobv, m, n, k, p, niters, dataTypeA, A, lda, &
    dataTypeSrand, Srand, dataTypeUrand, Urand, ldurand, &
    dataTypeVrand, Vrand, ldvrand, computeType, &
    bufferOnDevice, workspaceInBytesOnDevice, &
    bufferOnHost, workspaceInBytesOnHost, devinfo)
    type(cusolverDnHandle) :: handle
    type(cusolverDnParams) :: params
    character*1 :: jobu, jobv
    integer(8) :: m, n, k, p, niters, lda, ldurand, ldvrand
    type(cudaDataType) :: dataTypeA, dataTypeSrand, dataTypeUrand, &
      dataTypeVrand, computeType
    real, device, dimension(lda,*) :: A
    real, device, dimension(*)     :: Srand
    real, device, dimension(ldurand,*) :: Urand
    real, device, dimension(ldvrand,*) :: Vrand
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(1), device :: bufferOnDevice(workspaceInBytesOnDevice)
    integer(1)         :: bufferOnHost(workspaceInBytesOnHost)
    integer(4), device, intent(out) :: devinfo

6.5. cusolverMp API

本节介绍 cusolverMp 中支持的分布式多处理器线性求解器，以及用于设置和初始化库的支持函数。

cusolverMp 模块包含以下派生类型定义

! Definitions from cusolverMp.h
integer, parameter :: CUSOLVERMP_VER_MAJOR = 0
integer, parameter :: CUSOLVERMP_VER_MINOR = 4
integer, parameter :: CUSOLVERMP_VER_PATCH = 3
integer, parameter :: CUSOLVERMP_VER_BUILD = 0
integer, parameter :: CUSOLVERMP_VERSION = &
        (CUSOLVERMP_VER_MAJOR * 1000 + CUSOLVERMP_VER_MINOR * 100 + CUSOLVERMP_VER_PATCH)

! Types from cusolverMp.h
    TYPE cusolverMpHandle
      TYPE(C_PTR) :: handle
    END TYPE cusolverMpHandle

    TYPE cusolverMpGrid
      TYPE(C_PTR) :: handle
    END TYPE cusolverMpGrid

    TYPE cusolverMpMatrixDescriptor
      TYPE(C_PTR) :: handle
    END TYPE cusolverMpMatrixDescriptor

enum, bind(c)
    enumerator :: CUDALIBMP_GRID_MAPPING_COL_MAJOR = 0
    enumerator :: CUDALIBMP_GRID_MAPPING_ROW_MAJOR = 1
end enum

6.5.1. cusolverMpCreate

此函数初始化 cusolverMp 库并在 cusolverDn 上下文中创建句柄。它必须在调用其他 cuSolverMp API 函数之前调用，但在创建 CUDA 上下文和流之后调用。

integer(4) function cusolverMpCreate(handle, deviceId, stream)
  type(cusolverMpHandle) :: handle
  integer(4) :: deviceId
  integer(cuda_stream_kind) :: stream

6.5.2. cusolverMpDestroy

此函数释放 cuSolverMp 库使用的 CPU 端资源。

integer(4) function cusolverMpDestroy(handle)
  type(cusolverMpHandle) :: handle

6.5.3. cusolverMpGetStream

此函数获取 cuSolverMp 库用于执行其例程的流。

integer(4) function cusolverMpGetStream(handle, stream)
  type(cusolverMpHandle) :: handle
  integer(cuda_stream_kind) :: stream

6.5.4. cusolverMpGetVersion

此函数在运行时获取 cuSolverMp 库的版本。它的值为 (CUSOLVERMP_VER_MAJOR * 1000 + CUSOLVERMP_VER_MINOR * 100 + CUSOLVERMP_VER_PATCH)

integer(4) function cusolverMpGetVersion(handle, version)
  type(cusolverMpHandle) :: handle
  integer(4) :: version

6.5.5. cusolverMpCreateDeviceGrid

此函数初始化 cusolverMp 库中使用的网格数据结构。它接受句柄、通信器以及与数据布局相关的其他信息作为输入。

integer(4) function cusolverMpCreateDeviceGrid(handle, &
          grid, comm, numRowDevices, numColDevices, mapping)
  type(cusolverMpHandle) :: handle
  type(cusolverMpGrid) :: grid
  type(cal_comm) :: comm
  integer(4) :: numRowDevices, numColDevices
  integer(4) :: mapping ! enum above, usually column major in Fortran

6.5.6. cusolverMpDestroyGrid

此函数销毁网格数据结构并释放 cusolverMp 库中使用的资源。

integer(4) function cusolverMpDestroyGrid(grid)
   type(cusolverMpGrid) :: grid

6.5.7. cusolverMpCreateMatrixDesc

此函数初始化 cusolverMp 库中使用的矩阵描述符对象。它接受全局数组中的行数 (M_A) 和列数 (N_A)，以及每个维度上的分块因子。 RSRC_A 和 CSRC_A 目前必须为 0。 LLD_A 是本地矩阵的引导维度，在分块和分布矩阵之后。

integer(4) function cusolverMpCreateMatrixDesc(descr, grid, &
          dataType, M_A, N_A, MB_A, NB_A, RSRC_A, CSRC_A, LLD_A)
  type(cusolverMpMatrixDescriptor)  :: descr
  type(cusolverMpGrid) :: grid
  type(cudaDataType)  :: dataType
  integer(8) :: M_A, N_A, MB_A, NB_A
  integer(4) :: RSRC_A, CSRC_A
  integer(8) :: LLD_A

6.5.8. cusolverMpDestroyMatrixDesc

此函数销毁矩阵描述符数据结构并释放 cusolverMp 库中使用的资源。

integer(4) function cusolverMpDestroyMatrixDesc(descr)
   type(cusolverMpMatrixDescriptor) :: descr

6.5.9. cusolverMpNumROC

此实用程序函数返回 iproc 进程拥有的分布式矩阵中的行数或列数。

integer(4) function cusolverMpNumROC(N, NB, iproc, isrcproc, nprocs)
  integer(8), intent(in) :: N, NB
  integer(4), intent(in) :: iproc, isrcproc, nprocs

6.5.10. cusolverMpGetrf_buffersize

此函数计算传递到 cusolverMpGetrf 中的主机和设备工作空间所需的缓冲区大小。

A 矩阵的类型、kind 和秩将被忽略，并且已由 descrA 参数设置。 computeType 通常设置为相同类型。编译器会将数组大小和维度（例如 M、 N）提升为 integer(8)，因此可以使用其他整数 kind。

integer function cusolverMpGetrf_buffersize(handle, &
    M, N, A, IA, JA, descrA, devipiv, computeType, &
    workspaceInBytesOnDevice, workspaceInBytesOnHost)
    type(cusolverMpHandle) :: handle
    integer(8) :: M, N, IA, JA
    real, device, dimension(*) :: A
    type(cusolverMpMatrixDescriptor) :: descrA
    integer(8), device, dimension(*) :: devipiv
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost

6.5.11. cusolverMpGetrf

此函数计算一般 mxn 矩阵的 LU 分解

A 矩阵的类型、kind 和秩将被忽略，并且已由 descrA 参数设置。 computeType 通常设置为相同类型。编译器会将数组大小和维度（例如 M、 N）提升为 integer(8)，因此可以使用其他整数 kind。只要字节空间足够，工作空间可以是任何类型和 kind。

integer function cusolverMpGetrf(handle, &
    M, N, A, IA, JA, descrA, devipiv, computeType, &
    bufferOnDevice, workspaceInBytesOnDevice, &
    bufferOnHost, workspaceInBytesOnHost, info)
    type(cusolverMpHandle) :: handle
    integer(8) :: M, N, IA, JA
    real, device, dimension(*) :: A
    type(cusolverMpMatrixDescriptor) :: descrA
    integer(8), device, dimension(*) :: devipiv
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(1), device :: bufferOnDevice(workspaceInBytesOnDevice)
    integer(1)         :: bufferOnHost(workspaceInBytesOnHost)
    integer(4), device, intent(out) :: info

6.5.12. cusolverMpGetrs_buffersize

此函数计算传递到 cusolverMpGetrs 中的主机和设备工作空间所需的缓冲区大小。

A、 B 矩阵的类型、kind 和秩将被忽略，并且由 descrA、 descrB 参数设置。 computeType 通常设置为相同类型。编译器会将数组大小和维度（例如 N、 NRHS）提升为 integer(8)，因此可以使用其他整数 kind。

integer function cusolverMpGetrs_buffersize(handle, trans, &
    N, NRHS, A, IA, JA, descrA, devipiv, B, IB, JB, descrB, computeType, &
    workspaceInBytesOnDevice, workspaceInBytesOnHost)
    type(cusolverMpHandle) :: handle
    integer(4) :: trans
    integer(8) :: N, NRHS, IA, JA, IB, JB
    real, device, dimension(*) :: A, B
    type(cusolverMpMatrixDescriptor) :: descrA, descrB
    integer(8), device, dimension(*) :: devipiv
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost

6.5.13. cusolverMpGetrs

此函数求解多个右手侧的线性系统，应用使用 cusolverMpGetrf 进行 LU 分解的通用 nxn 矩阵。

A、 B 矩阵的类型、kind 和秩将被忽略，并且由 descrA、 descrB 参数设置。 computeType 通常设置为相同类型。编译器会将数组大小和维度（例如 N、 NRHS）提升为 integer(8)，因此可以使用其他整数 kind。

integer function cusolverMpGetrs(handle, trans, &
    N, NRHS, A, IA, JA, descrA, devipiv, B, IB, JB, descrB, computeType, &
    bufferOnDevice, workspaceInBytesOnDevice, &
    bufferOnHost, workspaceInBytesOnHost, devinfo)
    type(cusolverMpHandle) :: handle
    integer(4) :: trans
    integer(8) :: N, NRHS, IA, JA, IB, JB
    real, device, dimension(*) :: A, B
    type(cusolverMpMatrixDescriptor) :: descrA, descrB
    integer(8), device, dimension(*) :: devipiv
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(1), device :: bufferOnDevice(workspaceInBytesOnDevice)
    integer(1)         :: bufferOnHost(workspaceInBytesOnHost)
    integer(4), device, intent(out) :: devinfo

6.5.14. cusolverMpPotrf_buffersize

此函数计算传递到 cusolverMpPotrf 中的主机和设备工作空间所需的缓冲区大小。

A 矩阵的类型、kind 和秩将被忽略，并且已由 descrA 参数设置。 computeType 通常设置为相同类型。编译器会将数组大小和维度（例如 N）提升为 integer(8)，因此可以使用其他整数 kind。

integer function cusolverMpPotrf_buffersize(handle, &
    uplo, N, A, IA, JA, descrA, computeType, &
    workspaceInBytesOnDevice, workspaceInBytesOnHost)
    type(cusolverMpHandle) :: handle
    integer(4) :: uplo
    integer(8) :: N, IA, JA
    real, device, dimension(*) :: A
    type(cusolverMpMatrixDescriptor) :: descrA
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost

6.5.15. cusolverMpPotrf

此函数计算 Hermitian 正定矩阵的 Cholesky 分解

A 矩阵的类型、kind 和秩将被忽略，并且已由 descrA 参数设置。 computeType 通常设置为相同类型。编译器会将数组大小和维度（例如 N）提升为 integer(8)，因此可以使用其他整数 kind。

integer function cusolverMpPotrf(handle, &
    uplo, N, A, IA, JA, descrA, computeType, &
    bufferOnDevice, workspaceInBytesOnDevice, &
    bufferOnHost, workspaceInBytesOnHost, info)
    type(cusolverMpHandle) :: handle
    integer(4) :: uplo
    integer(8) :: N, IA, JA
    real, device, dimension(*) :: A
    type(cusolverMpMatrixDescriptor) :: descrA
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(1), device :: bufferOnDevice(workspaceInBytesOnDevice)
    integer(1)         :: bufferOnHost(workspaceInBytesOnHost)
    integer(4), device, intent(out) :: info

6.5.16. cusolverMpPotrs_buffersize

此函数计算传递到 cusolverMpPotrs 中的主机和设备工作空间所需的缓冲区大小。

A、 B 矩阵的类型、kind 和秩将被忽略，并且由 descrA、 descrB 参数设置。 computeType 通常设置为相同类型。编译器会将数组大小和维度（例如 N、 NRHS）提升为 integer(8)，因此可以使用其他整数 kind。

integer function cusolverMpPotrs_buffersize(handle, uplo, &
    N, NRHS, A, IA, JA, descrA, B, IB, JB, descrB, computeType, &
    workspaceInBytesOnDevice, workspaceInBytesOnHost)
    type(cusolverMpHandle) :: handle
    integer(4) :: uplo
    integer(8) :: N, NRHS, IA, JA, IB, JB
    real, device, dimension(*) :: A, B
    type(cusolverMpMatrixDescriptor) :: descrA, descrB
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost

6.5.17. cusolverMpPotrs

此函数求解由 Hermitian 正定矩阵的 Cholesky 分解产生的线性方程组，使用 cusolverMpPotrf。

A、 B 矩阵的类型、kind 和秩将被忽略，并且由 descrA、 descrB 参数设置。 computeType 通常设置为相同类型。编译器会将数组大小和维度（例如 N、 NRHS）提升为 integer(8)，因此可以使用其他整数 kind。

integer function cusolverMpPotrs(handle, uplo, &
    N, NRHS, A, IA, JA, descrA, B, IB, JB, descrB, computeType, &
    bufferOnDevice, workspaceInBytesOnDevice, &
    bufferOnHost, workspaceInBytesOnHost, info)
    type(cusolverMpHandle) :: handle
    integer(4) :: uplo
    integer(8) :: N, NRHS, IA, JA, IB, JB
    real, device, dimension(*) :: A, B
    type(cusolverMpMatrixDescriptor) :: descrA, descrB
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(1), device :: bufferOnDevice(workspaceInBytesOnDevice)
    integer(1)         :: bufferOnHost(workspaceInBytesOnHost)
    integer(4), device, intent(out) :: info

6.5.18. cusolverMpOrmqr_buffersize

此函数计算传递到 cusolverMpOrmqr 中的主机和设备工作空间所需的缓冲区大小。

A、 C 矩阵的类型、kind 和秩将被忽略，并且已由 descrA、 descrC 参数设置。 computeType 通常设置为相同类型。编译器会将数组大小和维度（例如 M、 N、 K）提升为 integer(8)，因此可以使用其他整数 kind。

integer function cusolverMpOrmqr_buffersize(handle, side, trans, &
    M, N, K, A, IA, JA, descrA, tau, C, IC, JC, descrC, computeType, &
    workspaceInBytesOnDevice, workspaceInBytesOnHost)
    type(cusolverMpHandle) :: handle
    integer(4) :: side, trans
    integer(8) :: M, N, K, IA, JA, IC, JC
    real, device, dimension(*) :: A, tau, C
    type(cusolverMpMatrixDescriptor) :: descrA, descrC
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost

6.5.19. cusolverMpOrmqr

此函数从 mxn 矩阵的 QR 分解生成酉矩阵 Q，并根据 side 和 trans 参数覆盖数组 C。

A、 C 矩阵的类型、kind 和秩将被忽略，并且已由 descrA、 descrC 参数设置。 computeType 通常设置为相同类型。编译器会将数组大小和维度（例如 M、 N、 K）提升为 integer(8)，因此可以使用其他整数 kind。

integer function cusolverMpOrmqr(handle, side, trans, &
    M, N, K, A, IA, JA, descrA, tau, C, IC, JC, descrC, computeType, &
    bufferOnDevice, workspaceInBytesOnDevice, &
    bufferOnHost, workspaceInBytesOnHost, info)
    type(cusolverMpHandle) :: handle
    integer(4) :: side, trans
    integer(8) :: M, N, K, IA, JA, IC, JC
    real, device, dimension(*) :: A, tau, C
    type(cusolverMpMatrixDescriptor) :: descrA, descrC
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(1), device :: bufferOnDevice(workspaceInBytesOnDevice)
    integer(1)         :: bufferOnHost(workspaceInBytesOnHost)
    integer(4), device, intent(out) :: info

6.5.20. cusolverMpOrmtr_buffersize

此函数计算传递到 cusolverMpOrmtr 中的主机和设备工作空间所需的缓冲区大小。

A、 tau、 C 矩阵的类型、kind 和秩将被忽略，并且已由 descrA、 descrC 参数设置。 computeType 通常设置为相同类型。编译器会将数组大小和维度（例如 M、 N、 K）提升为 integer(8)，因此可以使用其他整数 kind。

integer function cusolverMpOrmtr_buffersize(handle, side, uplo, trans, &
    M, N, A, IA, JA, descrA, tau, C, IC, JC, descrC, computeType, &
    workspaceInBytesOnDevice, workspaceInBytesOnHost)
    type(cusolverMpHandle) :: handle
    integer(4) :: side, uplo, trans
    integer(8) :: M, N, IA, JA, IC, JC
    real, device, dimension(*) :: A, tau, C
    type(cusolverMpMatrixDescriptor) :: descrA, descrC
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost

6.5.21. cusolverMpOrmtr

此函数基于 side 和 trans 参数，生成由一系列初等反射向量组成的酉矩阵 Q 并覆盖数组 C。

A、 C 矩阵的类型、kind 和秩将被忽略，并且已由 descrA、 descrC 参数设置。 computeType 通常设置为相同类型。编译器会将数组大小和维度（例如 M、 N、 K）提升为 integer(8)，因此可以使用其他整数 kind。

integer function cusolverMpOrmtr(handle, side, uplo, trans, &
    M, N, A, IA, JA, descrA, tau, C, IC, JC, descrC, computeType, &
    bufferOnDevice, workspaceInBytesOnDevice, &
    bufferOnHost, workspaceInBytesOnHost, info)
    type(cusolverMpHandle) :: handle
    integer(4) :: side, uplo, trans
    integer(8) :: M, N, IA, JA, IC, JC
    real, device, dimension(*) :: A, tau, C
    type(cusolverMpMatrixDescriptor) :: descrA, descrC
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(1), device :: bufferOnDevice(workspaceInBytesOnDevice)
    integer(1)         :: bufferOnHost(workspaceInBytesOnHost)
    integer(4), device, intent(out) :: info

6.5.22. cusolverMpGels_buffersize

此函数计算传递到 cusolverMpGels 中的主机和设备工作空间所需的缓冲区大小。

A、 B 矩阵的类型、kind 和秩将被忽略，并且由 descrA、 descrB 参数设置。 computeType 通常设置为相同类型。编译器会将数组大小和维度（例如 N、 NRHS）提升为 integer(8)，因此可以使用其他整数 kind。

integer function cusolverMpGels_buffersize(handle, trans, &
    M, N, NRHS, A, IA, JA, descrA, B, IB, JB, descrB, computeType, &
    workspaceInBytesOnDevice, workspaceInBytesOnHost)
    type(cusolverMpHandle) :: handle
    integer(4) :: trans
    integer(8) :: M, N, NRHS, IA, JA, IB, JB
    real, device, dimension(*) :: A, B
    type(cusolverMpMatrixDescriptor) :: descrA, descrB
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost

6.5.23. cusolverMpGels

此函数使用 QR 或 LQ 分解求解 MxN 矩阵 A 或其转置的超定或欠定线性系统。

A、 B 矩阵的类型、kind 和秩将被忽略，并且由 descrA、 descrB 参数设置。 computeType 通常设置为相同类型。编译器会将数组大小和维度（例如 N、 NRHS）提升为 integer(8)，因此可以使用其他整数 kind。

integer function cusolverMpGels(handle, trans, &
    M, N, NRHS, A, IA, JA, descrA, B, IB, JB, descrB, computeType, &
    bufferOnDevice, workspaceInBytesOnDevice, &
    bufferOnHost, workspaceInBytesOnHost, info)
    type(cusolverMpHandle) :: handle
    integer(4) :: trans
    integer(8) :: M, N, NRHS, IA, JA, IB, JB
    real, device, dimension(*) :: A, B
    type(cusolverMpMatrixDescriptor) :: descrA, descrB
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(1), device :: bufferOnDevice(workspaceInBytesOnDevice)
    integer(1)         :: bufferOnHost(workspaceInBytesOnHost)
    integer(4), device, intent(out) :: info

6.5.24. cusolverMpStedc_buffersize

此函数计算传递到 cusolverMpStedc 中的主机和设备工作空间所需的缓冲区大小。

D、 E、 Q 矩阵的类型、kind 和秩将被忽略，并且已由 descrQ 参数设置。 computeType 通常设置为相同类型。编译器会将数组偏移和维度（例如 N、 IQ、 JQ）提升为 integer(8)，因此可以使用其他整数 kind。

integer function cusolverMpStedc_buffersize(handle, compz, &
    N, D, E, Q, IQ, JQ, descrQ, computeType, &
    workspaceInBytesOnDevice, workspaceInBytesOnHost)
    type(cusolverMpHandle) :: handle
    character :: compz
    integer(8) :: N, IQ, JQ
    real, device, dimension(*) :: D, E, Q
    type(cusolverMpMatrixDescriptor) :: descrQ
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(4) :: iwork(*)

6.5.25. cusolverMpStedc

此函数使用分治法计算对称三对角矩阵的所有特征值，以及可选的特征向量。

D、 E、 Q 矩阵的类型、kind 和秩将被忽略，并且已由 descrQ 参数设置。 computeType 通常设置为相同类型。编译器会将数组偏移和维度（例如 N、 IQ、 JQ）提升为 integer(8)，因此可以使用其他整数 kind。

integer function cusolverMpStedc(handle, compz, &
    N, D, E, Q, IQ, JQ, descrQ, computeType, &
    bufferOnDevice, workspaceInBytesOnDevice, &
    bufferOnHost, workspaceInBytesOnHost, info)
    type(cusolverMpHandle) :: handle
    character :: compz
    integer(8) :: N, IQ, JQ
    real, device, dimension(*) :: D, E, Q
    type(cusolverMpMatrixDescriptor) :: descrQ
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(1), device :: bufferOnDevice(workspaceInBytesOnDevice)
    integer(1)         :: bufferOnHost(workspaceInBytesOnHost)
    integer(4), device, intent(out) :: info

6.5.26. cusolverMpGeqrf_buffersize

此函数计算传递到 cusolverMpGeqrf 中的主机和设备工作空间所需的缓冲区大小。

A 矩阵的类型、kind 和秩将被忽略，并且已由 descrA 参数设置。 computeType 通常设置为相同类型。编译器会将数组大小和维度（例如 M、 N）提升为 integer(8)，因此可以使用其他整数 kind。

integer function cusolverMpGeqrf_buffersize(handle, &
    M, N, A, IA, JA, descrA, computeType, &
    workspaceInBytesOnDevice, workspaceInBytesOnHost)
    type(cusolverMpHandle) :: handle
    integer(8) :: M, N, IA, JA
    real, device, dimension(*) :: A
    type(cusolverMpMatrixDescriptor) :: descrA
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost

6.5.27. cusolverMpGeqrf

此函数计算 MxN 矩阵的 QR 分解。

A 矩阵的类型、kind 和秩将被忽略，并且已由 descrA 参数设置。 computeType 通常设置为相同类型。编译器会将数组大小和维度（例如 M、 N、 K）提升为 integer(8)，因此可以使用其他整数 kind。

integer function cusolverMpGeqrf(handle, &
    M, N, A, IA, JA, descrA, tau, computeType, &
    bufferOnDevice, workspaceInBytesOnDevice, &
    bufferOnHost, workspaceInBytesOnHost, info)
    type(cusolverMpHandle) :: handle
    integer(8) :: M, N, IA, JA
    real, device, dimension(*) :: A, tau
    type(cusolverMpMatrixDescriptor) :: descrA
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(1), device :: bufferOnDevice(workspaceInBytesOnDevice)
    integer(1)         :: bufferOnHost(workspaceInBytesOnHost)
    integer(4), device, intent(out) :: info

6.5.28. cusolverMpSytrd_buffersize

此函数计算传递到 cusolverMpSytrd 中的主机和设备工作空间所需的缓冲区大小。

A、 D、 E 矩阵和向量的类型、kind 和秩将被忽略，并且已由 descrA 参数设置。 computeType 通常设置为相同类型。编译器会将数组偏移和维度（例如 N、 IA、 JA）提升为 integer(8)，因此可以使用其他整数 kind。

integer function cusolverMpSytrd_buffersize(handle, uplo, &
    N, A, IA, JA, descrA, D, E, tau, computeType, &
    workspaceInBytesOnDevice, workspaceInBytesOnHost)
    type(cusolverMpHandle) :: handle
    integer(4) :: uplo
    integer(8) :: N, IA, JA
    real, device, dimension(*) :: A, D, E, tau
    type(cusolverMpMatrixDescriptor) :: descrA
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost

6.5.29. cusolverMpSytrd

此函数将对称（Hermitian）NxN 矩阵约化为对称三对角形式。

A、 D、 E 矩阵和向量的类型、kind 和秩将被忽略，并且已由 descrA 参数设置。 computeType 通常设置为相同类型。编译器会将数组偏移和维度（例如 N、 IA、 JA）提升为 integer(8)，因此可以使用其他整数 kind。

integer function cusolverMpSytrd(handle, uplo, &
    N, A, IA, JA, descrA, D, E, tau, computeType, &
    bufferOnDevice, workspaceInBytesOnDevice, &
    bufferOnHost, workspaceInBytesOnHost, info)
    type(cusolverMpHandle) :: handle
    integer(4) :: uplo
    integer(8) :: N, IA, JA
    real, device, dimension(*) :: A, D, E, tau
    type(cusolverMpMatrixDescriptor) :: descrA
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(1), device :: bufferOnDevice(workspaceInBytesOnDevice)
    integer(1)         :: bufferOnHost(workspaceInBytesOnHost)
    integer(4), device, intent(out) :: info

6.5.30. cusolverMpSyevd_buffersize

此函数计算传递到 cusolverMpSyevd 中的主机和设备工作空间所需的缓冲区大小。

A、 D、 Q 矩阵的类型、kind 和秩将被忽略，并且已由 descrA、 descrQ 参数设置。 computeType 通常设置为相同类型。编译器会将数组偏移和维度（例如 N、 IA、 JA）提升为 integer(8)，因此可以使用其他整数 kind。

integer function cusolverMpSyevd_buffersize(handle, compz, &
    uplo, N, A, IA, JA, descrA, D, Q, IQ, JQ, descrQ, computeType, &
    workspaceInBytesOnDevice, workspaceInBytesOnHost)
    type(cusolverMpHandle) :: handle
    character :: compz
    integer(4) :: uplo
    integer(8) :: N, IA, JA, IQ, JQ
    real, device, dimension(*) :: A, D, Q
    type(cusolverMpMatrixDescriptor) :: descrA, descrQ
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost

6.5.31. cusolverMpSyevd

此函数计算对称（Hermitian）nxn 矩阵的特征值和特征向量

A、 D、 Q 矩阵的类型、kind 和秩将被忽略，并且已由 descrA、 descrQ 参数设置。 computeType 通常设置为相同类型。编译器会将数组偏移和维度（例如 N、 IA、 JA）提升为 integer(8)，因此可以使用其他整数 kind。

integer function cusolverMpSyevd(handle, compz, &
    uplo, N, A, IA, JA, descrA, D, Q, IQ, JQ, descrQ, computeType, &
    bufferOnDevice, workspaceInBytesOnDevice, &
    bufferOnHost, workspaceInBytesOnHost, devinfo)
    type(cusolverMpHandle) :: handle
    character :: compz
    integer(4) :: uplo
    integer(8) :: N, IA, JA, IQ, JQ
    real, device, dimension(*) :: A, D, Q
    type(cusolverMpMatrixDescriptor) :: descrA, descrQ
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(1), device :: bufferOnDevice(workspaceInBytesOnDevice)
    integer(1)         :: bufferOnHost(workspaceInBytesOnHost)
    integer(4), device, intent(out) :: devinfo

6.5.32. cusolverMpSygst_buffersize

此函数计算传递到 cusolverMpSygst 中的主机和设备工作空间所需的缓冲区大小。

A、 B 矩阵的类型由 descrA、 descrB 参数设置，而不是传递进来计算缓冲区需求。 computeType 通常设置为相同类型。编译器会将数组偏移和维度（例如 M、 IA、 JA）提升为 integer(8)，因此可以使用其他整数 kind。

integer function cusolverMpSygst_buffersize(handle, ibtype, uplo, &
    M, IA, JA, descrA, IB, JB, descrB, computeType, &
    workspaceInBytesOnDevice, workspaceInBytesOnHost)
    type(cusolverMpHandle) :: handle
    integer(4) :: ibtype, uplo
    integer(8) :: M, IA, JA, IB, JB
    type(cusolverMpMatrixDescriptor) :: descrA, descrB
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost

6.5.33. cusolverMpSygst

此函数将对称正定广义特征值问题简化为标准形式。

A、 B 矩阵的类型、kind 和秩将被忽略，并且已由 descrA、 descrB 参数设置。 computeType 通常设置为相同类型。编译器会将数组偏移和维度（例如 M、 IA、 JA）提升为 integer(8)，因此可以使用其他整数 kind。

integer function cusolverMpSygst(handle, ibtype, uplo, &
    M, A, IA, JA, descrA, B, IB, JB, descrB, computeType, &
    bufferOnDevice, workspaceInBytesOnDevice, &
    bufferOnHost, workspaceInBytesOnHost, info)
    type(cusolverMpHandle) :: handle
    integer(4) :: ibtype, uplo
    integer(8) :: M, IA, JA, IB, JB
    real, device, dimension(*) :: A, B
    type(cusolverMpMatrixDescriptor) :: descrA, descrB
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(1), device :: bufferOnDevice(workspaceInBytesOnDevice)
    integer(1)         :: bufferOnHost(workspaceInBytesOnHost)
    integer(4), device, intent(out) :: info

6.5.34. cusolverMpSygvd_buffersize

此函数计算传递到 cusolverMpSygvd 中的主机和设备工作空间所需的缓冲区大小。

A、 B、 Z 矩阵的类型由 descrA、 descrB、 descrZ 参数设置，而不是传递进来计算缓冲区需求。 computeType 通常设置为相同类型。编译器会将数组偏移和维度（例如 M、 IA、 JA）提升为 integer(8)，因此可以使用其他整数 kind。

integer function cusolverMpSygvd_buffersize(handle, ibtype, jobz, &
    uplo, M, IA, JA, descrA, IB, JB, descrB, IZ, JZ, descrZ, computeType, &
    workspaceInBytesOnDevice, workspaceInBytesOnHost)
    type(cusolverMpHandle) :: handle
    integer(4) :: ibtype, jobz, uplo
    integer(8) :: M, IA, JA, IB, JB, IZ, JZ
    type(cusolverMpMatrixDescriptor) :: descrA, descrB, descrZ
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost

6.5.35. cusolverMpSygvd

此函数计算对称（Hermitian）广义特征值问题的所有特征值和特征向量。

A、 B、 Z 矩阵的类型、kind 和秩将被忽略，并且已由 descrA、 descrB、 descrZ 参数设置。 computeType 通常设置为相同类型。编译器会将数组偏移和维度（例如 M、 IA、 JA）提升为 integer(8)，因此可以使用其他整数 kind。

integer function cusolverMpSygvd(handle, ibtype, jobz, &
    uplo, M, A, IA, JA, descrA, B, IB, JB, descrB, &
    W, Z, IZ, JZ, descrZ, computeType, &
    bufferOnDevice, workspaceInBytesOnDevice, &
    bufferOnHost, workspaceInBytesOnHost, info)
    type(cusolverMpHandle) :: handle
    integer(4) :: ibtype, jobz, uplo
    integer(8) :: M, IA, JA, IB, JB,
    real, device, dimension(*) :: A, B, W, Z
    type(cusolverMpMatrixDescriptor) :: descrA, descrB, descrZ
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(1), device :: bufferOnDevice(workspaceInBytesOnDevice)
    integer(1)         :: bufferOnHost(workspaceInBytesOnHost)
    integer(4), device, intent(out) :: info

6.5.36. cusolverMpLoggerSetFile

此函数指定要用作 cusolverMp 日志文件的 Fortran 单元。

integer(4) function cusolverMpLoggerSetFile(unit)
  integer :: unit

6.5.37. cusolverMpLoggerOpenFile

此函数指定要打开并用作 cusolverMp 日志文件的 Fortran 字符串。

integer(4) function cusolverMpLoggerOpenFile(logFile)
  character*(*) :: logFile

6.5.38. cusolverMpLoggerSetLevel

此函数指定 cusolverMp 日志记录级别。

integer(4) function cusolverMpLoggerSetLevel(level)
  integer :: level

6.5.39. cusolverMpLoggerSetMask

此函数指定 cusolverMp 日志记录掩码。

integer(4) function cusolverMpLoggerSetMask(mask)
  integer :: mask

6.5.40. cusolverMpLoggerForceDisable

此函数禁用 cusolverMp 日志记录。

integer(4) function cusolverMpLoggerForceDisable()

6.6. NVLAMATH 运行时库

本节介绍 NVLAmath 运行时库，该库通过将对标准 LAPACK 子例程的调用重定向到 cuSOLVER 函数的包装器，从而能够在 GPU 上卸载这些调用。

在功能和性能方面，此库没有对本章前几节中记录的内容进行任何补充。我们看到的 NVLAmath 最常见的用例是

• 即插即用加速。在统一内存环境中运行时，NVLAmath 允许重新编译并运行，以将 LAPACK 求解器卸载到 GPU。

• 快速移植功能，这些功能可能对性能不是至关重要的，但数据已通过 CUDA、OpenACC 或 OpenMP 从应用程序的其他部分驻留在 GPU 上。访问启用 GPU 的函数避免了 GPU 和 CPU 之间昂贵的数据来回移动。

• 保持传统代码的完整性。 NVLAmath 可以通过最少的代码更改移植到 GPU，例如在同一源中启用 32 位和 64 位整数，并调用所有目标上都可用的求解器库入口点。

NVLAmath 包装器通过 Fortran nvlamath 模块启用，该模块重载了 LAPACK 子例程名称。用户可以通过两种方式将模块插入到他们的 Fortran 子程序单元中。第一种是非侵入式的：将编译器选项 -gpu=nvlamath 添加到包含您希望移动到 GPU 的 LAPACK 调用的文件的编译行中。第二种方法更传统，只需将 use nvlamath 语句添加到包含这些 LAPACK 调用的子例程或函数中。如果您不使用这两种方法，LAPACK 调用可能会由 CPU LAPACK 库解析，无论是我们提供的库还是您决定在链接行上使用的库。在某些情况下，NVLAmath 包装器甚至可能也调用到该 CPU 库。换句话说，不会篡改 CPU LAPACK 符号（库入口点）名称。

要链接 NVLAmath 包装器库，请将 -cudalib=nvlamath 添加到您的链接行。要使用 64 位整数版本的库，请使用 -i8 选项编译和链接，或将 -cudalib=nvlamath_ilp64 添加到您的链接行。

6.6.1. NVLAMATH 自动即插即用加速

在统一内存环境中，将标准 LAPACK 调用移动到 GPU 上运行的最简单方法是通过我们称之为自动即插即用加速的方法。这目前需要支持 CUDA 托管内存的 GPU 和操作系统，以及传递给库函数的数组是动态分配的。

这是一个调用 dgetrf() 和 dgetrs() 的示例测试程序

program testdgetrf
integer, parameter :: M = 1000, N = M, NRHS=2
real(8), allocatable :: A(:,:), B(:,:)
integer, allocatable :: IPIV(:)
real(8), parameter :: eps = 1.0d-10
!
allocate(A(M,N),B(M,NRHS),IPIV(M))
call random_number(A)
do i = 1, M
    A(i,i) = A(i,i) * 10.0d0
    B(i,1) = sum(A(i,:))
    B(i,2) = B(i,1) * 2.0d0
end do
!
lda = M; ldb = M
call dgetrf(M,N,A,lda,IPIV,info1)
call dgetrs('n',n,NRHS,A,lda,IPIV,B,ldb,info2)
!
if ((info1.ne.0) .or. (info2.ne.0)) then
    print *,"test FAILED"
else if (any(abs(B(:,1)-1.0d0) .gt. eps) .or. &
         any(abs(B(:,2)-2.0d0) .gt. eps)) then
    print *,"test FAILED"
else
    print *,"test PASSED"
end if
end

要使用 nvfortran 编译和链接此程序以进行 CPU 执行，最简单的选项是 nvfortran testdgetrf.f90 -llapack -lblas。要在 GPU 上启用加速，最简单的选项是 nvfortran -stdpar -gpu=nvlamath testdgetrf.f90 -cudalib=nvlamath。这里，-stdpar 是指示编译器和运行时将可分配数组视为 CUDA 托管数据的可用方法之一。-gpu=nvlamath 选项指示编译器将语句 use nvhpc_nvlamath 插入到程序单元中，然后将两个 LAPACK 调用重定向到包装器。最后，-cudalib=nvlamath 链接器选项拉入 NVLAmath 包装器运行时库。

6.6.2. 从 CUDA Fortran 使用 NVLAMATH

从 CUDA Fortran 中使用 NVLAmath 非常简单。nvhpc_nvlamath 模块中的接口在性质上与本文档中的所有其他 Fortran 模块相似。库函数设备虚拟参数可以与设备或托管实际参数，或两者的组合匹配，如此处所用。

此示例代码是用 CUDA Fortran 编写的。请注意，所有 CUDA Fortran 添加项都在 !@cuf 标记之后，或在 CUF 内核中，这仍然允许使用任何 Fortran 编译器编译此文件。

program testdgetrf
!@cuf use nvhpc_nvlamath
!@cuf use cutensorex
integer, parameter :: M = 1000, N = M, NRHS=2
real(8), allocatable :: A(:,:), B(:,:)
integer, allocatable :: IPIV(:)
!@cuf attributes(device) :: A, IPIV
!@cuf attributes(managed) :: B
real(8), parameter :: eps = 1.0d-10
!
allocate(A(M,N),B(M,NRHS),IPIV(M))
call random_number(A)
!$cuf kernel do(1)<<<*,*>>>
do i = 1, M
    A(i,i) = A(i,i) * 10.0d0
    B(i,1) = sum(A(i,:))
    B(i,2) = B(i,1) * 2.0d0
end do
!
lda = M; ldb = M
call dgetrf(M,N,A,lda,IPIV,info1)
call dgetrs('n',n,NRHS,A,lda,IPIV,B,ldb,info2)
!
if ((info1.ne.0) .or. (info2.ne.0)) then
    print *,"test FAILED"
else if (any(abs(B(:,1)-1.0d0) .gt. eps) .or. &
         any(abs(B(:,2)-2.0d0) .gt. eps)) then
    print *,"test FAILED"
else
    print *,"test PASSED"
end if
end

这里我们显式地使用了 nvhpc_nvlamath 模块，并且我们还使用了本文档中其他地方讨论的 cutensorex 模块，以在 GPU 上生成随机数。假设此文件具有 .cuf 扩展名，则与此文件一起使用的最简单的编译和链接行是 nvfortran testdgetrf.cuf -cudalib=curand,nvlamath。

6.6.3. 从 OpenACC 使用 NVLAMATH

从 OpenACC 中，LAPACK 函数就像 CUBLAS 或 CUSOLVER 函数一样处理。使用 host_data use_device 指令将设备指针传递给函数。

program testdgetrf
integer, parameter :: M = 1000, N = M, NRHS=2
real(8) :: A(M,N), B(M,NRHS)
integer :: IPIV(M)
real(8), parameter :: eps = 1.0d-10
!
call random_number(A)
!$acc data copyin(A), copyout(B), create(IPIV)
!$acc parallel loop
do i = 1, M
  A(i,i) = A(i,i) * 10.0d0
  B(i,1) = sum(A(i,:))
  B(i,2) = B(i,1) * 2.0d0
end do
!
lda = M; ldb = M
!$acc host_data use_device(A, IPIV, B)
call dgetrf(M,N,A,lda,IPIV,info1)
call dgetrs('n',n,NRHS,A,lda,IPIV,B,ldb,info2)
!$acc end host_data
!$acc end data
!
if ((info1.ne.0) .or. (info2.ne.0)) then
  print *,"test FAILED"
else if (any(abs(B(:,1)-1.0d0).gt.eps).or.any(abs(B(:,2)-2.0d0).gt.eps)) then
  print *,"test FAILED"
else
  print *,"test PASSED"
end if
end

这里我们展示了静态数组而不是动态数组，因此我们使用 OpenACC 数据指令来控制数据移动。与此文件一起使用的最简单的编译和链接行是 nvfortran -acc=gpu -gpu=nvlamath testdgetrf.f90 -cudalib=nvlamath。

6.6.4. 从 OpenMP 使用 NVLAMATH

从 OpenMP 中使用 NVLAmath 函数与从 OpenACC 中使用基本相同。使用 target data use_device_ptr 指令将设备指针传递给函数。

program testdgetrf
integer, parameter :: M = 1000, N = M, NRHS=2
real(8) :: A(M,N), B(M,NRHS)
integer :: IPIV(M)
real(8), parameter :: eps = 1.0d-10
!
call random_number(A)
!$omp target enter data map(to:A) map(alloc:B,IPIV)
!$omp target teams loop
do i = 1, M
  A(i,i) = A(i,i) * 10.0d0
  B(i,1) = sum(A(i,:))
  B(i,2) = B(i,1) * 2.0d0
end do
!
lda = M; ldb = M
!$omp target data use_device_ptr(A, IPIV, B)
call dgetrf(M,N,A,lda,IPIV,info1)
call dgetrs('n',n,NRHS,A,lda,IPIV,B,ldb,info2)
!$omp end target data
!$omp target exit data map(from:B) map(delete:A,IPIV)
!
if ((info1.ne.0) .or. (info2.ne.0)) then
  print *,"test FAILED"
else if (any(abs(B(:,1)-1.0d0).gt.eps).or.any(abs(B(:,2)-2.0d0).gt.eps)) then
  print *,"test FAILED"
else
  print *,"test PASSED"
end if
end

同样，我们展示了静态数组而不是动态数组，因此我们使用 OpenMP 数据指令来控制数据移动。与此文件一起使用的最简单的编译和链接行是 nvfortran -mp=gpu -gpu=nvlamath testdgetrf.f90 -cudalib=nvlamath。

6.6.5. NVLAMATH 当前子例程列表

在数千个 LAPACK 子例程和函数中，目前此库中包装了 31 个最常用和最需要的子例程。

表 1. NVLAMATH 子例程列表

		S	C	D	Z
线性求解器	LU	sgetrf	cgetrf	dgetrf	zgetrf
		sgetrs	cgetrs	dgetrs	zgetrs
		sgesv
	Cholesky			dpotrf	zpotrf
				dpotrs
特征值求解器	特征值求解器	ssyev		dsyev	zheev
		ssyevd	cheevd	dsyevd	zheevd
	部分特征值求解器	ssyevx	cheevx	dsyevx	zheevx
		ssyevr		dsyevr
	广义问题特征值求解器			dsygv	zhegv
				dsygvd	zhegvd
	广义问题部分特征值求解器				zhegvx
	SVD			dgesvd

6.6.6. NVLAMATH 参数检查和 CPU 回退

在大型复杂的应用程序中，编译器（和开发人员）可能会忽略数据数组的属性：它们是主机数组、托管数组还是设备数组。请注意，编译器将可分配数组自动转换为托管数组要求它们是可分配的。考虑来自即插即用案例的示例，但其中枢轴数组是静态声明的。

program testdgetrf
integer, parameter :: M = 1000, N = M, NRHS=2
real(8), allocatable :: A(:,:), B(:,:)
integer :: IPIV(M)
real(8), parameter :: eps = 1.0d-10
!
allocate(A(M,N),B(M,NRHS))
call random_number(A)
do i = 1, M
    A(i,i) = A(i,i) * 10.0d0
    B(i,1) = sum(A(i,:))
    B(i,2) = B(i,1) * 2.0d0
end do
!
lda = M; ldb = M
call dgetrf(M,N,A,lda,IPIV,info1)
call dgetrs('n',n,NRHS,A,lda,IPIV,B,ldb,info2)
!
if ((info1.ne.0) .or. (info2.ne.0)) then
    print *,"test FAILED"
else if (any(abs(B(:,1)-1.0d0) .gt. eps) .or. &
         any(abs(B(:,2)-2.0d0) .gt. eps)) then
    print *,"test FAILED"
else
    print *,"test PASSED"
end if
end

现在，我们像以前一样编译它，nvfortran -stdpar -gpu=nvlamath testdgetrf.f90 -cudalib=nvlamath。回顾一下，-stdpar 指示编译器和运行时将可分配数组视为 CUDA 托管数据。但是，这次程序运行时

** On entry to dgetrf parameter number 5 failed the pointer check
3: Accessible on GPU = T; Accessible on CPU = T
5: Accessible on GPU = F; Accessible on CPU = T
 Fallback to CPU compute disabled.
 Please (1) make sure that input arrays are accessible on the GPU; or (2) set
 environment variable NVCOMPILER_LAMATH_FALLBACK=1 to fallback to CPU execution.
 Terminate the application

除非调用中的每个数组都只能在 CPU 上访问，否则我们假设如果开发人员正在使用 NVLAMATH，则他们打算在 GPU 上运行库函数，因此应报告子例程参数的 GPU 可访问性不匹配。正如错误消息所述，您可以通过将 NVCOMPILER_LAMATH_FALLBACK 环境变量设置为 1 来继续忽略此错误。

** On entry to dgetrf parameter number 5 failed the pointer check
3: Accessible on GPU = T; Accessible on CPU = T
5: Accessible on GPU = F; Accessible on CPU = T
 Fallback to CPU compute
** On entry to dgetrs parameter number 6 failed the pointer check
4: Accessible on GPU = T; Accessible on CPU = T
6: Accessible on GPU = F; Accessible on CPU = T
7: Accessible on GPU = T; Accessible on CPU = T
 Fallback to CPU compute
 test PASSED

最后，我们假设开发人员更愿意通过使 pivot 数组在 GPU 上可访问来解决此问题，可以通过 CUDA Fortran device 或 managed attributes、OpenACC 或 OpenMP 数据指令，或者将其从静态声明更改为可分配数组来实现。

7. 张量原语运行时库 API

本节介绍 CUDA cuTENSOR 库的 Fortran 接口。 cuTENSOR 函数只能从主机代码访问。 大多数运行时 API 例程（除了一些实用程序外）都是返回错误代码的函数；如果调用成功，它们将返回 CUTENSOR_STATUS_SUCCESS 值，如果发生错误，则返回另一个 cuTENSOR 状态返回值。 与早期的 Fortran 模块不同，我们为返回值创建了一个 cutensorStatus 派生类型。 我们还为测试返回状态重载了 .eq. 和 .ne. 逻辑运算符。

目前，我们为 cuTENSOR 库提供了两个级别的 Fortran 接口：一个低级模块，它与 cuTENSOR v2.0.0 中的 C 接口一对一映射；以及一个实验性高级模块，它将几个标准的 Fortran 内置函数映射到 cuTENSOR 库中包含的功能。

cuTENSOR 版本 2.0 的文档解释了如何将低级代码从版本 1.x 迁移到 2.x。 简而言之，创建函数 cutensorCreateElementwiseBinary(), cutensorCreateElementwiseTrinary(), cutensorCreatePermutation(), cutensorCreateReduction(), 和 cutensorCreateContraction() 创建一个操作描述符类型。 您可以使用 cutensorCreatePlanPreference() 和 cutensorCreatePlan() 分别创建计划首选项和计划。 某些操作需要工作空间，您可以使用 cutensorEstimateWorkspaceSize() 查询工作空间大小。 此时，您拥有一个 cuTensor 计划类型，可以将其传递到执行函数 cutensorElementwiseBinaryExecute(), cutensorElementwiseTrinaryExecute(), cutensorPermute(), cutensorReduce(), 或 cutensorContract() 之一，以及指向设备数据的实际指针和缩放因子。

第 12 章包含从 OpenACC 和 CUDA Fortran 访问 cuTENSOR 库例程的示例。 在这两种情况下，可以通过添加以下行来公开库的接口

use cutensor_v2

到您的程序单元。

除非提供了特定的 kind，否则接口中使用的普通 integer 类型表示 integer(4)，而普通 real 类型表示 real(4)。

7.1. CUTENSOR 定义和辅助函数

本节包含 cuTENSOR 库中使用的定义和数据类型，以及 cuTENSOR 辅助函数的接口。

从 NVHPC 24.1 版本开始，cuTENSOR 2.x 版本库捆绑在发布包中。 版本 2 API 与之前的 1.x 版本有很大不同，并且模块名称已更改以避免混淆。 可以通过添加以下行来公开新的库接口

use cutensor_v2

到您的程序单元。

此 cuTENSOR 模块包含以下派生类型定义

! Definitions from cutensor.h
integer, parameter :: CUTENSOR_MAJOR = 2
integer, parameter :: CUTENSOR_MINOR = 0
integer, parameter :: CUTENSOR_PATCH = 0

! Types from cutensor/types.h
! Algorithm Control
type, bind(c) :: cutensorAlgo
    integer(4) :: algo
end type
type(cutensorAlgo), parameter :: &
    CUTENSOR_ALGO_DEFAULT_PATIENT = cutensorAlgo(-6), &
    CUTENSOR_ALGO_GETT    = cutensorAlgo(-4), &
    CUTENSOR_ALGO_TGETT   = cutensorAlgo(-3), &
    CUTENSOR_ALGO_TTGT    = cutensorAlgo(-2), &
    CUTENSOR_ALGO_DEFAULT = cutensorAlgo(-1)

! Workspace Control
type, bind(c) :: cutensorWorksizePreference
    integer(4) :: wksp
end type
type(cutensorWorksizePreference), parameter :: &
    CUTENSOR_WORKSPACE_MIN         = cutensorWorksizePreference(1), &
    CUTENSOR_WORKSPACE_RECOMMENDED = cutensorWorksizePreference(2), &
    CUTENSOR_WORKSPACE_MAX         = cutensorWorksizePreference(3)

! Unary and Binary Element-wise Operations
type, bind(c) :: cutensorOperator
    integer(4) :: opno
end type
type(cutensorOperator), parameter :: &
    ! Unary
    CUTENSOR_OP_IDENTITY = cutensorOperator(1), & ! Identity operator
    CUTENSOR_OP_SQRT    = cutensorOperator(2), &  ! Square root
    CUTENSOR_OP_RELU    = cutensorOperator(8), &  ! Rectified linear unit
    CUTENSOR_OP_CONJ    = cutensorOperator(9), &  ! Complex conjugate
    CUTENSOR_OP_RCP     = cutensorOperator(10), & ! Reciprocal
    CUTENSOR_OP_SIGMOID = cutensorOperator(11), & ! y=1/(1+exp(-x))
    CUTENSOR_OP_TANH    = cutensorOperator(12), & ! y=tanh(x)
    CUTENSOR_OP_EXP     = cutensorOperator(22), & ! Exponentiation.
    CUTENSOR_OP_LOG     = cutensorOperator(23), & ! Log (base e).
    CUTENSOR_OP_ABS     = cutensorOperator(24), & ! Absolute value.
    CUTENSOR_OP_NEG     = cutensorOperator(25), & ! Negation.
    CUTENSOR_OP_SIN     = cutensorOperator(26), & ! Sine.
    CUTENSOR_OP_COS     = cutensorOperator(27), & ! Cosine.
    CUTENSOR_OP_TAN     = cutensorOperator(28), & ! Tangent.
    CUTENSOR_OP_SINH    = cutensorOperator(29), & ! Hyperbolic sine.
    CUTENSOR_OP_COSH    = cutensorOperator(30), & ! Hyperbolic cosine.
    CUTENSOR_OP_ASIN    = cutensorOperator(31), & ! Inverse sine.
    CUTENSOR_OP_ACOS    = cutensorOperator(32), & ! Inverse cosine.
    CUTENSOR_OP_ATAN    = cutensorOperator(33), & ! Inverse tangent.
    CUTENSOR_OP_ASINH   = cutensorOperator(34), & ! Inverse hyperbolic sine.
    CUTENSOR_OP_ACOSH   = cutensorOperator(35), & ! Inverse hyperbolic cosine.
    CUTENSOR_OP_ATANH   = cutensorOperator(36), & ! Inverse hyperbolic tangent.
    CUTENSOR_OP_CEIL    = cutensorOperator(37), & ! Ceiling.
    CUTENSOR_OP_FLOOR   = cutensorOperator(38), & ! Floor.
    CUTENSOR_OP_MISH    = cutensorOperator(39), & ! Mish y=x*tanh(softplus(x)).
    CUTENSOR_OP_SWISH   = cutensorOperator(40), & ! Swish y=x*sigmoid(x).
    CUTENSOR_OP_SOFT_PLUS = cutensorOperator(41), & ! Softplus y=log(exp(x)+1).
    CUTENSOR_OP_SOFT_SIGN = cutensorOperator(42), & ! Softsign y=x/(abs(x)+1).

    ! Binary
    CUTENSOR_OP_ADD     = cutensorOperator(3), &  ! Addition of two elements
    CUTENSOR_OP_MUL     = cutensorOperator(5), &  ! Multiplication of 2 elements
    CUTENSOR_OP_MAX     = cutensorOperator(6), &  ! Maximum of two elements
    CUTENSOR_OP_MIN     = cutensorOperator(7), &  ! Minimum of two elements
    CUTENSOR_OP_UNKNOWN = cutensorOperator(126)   ! reserved for internal use only

! Status Return Values
type, bind(c) :: cutensorStatus
    integer(4) :: stat
end type
type(cutensorStatus), parameter :: &
    ! The operation completed successfully.
    CUTENSOR_STATUS_SUCCESS                = cutensorStatus(0), &
    ! The cuTENSOR library was not initialized.
    CUTENSOR_STATUS_NOT_INITIALIZED        = cutensorStatus(1), &
    ! Resource allocation failed inside the cuTENSOR library.
    CUTENSOR_STATUS_ALLOC_FAILED           = cutensorStatus(3), &
    ! An unsupported value or parameter was passed to the function.
    CUTENSOR_STATUS_INVALID_VALUE          = cutensorStatus(7), &
    ! Indicates that the device is either not ready,
    ! or the target architecture is not supported.
    CUTENSOR_STATUS_ARCH_MISMATCH          = cutensorStatus(8), &
    ! An access to GPU memory space failed, which is usually caused
    ! by a failure to bind a texture.
    CUTENSOR_STATUS_MAPPING_ERROR          = cutensorStatus(11), &
    ! The GPU program failed to execute. This is often caused by a
    ! launch failure of the kernel on the GPU, which can be caused by
    ! multiple reasons.
    CUTENSOR_STATUS_EXECUTION_FAILED       = cutensorStatus(13), &
    ! An internal cuTENSOR error has occurred.
    CUTENSOR_STATUS_INTERNAL_ERROR         = cutensorStatus(14), &
    ! The requested operation is not supported.
    CUTENSOR_STATUS_NOT_SUPPORTED          = cutensorStatus(15), &
    ! The functionality requested requires some license and an error
    ! was detected when trying to check the current licensing.
    CUTENSOR_STATUS_LICENSE_ERROR          = cutensorStatus(16), &
    ! A call to CUBLAS did not succeed.
    CUTENSOR_STATUS_CUBLAS_ERROR           = cutensorStatus(17), &
    ! Some unknown CUDA error has occurred.
    CUTENSOR_STATUS_CUDA_ERROR             = cutensorStatus(18), &
    ! The provided workspace was insufficient.
    CUTENSOR_STATUS_INSUFFICIENT_WORKSPACE = cutensorStatus(19), &
    ! Indicates that the driver version is insufficient.
    CUTENSOR_STATUS_INSUFFICIENT_DRIVER    = cutensorStatus(20), &
    ! Indicates an error related to file I/O
    CUTENSOR_STATUS_IO_ERROR               = cutensorStatus(21)

! Data Type
type, bind(c) :: cutensorDataType
    integer(4) :: cudaDataType
end type
type(cutensorDataType), parameter :: &
    CUTENSOR_R_16F  =  cutensorDataType(2), & ! real as a half
    CUTENSOR_C_16F  =  cutensorDataType(6), & ! complex as a pair of half numbers
    CUTENSOR_R_16BF = cutensorDataType(14), & ! real as a nv_bfloat16
    CUTENSOR_C_16BF = cutensorDataType(15), & ! complex as a pair of nv_bfloat16 numbers
    CUTENSOR_R_32F  =  cutensorDataType(0), & ! real as a float
    CUTENSOR_C_32F  =  cutensorDataType(4), & ! complex as a pair of float numbers
    CUTENSOR_R_64F  =  cutensorDataType(1), & ! real as a double
    CUTENSOR_C_64F  =  cutensorDataType(5), & ! complex as a pair of double numbers
    CUTENSOR_R_4I   = cutensorDataType(16), & ! real as a signed 4-bit int
    CUTENSOR_C_4I   = cutensorDataType(17), & ! complex as a pair of signed 4-bit int numbers
    CUTENSOR_R_4U   = cutensorDataType(18), & ! real as a unsigned 4-bit int
    CUTENSOR_C_4U   = cutensorDataType(19), & ! complex as a pair of unsigned 4-bit int numbers
    CUTENSOR_R_8I   =  cutensorDataType(3), & ! real as a signed 8-bit int
    CUTENSOR_C_8I   =  cutensorDataType(7), & ! complex as a pair of signed 8-bit int numbers
    CUTENSOR_R_8U   =  cutensorDataType(8), & ! real as a unsigned 8-bit int
    CUTENSOR_C_8U   =  cutensorDataType(9), & ! complex as a pair of unsigned 8-bit int numbers
    CUTENSOR_R_16I  = cutensorDataType(20), & ! real as a signed 16-bit int
    CUTENSOR_C_16I  = cutensorDataType(21), & ! complex as a pair of signed 16-bit int numbers
    CUTENSOR_R_16U  = cutensorDataType(22), & ! real as a unsigned 16-bit int
    CUTENSOR_C_16U  = cutensorDataType(23), & ! complex as a pair of unsigned 16-bit int numbers
    CUTENSOR_R_32I  = cutensorDataType(10), & ! real as a signed 32-bit int
    CUTENSOR_C_32I  = cutensorDataType(11), & ! complex as a pair of signed 32-bit int numbers
    CUTENSOR_R_32U  = cutensorDataType(12), & ! real as a unsigned 32-bit int
    CUTENSOR_C_32U  = cutensorDataType(13), & ! complex as a pair of unsigned 32-bit int numbers
    CUTENSOR_R_64I  = cutensorDataType(24), & ! real as a signed 64-bit int
    CUTENSOR_C_64I  = cutensorDataType(25), & ! complex as a pair of signed 64-bit int numbers
    CUTENSOR_R_64U  = cutensorDataType(26), & ! real as a unsigned 64-bit int
    CUTENSOR_C_64U  = cutensorDataType(27)        ! complex as a pair of unsigned 64-bit int numbers

! Compute Type, no longer used, will be removed
type, bind(c) :: cutensorComputeType
    integer(4) :: ctyp
end type
type(cutensorComputeType), parameter :: &
    CUTENSOR_R_MIN_16F = cutensorComputeType(2**0), & ! real as a half
    CUTENSOR_C_MIN_16F = cutensorComputeType(2**1), & ! complex as a half
    CUTENSOR_R_MIN_32F = cutensorComputeType(2**2), & ! real as a float
    CUTENSOR_C_MIN_32F = cutensorComputeType(2**3), & ! complex as a float
    CUTENSOR_R_MIN_64F = cutensorComputeType(2**4), & ! real as a double
    CUTENSOR_C_MIN_64F = cutensorComputeType(2**5), & ! complex as a double
    CUTENSOR_R_MIN_8U  = cutensorComputeType(2**6), & ! real as a uint8
    CUTENSOR_R_MIN_32U = cutensorComputeType(2**7), & ! real as a uint32
    CUTENSOR_R_MIN_8I  = cutensorComputeType(2**8), & ! real as a int8
    CUTENSOR_R_MIN_32I = cutensorComputeType(2**9), & ! real as a int32
    CUTENSOR_R_MIN_16BF = cutensorComputeType(2**10), & ! real as a bfloat16
    CUTENSOR_R_MIN_TF32 = cutensorComputeType(2**11), & ! real as a tf32
    CUTENSOR_C_MIN_TF32 = cutensorComputeType(2**12) ! complex as a tf32

! Operation Descriptor attribute
type, bind(c) :: cutensorOperationDescriptorAttribute
    integer(4) :: attr
end type
type(cutensorOperationDescriptorAttribute), parameter :: &
    CUTENSOR_OPERATION_DESCRIPTOR_TAG = &
      cutensorOperationDescriptorAttribute(0), &  ! integer(4)
    CUTENSOR_OPERATION_DESCRIPTOR_SCALAR_TYPE = &
      cutensorOperationDescriptorAttribute(1), &  ! cutensorDataType
    CUTENSOR_OPERATION_DESCRIPTOR_FLOPS = &
      cutensorOperationDescriptorAttribute(2), &  ! real(4)
    CUTENSOR_OPERATION_DESCRIPTOR_MOVED_BYTES = &
      cutensorOperationDescriptorAttribute(3), &  ! real(4)
    CUTENSOR_OPERATION_DESCRIPTOR_PADDING_LEFT = &
      cutensorOperationDescriptorAttribute(4), &  ! integer(4)
    CUTENSOR_OPERATION_DESCRIPTOR_PADDING_RIGHT = &
      cutensorOperationDescriptorAttribute(5), &  ! integer(4)
    CUTENSOR_OPERATION_DESCRIPTOR_PADDING_VALUE = &
      cutensorOperationDescriptorAttribute(6)     ! type(c_ptr)

! Plan Preference attribute
type, bind(c) :: cutensorPlanPreferenceAttribute
    integer(4) :: attr
end type
type(cutensorPlanPreferenceAttribute), parameter :: &
    CUTENSOR_PLAN_PREFERENCE_AUTOTUNE_MODE = &
      cutensorPlanPreferenceAttribute(0), &  ! cutensorAutotuneMode type
    CUTENSOR_PLAN_PREFERENCE_CACHE_MODE = &
      cutensorPlanPreferenceAttribute(1), &  ! cutensorCacheMode type
    CUTENSOR_PLAN_PREFERENCE_INCREMENTAL_COUNT = &
      cutensorPlanPreferenceAttribute(2), &  ! integer(4)
    CUTENSOR_PLAN_PREFERENCE_ALGO = &
      cutensorPlanPreferenceAttribute(3), &  ! cutensorAlgo type
    CUTENSOR_PLAN_PREFERENCE_KERNEL_RANK = &
      cutensorPlanPreferenceAttribute(4), &  ! integer(4)
    CUTENSOR_PLAN_PREFERENCE_JIT = &
      cutensorPlanPreferenceAttribute(5)     ! cutensorJitMode type

! Plan Info attribute
type, bind(c) :: cutensorPlanInfoAttribute
    integer(4) :: attr
end type
type(cutensorPlanInfoAttribute), parameter :: &
    ! Pass integer(8), return exact required workspace in bytes needed
    CUTENSOR_PLAN_REQUIRED_WORKSPACE = cutensorPlanInfoAttribute(0)

! Autotune Mode
type, bind(c) :: cutensorAutotuneMode
    integer(4) :: mode
end type
type(cutensorAutotuneMode), parameter :: &
    CUTENSOR_AUTOTUNE_MODE_NONE        = cutensorAutotuneMode(0), &
    CUTENSOR_AUTOTUNE_MODE_INCREMENTAL = cutensorAutotuneMode(1)

! JIT Mode
type, bind(c) :: cutensorJitMode
    integer(4) :: mode
end type
type(cutensorJitMode), parameter :: &
    CUTENSOR_JIT_MODE_NONE        = cutensorJitMode(0), &
    CUTENSOR_JIT_MODE_DEFAULT     = cutensorJitMode(1)

! Cache Mode
type, bind(c) :: cutensorCacheMode
    integer(4) :: mode
end type
type(cutensorCacheMode), parameter :: &
    CUTENSOR_CACHE_MODE_NONE        = cutensorCacheMode(0), &
    CUTENSOR_CACHE_MODE_PEDANTIC    = cutensorCacheMode(1)

! New 2.0 handle types
type cutensorHandle
  TYPE(C_PTR) :: handle
end type

type cutensorTensorDescriptor
  TYPE(C_PTR) :: desc
end type

type cutensorOperationDescriptor
  TYPE(C_PTR) :: desc
end type

type cutensorComputeDescriptor
  TYPE(C_PTR) :: desc
end type

type cutensorPlan
  TYPE(C_PTR) :: desc
end type

type cutensorPlanPreference
  TYPE(C_PTR) :: desc
end type

! These are global C symbols in libcutensor
type(cutensorComputeDescriptor), &
  bind(C, name='CUTENSOR_COMPUTE_DESC_16F') ::  cutensor_Compute_Desc_16F
type(cutensorComputeDescriptor), &
  bind(C, name='CUTENSOR_COMPUTE_DESC_16BF') :: cutensor_Compute_Desc_16BF
type(cutensorComputeDescriptor), &
  bind(C, name='CUTENSOR_COMPUTE_DESC_TF32') :: cutensor_Compute_Desc_TF32
type(cutensorComputeDescriptor), &
  bind(C, name='CUTENSOR_COMPUTE_DESC_3XTF32') :: cutensor_Compute_Desc_3XTF32
type(cutensorComputeDescriptor), &
  bind(C, name='CUTENSOR_COMPUTE_DESC_32F') :: cutensor_Compute_Desc_32F
type(cutensorComputeDescriptor), &
  bind(C, name='CUTENSOR_COMPUTE_DESC_64F') :: cutensor_Compute_Desc_64F

7.1.1. cutensorCreate

此函数初始化 cuTENSOR 库并返回一个句柄，用于后续的 cuTENSOR 调用。

type(cutensorStatus) function cutensorCreate(handle)
   type(cutensorHandle) :: handle

7.1.2. cutensorDestroy

此函数释放 cuTENSOR 库使用的资源。 此函数通常是使用特定句柄调用 cuTENSOR API 的最后一个调用。

type(cutensorStatus) function cutensorDestroy(handle)
   type(cutensorHandle) :: handle

7.1.3. cutensorCreateTensorDescriptor

此函数创建并初始化一个 cuTENSOR 描述符，给定模式数量、范围、步幅和数据类型。

type(cutensorStatus) function cutensorCreateTensorDescriptor(handle, desc, &
        numModes, extent, stride, dataType, alignmentRequirement)
    type(cutensorHandle) :: handle
    type(cutensorTensorDescriptor) :: desc
    integer(4) :: numModes
    integer(8), dimension(*) :: extent
    integer(8), dimension(*) :: stride
    type(cutensorDataType) :: dataType
    integer(4) :: alignmentRequirement

7.1.4. cutensorDestroyTensorDescriptor

此函数删除 cuTENSOR 张量描述符并释放与其关联的资源。

type(cutensorStatus) function cutensorDestroyTensorDescriptor(desc)
    type(cutensorTensorDescriptor) :: desc

7.1.5. cutensorOperationDescriptorGetAttribute

此函数检索操作描述符类型的属性

type(cutensorStatus) function cutensorOperationDescriptorGetAttribute(handle, &
    desc, attr, buf, sizeInBytes)
    type(cutensorHandle) :: handle
    type(cutensorOperationDescriptor) :: desc
    type(cutensorOperationDescriptorAttribute) :: attr
    integer(4) :: buf(*)  ! Any type, of size sizeInBytes
    integer(8) :: sizeInBytes

7.1.6. cutensorOperationDescriptorSetAttribute

此函数设置操作描述符类型的属性

type(cutensorStatus) function cutensorOperationDescriptorSetAttribute(handle, &
    desc, attr, buf, sizeInBytes)
    type(cutensorHandle) :: handle
    type(cutensorOperationDescriptor) :: desc
    type(cutensorOperationDescriptorAttribute) :: attr
    integer(4) :: buf(*)  ! Any type, of size sizeInBytes
    integer(8) :: sizeInBytes

7.1.7. cutensorDestroyOperationDescriptor

此函数释放与操作描述符类型相关的资源

type(cutensorStatus) function cutensorDestroyOperationDescriptor(desc)
    type(cutensorOperationDescriptor) :: desc

7.1.8. cutensorCreatePlanPreference

此函数分配并设置 cuTENSOR 计划首选项类型。

type(cutensorStatus) function cutensorCreatePlanPreference(handle, pref, algo, &
        jitMode)
    type(cutensorHandle) :: handle
    type(cutensorPlanPreference) :: pref
    type(cutensorAlgo) :: algo
    type(cutensorJitMode) :: jitMode

7.1.9. cutensorDestroyPlanPreference

此函数释放与计划首选项类型关联的资源。

type(cutensorStatus) function cutensorDestroyPlanPreference(pref)
    type(cutensorPlanPreference) :: pref

7.1.10. cutensorPlanPreferenceSetAttribute

此函数设置操作描述符类型的属性

type(cutensorStatus) function cutensorPlanPreferenceSetAttribute(handle, pref, &
    attr, buf, sizeInBytes)
    type(cutensorHandle) :: handle
    type(cutensorPlanPreference) :: pref
    type(cutensorPlanPreferenceAttribute) :: attr
    integer(4) :: buf(*)  ! Any type, of size sizeInBytes
    integer(8) :: sizeInBytes

7.1.11. cutensorEstimateWorkspaceSize

此函数确定给定操作和首选项所需的工作空间大小。

type(cutensorStatus) function cutensorEstimateWorkspaceSize(handle, desc, &
        pref, workspacePref, workspaceSizeEstimate)
    type(cutensorHandle) :: handle
    type(cutensorOperationDescriptor) :: desc
    type(cutensorPlanPreference) :: pref
    type(cutensorWorksizePreference) :: workspacePref
    integer(8) :: workspaceSizeEstimate

7.1.12. cutensorCreatePlan

此函数分配并设置 cuTENSOR 计划类型。

type(cutensorStatus) function cutensorCreatePlan(handle, plan, &
        desc, pref, workspaceSizeLimit)
    type(cutensorHandle) :: handle
    type(cutensorPlan), intent(out) :: plan
    type(cutensorOperationDescriptor) :: desc
    type(cutensorPlanPreference) :: pref
    integer(8) :: workspaceSizeLimit

7.1.13. cutensorDestroyPlan

此函数释放与 cuTENSOR 计划类型关联的资源。

type(cutensorStatus) function cutensorDestroyPlan(plan)
    type(cutensorPlan) :: plan

7.1.14. cutensorGetErrorString

此函数返回错误代码的描述字符串。

character*128 function cutensorGetErrorString(ierr)
   type(cutensorStatus) :: ierr

7.1.15. cutensorGetVersion

此函数返回 cuTENSOR 库的版本号。

integer(8) function cutensorGetVersion()

7.1.16. cutensorGetCudartVersion

此函数返回 cuTENSOR 库编译时所针对的 CUDA 运行时的版本。

integer(8) function cutensorGetCudartVersion()

7.2. CUTENSOR 逐元素操作

本节包含 cuTENSOR 函数的接口，这些函数在张量之间执行逐元素操作。

7.2.1. cutensorCreatePermutation

此函数创建以下形式的异位张量置换运算符

B = alpha * opA(perm(A)) 置换操作信息存储在 intent(out) desc 参数中。

数组 A, B 可以是任何支持的类型、种类和秩。 A, B 的置换是使用模式参数设置的。

type(cutensorStatus) function cutensorCreatePermutation(handle, desc, &
    descA, modeA, opA, descB, modeB, descCompute)
    type(cutensorHandle) :: handle
    type(cutensorOperationDescriptor), intent(out) :: desc
    type(cutensorTensorDescriptor) :: descA, descB
    integer(4), dimension(*) :: modeA, modeB
    type(cutensorOperator) :: opA
    type(cutensorComputeDescriptor) :: descCompute

7.2.2. cutensorPermute

此函数执行以下形式的异位张量置换

B = alpha * opA(perm(A))

alpha 标量的类型和种类由 typeScalar 参数确定。 数组 A, B 可以是任何支持的类型、种类和秩。 A, B 的置换是使用模式参数设置的。 操作 opA(perm(A)) 在调用 cutensorInitTensorDescriptor() 时通过 unaryOp 参数设置。

type(cutensorStatus) function cutensorPermute(handle, plan, &
    alpha, A, B, stream)
    type(cutensorHandle) :: handle
    type(cutensorPlan) :: plan
    real :: alpha
    real, device, dimension(*) :: A, B
    integer(kind=cuda_stream_kind) :: stream

7.2.3. cutensorCreateElementwiseBinary

此函数在两个输入上创建逐元素张量运算，形式如下

D=opAC(alpha*op(perm(A)),gamma*op(perm(C)))

opA, opC 参数是逐元素一元运算符。 opAC 参数是逐元素二元运算符。 数组 A, C, D 可以是任何支持的类型、种类和秩。 A, C, D 的置换是使用模式参数设置的。

type(cutensorStatus) function cutensorCreateElementwiseBinary(handle, desc, &
        descA, modeA, opA, descC, modeC, opC, &
        descD, modeD, opAC, descCompute)
    type(cutensorHandle) :: handle
    type(cutensorOperationDescriptor) :: desc
    type(cutensorTensorDescriptor) :: descA, descC, descD
    integer(4), dimension(*) :: modeA, modeC, modeD
    type(cutensorOperator) :: opA, opC, opAC
    type(cutensorComputeDescriptor) :: descCompute

7.2.4. cutensorElementwiseBinaryExecute

此函数在两个输入上执行逐元素张量运算，形式如下

D=opAC(alpha*op(perm(A)),gamma*op(perm(C)))

指定的计划是通过调用 cutensorCreatePlan() 创建的。 数组 A, C, D 可以是任何支持的类型、种类和秩。 alpha, gamma 标量的允许类型和种类由调用 cutensorCreateElementwiseBinary 中的计算描述符确定。

type(cutensorStatus) function cutensorElementwiseBinaryExecute(handle, &
    plan, alpha, A, gamma, C, D, stream)
    type(cutensorHandle) :: handle
    type(cutensorPlan) :: plan
    real :: alpha, gamma  ! Any compatible type and kind
    real, device, dimension(*) :: A, C, D
    integer(kind=cuda_stream_kind) :: stream

7.2.5. cutensorCreateElementwiseTrinary

此函数在三个输入上创建逐元素张量运算，形式如下

D=opABC(opAB(alpha*op(perm(A)),beta*op(perm(B))),gamma*op(perm(C)))

opA, opB, opC 参数是逐元素一元运算符。 opAB 参数是逐元素二元运算符。 数组 A, B, C, D 可以是任何支持的类型、种类和秩。 A, B, C, D 的置换是使用模式参数设置的。

type(cutensorStatus) function cutensorCreateElementwiseTrinary(handle, desc, &
        descA, modeA, opA, descB, modeB, opB, descC, modeC, opC, &
        descD, modeD, opAB, descCompute)
    type(cutensorHandle) :: handle
    type(cutensorOperationDescriptor) :: desc
    type(cutensorTensorDescriptor) :: descA, descB, descC, descD
    integer(4), dimension(*) :: modeA, modeB, modeC, modeD
    type(cutensorOperator) :: opA, opB, opC, opAB
    type(cutensorComputeDescriptor) :: descCompute

7.2.6. cutensorElementwiseTrinaryExecute

此函数在三个输入上执行逐元素张量运算，形式如下

D=opABC(opAB(alpha*op(perm(A)),beta*op(perm(B))),gamma*op(perm(C)))

指定的计划是通过调用 cutensorCreatePlan() 创建的。 数组 A, B, C, D 可以是任何支持的类型、种类和秩。 alpha, gamma 标量的允许类型和种类由调用 cutensorCreateElementwiseTrinary 中的计算描述符确定。

type(cutensorStatus) function cutensorElementwiseTrinaryExecute(handle, plan,  &
    alpha, A, beta, B, gamma, C, D, stream)
    type(cutensorHandle) :: handle
    type(cutensorPlan) :: plan
    real :: alpha, beta, gamma  ! Any compatible type and kind
    real, device, dimension(*) :: A, B, C, D
    integer(kind=cuda_stream_kind) :: stream

7.3. CUTENSOR 归约操作

本节包含 cuTENSOR 函数的接口，这些函数对张量执行归约操作。

7.3.1. cutensorCreateReduction

此函数创建以下形式的归约张量运算

D = alpha * opReduce(opA(A)) + beta * opC(C)

opA, opC 参数是逐元素一元运算符。 opReduce 参数是二元运算符。 数组 A, C, D 可以是任何支持的类型、种类和秩。 A, C 的置换是使用模式参数设置的。

type(cutensorStatus) function cutensorCreateReduction(handle, desc, &
        descA, modeA, opA, descC, modeC, opC, &
        descD, modeD, opReduce, descCompute)
    type(cutensorHandle) :: handle
    type(cutensorOperationDescriptor) :: desc
    type(cutensorTensorDescriptor) :: descA, descC, descD
    integer(4), dimension(*) :: modeA, modeC, modeD
    type(cutensorOperator) :: opA, opC, opReduce
    type(cutensorComputeDescriptor) :: descCompute

7.3.2. cutensorReduce

此函数执行以下形式的归约

D = alpha * opReduce(opA(A)) + beta * opC(C)

指定的计划是通过调用 cutensorCreatePlan() 创建的。 数组 A, C, D 可以是任何支持的类型、种类和秩。 alpha, beta 标量的允许类型和种类由调用 cutensorCreateReduction 中的计算描述符确定。

type(cutensorStatus) function cutensorReduce(handle, plan, &
    alpha, A, beta, C, D, workspace, workspaceSize, stream)
    type(cutensorHandle) :: handle
    type(cutensorPlan) :: plan
    real :: alpha, beta  ! Any compatible type and kind
    real, device, dimension(*) :: A, C, D
    real, device, dimension(*) :: workspace  ! Any type
    integer(8) :: workspaceSize
    integer(kind=cuda_stream_kind) :: stream

7.4. CUTENSOR 缩并操作

本节包含 cuTENSOR 函数的接口，这些函数在张量之间执行缩并操作。

7.4.1. cutensorCreateContraction

此函数创建以下形式的缩并张量运算

D = alpha*(AxB) + beta*C

opA, opB, opC 参数是逐元素一元运算符。 数组 A, B, C, D 可以是任何支持的类型、种类和秩。 A, B, C 的置换是使用模式参数设置的。

type(cutensorStatus) function cutensorCreateContraction(handle, desc, &
        descA, modeA, opA, descB, modeB, opB, &
        descC, modeC, opC, descD, modeD, descCompute)
    type(cutensorHandle) :: handle
    type(cutensorOperationDescriptor) :: desc
    type(cutensorTensorDescriptor) :: descA, descB, descC, descD
    integer(4), dimension(*) :: modeA, modeB, modeC, modeD
    type(cutensorOperator) :: opA, opB, opC
    type(cutensorComputeDescriptor) :: descCompute

7.4.2. cutensorContract

此函数执行以下形式的缩并

D = alpha*(AxB) + beta*C

指定的计划是通过调用 cutensorCreatePlan() 创建的。 数组 A, B, C, D 可以是任何支持的类型、种类和秩。 alpha, beta 标量的允许类型和种类由调用 cutensorCreateContraction 中的计算描述符确定。

type(cutensorStatus) function cutensorContract(handle, plan, &
    alpha, A, B, beta, C, D, workspace, workspaceSize, stream)
    type(cutensorHandle) :: handle
    type(cutensorPlan) :: plan
    real :: alpha, beta  ! Any compatible type and kind
    real, device, dimension(*) :: A, B, C, D
    real, device, dimension(*) :: workspace  ! Any type
    integer(8) :: workspaceSize
    integer(kind=cuda_stream_kind) :: stream

7.5. CUTENSOR Fortran 扩展

本节包含基于 cuTENSOR 库构建的 Fortran 数组内置函数操作、数组表达式和数组赋值的 cuTENSOR 接口扩展。 在 CUDA Fortran 中，这些操作采用具有 device 或 managed 属性的数据。 在 OpenACC 中，可以使用 host_data 构造调用它们。 通过在程序单元中添加行 use cutensorEx 来公开这些扩展的接口，或者可以使用 Fortran 块功能将其应用于特定语句，如下一个示例所示。

block; use cutensorEx
  D = reshape(A,shape=[ni,nk,nj],order=[1,3,2])
end block

为了使操作在一次底层内核调用中进行，RHS 表达式被延迟，直到重载的赋值操作同时具有 LHS 和 RHS。 这保证了在任何可能的情况下，性能与低级 cuTENSOR API 相当。 通用性受到影响，因此目前仅支持特定形式的 Fortran 语句，这些语句将在本章的后续章节中进行文档说明。

由于 cuTENSOR 库操作采用流参数，因此我们添加了一种设置 cuTENSOR 默认流的方法，我们的运行时将维护该默认流，每个 CPU 线程一个副本。 也就是

integer function cutensorexSetStream(stream)
integer(kind=cuda_stream_kind) :: stream

7.5.1. Fortran Reshape

此 Fortran 函数更改数组的形状，并可能置换维度和布局。 它的调用方式如下

D = alpha * func(reshape(A, shape=[...], order=[...]))

数组 A 和 D 的类型可以是 real(2)、real(4)、real(8)、complex(4) 或 complex(8)。 A 和 D 的秩（维度数）可以是 1 到 7。 alpha 值应与 A 的类型相同，或者与 func(reshape(A)) 的类型相同（如果不同）。 可以应用于 reshape 结果的接受函数在本节末尾列出。 当前不支持 F90 reshape 函数的 pad 参数。 除了初始化和设置 cuTENSOR 描述符外，此 Fortran 调用还映射到 cutensorPermutation()。

! Example to switch the 2nd and 3rd dimension layout
D = reshape(a,shape=[ni,nk,nj], order=[1,3,2])
! Same example, take the absolute value and scale by 2.5
D = 2.5 * abs(reshape(a,shape=[ni,nk,nj], order=[1,3,2]))

7.5.2. Fortran Transpose

此 Fortran 函数转置矩阵（二维数组）。 它的调用方式如下

D = alpha * func(transpose(A))

数组 A 和 D 的类型可以是 real(2)、real(4)、real(8)、complex(4) 或 complex(8)。 A 和 D 的秩（维度数）为 2。 应用缩放（alpha 参数）或将函数应用于转置结果是可选的。 alpha 值应与 A 的类型相同，或者与 func(transpose(A)) 的类型相同（如果不同）。 可以应用于 transpose 结果的接受函数在本节末尾列出。 除了初始化和设置 cuTENSOR 描述符外，此 Fortran 调用还映射到 cutensorPermutation()。

! Example of transpose
D = transpose(A)
! Same example, take the absolute value and scale by 2.5
D = 2.5 * abs(tranpose(A))

7.5.3. Fortran Spread

此 Fortran 函数通过指定的维度将数组的秩增加一，并在新维度上广播值。 它的调用方式如下

D = alpha * func(spread(A, dim=i, ncopies=n))

数组 A 和 D 的类型可以是 real(2)、real(4)、real(8)、complex(4) 或 complex(8)。 A 和 D 的秩（维度数）可以是 1 到 7。 alpha 值应与 A 的类型相同。 可以应用于 spread 结果的接受函数在本节末尾列出。 除了初始化和设置 cuTENSOR 描述符外，此 Fortran 调用还映射到 cutensorPermutation()。

! Example to add and broadcast values over the new first dimension
D = spread(A, dim=1, ncopies=n1)
! Same example, take the absolute value and scale by 2.5
D = 2.5 * abs(spread(A, dim=1, ncopies=n1))

7.5.4. Fortran 逐元素表达式

对将涉及两个或三个源数组的表达式转换为 cuTENSOR 调用的支持有限。 第一个或前两个操作数可以是置换数组，reshape()、transpose() 或 spread() 调用的结果。 元素函数可以应用于数组操作数（无论是否置换），它们也可以缩放。 以下是一些支持的形式

D = A + B

D = permute(A) + B

D = A + permute(B)

D = permute(A) - B

D = A - permute(B)

D = A + func(permute(B))

D = func(permute(A)) + permute(B)

D = alpha * func(permute(A)) + beta * permute(B) + gamma * C

数组 A、B、C 和 D 的类型可以是 real(2)、real(4)、real(8)、complex(4) 或 complex(8)。 A、B、C 和 D 的秩（维度数）可以是 1 到 7。 对于三操作数情况，数组 C 和 D 必须具有相同的形状、步幅和类型。 alpha 值应与 A 的类型相同。 beta 和 B 以及 gamma 和 C 也是如此。 Fortran 包装器不进行类型转换，但 cuTENSOR 可能会进行类型转换。 对数组一致性的编译时检查是有限的。 来自 Fortran 包装器或 cuTENSOR 的其他运行时检查可能用于不支持的组合。 可以应用于置换或未置换数组的接受函数在本节末尾列出。 除了初始化和设置 cuTENSOR 描述符外，这些 Fortran 表达式还映射到 cutensorElementwiseBinary() 或 cutensorElementwiseTrinary()。

! Example to scale and add two arrays together
D = alpha * A + beta * B
! Same example, take the absolute value of A and B and add to C
D = alpha * abs(A) + beta * abs(B) + C
! Transpose the first array before adding to the second
D = alpha * abs(transpose(A)) + beta * abs(B) + C

7.5.5. Fortran Matmul 操作

矩阵乘法是张量缩并的一个实例。 matmul 的任一操作数都可以是置换数组，reshape()、transpose() 或 spread() 调用的结果。 cuTENSOR 库当前不支持将元素函数应用于数组操作数，但可以缩放结果和累加器。 以下是一些支持的形式

D = matmul(A, B)

D = matmul(permute(A), B)

D = matmul(A, permute(B))

D = matmul(permute(A), permute(B))

D = C + matmul(A, B)

D = C - matmul(A, B)

D = alpha * matmul(A, B) + beta * C

数组 A、B、C 和 D 的类型可以是 real(2)、real(4)、real(8)、complex(4) 或 complex(8)。 在任何置换之后，A、B、C 和 D 的秩（维度数）必须为 2。 数组 C 和 D 目前必须具有相同的形状、步幅和类型。 alpha 值应与 A 和 B 的类型相同。 beta 值应与 C 的类型相同。 Fortran 包装器不进行类型转换，但 cuTENSOR 可能会进行类型转换。 对数组一致性的编译时检查是有限的。 来自 Fortran 包装器或 cuTENSOR 的其他运行时检查可能用于不支持的组合。 除了初始化和设置 cuTENSOR 描述符外，Fortran 对 Matmul 的支持还映射到 cutensorContraction()。

! Example to multiply two matrices together
D = matmul(A, B)
! Same example, accumulate into C
C = C +  matmul(A, B)
! Same example, transpose the first argument
C = C + matmul(transpose(A), B)

在支持 TF32 类型的 GPU 上，为了指示缩并对 real(4) 使用计算类型 CUTENSOR_R_MIN_TF32 而不是 CUTENSOR_R_MIN_32F（或对 complex(4) 类似），我们提供了一种设置内部参数的方法，类似于默认流，我们的运行时将维护该参数。 默认优化级别为 0。 将优化级别设置为大于 0 将使用 CUTENSOR_R_MIN_TF32。

integer function cutensorExSetOptLevel(level)
integer(4) :: level

7.5.6. Fortran Dot_Product 操作

点积是张量缩并的另一个实例。 在此实现中，我们添加了一个新的 dim 参数，使 dot_product 更普遍地适用于高阶数组。 它与上一节中的 matmul 功能非常相似。 dot_product 的两个操作数中的任何一个都可以是置换数组，reshape()、transpose() 或 spread() 调用的结果。 请注意，只有 reshape() 可以生成一维数组。 其他调用可以与 dim 参数一起使用。 cuTENSOR 库当前不支持将元素函数应用于数组操作数，但可以缩放结果和累加器。 以下是一些支持的形式

X = dot_product(A, B)

X = dot_product(reshape(A,shape=[n]), B)

X = dot_product((A, reshape(B,shape=[n]))

D = dot_product(permute(A), permute(B),dim=i)

D = C + dot_product(A, B, dim=i)

D = C - dot_product(A, B, dim=i)

D = C + alpha * dot_product(A, B, dim=i)

数组 A、B、C 和 D 以及标量 X 的类型可以是 real(2)、real(4)、real(8)、complex(4) 或 complex(8)。 数组 C 和 D 目前必须具有相同的形状、步幅和类型。 对于使用 dim 参数的情况，D 和 C 的秩比 A 和 B 小 1。 alpha 值应与 A 和 B 的类型相同。 Fortran 包装器不进行类型转换，但 cuTENSOR 可能会进行类型转换。 对数组一致性的编译时检查是有限的。 来自 Fortran 包装器或 cuTENSOR 的其他运行时检查可能用于不支持的组合。 除了初始化和设置 cuTENSOR 描述符外，Fortran 对 Dot_Product 的支持还映射到 cutensorContraction()。

7.5.7. 支持的逐元素函数

从上面列出的 cuTENSOR 定义支持的逐元素函数列表中，高级接口支持其中几个函数。 cuTENSOR 库当前不支持为复杂数据列出的许多函数；有关最新信息，请查阅 cuTENSOR 文档。 以下是至少具有一定程度 Fortran 接口支持的函数

SQRT RELU CONJG RCP SIGMOID

TANH EXP LOG ABS NEG

SIN COS TAN SINH COSH

ASIN ACOS ATAN ASINH ACOSH

ATANH CEIL FLOOR

请注意，C 语言的复共轭函数 conj 在 Fortran 中拼写为 conjg。此外，C 语言和 Fortran 语言中 ceil 和 floor 函数的返回值类型有所不同。我们保留了 C 语言的拼写和行为（返回实数，而不是整数）。

在当前的实现中，只有 ABS、 CEIL、 CONJG、 COS、 SIN 可以用于裸数组。所有函数都可以应用于置换的结果。使用 reshape(A, shape=shape(A)) 作为一个空操作 (NOP)，将裸数组转换为当前可以识别的形式。

用户会发现，二元或三元内核的性能，例如

D = sin(A) + cos(B) + C

将不如为该特定操作编写和编译的内核（使用 CUDA、CUDA Fortran 或 OpenACC）的性能好，这是因为将函数通用地应用于操作数时，cuTENSOR 内核存在开销。如果操作置换操作数，例如

D = sin(permute(A)) + cos(permute(B)) + C

用户可能会看到与其他朴素实现相比良好的性能，这取决于输入数组上的置换有多复杂。

8. NVIDIA 集体通信库 (NCCL) API

本节介绍 NCCL 库的 Fortran 接口。NCCL 函数只能从主机代码访问。大多数运行时 API 例程，除了一些实用程序外，都是返回错误代码的函数；如果调用成功，它们返回 ncclSuccess 值，如果出现错误，则返回另一个值。与早期的 Fortran 模块不同，我们为返回值创建了一个 ncclResult 派生类型。我们还为测试返回状态重载了 .eq. 和 .ne. 逻辑运算符。

通过添加以下行，可以在主机代码中公开本章中描述的 NCCL 接口和定义

use nccl

到您的程序单元。

除非提供了特定的 kind，否则接口中使用的普通 integer 类型表示 integer(4)，而普通 real 类型表示 real(4)。

8.1. NCCL 定义和辅助函数

本节包含 NCCL 库中使用的定义和数据类型，以及 NCCL 通信器创建和管理函数的接口。

Fortran NCCL 模块包含以下派生类型定义

! Definitions from nccl.h
integer, parameter :: NCCL_MAJOR = 2
integer, parameter :: NCCL_MINOR = 19
integer, parameter :: NCCL_PATCH = 3
integer, parameter :: NCCL_VERSION = &
    (NCCL_MAJOR * 10000 + NCCL_MINOR * 100 + NCCL_PATCH)

integer, parameter :: NCCL_SPLIT_NOCOLOR = -1

! Types from nccl.h
! ncclUniqueId
type, bind(c) :: ncclUniqueId
  character(c_char) :: internal(NCCL_UNIQUE_ID_BYTES)
end type ncclUniqueId

! ncclComm
type, bind(c) :: ncclComm
  type(c_ptr) :: member
end type ncclComm

! ncclResult
type, bind(c) :: ncclResult
  integer(c_int) :: member
end type ncclResult

type(ncclResult), parameter :: &
    ncclSuccess             = ncclResult(0), &
    ncclUnhandledCudaError  = ncclResult(1), &
    ncclSystemError         = ncclResult(2), &
    ncclInternalError       = ncclResult(3), &
    ncclInvalidArgument     = ncclResult(4), &
    ncclInvalidUsage        = ncclResult(5), &
    ncclRemoteError         = ncclResult(6), &
    ncclInProgress          = ncclResult(7), &
    ncclNumResults          = ncclResult(8)

! ncclDataType
type, bind(c) :: ncclDataType
  integer(c_int) :: member
end type ncclDataType

type(ncclDataType), parameter :: &
    ncclInt8     = ncclDataType(0), &
    ncclChar     = ncclDataType(0), &
    ncclUint8    = ncclDataType(1), &
    ncclInt32    = ncclDataType(2), &
    ncclInt      = ncclDataType(2), &
    ncclUint32   = ncclDataType(3), &
    ncclInt64    = ncclDataType(4), &
    ncclUint64   = ncclDataType(5), &
    ncclFloat16  = ncclDataType(6), &
    ncclHalf     = ncclDataType(6), &
    ncclFloat32  = ncclDataType(7), &
    ncclFloat    = ncclDataType(7), &
    ncclFloat64  = ncclDataType(8), &
    ncclDouble   = ncclDataType(8), &
    ncclNumTypes = ncclDataType(9)

! ncclRedOp
type, bind(c) :: ncclRedOp
  integer(c_int) :: member
end type ncclRedOp

type(ncclRedOp), parameter :: &
    ncclSum    = ncclRedOp(0), &
    ncclProd   = ncclRedOp(1), &
    ncclMax    = ncclRedOp(2), &
    ncclMin    = ncclRedOp(3), &
    ncclAvg    = ncclRedOp(4), &
    ncclNumOps = ncclRedOp(5)

! ncclConfig
type, bind(c) :: ncclConfig
  integer(c_size_t) :: size = 48
  integer(c_int) :: magic = z'cafebeef'
  integer(c_int) :: version = NCCL_VERSION
  integer(c_int) :: blocking = z'80000000'
  integer(c_int) :: cgaClusterSize = z'80000000'
  integer(c_int) :: minCTAs = z'80000000'
  integer(c_int) :: maxCTAs = z'80000000'
  type(c_ptr)    :: netName = c_null_ptr
  integer(c_int) :: splitShare = z'80000000'
end type ncclConfig

8.1.1. ncclGetVersion

此函数返回 NCCL 库的版本号。

type(ncclResult) function ncclGetVersion(version)
integer(4) :: version

8.1.2. ncclGetUniqueId

此函数生成一个 ID，用于 ncclCommInitRank。此例程应调用一次，生成的 ID 应分发给所有 rank。

type(ncclResult) function ncclGetUniqueId(uniqueId)
type(ncclUniqueId) :: uniqueId

8.1.3. ncclCommInitRank

此函数生成一个新的 NCCL 通信器，类型为 type(ncclCom)。rank 参数必须介于 0 和 nranks-1 之间。uniqueId 参数应使用 ncclGetUniqueId 生成。

type(ncclResult) function ncclCommInitRank(comm, nranks, uniqueId, rank)
type(ncclComm) :: comm
integer(4) :: nranks
type(ncclUniqueId) :: uniqueId
integer(4) :: rank

8.1.4. ncclCommInitRankConfig

此函数使用配置参数生成一个新的 NCCL 通信器，类型为 type(ncclCom)。rank 参数必须介于 0 和 nranks-1 之间。uniqueId 参数应使用 ncclGetUniqueId 生成。此接口的一个变体将接受 c_null_ptr 作为最后一个参数。

type(ncclResult) function ncclCommInitRankConfig(comm, nranks, &
        commId, rank, config)
type(ncclComm) :: comm
integer(4) :: nranks
type(ncclUniqueId) :: commId
integer(4) :: rank
type(ncclConfig) :: config

8.1.5. ncclCommInitAll

此函数创建一个单进程通信器 clique，类型为 type(ncclCom) 的数组。

type(ncclResult) function ncclCommInitAll(comms, ndev, devlist)
type(ncclComm) :: comms(*)
integer(4) :: ndev
integer(4) :: devlist(*)

8.1.6. ncclCommDestroy

此函数释放分配给 NCCL 通信器的资源。它将等待未完成的操作。

type(ncclResult) function ncclCommDestroy(comm)
type(ncclComm) :: comm

8.1.7. ncclCommFinalize

此函数最终确定 NCCL 通信器对象。

type(ncclResult) function ncclCommFinalize(comm)
type(ncclComm) :: comm

8.1.8. ncclCommSplit

此函数从现有的 NCCL 通信器创建一个新的 NCCL 通信器，类型为 type(ncclCom)，基于输入的 color 和 key。此接口的一个变体将接受 c_null_ptr 作为最后一个参数。

type(ncclResult) function ncclCommSplit(comm, color, &
        key, newcomm, config)
type(ncclComm) :: comm
integer(4) :: color, key
type(ncclComm) :: newcomm
type(ncclConfig) :: config

8.1.9. ncclCommAbort

此函数释放分配给 NCCL 通信器的资源。它将中止未完成的操作。

type(ncclResult) function ncclCommAbort(comm)
type(ncclComm) :: comm

8.1.10. ncclCommRegister

此函数注册一个 CUDA 缓冲区，使其可用于零拷贝操作。缓冲区可以是任何类型。

type(ncclResult) function ncclCommRegister(comm, buff, size, handle)
type(ncclComm) :: comm
real(4), device :: buff(*)  ! Any type of device array
integer(8)      :: size
type(c_ptr), intent(out) :: handle

8.1.11. ncclCommDeregister

此函数注销用于零拷贝操作的 CUDA 缓冲区。

type(ncclResult) function ncclCommDeregister(comm, handle)
type(ncclComm) :: comm
type(c_ptr), intent(in) :: handle

8.1.12. ncclGetErrorString

此函数为给定的 ncclResult 值返回一个错误字符串。

character*128 function ncclGetErrorString(ierr)
type(ncclResult) :: ierr

8.1.13. ncclGetLastError

此函数返回最近发生的错误的字符串。

character*128 function ncclGetLastError(comm)
type(ncclComm) :: comm

8.1.14. ncclCommGetAsyncError

此函数查询通信器是否遇到任何异步错误。

type(ncclResult) function ncclCommGetAsyncError(comm, asyncError)
type(ncclComm) :: comm
type(ncclResult) :: asyncError

8.1.15. ncclCommCount

此函数将 count 参数设置为 NCCL 通信器中 rank 的数量。

type(ncclResult) function ncclCommCount(comm, count)
type(ncclComm) :: comm
integer(4) :: count

8.1.16. ncclCommCuDevice

此函数将 device 参数设置为与 NCCL 通信器关联的 CUDA 设备。

type(ncclResult) function ncclCommCuDevice(comm, device)
type(ncclComm) :: comm
integer(4) :: device

8.1.17. ncclCommUserRank

此函数将 rank 参数设置为 NCCL 通信器内的 rank。

type(ncclResult) function ncclCommUserRank(comm, rank)
type(ncclComm) :: comm
integer(4) :: rank

8.2. NCCL 集体通信函数

本节包含用于在设备数据上执行集体通信操作的 NCCL 函数的接口。所有函数都可以接受 CUDA Fortran 设备数组、host_data use_device 数据指令中的 OpenACC 数组或 Fortran type(c_devptr) 参数。

8.2.1. ncclAllReduce

此函数对跨设备的数据执行指定的归约操作，并将结果写入每个 rank 的接收缓冲区。

type(ncclResult) function ncclAllReduce(sendbuff, recvbuff, &
    count, datatype, op, comm, stream)
type(c_devptr) :: sendbuff, recvbuff
  ! These combinations of sendbuff, recvbuff are also accepted:
  ! integer(4), device :: sendbuff(*), recvbuff(*)
  ! integer(8), device :: sendbuff(*), recvbuff(*)
  ! real(2), device :: sendbuff(*), recvbuff(*)
  ! real(4), device :: sendbuff(*), recvbuff(*)
  ! real(8), device :: sendbuff(*), recvbuff(*)
integer(cuda_count_kind) :: count
type(ncclDataType) :: datatype
type(ncclRedOp) :: op
type(ncclComm) :: comm
integer(cuda_stream_kind) :: stream

8.2.2. ncclBroadcast

此函数将根 rank 上的发送缓冲区复制到 NCCL 通信器中的所有其他 rank。如果 sendbuff 和 recvbuff 是相同的地址，则会发生就地操作。

type(ncclResult) function ncclBroadcast(sendbuff, recvbuff, &
    count, datatype, root, comm, stream)
type(c_devptr) :: sendbuff, recvbuff
  ! These combinations of sendbuff, recvbuff are also accepted:
  ! integer(4), device :: sendbuff(*), recvbuff(*)
  ! integer(8), device :: sendbuff(*), recvbuff(*)
  ! real(2), device :: sendbuff(*), recvbuff(*)
  ! real(4), device :: sendbuff(*), recvbuff(*)
  ! real(8), device :: sendbuff(*), recvbuff(*)
integer(cuda_count_kind) :: count
type(ncclDataType) :: datatype
integer(4) :: root
type(ncclComm) :: comm
integer(cuda_stream_kind) :: stream

8.2.3. ncclReduce

此函数执行与 AllReduce 相同的操作，但仅将结果写入指定根 rank 的接收缓冲区。

type(ncclResult) function ncclReduce(sendbuff, recvbuff, &
    count, datatype, op, root, comm, stream)
type(c_devptr) :: sendbuff, recvbuff
  ! These combinations of sendbuff, recvbuff are also accepted:
  ! integer(4), device :: sendbuff(*), recvbuff(*)
  ! integer(8), device :: sendbuff(*), recvbuff(*)
  ! real(2), device :: sendbuff(*), recvbuff(*)
  ! real(4), device :: sendbuff(*), recvbuff(*)
  ! real(8), device :: sendbuff(*), recvbuff(*)
integer(cuda_count_kind) :: count
type(ncclDataType) :: datatype
type(ncclRedOp) :: op
integer(4) :: root
type(ncclComm) :: comm
integer(cuda_stream_kind) :: stream

8.2.4. ncclAllGather

此函数收集来自每个 rank 的发送缓冲区，并将它们按 rank 顺序存储在所有 rank 的接收缓冲区中。

type(ncclResult) function ncclAllGather(sendbuff, recvbuff, &
    sendcount, datatype, comm, stream)
type(c_devptr) :: sendbuff, recvbuff
  ! These combinations of sendbuff, recvbuff are also accepted:
  ! integer(4), device :: sendbuff(*), recvbuff(*)
  ! integer(8), device :: sendbuff(*), recvbuff(*)
  ! real(2), device :: sendbuff(*), recvbuff(*)
  ! real(4), device :: sendbuff(*), recvbuff(*)
  ! real(8), device :: sendbuff(*), recvbuff(*)
integer(cuda_count_kind) :: sendcount
type(ncclDataType) :: datatype
type(ncclComm) :: comm
integer(cuda_stream_kind) :: stream

8.2.5. ncclReduceScatter

此函数对数据执行指定的归约操作，并根据 rank 索引将结果分散在 rank 之间的相等块中。

type(ncclResult) function ncclReduceScatter(sendbuff, recvbuff, &
    recvcount, datatype, op, comm, stream)
type(c_devptr) :: sendbuff, recvbuff
  ! These combinations of sendbuff, recvbuff are also accepted:
  ! integer(4), device :: sendbuff(*), recvbuff(*)
  ! integer(8), device :: sendbuff(*), recvbuff(*)
  ! real(2), device :: sendbuff(*), recvbuff(*)
  ! real(4), device :: sendbuff(*), recvbuff(*)
  ! real(8), device :: sendbuff(*), recvbuff(*)
integer(cuda_count_kind) :: recvcount
type(ncclDataType) :: datatype
type(ncclRedOp) :: op
type(ncclComm) :: comm
integer(cuda_stream_kind) :: stream

8.3. NCCL 点对点通信函数

本节包含用于在设备数据上执行点对点通信操作的 NCCL 函数的接口。所有函数都可以接受 CUDA Fortran 设备数组、host_data use_device 数据指令中的 OpenACC 数组或 Fortran type(c_devptr) 参数。点对点操作在 NCCL 2.7 中添加。

8.3.1. ncclSend

此函数将数据从发送缓冲区发送到通信器对等方。此操作会阻塞 GPU。接收对等方必须使用相同的数据类型和计数调用 ncclRecv。

type(ncclResult) function ncclSend(sendbuff, &
    count, datatype, peer, comm, stream)
type(c_devptr) :: sendbuff
  ! These types for sendbuff are also accepted:
  ! integer(4), device :: sendbuff(*)
  ! integer(8), device :: sendbuff(*)
  ! real(2), device :: sendbuff(*)
  ! real(4), device :: sendbuff(*)
  ! real(8), device :: sendbuff(*)
integer(cuda_count_kind) :: count
type(ncclDataType) :: datatype
integer(4) :: peer
type(ncclComm) :: comm
integer(cuda_stream_kind) :: stream

8.3.2. ncclRecv

此函数从通信器对等方接收数据。此操作会阻塞 GPU。发送对等方必须使用相同的数据类型和计数调用 ncclSend。

type(ncclResult) function ncclRecv(recvbuff, &
    count, datatype, peer, comm, stream)
type(c_devptr) :: recvbuff
  ! These types for recvbuff are also accepted:
  ! integer(4), device :: recvbuff(*)
  ! integer(8), device :: recvbuff(*)
  ! real(2), device :: recvbuff(*)
  ! real(4), device :: recvbuff(*)
  ! real(8), device :: recvbuff(*)
integer(cuda_count_kind) :: count
type(ncclDataType) :: datatype
integer(4) :: peer
type(ncclComm) :: comm
integer(cuda_stream_kind) :: stream

8.4. NCCL 组调用

本节包含用于开始和结束组的 NCCL 函数的接口，以便可以合并多个调用。

8.4.1. ncclGroupStart

此函数启动组调用。由于 CPU 间同步，后续对 NCCL 函数的所有调用都可能不会阻塞。

type(ncclResult) function ncclGroupStart()

8.4.2. ncclGroupEnd

此函数结束组调用。当自相应的 ncclGroupStart 调用以来的所有操作都已处理（但不一定完成）时，它会返回。

type(ncclResult) function ncclGroupEnd()

9. NVSHMEM 通信库 API

本节介绍 NVSHMEM 库的 Fortran 接口。NVSHMEM 是一个软件库，它为 NVIDIA GPU 集群实现了 OpenSHMEM 应用程序编程接口 (API)。OpenSHMEM 是一个社区标准、单边通信 API，它提供了一个分区全局地址空间 (PGAS) 并行编程模型。NVSHMEM 为分配对称内存提供了一个易于使用的主机端接口，该对称内存可以分布在通过 NVLink、PCIe 和 InfiniBand 互连的 NVIDIA GPU 集群中。NVSHMEM 通信函数可以从主机和设备代码访问。大多数运行时 API 例程都编写为 C void 函数，我们已将其 Fortran 包装器实现为子例程。

通过添加以下行，可以公开本章中描述的 NVSHMEM 接口和定义

use nvshmem

到您的程序单元。相同的模块用于主机和设备代码。在线程块或 warp 上运行的设备函数声明为 acc vector nohost 例程。其他的是 acc seq 例程。

除非提供了特定的 kind，否则接口中使用的普通 integer 类型表示 integer(4)，而普通 real 类型表示 real(4)。

9.1. NVSHMEM 定义、设置、退出和查询函数

本节包含 NVSHMEM 库中使用的定义和数据类型，以及 NVSHMEM 初始化和访问 PE 并行环境的接口。

Fortran NVSHMEM 模块包含以下常量和派生类型定义

! These are not available to the user, internal only
! defines, from nvshmemx_api.h
#define INIT_HANDLE_BYTES 128

! defines, from nvshmem_constants.h
#define SYNC_SIZE 27648

! Constant Definitions
integer, parameter :: NVSHMEM_SYNC_VALUE = 0
integer, parameter :: NVSHMEM_SYNC_SIZE = (2 * SYNC_SIZE)
integer, parameter :: NVSHMEM_BARRIER_SYNC_SIZE = (2 * SYNC_SIZE)
integer, parameter :: NVSHMEM_BCAST_SYNC_SIZE = SYNC_SIZE
integer, parameter :: NVSHMEM_REDUCE_SYNC_SIZE = SYNC_SIZE
integer, parameter :: NVSHMEM_REDUCE_MIN_WRKDATA_SIZE = SYNC_SIZE
integer, parameter :: NVSHMEM_COLLECT_SYNC_SIZE = SYNC_SIZE
integer, parameter :: NVSHMEM_ALLTOALL_SYNC_SIZE = SYNC_SIZE

integer, parameter :: NVSHMEMX_CMP_EQ = 0
integer, parameter :: NVSHMEMX_CMP_NE = 1
integer, parameter :: NVSHMEMX_CMP_GT = 2
integer, parameter :: NVSHMEMX_CMP_LE = 3
integer, parameter :: NVSHMEMX_CMP_LT = 4
integer, parameter :: NVSHMEMX_CMP_GE = 5

integer, parameter :: NVSHMEMX_THREAD_SINGLE     = 0
integer, parameter :: NVSHMEMX_THREAD_FUNNELED   = 1
integer, parameter :: NVSHMEMX_THREAD_SERIALIZED = 2
integer, parameter :: NVSHMEMX_THREAD_MULTIPLE   = 3

integer, parameter :: NVSHMEM_TEAM_INVALID = -1
integer, parameter :: NVSHMEM_TEAM_WORLD   = 0
integer, parameter :: NVSHMEM_TEAM_SHARED  = 1
integer, parameter :: NVSHMEMX_TEAM_NODE   = 2

integer, parameter :: NVSHMEMX_INIT_THREAD_PES    = 1
integer, parameter :: NVSHMEMX_INIT_WITH_MPI_COMM = 2
integer, parameter :: NVSHMEMX_INIT_WITH_SHMEM    = 4
integer, parameter :: NVSHMEMX_INIT_WITH_HANDLE   = 8

! Types from nvshmemx_api.h
type, bind(c) :: nvshmemx_init_handle
  character(c_char) :: content(INIT_HANDLE_BYTES)
end type nvshmemx_init_handle

! Types from nvshmemx_api.h
type, bind(c) :: nvshmemx_init_attr_type
  integer(8)  heap_size
  integer(4)  num_threads
  integer(4)  n_pes
  integer(4)  my_pe
  type(c_ptr) mpi_comm
  type(nvshmemx_init_handle) handle
end type nvshmemx_init_attr_type

! Types from nvshmem_types.h
type, bind(c) :: nvshmem_team_config
  integer(c_int) :: num_contexts
end type nvshmem_team_config

! nvshmemx_status, from nvshmem_error.h
type, bind(c) :: nvshmemx_status
  integer(c_int) :: member
end type nvshmemx_status

type(nvshmemx_status), parameter :: &
  NVSHMEMX_SUCCESS = nvshmemx_status(0), &
  NVSHMEMX_ERROR_INVALID_VALUE = nvshmemx_status(1), &
  NVSHMEMX_ERROR_OUT_OF_MEMORY = nvshmemx_status(2), &
  NVSHMEMX_ERROR_NOT_SUPPORTED = nvshmemx_status(3), &
  NVSHMEMX_ERROR_SYMMETRY = nvshmemx_status(4), &
  NVSHMEMX_ERROR_GPU_NOT_SELECTED = nvshmemx_status(5), &
  NVSHMEMX_ERROR_COLLECTIVE_LAUNCH_FAILED = nvshmemx_status(6), &
  NVSHMEMX_ERROR_INTERNAL = nvshmemx_status(7)

9.1.1. nvshmem_init

此子例程分配和初始化 NVSHMEM 库使用的资源。

subroutine nvshmem_init()

9.1.2. nvshmemx_init_attr

此函数基于现有的 MPI 通信器初始化 NVSHMEM 库。由于 C 和 Fortran mpi_comm 对象不同，因此此函数具有与相应的 C 库入口点不同的参数列表。

type(nvshmemx_status) function nvshmemx_init_attr(flags, comm)
    integer(4) :: flags, comm

以下是使用 MPI 的此函数的示例

use nvshmem
type(nvshmemx_status) :: nvstat
. . .
! Setup MPI
call MPI_Init(ierror)
call MPI_Comm_rank(MPI_COMM_WORLD, my_rank, ierror)
call MPI_Comm_size(MPI_COMM_WORLD, nranks, ierror)
!
nvstat = nvshmemx_init_attr(NVSHMEMX_INIT_WITH_MPI_COMM, MPI_COMM_WORLD)

9.1.3. nvshmem_my_pe

此函数返回调用 PE 的 PE 编号，编号介于 0 和 npes-1 之间。

integer(4) function nvshmem_my_pe()

9.1.4. nvshmem_n_pes

此函数返回程序中运行的 PE 数量。

integer(4) function nvshmem_n_pes()

9.1.5. nvshmem_team_my_pe

此函数返回调用 PE 在指定 team 中的 PE 编号。

integer(4) function nvshmem_team_my_pe(team)
    integer(4) :: team

9.1.6. nvshmem_team_n_pes

此函数返回指定 team 中的 PE 数量。

integer(4) function nvshmem_team_n_pes(team)
    integer(4) :: team

9.1.7. nvshmem_team_get_config

此函数返回配置参数，如 config 参数中的掩码所述。

integer(4) function nvshmem_team_get_config(team, mask, config)
    integer(4) :: team
    integer(8) :: mask
    type(nvshmem_team_config) :: config

9.1.8. nvshmem_team_translate_pe

给定源 team、源 pe 和目标 team，此函数返回转换后的目标 pe。

integer(4) function nvshmem_team_translate_pe(src_team, src_pe, dest_team)
    integer(4) :: src_team, src_pe, dest_team

9.1.9. nvshmem_team_split_strided

此函数执行集体操作，并根据父 team 和父 team 中所需的切片（start、stride 和 size）创建一个新 team。

integer(4) function nvshmem_team_split_strided(parent_team, &
        start, stride, size, config, mask, new_team)
    integer(4) :: parent_team
    integer(4) :: start, stride, size
    type(nvshmem_team_config) :: config
    integer(8) :: mask
    integer(4) :: new_team

9.1.10. nvshmem_team_split_2d

此函数执行集体操作，并根据父 team 和 2D 空间的规范创建两个新 team。结果是两个 team，其中包含映射到 2D 空间的行和列的 PE。

integer(4) function nvshmem_team_split_2d(parent_team, &
        xrange, xaxis_config, xaxis_mask, xaxis_team, &
        yaxis_config, yaxis_mask, yaxis_team)
    integer(4) :: parent_team
    integer(4) :: xrange
    type(nvshmem_team_config) :: xaxis_config, yaxis_config
    integer(8) :: xaxis_mask, yaxis_mask
    integer(4), intent(out) :: xaxis_team, yaxis_team

9.1.11. nvshmem_team_destroy

此函数是一个集体操作，它销毁 team 并释放与其关联的资源。

integer(4) function nvshmem_team_destroy(team)
    integer(4) :: team

9.1.12. nvshmem_info_get_version

此子例程返回 NVSHMEM 库的主版本号和次版本号。

subroutine nvshmem_info_get_version(major, minor)
    integer(4) :: major, minor

9.1.13. nvshmem_info_get_name

此子例程返回库的供应商定义的名称字符串。

subroutine nvshmem_info_get_name(name)
    character*256, intent(out) :: name

9.1.14. nvshmem_finalize

此子例程释放资源并结束使用 nvshmem_init() 启动的程序的 NVSHMEM 部分。

subroutine nvshmem_finalize()

9.1.15. nvshmem_ptr

此函数返回一个本地地址，该地址可用于直接引用指定 PE 上的目标数据。函数 nvshmem_ptr 实现为 Fortran 泛型函数，可以接受任何数据类型，只要它是对称地址即可。

type(c_devptr) function nvshmem_ptr(dest, pe)
    ! dest can be of type integer, logical, real, complex, character,
    ! or a type(c_devptr)
    integer(4) :: pe

还支持以下特定函数

type(c_devptr) function nvshmem_ptri(dest, pe)
    integer :: dest ! Any kind and rank
    integer(4) :: pe

type(c_devptr) function nvshmem_ptrl(dest, pe)
    logical :: dest ! Any kind and rank
    integer(4) :: pe

type(c_devptr) function nvshmem_ptrr(dest, pe)
    real :: dest ! Any kind and rank
    integer(4) :: pe

type(c_devptr) function nvshmem_ptrc(dest, pe)
    complex :: dest ! Any kind and rank
    integer(4) :: pe

type(c_devptr) function nvshmem_ptrc1(dest, pe)
    character :: dest ! Any kind and rank
    integer(4) :: pe

type(c_devptr) function nvshmem_ptrcd(dest, pe)
    type(c_devptr) :: dest
    integer(4) :: pe

9.2. NVSHMEM 内存管理函数

本节包含用于管理对称堆的 NVSHMEM 函数的 Fortran 接口。

9.2.1. nvshmem_malloc

此函数从对称堆分配一个包含指定字节数的块。此例程是一个集体操作，需要所有 PE 的参与。

type(c_devptr) function nvshmem_malloc(size)
    integer(8) :: size  ! Size is in bytes

type(c_devptr) 类型的实体可以通过几种方式转换为 Fortran 数组。以下是一些示例

use nvshmem
! Contiguous will avoid some runtime checks
real(8), device, pointer, contiguous :: array(:)
. . .
call c_f_pointer(nvshmem_malloc(N*8), array, [N])

use nvshmem
! Cray Pointer
real(8), device :: array(N); pointer(pa,array)
. . .
pa = transfer(nvshmem_malloc(N*8), pa)

9.2.2. nvshmem_free

此子例程释放先前分配的对称数据块。

subroutine nvshmem_free(ptr)
    ! ptr can be of type(c_devptr), or other types if it was cast to a Fortran
    ! array using the techniques described in the nvshmem_malloc section.

9.2.3. nvshmem_align

此函数从对称堆分配一个块，该块具有由 alignment 参数指定的字节对齐方式。

type(c_devptr) function nvshmem_align(alignment, size)
    integer(8) :: alignment
    integer(8) :: size  ! Size is in bytes

9.2.4. nvshmem_calloc

此函数从对称堆分配一个包含指定字节数的块。此例程是一个集体操作，需要所有 PE 的参与。该空间也初始化为零。

type(c_devptr) function nvshmem_calloc(size)
    integer(8) :: size  ! Size is in bytes

9.2.5. nvshmemx_buffer_register

此函数向远程传输和 CUDA 注册给定的缓冲区，以便进行后续的 nvshmem 操作。作为第一个参数传递的地址可以是任何类型，具有主机或设备属性。

integer(4) function nvshmemx_buffer_register(addr, len)
    real(4) :: addr(*)  ! Any type is accepted
    integer(8) :: len   ! Size is in bytes

9.2.6. nvshmemx_buffer_unregister

此函数注销先前使用 nvshmemx_buffer_register 库函数注册的缓冲区。

integer(4) function nvshmemx_buffer_unregister(addr)
    real(4) :: addr(*)  ! Any type is accepted

9.2.7. nvshmemx_buffer_unregister_all

此子例程注销先前使用 nvshmemx_buffer_register 库函数注册的所有缓冲区。

subroutine nvshmemx_buffer_unregister_all()

9.3. NVSHMEM 远程内存访问函数

本节包含用于对对称数据对象执行读写操作的 NVSHMEM 函数的 Fortran 接口。CUDA C 库为每种 C 类型包含许多函数。我们已尝试将这些函数提炼成对 Fortran 程序员有用但不冗余的集合。此外，我们还提供了以下泛型接口，这些接口被重载以接受多种类型

• nvshmem_put

• nvshmem_p

• nvshmem_iput

• nvshmem_put_nbi

• nvshmemx_put_block

• nvshmemx_put_warp

• nvshmem_get

• nvshmem_g

• nvshmem_iget

• nvshmem_get_nbi

• nvshmemx_get_block

• nvshmemx_get_warp

这些函数中的许多函数在主机和设备上都可用。某些编程模型可能目前不支持设备上的泛型函数。某些函数仅在设备上可用（最值得注意的是，由整个块或整个 warp 执行的函数）。

9.3.1. nvshmem_put

此子例程在数据已从本地 PE 上的源数组复制出来后返回。子例程 nvshmem_put 被重载以接受许多不同的参数集。具体的名称和参数列表如下。

subroutine nvshmem_putmem(dest, source, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_putmem_on_stream(dest, source, nelems, pe, stream)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_int8_put(dest, source, nelems, pe)
    integer(1), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_int8_put_on_stream(dest, source, nelems, pe, stream)
    integer(1), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_int16_put(dest, source, nelems, pe)
    integer(2), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_int16_put_on_stream(dest, source, nelems, pe, stream)
    integer(2), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_int32_put(dest, source, nelems, pe)
    integer(4), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_int32_put_on_stream(dest, source, nelems, pe, stream)
    integer(4), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_int64_put(dest, source, nelems, pe)
    integer(8), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_int64_put_on_stream(dest, source, nelems, pe, stream)
    integer(8), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_float_put(dest, source, nelems, pe)
    real(4), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_float_put_on_stream(dest, source, nelems, pe, stream)
    real(4), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_double_put(dest, source, nelems, pe)
    real(8), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_double_put_on_stream(dest, source, nelems, pe, stream)
    real(8), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_complex_put(dest, source, nelems, pe)
    complex(4), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_complex_put_on_stream(dest, source, nelems, pe, stream)
    complex(4), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_dcomplex_put(dest, source, nelems, pe)
    complex(8), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_dcomplex_put_on_stream(dest, source, nelems, pe, stream)
    complex(8), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

以下 nvshmem put 子例程不是泛型 nvshmem_put 组的一部分，但为了灵活性和与 C 名称的兼容性而提供

subroutine nvshmem_put8(dest, source, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_put8_on_stream(dest, source, nelems, pe, stream)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_put16(dest, source, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_put16_on_stream(dest, source, nelems, pe, stream)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_put32(dest, source, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_put32_on_stream(dest, source, nelems, pe, stream)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_put64(dest, source, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_put64_on_stream(dest, source, nelems, pe, stream)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_put128(dest, source, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_put128_on_stream(dest, source, nelems, pe, stream)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

9.3.2. nvshmem_p

此子例程在数据已从本地 PE 上的源数组复制出来后返回。子例程 nvshmem_p 被重载以接受许多不同的参数集。这些子例程可以从主机或设备调用，并且源通过值传递，并且应分别是驻留在主机或设备上的。具体的名称和参数列表如下。

subroutine nvshmem_int8_p(dest, source, nelems, pe)
    integer(1), device :: dest(*), source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_int8_p_on_stream(dest, source, nelems, pe, stream)
    integer(1), device :: dest(*), source
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_int16_p(dest, source, nelems, pe)
    integer(2), device :: dest(*), source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_int16_p_on_stream(dest, source, nelems, pe, stream)
    integer(2), device :: dest(*), source
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_int32_p(dest, source, nelems, pe)
    integer(4), device :: dest(*), source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_int32_p_on_stream(dest, source, nelems, pe, stream)
    integer(4), device :: dest(*), source
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_int64_p(dest, source, nelems, pe)
    integer(8), device :: dest(*), source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_int64_p_on_stream(dest, source, nelems, pe, stream)
    integer(8), device :: dest(*), source
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_float_p(dest, source, nelems, pe)
    real(4), device :: dest(*), source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_float_p_on_stream(dest, source, nelems, pe, stream)
    real(4), device :: dest(*), source
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_double_p(dest, source, nelems, pe)
    real(8), device :: dest(*), source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_double_p_on_stream(dest, source, nelems, pe, stream)
    real(8), device :: dest(*), source
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

9.3.3. nvshmem_iput

此子例程提供了一种将步幅数据元素复制到目标的方法。此子例程在数据已从本地 PE 上的源数组复制出来后返回。子例程 nvshmem_iput 被重载以接受许多不同的参数集。这些子例程可以从主机或设备调用。具体的名称和参数列表如下。

subroutine nvshmem_int8_iput(dest, source, dst, sst, nelems, pe)
    integer(1), device :: dest(*), source(*)
    integer(8) :: dst, sst, nelems
    integer(4) :: pe

subroutine nvshmemx_int8_iput_on_stream(dest, source, dst, sst, nelems, pe, stream)
    integer(1), device :: dest(*), source(*)
    integer(8) :: dst, sst, nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_int16_iput(dest, source, dst, sst, nelems, pe)
    integer(2), device :: dest(*), source(*)
    integer(8) :: dst, sst, nelems
    integer(4) :: pe

subroutine nvshmemx_int16_iput_on_stream(dest, source, dst, sst, nelems, pe, stream)
    integer(2), device :: dest(*), source(*)
    integer(8) :: dst, sst, nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_int32_iput(dest, source, dst, sst, nelems, pe)
    integer(4), device :: dest(*), source(*)
    integer(8) :: dst, sst, nelems
    integer(4) :: pe

subroutine nvshmemx_int32_iput_on_stream(dest, source, dst, sst, nelems, pe, stream)
    integer(4), device :: dest(*), source(*)
    integer(8) :: dst, sst, nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_int64_iput(dest, source, dst, sst, nelems, pe)
    integer(8), device :: dest(*), source(*)
    integer(8) :: dst, sst, nelems
    integer(4) :: pe

subroutine nvshmemx_int64_iput_on_stream(dest, source, dst, sst, nelems, pe, stream)
    integer(8), device :: dest(*), source(*)
    integer(8) :: dst, sst, nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_float_iput(dest, source, dst, sst, nelems, pe)
    real(4), device :: dest(*), source(*)
    integer(8) :: dst, sst, nelems
    integer(4) :: pe

subroutine nvshmemx_float_iput_on_stream(dest, source, dst, sst, nelems, pe, stream)
    real(4), device :: dest(*), source(*)
    integer(8) :: dst, sst, nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_double_iput(dest, source, dst, sst, nelems, pe)
    real(8), device :: dest(*), source(*)
    integer(8) :: dst, sst, nelems
    integer(4) :: pe

subroutine nvshmemx_double_iput_on_stream(dest, source, dst, sst, nelems, pe, stream)
    real(8), device :: dest(*), source(*)
    integer(8) :: dst, sst, nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_complex_iput(dest, source, dst, sst, nelems, pe)
    complex(4), device :: dest(*), source(*)
    integer(8) :: dst, sst, nelems
    integer(4) :: pe

subroutine nvshmemx_complex_iput_on_stream(dest, source, dst, sst, nelems, pe, stream)
    complex(4), device :: dest(*), source(*)
    integer(8) :: dst, sst, nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_dcomplex_iput(dest, source, dst, sst, nelems, pe)
    complex(8), device :: dest(*), source(*)
    integer(8) :: dst, sst, nelems
    integer(4) :: pe

subroutine nvshmemx_dcomplex_iput_on_stream(dest, source, dst, sst, nelems, pe, stream)
    complex(8), device :: dest(*), source(*)
    integer(8) :: dst, sst, nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

以下 nvshmem iput 子例程不是泛型 nvshmem_iput 组的一部分，但为了灵活性和与 C 名称的兼容性而提供

subroutine nvshmem_iput8(dest, source, dst, sst, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: dst, sst, nelems
    integer(4) :: pe

subroutine nvshmemx_iput8_on_stream(dest, source, dst, sst, nelems, pe, stream)
    type(c_devptr) :: dest, source
    integer(8) :: dst, sst, nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_iput16(dest, source, dst, sst, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: dst, sst, nelems
    integer(4) :: pe

subroutine nvshmemx_iput16_on_stream(dest, source, dst, sst, nelems, pe, stream)
    type(c_devptr) :: dest, source
    integer(8) :: dst, sst, nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_iput32(dest, source, dst, sst, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: dst, sst, nelems
    integer(4) :: pe

subroutine nvshmemx_iput32_on_stream(dest, source, dst, sst, nelems, pe, stream)
    type(c_devptr) :: dest, source
    integer(8) :: dst, sst, nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_iput64(dest, source, dst, sst, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: dst, sst, nelems
    integer(4) :: pe

subroutine nvshmemx_iput64_on_stream(dest, source, dst, sst, nelems, pe, stream)
    type(c_devptr) :: dest, source
    integer(8) :: dst, sst, nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_iput128(dest, source, dst, sst, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: dst, sst, nelems
    integer(4) :: pe

subroutine nvshmemx_iput128_on_stream(dest, source, dst, sst, nelems, pe, stream)
    type(c_devptr) :: dest, source
    integer(8) :: dst, sst, nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

9.3.4. nvshmem_put_nbi

此子例程在启动 put 操作后返回。子例程 nvshmem_put_nbi 被重载以接受许多不同的参数集。这些子例程可以从主机或设备调用。具体的名称和参数列表如下。

subroutine nvshmem_int8_put_nbi(dest, source, nelems, pe)
    integer(1), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_int8_put_nbi_on_stream(dest, source, nelems, pe, stream)
    integer(1), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_int16_put_nbi(dest, source, nelems, pe)
    integer(2), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_int16_put_nbi_on_stream(dest, source, nelems, pe, stream)
    integer(2), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_int32_put_nbi(dest, source, nelems, pe)
    integer(4), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_int32_put_nbi_on_stream(dest, source, nelems, pe, stream)
    integer(4), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_int64_put_nbi(dest, source, nelems, pe)
    integer(8), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_int64_put_nbi_on_stream(dest, source, nelems, pe, stream)
    integer(8), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_float_put_nbi(dest, source, nelems, pe)
    real(4), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_float_put_nbi_on_stream(dest, source, nelems, pe, stream)
    real(4), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_double_put_nbi(dest, source, nelems, pe)
    real(8), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_double_put_nbi_on_stream(dest, source, nelems, pe, stream)
    real(8), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_complex_put_nbi(dest, source, nelems, pe)
    complex(4), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_complex_put_nbi_on_stream(dest, source, nelems, pe, stream)
    complex(4), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_dcomplex_put_nbi(dest, source, nelems, pe)
    complex(8), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_dcomplex_put_nbi_on_stream(dest, source, nelems, pe, stream)
    complex(8), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

以下 nvshmem put_nbi 子例程不是泛型 nvshmem_put_nbi 组的一部分，但为了灵活性和与 C 名称的兼容性而提供

subroutine nvshmem_put8_nbi(dest, source, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_put8_nbi_on_stream(dest, source, nelems, pe, stream)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_put16_nbi(dest, source, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_put16_nbi_on_stream(dest, source, nelems, pe, stream)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_put32_nbi(dest, source, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_put32_nbi_on_stream(dest, source, nelems, pe, stream)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_put64_nbi(dest, source, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_put64_nbi_on_stream(dest, source, nelems, pe, stream)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_put128_nbi(dest, source, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_put128_nbi_on_stream(dest, source, nelems, pe, stream)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

9.3.5. nvshmemx_put_block

此子例程在数据已从本地 PE 上的源数组复制出来后返回。它仅在设备代码中可用。子例程 nvshmemx_put_block 被重载以接受许多不同的参数集。具体的名称和参数列表如下。

subroutine nvshmemx_putmem_block(dest, source, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_int8_put_block(dest, source, nelems, pe)
    integer(1), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_int16_put_block(dest, source, nelems, pe)
    integer(2), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_int32_put_block(dest, source, nelems, pe)
    integer(4), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_int64_put_block(dest, source, nelems, pe)
    integer(8), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_fp16_put_block(dest, source, nelems, pe)
    real(2), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_float_put_block(dest, source, nelems, pe)
    real(4), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_double_put_block(dest, source, nelems, pe)
    real(8), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_complex_put_block(dest, source, nelems, pe)
    complex(4), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_dcomplex_put_block(dest, source, nelems, pe)
    complex(8), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

以下 nvshmem put block 子例程不是泛型 nvshmemx_put_block 组的一部分，但为了灵活性和与 C 名称的兼容性而提供

subroutine nvshmemx_int_put_block(dest, source, nelems, pe)
    integer(4), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_long_put_block(dest, source, nelems, pe)
    integer(8), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_put8_block(dest, source, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_put16_block(dest, source, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_put32_block(dest, source, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_put64_block(dest, source, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_put128_block(dest, source, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe

9.3.6. nvshmemx_put_warp

此子例程在数据已从本地 PE 上的源数组复制出来后返回。它仅在设备代码中可用。子例程 nvshmemx_put_warp 被重载以接受许多不同的参数集。具体的名称和参数列表如下。

subroutine nvshmemx_putmem_warp(dest, source, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_int8_put_warp(dest, source, nelems, pe)
    integer(1), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_int16_put_warp(dest, source, nelems, pe)
    integer(2), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_int32_put_warp(dest, source, nelems, pe)
    integer(4), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_int64_put_warp(dest, source, nelems, pe)
    integer(8), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_fp16_put_warp(dest, source, nelems, pe)
    real(2), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_float_put_warp(dest, source, nelems, pe)
    real(4), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_double_put_warp(dest, source, nelems, pe)
    real(8), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_complex_put_warp(dest, source, nelems, pe)
    complex(4), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_dcomplex_put_warp(dest, source, nelems, pe)
    complex(8), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

以下 nvshmem put warp 子例程不是泛型 nvshmemx_put_warp 组的一部分，但为了灵活性和与 C 名称的兼容性而提供

subroutine nvshmemx_int_put_warp(dest, source, nelems, pe)
    integer(4), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_long_put_warp(dest, source, nelems, pe)
    integer(8), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_put8_warp(dest, source, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_put16_warp(dest, source, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_put32_warp(dest, source, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_put64_warp(dest, source, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_put128_warp(dest, source, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe

9.3.7. nvshmem_get

此子例程在数据已从本地 PE 上的源数组复制出来后返回。子例程 nvshmem_get 被重载以接受许多不同的参数集。具体的名称和参数列表如下。

subroutine nvshmem_getmem(dest, source, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_getmem_on_stream(dest, source, nelems, pe, stream)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_int8_get(dest, source, nelems, pe)
    integer(1), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_int8_get_on_stream(dest, source, nelems, pe, stream)
    integer(1), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_int16_get(dest, source, nelems, pe)
    integer(2), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_int16_get_on_stream(dest, source, nelems, pe, stream)
    integer(2), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_int32_get(dest, source, nelems, pe)
    integer(4), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_int32_get_on_stream(dest, source, nelems, pe, stream)
    integer(4), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_int64_get(dest, source, nelems, pe)
    integer(8), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_int64_get_on_stream(dest, source, nelems, pe, stream)
    integer(8), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_float_get(dest, source, nelems, pe)
    real(4), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_float_get_on_stream(dest, source, nelems, pe, stream)
    real(4), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_double_get(dest, source, nelems, pe)
    real(8), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_double_get_on_stream(dest, source, nelems, pe, stream)
    real(8), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_complex_get(dest, source, nelems, pe)
    complex(4), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_complex_get_on_stream(dest, source, nelems, pe, stream)
    complex(4), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_dcomplex_get(dest, source, nelems, pe)
    complex(8), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_dcomplex_get_on_stream(dest, source, nelems, pe, stream)
    complex(8), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

以下 nvshmem get 子例程不是泛型 nvshmem_get 组的一部分，但为了灵活性和与 C 名称的兼容性而提供

subroutine nvshmem_get8(dest, source, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_get8_on_stream(dest, source, nelems, pe, stream)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_get16(dest, source, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_get16_on_stream(dest, source, nelems, pe, stream)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_get32(dest, source, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_get32_on_stream(dest, source, nelems, pe, stream)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_get64(dest, source, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_get64_on_stream(dest, source, nelems, pe, stream)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_get128(dest, source, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_get128_on_stream(dest, source, nelems, pe, stream)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

9.3.8. nvshmem_g

此子例程在数据已从本地 PE 上的源数组复制出来后返回。子例程 nvshmem_g 被重载以接受许多不同的参数集。这些子例程可以从主机或设备调用，并且源通过值传递，并且应分别是驻留在主机或设备上的。具体的名称和参数列表如下。

subroutine nvshmem_int8_g(dest, source, nelems, pe)
    integer(1), device :: dest(*), source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_int8_g_on_stream(dest, source, nelems, pe, stream)
    integer(1), device :: dest(*), source
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_int16_g(dest, source, nelems, pe)
    integer(2), device :: dest(*), source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_int16_g_on_stream(dest, source, nelems, pe, stream)
    integer(2), device :: dest(*), source
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_int32_g(dest, source, nelems, pe)
    integer(4), device :: dest(*), source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_int32_g_on_stream(dest, source, nelems, pe, stream)
    integer(4), device :: dest(*), source
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_int64_g(dest, source, nelems, pe)
    integer(8), device :: dest(*), source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_int64_g_on_stream(dest, source, nelems, pe, stream)
    integer(8), device :: dest(*), source
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_float_g(dest, source, nelems, pe)
    real(4), device :: dest(*), source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_float_g_on_stream(dest, source, nelems, pe, stream)
    real(4), device :: dest(*), source
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_double_g(dest, source, nelems, pe)
    real(8), device :: dest(*), source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_double_g_on_stream(dest, source, nelems, pe, stream)
    real(8), device :: dest(*), source
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

9.3.9. nvshmem_iget

此子例程提供了一种将步幅数据元素复制到目标的方法。此子例程在数据已从本地 PE 上的源数组复制出来后返回。子例程 nvshmem_iget 被重载以接受许多不同的参数集。这些子例程可以从主机或设备调用。具体的名称和参数列表如下。

subroutine nvshmem_int8_iget(dest, source, dst, sst, nelems, pe)
    integer(1), device :: dest(*), source(*)
    integer(8) :: dst, sst, nelems
    integer(4) :: pe

subroutine nvshmemx_int8_iget_on_stream(dest, source, dst, sst, nelems, pe, stream)
    integer(1), device :: dest(*), source(*)
    integer(8) :: dst, sst, nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_int16_iget(dest, source, dst, sst, nelems, pe)
    integer(2), device :: dest(*), source(*)
    integer(8) :: dst, sst, nelems
    integer(4) :: pe

subroutine nvshmemx_int16_iget_on_stream(dest, source, dst, sst, nelems, pe, stream)
    integer(2), device :: dest(*), source(*)
    integer(8) :: dst, sst, nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_int32_iget(dest, source, dst, sst, nelems, pe)
    integer(4), device :: dest(*), source(*)
    integer(8) :: dst, sst, nelems
    integer(4) :: pe

subroutine nvshmemx_int32_iget_on_stream(dest, source, dst, sst, nelems, pe, stream)
    integer(4), device :: dest(*), source(*)
    integer(8) :: dst, sst, nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_int64_iget(dest, source, dst, sst, nelems, pe)
    integer(8), device :: dest(*), source(*)
    integer(8) :: dst, sst, nelems
    integer(4) :: pe

subroutine nvshmemx_int64_iget_on_stream(dest, source, dst, sst, nelems, pe, stream)
    integer(8), device :: dest(*), source(*)
    integer(8) :: dst, sst, nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_float_iget(dest, source, dst, sst, nelems, pe)
    real(4), device :: dest(*), source(*)
    integer(8) :: dst, sst, nelems
    integer(4) :: pe

subroutine nvshmemx_float_iget_on_stream(dest, source, dst, sst, nelems, pe, stream)
    real(4), device :: dest(*), source(*)
    integer(8) :: dst, sst, nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_double_iget(dest, source, dst, sst, nelems, pe)
    real(8), device :: dest(*), source(*)
    integer(8) :: dst, sst, nelems
    integer(4) :: pe

subroutine nvshmemx_double_iget_on_stream(dest, source, dst, sst, nelems, pe, stream)
    real(8), device :: dest(*), source(*)
    integer(8) :: dst, sst, nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_complex_iget(dest, source, dst, sst, nelems, pe)
    complex(4), device :: dest(*), source(*)
    integer(8) :: dst, sst, nelems
    integer(4) :: pe

subroutine nvshmemx_complex_iget_on_stream(dest, source, dst, sst, nelems, pe, stream)
    complex(4), device :: dest(*), source(*)
    integer(8) :: dst, sst, nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_dcomplex_iget(dest, source, dst, sst, nelems, pe)
    complex(8), device :: dest(*), source(*)
    integer(8) :: dst, sst, nelems
    integer(4) :: pe

subroutine nvshmemx_dcomplex_iget_on_stream(dest, source, dst, sst, nelems, pe, stream)
    complex(8), device :: dest(*), source(*)
    integer(8) :: dst, sst, nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

以下 nvshmem iget 子例程不是泛型 nvshmem_iget 组的一部分，但为了灵活性和与 C 名称的兼容性而提供

subroutine nvshmem_iget8(dest, source, dst, sst, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: dst, sst, nelems
    integer(4) :: pe

subroutine nvshmemx_iget8_on_stream(dest, source, dst, sst, nelems, pe, stream)
    type(c_devptr) :: dest, source
    integer(8) :: dst, sst, nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_iget16(dest, source, dst, sst, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: dst, sst, nelems
    integer(4) :: pe

subroutine nvshmemx_iget16_on_stream(dest, source, dst, sst, nelems, pe, stream)
    type(c_devptr) :: dest, source
    integer(8) :: dst, sst, nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_iget32(dest, source, dst, sst, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: dst, sst, nelems
    integer(4) :: pe

subroutine nvshmemx_iget32_on_stream(dest, source, dst, sst, nelems, pe, stream)
    type(c_devptr) :: dest, source
    integer(8) :: dst, sst, nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_iget64(dest, source, dst, sst, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: dst, sst, nelems
    integer(4) :: pe

subroutine nvshmemx_iget64_on_stream(dest, source, dst, sst, nelems, pe, stream)
    type(c_devptr) :: dest, source
    integer(8) :: dst, sst, nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_iget128(dest, source, dst, sst, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: dst, sst, nelems
    integer(4) :: pe

subroutine nvshmemx_iget128_on_stream(dest, source, dst, sst, nelems, pe, stream)
    type(c_devptr) :: dest, source
    integer(8) :: dst, sst, nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

9.3.10. nvshmem_get_nbi

此子例程在启动 get 操作后返回。子例程 nvshmem_get_nbi 被重载以接受许多不同的参数集。这些子例程可以从主机或设备调用。具体的名称和参数列表如下。

subroutine nvshmem_int8_get_nbi(dest, source, nelems, pe)
    integer(1), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_int8_get_nbi_on_stream(dest, source, nelems, pe, stream)
    integer(1), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_int16_get_nbi(dest, source, nelems, pe)
    integer(2), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_int16_get_nbi_on_stream(dest, source, nelems, pe, stream)
    integer(2), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_int32_get_nbi(dest, source, nelems, pe)
    integer(4), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_int32_get_nbi_on_stream(dest, source, nelems, pe, stream)
    integer(4), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_int64_get_nbi(dest, source, nelems, pe)
    integer(8), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_int64_get_nbi_on_stream(dest, source, nelems, pe, stream)
    integer(8), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_float_get_nbi(dest, source, nelems, pe)
    real(4), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_float_get_nbi_on_stream(dest, source, nelems, pe, stream)
    real(4), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_double_get_nbi(dest, source, nelems, pe)
    real(8), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_double_get_nbi_on_stream(dest, source, nelems, pe, stream)
    real(8), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_complex_get_nbi(dest, source, nelems, pe)
    complex(4), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_complex_get_nbi_on_stream(dest, source, nelems, pe, stream)
    complex(4), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_dcomplex_get_nbi(dest, source, nelems, pe)
    complex(8), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_dcomplex_get_nbi_on_stream(dest, source, nelems, pe, stream)
    complex(8), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

以下 nvshmem get_nbi 子例程不是泛型 nvshmem_get_nbi 组的一部分，但为了灵活性和与 C 名称的兼容性而提供

subroutine nvshmem_get8_nbi(dest, source, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_get8_nbi_on_stream(dest, source, nelems, pe, stream)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_get16_nbi(dest, source, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_get16_nbi_on_stream(dest, source, nelems, pe, stream)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_get32_nbi(dest, source, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_get32_nbi_on_stream(dest, source, nelems, pe, stream)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_get64_nbi(dest, source, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_get64_nbi_on_stream(dest, source, nelems, pe, stream)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_get128_nbi(dest, source, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_get128_nbi_on_stream(dest, source, nelems, pe, stream)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe
    integer(cuda_stream_kind) :: stream

9.3.11. nvshmemx_get_block

此子例程在数据已从本地 PE 上的源数组复制出来后返回。它仅在设备代码中可用。子例程 nvshmemx_get_block 被重载以接受许多不同的参数集。具体的名称和参数列表如下。

subroutine nvshmemx_getmem_block(dest, source, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_int8_get_block(dest, source, nelems, pe)
    integer(1), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_int16_get_block(dest, source, nelems, pe)
    integer(2), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_int32_get_block(dest, source, nelems, pe)
    integer(4), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_int64_get_block(dest, source, nelems, pe)
    integer(8), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_fp16_get_block(dest, source, nelems, pe)
    real(2), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_float_get_block(dest, source, nelems, pe)
    real(4), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_double_get_block(dest, source, nelems, pe)
    real(8), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_complex_get_block(dest, source, nelems, pe)
    complex(4), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_dcomplex_get_block(dest, source, nelems, pe)
    complex(8), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

以下 nvshmem get block 子例程不是泛型 nvshmemx_get_block 组的一部分，但为了灵活性和与 C 名称的兼容性而提供

subroutine nvshmemx_int_get_block(dest, source, nelems, pe)
    integer(4), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_long_get_block(dest, source, nelems, pe)
    integer(8), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_get8_block(dest, source, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_get16_block(dest, source, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_get32_block(dest, source, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_get64_block(dest, source, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_get128_block(dest, source, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe

9.3.12. nvshmemx_get_warp

此子例程在数据已从本地 PE 上的源数组复制出来后返回。它仅在设备代码中可用。子例程 nvshmemx_get_warp 被重载以接受许多不同的参数集。具体的名称和参数列表如下。

subroutine nvshmemx_getmem_warp(dest, source, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_int8_get_warp(dest, source, nelems, pe)
    integer(1), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_int16_get_warp(dest, source, nelems, pe)
    integer(2), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_int32_get_warp(dest, source, nelems, pe)
    integer(4), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_int64_get_warp(dest, source, nelems, pe)
    integer(8), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_fp16_get_warp(dest, source, nelems, pe)
    real(2), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_float_get_warp(dest, source, nelems, pe)
    real(4), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_double_get_warp(dest, source, nelems, pe)
    real(8), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_complex_get_warp(dest, source, nelems, pe)
    complex(4), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_dcomplex_get_warp(dest, source, nelems, pe)
    complex(8), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

以下 nvshmem get warp 子例程不是泛型 nvshmemx_get_warp 组的一部分，但为了灵活性和与 C 名称的兼容性而提供

subroutine nvshmemx_int_get_warp(dest, source, nelems, pe)
    integer(4), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_long_get_warp(dest, source, nelems, pe)
    integer(8), device :: dest(*), source(*)
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_get8_warp(dest, source, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_get16_warp(dest, source, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_get32_warp(dest, source, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_get64_warp(dest, source, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe

subroutine nvshmemx_get128_warp(dest, source, nelems, pe)
    type(c_devptr) :: dest, source
    integer(8) :: nelems
    integer(4) :: pe

9.4. NVSHMEM 集体通信函数

本节包含用于在 PE 组内执行协调通信或同步操作的 NVSHMEM 函数的 Fortran 接口。本节可以进一步划分为 barrier 和 sync 函数、all-to-all、broadcast 和 collect 函数以及 reductions。

9.4.1. nvshmem_barrier, nvshmem_barrier_all

这些子例程对所有 (nvshmem_barrier_all) 或提供的 PE 子集 (nvshmem_barrier) 执行集体同步。在 CPU 上启动的排序 API 仅对从 CPU 发出的通信操作进行排序。使用 cudaDeviceSynchronize() 或类似方法来确保 GPU 操作已完成。子例程名称和参数列表如下。

subroutine nvshmem_barrier_all()

subroutine nvshmemx_barrier_all_on_stream(stream)
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_barrier(pe_start, pe_stride, pe_size, psync)
    integer(4) :: pe_start, pe_stride, pe_size
    integer(8), device :: psync(*)

subroutine nvshmemx_barrier_on_stream(pe_start, pe_stride, pe_size, psync, stream)
    integer(4) :: pe_start, pe_stride, pe_size
    integer(8), device :: psync(*)
    integer(cuda_stream_kind) :: stream

9.4.2. nvshmem_sync, nvshmem_sync_all

这些子例程对所有 (nvshmem_sync_all) 或提供的 PE 子集 (nvshmem_sync) 执行集体同步。与 barrier 例程不同，这些子例程仅确保先前发出的内存存储的完成和可见性，而不确保远程内存更新的完成。子例程名称和参数列表如下。

subroutine nvshmem_sync_all()

subroutine nvshmemx_sync_all_on_stream(stream)
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_sync(pe_start, pe_stride, pe_size, psync)
    integer(4) :: pe_start, pe_stride, pe_size
    integer(8), device :: psync(*)

subroutine nvshmemx_sync_on_stream(pe_start, pe_stride, pe_size, psync, stream)
    integer(4) :: pe_start, pe_stride, pe_size
    integer(8), device :: psync(*)
    integer(cuda_stream_kind) :: stream

9.4.3. nvshmem_alltoall

这些函数在 team 上执行集体 all-to-all 操作。从 nvshmem 版本 2.0 开始，集体操作的特定名称采用 team 参数并且特定于类型。这些函数与 team 中的所有其他 PE 交换指定数量的数据元素。Fortran 接口中支持以下泛型名称：nvshmem_alltoall、nvshmemx_alltoall_block 和 nvshmemx_alltoall_warp。nvshmem_alltoall 函数可从主机或设备调用，nvshmemx_alltoall_on_stream 函数仅可从主机调用，而 block 和 warp 函数仅可从设备调用。

integer function nvshmem_int8_alltoall(team, dest, source, nelems)
    integer(4) :: team
    integer(1), device :: dest, source
    integer(8) :: nelems

integer function nvshmem_int16_alltoall(team, dest, source, nelems)
    integer(4) :: team
    integer(2), device :: dest, source
    integer(8) :: nelems

integer function nvshmem_int32_alltoall(team, dest, source, nelems)
    integer(4) :: team
    integer(4), device :: dest, source
    integer(8) :: nelems

integer function nvshmem_int64_alltoall(team, dest, source, nelems)
    integer(4) :: team
    integer(8), device :: dest, source
    integer(8) :: nelems

integer function nvshmem_float_alltoall(team, dest, source, nelems)
    integer(4) :: team
    real(4), device :: dest, source
    integer(8) :: nelems

integer function nvshmem_double_alltoall(team, dest, source, nelems)
    integer(4) :: team
    real(8), device :: dest, source
    integer(8) :: nelems

integer function nvshmemx_int8_alltoall_on_stream(team, &
        dest, source, nelems, stream)
    integer(4) :: team
    integer(1), device :: dest, source
    integer(8) :: nelems
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_int16_alltoall_on_stream(team, &
        dest, source, nelems, stream)
    integer(4) :: team
    integer(2), device :: dest, source
    integer(8) :: nelems
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_int32_alltoall_on_stream(team, &
        dest, source, nelems, stream)
    integer(4) :: team
    integer(4), device :: dest, source
    integer(8) :: nelems
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_int64_alltoall_on_stream(team, &
        dest, source, nelems, stream)
    integer(4) :: team
    integer(8), device :: dest, source
    integer(8) :: nelems
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_float_alltoall_on_stream(team, &
        dest, source, nelems, stream)
    integer(4) :: team
    real(4), device :: dest, source
    integer(8) :: nelems
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_double_alltoall_on_stream(team, &
        dest, source, nelems, stream)
    integer(4) :: team
    real(8), device :: dest, source
    integer(8) :: nelems
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_int8_alltoall_block(team, dest, source, nelems)
    integer(4) :: team
    integer(1), device :: dest, source
    integer(8) :: nelems

integer function nvshmemx_int16_alltoall_block(team, dest, source, nelems)
    integer(4) :: team
    integer(2), device :: dest, source
    integer(8) :: nelems

integer function nvshmemx_int32_alltoall_block(team, dest, source, nelems)
    integer(4) :: team
    integer(4), device :: dest, source
    integer(8) :: nelems

integer function nvshmemx_int64_alltoall_block(team, dest, source, nelems)
    integer(4) :: team
    integer(8), device :: dest, source
    integer(8) :: nelems

integer function nvshmemx_float_alltoall_block(team, dest, source, nelems)
    integer(4) :: team
    real(4), device :: dest, source
    integer(8) :: nelems

integer function nvshmemx_double_alltoall_block(team, dest, source, nelems)
    integer(4) :: team
    real(8), device :: dest, source
    integer(8) :: nelems

integer function nvshmemx_int8_alltoall_warp(team, dest, source, nelems)
    integer(4) :: team
    integer(1), device :: dest, source
    integer(8) :: nelems

integer function nvshmemx_int16_alltoall_warp(team, dest, source, nelems)
    integer(4) :: team
    integer(2), device :: dest, source
    integer(8) :: nelems

integer function nvshmemx_int32_alltoall_warp(team, dest, source, nelems)
    integer(4) :: team
    integer(4), device :: dest, source
    integer(8) :: nelems

integer function nvshmemx_int64_alltoall_warp(team, dest, source, nelems)
    integer(4) :: team
    integer(8), device :: dest, source
    integer(8) :: nelems

integer function nvshmemx_float_alltoall_warp(team, dest, source, nelems)
    integer(4) :: team
    real(4), device :: dest, source
    integer(8) :: nelems

integer function nvshmemx_double_alltoall_warp(team, dest, source, nelems)
    integer(4) :: team
    real(8), device :: dest, source
    integer(8) :: nelems

9.4.4. nvshmem_broadcast

这些函数在一个团队上执行集体广播操作。从 nvshmem 2.0 版本开始，集体操作的特定名称接受一个团队参数并且特定于类型。这些函数将指定数量的源数据元素从指定的根发送到团队中的所有其他 PE。Fortran 接口支持以下通用名称：nvshmem_broadcast、nvshmemx_broadcast_block 和 nvshmemx_broadcast_warp。nvshmem_broadcast 函数可以从主机或设备调用，nvshmemx_broadcast_on_stream 函数只能从主机调用，而 block 和 warp 函数只能从设备调用。

integer function nvshmem_int8_broadcast(team, dest, source, nelems, pe_root)
    integer(4) :: team
    integer(1), device :: dest, source
    integer(8) :: nelems
    integer(4) :: pe_root

integer function nvshmem_int16_broadcast(team, dest, source, nelems, pe_root)
    integer(4) :: team
    integer(2), device :: dest, source
    integer(8) :: nelems
    integer(4) :: pe_root

integer function nvshmem_int32_broadcast(team, dest, source, nelems, pe_root)
    integer(4) :: team
    integer(4), device :: dest, source
    integer(8) :: nelems
    integer(4) :: pe_root

integer function nvshmem_int64_broadcast(team, dest, source, nelems, pe_root)
    integer(4) :: team
    integer(8), device :: dest, source
    integer(8) :: nelems
    integer(4) :: pe_root

integer function nvshmem_float_broadcast(team, dest, source, nelems, pe_root)
    integer(4) :: team
    real(4), device :: dest, source
    integer(8) :: nelems
    integer(4) :: pe_root

integer function nvshmem_double_broadcast(team, dest, source, nelems, pe_root)
    integer(4) :: team
    real(8), device :: dest, source
    integer(8) :: nelems
    integer(4) :: pe_root

integer function nvshmemx_int8_broadcast_on_stream(team, &
        dest, source, nelems, pe_root, stream)
    integer(4) :: team
    integer(1), device :: dest, source
    integer(8) :: nelems
    integer(4) :: pe_root
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_int16_broadcast_on_stream(team, &
        dest, source, nelems, pe_root, stream)
    integer(4) :: team
    integer(2), device :: dest, source
    integer(8) :: nelems
    integer(4) :: pe_root
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_int32_broadcast_on_stream(team, &
        dest, source, nelems, pe_root, stream)
    integer(4) :: team
    integer(4), device :: dest, source
    integer(8) :: nelems
    integer(4) :: pe_root
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_int64_broadcast_on_stream(team, &
        dest, source, nelems, pe_root, stream)
    integer(4) :: team
    integer(8), device :: dest, source
    integer(8) :: nelems
    integer(4) :: pe_root
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_float_broadcast_on_stream(team, &
        dest, source, nelems, pe_root, stream)
    integer(4) :: team
    real(4), device :: dest, source
    integer(8) :: nelems
    integer(4) :: pe_root
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_double_broadcast_on_stream(team, &
        dest, source, nelems, pe_root, stream)
    integer(4) :: team
    real(8), device :: dest, source
    integer(8) :: nelems
    integer(4) :: pe_root
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_int8_broadcast_block(team, dest, source, nelems, pe_root)
    integer(4) :: team
    integer(1), device :: dest, source
    integer(8) :: nelems
    integer(4) :: pe_root

integer function nvshmemx_int16_broadcast_block(team, dest, source, nelems, pe_root)
    integer(4) :: team
    integer(2), device :: dest, source
    integer(8) :: nelems
    integer(4) :: pe_root

integer function nvshmemx_int32_broadcast_block(team, dest, source, nelems, pe_root)
    integer(4) :: team
    integer(4), device :: dest, source
    integer(8) :: nelems
    integer(4) :: pe_root

integer function nvshmemx_int64_broadcast_block(team, dest, source, nelems, pe_root)
    integer(4) :: team
    integer(8), device :: dest, source
    integer(8) :: nelems
    integer(4) :: pe_root

integer function nvshmemx_float_broadcast_block(team, dest, source, nelems, pe_root)
    integer(4) :: team
    real(4), device :: dest, source
    integer(8) :: nelems
    integer(4) :: pe_root

integer function nvshmemx_double_broadcast_block(team, dest, source, nelems, pe_root)
    integer(4) :: team
    real(8), device :: dest, source
    integer(8) :: nelems
    integer(4) :: pe_root

integer function nvshmemx_int8_broadcast_warp(team, dest, source, nelems, pe_root)
    integer(4) :: team
    integer(1), device :: dest, source
    integer(8) :: nelems
    integer(4) :: pe_root

integer function nvshmemx_int16_broadcast_warp(team, dest, source, nelems, pe_root)
    integer(4) :: team
    integer(2), device :: dest, source
    integer(8) :: nelems
    integer(4) :: pe_root

integer function nvshmemx_int32_broadcast_warp(team, dest, source, nelems, pe_root)
    integer(4) :: team
    integer(4), device :: dest, source
    integer(8) :: nelems
    integer(4) :: pe_root

integer function nvshmemx_int64_broadcast_warp(team, dest, source, nelems, pe_root)
    integer(4) :: team
    integer(8), device :: dest, source
    integer(8) :: nelems
    integer(4) :: pe_root

integer function nvshmemx_float_broadcast_warp(team, dest, source, nelems, pe_root)
    integer(4) :: team
    real(4), device :: dest, source
    integer(8) :: nelems
    integer(4) :: pe_root

integer function nvshmemx_double_broadcast_warp(team, dest, source, nelems, pe_root)
    integer(4) :: team
    real(8), device :: dest, source
    integer(8) :: nelems
    integer(4) :: pe_root

9.4.5. nvshmem_collect

这些函数执行集体操作，将每个源数组中指定数量的元素连接到团队中每个 PE 的 dest 数组中。从 nvshmem 2.0 版本开始，集体操作的特定名称接受一个团队参数并且特定于类型。收集的数据按照团队中 PE 的顺序排列，并且 nelems 可能因 PE 而异。Fortran 接口支持以下通用名称：nvshmem_collect、nvshmemx_collect_block 和 nvshmemx_collect_warp。nvshmem_collect 函数可以从主机或设备调用，nvshmemx_collect_on_stream 函数只能从主机调用，而 block 和 warp 函数只能从设备调用。

integer function nvshmem_int8_collect(team, dest, source, nelems)
    integer(4) :: team
    integer(1), device :: dest, source
    integer(8) :: nelems

integer function nvshmem_int16_collect(team, dest, source, nelems)
    integer(4) :: team
    integer(2), device :: dest, source
    integer(8) :: nelems

integer function nvshmem_int32_collect(team, dest, source, nelems)
    integer(4) :: team
    integer(4), device :: dest, source
    integer(8) :: nelems

integer function nvshmem_int64_collect(team, dest, source, nelems)
    integer(4) :: team
    integer(8), device :: dest, source
    integer(8) :: nelems

integer function nvshmem_float_collect(team, dest, source, nelems)
    integer(4) :: team
    real(4), device :: dest, source
    integer(8) :: nelems

integer function nvshmem_double_collect(team, dest, source, nelems)
    integer(4) :: team
    real(8), device :: dest, source
    integer(8) :: nelems

integer function nvshmemx_int8_collect_on_stream(team, &
        dest, source, nelems, stream)
    integer(4) :: team
    integer(1), device :: dest, source
    integer(8) :: nelems
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_int16_collect_on_stream(team, &
        dest, source, nelems, stream)
    integer(4) :: team
    integer(2), device :: dest, source
    integer(8) :: nelems
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_int32_collect_on_stream(team, &
        dest, source, nelems, stream)
    integer(4) :: team
    integer(4), device :: dest, source
    integer(8) :: nelems
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_int64_collect_on_stream(team, &
        dest, source, nelems, stream)
    integer(4) :: team
    integer(8), device :: dest, source
    integer(8) :: nelems
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_float_collect_on_stream(team, &
        dest, source, nelems, stream)
    integer(4) :: team
    real(4), device :: dest, source
    integer(8) :: nelems
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_double_collect_on_stream(team, &
        dest, source, nelems, stream)
    integer(4) :: team
    real(8), device :: dest, source
    integer(8) :: nelems
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_int8_collect_block(team, dest, source, nelems)
    integer(4) :: team
    integer(1), device :: dest, source
    integer(8) :: nelems

integer function nvshmemx_int16_collect_block(team, dest, source, nelems)
    integer(4) :: team
    integer(2), device :: dest, source
    integer(8) :: nelems

integer function nvshmemx_int32_collect_block(team, dest, source, nelems)
    integer(4) :: team
    integer(4), device :: dest, source
    integer(8) :: nelems

integer function nvshmemx_int64_collect_block(team, dest, source, nelems)
    integer(4) :: team
    integer(8), device :: dest, source
    integer(8) :: nelems

integer function nvshmemx_float_collect_block(team, dest, source, nelems)
    integer(4) :: team
    real(4), device :: dest, source
    integer(8) :: nelems

integer function nvshmemx_double_collect_block(team, dest, source, nelems)
    integer(4) :: team
    real(8), device :: dest, source
    integer(8) :: nelems

integer function nvshmemx_int8_collect_warp(team, dest, source, nelems)
    integer(4) :: team
    integer(1), device :: dest, source
    integer(8) :: nelems

integer function nvshmemx_int16_collect_warp(team, dest, source, nelems)
    integer(4) :: team
    integer(2), device :: dest, source
    integer(8) :: nelems

integer function nvshmemx_int32_collect_warp(team, dest, source, nelems)
    integer(4) :: team
    integer(4), device :: dest, source
    integer(8) :: nelems

integer function nvshmemx_int64_collect_warp(team, dest, source, nelems)
    integer(4) :: team
    integer(8), device :: dest, source
    integer(8) :: nelems

integer function nvshmemx_float_collect_warp(team, dest, source, nelems)
    integer(4) :: team
    real(4), device :: dest, source
    integer(8) :: nelems

integer function nvshmemx_double_collect_warp(team, dest, source, nelems)
    integer(4) :: team
    real(8), device :: dest, source
    integer(8) :: nelems

9.4.6. NVSHMEM 归约

本节包含 NVSHMEM 函数的 Fortran 接口，这些函数执行归约操作，归约操作是在一组 PE 中执行的同步操作，执行按位或算术运算，将一组值归约为一个值。

9.4.6.1. nvshmem_and_reduce

这些函数在一个团队中的一组 PE 上执行按位 AND 归约。从 nvshmem 2.0 版本开始，归约操作的特定名称接受一个团队参数并且特定于类型。Fortran 接口支持以下通用名称：nvshmem_and_reduce、nvshmemx_and_reduce_block 和 nvshmemx_and_reduce_warp。nvshmem_and_reduce 函数可以从主机或设备调用，nvshmemx_and_reduce_on_stream 函数只能从主机调用，而 block 和 warp 函数只能从设备调用。

integer function nvshmem_int8_and_reduce(team, dest, source, nreduce)
    integer(4) :: team
    integer(1), device :: dest, source
    integer(8) :: nreduce

integer function nvshmem_int16_and_reduce(team, dest, source, nreduce)
    integer(4) :: team
    integer(2), device :: dest, source
    integer(8) :: nreduce

integer function nvshmem_int32_and_reduce(team, dest, source, nreduce)
    integer(4) :: team
    integer(4), device :: dest, source
    integer(8) :: nreduce

integer function nvshmem_int64_and_reduce(team, dest, source, nreduce)
    integer(4) :: team
    integer(8), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int8_and_reduce_on_stream(team, &
        dest, source, nreduce, stream)
    integer(4) :: team
    integer(1), device :: dest, source
    integer(8) :: nreduce
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_int16_and_reduce_on_stream(team, &
        dest, source, nreduce, stream)
    integer(4) :: team
    integer(2), device :: dest, source
    integer(8) :: nreduce
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_int32_and_reduce_on_stream(team, &
        dest, source, nreduce, stream)
    integer(4) :: team
    integer(4), device :: dest, source
    integer(8) :: nreduce
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_int64_and_reduce_on_stream(team, &
        dest, source, nreduce, stream)
    integer(4) :: team
    integer(8), device :: dest, source
    integer(8) :: nreduce
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_int8_and_reduce_block(team, dest, source, nreduce)
    integer(4) :: team
    integer(1), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int16_and_reduce_block(team, dest, source, nreduce)
    integer(4) :: team
    integer(2), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int32_and_reduce_block(team, dest, source, nreduce)
    integer(4) :: team
    integer(4), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int64_and_reduce_block(team, dest, source, nreduce)
    integer(4) :: team
    integer(8), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int8_and_reduce_warp(team, dest, source, nreduce)
    integer(4) :: team
    integer(1), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int16_and_reduce_warp(team, dest, source, nreduce)
    integer(4) :: team
    integer(2), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int32_and_reduce_warp(team, dest, source, nreduce)
    integer(4) :: team
    integer(4), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int64_and_reduce_warp(team, dest, source, nreduce)
    integer(4) :: team
    integer(8), device :: dest, source
    integer(8) :: nreduce

9.4.6.2. nvshmem_or_reduce

这些函数在一个团队中的一组 PE 上执行按位 OR 归约。从 nvshmem 2.0 版本开始，归约操作的特定名称接受一个团队参数并且特定于类型。Fortran 接口支持以下通用名称：nvshmem_or_reduce、nvshmemx_or_reduce_block 和 nvshmemx_or_reduce_warp。nvshmem_or_reduce 函数可以从主机或设备调用，nvshmemx_or_reduce_on_stream 函数只能从主机调用，而 block 和 warp 函数只能从设备调用。

integer function nvshmem_int8_or_reduce(team, dest, source, nreduce)
    integer(4) :: team
    integer(1), device :: dest, source
    integer(8) :: nreduce

integer function nvshmem_int16_or_reduce(team, dest, source, nreduce)
    integer(4) :: team
    integer(2), device :: dest, source
    integer(8) :: nreduce

integer function nvshmem_int32_or_reduce(team, dest, source, nreduce)
    integer(4) :: team
    integer(4), device :: dest, source
    integer(8) :: nreduce

integer function nvshmem_int64_or_reduce(team, dest, source, nreduce)
    integer(4) :: team
    integer(8), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int8_or_reduce_on_stream(team, &
        dest, source, nreduce, stream)
    integer(4) :: team
    integer(1), device :: dest, source
    integer(8) :: nreduce
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_int16_or_reduce_on_stream(team, &
        dest, source, nreduce, stream)
    integer(4) :: team
    integer(2), device :: dest, source
    integer(8) :: nreduce
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_int32_or_reduce_on_stream(team, &
        dest, source, nreduce, stream)
    integer(4) :: team
    integer(4), device :: dest, source
    integer(8) :: nreduce
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_int64_or_reduce_on_stream(team, &
        dest, source, nreduce, stream)
    integer(4) :: team
    integer(8), device :: dest, source
    integer(8) :: nreduce
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_int8_or_reduce_block(team, dest, source, nreduce)
    integer(4) :: team
    integer(1), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int16_or_reduce_block(team, dest, source, nreduce)
    integer(4) :: team
    integer(2), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int32_or_reduce_block(team, dest, source, nreduce)
    integer(4) :: team
    integer(4), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int64_or_reduce_block(team, dest, source, nreduce)
    integer(4) :: team
    integer(8), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int8_or_reduce_warp(team, dest, source, nreduce)
    integer(4) :: team
    integer(1), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int16_or_reduce_warp(team, dest, source, nreduce)
    integer(4) :: team
    integer(2), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int32_or_reduce_warp(team, dest, source, nreduce)
    integer(4) :: team
    integer(4), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int64_or_reduce_warp(team, dest, source, nreduce)
    integer(4) :: team
    integer(8), device :: dest, source
    integer(8) :: nreduce

9.4.6.3. nvshmem_xor_reduce

这些函数在一个团队中的一组 PE 上执行按位 XOR 归约。从 nvshmem 2.0 版本开始，归约操作的特定名称接受一个团队参数并且特定于类型。Fortran 接口支持以下通用名称：nvshmem_xor_reduce、nvshmemx_xor_reduce_block 和 nvshmemx_xor_reduce_warp。nvshmem_xor_reduce 函数可以从主机或设备调用，nvshmemx_xor_reduce_on_stream 函数只能从主机调用，而 block 和 warp 函数只能从设备调用。

integer function nvshmem_int8_xor_reduce(team, dest, source, nreduce)
    integer(4) :: team
    integer(1), device :: dest, source
    integer(8) :: nreduce

integer function nvshmem_int16_xor_reduce(team, dest, source, nreduce)
    integer(4) :: team
    integer(2), device :: dest, source
    integer(8) :: nreduce

integer function nvshmem_int32_xor_reduce(team, dest, source, nreduce)
    integer(4) :: team
    integer(4), device :: dest, source
    integer(8) :: nreduce

integer function nvshmem_int64_xor_reduce(team, dest, source, nreduce)
    integer(4) :: team
    integer(8), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int8_xor_reduce_on_stream(team, &
        dest, source, nreduce, stream)
    integer(4) :: team
    integer(1), device :: dest, source
    integer(8) :: nreduce
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_int16_xor_reduce_on_stream(team, &
        dest, source, nreduce, stream)
    integer(4) :: team
    integer(2), device :: dest, source
    integer(8) :: nreduce
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_int32_xor_reduce_on_stream(team, &
        dest, source, nreduce, stream)
    integer(4) :: team
    integer(4), device :: dest, source
    integer(8) :: nreduce
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_int64_xor_reduce_on_stream(team, &
        dest, source, nreduce, stream)
    integer(4) :: team
    integer(8), device :: dest, source
    integer(8) :: nreduce
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_int8_xor_reduce_block(team, dest, source, nreduce)
    integer(4) :: team
    integer(1), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int16_xor_reduce_block(team, dest, source, nreduce)
    integer(4) :: team
    integer(2), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int32_xor_reduce_block(team, dest, source, nreduce)
    integer(4) :: team
    integer(4), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int64_xor_reduce_block(team, dest, source, nreduce)
    integer(4) :: team
    integer(8), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int8_xor_reduce_warp(team, dest, source, nreduce)
    integer(4) :: team
    integer(1), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int16_xor_reduce_warp(team, dest, source, nreduce)
    integer(4) :: team
    integer(2), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int32_xor_reduce_warp(team, dest, source, nreduce)
    integer(4) :: team
    integer(4), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int64_xor_reduce_warp(team, dest, source, nreduce)
    integer(4) :: team
    integer(8), device :: dest, source
    integer(8) :: nreduce

9.4.6.4. nvshmem_max_reduce

这些函数在一个团队中的一组 PE 上执行最大值 (MAX) 归约。从 nvshmem 2.0 版本开始，归约操作的特定名称接受一个团队参数并且特定于类型。Fortran 接口支持以下通用名称：nvshmem_max_reduce、nvshmemx_max_reduce_block 和 nvshmemx_max_reduce_warp。nvshmem_max_reduce 函数可以从主机或设备调用，nvshmemx_max_reduce_on_stream 函数只能从主机调用，而 block 和 warp 函数只能从设备调用。

integer function nvshmem_int8_max_reduce(team, dest, source, nreduce)
    integer(4) :: team
    integer(1), device :: dest, source
    integer(8) :: nreduce

integer function nvshmem_int16_max_reduce(team, dest, source, nreduce)
    integer(4) :: team
    integer(2), device :: dest, source
    integer(8) :: nreduce

integer function nvshmem_int32_max_reduce(team, dest, source, nreduce)
    integer(4) :: team
    integer(4), device :: dest, source
    integer(8) :: nreduce

integer function nvshmem_int64_max_reduce(team, dest, source, nreduce)
    integer(4) :: team
    integer(8), device :: dest, source
    integer(8) :: nreduce

integer function nvshmem_float_max_reduce(team, dest, source, nreduce)
    integer(4) :: team
    real(4), device :: dest, source
    integer(8) :: nreduce

integer function nvshmem_double_max_reduce(team, dest, source, nreduce)
    integer(4) :: team
    real(8), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int8_max_reduce_on_stream(team, &
        dest, source, nreduce, stream)
    integer(4) :: team
    integer(1), device :: dest, source
    integer(8) :: nreduce
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_int16_max_reduce_on_stream(team, &
        dest, source, nreduce, stream)
    integer(4) :: team
    integer(2), device :: dest, source
    integer(8) :: nreduce
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_int32_max_reduce_on_stream(team, &
        dest, source, nreduce, stream)
    integer(4) :: team
    integer(4), device :: dest, source
    integer(8) :: nreduce
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_int64_max_reduce_on_stream(team, &
        dest, source, nreduce, stream)
    integer(4) :: team
    integer(8), device :: dest, source
    integer(8) :: nreduce
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_float_max_reduce_on_stream(team, &
        dest, source, nreduce, stream)
    integer(4) :: team
    real(4), device :: dest, source
    integer(8) :: nreduce
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_double_max_reduce_on_stream(team, &
        dest, source, nreduce, stream)
    integer(4) :: team
    real(8), device :: dest, source
    integer(8) :: nreduce
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_int8_max_reduce_block(team, dest, source, nreduce)
    integer(4) :: team
    integer(1), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int16_max_reduce_block(team, dest, source, nreduce)
    integer(4) :: team
    integer(2), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int32_max_reduce_block(team, dest, source, nreduce)
    integer(4) :: team
    integer(4), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int64_max_reduce_block(team, dest, source, nreduce)
    integer(4) :: team
    integer(8), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_float_max_reduce_block(team, dest, source, nreduce)
    integer(4) :: team
    real(4), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_double_max_reduce_block(team, dest, source, nreduce)
    integer(4) :: team
    real(8), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int8_max_reduce_warp(team, dest, source, nreduce)
    integer(4) :: team
    integer(1), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int16_max_reduce_warp(team, dest, source, nreduce)
    integer(4) :: team
    integer(2), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int32_max_reduce_warp(team, dest, source, nreduce)
    integer(4) :: team
    integer(4), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int64_max_reduce_warp(team, dest, source, nreduce)
    integer(4) :: team
    integer(8), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_float_max_reduce_warp(team, dest, source, nreduce)
    integer(4) :: team
    real(4), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_double_max_reduce_warp(team, dest, source, nreduce)
    integer(4) :: team
    real(8), device :: dest, source
    integer(8) :: nreduce

9.4.6.5. nvshmem_min_reduce

这些函数在一个团队中的一组 PE 上执行最小值 (MIN) 归约。从 nvshmem 2.0 版本开始，归约操作的特定名称接受一个团队参数并且特定于类型。Fortran 接口支持以下通用名称：nvshmem_min_reduce、nvshmemx_min_reduce_block 和 nvshmemx_min_reduce_warp。nvshmem_min_reduce 函数可以从主机或设备调用，nvshmemx_min_reduce_on_stream 函数只能从主机调用，而 block 和 warp 函数只能从设备调用。

integer function nvshmem_int8_min_reduce(team, dest, source, nreduce)
    integer(4) :: team
    integer(1), device :: dest, source
    integer(8) :: nreduce

integer function nvshmem_int16_min_reduce(team, dest, source, nreduce)
    integer(4) :: team
    integer(2), device :: dest, source
    integer(8) :: nreduce

integer function nvshmem_int32_min_reduce(team, dest, source, nreduce)
    integer(4) :: team
    integer(4), device :: dest, source
    integer(8) :: nreduce

integer function nvshmem_int64_min_reduce(team, dest, source, nreduce)
    integer(4) :: team
    integer(8), device :: dest, source
    integer(8) :: nreduce

integer function nvshmem_float_min_reduce(team, dest, source, nreduce)
    integer(4) :: team
    real(4), device :: dest, source
    integer(8) :: nreduce

integer function nvshmem_double_min_reduce(team, dest, source, nreduce)
    integer(4) :: team
    real(8), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int8_min_reduce_on_stream(team, &
        dest, source, nreduce, stream)
    integer(4) :: team
    integer(1), device :: dest, source
    integer(8) :: nreduce
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_int16_min_reduce_on_stream(team, &
        dest, source, nreduce, stream)
    integer(4) :: team
    integer(2), device :: dest, source
    integer(8) :: nreduce
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_int32_min_reduce_on_stream(team, &
        dest, source, nreduce, stream)
    integer(4) :: team
    integer(4), device :: dest, source
    integer(8) :: nreduce
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_int64_min_reduce_on_stream(team, &
        dest, source, nreduce, stream)
    integer(4) :: team
    integer(8), device :: dest, source
    integer(8) :: nreduce
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_float_min_reduce_on_stream(team, &
        dest, source, nreduce, stream)
    integer(4) :: team
    real(4), device :: dest, source
    integer(8) :: nreduce
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_double_min_reduce_on_stream(team, &
        dest, source, nreduce, stream)
    integer(4) :: team
    real(8), device :: dest, source
    integer(8) :: nreduce
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_int8_min_reduce_block(team, dest, source, nreduce)
    integer(4) :: team
    integer(1), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int16_min_reduce_block(team, dest, source, nreduce)
    integer(4) :: team
    integer(2), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int32_min_reduce_block(team, dest, source, nreduce)
    integer(4) :: team
    integer(4), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int64_min_reduce_block(team, dest, source, nreduce)
    integer(4) :: team
    integer(8), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_float_min_reduce_block(team, dest, source, nreduce)
    integer(4) :: team
    real(4), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_double_min_reduce_block(team, dest, source, nreduce)
    integer(4) :: team
    real(8), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int8_min_reduce_warp(team, dest, source, nreduce)
    integer(4) :: team
    integer(1), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int16_min_reduce_warp(team, dest, source, nreduce)
    integer(4) :: team
    integer(2), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int32_min_reduce_warp(team, dest, source, nreduce)
    integer(4) :: team
    integer(4), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int64_min_reduce_warp(team, dest, source, nreduce)
    integer(4) :: team
    integer(8), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_float_min_reduce_warp(team, dest, source, nreduce)
    integer(4) :: team
    real(4), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_double_min_reduce_warp(team, dest, source, nreduce)
    integer(4) :: team
    real(8), device :: dest, source
    integer(8) :: nreduce

9.4.6.6. nvshmem_sum_reduce

这些函数在一个团队中的一组 PE 上执行求和 (SUM) 归约。从 nvshmem 2.0 版本开始，归约操作的特定名称接受一个团队参数并且特定于类型。Fortran 接口支持以下通用名称：nvshmem_sum_reduce、nvshmemx_sum_reduce_block 和 nvshmemx_sum_reduce_warp。nvshmem_sum_reduce 函数可以从主机或设备调用，nvshmemx_sum_reduce_on_stream 函数只能从主机调用，而 block 和 warp 函数只能从设备调用。

integer function nvshmem_int8_sum_reduce(team, dest, source, nreduce)
    integer(4) :: team
    integer(1), device :: dest, source
    integer(8) :: nreduce

integer function nvshmem_int16_sum_reduce(team, dest, source, nreduce)
    integer(4) :: team
    integer(2), device :: dest, source
    integer(8) :: nreduce

integer function nvshmem_int32_sum_reduce(team, dest, source, nreduce)
    integer(4) :: team
    integer(4), device :: dest, source
    integer(8) :: nreduce

integer function nvshmem_int64_sum_reduce(team, dest, source, nreduce)
    integer(4) :: team
    integer(8), device :: dest, source
    integer(8) :: nreduce

integer function nvshmem_float_sum_reduce(team, dest, source, nreduce)
    integer(4) :: team
    real(4), device :: dest, source
    integer(8) :: nreduce

integer function nvshmem_double_sum_reduce(team, dest, source, nreduce)
    integer(4) :: team
    real(8), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int8_sum_reduce_on_stream(team, &
        dest, source, nreduce, stream)
    integer(4) :: team
    integer(1), device :: dest, source
    integer(8) :: nreduce
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_int16_sum_reduce_on_stream(team, &
        dest, source, nreduce, stream)
    integer(4) :: team
    integer(2), device :: dest, source
    integer(8) :: nreduce
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_int32_sum_reduce_on_stream(team, &
        dest, source, nreduce, stream)
    integer(4) :: team
    integer(4), device :: dest, source
    integer(8) :: nreduce
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_int64_sum_reduce_on_stream(team, &
        dest, source, nreduce, stream)
    integer(4) :: team
    integer(8), device :: dest, source
    integer(8) :: nreduce
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_float_sum_reduce_on_stream(team, &
        dest, source, nreduce, stream)
    integer(4) :: team
    real(4), device :: dest, source
    integer(8) :: nreduce
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_double_sum_reduce_on_stream(team, &
        dest, source, nreduce, stream)
    integer(4) :: team
    real(8), device :: dest, source
    integer(8) :: nreduce
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_int8_sum_reduce_block(team, dest, source, nreduce)
    integer(4) :: team
    integer(1), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int16_sum_reduce_block(team, dest, source, nreduce)
    integer(4) :: team
    integer(2), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int32_sum_reduce_block(team, dest, source, nreduce)
    integer(4) :: team
    integer(4), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int64_sum_reduce_block(team, dest, source, nreduce)
    integer(4) :: team
    integer(8), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_float_sum_reduce_block(team, dest, source, nreduce)
    integer(4) :: team
    real(4), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_double_sum_reduce_block(team, dest, source, nreduce)
    integer(4) :: team
    real(8), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int8_sum_reduce_warp(team, dest, source, nreduce)
    integer(4) :: team
    integer(1), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int16_sum_reduce_warp(team, dest, source, nreduce)
    integer(4) :: team
    integer(2), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int32_sum_reduce_warp(team, dest, source, nreduce)
    integer(4) :: team
    integer(4), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int64_sum_reduce_warp(team, dest, source, nreduce)
    integer(4) :: team
    integer(8), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_float_sum_reduce_warp(team, dest, source, nreduce)
    integer(4) :: team
    real(4), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_double_sum_reduce_warp(team, dest, source, nreduce)
    integer(4) :: team
    real(8), device :: dest, source
    integer(8) :: nreduce

9.4.6.7. nvshmem_prod_reduce

这些函数在一个团队中的一组 PE 上执行乘积归约。从 nvshmem 2.0 版本开始，归约操作的特定名称接受一个团队参数并且特定于类型。Fortran 接口支持以下通用名称：nvshmem_prod_reduce、nvshmemx_prod_reduce_block 和 nvshmemx_prod_reduce_warp。nvshmem_prod_reduce 函数可以从主机或设备调用，nvshmemx_prod_reduce_on_stream 函数只能从主机调用，而 block 和 warp 函数只能从设备调用。

integer function nvshmem_int8_prod_reduce(team, dest, source, nreduce)
    integer(4) :: team
    integer(1), device :: dest, source
    integer(8) :: nreduce

integer function nvshmem_int16_prod_reduce(team, dest, source, nreduce)
    integer(4) :: team
    integer(2), device :: dest, source
    integer(8) :: nreduce

integer function nvshmem_int32_prod_reduce(team, dest, source, nreduce)
    integer(4) :: team
    integer(4), device :: dest, source
    integer(8) :: nreduce

integer function nvshmem_int64_prod_reduce(team, dest, source, nreduce)
    integer(4) :: team
    integer(8), device :: dest, source
    integer(8) :: nreduce

integer function nvshmem_float_prod_reduce(team, dest, source, nreduce)
    integer(4) :: team
    real(4), device :: dest, source
    integer(8) :: nreduce

integer function nvshmem_double_prod_reduce(team, dest, source, nreduce)
    integer(4) :: team
    real(8), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int8_prod_reduce_on_stream(team, &
        dest, source, nreduce, stream)
    integer(4) :: team
    integer(1), device :: dest, source
    integer(8) :: nreduce
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_int16_prod_reduce_on_stream(team, &
        dest, source, nreduce, stream)
    integer(4) :: team
    integer(2), device :: dest, source
    integer(8) :: nreduce
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_int32_prod_reduce_on_stream(team, &
        dest, source, nreduce, stream)
    integer(4) :: team
    integer(4), device :: dest, source
    integer(8) :: nreduce
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_int64_prod_reduce_on_stream(team, &
        dest, source, nreduce, stream)
    integer(4) :: team
    integer(8), device :: dest, source
    integer(8) :: nreduce
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_float_prod_reduce_on_stream(team, &
        dest, source, nreduce, stream)
    integer(4) :: team
    real(4), device :: dest, source
    integer(8) :: nreduce
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_double_prod_reduce_on_stream(team, &
        dest, source, nreduce, stream)
    integer(4) :: team
    real(8), device :: dest, source
    integer(8) :: nreduce
    integer(cuda_stream_kind) :: stream

integer function nvshmemx_int8_prod_reduce_block(team, dest, source, nreduce)
    integer(4) :: team
    integer(1), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int16_prod_reduce_block(team, dest, source, nreduce)
    integer(4) :: team
    integer(2), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int32_prod_reduce_block(team, dest, source, nreduce)
    integer(4) :: team
    integer(4), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int64_prod_reduce_block(team, dest, source, nreduce)
    integer(4) :: team
    integer(8), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_float_prod_reduce_block(team, dest, source, nreduce)
    integer(4) :: team
    real(4), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_double_prod_reduce_block(team, dest, source, nreduce)
    integer(4) :: team
    real(8), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int8_prod_reduce_warp(team, dest, source, nreduce)
    integer(4) :: team
    integer(1), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int16_prod_reduce_warp(team, dest, source, nreduce)
    integer(4) :: team
    integer(2), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int32_prod_reduce_warp(team, dest, source, nreduce)
    integer(4) :: team
    integer(4), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_int64_prod_reduce_warp(team, dest, source, nreduce)
    integer(4) :: team
    integer(8), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_float_prod_reduce_warp(team, dest, source, nreduce)
    integer(4) :: team
    real(4), device :: dest, source
    integer(8) :: nreduce

integer function nvshmemx_double_prod_reduce_warp(team, dest, source, nreduce)
    integer(4) :: team
    real(8), device :: dest, source
    integer(8) :: nreduce

9.5. NVSHMEM 点对点同步函数

本节包含 NVSHMEM 函数的 Fortran 接口，这些接口提供了一种机制，用于基于对称内存中的值在两个 PE 之间进行同步。

9.5.1. nvshmem_wait_until

此子例程会阻塞，直到调用 PE 上的对称数据对象中包含的值满足比较运算符和比较值指定的条件。子例程 nvshmem_wait_until 已重载，可以接受多组不同的参数。具体名称和参数列表如下。

subroutine nvshmem_int32_wait_until(ivar, cmp, value)
    integer(4), device :: ivar
    integer(4) :: cmp, value

subroutine nvshmemx_int32_wait_until_on_stream(ivar, cmp, value, stream)
    integer(4), device :: ivar
    integer(4) :: cmp, value
    integer(cuda_stream_kind) :: stream

subroutine nvshmem_int64_wait_until(ivar, cmp, value)
    integer(8), device :: ivar
    integer(4) :: cmp
    integer(8) :: value

subroutine nvshmemx_int64_wait_until_on_stream(ivar, cmp, value, stream)
    integer(8), device :: ivar
    integer(4) :: cmp
    integer(8) :: value
    integer(cuda_stream_kind) :: stream

9.6. NVSHMEM 内存排序函数

本节包含 NVSHMEM 函数的 Fortran 接口，这些接口提供机制以确保 NVSHMEM 操作的排序和/或完成交付。

9.6.1. nvshmem_fence

此子例程确保对称数据对象上操作交付的顺序。

subroutine nvshmem_fence()

9.6.2. nvshmem_quiet

这些子例程确保完成调用 PE 发出的对称数据对象上的所有操作。

subroutine nvshmem_quiet()

subroutine nvshmemx_quiet_on_stream(stream)
    integer(cuda_stream_kind) :: stream

10. NVTX 性能分析库 API

本章介绍 NVIDIA 工具扩展 (NVTX) 库的 Fortran 接口。NVTX 是一组函数，开发人员可以使用这些函数向工具提供附加信息，例如 NVIDIA 的 Nsight Systems 性能分析工具。NVTX 函数可以从主机代码访问，但在标记和查看应用程序主机和设备部分的时间跨度（范围）时非常有用。

通过添加以下行，可以公开本章中描述的 NVTX 接口和定义

use nvtx

到您的程序单元。此模块的一个版本过去已通过其他方式提供，但本章档介绍了现在包含在 NVIDIA HPC SDK 中的 Fortran 模块。由于我们的目标是 NVTX v3 API（一个仅包含头文件的 C 库），因此我们实例化了可从 Fortran 调用的包装器，并在库 libnvhpcwrapnvtx.[a|so] 中提供这些包装器；链接需要开发人员将 -cudalib=nvtx 添加到其链接行，或者显式添加某种形式的 -lnvhpcwrapnvtx。

本章分为三个部分。第一部分介绍以前可用的传统 Fortran NVTX 接口。第二部分介绍 NVTX v3 API 现在支持的高级函数。第三部分介绍了一种利用 nvfortran -Minstrument 选项在子程序入口和出口自动插入 NVTX 范围的方法。

除非提供了特定的 kind，否则接口中使用的普通整数类型意味着 integer(4)。

10.1. NVTX 基本工具 API

本节介绍 NVIDIA 工具扩展 (NVTX) 库的最基本 Fortran 接口。这些接口最初在博客文章中和通过公开可用的源代码存储库定义。最简单的接口只是推送和弹出用户标记的嵌套时间范围。

StartRange/EndRange 名称最初为了易于使用而从高级 RangeStart/RangeEnd 转换而来。这两种类型都可以在同一个程序中使用。

10.1.1. nvtxStartRange

此子例程使用 NVTX 库开始一个简单的标记时间跨度范围。icolor 参数是可选的，并将映射到多种预定义颜色之一。范围可以嵌套。

subroutine nvtxStartRange( label, icolor )
  character(len=*) :: label
  integer, optional :: icolor

10.1.2. nvtxEndRange

此子例程终止由 nvtxStartRange 启动的简单标记时间跨度范围。它不接受任何参数。

subroutine nvtxEndRange()

10.2. NVTX 高级工具 API

本节介绍 NVIDIA 工具扩展 (NVTX) 库的高级 Fortran 接口，这些接口针对 NVTX v3 API。

10.2.1. NVTX 定义和派生类型

本节包含 NVIDIA 工具扩展 (NVTX) 库 v3 API 的高级 Fortran 接口中使用的定义和数据类型。

! Parameters
integer, parameter :: NVTX_VERSION = 3
integer, parameter :: NVTX_EVENT_ATTRIB_STRUCT_SIZE = 48

! NVTX Status
enum, bind(C)
    enumerator :: NVTX_SUCCESS = 0
    enumerator :: NVTX_FAIL = 1
    enumerator :: NVTX_ERR_INIT_LOAD_PROPERTY = 2
    enumerator :: NVTX_ERR_INIT_ACCESS_LIBRARY = 3
    enumerator :: NVTX_ERR_INIT_LOAD_LIBRARY = 4
    enumerator :: NVTX_ERR_INIT_MISSING_LIBRARY_ENTRY_POINT = 5
    enumerator :: NVTX_ERR_INIT_FAILED_LIBRARY_ENTRY_POINT = 6
    enumerator :: NVTX_ERR_NO_INJECTION_LIBRARY_AVAILABLE = 7
end enum

! nvtxColorType_t, from nvToolsExt.h
type, bind(c) :: nvtxColorType
  integer(4) :: type
end type
type(nvtxColorType), parameter :: &
    NVTX_COLOR_UNKNOWN  = nvtxColorType(0), &
    NVTX_COLOR_ARGB     = nvtxColorType(1)

! nvtxMessageType_t, from nvToolsExt.h
type, bind(c) :: nvtxMessageType
  integer(4) :: type
end type
type(nvtxMessageType), parameter :: &
  NVTX_MESSAGE_UNKNOWN          = nvtxMessageType(0), &
  NVTX_MESSAGE_TYPE_ASCII       = nvtxMessageType(1), &
  NVTX_MESSAGE_TYPE_UNICODE     = nvtxMessageType(2), &
  NVTX_MESSAGE_TYPE_REGISTERED  = nvtxMessageType(3)

! nvtxPayloadType_t, from nvToolsExt.h
type, bind(c) :: nvtxPayloadType
  integer(4) :: type
end type
type(nvtxPayloadType), parameter :: &
  NVTX_PAYLOAD_UNKNOWN             = nvtxPayloadType(0), &
  NVTX_PAYLOAD_TYPE_UNSIGNED_INT64 = nvtxPayloadType(1), &
  NVTX_PAYLOAD_TYPE_INT64          = nvtxPayloadType(2), &
  NVTX_PAYLOAD_TYPE_DOUBLE         = nvtxPayloadType(3), &
  NVTX_PAYLOAD_TYPE_UNSIGNED_INT32 = nvtxPayloadType(4), &
  NVTX_PAYLOAD_TYPE_INT32          = nvtxPayloadType(5), &
  NVTX_PAYLOAD_TYPE_FLOAT          = nvtxPayloadType(6)

! Something just for Fortran ease of use, C compat.
! The Fortran structure is bigger, but the first 48 bytes are the same
! Making it allocatable means it will get deallocated properly
type nvtxFtnStringType
  character(1), allocatable :: chars(:)
end type

! nvtxEventAttributes_v2, from nvToolsExt.h
type, bind(C):: nvtxEventAttributes
  integer(C_INT16_T)      :: version = NVTX_VERSION
  integer(C_INT16_T)      :: size = NVTX_EVENT_ATTRIB_STRUCT_SIZE
  integer(C_INT)          :: category = 0
  type(nvtxColorType)     :: colorType = NVTX_COLOR_ARGB
  integer(C_INT)          :: color = z'ffffffff'
  type(nvtxPayloadType)   :: payloadType = NVTX_PAYLOAD_UNKNOWN
  integer(C_INT)          :: reserved0
  integer(C_INT64_T)      :: payload  ! union uint,int,double
  type(nvtxMessageType)   :: messageType = NVTX_MESSAGE_TYPE_ASCII
  type(nvtxFtnStringType) :: message  ! ascii char
end type

! This module provides a type constructor for the nvtxEventAttributes type.
! For example:
! event = nvtxEventAttributes(message, color)
! message can be a Fortran character string, or
! an nvtx registered string.
! color is an optional argument, integer(C_INT), assigned to
! the color field

type nvtxRangeId
  integer(8) :: id
end type

type nvtxDomainHandle
  type(C_PTR) :: handle
end type

type nvtxStringHandle
  type(C_PTR) :: handle
end type

10.2.2. nvtxInitialize

此子例程强制 NVTX 库初始化。它可用于移动初始化开销以进行计时。它不接受任何参数。

subroutine nvtxInitialize()

10.2.3. nvtxDomainCreate

此函数创建一个新的命名 NVTX 域。每个域维护其自身的推送和弹出堆栈。

function nvtxDomainCreate(message) result(domain)
   character(len=*) :: message
   type(nvtxDomainHandle) :: domain

10.2.4. nvtxDomainDestroy

此子例程销毁一个 NVTX 域。

subroutine nvtxDomainDestroy(domain)
   type(nvtxDomainHandle) :: domain

10.2.5. nvtxDomainRegisterString

此函数向 NVTX 注册一个不可变字符串，用于 type(eventAttributes) 消息字段。

function nvtxDomainRegisterString(domain, message) &
  result(stringHandle)
  type(nvtxDomainHandle) :: domain
  character(len=*) :: message
  type(nvtxStringHandle) :: stringHandle

使用此模块中定义的重载赋值，用户可以使用以下两个语句启用注册的字符串

event%message = nvtxDomainRegisterString(domain, "Str 1")
event%messageType = NVTX_MESSAGE_TYPE_REGISTERED

也可以通过将注册的字符串传递给类型构造函数以及可选颜色来初始化 type(eventAttributes) 变量

regstr = nvtxDomainRegisterString(domain, "Str 2")
  event = nvtxEventAttributes(regstr, icolor)

10.2.6. nvtxDomainNameCategory

此子例程允许用户为特定于域的类别 ID 分配一个名称。

subroutine nvtxDomainNameCategory(domain, category, name)
  type(nvtxDomainHandle) :: domain
  integer(4) :: category
  character(len=*) :: name

10.2.7. nvtxNameCategory

此子例程允许用户为类别 ID 分配一个名称。

subroutine nvtxNameCategory(category, name)
  integer(4) :: category
  character(len=*) :: name

10.2.8. nvtxDomainMarkEx

此子例程在应用程序中标记一个瞬时事件，可以完全控制 NVTX 域和事件属性。

subroutine nvtxDomainMarkEx(domain, event)
  type(nvtxDomainHandle) :: domain
  type(nvtxEventAttributes) :: event

10.2.9. nvtxMarkEx

此子例程在应用程序中标记一个瞬时事件，并带有用户提供的 NVTX 事件属性。

subroutine nvtxMarkEx(event)
  type(nvtxEventAttributes) :: event

10.2.10. nvtxMark

此子例程在应用程序中标记一个瞬时事件，并带有用户提供的消息。

subroutine nvtxMark(message)
  character(len=*) :: message

10.2.11. nvtxDomainRangeStartEx

此函数在应用程序中启动一个进程范围，可以完全控制 NVTX 域和事件属性，并返回唯一的范围 ID。

function nvtxDomainRangeStartEx(domain, event) result(id)
  type(nvtxDomainHandle) :: domain
  type(nvtxEventAttributes) :: event
  type(nvtxRangeId) :: id

10.2.12. nvtxRangeStartEx

此函数在应用程序中启动一个进程范围，并带有用户提供的 NVTX 事件属性，并返回唯一的范围 ID。

function nvtxRangeStartEx(event) result(id)
  type(nvtxEventAttributes) :: event
  type(nvtxRangeId) :: id

10.2.13. nvtxRangeStart

此函数在应用程序中启动一个进程范围，并带有用户提供的消息，并返回唯一的范围 ID。

function nvtxRangeStart(message) result(id)
  character(len=*) :: message
  type(nvtxRangeId) :: id

10.2.14. nvtxDomainRangeEnd

此子例程结束应用程序中的进程范围。参数是先前调用 nvtxDomainRangeStartEx 中的域和范围 ID。

subroutine nvtxDomainRangeEnd(domain, id)
  type(nvtxDomainHandle) :: domain
  type(nvtxRangeId) :: id

10.2.15. nvtxRangeEnd

此子例程结束应用程序中的进程范围。参数是从先前调用任何 nvtxRangeStart 函数返回的范围 ID。

subroutine nvtxRangeEnd(id)
  type(nvtxRangeId) :: id

10.2.16. nvtxDomainRangePushEx

此函数在应用程序中启动一个嵌套线程范围，可以完全控制 NVTX 域和事件属性，并返回嵌套范围级别。

function nvtxDomainRangePushEx(domain, event) result(ilvl)
  type(nvtxDomainHandle) :: domain
  type(nvtxEventAttributes) :: event
  integer(4) :: ilvl

10.2.17. nvtxRangePushEx

此函数在应用程序中启动一个嵌套线程范围，并带有用户提供的事件属性，并返回嵌套范围级别。

function nvtxRangePushEx(event) result(ilvl)
  type(nvtxEventAttributes) :: event
  integer(4) :: ilvl

10.2.18. nvtxRangePush

此函数在应用程序中启动一个嵌套范围，并带有用户提供的消息，并返回正在启动的范围级别。

function nvtxRangePush(message) result(ilvl)
  character(len=*) :: message
  integer(4) :: ilvl

10.2.19. nvtxDomainRangePop

此函数结束应用程序中特定域内的嵌套线程范围。

function nvtxDomainRangePop(domain) result(ilvl)
  type(nvtxDomainHandle) :: domain
  integer(4) :: ilvl

10.2.20. nvtxRangePop

此函数结束应用程序中的嵌套线程范围，并返回正在结束的范围级别。

function nvtxRangePop() result(ilvl)
  integer(4) :: ilvl

10.3. NVTX 自动Instrumentation

本节介绍一种在不进行源代码更改的情况下自动将 NVIDIA 工具扩展 (NVTX) 范围插入到代码中的方法。此方法仅在 Linux 系统上受支持。

第一步是确定要查看 NVTX 标签的源文件。在构建过程中，为这些文件添加以下编译器选项

-Minstrument

此标准编译器选项指示编译器在生成的代码中插入两个调用：在子程序入口处，它将插入对 __cyg_profile_func_enter() 的调用，在子程序出口处，它将插入对 __cyg_profile_func_exit() 的调用。这些入口点旨在由性能分析工具提供。编译器插入到这些函数中的一个重要输入参数是函数地址。

下一步，为了获得最佳用户体验，请使用以下选项链接您的可执行文件

-traceback  -lnvhpcwrapnvtx

或者，也可以

-fPIC  -Wl,-export-dynamic  -lnvhpcwrapnvtx

这些选项将使运行时能够通过 dladdr() 系统调用将函数或子例程地址转换为符号。如果没有这些选项，标签将包含十六进制的子程序单元地址，这很有用，但确实需要一些其他手动处理步骤来确定关联的符号名称。

与所有 NVTX instrumentation 方法一样，您需要在运行时启用 NVTX API 调用的处理。使用 Nsight Systems 启用 NVTX 的一个示例是使用

nsys profile --trace=nvtx

这将导致 NVTX 时间跨度范围显示在 Nsight 时间轴上。目前，

--trace=nvtx

默认情况下已设置，因此只需指定

nsys profile ./a.out

将为您提供 NVTX 注释以及 CUDA 跟踪。

11. NVIDIA 通信抽象库 (CAL) API

本节介绍 CAL 库的 Fortran 接口。此库包含少量函数，这些函数与其他多处理器库结合使用，用于初始化用于处理分布式矩阵和数组的通信层。

通过添加以下行，可以在主机代码中公开本章中描述的 CAL 接口和定义

use nvf_cal_comm

到您的程序单元，但由于模块定义也在此文档的其他模块中使用，因此建议您通过更高级别的模块访问它们，例如

use cublasMp

或

use cusolverMp

.

11.1. CAL API

本节介绍 CAL 模块中定义的参数和派生类型。

! Definitions from cal.h
integer, parameter :: CAL_VER_MAJOR = 0
integer, parameter :: CAL_VER_MINOR = 4
integer, parameter :: CAL_VER_PATCH = 2
integer, parameter :: CAL_VER_BUILD = 0
integer, parameter :: CAL_VERSION = &
        (CAL_VER_MAJOR * 1000 + CAL_VER_MINOR * 100 + CAL_VER_PATCH)

enum, bind(c)
    enumerator :: CAL_OK = 0                       ! Success
    enumerator :: CAL_ERROR_INPROGRESS = 1         ! Request is in progress
    enumerator :: CAL_ERROR = 2                    ! Generic error
    enumerator :: CAL_ERROR_INVALID_PARAMETER = 3  ! Invalid parameter to the interface function.
    enumerator :: CAL_ERROR_INTERNAL = 4           ! Internal error
    enumerator :: CAL_ERROR_CUDA = 5               ! Error in CUDA runtime/driver API
    enumerator :: CAL_ERROR_UCC = 6                ! Error in UCC call
    enumerator :: CAL_ERROR_NOT_SUPPORTED = 7      ! Requested configuration not supported
end enum

! Types from cal.h
    TYPE cal_comm
      TYPE(C_PTR) :: handle
    END TYPE cal_comm

11.1.1. cal_comm_create_mpi

CAL 是 cublasMp 和其他多处理器库使用的通信库。它使用 MPI 进行初始化以及可能的其他用途。这是一个 Fortran 提供的便利函数，用于初始化 cal 通信器。由于依赖于 MPI，因此某些 cal Fortran 包装器的源代码随 NVHPC 软件包一起提供，并且可以使用应用程序中使用的 MPI 头文件进行构建。我们提供的版本适用于 NVHPC 软件包中捆绑的默认 MPI。此函数输出的 cal 通信器派生类型是 cublasMpGridCreate()、 cusolverMpCreateDeviceGrid() 和类似函数的输入。

integer(4) function cal_comm_create_mpi(mpi_comm, &
      rank, nranks, local_device, comm)
  integer(4), intent(in) :: mpi_comm, rank, nranks, local_device
  type(cal_comm), intent(out) :: comm

11.1.2. cal_comm_destroy

此函数销毁 cal_comm 数据结构并释放与其关联的资源。

integer(4) function cal_comm_destroy(comm)
  type(cal_comm) :: comm

11.1.3. cal_stream_sync

此函数会阻塞调用线程，直到指定 stream 中所有未完成的设备操作（包括 cal 操作）完成。

integer(4) function cal_stream_sync(comm, stream)
  type(cal_comm) :: comm
  integer(cuda_stream_kind) :: stream

11.1.4. cal_comm_barrier

此函数同步 cal 通信器中所有进程的流，基本上是全对全同步。

integer(4) function cal_comm_barrier(comm, stream)
  type(cal_comm) :: comm
  integer(cuda_stream_kind) :: stream

11.1.5. cal_comm_get_rank

此函数返回 CAL 通信器中调用线程的 rank。

integer(4) function cal_comm_get_rank(comm, rank)
  type(cal_comm) :: comm
  integer(4) :: rank

11.1.6. cal_comm_get_size

此函数返回 CAL 通信器的大小。

integer(4) function cal_comm_get_size(comm, size)
  type(cal_comm) :: comm
  integer(4) :: size

12. 示例

本节包含带有源代码的示例。

12.1. 从 OpenACC 主机代码使用 cuBLAS

此示例演示了如何从 OpenACC 数据区域使用 cublas 模块、cublasHandle 类型和多种形式的 blas 调用。

简单的 OpenACC BLAS 测试

program testcublas
! compile with pgfortran -ta=tesla -cudalib=cublas -cuda testcublas.f90
call testcu1(1000)
call testcu2(1000)
end
!
subroutine testcu1(n)
use openacc
use cublas
integer :: a(n), b(n)
type(cublasHandle) :: h
istat = cublasCreate(h)
! Force OpenACC kernels and cuBLAS to use the OpenACC stream.
istat = cublasSetStream(h, acc_get_cuda_stream(acc_async_sync))
!$acc data copyout(a, b)
!$acc kernels
a = 1
b = 2
!$acc end kernels
! No host_data, we are lexically inside a data region
! sswap will accept any kind(4) data type
call sswap(n, a, 1, b, 1)
call cublasSswap(n, a, 1, b, 1)
!$acc end data
if (all(a.eq.1).and.all(b.eq.2)) then
  print *,"Test PASSED"
else
  print *,"Test FAILED"
endif
end
!
subroutine testcu2(n)
use openacc
use cublas
real(8) :: a(n), b(n)
a = 1.0d0
b = 2.0d0
!$acc data copy(a, b)
!$acc host_data use_device(a,b)
call dswap(n, a, 1, b, 1)
call cublasDswap(n, a, 1, b, 1)
!$acc end host_data
!$acc end data
if (all(a.eq.1.0d0).and.all(b.eq.2.0d0)) then
  print *,"Test PASSED"
else
  print *,"Test FAILED"
endif
end

CUBLASXT BLAS 测试

此示例演示了 cublasxt 模块的使用

program testcublasxt
call testxt1(1000)
call testxt2(1000)
end
!
subroutine testxt1(n)
use cublasxt
real(4) :: a(n,n), b(n,n), c(n,n), alpha, beta
type(cublasXtHandle) :: h
integer ndevices(1)
a = 1.0
b = 2.0
c = -1.0
alpha = 1.0
beta = 0.0
istat = cublasXtCreate(h)
if (istat .ne. CUBLAS_STATUS_SUCCESS) print *,istat
ndevices(1) = 0
istat = cublasXtDeviceSelect(h, 1, ndevices)
if (istat .ne. CUBLAS_STATUS_SUCCESS) print *,istat
istat = cublasXtSgemm(h, CUBLAS_OP_N, CUBLAS_OP_N, &
                      n, n, n, &
                      alpha, A, n, B, n, beta, C, n)
if (istat .ne. CUBLAS_STATUS_SUCCESS) print *,istat
istat = cublasXtDestroy(h)
if (istat .ne. CUBLAS_STATUS_SUCCESS) print *,istat
if (all(c.eq.2.0*n)) then
  print *,"Test PASSED"
else
  print *,"Test FAILED"
endif
print *,c(1,1),c(n,n)
end
!
subroutine testxt2(n)
use cublasxt
real(8) :: a(n,n), b(n,n), c(n,n), alpha, beta
type(cublasXtHandle) :: h
integer ndevices(1)
a = 1.0d0
b = 2.0d0
c = -1.0d0
alpha = 1.0d0
beta = 0.0
istat = cublasXtCreate(h)
if (istat .ne. CUBLAS_STATUS_SUCCESS) print *,istat
ndevices(1) = 0
istat = cublasXtDeviceSelect(h, 1, ndevices)
if (istat .ne. CUBLAS_STATUS_SUCCESS) print *,istat
istat = cublasXtDgemm(h, CUBLAS_OP_N, CUBLAS_OP_N, &
                      n, n, n, &
                      alpha, A, n, B, n, beta, C, n)
if (istat .ne. CUBLAS_STATUS_SUCCESS) print *,istat
istat = cublasXtDestroy(h)
if (istat .ne. CUBLAS_STATUS_SUCCESS) print *,istat
if (all(c.eq.2.0d0*n)) then
  print *,"Test PASSED"
else
  print *,"Test FAILED"
endif
print *,c(1,1),c(n,n)
end

12.2. 从 CUDA Fortran 主机代码使用 cuBLAS

此示例演示了 cublas 模块、cublasHandle 类型和多种形式的 blas 调用的使用。

简单的 BLAS 测试

program testisamax
! Compile with "pgfortran testisamax.cuf -cudalib=cublas -lblas"
! Use the NVIDIA cudafor and cublas modules
use cudafor
use cublas
!
real*4, device, allocatable :: xd(:)
real*4 x(1000)
integer, device :: kd
type(cublasHandle) :: h

call random_number(x)

! F90 way
i = maxloc(x,dim=1)
print *,i
print *,x(i-1),x(i),x(i+1)

! Host way
j = isamax(1000,x,1)
print *,j
print *,x(j-1),x(j),x(j+1)

! CUDA Generic BLAS way
allocate(xd(1000))
xd = x
k = isamax(1000,xd,1)
print *,k
print *,x(k-1),x(k),x(k+1)

! CUDA Specific BLAS way
k = cublasIsamax(1000,xd,1)
print *,k
print *,x(k-1),x(k),x(k+1)

! CUDA V2 Host Specific BLAS way
istat = cublasCreate(h)
if (istat .ne. 0) print *,"cublasCreate returned ",istat
k = 0
istat = cublasIsamax_v2(h, 1000, xd, 1, k)
if (istat .ne. 0) print *,"cublasIsamax 1 returned ",istat
print *,k
print *,x(k-1),x(k),x(k+1)

! CUDA V2 Device Specific BLAS way
k = 0
istat = cublasIsamax_v2(h, 1000, xd, 1, kd)
if (istat .ne. 0) print *,"cublasIsamax 2 returned ",istat
k = kd
print *,k
print *,x(k-1),x(k),x(k+1)

istat = cublasDestroy(h)
if (istat .ne. 0) print *,"cublasDestroy returned ",istat

end program

多线程 BLAS 测试

此示例演示了如何在多线程代码中使用 cublas 模块。每个线程将连接到不同的 GPU，创建一个上下文，并在最后合并结果。

program tsgemm
!
! Multi-threaded example calling sgemm from cuda fortran.
! Compile with "pgfortran -mp tsgemm.cuf -cudalib=cublas"
! Set OMP_NUM_THREADS=number of GPUs in your system.
!
use cublas
use cudafor
use omp_lib
!
! Size this according to number of GPUs
!
! Small
!integer, parameter :: K = 2500
!integer, parameter :: M = 2000
!integer, parameter :: N = 2000
! Large
integer, parameter :: K = 10000
integer, parameter :: M = 10000
integer, parameter :: N = 10000
integer, parameter :: NTIMES = 10
!
real*4, device, allocatable :: a_d(:,:), b_d(:,:), c_d(:,:)
!$omp THREADPRIVATE(a_d,b_d,c_d)
real*4 a(m,k), b(k,n), c(m,n)
real*4 alpha, beta
integer, allocatable :: offs(:)
type(cudaEvent) :: start, stop

a = 1.0; b = 0.0; c = 0.0
do i = 1, N
  b(i,i) = 1.0
end do
alpha = 1.0; beta  = 1.0

! Break up the B and C array into sections
nthr = omp_get_max_threads()
nsec = N / nthr
print *,"Running with ",nthr," threads, each section = ",nsec
allocate(offs(nthr))
offs = (/ (i*nsec,i=0,nthr-1) /)

! Allocate and initialize the arrays
! Each thread connects to a device and creates a CUDA context.
!$omp PARALLEL private(i,istat)
    i = omp_get_thread_num() + 1
    istat = cudaSetDevice(i-1)
    allocate(a_d(M,K), b_d(K,nsec), c_d(M,nsec))
    a_d = a
    b_d = b(:,offs(i)+1:offs(i)+nsec)
    c_d = c(:,offs(i)+1:offs(i)+nsec)
!$omp end parallel

istat = cudaEventCreate(start)
istat = cudaEventCreate(stop)

time = 0.0
istat = cudaEventRecord(start, 0)
! Run the traditional blas kernel
!$omp PARALLEL private(j,istat)
    do j = 1, NTIMES
      call sgemm('n','n', M, N/nthr, K, alpha, a_d, M, b_d, K, beta, c_d, M)
    end do
    istat = cudaDeviceSynchronize()
!$omp end parallel

istat = cudaEventRecord(stop, 0)
istat = cudaEventElapsedTime(time, start, stop)
time = time / (NTIMES*1.0e3)
!$omp PARALLEL private(i)
    i = omp_get_thread_num() + 1
    c(:,offs(i)+1:offs(i)+nsec) = c_d
!$omp end parallel
nerrors = 0
do j = 1, N
    do i = 1, M
        if (c(i,j) .ne. NTIMES) nerrors = nerrors + 1
    end do
end do
print *,"Number of Errors:",nerrors
gflops = 2.0 * N * M * K/time/1e9
write (*,901) m,k,k,N,time*1.0e3,gflops
901 format(i0,'x',i0,' * ',i0,'x',i0,':\t',f8.3,' ms\t',f12.3,' GFlops/s')
end

12.3. 从 OpenACC 主机代码使用 cuFFT

此示例演示了 cufft 模块、cufftHandle 类型和多个 cuFFT 库调用的使用。

简单的 cuFFT 测试

program cufft2dTest
  use cufft
  use openacc
  integer, parameter :: m=768, n=512
  complex, allocatable  :: a(:,:),b(:,:),c(:,:)
  real, allocatable     :: r(:,:),q(:,:)
  integer :: iplan1, iplan2, iplan3, ierr

  allocate(a(m,n),b(m,n),c(m,n))
  allocate(r(m,n),q(m,n))

  a = 1; r = 1
  xmx = -99.0

  ierr = cufftPlan2D(iplan1,n,m,CUFFT_C2C)
  ierr = ierr + cufftSetStream(iplan1,acc_get_cuda_stream(acc_async_sync))
  !$acc host_data use_device(a,b,c)
  ierr = ierr + cufftExecC2C(iplan1,a,b,CUFFT_FORWARD)
  ierr = ierr + cufftExecC2C(iplan1,b,c,CUFFT_INVERSE)
  !$acc end host_data

  ! scale c
  !$acc kernels
  c = c / (m*n)
  !$acc end kernels

  ! Check forward answer
  write(*,*) 'Max error C2C FWD: ', cmplx(maxval(real(b)) - sum(real(b)), &
                                          maxval(imag(b)))
  ! Check inverse answer
  write(*,*) 'Max error C2C INV: ', maxval(abs(a-c))

  ! Real transform
  ierr = ierr + cufftPlan2D(iplan2,n,m,CUFFT_R2C)
  ierr = ierr + cufftPlan2D(iplan3,n,m,CUFFT_C2R)
  ierr = ierr + cufftSetStream(iplan2,acc_get_cuda_stream(acc_async_sync))
  ierr = ierr + cufftSetStream(iplan3,acc_get_cuda_stream(acc_async_sync))

  !$acc host_data use_device(r,b,q)
  ierr = ierr + cufftExecR2C(iplan2,r,b)
  ierr = ierr + cufftExecC2R(iplan3,b,q)
  !$acc end host_data

  !$acc kernels
  xmx = maxval(abs(r-q/(m*n)))
  !$acc end kernels

  ! Check R2C + C2R answer
  write(*,*) 'Max error R2C/C2R: ', xmx

  ierr = ierr + cufftDestroy(iplan1)
  ierr = ierr + cufftDestroy(iplan2)
  ierr = ierr + cufftDestroy(iplan3)

  if (ierr.eq.0) then
    print *,"test PASSED"
  else
    print *,"test FAILED"
  endif

end program cufft2dTest

12.4. 从 CUDA Fortran 主机代码使用 cuFFT

此示例演示了 cuFFT 模块、cufftHandle 类型和多个 cuFFT 库调用的使用。

简单的 cuFFT 测试

program cufft2dTest
  use cudafor
  use cufft
  implicit none
  integer, parameter :: m=768, n=512
  complex, managed :: a(m,n),b(m,n)
  real, managed :: ar(m,n),br(m,n)
  real    x
  integer plan, ierr
  logical passing

  a = 1; ar = 1

  ierr = cufftPlan2D(plan,n,m,CUFFT_C2C)
  ierr = ierr + cufftExecC2C(plan,a,b,CUFFT_FORWARD)
  ierr = ierr + cufftExecC2C(plan,b,b,CUFFT_INVERSE)
  ierr = ierr + cudaDeviceSynchronize()
  x = maxval(abs(a-b/(m*n)))
  write(*,*) 'Max error C2C: ', x
  passing = x .le. 1.0e-5

  ierr = ierr + cufftPlan2D(plan,n,m,CUFFT_R2C)
  ierr = ierr + cufftExecR2C(plan,ar,b)
  ierr = ierr + cufftPlan2D(plan,n,m,CUFFT_C2R)
  ierr = ierr + cufftExecC2R(plan,b,br)
  ierr = ierr + cudaDeviceSynchronize()
  x = maxval(abs(ar-br/(m*n)))
  write(*,*) 'Max error R2C/C2R: ', x
  passing = passing .and. (x .le. 1.0e-5)

  ierr = ierr + cufftDestroy(plan)
  print *,ierr
  passing = passing .and. (ierr .eq. 0)
  if (passing) then
    print *,"Test PASSED"
  else
    print *,"Test FAILED"
  endif
end program cufft2dTest

12.5. 从 CUDA Fortran 主机代码使用 cufftXt

此示例演示了 cufftXt 模块、cudaLibXtDesc 类型、许多 cufftXt API 调用、实/复数 FFT 所需的填充以及跨多个 GPU 的活动模式分布的使用。

简单的 Poisson 3D CufftXt 测试

program cufftXt3DTest
  use cudafor
  use cufftXt   ! cufftXt module includes cufft
  implicit none

  integer, parameter :: nGPUs = 2
  integer, parameter :: M = 1, N = 1, P = 1
  integer, parameter :: nx = 32, ny=32, nz=32
  real, parameter :: twopi = 8.0*atan(1.0)
  real, parameter :: Lx = 1.0, Ly = 1.0, Lz = 1.0
  logical, parameter :: printModes = .true.

  ! GPU
  integer :: nodeGPUs
  integer :: whichGPUs(nGPUs)

  ! grid
  real :: x(nx), y(ny), z(nz)
  real :: hx, hy, hz

  ! wavenumbers
  real :: kx(nx/2+1), ky(ny), kz(nz)
  type realDeviceArray
     real, device, allocatable :: v(:)
  end type realDeviceArray
  type(realDeviceArray) :: kx_da(nGPUs), ky_da(nGPUs), kz_da(nGPUs)

  real :: phi(nx+2,ny, nz), u(nx+2,ny,nz), ua(nx,ny,nz)
  integer :: status, i, j, k

  ! check M, N

  if (M==0 .or. N==0 .or. P==0) then
     write(*,*) 'M, N or P is 0 thus solution is u=0'
     stop
  else
     write(*,"(' Running with modes M, N, P = ', i0, ', ', i0, ', ', i0)") M, N, P
     write(*,"('  on a grid of ', i0, 'x', i0, 'x', i0)") nx, ny, nz
  end if

  ! choose GPUs

  ! check for multiple GPUs
  status = cudaGetDeviceCount(nodeGPUs)
  if (status /= cudaSuccess) write(*,*) 'Error in cudaGetDeviceCount()'
  if (nodeGPUs .lt. nGPUs) then
     write(*,*) 'Number of GPUs on node:', nodeGPUs
     write(*,*) 'Insufficient number of GPUs for this code, exiting ...'
     stop
  end if

  ! check for GPUs of same compute capability
  block
    type(cudaDeviceProp) :: prop
    integer :: cc(0:nodeGPUs-1,2)
    logical :: foundIdenticalGPUs = .false.
    integer :: iWG, nIdentGPUs

    write(*,*) 'Available devices:'
    do i = 0, nodeGPUs-1
       status = cudaGetDeviceProperties(prop, i)
       if (status /= cudaSuccess) write(*,*) 'Error in cudaGetDeviceProperties()'
       cc(i,1) = prop%major
       cc(i,2) = prop%minor
       write(*,"('  ', i0, ' CC: ', i0, '.', i0)") i, cc(i,1), cc(i,2)
    enddo

    do i = 0, nodeGPUs-1
       nIdentGPUs = 1
       do j = i+1, nodeGPUs
          if (all(cc(i,:) == cc(j,:))) nIdentGPUs = nIdentGPUs+1
       enddo

       if (nIdentGPUs .ge. nGPUs) then
          foundIdenticalGPUs = .true.
          iWG = 1
          whichGPUs(iWG) = i
          do j = i+1, nodeGPUs-1
             if (all(cc(i,:) == cc(j,:))) then
                iWG = iWG+1
                whichGPUs(iWG) = j
             end if
             if (iWG == nGPUs) exit
          end do
          exit
       end if
    end do

    if (foundIdenticalGPUS) then
       write(*,*) 'Running on GPUs:'
       write(*,*) whichGPUs
    else
       write(*,"(' No ', i0, ' identical GPUs found, exiting ...')"), nGPUs
       stop
    end if

  end block

  ! Physical grid

  hx = Lx/nx
  do i = 1, nx
     x(i) = hx*i
  enddo

  hy = Ly/ny
  do j = 1, ny
     y(j) = hy*j
  enddo

  hz = Lz/nz
  do k = 1, nz
     z(k) = hz*k
  enddo

  ! Wavenumbers

  do i = 1, nx/2+1
     kx(i) = (i-1)*(twoPi/Lx)
  enddo

  do j = 1, ny/2
     ky(j) = (j-1)*(twoPi/Ly)
  enddo
  do j = ny/2+1, ny
     ky(j) = (j-1-ny)*(twoPi/Ly)
  enddo

  do k = 1, nz/2
     kz(k) = (k-1)*(twoPi/Lz)
  enddo
  do k = nz/2+1, nz
     kz(k) = (k-1-nz)*(twoPi/Lz)
  enddo

  ! copy wavenumber arrays to each device
  do i = 1, nGPUs
     status = cudaSetDevice(whichGPUs(i))
     allocate(kx_da(i)%v, source=kx)
     allocate(ky_da(i)%v, source=ky)
     allocate(kz_da(i)%v, source=kz)
  enddo

  ! Initialize phi and get analytical solution

  do k = 1, nz
     do j = 1, ny
        do i = 1, nx
           phi(i,j,k) = sin(twoPi*M*x(i))*sin(twoPi*N*y(j))*sin(twoPi*P*z(k))
           ua(i,j,k) = -phi(i,j,k)/((twoPi*M)**2 + (twoPi*N)**2 + (twoPi*P)**2)
        enddo
     enddo
  end do

  ! cufft block

  block
    integer :: planR2C, planC2R
    integer(c_size_t) :: worksize(nGPUs)
    type(cudaLibXtDesc), pointer :: phi_desc

    status = cufftCreate(planR2C)
    if (status /= CUFFT_SUCCESS) write(*,*) 'Error in cufftCreate'

    status = cufftCreate(planC2R)
    if (status /= CUFFT_SUCCESS) write(*,*) 'Error in cufftCreate'

    status = cufftXtSetGPUs(planR2C, nGPUs, whichGPUs)
    if (status /= CUFFT_SUCCESS) write(*,*) 'cufftXtSetGPUs failed'

    status = cufftXtSetGPUs(planC2R, nGPUs, whichGPUs)
    if (status /= CUFFT_SUCCESS) write(*,*) 'cufftXtSetGPUs failed'

    status = cufftMakePlan3d(planR2C, nz, ny, nx, CUFFT_R2C, worksize)
    if (status /= CUFFT_SUCCESS) write(*,*) 'Error in cufftMakePlan2d'

    status = cufftMakePlan3d(planC2R, nz, ny, nx, CUFFT_C2R, worksize)
    if (status /= CUFFT_SUCCESS) write(*,*) 'Error in cufftMakePlan2d'

    ! allocate memory on seperate devices
    status = cufftXtMalloc(planR2C, phi_desc, CUFFT_XT_FORMAT_INPLACE)
    if (status /= CUFFT_SUCCESS) write(*,*) 'cufftXtMalloc failed'

    ! H2D transfer
    write(*,*) 'cufftXtMemcpy H2D ...'
    status = cufftXtMemcpy(planR2C, phi_desc, phi, CUFFT_COPY_HOST_TO_DEVICE)
    if (status /= CUFFT_SUCCESS) write(*,*) 'cufftXtMemcpy H2D failed'

    ! forward FFT
    write(*,*) 'Forward transform ...'
    status = cufftXtExecDescriptorR2C(planR2C, phi_desc, phi_desc)
    if (status /= CUFFT_SUCCESS) write(*,*) 'cufftXtExecDescriptorR2C failed:', status

    if (printModes) then
       block
         real :: threshold = 1.e-3
         type(cudaXtDesc), pointer :: phiXtDesc
         complex, device, pointer :: phi_d(:,:,:)
         integer :: dev, g, jl, nyl
         complex :: phi_h(nx/2+1, ny, nz)

         call c_f_pointer(phi_desc%descriptor, phiXtDesc)

         do g = 1, nGPUs
            write(*,"(' Active modes on g = ', i0)") g
            dev = phiXtDesc%GPUs(g)
            status = cudaSetDevice(dev)
            if (status /= cudaSuccess) write(*,*) 'cudaSetDevice failed'

            ! XtMalloc done with FORMAT_INPLACE, so data prior to transform
            ! are in natural order (split in least frequently changing index,
            ! in this case z), and after transform are in shuffled order (split in
            ! second least frequently changing index, in this case y)

            nyl = ny/nGPUs
            if (g .le. mod(ny, nGPUs)) nyl = nyl+1

            call c_f_pointer(phiXtDesc%data(g), phi_d, [nx/2+1, nyl, nz])

            !$cuf kernel do (3)
            do k = 1, nz
               do jl = 1, nyl
                  do i = 1, nx/2+1
                     if (abs(phi_d(i,jl,k)) .gt. threshold) print*, i, jl, k, phi_d(i,jl,k)
                  enddo
               enddo
            enddo
            status = cudaDeviceSynchronize()
            call flush()
         end do

         status = cufftXtMemcpy(planR2C, phi_h, phi_desc, CUFFT_COPY_DEVICE_TO_HOST)
         if (status /= CUFFT_SUCCESS) write(*,*) 'cufftXtMemcpy D2H failed'
         write(*,*) 'Active modes on host (after D2H):'
         do k = 1, nz
            do j = 1, ny
               do i = 1, nx/2+1
                  if (abs(phi_h(i,j,k)) .gt. threshold) print*, i, j, k, phi_h(i,j,k)
               end do
            end do
         enddo
       end block
    end if

    ! solve Poisson equation
    write(*,*) 'Solve Poisson Eq ...'
    block
      type(cudaXtDesc), pointer :: phiXtDesc
      complex, device, pointer :: phi_d(:,:,:)
      integer :: dev, g, jl, nyl, yOffset
      real :: k2

      call c_f_pointer(phi_desc%descriptor, phiXtDesc)

      yOffset = 0
      do g = 1, nGPUs
         dev = phiXtDesc%GPUs(g)
         status = cudaSetDevice(dev)
         if (status /= cudaSuccess) write(*,*) 'cudaSetDevice failed'

         ! XtMalloc done with FORMAT_INPLACE, so data prior to transform
         ! are in natural order (split in least frequently changing index,
         ! in this case z), and after transform are in shuffled order (split in
         ! second least frequently changing index, in this case y)

         nyl = ny/nGPUs
         if (g .le. mod(ny, nGPUs)) nyl = nyl+1

         call c_f_pointer(phiXtDesc%data(g), phi_d, [nx/2+1, nyl, nz])

         associate(kx_d => kx_da(g)%v, ky_d => ky_da(g)%v, kz_d => kz_da(g)%v)
           !$cuf kernel do (3)
           do k = 1, nz
              do jl = 1, nyl
                 j = jl + yOffset
                 do i = 1, nx/2+1
                    k2 = kx_d(i)**2 + ky_d(j)**2 + kz_d(k)**2
                    phi_d(i,jl,k) = -phi_d(i,jl,k)/k2/(nx*ny*nz)
                 enddo
              enddo
           enddo
         end associate

         ! specify mean (corrects division by zero wavenumber above)
         if (g == 1) phi_d(1,1,1) = 0.0

         yOffset = yOffset + nyl
      end do

      do g = 1, nGPUs
         dev = phiXtDesc%GPUs(g)
         status = cudaSetDevice(dev)
         if (status /= cudaSuccess) write(*,*) 'cudaSetDevice failed'
         status = cudaDeviceSynchronize()
         if (status /= cudaSuccess) write(*,*) 'CUF kernel sync error'
      end do

    end block ! poisson

    ! inverse FFT
    write(*,*) 'Inverse transform ...'
    status = cufftXtExecDescriptorC2R(planC2R, phi_desc, phi_desc)
    if (status /= CUFFT_SUCCESS) write(*,*) 'cufftXtExecDescriptorC2R failed'

    ! D2H transfer
    write(*,*) 'cufftXtMemcpy D2H ...'
    status = cufftXtMemcpy(planC2R, u, phi_desc, CUFFT_COPY_DEVICE_TO_HOST)
    if (status /= CUFFT_SUCCESS) write(*,*) 'cufftXtMemcpy D2H failed'

    ! cufft block cleanup
    status = cufftXtFree(phi_desc)
    if (status /= CUFFT_SUCCESS) write(*,*) 'cufftXtFree failed'

    status = cufftDestroy(planR2C)
    if (status /= CUFFT_SUCCESS) write(*,*) 'cufftXtFree failed'

    status = cufftDestroy(planC2R)
    if (status /= CUFFT_SUCCESS) write(*,*) 'cufftXtFree failed'

  end block

  write(*,*) 'Max error: ', maxval(abs(u(1:nx,1:ny,1:nz)-ua(1:nx,1:ny,1:nz)))

  ! cleanup

  do i = 1, nGPUs
     status = cudaSetDevice(whichGPUs(i))
     deallocate(kx_da(i)%v, ky_da(i)%v, kz_da(i)%v)
  enddo

  write(*,*) '... finished'

end program cufftXt3DTest

12.6. 从 OpenACC 或 CUDA Fortran 使用 cuFFTMp

此示例演示了如何从 cuFFTXt 模块使用 cuFFTMp API、cudaLibXtDesc 和 cudaXtDesc 类型，以及将 MPI COMM 附加到 cuFFT 计划。

实数到复数和复数到实数 cuFFTMp 测试

!
! This samples illustrates a basic use of cuFFTMp using the built-in, optimized,
! data distributions.
!
!  It assumes the CPU data is initially distributed according to
!  CUFFT_XT_FORMAT_INPLACE, a.k.a. X-Slabs.
!  Given a global array of size X!  Y!  Z, every MPI rank owns approximately
!  (X / ngpus)!  Y*Z entries.
!  More precisely,
!  - The first (ngpus % X) MPI rank each own (X/ngpus+1) planes of size Y*Z,
!  - The remaining MPI rank each own (X / ngpus) planes of size Y*Z
!
!  The CPU data is then copied on GPU and a forward transform is applied.
!
!  After that transform, GPU data is distributed according to
!  CUFFT_XT_FORMAT_INPLACE_SHUFFLED, a.k.a. Y-Slabs.
!  Given a global array of size X * Y * Z, every MPI rank owns approximately
!  X * (Y / ngpus) * Z entries.
!  More precisely,
!  - The first (ngpus % Y) MPI rank each own (Y/ngpus+1) planes of size X*Z,
!  - The remaining MPI rank each own (Y / ngpus) planes of size X*Z
!
!  A scaling kerel is applied, on the distributed GPU data (distributed
!  according to CUFFT_XT_FORMAT_INPLACE)
!  This kernel prints some elements to illustrate the
!  CUFFT_XT_FORMAT_INPLACE_SHUFFLED data distribution and normalize entries
!  by (nx * ny * nz)
!
!  Finally, a backward transform is applied.
!  After this, data is again distributed according to CUFFT_XT_FORMAT_INPLACE,
!  same as the input data.
!
!  Data is finally copied back to CPU and compared to the input data. They
!  should be almost identical.
!
!  This program can be used by either OpenACC or CUDA Fortran:
!    mpif90 -acc cufftmp_r2c.F90 -cudalib=cufftmp
!  Or:
!    mpif90 -cuda cufftmp_r2c.F90 -cudalib=cufftmp
!
module cufft_required
    integer :: planr2c, planc2r
    integer :: local_rshape(3), local_rshape_permuted(3)
    integer :: local_permuted_cshape(3)
end module cufft_required

program cufftmp_r2c
    use iso_c_binding
    use cufftXt
    use cufft
!@cuf use cudafor
!@acc use openacc
    use mpi
    use cufft_required
    implicit none

    integer :: size, rank, ndevices, ierr
    integer :: nx, ny, nz ! nx slowest
    integer :: i, j, k
    integer :: my_nx, my_ny, my_nz, ranks_cutoff, whichgpu(1)
    real, dimension(:, :, :), allocatable :: u, ref
    complex, dimension(:,:,:), allocatable :: u_permuted
    real :: max_norm, max_diff

    ! cufft stuff
    integer(c_size_t) :: worksize(1)
    type(cudaLibXtDesc), pointer :: u_desc
    type(cudaXtDesc), pointer    :: u_descptr
#ifdef _OPENACC
    complex, pointer             :: u_dptr(:,:,:)
    type(c_ptr)                  :: tmpcptr
#else
    complex, pointer, device     :: u_dptr(:,:,:)
#endif

    call mpi_init(ierr)
    call mpi_comm_size(MPI_COMM_WORLD,size,ierr)
    call mpi_comm_rank(MPI_COMM_WORLD,rank,ierr)

#ifdef _OPENACC
    ndevices = acc_get_num_devices(acc_device_nvidia)
    call acc_set_device_num(mod(rank, ndevices), acc_device_nvidia)
#else
    call checkCuda(cudaGetDeviceCount(ndevices))
    call checkCuda(cudaSetDevice(mod(rank, ndevices)))
#endif
    whichgpu(1) = mod(rank, ndevices)

    print*,"Hello from rank ",rank," gpu id",mod(rank,ndevices),"size",size

    nx = 256
    ny = nx
    nz = nx

    ! We start with X-Slabs
    ! Ranks 0 ... (nx % size - 1) have 1 more element in the X dimension
    ! and every rank own all elements in the Y and Z dimensions.
    ranks_cutoff = mod(nx, size)
    my_nx = nx / size
    if (rank < ranks_cutoff) my_nx = my_nx + 1
    my_ny =  ny;
    my_nz =  nz;
    ! Note nz is first dimension, nx third
    local_rshape = [2*(nz/2+1), ny, my_nx]
    local_permuted_cshape = [nz/2+1, ny/size, nx]
    local_rshape_permuted = [2*(nz/2+1), ny/size, nx]
    if (mod(ny, size) > 0) then
        print*," ny has to divide evenly by mpi_procs"
        call mpi_finalize(ierr)
    end if
    if (rank == 0) then
        write(*,*) "local_rshape          :", local_rshape(1:3)
        write(*,*) "local_permuted_cshape :", local_permuted_cshape(1:3)
    end if

    ! Generate local, distributed data
    allocate(u(local_rshape(1), local_rshape(2), local_rshape(3)))
    allocate(u_permuted(local_permuted_cshape(1), local_permuted_cshape(2), &
        local_permuted_cshape(3)))
    allocate(ref(local_rshape(1), local_rshape(2), local_rshape(3)))
    print*,'shape of u is ', shape(u)
    print*,'shape of u_permuted is ', shape(u_permuted)
    call generate_random(nz, local_rshape(1), local_rshape(2), &
        local_rshape(3), u)
    ref = u
    u_permuted = (0.0,0.0)

    call checkNorm(nz, local_rshape(1), local_rshape(2), local_rshape(3), &
        u, max_norm)
    print*, "initial data on ", rank, " max_norm is ", max_norm

    call checkCufft(cufftCreate(planr2c))
    call checkCufft(cufftCreate(planc2r))
    call checkCufft(cufftMpAttachComm(planr2c, CUFFT_COMM_MPI, &
        MPI_COMM_WORLD), 'cufftMpAttachComm error')
    call checkCufft(cufftMpAttachComm(planc2r, CUFFT_COMM_MPI, &
        MPI_COMM_WORLD), 'cufftMpAttachComm error')

    ! Note nx, ny, nz order
    call checkCufft(cufftMakePlan3d(planr2c, nx, ny, nz, CUFFT_R2C, &
        worksize), 'cufftMakePlan3d r2c error')
    call checkCufft(cufftMakePlan3d(planc2r, nx, ny, nz, CUFFT_C2R, &
        worksize), 'cufftMakePlan3d c2r error')

    call checkCufft(cufftXtMalloc(planr2c, u_desc, &
        CUFFT_XT_FORMAT_INPLACE), 'cufftXtMalloc error')

    ! These are equivalent, and work as well
    ! istat = cufftXtMemcpy(planr2c, u_desc, u, CUFFT_COPY_HOST_TO_DEVICE)
    ! call cufft_memcpyH2D(u_desc, u, CUFFT_XT_FORMAT_INPLACE, .false.)
    call cufft_memcpyH2D(u_desc, u, CUFFT_XT_FORMAT_INPLACE, .true.)

    ! now reset u to make sure the check later is valid
    u = 0.0

    !xxxxxxxxxxxxxxxxxxxxxxxxxx Forward
    call checkCufft(cufftXtExecDescriptor(planr2c, u_desc, u_desc, &
        CUFFT_FORWARD),'forward fft failed')

    ! in case we want to check the results after Forward
    !call checkCufft(cufftXtMemcpy(planr2c, u_permuted, u_desc, CUFFT_COPY_DEVICE_TO_HOST), 'permuted D2H error')
    !call checkNormComplex(local_permuted_cshape(1), local_permuted_cshape(2), local_permuted_cshape(3), u_permuted, max_norm)
    !write(*,'(A18, I1, A14, F25.8)') "after R2C ", rank, " max_norm is ", max_norm

    ! Data is now distributed as Y-Slab. We need to scale the output
    call c_f_pointer(u_desc%descriptor, u_descptr)

#ifdef _OPENACC
    tmpcptr = transfer(u_descptr%data(1), tmpcptr)
    call c_f_pointer(tmpcptr, u_dptr, local_permuted_cshape(1:3))

    call scalingData(local_permuted_cshape(1), local_permuted_cshape(2), &
        local_permuted_cshape(3), u_dptr, real(nx*ny*nz))
#else
    call c_f_pointer(u_descptr%data(1), u_dptr, local_permuted_cshape(1:3))
    !$cuf kernel do (3)
    do k =1, local_permuted_cshape(3)
        do j = 1, local_permuted_cshape(2)
            do i = 1, local_permuted_cshape(1)
                u_dptr(i,j,k) = u_dptr(i,j,k) / real(nx*ny*nz)
            end do
        end do
    end do
    call checkCuda(cudaDeviceSynchronize())
#endif

    ! in case we want to check again after scaling
    call checkCufft(cufftXtMemcpy(planr2c, u_permuted, u_desc, &
        CUFFT_COPY_DEVICE_TO_HOST), 'permuted D2H error')
    call checkNormComplex(local_permuted_cshape(1), &
        local_permuted_cshape(2), local_permuted_cshape(3), &
        u_permuted, max_norm)
    write(*,'(A18, I1, A14, F25.8)') "after scaling ", rank, &
        " max_norm is ", max_norm

    !xxxxxxxxxxxxxxxxxxxxxxxxxxxx inverse
    call checkCufft(cufftXtExecDescriptor(planc2r, u_desc, u_desc, &
        CUFFT_INVERSE), 'inverse fft failed')

    ! These are equivalent, and work as well
    ! istat = cufftXtMemcpy(planc2r, u, u_desc, CUFFT_COPY_DEVICE_TO_HOST)
    ! call cufft_memcpyD2H(u, u_desc, CUFFT_XT_FORMAT_INPLACE, .false.)
    call cufft_memcpyD2H(u, u_desc, CUFFT_XT_FORMAT_INPLACE, .true.)

    call checkCufft(cufftXtFree(u_desc))
    call checkCufft(cufftDestroy(planr2c))
    call checkCufft(cufftDestroy(planc2r))

    call checkNormDiff(nz, local_rshape(1), local_rshape(2), &
        local_rshape(3), u, ref, max_norm, max_diff)
    write(*,'(A18,I1,A14,F25.8,A14,F15.8)') "after C2R ", rank, &
        " max_norm is ", max_norm, " max_diff is ", max_diff
    write(*,'(A25,I1,A14,F25.8)') "Relative Linf on rank ", rank, &
        " is ", max_diff/max_norm
    deallocate(u)
    deallocate(ref)
    deallocate(u_permuted)

    call mpi_finalize(ierr)

    if(max_diff / max_norm > 1e-5) then
        print*, ">>>> FAILED on rank ", rank
        stop 1
    else
        print*, ">>>> PASSED on rank ", rank
    end if

contains
#ifdef _CUDA
    subroutine checkCuda(istat, message)
        implicit none
        integer, intent(in)                   :: istat
        character(len=*),intent(in), optional :: message
        if (istat /= cudaSuccess) then
            write(*,"('Error code: ',I0, ': ')") istat
            write(*,*) cudaGetErrorString(istat)
            if(present(message)) write(*,*) message
            call mpi_finalize(ierr)
        endif
    end subroutine checkCuda
#endif

    subroutine checkCufft(istat, message)
        implicit none
        integer, intent(in)                   :: istat
        character(len=*),intent(in), optional :: message
        if (istat /= CUFFT_SUCCESS) then
            write(*,"('Error code: ',I0, ': ')") istat
!@cuf       write(*,*) cudaGetErrorString(istat)
            if(present(message)) write(*,*) message
            call mpi_finalize(ierr)
        endif
    end subroutine checkCufft

    subroutine generate_random(nz1, nz, ny, nx, data)
        implicit none
        integer, intent(in) :: nx, ny, nz, nz1
        real, dimension(nz, ny, nx), intent(out) :: data
        real :: rand(1)
        integer :: i,j,k
        !call random_seed(put=(/seed, seed+1/))
        do k =1, nx
            do j = 1, ny
                do i = 1, nz1
                    call random_number(rand)
                    data(i,j,k) = rand(1)
                end do
            end do
        end do

    end subroutine generate_random

    subroutine checkNorm(nz1, nz, ny, nx, data, max_norm)
        implicit none
        integer, intent(in)  :: nx, ny, nz, nz1
        real, dimension(nz, ny, nx), intent(in) :: data
        real :: max_norm
        integer :: i, j, k
        max_norm = 0
        do k =1, nx
            do j = 1, ny
                do i = 1, nz1
                    max_norm = max(max_norm, abs(data(i,j,k)))
                end do
            end do
        end do
    end subroutine checkNorm

    subroutine checkNormComplex(nz, ny, nx, data, max_norm)
        implicit none
        integer, intent(in)  :: nx, ny, nz
        complex, dimension(nz, ny, nx), intent(in) :: data
        real :: max_norm, max_diff
        integer :: i,j,k
        max_norm = 0
        do k =1, nx
            do j = 1, ny
                do i = 1, nz
                    max_norm = max(max_norm, abs(data(i,j,k)%re))
                    max_norm = max(max_norm, abs(data(i,j,k)%im))
                end do
            end do
        end do
    end subroutine checkNormComplex

    subroutine checkNormDiff(nz1, nz, ny, nx, data, ref, max_norm, max_diff)
        implicit none
        integer, intent(in)  :: nx, ny, nz, nz1
        real, dimension(nz, ny, nx), intent(in) :: data, ref
        real :: max_norm, max_diff
        max_norm = 0
        max_diff = 0
        do k =1, nx
          do j = 1, ny
            do i = 1, nz1
              max_norm = max(max_norm, abs(data(i,j,k)))
              max_diff = max(max_diff, abs(ref(i,j,k)-data(i,j,k)))
              if (abs(ref(i,j,k)-data(i,j,k)) > 0.0001) then
                write(*,'(A9,I3,I3,I3,A2,F18.8,A7,F18.8,A9,I2)') "diff ref[", &
                  i,j,k,"]",ref(i,j,k),"data ",data(i,j,k)," at rank",rank
              end if
            end do
          end do
        end do
    end subroutine checkNormDiff

#ifdef _OPENACC
    subroutine scalingData(nz, ny, nx, data, factor)
        implicit none
        integer, intent(in)  :: nx, ny, nz
        complex, dimension(nz, ny, nz) :: data
        !$acc declare deviceptr(data)
        real, intent(in)     :: factor

    !$acc parallel loop collapse(3)
        do k =1, nx
            do j = 1, ny
                do i = 1, nz
                    data(i, j, k) = data(i, j, k) / factor
                end do
            end do
        end do

    end subroutine scalingData
#endif

subroutine cufft_memcpyH2D(ulibxt, u_h, data_format, ismemcpy)
    implicit none
    type(cudaLibXtDesc), pointer, intent(out) :: ulibxt
    real, dimension(*), intent(in)          :: u_h
    integer, intent(in)                         :: data_format
    logical, intent(in)                         :: ismemcpy
    type(cudaXtDesc), pointer  :: uxt
!@cuf real, dimension(:,:,:), device, pointer :: u_d

    if (ismemcpy == .false.) then
        call checkCufft(cufftXtMemcpy(planc2r, ulibxt, u_h, &
                 CUFFT_COPY_HOST_TO_DEVICE), "cufft_memcpyHToD Error")
    else
        call c_f_pointer(ulibxt%descriptor, uxt)
        if(data_format == CUFFT_XT_FORMAT_INPLACE_SHUFFLED) then
#ifdef _OPENACC
            call acc_memcpy_to_device(uxt%data(1), u_h, &
                     product(int(local_rshape_permuted,kind=8))*4_8) ! bytes
#else
            call c_f_pointer(uxt%data(1), u_d, local_rshape_permuted)
            call checkCuda(cudaMemcpy(u_d, u_h, &
                     product(int(local_rshape_permuted,kind=8))), &
                     "cudamemcpy H2D Error")
#endif
        else if (data_format == CUFFT_XT_FORMAT_INPLACE) then
#ifdef _OPENACC
            call acc_memcpy_to_device(uxt%data(1), u_h, &
                     product(int(local_rshape,kind=8))*4_8) ! bytes
#else
            call c_f_pointer(uxt%data(1), u_d, local_rshape)
            call checkCuda(cudaMemcpy(u_d, u_h, &
                     product(int(local_rshape,kind=8))), &
                     "cudamemcpy H2D Error")
#endif
        endif
    endif
end subroutine cufft_memcpyH2D


subroutine cufft_memcpyD2H(u_h, ulibxt, data_format,ismemcpy)
    implicit none
    type(cudaLibXtDesc), pointer, intent(in) :: ulibxt
    real, dimension(*), intent(out)      :: u_h
    integer, intent(in)                      :: data_format
    logical, intent(in)                      :: ismemcpy
    type(cudaXtDesc), pointer  :: uxt
!@cuf real, dimension(:,:,:), device, pointer :: u_d

    if (ismemcpy == .false.) then
        call checkCufft(cufftXtMemcpy(planr2c, u_h, ulibxt, &
                 CUFFT_COPY_DEVICE_TO_HOST), "cufft_memcpyDToH Error")
    else
        call c_f_pointer(ulibxt%descriptor, uxt)
        if(data_format == CUFFT_XT_FORMAT_INPLACE_SHUFFLED) then
#ifdef _OPENACC
            call acc_memcpy_from_device(u_h, uxt%data(1), &
                     product(int(local_rshape_permuted,kind=8))*4_8) ! bytes
#else
            call c_f_pointer(uxt%data(1), u_d, local_rshape_permuted)
            call checkCuda(cudaMemcpy(u_h, u_d, &
                     product(int(local_rshape_permuted,kind=8))), &
                     "cudamemcpy D2H Error")
#endif
        else if (data_format == CUFFT_XT_FORMAT_INPLACE) then
#ifdef _OPENACC
            call acc_memcpy_from_device(u_h, uxt%data(1), &
                     product(int(local_rshape,kind=8))*4_8) ! bytes
#else
            call c_f_pointer(uxt%data(1), u_d, local_rshape)
            call checkCufft(cudamemcpy(u_h, u_d, &
                     product(int(local_rshape,kind=8))), &
                     "cufft_memcpyD2H error")
#endif
        endif
    endif
end subroutine cufft_memcpyD2H


end program cufftmp_r2c

12.7. 从 OpenACC 主机代码使用 cuRAND

此示例演示了 curand 模块、curandHandle 类型和多种形式的 rand 调用的使用。

简单的 cuRAND 测试

program testcurand
! compile with the flags -ta=tesla -cuda -cudalib=curand
call cur1(1000, .true.); call cur1(1000, .false.)
call cur2(1000, .true.); call cur2(1000, .false.)
call cur3(1000, .true.); call cur3(1000, .false.)
end
!
subroutine cur1(n, onhost)
use curand
integer :: a(n)
type(curandGenerator) :: g
integer(8) nbits
logical onhost, passing
a = 0
passing = .true.
if (onhost) then
  istat = curandCreateGeneratorHost(g,CURAND_RNG_PSEUDO_XORWOW)
  istat = curandGenerate(g, a, n)
  istat = curandDestroyGenerator(g)
else
  !$acc data copy(a)
  istat = curandCreateGenerator(g,CURAND_RNG_PSEUDO_XORWOW)
  !$acc host_data use_device(a)
  istat = curandGenerate(g, a, n)
  !$acc end host_data
  istat = curandDestroyGenerator(g)
  !$acc end data
endif
nbits = 0
do i = 1, n
  if (i.lt.10) print *,i,a(i)
  nbits = nbits + popcnt(a(i))
end do
print *,"Should be roughly half the bits set"
nbits = nbits / n
if ((nbits .lt. 12) .or. (nbits .gt. 20)) then
  passing = .false.
else
  print *,"nbits is ",nbits," which passes"
endif
if (passing) then
  print *,"Test PASSED"
else
  print *,"Test FAILED"
endif
end
!
subroutine cur2(n, onhost)
use curand
real :: a(n)
type(curandGenerator) :: g
logical onhost, passing
a = 0.0
passing = .true.
if (onhost) then
  istat = curandCreateGeneratorHost(g,CURAND_RNG_PSEUDO_XORWOW)
  istat = curandGenerate(g, a, n)
  istat = curandDestroyGenerator(g)
else
  !$acc data copy(a)
  istat = curandCreateGenerator(g,CURAND_RNG_PSEUDO_XORWOW)
  !$acc host_data use_device(a)
  istat = curandGenerate(g, a, n)
  !$acc end host_data
  istat = curandDestroyGenerator(g)
  !$acc end data
endif
print *,"Should be uniform around 0.5"
do i = 1, n
  if (i.lt.10) print *,i,a(i)
  if ((a(i).lt.0.0) .or. (a(i).gt.1.0)) passing = .false.
end do
rmean = sum(a)/n
if ((rmean .lt. 0.4) .or. (rmean .gt. 0.6)) then
  passing = .false.
else
  print *,"Mean is ",rmean," which passes"
endif
if (passing) then
  print *,"Test PASSED"
else
  print *,"Test FAILED"
endif
end
!
subroutine cur3(n, onhost)
use curand
real(8) :: a(n)
type(curandGenerator) :: g
logical onhost, passing
a = 0.0d0
passing = .true.
if (onhost) then
  istat = curandCreateGeneratorHost(g,CURAND_RNG_PSEUDO_XORWOW)
  istat = curandGenerate(g, a, n)
  istat = curandDestroyGenerator(g)
else
  !$acc data copy(a)
  istat = curandCreateGenerator(g,CURAND_RNG_PSEUDO_XORWOW)
  !$acc host_data use_device(a)
  istat = curandGenerate(g, a, n)
  !$acc end host_data
  istat = curandDestroyGenerator(g)
  !$acc end data
endif
do i = 1, n
  if (i.lt.10) print *,i,a(i)
  if ((a(i).lt.0.0d0) .or. (a(i).gt.1.0d0)) passing = .false.
end do
rmean = sum(a)/n
if ((rmean .lt. 0.4d0) .or. (rmean .gt. 0.6d0)) then
  passing = .false.
else
  print *,"Mean is ",rmean," which passes"
endif
if (passing) then
  print *,"Test PASSED"
else
  print *,"Test FAILED"
endif
end

12.8. 从 OpenACC 设备代码使用 cuRAND

此示例演示了如何从 CUDA Fortran 全局子例程中使用 curand_device 模块。

从 OpenACC 设备代码进行的简单 cuRAND 测试

module mtests
  integer, parameter :: n = 1000
  contains
    subroutine testrand( a, b )
    use openacc_curand
    real :: a(n), b(n)
    type(curandStateXORWOW) :: h
    integer(8) :: seed, seq, offset

    !$acc parallel num_gangs(1) vector_length(1) copy(a,b) private(h)
    seed = 12345
    seq = 0
    offset = 0
    call curand_init(seed, seq, offset, h)
    !$acc loop seq
    do i = 1, n
      a(i) = curand_uniform(h)
      b(i) = curand_normal(h)
    end do
    !$acc end parallel
    return
    end subroutine
end module mtests

program t
use mtests
real :: a(n), b(n), c(n)
logical passing
a = 1.0
b = 2.0
passing = .true.
call testrand(a,b)
c = a
print *,"Should be uniform around 0.5"
do i = 1, n
  if (i.lt.10) print *,i,c(i)
  if ((c(i).lt.0.0) .or. (c(i).gt.1.0)) passing = .false.
end do
rmean = sum(c)/n
if ((rmean .lt. 0.4) .or. (rmean .gt. 0.6)) then
  passing = .false.
else
  print *,"Mean is ",rmean," which passes"
endif
c = b
print *,"Should be normal around 0.0"
nc1 = 0;
nc2 = 0;
do i = 1, n
  if (i.lt.10) print *,i,c(i)
  if ((c(i) .gt. -4.0) .and. (c(i) .lt. 0.0)) nc1 = nc1 + 1
  if ((c(i) .gt.  0.0) .and. (c(i) .lt. 4.0)) nc2 = nc2 + 1
end do
print *,"Found on each side of zero ",nc1,nc2
if (abs(nc1-nc2) .gt. (n/10)) npassing = .false.
rmean = sum(c,mask=abs(c).lt.4.0)/n
if ((rmean .lt. -0.1) .or. (rmean .gt. 0.1)) then
  passing = .false.
else
  print *,"Mean is ",rmean," which passes"
endif

if (passing) then
  print *,"Test PASSED"
else
  print *,"Test FAILED"
endif
end program

12.9. 从 CUDA Fortran 主机代码使用 cuRAND

此示例演示了 curand 模块、curandHandle 类型和多种形式的 rand 调用的使用。

简单的 cuRAND 测试

program testcurand1
call testr1(1000)
call testr2(1000)
call testr3(1000)
end
!
subroutine testr1(n)
use cudafor
use curand
integer, managed :: a(n)
type(curandGenerator) :: g
integer(8) nbits
logical passing
a = 0
passing = .true.
istat = curandCreateGenerator(g,CURAND_RNG_PSEUDO_XORWOW)
istat = curandGenerate(g, a, n)
istat = cudaDeviceSynchronize()
istat = curandDestroyGenerator(g)
nbits = 0
do i = 1, n
  if (i.lt.10) print *,i,a(i)
  nbits = nbits + popcnt(a(i))
end do
print *,"Should be roughly half the bits set"
nbits = nbits / n
if ((nbits .lt. 12) .or. (nbits .gt. 20)) then
  passing = .false.
else
  print *,"nbits is ",nbits," which passes"
endif
if (passing) then
  print *,"Test PASSED"
else
  print *,"Test FAILED"
endif
end
!
subroutine testr2(n)
use cudafor
use curand
real, managed :: a(n)
type(curandGenerator) :: g
logical passing
a = 0.0
passing = .true.
istat = curandCreateGenerator(g,CURAND_RNG_PSEUDO_XORWOW)
istat = curandGenerate(g, a, n)
istat = cudaDeviceSynchronize()
istat = curandDestroyGenerator(g)
print *,"Should be uniform around 0.5"
do i = 1, n
  if (i.lt.10) print *,i,a(i)
  if ((a(i).lt.0.0) .or. (a(i).gt.1.0)) passing = .false.
end do
rmean = sum(a)/n
if ((rmean .lt. 0.4) .or. (rmean .gt. 0.6)) then
  passing = .false.
else
  print *,"Mean is ",rmean," which passes"
endif
if (passing) then
  print *,"Test PASSED"
else
  print *,"Test FAILED"
endif
end
!
subroutine testr3(n)
use cudafor
use curand
real(8), managed :: a(n)
type(curandGenerator) :: g
logical passing
a = 0.0d0
passing = .true.
istat = curandCreateGenerator(g,CURAND_RNG_PSEUDO_XORWOW)
istat = curandGenerate(g, a, n)
istat = cudaDeviceSynchronize()
istat = curandDestroyGenerator(g)
do i = 1, n
  if (i.lt.10) print *,i,a(i)
  if ((a(i).lt.0.0d0) .or. (a(i).gt.1.0d0)) passing = .false.
end do
rmean = sum(a)/n
if ((rmean .lt. 0.4d0) .or. (rmean .gt. 0.6d0)) then
  passing = .false.
else
  print *,"Mean is ",rmean," which passes"
endif
if (passing) then
  print *,"Test PASSED"
else
  print *,"Test FAILED"
endif
end
end program

12.10. 从 CUDA Fortran 设备代码使用 cuRAND

此示例演示了如何从 CUDA Fortran 全局子例程中使用 curand_device 模块。

从设备代码进行的简单 cuRAND 测试

module mtests
  use curand_device
  integer, parameter :: n = 10000
  contains
    attributes(global) subroutine testr( a, b )
    real, device :: a(n), b(n)
    type(curandStateXORWOW) :: h
    integer(8) :: seed, seq, offset
    integer :: iam
    iam = threadIdx%x
    seed = iam*64 + 12345
    seq = 0
    offset = 0
    call curand_init(seed, seq, offset, h)
    do i = iam, n, blockdim%x
      a(i) = curand_uniform(h)
      b(i) = curand_normal(h)
    end do
    return
    end subroutine
end module mtests

program t
use mtests
real, allocatable, device :: a(:), b(:)
real c(n), rmean
logical passing
allocate(a(n))
allocate(b(n))
a = 0.0
b = 0.0
passing = .true.
call testr<<<1,32>>> (a,b)
c = a
print *,"Should be uniform around 0.5"
do i = 1, n
  if (i.lt.10) print *,i,c(i)
  if ((c(i).lt.0.0) .or. (c(i).gt.1.0)) passing = .false.
end do
rmean = sum(c)/n
if ((rmean .lt. 0.4) .or. (rmean .gt. 0.6)) then
  passing = .false.
else
  print *,"Mean is ",rmean," which passes"
endif

c = b
print *,"Should be normal around 0.0"
nc1 = 0;
nc2 = 0;
do i = 1, n
  if (i.lt.10) print *,i,c(i)
  if ((c(i) .gt. -4.0) .and. (c(i) .lt. 0.0)) nc1 = nc1 + 1
  if ((c(i) .gt.  0.0) .and. (c(i) .lt. 4.0)) nc2 = nc2 + 1
end do
print *,"Found on each side of zero ",nc1,nc2
if (abs(nc1-nc2) .gt. (n/10)) npassing = .false.
rmean = sum(c,mask=abs(c).lt.4.0)/n
if ((rmean .lt. -0.1) .or. (rmean .gt. 0.1)) then
  passing = .false.
else
  print *,"Mean is ",rmean," which passes"
endif

if (passing) then
  print *,"Test PASSED"
else
  print *,"Test FAILED"
endif
end
end program

12.11. 从 OpenACC 主机代码使用 cuSPARSE

此示例演示了 cuSPARSE 模块、cusparseHandle 类型和对 cuSPARSE 库的多个调用的使用。

简单的 BLAS 测试

program sparseMatVec
    integer n
    n = 25 ! # rows/cols in dense matrix
    call sparseMatVecSub1(n)
    n = 45 ! # rows/cols in dense matrix
    call sparseMatVecSub1(n)
end program

subroutine sparseMatVecSub1(n)
  use openacc
  use cusparse

  implicit none

  integer n

  ! dense data
  real(4), allocatable :: Ade(:,:), x(:), y(:)

  ! sparse CSR arrays
  real(4), allocatable :: csrValA(:)
  integer, allocatable :: nnzPerRowA(:), csrRowPtrA(:), csrColIndA(:)

  allocate(Ade(n,n), x(n), y(n))
  allocate(csrValA(n))
  allocate(nnzPerRowA(n), csrRowPtrA(n+1), csrColIndA(n))

  call sparseMatVecSub2(Ade, x, y, csrValA, nnzPerRowA, csrRowPtrA, &
                                                         csrColIndA, n)
  deallocate(Ade)
  deallocate(x)
  deallocate(y)
  deallocate(csrValA)
  deallocate(nnzPerRowA)
  deallocate(csrRowPtrA)
  deallocate(csrColIndA)
end subroutine

subroutine sparseMatVecSub2(Ade, x, y, csrValA, nnzPerRowA, csrRowPtrA, &
                                                             csrColIndA, n)
  use openacc
  use cusparse

  implicit none

  ! dense data
  real(4) :: Ade(n,n), x(n), y(n)

  ! sparse CSR arrays
  real(4) :: csrValA(n)
  integer :: nnzPerRowA(n), csrRowPtrA(n+1), csrColIndA(n)

  integer :: n, nnz, status, i
  type(cusparseHandle) :: h
  type(cusparseMatDescr) :: descrA

  ! parameters
  real(4) :: alpha, beta

  ! result
  real(4) :: xerr

  ! initalize CUSPARSE and matrix descriptor
  status = cusparseCreate(h)
  if (status /= CUSPARSE_STATUS_SUCCESS) &
       write(*,*) 'cusparseCreate error: ', status
  status = cusparseCreateMatDescr(descrA)
  status = cusparseSetMatType(descrA, &
       CUSPARSE_MATRIX_TYPE_GENERAL)
  status = cusparseSetMatIndexBase(descrA, &
       CUSPARSE_INDEX_BASE_ONE)
  status = cusparseSetStream(h, acc_get_cuda_stream(acc_async_sync))

  !$acc data create(Ade, x, y, csrValA, nnzPerRowA, csrRowPtrA, csrColIndA)

  ! Initialize matrix (upper circular shift matrix)
  !$acc kernels
  Ade = 0.0
  do i = 1, n-1
     Ade(i,i+1) = 1.0
  end do
  Ade(n,1) = 1.0

  ! Initialize vectors and constants
  do i = 1, n
     x(i) = i
  enddo
  y = 0.0
  !$acc end kernels

  !$acc update host(x)
  write(*,*) 'Original vector:'
  write(*,'(5(1x,f7.2))') x

  ! convert matrix from dense to csr format
  !$acc host_data use_device(Ade, nnzPerRowA, csrValA, csrRowPtrA, csrColIndA)
  status = cusparseSnnz_v2(h, CUSPARSE_DIRECTION_ROW, &
       n, n, descrA, Ade, n, nnzPerRowA, nnz)
  status = cusparseSdense2csr(h, n, n, descrA, Ade, n, &
       nnzPerRowA, csrValA, csrRowPtrA, csrColIndA)
  !$acc end host_data

  ! A is upper circular shift matrix
  ! y = alpha*A*x + beta*y
  alpha = 1.0
  beta = 0.0
  !$acc host_data use_device(csrValA, csrRowPtrA, csrColIndA, x, y)
  status = cusparseScsrmv(h, CUSPARSE_OPERATION_NON_TRANSPOSE, &
       n, n, n, alpha, descrA, csrValA, csrRowPtrA, &
       csrColIndA, x, beta, y)
  !$acc end host_data

  !$acc wait
  write(*,*) 'Shifted vector:'
  write(*,'(5(1x,f7.2))') y

  ! shift-down y and add original x
  ! A' is lower circular shift matrix
  ! x = alpha*A'*y + beta*x
  beta = -1.0
  !$acc host_data use_device(csrValA, csrRowPtrA, csrColIndA, x, y)
  status = cusparseScsrmv(h, CUSPARSE_OPERATION_TRANSPOSE, &
       n, n, n, alpha, descrA, csrValA, csrRowPtrA, &
       csrColIndA, y, beta, x)
  !$acc end host_data

  !$acc kernels
  xerr = maxval(abs(x))
  !$acc end kernels
  !$acc end data

  write(*,*) 'Max error = ', xerr
  if (xerr.le.1.e-5) then
    write(*,*) 'Test PASSED'
  else
    write(*,*) 'Test FAILED'
  endif

end subroutine

12.12. 从 CUDA Fortran 主机代码使用 cuSPARSE

此示例演示了 cuSPARSE 模块、cusparseHandle 类型和多种形式的 cusparse 调用的使用。

简单的 BLAS 测试

program sparseMatVec
  use cudafor
  use cusparse

  implicit none

  integer, parameter :: n = 25 ! # rows/cols in dense matrix

  type(cusparseHandle) :: h
  type(cusparseMatDescr) :: descrA

  ! dense data
  real(4), managed :: Ade(n,n), x(n), y(n)

  ! sparse CSR arrays
  real(4), managed :: csrValA(n)
  integer, managed :: nnzPerRowA(n), &
       csrRowPtrA(n+1), csrColIndA(n)
  integer :: nnz, status, i

  ! parameters
  real(4) :: alpha, beta

  ! initalize CUSPARSE and matrix descriptor
  status = cusparseCreate(h)
  if (status /= CUSPARSE_STATUS_SUCCESS) &
       write(*,*) 'cusparseCreate error: ', status
  status = cusparseCreateMatDescr(descrA)
  status = cusparseSetMatType(descrA, &
       CUSPARSE_MATRIX_TYPE_GENERAL)
  status = cusparseSetMatIndexBase(descrA, &
       CUSPARSE_INDEX_BASE_ONE)

  ! Initialize matrix (upper circular shift matrix)
  Ade = 0.0
  do i = 1, n-1
     Ade(i,i+1) = 1.0
  end do
  Ade(n,1) = 1.0

  ! Initialize vectors and constants
  x = [(i,i=1,n)]
  y = 0.0

  write(*,*) 'Original vector:'
  write(*,'(5(1x,f7.2))') x

  ! convert matrix from dense to csr format
  status = cusparseSnnz_v2(h, CUSPARSE_DIRECTION_ROW, &
       n, n, descrA, Ade, n, nnzPerRowA, nnz)
  status = cusparseSdense2csr(h, n, n, descrA, Ade, n, &
       nnzPerRowA, csrValA, csrRowPtrA, csrColIndA)

  ! A is upper circular shift matrix
  ! y = alpha*A*x + beta*y
  alpha = 1.0
  beta = 0.0
  status = cusparseScsrmv(h, CUSPARSE_OPERATION_NON_TRANSPOSE, &
       n, n, n, alpha, descrA, csrValA, csrRowPtrA, &
       csrColIndA, x, beta, y)

  ! shift-down y and add original x
  ! A' is lower circular shift matrix
  ! x = alpha*A'*y + beta*x
  beta = -1.0
  status = cusparseScsrmv(h, CUSPARSE_OPERATION_TRANSPOSE, &
       n, n, n, alpha, descrA, csrValA, csrRowPtrA, &
       csrColIndA, y, beta, x)

  status = cudaDeviceSynchronize()

  write(*,*) 'Shifted vector:'
  write(*,'(5(1x,f7.2))') y

  write(*,*) 'Max error = ', maxval(abs(x))

  if (maxval(abs(x)).le.1.e-5) then
    write(*,*) 'Test PASSED'
  else
    write(*,*) 'Test FAILED'
  endif

end program sparseMatVec

12.13. 从 CUDA Fortran 主机代码使用 cuTENSOR

此示例演示了如何从 CUDA Fortran 使用低级 cuTENSOR 模块（版本 2）来执行重塑置换和跨一个维度的求和归约。

通过将 “-cudalib=cutensor” 选项添加到链接行，可以将此示例编译并链接为普通的 CUDA Fortran 子程序。

来自 CUDA Fortran 的简单 cuTENSOR 测试

program testcutensorcuf1
use cudafor
use cutensor

integer, parameter :: ndim = 3
real, managed, allocatable :: dA(:,:,:), dC(:,:)
real, allocatable :: hA(:,:,:), hC(:,:)
real, device, allocatable :: workbuf(:)
real :: alpha, beta
integer(4) :: numModesA, numModesC
integer(8), dimension(ndim) :: extA, strA, extC, strC
integer(4), dimension(ndim) :: modeA, modeC
integer(8) :: workbufsize

type(cutensorStatus) :: cstat
type(cutensorHandle) :: handle
type(cutensorTensorDescriptor) :: descA, descC
type(cutensorOperationDescriptor) :: rdesc
type(cutensorComputeDescriptor) :: descCompute
type(cutensorPlan) :: plan
type(cutensorAlgo) :: algo
type(cutensorPlanPreference) :: pref

! Init
cstat = cutensorCreate(handle)
if (cstat.ne.CUTENSOR_STATUS_SUCCESS) print *,cutensorGetErrorString(cstat)

descCompute = CUTENSOR_COMPUTE_DESC_32F

allocate(dA(100,60,80))
! This is the operation we are going to perform
! dC = sum(reshape(dA,shape=[80,60,100],order=[3,2,1]),dim=2)
!
call random_number(dA); dA = real(int(dA * 10.0))
extA = shape(dA)
strA(1) =  1; strA(2) = 100; strA(3) = 6000
modeA(1) = 3; modeA(2) = 2; modeA(3) = 1
numModesA = ndim
ialign = 256

print *,"Desc A"
cstat = cutensorCreateTensorDescriptor(handle, descA, numModesA, extA, strA, &
              CUTENSOR_R_32F, ialign)
if (cstat.ne.CUTENSOR_STATUS_SUCCESS) print *,cutensorGetErrorString(cstat)

allocate(dC(80,100))
extC(1:ndim-1) = shape(dC)
strC(1) = 1; strC(2) = 80
numModesC = ndim-1
dC = 0.0
modeC(1) = 1; modeC(2) = 3  ! Skip mode 2 for reduction across that dim

print *,"Desc C"
cstat = cutensorCreateTensorDescriptor(handle, descC, numModesC, extC, strC, &
              CUTENSOR_R_32F, ialign)
if (cstat.ne.CUTENSOR_STATUS_SUCCESS) print *,cutensorGetErrorString(cstat)

print *,"CreateRed "
cstat = cutensorCreateReduction(handle, rdesc, &
              descA, modeA, CUTENSOR_OP_IDENTITY, &
              descC, modeC, CUTENSOR_OP_IDENTITY, &
              descC, modeC, CUTENSOR_OP_ADD, descCompute)
if (cstat.ne.CUTENSOR_STATUS_SUCCESS) print *,cutensorGetErrorString(cstat)

print *,"CreatePlanPref "
cstat = cutensorCreatePlanPreference(handle, pref, CUTENSOR_ALGO_DEFAULT, &
              CUTENSOR_JIT_MODE_NONE)
if (cstat.ne.CUTENSOR_STATUS_SUCCESS) print *,cutensorGetErrorString(cstat)

print *,"EstimateWork "
cstat = cutensorEstimateWorkspaceSize(handle, rdesc, pref, &
              CUTENSOR_WORKSPACE_DEFAULT, workbufsize)
if (cstat.ne.CUTENSOR_STATUS_SUCCESS) print *,cutensorGetErrorString(cstat)

print *,"Estimated workspace size: ",workbufsize

print *,"CreatePlan "
cstat = cutensorCreatePlan(handle, plan, rdesc, pref, workbufsize)
if (cstat.ne.CUTENSOR_STATUS_SUCCESS) print *,cutensorGetErrorString(cstat)

allocate(workbuf((workbufsize+3)/4))

alpha = 1.0; beta = 0.0
print *,"Reduce "
cstat = cutensorReduce(handle, plan, alpha, dA, beta, dC, &
              dC, workbuf, workbufsize, 0)
if (cstat.ne.CUTENSOR_STATUS_SUCCESS) print *,cutensorGetErrorString(cstat)

hA = dA
hC = sum(reshape(hA,[80,60,100],order=[3,2,1]), dim=2)
istat = cudaDeviceSynchronize()  ! Managed memory, to be sure

if (all(hC.eq.dC)) then
  print *,"test PASSED"
else
  print *,"test FAILED"
end if

cstat = cutensorDestroy(handle)
if (cstat.ne.CUTENSOR_STATUS_SUCCESS) print *,cutensorGetErrorString(cstat)
cstat = cutensorDestroyPlan(plan)
if (cstat.ne.CUTENSOR_STATUS_SUCCESS) print *,cutensorGetErrorString(cstat)
cstat = cutensorDestroyPlanPreference(pref)
if (cstat.ne.CUTENSOR_STATUS_SUCCESS) print *,cutensorGetErrorString(cstat)
cstat = cutensorDestroyOperationDescriptor(rdesc)
if (cstat.ne.CUTENSOR_STATUS_SUCCESS) print *,cutensorGetErrorString(cstat)
cstat = cutensorDestroyTensorDescriptor(descA)
if (cstat.ne.CUTENSOR_STATUS_SUCCESS) print *,cutensorGetErrorString(cstat)
cstat = cutensorDestroyTensorDescriptor(descC)
if (cstat.ne.CUTENSOR_STATUS_SUCCESS) print *,cutensorGetErrorString(cstat)

deallocate(workbuf)
deallocate(dA, dC)
deallocate(hA, hC)

end program

12.14. 从 CUDA Fortran 主机代码使用 cuTENSOREX

此示例演示了如何从 CUDA Fortran 使用更高级别的 cuTENSOREX 模块，以使用多个 OpenMP 线程执行大型矩阵乘法。

通过将 “-mp -cudalib=cutensor” 选项添加到编译和链接行，可以将此示例编译并链接为普通的 CUDA Fortran 子程序。

来自 CUDA Fortran 的多线程 cuTENSOREX 示例

! Test cuTensor + cuda Fortran + OMP multi-stream matmul
program testCuCufMsMatmul
use cudafor
use cutensorex

integer, parameter :: m=8192, k=1280, n=1024
integer, parameter :: mblksize = 128
integer, parameter :: mslices = m / mblksize
integer, parameter :: nstreams = 4
integer, parameter :: numtimes = mslices / nstreams

real(8), allocatable, dimension(:,:), device :: a_d, d_d
real(8), allocatable, dimension(:,:,:), pinned :: ha
real(8), dimension(k,n), device :: b_d
real(8), allocatable, dimension(:,:), pinned :: d
real(8) :: alpha
integer(kind=cuda_stream_kind) :: mystream
!$OMP THREADPRIVATE(a_d, d_d, mystream)

allocate( ha(k,mblksize,nstreams))
allocate(  d(1:m,1:n))

b_d   = 1.0d0
alpha = 1.0d0

!$OMP PARALLEL NUM_THREADS(nstreams) PRIVATE(istat)
istat = cudaStreamCreate(mystream)
istat = cudaforSetDefaultStream(mystream)
istat = cutensorExSetStream(mystream)
! At this point, all new allocations will pick up default stream
allocate(a_d(k,mblksize))
allocate(d_d(mblksize,n))
!$OMP END PARALLEL

! Test matmul
!$OMP PARALLEL DO NUM_THREADS(nstreams) PRIVATE(jlcl,jgbl,jend)
do ns = 1, nstreams
    do nt = 1, numtimes
        jgbl = 1 + ((ns-1) + (nt-1)*nstreams)*mblksize
        jend = jgbl + mblksize - 1
        ! Do some host work
        do jlcl = 1, mblksize
            ha(:,jlcl,ns) = dble(jlcl+jgbl-1)
        end do
        ! Move data to the device on default stream
        a_d = ha(:,:,ns)
        ! Matrix multiply on my thread cutensorEx stream
        d_d = alpha * matmul(transpose(a_d),b_d)
        ! Move result back to host on default stream
        d(jgbl:jend,:) = d_d
    end do
end do
! Wait for all threads to finish GPU work
istat = cudaDeviceSynchronize()
nfailed = 0
do j = 1, n
    do i = 1, m
        if (d(i,j) .ne. i*k) then
            if (nfailed .lt. 100) print *,i,j,d(i,j)
            nfailed = nfailed + 1
        end if
    end do
end do
if (nfailed .eq. 0) then
    print *,"test PASSED"
else
    print *,"test FAILED"
endif
end program

12.15. 从 OpenACC 主机代码使用 cuTENSOR

此示例演示了 cuTENSOREX 模块的使用，使用 OpenACC 设备数据调用 Matmul()，以及将 cuTENSOR 库流设置为与 OpenACC 默认流一致。

此示例可以使用或不使用 OpenACC 进行编译和运行。要使用 OpenACC 进行编译，选项为 “-ta=tesla -cuda -cudalib=cutensor”。要在 CPU 上运行，请省略这些选项。

来自 OpenACC 的简单 cuTENSOREX 测试

program testcutensorOpenACC
!@acc use openacc
!@acc use cutensorex
integer, parameter :: ni=1280, nj=1024, nk=960, ntimes=1
real(8) :: a(ni,nk), b(nk,nj), c(ni,nj), d(ni,nj)

call random_number(a)
call random_number(b)
a = dble(int(4.0d0*a - 2.0d0))
b = dble(int(8.0d0*b - 4.0d0))
c = 2.0; d = 0.0

!$acc enter data copyin(a,b,c) create(d)
!@acc istat = cutensorExSetStream(acc_get_cuda_stream(acc_async_sync))
!$acc host_data use_device(a,b,c,d)
do nt = 1, ntimes
  d = c + matmul(a,b)
end do
!$acc end host_data

!$acc update host(d)
print *,sum(d)

do nt = 1, ntimes
!$acc kernels
  do j = 1, nj
    do i = 1, ni
      d(i,j) = c(i,j)
      do k = 1, nk
        d(i,j) = d(i,j) + a(i,k) * b(k,j)
      end do
    end do
  end do
!$acc end kernels
end do
!$acc exit data copyout(d)

print *,sum(d)
end program

通知

注意事项

所有 NVIDIA 设计规范、参考板、文件、图纸、诊断程序、列表和其他文档（统称为“材料”）均按“原样”提供。NVIDIA 不对这些材料做出任何明示、暗示、法定或其他方面的保证，并明确声明不承担所有关于不侵权、适销性和针对特定用途适用性的暗示保证。

提供的信息被认为是准确且可靠的。但是，NVIDIA 公司对使用此类信息造成的后果或因使用此类信息而可能导致的侵犯第三方专利或其他权利的行为不承担任何责任。NVIDIA 公司未通过暗示或其他方式授予任何专利权许可。本出版物中提及的规格如有更改，恕不另行通知。本出版物取代并替换之前提供的所有其他信息。未经 NVIDIA 公司明确书面批准，NVIDIA 公司产品不得用作生命支持设备或系统中的关键组件。

商标

NVIDIA、NVIDIA 徽标、CUDA、CUDA-X、GPUDirect、HPC SDK、NGC、NVIDIA Volta、NVIDIA DGX、NVIDIA Nsight、NVLink、NVSwitch 和 Tesla 是 NVIDIA 公司在美国和其他国家/地区的商标和/或注册商标。其他公司和产品名称可能是与其相关的各自公司的商标。